Fix PDF viewer failing on Edge (not based on Chromium)

Since version v2.4.456 the PDF.js library is published as two different
packages, a non-translated/non-polyfilled build for modern browsers and
an ES5 compatible build for older browsers.

The PDF viewer was using the build for modern browsers, so it did not
work, for example, on Edge (the original version not based on Chromium).
This has been changed to use the ES5 build instead for maximum
compatibility.

Unfortunately, the ES5 build requires allowing "unsafe-eval" in the
iframe where the PDF.js library is loaded.

Signed-off-by: Daniel Calviño Sánchez <danxuliu@gmail.com>

1 files changed, 9557 insertions, 6552 deletions

diff --git a/js/pdfjs/web/viewer.js b/js/pdfjs/web/viewer.js
index 3cf8bee..5e17fe5 100644
--- a/js/pdfjs/web/viewer.js
+++ b/js/pdfjs/web/viewer.js
@@ -114,18 +114,18 @@
 
 
 ;
-let pdfjsWebApp, pdfjsWebAppOptions;
+var pdfjsWebApp, pdfjsWebAppOptions;
 {
   pdfjsWebApp = __webpack_require__(1);
-  pdfjsWebAppOptions = __webpack_require__(3);
+  pdfjsWebAppOptions = __webpack_require__(6);
 }
 ;
 {
-  __webpack_require__(33);
+  __webpack_require__(36);
 }
 ;
 {
-  __webpack_require__(38);
+  __webpack_require__(41);
 }
 
 function getViewerConfiguration() {
@@ -252,10 +252,10 @@ function getViewerConfiguration() {
 }
 
 function webViewerLoad() {
-  const config = getViewerConfiguration();
+  var config = getViewerConfiguration();
   window.PDFViewerApplication = pdfjsWebApp.PDFViewerApplication;
   window.PDFViewerApplicationOptions = pdfjsWebAppOptions.AppOptions;
-  const event = document.createEvent("CustomEvent");
+  var event = document.createEvent("CustomEvent");
   event.initCustomEvent("webviewerloaded", true, true, {
     source: window
   });
@@ -263,7 +263,7 @@ function webViewerLoad() {
   try {
     parent.document.dispatchEvent(event);
   } catch (ex) {
-    console.error(`webviewerloaded: ${ex}`);
+    console.error("webviewerloaded: ".concat(ex));
     document.dispatchEvent(event);
   }
 
@@ -288,111 +288,156 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFPrintServiceFactory = exports.DefaultExternalServices = exports.PDFViewerApplication = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
 
-var _app_options = __webpack_require__(3);
+var _ui_utils = __webpack_require__(5);
 
-var _pdfjsLib = __webpack_require__(5);
+var _app_options = __webpack_require__(6);
 
-var _pdf_cursor_tools = __webpack_require__(6);
+var _pdfjsLib = __webpack_require__(8);
 
-var _pdf_rendering_queue = __webpack_require__(8);
+var _pdf_cursor_tools = __webpack_require__(9);
 
-var _pdf_sidebar = __webpack_require__(9);
+var _pdf_rendering_queue = __webpack_require__(11);
 
-var _overlay_manager = __webpack_require__(10);
+var _pdf_sidebar = __webpack_require__(12);
 
-var _password_prompt = __webpack_require__(11);
+var _overlay_manager = __webpack_require__(13);
 
-var _pdf_attachment_viewer = __webpack_require__(12);
+var _password_prompt = __webpack_require__(14);
 
-var _pdf_document_properties = __webpack_require__(13);
+var _pdf_attachment_viewer = __webpack_require__(15);
 
-var _pdf_find_bar = __webpack_require__(14);
+var _pdf_document_properties = __webpack_require__(16);
 
-var _pdf_find_controller = __webpack_require__(15);
+var _pdf_find_bar = __webpack_require__(17);
 
-var _pdf_history = __webpack_require__(17);
+var _pdf_find_controller = __webpack_require__(18);
 
-var _pdf_link_service = __webpack_require__(18);
+var _pdf_history = __webpack_require__(20);
 
-var _pdf_outline_viewer = __webpack_require__(19);
+var _pdf_link_service = __webpack_require__(21);
 
-var _pdf_presentation_mode = __webpack_require__(20);
+var _pdf_outline_viewer = __webpack_require__(22);
 
-var _pdf_sidebar_resizer = __webpack_require__(21);
+var _pdf_presentation_mode = __webpack_require__(23);
 
-var _pdf_thumbnail_viewer = __webpack_require__(22);
+var _pdf_sidebar_resizer = __webpack_require__(24);
 
-var _pdf_viewer = __webpack_require__(24);
+var _pdf_thumbnail_viewer = __webpack_require__(25);
 
-var _secondary_toolbar = __webpack_require__(29);
+var _pdf_viewer = __webpack_require__(27);
 
-var _toolbar = __webpack_require__(31);
+var _secondary_toolbar = __webpack_require__(32);
 
-var _view_history = __webpack_require__(32);
+var _toolbar = __webpack_require__(34);
 
-const DEFAULT_SCALE_DELTA = 1.1;
-const DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
-const FORCE_PAGES_LOADED_TIMEOUT = 10000;
-const WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
-const ENABLE_PERMISSIONS_CLASS = "enablePermissions";
-const ViewOnLoad = {
-  UNKNOWN: -1,
-  PREVIOUS: 0,
-  INITIAL: 1
-};
+var _view_history = __webpack_require__(35);
 
-class DefaultExternalServices {
-  constructor() {
-    throw new Error("Cannot initialize DefaultExternalServices.");
-  }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-  static updateFindControlState(data) {}
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-  static updateFindMatchesCount(data) {}
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-  static initPassiveLoading(callbacks) {}
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-  static fallback(data, callback) {}
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-  static reportTelemetry(data) {}
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-  static createDownloadManager(options) {
-    throw new Error("Not implemented: createDownloadManager");
-  }
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-  static createPreferences() {
-    throw new Error("Not implemented: createPreferences");
-  }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-  static createL10n(options) {
-    throw new Error("Not implemented: createL10n");
-  }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-  static get supportsIntegratedFind() {
-    return (0, _pdfjsLib.shadow)(this, "supportsIntegratedFind", false);
-  }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-  static get supportsDocumentFonts() {
-    return (0, _pdfjsLib.shadow)(this, "supportsDocumentFonts", true);
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  static get supportedMouseWheelZoomModifierKeys() {
-    return (0, _pdfjsLib.shadow)(this, "supportedMouseWheelZoomModifierKeys", {
-      ctrlKey: true,
-      metaKey: true
-    });
-  }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DEFAULT_SCALE_DELTA = 1.1;
+var DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
+var FORCE_PAGES_LOADED_TIMEOUT = 10000;
+var WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
+var ENABLE_PERMISSIONS_CLASS = "enablePermissions";
+var ViewOnLoad = {
+  UNKNOWN: -1,
+  PREVIOUS: 0,
+  INITIAL: 1
+};
+
+var DefaultExternalServices = /*#__PURE__*/function () {
+  function DefaultExternalServices() {
+    _classCallCheck(this, DefaultExternalServices);
 
-  static get isInAutomation() {
-    return (0, _pdfjsLib.shadow)(this, "isInAutomation", false);
+    throw new Error("Cannot initialize DefaultExternalServices.");
   }
 
-}
+  _createClass(DefaultExternalServices, null, [{
+    key: "updateFindControlState",
+    value: function updateFindControlState(data) {}
+  }, {
+    key: "updateFindMatchesCount",
+    value: function updateFindMatchesCount(data) {}
+  }, {
+    key: "initPassiveLoading",
+    value: function initPassiveLoading(callbacks) {}
+  }, {
+    key: "fallback",
+    value: function fallback(data, callback) {}
+  }, {
+    key: "reportTelemetry",
+    value: function reportTelemetry(data) {}
+  }, {
+    key: "createDownloadManager",
+    value: function createDownloadManager(options) {
+      throw new Error("Not implemented: createDownloadManager");
+    }
+  }, {
+    key: "createPreferences",
+    value: function createPreferences() {
+      throw new Error("Not implemented: createPreferences");
+    }
+  }, {
+    key: "createL10n",
+    value: function createL10n(options) {
+      throw new Error("Not implemented: createL10n");
+    }
+  }, {
+    key: "supportsIntegratedFind",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "supportsIntegratedFind", false);
+    }
+  }, {
+    key: "supportsDocumentFonts",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "supportsDocumentFonts", true);
+    }
+  }, {
+    key: "supportedMouseWheelZoomModifierKeys",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "supportedMouseWheelZoomModifierKeys", {
+        ctrlKey: true,
+        metaKey: true
+      });
+    }
+  }, {
+    key: "isInAutomation",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "isInAutomation", false);
+    }
+  }]);
+
+  return DefaultExternalServices;
+}();
 
 exports.DefaultExternalServices = DefaultExternalServices;
-const PDFViewerApplication = {
+var PDFViewerApplication = {
   initialBookmark: document.location.hash.substring(1),
   _initializedCapability: (0, _pdfjsLib.createPromiseCapability)(),
   fellback: false,
@@ -428,241 +473,357 @@ const PDFViewerApplication = {
   externalServices: DefaultExternalServices,
   _boundEvents: {},
   contentDispositionFilename: null,
+  initialize: function initialize(appConfig) {
+    var _this = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var appContainer;
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _this.preferences = _this.externalServices.createPreferences();
+              _this.appConfig = appConfig;
+              _context.next = 4;
+              return _this._readPreferences();
+
+            case 4:
+              _context.next = 6;
+              return _this._parseHashParameters();
+
+            case 6:
+              _context.next = 8;
+              return _this._initializeL10n();
+
+            case 8:
+              if (_this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdfjsLib.LinkTarget.NONE) {
+                _app_options.AppOptions.set("externalLinkTarget", _pdfjsLib.LinkTarget.TOP);
+              }
 
-  async initialize(appConfig) {
-    this.preferences = this.externalServices.createPreferences();
-    this.appConfig = appConfig;
-    await this._readPreferences();
-    await this._parseHashParameters();
-    await this._initializeL10n();
+              _context.next = 11;
+              return _this._initializeViewerComponents();
 
-    if (this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdfjsLib.LinkTarget.NONE) {
-      _app_options.AppOptions.set("externalLinkTarget", _pdfjsLib.LinkTarget.TOP);
-    }
+            case 11:
+              _this.bindEvents();
 
-    await this._initializeViewerComponents();
-    this.bindEvents();
-    this.bindWindowEvents();
-    const appContainer = appConfig.appContainer || document.documentElement;
-    this.l10n.translate(appContainer).then(() => {
-      this.eventBus.dispatch("localized", {
-        source: this
-      });
-    });
+              _this.bindWindowEvents();
 
-    this._initializedCapability.resolve();
-  },
+              appContainer = appConfig.appContainer || document.documentElement;
 
-  async _readPreferences() {
-    if (_app_options.AppOptions.get("disablePreferences")) {
-      return;
-    }
+              _this.l10n.translate(appContainer).then(function () {
+                _this.eventBus.dispatch("localized", {
+                  source: _this
+                });
+              });
 
-    try {
-      const prefs = await this.preferences.getAll();
+              _this._initializedCapability.resolve();
 
-      for (const name in prefs) {
-        _app_options.AppOptions.set(name, prefs[name]);
-      }
-    } catch (reason) {
-      console.error(`_readPreferences: "${reason.message}".`);
-    }
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }))();
   },
+  _readPreferences: function _readPreferences() {
+    var _this2 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var prefs, name;
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!_app_options.AppOptions.get("disablePreferences")) {
+                _context2.next = 2;
+                break;
+              }
 
-  async _parseHashParameters() {
-    if (!_app_options.AppOptions.get("pdfBugEnabled")) {
-      return undefined;
-    }
+              return _context2.abrupt("return");
 
-    const hash = document.location.hash.substring(1);
+            case 2:
+              _context2.prev = 2;
+              _context2.next = 5;
+              return _this2.preferences.getAll();
 
-    if (!hash) {
-      return undefined;
-    }
+            case 5:
+              prefs = _context2.sent;
 
-    const hashParams = (0, _ui_utils.parseQueryString)(hash),
-          waitOn = [];
+              for (name in prefs) {
+                _app_options.AppOptions.set(name, prefs[name]);
+              }
 
-    if ("disableworker" in hashParams && hashParams.disableworker === "true") {
-      waitOn.push(loadFakeWorker());
-    }
+              _context2.next = 12;
+              break;
 
-    if ("disablerange" in hashParams) {
-      _app_options.AppOptions.set("disableRange", hashParams.disablerange === "true");
-    }
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](2);
+              console.error("_readPreferences: \"".concat(_context2.t0.message, "\"."));
 
-    if ("disablestream" in hashParams) {
-      _app_options.AppOptions.set("disableStream", hashParams.disablestream === "true");
-    }
+            case 12:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[2, 9]]);
+    }))();
+  },
+  _parseHashParameters: function _parseHashParameters() {
+    var _this3 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var hash, hashParams, waitOn, viewer, enabled;
+      return _regenerator["default"].wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (_app_options.AppOptions.get("pdfBugEnabled")) {
+                _context3.next = 2;
+                break;
+              }
 
-    if ("disableautofetch" in hashParams) {
-      _app_options.AppOptions.set("disableAutoFetch", hashParams.disableautofetch === "true");
-    }
+              return _context3.abrupt("return", undefined);
 
-    if ("disablefontface" in hashParams) {
-      _app_options.AppOptions.set("disableFontFace", hashParams.disablefontface === "true");
-    }
+            case 2:
+              hash = document.location.hash.substring(1);
 
-    if ("disablehistory" in hashParams) {
-      _app_options.AppOptions.set("disableHistory", hashParams.disablehistory === "true");
-    }
+              if (hash) {
+                _context3.next = 5;
+                break;
+              }
 
-    if ("webgl" in hashParams) {
-      _app_options.AppOptions.set("enableWebGL", hashParams.webgl === "true");
-    }
+              return _context3.abrupt("return", undefined);
 
-    if ("verbosity" in hashParams) {
-      _app_options.AppOptions.set("verbosity", hashParams.verbosity | 0);
-    }
+            case 5:
+              hashParams = (0, _ui_utils.parseQueryString)(hash), waitOn = [];
 
-    if ("textlayer" in hashParams) {
-      switch (hashParams.textlayer) {
-        case "off":
-          _app_options.AppOptions.set("textLayerMode", _ui_utils.TextLayerMode.DISABLE);
+              if ("disableworker" in hashParams && hashParams.disableworker === "true") {
+                waitOn.push(loadFakeWorker());
+              }
 
-          break;
+              if ("disablerange" in hashParams) {
+                _app_options.AppOptions.set("disableRange", hashParams.disablerange === "true");
+              }
 
-        case "visible":
-        case "shadow":
-        case "hover":
-          const viewer = this.appConfig.viewerContainer;
-          viewer.classList.add("textLayer-" + hashParams.textlayer);
-          break;
-      }
-    }
+              if ("disablestream" in hashParams) {
+                _app_options.AppOptions.set("disableStream", hashParams.disablestream === "true");
+              }
 
-    if ("pdfbug" in hashParams) {
-      _app_options.AppOptions.set("pdfBug", true);
+              if ("disableautofetch" in hashParams) {
+                _app_options.AppOptions.set("disableAutoFetch", hashParams.disableautofetch === "true");
+              }
 
-      _app_options.AppOptions.set("fontExtraProperties", true);
+              if ("disablefontface" in hashParams) {
+                _app_options.AppOptions.set("disableFontFace", hashParams.disablefontface === "true");
+              }
 
-      const enabled = hashParams.pdfbug.split(",");
-      waitOn.push(loadAndEnablePDFBug(enabled));
-    }
+              if ("disablehistory" in hashParams) {
+                _app_options.AppOptions.set("disableHistory", hashParams.disablehistory === "true");
+              }
 
-    if ("locale" in hashParams) {
-      _app_options.AppOptions.set("locale", hashParams.locale);
-    }
+              if ("webgl" in hashParams) {
+                _app_options.AppOptions.set("enableWebGL", hashParams.webgl === "true");
+              }
 
-    return Promise.all(waitOn).catch(reason => {
-      console.error(`_parseHashParameters: "${reason.message}".`);
-    });
-  },
+              if ("verbosity" in hashParams) {
+                _app_options.AppOptions.set("verbosity", hashParams.verbosity | 0);
+              }
 
-  async _initializeL10n() {
-    this.l10n = this.externalServices.createL10n({
-      locale: _app_options.AppOptions.get("locale")
-    });
-    const dir = await this.l10n.getDirection();
-    document.getElementsByTagName("html")[0].dir = dir;
-  },
+              if (!("textlayer" in hashParams)) {
+                _context3.next = 23;
+                break;
+              }
 
-  async _initializeViewerComponents() {
-    const appConfig = this.appConfig;
-    const eventBus = appConfig.eventBus || new _ui_utils.EventBus({
-      isInAutomation: this.externalServices.isInAutomation
-    });
-    this.eventBus = eventBus;
-    this.overlayManager = new _overlay_manager.OverlayManager();
-    const pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
-    pdfRenderingQueue.onIdle = this.cleanup.bind(this);
-    this.pdfRenderingQueue = pdfRenderingQueue;
-    const pdfLinkService = new _pdf_link_service.PDFLinkService({
-      eventBus,
-      externalLinkTarget: _app_options.AppOptions.get("externalLinkTarget"),
-      externalLinkRel: _app_options.AppOptions.get("externalLinkRel"),
-      ignoreDestinationZoom: _app_options.AppOptions.get("ignoreDestinationZoom")
-    });
-    this.pdfLinkService = pdfLinkService;
-    const downloadManager = this.externalServices.createDownloadManager({
-      disableCreateObjectURL: _app_options.AppOptions.get("disableCreateObjectURL")
-    });
-    this.downloadManager = downloadManager;
-    const findController = new _pdf_find_controller.PDFFindController({
-      linkService: pdfLinkService,
-      eventBus
-    });
-    this.findController = findController;
-    const container = appConfig.mainContainer;
-    const viewer = appConfig.viewerContainer;
-    this.pdfViewer = new _pdf_viewer.PDFViewer({
-      container,
-      viewer,
-      eventBus,
-      renderingQueue: pdfRenderingQueue,
-      linkService: pdfLinkService,
-      downloadManager,
-      findController,
-      renderer: _app_options.AppOptions.get("renderer"),
-      enableWebGL: _app_options.AppOptions.get("enableWebGL"),
-      l10n: this.l10n,
-      textLayerMode: _app_options.AppOptions.get("textLayerMode"),
-      imageResourcesPath: _app_options.AppOptions.get("imageResourcesPath"),
-      renderInteractiveForms: _app_options.AppOptions.get("renderInteractiveForms"),
-      enablePrintAutoRotate: _app_options.AppOptions.get("enablePrintAutoRotate"),
-      useOnlyCssZoom: _app_options.AppOptions.get("useOnlyCssZoom"),
-      maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels")
-    });
-    pdfRenderingQueue.setViewer(this.pdfViewer);
-    pdfLinkService.setViewer(this.pdfViewer);
-    this.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
-      container: appConfig.sidebar.thumbnailView,
-      renderingQueue: pdfRenderingQueue,
-      linkService: pdfLinkService,
-      l10n: this.l10n
-    });
-    pdfRenderingQueue.setThumbnailViewer(this.pdfThumbnailViewer);
-    this.pdfHistory = new _pdf_history.PDFHistory({
-      linkService: pdfLinkService,
-      eventBus
-    });
-    pdfLinkService.setHistory(this.pdfHistory);
+              _context3.t0 = hashParams.textlayer;
+              _context3.next = _context3.t0 === "off" ? 18 : _context3.t0 === "visible" ? 20 : _context3.t0 === "shadow" ? 20 : _context3.t0 === "hover" ? 20 : 23;
+              break;
 
-    if (!this.supportsIntegratedFind) {
-      this.findBar = new _pdf_find_bar.PDFFindBar(appConfig.findBar, eventBus, this.l10n);
-    }
+            case 18:
+              _app_options.AppOptions.set("textLayerMode", _ui_utils.TextLayerMode.DISABLE);
 
-    this.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, this.l10n);
-    this.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
-      container,
-      eventBus,
-      cursorToolOnLoad: _app_options.AppOptions.get("cursorToolOnLoad")
-    });
-    this.toolbar = new _toolbar.Toolbar(appConfig.toolbar, eventBus, this.l10n);
-    this.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
+              return _context3.abrupt("break", 23);
 
-    if (this.supportsFullscreen) {
-      this.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
-        container,
-        pdfViewer: this.pdfViewer,
-        eventBus,
-        contextMenuItems: appConfig.fullscreen
-      });
-    }
+            case 20:
+              viewer = _this3.appConfig.viewerContainer;
+              viewer.classList.add("textLayer-" + hashParams.textlayer);
+              return _context3.abrupt("break", 23);
 
-    this.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.l10n);
-    this.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
-      container: appConfig.sidebar.outlineView,
-      eventBus,
-      linkService: pdfLinkService
-    });
-    this.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
-      container: appConfig.sidebar.attachmentsView,
-      eventBus,
-      downloadManager
-    });
-    this.pdfSidebar = new _pdf_sidebar.PDFSidebar({
-      elements: appConfig.sidebar,
-      pdfViewer: this.pdfViewer,
-      pdfThumbnailViewer: this.pdfThumbnailViewer,
-      eventBus,
-      l10n: this.l10n
-    });
-    this.pdfSidebar.onToggled = this.forceRendering.bind(this);
-    this.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, this.l10n);
+            case 23:
+              if ("pdfbug" in hashParams) {
+                _app_options.AppOptions.set("pdfBug", true);
+
+                _app_options.AppOptions.set("fontExtraProperties", true);
+
+                enabled = hashParams.pdfbug.split(",");
+                waitOn.push(loadAndEnablePDFBug(enabled));
+              }
+
+              if ("locale" in hashParams) {
+                _app_options.AppOptions.set("locale", hashParams.locale);
+              }
+
+              return _context3.abrupt("return", Promise.all(waitOn)["catch"](function (reason) {
+                console.error("_parseHashParameters: \"".concat(reason.message, "\"."));
+              }));
+
+            case 26:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }))();
   },
+  _initializeL10n: function _initializeL10n() {
+    var _this4 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var dir;
+      return _regenerator["default"].wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _this4.l10n = _this4.externalServices.createL10n({
+                locale: _app_options.AppOptions.get("locale")
+              });
+              _context4.next = 3;
+              return _this4.l10n.getDirection();
+
+            case 3:
+              dir = _context4.sent;
+              document.getElementsByTagName("html")[0].dir = dir;
+
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }))();
+  },
+  _initializeViewerComponents: function _initializeViewerComponents() {
+    var _this5 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+      var appConfig, eventBus, pdfRenderingQueue, pdfLinkService, downloadManager, findController, container, viewer;
+      return _regenerator["default"].wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              appConfig = _this5.appConfig;
+              eventBus = appConfig.eventBus || new _ui_utils.EventBus({
+                isInAutomation: _this5.externalServices.isInAutomation
+              });
+              _this5.eventBus = eventBus;
+              _this5.overlayManager = new _overlay_manager.OverlayManager();
+              pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
+              pdfRenderingQueue.onIdle = _this5.cleanup.bind(_this5);
+              _this5.pdfRenderingQueue = pdfRenderingQueue;
+              pdfLinkService = new _pdf_link_service.PDFLinkService({
+                eventBus: eventBus,
+                externalLinkTarget: _app_options.AppOptions.get("externalLinkTarget"),
+                externalLinkRel: _app_options.AppOptions.get("externalLinkRel"),
+                ignoreDestinationZoom: _app_options.AppOptions.get("ignoreDestinationZoom")
+              });
+              _this5.pdfLinkService = pdfLinkService;
+              downloadManager = _this5.externalServices.createDownloadManager({
+                disableCreateObjectURL: _app_options.AppOptions.get("disableCreateObjectURL")
+              });
+              _this5.downloadManager = downloadManager;
+              findController = new _pdf_find_controller.PDFFindController({
+                linkService: pdfLinkService,
+                eventBus: eventBus
+              });
+              _this5.findController = findController;
+              container = appConfig.mainContainer;
+              viewer = appConfig.viewerContainer;
+              _this5.pdfViewer = new _pdf_viewer.PDFViewer({
+                container: container,
+                viewer: viewer,
+                eventBus: eventBus,
+                renderingQueue: pdfRenderingQueue,
+                linkService: pdfLinkService,
+                downloadManager: downloadManager,
+                findController: findController,
+                renderer: _app_options.AppOptions.get("renderer"),
+                enableWebGL: _app_options.AppOptions.get("enableWebGL"),
+                l10n: _this5.l10n,
+                textLayerMode: _app_options.AppOptions.get("textLayerMode"),
+                imageResourcesPath: _app_options.AppOptions.get("imageResourcesPath"),
+                renderInteractiveForms: _app_options.AppOptions.get("renderInteractiveForms"),
+                enablePrintAutoRotate: _app_options.AppOptions.get("enablePrintAutoRotate"),
+                useOnlyCssZoom: _app_options.AppOptions.get("useOnlyCssZoom"),
+                maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels")
+              });
+              pdfRenderingQueue.setViewer(_this5.pdfViewer);
+              pdfLinkService.setViewer(_this5.pdfViewer);
+              _this5.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
+                container: appConfig.sidebar.thumbnailView,
+                renderingQueue: pdfRenderingQueue,
+                linkService: pdfLinkService,
+                l10n: _this5.l10n
+              });
+              pdfRenderingQueue.setThumbnailViewer(_this5.pdfThumbnailViewer);
+              _this5.pdfHistory = new _pdf_history.PDFHistory({
+                linkService: pdfLinkService,
+                eventBus: eventBus
+              });
+              pdfLinkService.setHistory(_this5.pdfHistory);
+
+              if (!_this5.supportsIntegratedFind) {
+                _this5.findBar = new _pdf_find_bar.PDFFindBar(appConfig.findBar, eventBus, _this5.l10n);
+              }
 
-  run(config) {
+              _this5.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, _this5.overlayManager, eventBus, _this5.l10n);
+              _this5.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
+                container: container,
+                eventBus: eventBus,
+                cursorToolOnLoad: _app_options.AppOptions.get("cursorToolOnLoad")
+              });
+              _this5.toolbar = new _toolbar.Toolbar(appConfig.toolbar, eventBus, _this5.l10n);
+              _this5.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
+
+              if (_this5.supportsFullscreen) {
+                _this5.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
+                  container: container,
+                  pdfViewer: _this5.pdfViewer,
+                  eventBus: eventBus,
+                  contextMenuItems: appConfig.fullscreen
+                });
+              }
+
+              _this5.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, _this5.overlayManager, _this5.l10n);
+              _this5.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
+                container: appConfig.sidebar.outlineView,
+                eventBus: eventBus,
+                linkService: pdfLinkService
+              });
+              _this5.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
+                container: appConfig.sidebar.attachmentsView,
+                eventBus: eventBus,
+                downloadManager: downloadManager
+              });
+              _this5.pdfSidebar = new _pdf_sidebar.PDFSidebar({
+                elements: appConfig.sidebar,
+                pdfViewer: _this5.pdfViewer,
+                pdfThumbnailViewer: _this5.pdfThumbnailViewer,
+                eventBus: eventBus,
+                l10n: _this5.l10n
+              });
+              _this5.pdfSidebar.onToggled = _this5.forceRendering.bind(_this5);
+              _this5.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, _this5.l10n);
+
+            case 34:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }))();
+  },
+  run: function run(config) {
     this.initialize(config).then(webViewerInitialized);
   },
 
@@ -674,12 +835,12 @@ const PDFViewerApplication = {
     return this._initializedCapability.promise;
   },
 
-  zoomIn(ticks) {
+  zoomIn: function zoomIn(ticks) {
     if (this.pdfViewer.isInPresentationMode) {
       return;
     }
 
-    let newScale = this.pdfViewer.currentScale;
+    var newScale = this.pdfViewer.currentScale;
 
     do {
       newScale = (newScale * DEFAULT_SCALE_DELTA).toFixed(2);
@@ -689,13 +850,12 @@ const PDFViewerApplication = {
 
     this.pdfViewer.currentScaleValue = newScale;
   },
-
-  zoomOut(ticks) {
+  zoomOut: function zoomOut(ticks) {
     if (this.pdfViewer.isInPresentationMode) {
       return;
     }
 
-    let newScale = this.pdfViewer.currentScale;
+    var newScale = this.pdfViewer.currentScale;
 
     do {
       newScale = (newScale / DEFAULT_SCALE_DELTA).toFixed(2);
@@ -705,8 +865,7 @@ const PDFViewerApplication = {
 
     this.pdfViewer.currentScaleValue = newScale;
   },
-
-  zoomReset() {
+  zoomReset: function zoomReset() {
     if (this.pdfViewer.isInPresentationMode) {
       return;
     }
@@ -735,8 +894,8 @@ const PDFViewerApplication = {
   },
 
   get supportsFullscreen() {
-    let support;
-    const doc = document.documentElement;
+    var support;
+    var doc = document.documentElement;
     support = !!(doc.requestFullscreen || doc.mozRequestFullScreen || doc.webkitRequestFullScreen || doc.msRequestFullscreen);
 
     if (document.fullscreenEnabled === false || document.mozFullScreenEnabled === false || document.webkitFullscreenEnabled === false || document.msFullscreenEnabled === false) {
@@ -755,7 +914,7 @@ const PDFViewerApplication = {
   },
 
   get loadingBar() {
-    const bar = new _ui_utils.ProgressBar("#loadingBar");
+    var bar = new _ui_utils.ProgressBar("#loadingBar");
     return (0, _pdfjsLib.shadow)(this, "loadingBar", bar);
   },
 
@@ -763,14 +922,14 @@ const PDFViewerApplication = {
     return this.externalServices.supportedMouseWheelZoomModifierKeys;
   },
 
-  initPassiveLoading() {
+  initPassiveLoading: function initPassiveLoading() {
     throw new Error("Not implemented: initPassiveLoading");
   },
-
-  setTitleUsingUrl(url = "") {
+  setTitleUsingUrl: function setTitleUsingUrl() {
+    var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
     this.url = url;
     this.baseUrl = url.split("#")[0];
-    let title = (0, _ui_utils.getPDFFileNameFromURL)(url, "");
+    var title = (0, _ui_utils.getPDFFileNameFromURL)(url, "");
 
     if (!title) {
       try {
@@ -782,165 +941,218 @@ const PDFViewerApplication = {
 
     this.setTitle(title);
   },
-
-  setTitle(title) {
+  setTitle: function setTitle(title) {
     if (this.isViewerEmbedded) {
       return;
     }
 
     document.title = title;
   },
+  close: function close() {
+    var _this6 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+      var errorWrapper, promise;
+      return _regenerator["default"].wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              errorWrapper = _this6.appConfig.errorWrapper.container;
+              errorWrapper.setAttribute("hidden", "true");
+
+              if (_this6.pdfLoadingTask) {
+                _context6.next = 4;
+                break;
+              }
 
-  async close() {
-    const errorWrapper = this.appConfig.errorWrapper.container;
-    errorWrapper.setAttribute("hidden", "true");
+              return _context6.abrupt("return", undefined);
 
-    if (!this.pdfLoadingTask) {
-      return undefined;
-    }
+            case 4:
+              promise = _this6.pdfLoadingTask.destroy();
+              _this6.pdfLoadingTask = null;
 
-    const promise = this.pdfLoadingTask.destroy();
-    this.pdfLoadingTask = null;
+              if (_this6.pdfDocument) {
+                _this6.pdfDocument = null;
 
-    if (this.pdfDocument) {
-      this.pdfDocument = null;
-      this.pdfThumbnailViewer.setDocument(null);
-      this.pdfViewer.setDocument(null);
-      this.pdfLinkService.setDocument(null);
-      this.pdfDocumentProperties.setDocument(null);
-    }
+                _this6.pdfThumbnailViewer.setDocument(null);
 
-    webViewerResetPermissions();
-    this.store = null;
-    this.isInitialViewSet = false;
-    this.downloadComplete = false;
-    this.url = "";
-    this.baseUrl = "";
-    this.contentDispositionFilename = null;
-    this.pdfSidebar.reset();
-    this.pdfOutlineViewer.reset();
-    this.pdfAttachmentViewer.reset();
+                _this6.pdfViewer.setDocument(null);
 
-    if (this.pdfHistory) {
-      this.pdfHistory.reset();
-    }
+                _this6.pdfLinkService.setDocument(null);
 
-    if (this.findBar) {
-      this.findBar.reset();
-    }
+                _this6.pdfDocumentProperties.setDocument(null);
+              }
 
-    this.toolbar.reset();
-    this.secondaryToolbar.reset();
+              webViewerResetPermissions();
+              _this6.store = null;
+              _this6.isInitialViewSet = false;
+              _this6.downloadComplete = false;
+              _this6.url = "";
+              _this6.baseUrl = "";
+              _this6.contentDispositionFilename = null;
 
-    if (typeof PDFBug !== "undefined") {
-      PDFBug.cleanup();
-    }
+              _this6.pdfSidebar.reset();
 
-    return promise;
-  },
+              _this6.pdfOutlineViewer.reset();
 
-  async open(file, args) {
-    if (this.pdfLoadingTask) {
-      await this.close();
-    }
+              _this6.pdfAttachmentViewer.reset();
 
-    const workerParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.WORKER);
+              if (_this6.pdfHistory) {
+                _this6.pdfHistory.reset();
+              }
 
-    for (const key in workerParameters) {
-      _pdfjsLib.GlobalWorkerOptions[key] = workerParameters[key];
-    }
+              if (_this6.findBar) {
+                _this6.findBar.reset();
+              }
 
-    const parameters = Object.create(null);
+              _this6.toolbar.reset();
 
-    if (typeof file === "string") {
-      this.setTitleUsingUrl(file);
-      parameters.url = file;
-    } else if (file && "byteLength" in file) {
-      parameters.data = file;
-    } else if (file.url && file.originalUrl) {
-      this.setTitleUsingUrl(file.originalUrl);
-      parameters.url = file.url;
-    }
+              _this6.secondaryToolbar.reset();
 
-    const apiParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.API);
+              if (typeof PDFBug !== "undefined") {
+                PDFBug.cleanup();
+              }
 
-    for (const key in apiParameters) {
-      let value = apiParameters[key];
+              return _context6.abrupt("return", promise);
 
-      if (key === "docBaseUrl" && !value) {}
+            case 23:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6);
+    }))();
+  },
+  open: function open(file, args) {
+    var _this7 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+      var workerParameters, key, parameters, apiParameters, _key, value, _key2, _value, loadingTask;
+
+      return _regenerator["default"].wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              if (!_this7.pdfLoadingTask) {
+                _context7.next = 3;
+                break;
+              }
 
-      parameters[key] = value;
-    }
+              _context7.next = 3;
+              return _this7.close();
 
-    if (args) {
-      for (const key in args) {
-        const value = args[key];
+            case 3:
+              workerParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.WORKER);
 
-        if (key === "length") {
-          this.pdfDocumentProperties.setFileSize(value);
-        }
+              for (key in workerParameters) {
+                _pdfjsLib.GlobalWorkerOptions[key] = workerParameters[key];
+              }
 
-        parameters[key] = value;
-      }
-    }
+              parameters = Object.create(null);
 
-    const loadingTask = (0, _pdfjsLib.getDocument)(parameters);
-    this.pdfLoadingTask = loadingTask;
+              if (typeof file === "string") {
+                _this7.setTitleUsingUrl(file);
 
-    loadingTask.onPassword = (updateCallback, reason) => {
-      this.pdfLinkService.externalLinkEnabled = false;
-      this.passwordPrompt.setUpdateCallback(updateCallback, reason);
-      this.passwordPrompt.open();
-    };
+                parameters.url = file;
+              } else if (file && "byteLength" in file) {
+                parameters.data = file;
+              } else if (file.url && file.originalUrl) {
+                _this7.setTitleUsingUrl(file.originalUrl);
 
-    loadingTask.onProgress = ({
-      loaded,
-      total
-    }) => {
-      this.progress(loaded / total);
-    };
+                parameters.url = file.url;
+              }
 
-    loadingTask.onUnsupportedFeature = this.fallback.bind(this);
-    return loadingTask.promise.then(pdfDocument => {
-      this.load(pdfDocument);
-    }, exception => {
-      if (loadingTask !== this.pdfLoadingTask) {
-        return undefined;
-      }
+              apiParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.API);
 
-      const message = exception && exception.message;
-      let loadingErrorMessage;
+              for (_key in apiParameters) {
+                value = apiParameters[_key];
 
-      if (exception instanceof _pdfjsLib.InvalidPDFException) {
-        loadingErrorMessage = this.l10n.get("invalid_file_error", null, "Invalid or corrupted PDF file.");
-      } else if (exception instanceof _pdfjsLib.MissingPDFException) {
-        loadingErrorMessage = this.l10n.get("missing_file_error", null, "Missing PDF file.");
-      } else if (exception instanceof _pdfjsLib.UnexpectedResponseException) {
-        loadingErrorMessage = this.l10n.get("unexpected_response_error", null, "Unexpected server response.");
-      } else {
-        loadingErrorMessage = this.l10n.get("loading_error", null, "An error occurred while loading the PDF.");
-      }
+                if (_key === "docBaseUrl" && !value) {}
 
-      return loadingErrorMessage.then(msg => {
-        this.error(msg, {
-          message
-        });
-        throw exception;
-      });
-    });
+                parameters[_key] = value;
+              }
+
+              if (args) {
+                for (_key2 in args) {
+                  _value = args[_key2];
+
+                  if (_key2 === "length") {
+                    _this7.pdfDocumentProperties.setFileSize(_value);
+                  }
+
+                  parameters[_key2] = _value;
+                }
+              }
+
+              loadingTask = (0, _pdfjsLib.getDocument)(parameters);
+              _this7.pdfLoadingTask = loadingTask;
+
+              loadingTask.onPassword = function (updateCallback, reason) {
+                _this7.pdfLinkService.externalLinkEnabled = false;
+
+                _this7.passwordPrompt.setUpdateCallback(updateCallback, reason);
+
+                _this7.passwordPrompt.open();
+              };
+
+              loadingTask.onProgress = function (_ref) {
+                var loaded = _ref.loaded,
+                    total = _ref.total;
+
+                _this7.progress(loaded / total);
+              };
+
+              loadingTask.onUnsupportedFeature = _this7.fallback.bind(_this7);
+              return _context7.abrupt("return", loadingTask.promise.then(function (pdfDocument) {
+                _this7.load(pdfDocument);
+              }, function (exception) {
+                if (loadingTask !== _this7.pdfLoadingTask) {
+                  return undefined;
+                }
+
+                var message = exception && exception.message;
+                var loadingErrorMessage;
+
+                if (exception instanceof _pdfjsLib.InvalidPDFException) {
+                  loadingErrorMessage = _this7.l10n.get("invalid_file_error", null, "Invalid or corrupted PDF file.");
+                } else if (exception instanceof _pdfjsLib.MissingPDFException) {
+                  loadingErrorMessage = _this7.l10n.get("missing_file_error", null, "Missing PDF file.");
+                } else if (exception instanceof _pdfjsLib.UnexpectedResponseException) {
+                  loadingErrorMessage = _this7.l10n.get("unexpected_response_error", null, "Unexpected server response.");
+                } else {
+                  loadingErrorMessage = _this7.l10n.get("loading_error", null, "An error occurred while loading the PDF.");
+                }
+
+                return loadingErrorMessage.then(function (msg) {
+                  _this7.error(msg, {
+                    message: message
+                  });
+
+                  throw exception;
+                });
+              }));
+
+            case 16:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7);
+    }))();
   },
+  download: function download() {
+    var _this8 = this;
 
-  download() {
     function downloadByUrl() {
       downloadManager.downloadUrl(url, filename);
     }
 
-    const url = this.baseUrl;
-    const filename = this.contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
-    const downloadManager = this.downloadManager;
+    var url = this.baseUrl;
+    var filename = this.contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
+    var downloadManager = this.downloadManager;
 
-    downloadManager.onerror = err => {
-      this.error(`PDF failed to download: ${err}`);
+    downloadManager.onerror = function (err) {
+      _this8.error("PDF failed to download: ".concat(err));
     };
 
     if (!this.pdfDocument || !this.downloadComplete) {
@@ -949,21 +1161,20 @@ const PDFViewerApplication = {
     }
 
     this.pdfDocument.getData().then(function (data) {
-      const blob = new Blob([data], {
+      var blob = new Blob([data], {
         type: "application/pdf"
       });
       downloadManager.download(blob, url, filename);
-    }).catch(downloadByUrl);
+    })["catch"](downloadByUrl);
   },
-
-  fallback(featureId) {
+  fallback: function fallback(featureId) {
     if (this.fellback) {
       return;
     }
 
     this.fellback = true;
     this.externalServices.fallback({
-      featureId,
+      featureId: featureId,
       url: this.baseUrl
     }, function response(download) {
       if (!download) {
@@ -973,9 +1184,8 @@ const PDFViewerApplication = {
       PDFViewerApplication.download();
     });
   },
-
-  error(message, moreInfo) {
-    const moreInfoText = [this.l10n.get("error_version_info", {
+  error: function error(message, moreInfo) {
+    var moreInfoText = [this.l10n.get("error_version_info", {
       version: _pdfjsLib.version || "?",
       build: _pdfjsLib.build || "?"
     }, "PDF.js v{{version}} (build: {{build}})")];
@@ -1004,20 +1214,20 @@ const PDFViewerApplication = {
       }
     }
 
-    const errorWrapperConfig = this.appConfig.errorWrapper;
-    const errorWrapper = errorWrapperConfig.container;
+    var errorWrapperConfig = this.appConfig.errorWrapper;
+    var errorWrapper = errorWrapperConfig.container;
     errorWrapper.removeAttribute("hidden");
-    const errorMessage = errorWrapperConfig.errorMessage;
+    var errorMessage = errorWrapperConfig.errorMessage;
     errorMessage.textContent = message;
-    const closeButton = errorWrapperConfig.closeButton;
+    var closeButton = errorWrapperConfig.closeButton;
 
     closeButton.onclick = function () {
       errorWrapper.setAttribute("hidden", "true");
     };
 
-    const errorMoreInfo = errorWrapperConfig.errorMoreInfo;
-    const moreInfoButton = errorWrapperConfig.moreInfoButton;
-    const lessInfoButton = errorWrapperConfig.lessInfoButton;
+    var errorMoreInfo = errorWrapperConfig.errorMoreInfo;
+    var moreInfoButton = errorWrapperConfig.moreInfoButton;
+    var lessInfoButton = errorWrapperConfig.lessInfoButton;
 
     moreInfoButton.onclick = function () {
       errorMoreInfo.removeAttribute("hidden");
@@ -1037,21 +1247,22 @@ const PDFViewerApplication = {
     closeButton.oncontextmenu = _ui_utils.noContextMenuHandler;
     moreInfoButton.removeAttribute("hidden");
     lessInfoButton.setAttribute("hidden", "true");
-    Promise.all(moreInfoText).then(parts => {
+    Promise.all(moreInfoText).then(function (parts) {
       errorMoreInfo.value = parts.join("\n");
     });
   },
+  progress: function progress(level) {
+    var _this9 = this;
 
-  progress(level) {
     if (this.downloadComplete) {
       return;
     }
 
-    const percent = Math.round(level * 100);
+    var percent = Math.round(level * 100);
 
     if (percent > this.loadingBar.percent || isNaN(percent)) {
       this.loadingBar.percent = percent;
-      const disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams.disableAutoFetch : _app_options.AppOptions.get("disableAutoFetch");
+      var disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams.disableAutoFetch : _app_options.AppOptions.get("disableAutoFetch");
 
       if (disableAutoFetch && percent) {
         if (this.disableAutoFetchLoadingBarTimeout) {
@@ -1060,44 +1271,46 @@ const PDFViewerApplication = {
         }
 
         this.loadingBar.show();
-        this.disableAutoFetchLoadingBarTimeout = setTimeout(() => {
-          this.loadingBar.hide();
-          this.disableAutoFetchLoadingBarTimeout = null;
+        this.disableAutoFetchLoadingBarTimeout = setTimeout(function () {
+          _this9.loadingBar.hide();
+
+          _this9.disableAutoFetchLoadingBarTimeout = null;
         }, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
       }
     }
   },
+  load: function load(pdfDocument) {
+    var _this10 = this;
 
-  load(pdfDocument) {
     this.pdfDocument = pdfDocument;
-    pdfDocument.getDownloadInfo().then(() => {
-      this.downloadComplete = true;
-      this.loadingBar.hide();
-      firstPagePromise.then(() => {
-        this.eventBus.dispatch("documentloaded", {
-          source: this
+    pdfDocument.getDownloadInfo().then(function () {
+      _this10.downloadComplete = true;
+
+      _this10.loadingBar.hide();
+
+      firstPagePromise.then(function () {
+        _this10.eventBus.dispatch("documentloaded", {
+          source: _this10
         });
       });
     });
-    const pageLayoutPromise = pdfDocument.getPageLayout().catch(function () {});
-    const pageModePromise = pdfDocument.getPageMode().catch(function () {});
-    const openActionPromise = pdfDocument.getOpenAction().catch(function () {});
+    var pageLayoutPromise = pdfDocument.getPageLayout()["catch"](function () {});
+    var pageModePromise = pdfDocument.getPageMode()["catch"](function () {});
+    var openActionPromise = pdfDocument.getOpenAction()["catch"](function () {});
     this.toolbar.setPagesCount(pdfDocument.numPages, false);
     this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
-    let baseDocumentUrl;
+    var baseDocumentUrl;
     baseDocumentUrl = null;
     this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
     this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
-    const pdfViewer = this.pdfViewer;
+    var pdfViewer = this.pdfViewer;
     pdfViewer.setDocument(pdfDocument);
-    const {
-      firstPagePromise,
-      onePageRendered,
-      pagesPromise
-    } = pdfViewer;
-    const pdfThumbnailViewer = this.pdfThumbnailViewer;
+    var firstPagePromise = pdfViewer.firstPagePromise,
+        onePageRendered = pdfViewer.onePageRendered,
+        pagesPromise = pdfViewer.pagesPromise;
+    var pdfThumbnailViewer = this.pdfThumbnailViewer;
     pdfThumbnailViewer.setDocument(pdfDocument);
-    const storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument.fingerprint)).getMultiple({
+    var storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument.fingerprint)).getMultiple({
       page: null,
       zoom: _ui_utils.DEFAULT_SCALE_VALUE,
       scrollLeft: "0",
@@ -1106,288 +1319,445 @@ const PDFViewerApplication = {
       sidebarView: _pdf_sidebar.SidebarView.UNKNOWN,
       scrollMode: _ui_utils.ScrollMode.UNKNOWN,
       spreadMode: _ui_utils.SpreadMode.UNKNOWN
-    }).catch(() => {
+    })["catch"](function () {
       return Object.create(null);
     });
-    firstPagePromise.then(pdfPage => {
-      this.loadingBar.setWidth(this.appConfig.viewerContainer);
-      Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then(async ([timeStamp, stored, pageLayout, pageMode, openAction]) => {
-        const viewOnLoad = _app_options.AppOptions.get("viewOnLoad");
-
-        this._initializePdfHistory({
-          fingerprint: pdfDocument.fingerprint,
-          viewOnLoad,
-          initialDest: openAction && openAction.dest
+    firstPagePromise.then(function (pdfPage) {
+      _this10.loadingBar.setWidth(_this10.appConfig.viewerContainer);
+
+      Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then( /*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee8(_ref2) {
+          var _ref4, timeStamp, stored, pageLayout, pageMode, openAction, viewOnLoad, initialBookmark, zoom, hash, rotation, sidebarView, scrollMode, spreadMode;
+
+          return _regenerator["default"].wrap(function _callee8$(_context8) {
+            while (1) {
+              switch (_context8.prev = _context8.next) {
+                case 0:
+                  _ref4 = _slicedToArray(_ref2, 5), timeStamp = _ref4[0], stored = _ref4[1], pageLayout = _ref4[2], pageMode = _ref4[3], openAction = _ref4[4];
+                  viewOnLoad = _app_options.AppOptions.get("viewOnLoad");
+
+                  _this10._initializePdfHistory({
+                    fingerprint: pdfDocument.fingerprint,
+                    viewOnLoad: viewOnLoad,
+                    initialDest: openAction && openAction.dest
+                  });
+
+                  initialBookmark = _this10.initialBookmark;
+                  zoom = _app_options.AppOptions.get("defaultZoomValue");
+                  hash = zoom ? "zoom=".concat(zoom) : null;
+                  rotation = null;
+                  sidebarView = _app_options.AppOptions.get("sidebarViewOnLoad");
+                  scrollMode = _app_options.AppOptions.get("scrollModeOnLoad");
+                  spreadMode = _app_options.AppOptions.get("spreadModeOnLoad");
+
+                  if (stored.page && viewOnLoad !== ViewOnLoad.INITIAL) {
+                    hash = "page=".concat(stored.page, "&zoom=").concat(zoom || stored.zoom, ",") + "".concat(stored.scrollLeft, ",").concat(stored.scrollTop);
+                    rotation = parseInt(stored.rotation, 10);
+
+                    if (sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+                      sidebarView = stored.sidebarView | 0;
+                    }
+
+                    if (scrollMode === _ui_utils.ScrollMode.UNKNOWN) {
+                      scrollMode = stored.scrollMode | 0;
+                    }
+
+                    if (spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+                      spreadMode = stored.spreadMode | 0;
+                    }
+                  }
+
+                  if (pageMode && sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+                    sidebarView = apiPageModeToSidebarView(pageMode);
+                  }
+
+                  if (pageLayout && spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+                    spreadMode = apiPageLayoutToSpreadMode(pageLayout);
+                  }
+
+                  _this10.setInitialView(hash, {
+                    rotation: rotation,
+                    sidebarView: sidebarView,
+                    scrollMode: scrollMode,
+                    spreadMode: spreadMode
+                  });
+
+                  _this10.eventBus.dispatch("documentinit", {
+                    source: _this10
+                  });
+
+                  if (!_this10.isViewerEmbedded) {
+                    pdfViewer.focus();
+                  }
+
+                  _this10._initializePermissions(pdfDocument);
+
+                  _context8.next = 19;
+                  return Promise.race([pagesPromise, new Promise(function (resolve) {
+                    setTimeout(resolve, FORCE_PAGES_LOADED_TIMEOUT);
+                  })]);
+
+                case 19:
+                  if (!(!initialBookmark && !hash)) {
+                    _context8.next = 21;
+                    break;
+                  }
+
+                  return _context8.abrupt("return");
+
+                case 21:
+                  if (!pdfViewer.hasEqualPageSizes) {
+                    _context8.next = 23;
+                    break;
+                  }
+
+                  return _context8.abrupt("return");
+
+                case 23:
+                  _this10.initialBookmark = initialBookmark;
+                  pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
+
+                  _this10.setInitialView(hash);
+
+                case 26:
+                case "end":
+                  return _context8.stop();
+              }
+            }
+          }, _callee8);
+        }));
+
+        return function (_x) {
+          return _ref3.apply(this, arguments);
+        };
+      }())["catch"](function () {
+        _this10.setInitialView();
+      }).then(function () {
+        pdfViewer.update();
+      });
+    });
+    pagesPromise.then(function () {
+      _this10._initializeAutoPrint(pdfDocument, openActionPromise);
+    });
+    onePageRendered.then(function () {
+      pdfDocument.getOutline().then(function (outline) {
+        _this10.pdfOutlineViewer.render({
+          outline: outline
+        });
+      });
+      pdfDocument.getAttachments().then(function (attachments) {
+        _this10.pdfAttachmentViewer.render({
+          attachments: attachments
         });
+      });
+    });
 
-        const initialBookmark = this.initialBookmark;
+    this._initializePageLabels(pdfDocument);
 
-        const zoom = _app_options.AppOptions.get("defaultZoomValue");
+    this._initializeMetadata(pdfDocument);
+  },
+  _initializeAutoPrint: function _initializeAutoPrint(pdfDocument, openActionPromise) {
+    var _this11 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+      var _yield$Promise$all, _yield$Promise$all2, openAction, javaScript, triggerAutoPrint, _iterator, _step, js;
+
+      return _regenerator["default"].wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 2;
+              return Promise.all([openActionPromise, pdfDocument.getJavaScript()]);
+
+            case 2:
+              _yield$Promise$all = _context9.sent;
+              _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+              openAction = _yield$Promise$all2[0];
+              javaScript = _yield$Promise$all2[1];
+
+              if (!(pdfDocument !== _this11.pdfDocument)) {
+                _context9.next = 8;
+                break;
+              }
 
-        let hash = zoom ? `zoom=${zoom}` : null;
-        let rotation = null;
+              return _context9.abrupt("return");
 
-        let sidebarView = _app_options.AppOptions.get("sidebarViewOnLoad");
+            case 8:
+              triggerAutoPrint = false;
 
-        let scrollMode = _app_options.AppOptions.get("scrollModeOnLoad");
+              if (openAction && openAction.action === "Print") {
+                triggerAutoPrint = true;
+              }
 
-        let spreadMode = _app_options.AppOptions.get("spreadModeOnLoad");
+              if (!javaScript) {
+                _context9.next = 31;
+                break;
+              }
 
-        if (stored.page && viewOnLoad !== ViewOnLoad.INITIAL) {
-          hash = `page=${stored.page}&zoom=${zoom || stored.zoom},` + `${stored.scrollLeft},${stored.scrollTop}`;
-          rotation = parseInt(stored.rotation, 10);
+              javaScript.some(function (js) {
+                if (!js) {
+                  return false;
+                }
 
-          if (sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
-            sidebarView = stored.sidebarView | 0;
-          }
+                console.warn("Warning: JavaScript is not supported");
 
-          if (scrollMode === _ui_utils.ScrollMode.UNKNOWN) {
-            scrollMode = stored.scrollMode | 0;
-          }
+                _this11.fallback(_pdfjsLib.UNSUPPORTED_FEATURES.javaScript);
 
-          if (spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
-            spreadMode = stored.spreadMode | 0;
-          }
-        }
+                return true;
+              });
 
-        if (pageMode && sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
-          sidebarView = apiPageModeToSidebarView(pageMode);
-        }
+              if (triggerAutoPrint) {
+                _context9.next = 31;
+                break;
+              }
 
-        if (pageLayout && spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
-          spreadMode = apiPageLayoutToSpreadMode(pageLayout);
-        }
+              _iterator = _createForOfIteratorHelper(javaScript);
+              _context9.prev = 14;
 
-        this.setInitialView(hash, {
-          rotation,
-          sidebarView,
-          scrollMode,
-          spreadMode
-        });
-        this.eventBus.dispatch("documentinit", {
-          source: this
-        });
+              _iterator.s();
 
-        if (!this.isViewerEmbedded) {
-          pdfViewer.focus();
-        }
+            case 16:
+              if ((_step = _iterator.n()).done) {
+                _context9.next = 23;
+                break;
+              }
 
-        this._initializePermissions(pdfDocument);
+              js = _step.value;
 
-        await Promise.race([pagesPromise, new Promise(resolve => {
-          setTimeout(resolve, FORCE_PAGES_LOADED_TIMEOUT);
-        })]);
+              if (!(js && _ui_utils.AutoPrintRegExp.test(js))) {
+                _context9.next = 21;
+                break;
+              }
 
-        if (!initialBookmark && !hash) {
-          return;
-        }
+              triggerAutoPrint = true;
+              return _context9.abrupt("break", 23);
 
-        if (pdfViewer.hasEqualPageSizes) {
-          return;
-        }
+            case 21:
+              _context9.next = 16;
+              break;
 
-        this.initialBookmark = initialBookmark;
-        pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
-        this.setInitialView(hash);
-      }).catch(() => {
-        this.setInitialView();
-      }).then(function () {
-        pdfViewer.update();
-      });
-    });
-    pagesPromise.then(() => {
-      this._initializeAutoPrint(pdfDocument, openActionPromise);
-    });
-    onePageRendered.then(() => {
-      pdfDocument.getOutline().then(outline => {
-        this.pdfOutlineViewer.render({
-          outline
-        });
-      });
-      pdfDocument.getAttachments().then(attachments => {
-        this.pdfAttachmentViewer.render({
-          attachments
-        });
-      });
-    });
+            case 23:
+              _context9.next = 28;
+              break;
 
-    this._initializePageLabels(pdfDocument);
+            case 25:
+              _context9.prev = 25;
+              _context9.t0 = _context9["catch"](14);
 
-    this._initializeMetadata(pdfDocument);
-  },
+              _iterator.e(_context9.t0);
 
-  async _initializeAutoPrint(pdfDocument, openActionPromise) {
-    const [openAction, javaScript] = await Promise.all([openActionPromise, pdfDocument.getJavaScript()]);
+            case 28:
+              _context9.prev = 28;
 
-    if (pdfDocument !== this.pdfDocument) {
-      return;
-    }
+              _iterator.f();
 
-    let triggerAutoPrint = false;
+              return _context9.finish(28);
 
-    if (openAction && openAction.action === "Print") {
-      triggerAutoPrint = true;
-    }
+            case 31:
+              if (_this11.supportsPrinting) {
+                _context9.next = 33;
+                break;
+              }
 
-    if (javaScript) {
-      javaScript.some(js => {
-        if (!js) {
-          return false;
-        }
+              return _context9.abrupt("return");
 
-        console.warn("Warning: JavaScript is not supported");
-        this.fallback(_pdfjsLib.UNSUPPORTED_FEATURES.javaScript);
-        return true;
-      });
+            case 33:
+              if (triggerAutoPrint) {
+                setTimeout(function () {
+                  window.print();
+                });
+              }
 
-      if (!triggerAutoPrint) {
-        for (const js of javaScript) {
-          if (js && _ui_utils.AutoPrintRegExp.test(js)) {
-            triggerAutoPrint = true;
-            break;
+            case 34:
+            case "end":
+              return _context9.stop();
           }
         }
-      }
-    }
-
-    if (!this.supportsPrinting) {
-      return;
-    }
-
-    if (triggerAutoPrint) {
-      setTimeout(function () {
-        window.print();
-      });
-    }
+      }, _callee9, null, [[14, 25, 28, 31]]);
+    }))();
   },
+  _initializeMetadata: function _initializeMetadata(pdfDocument) {
+    var _this12 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+      var _yield$pdfDocument$ge, info, metadata, contentDispositionFilename, pdfTitle, infoTitle, metadataTitle, versionId, KNOWN_VERSIONS, generatorId, KNOWN_GENERATORS, producer, formType;
+
+      return _regenerator["default"].wrap(function _callee10$(_context10) {
+        while (1) {
+          switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 2;
+              return pdfDocument.getMetadata();
+
+            case 2:
+              _yield$pdfDocument$ge = _context10.sent;
+              info = _yield$pdfDocument$ge.info;
+              metadata = _yield$pdfDocument$ge.metadata;
+              contentDispositionFilename = _yield$pdfDocument$ge.contentDispositionFilename;
+
+              if (!(pdfDocument !== _this12.pdfDocument)) {
+                _context10.next = 8;
+                break;
+              }
 
-  async _initializeMetadata(pdfDocument) {
-    const {
-      info,
-      metadata,
-      contentDispositionFilename
-    } = await pdfDocument.getMetadata();
+              return _context10.abrupt("return");
 
-    if (pdfDocument !== this.pdfDocument) {
-      return;
-    }
+            case 8:
+              _this12.documentInfo = info;
+              _this12.metadata = metadata;
+              _this12.contentDispositionFilename = contentDispositionFilename;
+              console.log("PDF ".concat(pdfDocument.fingerprint, " [").concat(info.PDFFormatVersion, " ") + "".concat((info.Producer || "-").trim(), " / ").concat((info.Creator || "-").trim(), "] ") + "(PDF.js: ".concat(_pdfjsLib.version || "-") + "".concat(_this12.pdfViewer.enableWebGL ? " [WebGL]" : "", ")"));
+              infoTitle = info && info.Title;
 
-    this.documentInfo = info;
-    this.metadata = metadata;
-    this.contentDispositionFilename = contentDispositionFilename;
-    console.log(`PDF ${pdfDocument.fingerprint} [${info.PDFFormatVersion} ` + `${(info.Producer || "-").trim()} / ${(info.Creator || "-").trim()}] ` + `(PDF.js: ${_pdfjsLib.version || "-"}` + `${this.pdfViewer.enableWebGL ? " [WebGL]" : ""})`);
-    let pdfTitle;
-    const infoTitle = info && info.Title;
+              if (infoTitle) {
+                pdfTitle = infoTitle;
+              }
 
-    if (infoTitle) {
-      pdfTitle = infoTitle;
-    }
+              metadataTitle = metadata && metadata.get("dc:title");
 
-    const metadataTitle = metadata && metadata.get("dc:title");
+              if (metadataTitle) {
+                if (metadataTitle !== "Untitled" && !/[\uFFF0-\uFFFF]/g.test(metadataTitle)) {
+                  pdfTitle = metadataTitle;
+                }
+              }
 
-    if (metadataTitle) {
-      if (metadataTitle !== "Untitled" && !/[\uFFF0-\uFFFF]/g.test(metadataTitle)) {
-        pdfTitle = metadataTitle;
-      }
-    }
+              if (pdfTitle) {
+                _this12.setTitle("".concat(pdfTitle, " - ").concat(contentDispositionFilename || document.title));
+              } else if (contentDispositionFilename) {
+                _this12.setTitle(contentDispositionFilename);
+              }
 
-    if (pdfTitle) {
-      this.setTitle(`${pdfTitle} - ${contentDispositionFilename || document.title}`);
-    } else if (contentDispositionFilename) {
-      this.setTitle(contentDispositionFilename);
-    }
+              if (info.IsAcroFormPresent) {
+                console.warn("Warning: AcroForm/XFA is not supported");
 
-    if (info.IsAcroFormPresent) {
-      console.warn("Warning: AcroForm/XFA is not supported");
-      this.fallback(_pdfjsLib.UNSUPPORTED_FEATURES.forms);
-    }
+                _this12.fallback(_pdfjsLib.UNSUPPORTED_FEATURES.forms);
+              }
 
-    let versionId = "other";
-    const KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
+              versionId = "other";
+              KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
 
-    if (KNOWN_VERSIONS.includes(info.PDFFormatVersion)) {
-      versionId = `v${info.PDFFormatVersion.replace(".", "_")}`;
-    }
+              if (KNOWN_VERSIONS.includes(info.PDFFormatVersion)) {
+                versionId = "v".concat(info.PDFFormatVersion.replace(".", "_"));
+              }
 
-    let generatorId = "other";
-    const KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
+              generatorId = "other";
+              KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
 
-    if (info.Producer) {
-      const producer = info.Producer.toLowerCase();
-      KNOWN_GENERATORS.some(function (generator) {
-        if (!producer.includes(generator)) {
-          return false;
-        }
+              if (info.Producer) {
+                producer = info.Producer.toLowerCase();
+                KNOWN_GENERATORS.some(function (generator) {
+                  if (!producer.includes(generator)) {
+                    return false;
+                  }
 
-        generatorId = generator.replace(/[ .\-]/g, "_");
-        return true;
-      });
-    }
+                  generatorId = generator.replace(/[ .\-]/g, "_");
+                  return true;
+                });
+              }
 
-    let formType = null;
+              formType = null;
 
-    if (info.IsAcroFormPresent) {
-      formType = info.IsXFAPresent ? "xfa" : "acroform";
-    }
+              if (info.IsAcroFormPresent) {
+                formType = info.IsXFAPresent ? "xfa" : "acroform";
+              }
 
-    this.externalServices.reportTelemetry({
-      type: "documentInfo",
-      version: versionId,
-      generator: generatorId,
-      formType
-    });
+              _this12.externalServices.reportTelemetry({
+                type: "documentInfo",
+                version: versionId,
+                generator: generatorId,
+                formType: formType
+              });
+
+            case 27:
+            case "end":
+              return _context10.stop();
+          }
+        }
+      }, _callee10);
+    }))();
   },
+  _initializePageLabels: function _initializePageLabels(pdfDocument) {
+    var _this13 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+      var labels, numLabels, i, pdfViewer, pdfThumbnailViewer, toolbar;
+      return _regenerator["default"].wrap(function _callee11$(_context11) {
+        while (1) {
+          switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 2;
+              return pdfDocument.getPageLabels();
+
+            case 2:
+              labels = _context11.sent;
+
+              if (!(pdfDocument !== _this13.pdfDocument)) {
+                _context11.next = 5;
+                break;
+              }
 
-  async _initializePageLabels(pdfDocument) {
-    const labels = await pdfDocument.getPageLabels();
+              return _context11.abrupt("return");
 
-    if (pdfDocument !== this.pdfDocument) {
-      return;
-    }
+            case 5:
+              if (!(!labels || _app_options.AppOptions.get("disablePageLabels"))) {
+                _context11.next = 7;
+                break;
+              }
 
-    if (!labels || _app_options.AppOptions.get("disablePageLabels")) {
-      return;
-    }
+              return _context11.abrupt("return");
 
-    const numLabels = labels.length;
+            case 7:
+              numLabels = labels.length;
 
-    if (numLabels !== this.pagesCount) {
-      console.error("The number of Page Labels does not match the number of pages in the document.");
-      return;
-    }
+              if (!(numLabels !== _this13.pagesCount)) {
+                _context11.next = 11;
+                break;
+              }
 
-    let i = 0;
+              console.error("The number of Page Labels does not match the number of pages in the document.");
+              return _context11.abrupt("return");
 
-    while (i < numLabels && labels[i] === (i + 1).toString()) {
-      i++;
-    }
+            case 11:
+              i = 0;
 
-    if (i === numLabels) {
-      return;
-    }
+              while (i < numLabels && labels[i] === (i + 1).toString()) {
+                i++;
+              }
+
+              if (!(i === numLabels)) {
+                _context11.next = 15;
+                break;
+              }
 
-    const {
-      pdfViewer,
-      pdfThumbnailViewer,
-      toolbar
-    } = this;
-    pdfViewer.setPageLabels(labels);
-    pdfThumbnailViewer.setPageLabels(labels);
-    toolbar.setPagesCount(numLabels, true);
-    toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
+              return _context11.abrupt("return");
+
+            case 15:
+              pdfViewer = _this13.pdfViewer, pdfThumbnailViewer = _this13.pdfThumbnailViewer, toolbar = _this13.toolbar;
+              pdfViewer.setPageLabels(labels);
+              pdfThumbnailViewer.setPageLabels(labels);
+              toolbar.setPagesCount(numLabels, true);
+              toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
+
+            case 20:
+            case "end":
+              return _context11.stop();
+          }
+        }
+      }, _callee11);
+    }))();
   },
+  _initializePdfHistory: function _initializePdfHistory(_ref5) {
+    var fingerprint = _ref5.fingerprint,
+        viewOnLoad = _ref5.viewOnLoad,
+        _ref5$initialDest = _ref5.initialDest,
+        initialDest = _ref5$initialDest === void 0 ? null : _ref5$initialDest;
 
-  _initializePdfHistory({
-    fingerprint,
-    viewOnLoad,
-    initialDest = null
-  }) {
     if (this.isViewerEmbedded || _app_options.AppOptions.get("disableHistory")) {
       return;
     }
 
     this.pdfHistory.initialize({
-      fingerprint,
+      fingerprint: fingerprint,
       resetHistory: viewOnLoad === ViewOnLoad.INITIAL,
       updateUrl: _app_options.AppOptions.get("historyUpdateUrl")
     });
@@ -1405,42 +1775,71 @@ const PDFViewerApplication = {
       });
     }
   },
+  _initializePermissions: function _initializePermissions(pdfDocument) {
+    var _this14 = this;
+
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+      var permissions;
+      return _regenerator["default"].wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              _context12.next = 2;
+              return pdfDocument.getPermissions();
+
+            case 2:
+              permissions = _context12.sent;
+
+              if (!(pdfDocument !== _this14.pdfDocument)) {
+                _context12.next = 5;
+                break;
+              }
 
-  async _initializePermissions(pdfDocument) {
-    const permissions = await pdfDocument.getPermissions();
+              return _context12.abrupt("return");
 
-    if (pdfDocument !== this.pdfDocument) {
-      return;
-    }
+            case 5:
+              if (!(!permissions || !_app_options.AppOptions.get("enablePermissions"))) {
+                _context12.next = 7;
+                break;
+              }
 
-    if (!permissions || !_app_options.AppOptions.get("enablePermissions")) {
-      return;
-    }
+              return _context12.abrupt("return");
 
-    if (!permissions.includes(_pdfjsLib.PermissionFlag.COPY)) {
-      this.appConfig.viewerContainer.classList.add(ENABLE_PERMISSIONS_CLASS);
-    }
+            case 7:
+              if (!permissions.includes(_pdfjsLib.PermissionFlag.COPY)) {
+                _this14.appConfig.viewerContainer.classList.add(ENABLE_PERMISSIONS_CLASS);
+              }
+
+            case 8:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12);
+    }))();
   },
+  setInitialView: function setInitialView(storedHash) {
+    var _this15 = this;
+
+    var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        rotation = _ref6.rotation,
+        sidebarView = _ref6.sidebarView,
+        scrollMode = _ref6.scrollMode,
+        spreadMode = _ref6.spreadMode;
 
-  setInitialView(storedHash, {
-    rotation,
-    sidebarView,
-    scrollMode,
-    spreadMode
-  } = {}) {
-    const setRotation = angle => {
+    var setRotation = function setRotation(angle) {
       if ((0, _ui_utils.isValidRotation)(angle)) {
-        this.pdfViewer.pagesRotation = angle;
+        _this15.pdfViewer.pagesRotation = angle;
       }
     };
 
-    const setViewerModes = (scroll, spread) => {
+    var setViewerModes = function setViewerModes(scroll, spread) {
       if ((0, _ui_utils.isValidScrollMode)(scroll)) {
-        this.pdfViewer.scrollMode = scroll;
+        _this15.pdfViewer.scrollMode = scroll;
       }
 
       if ((0, _ui_utils.isValidSpreadMode)(spread)) {
-        this.pdfViewer.spreadMode = spread;
+        _this15.pdfViewer.spreadMode = spread;
       }
     };
 
@@ -1465,8 +1864,7 @@ const PDFViewerApplication = {
       this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
     }
   },
-
-  cleanup() {
+  cleanup: function cleanup() {
     if (!this.pdfDocument) {
       return;
     }
@@ -1478,35 +1876,35 @@ const PDFViewerApplication = {
       this.pdfDocument.cleanup();
     }
   },
-
-  forceRendering() {
+  forceRendering: function forceRendering() {
     this.pdfRenderingQueue.printing = this.printing;
     this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.isThumbnailViewVisible;
     this.pdfRenderingQueue.renderHighestPriority();
   },
+  beforePrint: function beforePrint() {
+    var _this16 = this;
 
-  beforePrint() {
     if (this.printService) {
       return;
     }
 
     if (!this.supportsPrinting) {
-      this.l10n.get("printing_not_supported", null, "Warning: Printing is not fully supported by this browser.").then(printMessage => {
-        this.error(printMessage);
+      this.l10n.get("printing_not_supported", null, "Warning: Printing is not fully supported by this browser.").then(function (printMessage) {
+        _this16.error(printMessage);
       });
       return;
     }
 
     if (!this.pdfViewer.pageViewsReady) {
-      this.l10n.get("printing_not_ready", null, "Warning: The PDF is not fully loaded for printing.").then(notReadyMessage => {
+      this.l10n.get("printing_not_ready", null, "Warning: The PDF is not fully loaded for printing.").then(function (notReadyMessage) {
         window.alert(notReadyMessage);
       });
       return;
     }
 
-    const pagesOverview = this.pdfViewer.getPagesOverview();
-    const printContainer = this.appConfig.printContainer;
-    const printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, this.l10n);
+    var pagesOverview = this.pdfViewer.getPagesOverview();
+    var printContainer = this.appConfig.printContainer;
+    var printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, this.l10n);
     this.printService = printService;
     this.forceRendering();
     printService.layout();
@@ -1514,8 +1912,7 @@ const PDFViewerApplication = {
       type: "print"
     });
   },
-
-  afterPrint() {
+  afterPrint: function afterPrint() {
     if (this.printService) {
       this.printService.destroy();
       this.printService = null;
@@ -1523,29 +1920,24 @@ const PDFViewerApplication = {
 
     this.forceRendering();
   },
-
-  rotatePages(delta) {
+  rotatePages: function rotatePages(delta) {
     if (!this.pdfDocument) {
       return;
     }
 
-    const newRotation = (this.pdfViewer.pagesRotation + 360 + delta) % 360;
+    var newRotation = (this.pdfViewer.pagesRotation + 360 + delta) % 360;
     this.pdfViewer.pagesRotation = newRotation;
   },
-
-  requestPresentationMode() {
+  requestPresentationMode: function requestPresentationMode() {
     if (!this.pdfPresentationMode) {
       return;
     }
 
     this.pdfPresentationMode.request();
   },
-
-  bindEvents() {
-    const {
-      eventBus,
-      _boundEvents
-    } = this;
+  bindEvents: function bindEvents() {
+    var eventBus = this.eventBus,
+        _boundEvents = this._boundEvents;
     _boundEvents.beforePrint = this.beforePrint.bind(this);
     _boundEvents.afterPrint = this.afterPrint.bind(this);
 
@@ -1625,33 +2017,30 @@ const PDFViewerApplication = {
 
     eventBus._on("openfile", webViewerOpenFile);
   },
+  bindWindowEvents: function bindWindowEvents() {
+    var eventBus = this.eventBus,
+        _boundEvents = this._boundEvents;
 
-  bindWindowEvents() {
-    const {
-      eventBus,
-      _boundEvents
-    } = this;
-
-    _boundEvents.windowResize = () => {
+    _boundEvents.windowResize = function () {
       eventBus.dispatch("resize", {
         source: window
       });
     };
 
-    _boundEvents.windowHashChange = () => {
+    _boundEvents.windowHashChange = function () {
       eventBus.dispatch("hashchange", {
         source: window,
         hash: document.location.hash.substring(1)
       });
     };
 
-    _boundEvents.windowBeforePrint = () => {
+    _boundEvents.windowBeforePrint = function () {
       eventBus.dispatch("beforeprint", {
         source: window
       });
     };
 
-    _boundEvents.windowAfterPrint = () => {
+    _boundEvents.windowAfterPrint = function () {
       eventBus.dispatch("afterprint", {
         source: window
       });
@@ -1668,12 +2057,9 @@ const PDFViewerApplication = {
     window.addEventListener("beforeprint", _boundEvents.windowBeforePrint);
     window.addEventListener("afterprint", _boundEvents.windowAfterPrint);
   },
-
-  unbindEvents() {
-    const {
-      eventBus,
-      _boundEvents
-    } = this;
+  unbindEvents: function unbindEvents() {
+    var eventBus = this.eventBus,
+        _boundEvents = this._boundEvents;
 
     eventBus._off("resize", webViewerResize);
 
@@ -1754,11 +2140,8 @@ const PDFViewerApplication = {
     _boundEvents.beforePrint = null;
     _boundEvents.afterPrint = null;
   },
-
-  unbindWindowEvents() {
-    const {
-      _boundEvents
-    } = this;
+  unbindWindowEvents: function unbindWindowEvents() {
+    var _boundEvents = this._boundEvents;
     window.removeEventListener("visibilitychange", webViewerVisibilityChange);
     window.removeEventListener("wheel", webViewerWheel, {
       passive: false
@@ -1774,38 +2157,36 @@ const PDFViewerApplication = {
     _boundEvents.windowBeforePrint = null;
     _boundEvents.windowAfterPrint = null;
   }
-
 };
 exports.PDFViewerApplication = PDFViewerApplication;
-let validateFileURL;
+var validateFileURL;
 {
-  const HOSTED_VIEWER_ORIGINS = ["null", "http://mozilla.github.io", "https://mozilla.github.io"];
+  var HOSTED_VIEWER_ORIGINS = ["null", "http://mozilla.github.io", "https://mozilla.github.io"];
 
-  validateFileURL = function (file) {
+  validateFileURL = function validateFileURL(file) {
     if (file === undefined) {
       return;
     }
 
     try {
-      const viewerOrigin = new URL(window.location.href).origin || "null";
+      var viewerOrigin = new URL(window.location.href).origin || "null";
 
       if (HOSTED_VIEWER_ORIGINS.includes(viewerOrigin)) {
         return;
       }
 
-      const {
-        origin,
-        protocol
-      } = new URL(file, window.location.href);
+      var _URL = new URL(file, window.location.href),
+          origin = _URL.origin,
+          protocol = _URL.protocol;
 
       if (origin !== viewerOrigin && protocol !== "blob:") {
         throw new Error("file origin does not match viewer's");
       }
     } catch (ex) {
-      const message = ex && ex.message;
-      PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(loadingErrorMessage => {
+      var message = ex && ex.message;
+      PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(function (loadingErrorMessage) {
         PDFViewerApplication.error(loadingErrorMessage, {
-          message
+          message: message
         });
       });
       throw ex;
@@ -1813,16 +2194,34 @@ let validateFileURL;
   };
 }
 
-async function loadFakeWorker() {
-  if (!_pdfjsLib.GlobalWorkerOptions.workerSrc) {
-    _pdfjsLib.GlobalWorkerOptions.workerSrc = _app_options.AppOptions.get("workerSrc");
-  }
+function loadFakeWorker() {
+  return _loadFakeWorker.apply(this, arguments);
+}
+
+function _loadFakeWorker() {
+  _loadFakeWorker = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+    return _regenerator["default"].wrap(function _callee13$(_context13) {
+      while (1) {
+        switch (_context13.prev = _context13.next) {
+          case 0:
+            if (!_pdfjsLib.GlobalWorkerOptions.workerSrc) {
+              _pdfjsLib.GlobalWorkerOptions.workerSrc = _app_options.AppOptions.get("workerSrc");
+            }
+
+            return _context13.abrupt("return", (0, _pdfjsLib.loadScript)(_pdfjsLib.PDFWorker.getWorkerSrc()));
 
-  return (0, _pdfjsLib.loadScript)(_pdfjsLib.PDFWorker.getWorkerSrc());
+          case 2:
+          case "end":
+            return _context13.stop();
+        }
+      }
+    }, _callee13);
+  }));
+  return _loadFakeWorker.apply(this, arguments);
 }
 
 function loadAndEnablePDFBug(enabledTabs) {
-  const appConfig = PDFViewerApplication.appConfig;
+  var appConfig = PDFViewerApplication.appConfig;
   return (0, _pdfjsLib.loadScript)(appConfig.debuggerScriptPath).then(function () {
     PDFBug.enable(enabledTabs);
     PDFBug.init({
@@ -1832,13 +2231,13 @@ function loadAndEnablePDFBug(enabledTabs) {
 }
 
 function webViewerInitialized() {
-  const appConfig = PDFViewerApplication.appConfig;
-  let file;
-  const queryString = document.location.search.substring(1);
-  const params = (0, _ui_utils.parseQueryString)(queryString);
+  var appConfig = PDFViewerApplication.appConfig;
+  var file;
+  var queryString = document.location.search.substring(1);
+  var params = (0, _ui_utils.parseQueryString)(queryString);
   file = "file" in params ? params.file : _app_options.AppOptions.get("defaultUrl");
   validateFileURL(file);
-  const fileInput = document.createElement("input");
+  var fileInput = document.createElement("input");
   fileInput.id = appConfig.openFileInputName;
   fileInput.className = "fileInput";
   fileInput.setAttribute("type", "file");
@@ -1853,7 +2252,7 @@ function webViewerInitialized() {
   }
 
   fileInput.addEventListener("change", function (evt) {
-    const files = evt.target.files;
+    var files = evt.target.files;
 
     if (!files || files.length === 0) {
       return;
@@ -1870,7 +2269,7 @@ function webViewerInitialized() {
   });
   appConfig.mainContainer.addEventListener("drop", function (evt) {
     evt.preventDefault();
-    const files = evt.dataTransfer.files;
+    var files = evt.dataTransfer.files;
 
     if (!files || files.length === 0) {
       return;
@@ -1885,7 +2284,7 @@ function webViewerInitialized() {
   if (!PDFViewerApplication.supportsDocumentFonts) {
     _app_options.AppOptions.set("disableFontFace", true);
 
-    PDFViewerApplication.l10n.get("web_fonts_disabled", null, "Web fonts are disabled: unable to use embedded PDF fonts.").then(msg => {
+    PDFViewerApplication.l10n.get("web_fonts_disabled", null, "Web fonts are disabled: unable to use embedded PDF fonts.").then(function (msg) {
       console.warn(msg);
     });
   }
@@ -1915,18 +2314,18 @@ function webViewerInitialized() {
   try {
     webViewerOpenFileViaURL(file);
   } catch (reason) {
-    PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(msg => {
+    PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(function (msg) {
       PDFViewerApplication.error(msg, reason);
     });
   }
 }
 
-let webViewerOpenFileViaURL;
+var webViewerOpenFileViaURL;
 {
-  webViewerOpenFileViaURL = function (file) {
+  webViewerOpenFileViaURL = function webViewerOpenFileViaURL(file) {
     if (file && file.lastIndexOf("file:", 0) === 0) {
       PDFViewerApplication.setTitleUsingUrl(file);
-      const xhr = new XMLHttpRequest();
+      var xhr = new XMLHttpRequest();
 
       xhr.onload = function () {
         PDFViewerApplication.open(new Uint8Array(xhr.response));
@@ -1945,9 +2344,7 @@ let webViewerOpenFileViaURL;
 }
 
 function webViewerResetPermissions() {
-  const {
-    appConfig
-  } = PDFViewerApplication;
+  var appConfig = PDFViewerApplication.appConfig;
 
   if (!appConfig) {
     return;
@@ -1957,9 +2354,9 @@ function webViewerResetPermissions() {
 }
 
 function webViewerPageRendered(evt) {
-  const pageNumber = evt.pageNumber;
-  const pageIndex = pageNumber - 1;
-  const pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
+  var pageNumber = evt.pageNumber;
+  var pageIndex = pageNumber - 1;
+  var pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
 
   if (pageNumber === PDFViewerApplication.page) {
     PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
@@ -1970,7 +2367,7 @@ function webViewerPageRendered(evt) {
   }
 
   if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
-    const thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
+    var thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
     thumbnailView.setImage(pageView);
   }
 
@@ -1979,7 +2376,7 @@ function webViewerPageRendered(evt) {
   }
 
   if (pageView.error) {
-    PDFViewerApplication.l10n.get("rendering_error", null, "An error occurred while rendering the page.").then(msg => {
+    PDFViewerApplication.l10n.get("rendering_error", null, "An error occurred while rendering the page.").then(function (msg) {
       PDFViewerApplication.error(msg, pageView.error);
     });
   }
@@ -1991,15 +2388,14 @@ function webViewerPageRendered(evt) {
   PDFViewerApplication.pdfDocument.getStats().then(function (stats) {
     PDFViewerApplication.externalServices.reportTelemetry({
       type: "documentStats",
-      stats
+      stats: stats
     });
   });
 }
 
-function webViewerPageMode({
-  mode
-}) {
-  let view;
+function webViewerPageMode(_ref7) {
+  var mode = _ref7.mode;
+  var view;
 
   switch (mode) {
     case "thumbs":
@@ -2028,7 +2424,7 @@ function webViewerPageMode({
 }
 
 function webViewerNamedAction(evt) {
-  const action = evt.action;
+  var action = evt.action;
 
   switch (action) {
     case "GoToPage":
@@ -2044,11 +2440,10 @@ function webViewerNamedAction(evt) {
   }
 }
 
-function webViewerPresentationModeChanged({
-  active,
-  switchInProgress
-}) {
-  let state = _ui_utils.PresentationModeState.NORMAL;
+function webViewerPresentationModeChanged(_ref8) {
+  var active = _ref8.active,
+      switchInProgress = _ref8.switchInProgress;
+  var state = _ui_utils.PresentationModeState.NORMAL;
 
   if (switchInProgress) {
     state = _ui_utils.PresentationModeState.CHANGING;
@@ -2061,16 +2456,16 @@ function webViewerPresentationModeChanged({
 
 function webViewerSidebarViewChanged(evt) {
   PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar.isThumbnailViewVisible;
-  const store = PDFViewerApplication.store;
+  var store = PDFViewerApplication.store;
 
   if (store && PDFViewerApplication.isInitialViewSet) {
-    store.set("sidebarView", evt.view).catch(function () {});
+    store.set("sidebarView", evt.view)["catch"](function () {});
   }
 }
 
 function webViewerUpdateViewarea(evt) {
-  const location = evt.location,
-        store = PDFViewerApplication.store;
+  var location = evt.location,
+      store = PDFViewerApplication.store;
 
   if (store && PDFViewerApplication.isInitialViewSet) {
     store.setMultiple({
@@ -2079,44 +2474,42 @@ function webViewerUpdateViewarea(evt) {
       scrollLeft: location.left,
       scrollTop: location.top,
       rotation: location.rotation
-    }).catch(function () {});
+    })["catch"](function () {});
   }
 
-  const href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
+  var href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
   PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
   PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
-  const currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
-  const loading = currentPage.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED;
+  var currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
+  var loading = currentPage.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED;
   PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
 }
 
 function webViewerScrollModeChanged(evt) {
-  const store = PDFViewerApplication.store;
+  var store = PDFViewerApplication.store;
 
   if (store && PDFViewerApplication.isInitialViewSet) {
-    store.set("scrollMode", evt.mode).catch(function () {});
+    store.set("scrollMode", evt.mode)["catch"](function () {});
   }
 }
 
 function webViewerSpreadModeChanged(evt) {
-  const store = PDFViewerApplication.store;
+  var store = PDFViewerApplication.store;
 
   if (store && PDFViewerApplication.isInitialViewSet) {
-    store.set("spreadMode", evt.mode).catch(function () {});
+    store.set("spreadMode", evt.mode)["catch"](function () {});
   }
 }
 
 function webViewerResize() {
-  const {
-    pdfDocument,
-    pdfViewer
-  } = PDFViewerApplication;
+  var pdfDocument = PDFViewerApplication.pdfDocument,
+      pdfViewer = PDFViewerApplication.pdfViewer;
 
   if (!pdfDocument) {
     return;
   }
 
-  const currentScaleValue = pdfViewer.currentScaleValue;
+  var currentScaleValue = pdfViewer.currentScaleValue;
 
   if (currentScaleValue === "auto" || currentScaleValue === "page-fit" || currentScaleValue === "page-width") {
     pdfViewer.currentScaleValue = currentScaleValue;
@@ -2126,7 +2519,7 @@ function webViewerResize() {
 }
 
 function webViewerHashchange(evt) {
-  const hash = evt.hash;
+  var hash = evt.hash;
 
   if (!hash) {
     return;
@@ -2139,21 +2532,21 @@ function webViewerHashchange(evt) {
   }
 }
 
-let webViewerFileInputChange, webViewerOpenFile;
+var webViewerFileInputChange, webViewerOpenFile;
 {
-  webViewerFileInputChange = function (evt) {
+  webViewerFileInputChange = function webViewerFileInputChange(evt) {
     if (PDFViewerApplication.pdfViewer && PDFViewerApplication.pdfViewer.isInPresentationMode) {
       return;
     }
 
-    const file = evt.fileInput.files[0];
+    var file = evt.fileInput.files[0];
 
     if (!_app_options.AppOptions.get("disableCreateObjectURL")) {
-      let url = URL.createObjectURL(file);
+      var url = URL.createObjectURL(file);
 
       if (file.name) {
         url = {
-          url,
+          url: url,
           originalUrl: file.name
         };
       }
@@ -2161,25 +2554,25 @@ let webViewerFileInputChange, webViewerOpenFile;
       PDFViewerApplication.open(url);
     } else {
       PDFViewerApplication.setTitleUsingUrl(file.name);
-      const fileReader = new FileReader();
+      var fileReader = new FileReader();
 
       fileReader.onload = function webViewerChangeFileReaderOnload(event) {
-        const buffer = event.target.result;
+        var buffer = event.target.result;
         PDFViewerApplication.open(new Uint8Array(buffer));
       };
 
       fileReader.readAsArrayBuffer(file);
     }
 
-    const appConfig = PDFViewerApplication.appConfig;
+    var appConfig = PDFViewerApplication.appConfig;
     appConfig.toolbar.viewBookmark.setAttribute("hidden", "true");
     appConfig.secondaryToolbar.viewBookmarkButton.setAttribute("hidden", "true");
     appConfig.toolbar.download.setAttribute("hidden", "true");
     appConfig.secondaryToolbar.downloadButton.setAttribute("hidden", "true");
   };
 
-  webViewerOpenFile = function (evt) {
-    const openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
+  webViewerOpenFile = function webViewerOpenFile(evt) {
+    var openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
     document.getElementById(openFileInputName).click();
   };
 }
@@ -2229,7 +2622,7 @@ function webViewerZoomReset() {
 }
 
 function webViewerPageNumberChanged(evt) {
-  const pdfViewer = PDFViewerApplication.pdfViewer;
+  var pdfViewer = PDFViewerApplication.pdfViewer;
 
   if (evt.value !== "") {
     pdfViewer.currentPageLabel = evt.value;
@@ -2286,9 +2679,9 @@ function webViewerFindFromUrlHash(evt) {
   });
 }
 
-function webViewerUpdateFindMatchesCount({
-  matchesCount
-}) {
+function webViewerUpdateFindMatchesCount(_ref9) {
+  var matchesCount = _ref9.matchesCount;
+
   if (PDFViewerApplication.supportsIntegratedFind) {
     PDFViewerApplication.externalServices.updateFindMatchesCount(matchesCount);
   } else {
@@ -2296,16 +2689,16 @@ function webViewerUpdateFindMatchesCount({
   }
 }
 
-function webViewerUpdateFindControlState({
-  state,
-  previous,
-  matchesCount
-}) {
+function webViewerUpdateFindControlState(_ref10) {
+  var state = _ref10.state,
+      previous = _ref10.previous,
+      matchesCount = _ref10.matchesCount;
+
   if (PDFViewerApplication.supportsIntegratedFind) {
     PDFViewerApplication.externalServices.updateFindControlState({
       result: state,
       findPrevious: previous,
-      matchesCount
+      matchesCount: matchesCount
     });
   } else {
     PDFViewerApplication.findBar.updateUIState(state, previous, matchesCount);
@@ -2324,7 +2717,7 @@ function webViewerRotationChanging(evt) {
 }
 
 function webViewerPageChanging(evt) {
-  const page = evt.pageNumber;
+  var page = evt.pageNumber;
   PDFViewerApplication.toolbar.setPageNumber(page, evt.pageLabel || null);
   PDFViewerApplication.secondaryToolbar.setPageNumber(page);
 
@@ -2333,7 +2726,7 @@ function webViewerPageChanging(evt) {
   }
 
   if (typeof Stats !== "undefined" && Stats.enabled) {
-    const pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
+    var pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
 
     if (pageView && pageView.stats) {
       Stats.add(page, pageView.stats);
@@ -2347,7 +2740,7 @@ function webViewerVisibilityChange(evt) {
   }
 }
 
-let zoomDisabledTimeout = null;
+var zoomDisabledTimeout = null;
 
 function setZoomDisabledTimeout() {
   if (zoomDisabledTimeout) {
@@ -2360,10 +2753,8 @@ function setZoomDisabledTimeout() {
 }
 
 function webViewerWheel(evt) {
-  const {
-    pdfViewer,
-    supportedMouseWheelZoomModifierKeys
-  } = PDFViewerApplication;
+  var pdfViewer = PDFViewerApplication.pdfViewer,
+      supportedMouseWheelZoomModifierKeys = PDFViewerApplication.supportedMouseWheelZoomModifierKeys;
 
   if (pdfViewer.isInPresentationMode) {
     return;
@@ -2376,10 +2767,10 @@ function webViewerWheel(evt) {
       return;
     }
 
-    const previousScale = pdfViewer.currentScale;
-    const delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
-    const MOUSE_WHEEL_DELTA_PER_PAGE_SCALE = 3.0;
-    const ticks = delta * MOUSE_WHEEL_DELTA_PER_PAGE_SCALE;
+    var previousScale = pdfViewer.currentScale;
+    var delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
+    var MOUSE_WHEEL_DELTA_PER_PAGE_SCALE = 3.0;
+    var ticks = delta * MOUSE_WHEEL_DELTA_PER_PAGE_SCALE;
 
     if (ticks < 0) {
       PDFViewerApplication.zoomOut(-ticks);
@@ -2387,13 +2778,13 @@ function webViewerWheel(evt) {
       PDFViewerApplication.zoomIn(ticks);
     }
 
-    const currentScale = pdfViewer.currentScale;
+    var currentScale = pdfViewer.currentScale;
 
     if (previousScale !== currentScale) {
-      const scaleCorrectionFactor = currentScale / previousScale - 1;
-      const rect = pdfViewer.container.getBoundingClientRect();
-      const dx = evt.clientX - rect.left;
-      const dy = evt.clientY - rect.top;
+      var scaleCorrectionFactor = currentScale / previousScale - 1;
+      var rect = pdfViewer.container.getBoundingClientRect();
+      var dx = evt.clientX - rect.left;
+      var dy = evt.clientY - rect.top;
       pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
       pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
     }
@@ -2407,7 +2798,7 @@ function webViewerClick(evt) {
     return;
   }
 
-  const appConfig = PDFViewerApplication.appConfig;
+  var appConfig = PDFViewerApplication.appConfig;
 
   if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
     PDFViewerApplication.secondaryToolbar.close();
@@ -2419,11 +2810,11 @@ function webViewerKeyDown(evt) {
     return;
   }
 
-  let handled = false,
+  var handled = false,
       ensureViewerFocused = false;
-  const cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
-  const pdfViewer = PDFViewerApplication.pdfViewer;
-  const isViewerInPresentationMode = pdfViewer && pdfViewer.isInPresentationMode;
+  var cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
+  var pdfViewer = PDFViewerApplication.pdfViewer;
+  var isViewerInPresentationMode = pdfViewer && pdfViewer.isInPresentationMode;
 
   if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
     switch (evt.keyCode) {
@@ -2437,7 +2828,7 @@ function webViewerKeyDown(evt) {
 
       case 71:
         if (!PDFViewerApplication.supportsIntegratedFind) {
-          const findState = PDFViewerApplication.findController.state;
+          var findState = PDFViewerApplication.findController.state;
 
           if (findState) {
             PDFViewerApplication.findController.executeCommand("findagain", {
@@ -2507,9 +2898,7 @@ function webViewerKeyDown(evt) {
     }
   }
 
-  const {
-    eventBus
-  } = PDFViewerApplication;
+  var eventBus = PDFViewerApplication.eventBus;
 
   if (cmd === 1 || cmd === 8) {
     switch (evt.keyCode) {
@@ -2554,8 +2943,8 @@ function webViewerKeyDown(evt) {
     return;
   }
 
-  const curElement = document.activeElement || document.querySelector(":focus");
-  const curElementTagName = curElement && curElement.tagName.toUpperCase();
+  var curElement = document.activeElement || document.querySelector(":focus");
+  var curElementTagName = curElement && curElement.tagName.toUpperCase();
 
   if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" || curElementTagName === "SELECT" || curElement && curElement.isContentEditable) {
     if (evt.keyCode !== 27) {
@@ -2564,7 +2953,7 @@ function webViewerKeyDown(evt) {
   }
 
   if (cmd === 0) {
-    let turnPage = 0,
+    var turnPage = 0,
         turnOnlyIfPageFit = false;
 
     switch (evt.keyCode) {
@@ -2760,14 +3149,12 @@ function apiPageModeToSidebarView(mode) {
   return _pdf_sidebar.SidebarView.NONE;
 }
 
-const PDFPrintServiceFactory = {
+var PDFPrintServiceFactory = {
   instance: {
     supportsPrinting: false,
-
-    createPrintService() {
+    createPrintService: function createPrintService() {
       throw new Error("Not implemented: createPrintService");
     }
-
   }
 };
 exports.PDFPrintServiceFactory = PDFPrintServiceFactory;
@@ -2779,6 +3166,628 @@ exports.PDFPrintServiceFactory = PDFPrintServiceFactory;
 "use strict";
 
 
+module.exports = __webpack_require__(3);
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(module) {
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var runtime = function (exports) {
+  "use strict";
+
+  var Op = Object.prototype;
+  var hasOwn = Op.hasOwnProperty;
+  var undefined;
+  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+    var generator = Object.create(protoGenerator.prototype);
+    var context = new Context(tryLocsList || []);
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+    return generator;
+  }
+
+  exports.wrap = wrap;
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+  var ContinueSentinel = {};
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {}
+
+  var IteratorPrototype = {};
+
+  IteratorPrototype[iteratorSymbol] = function () {
+    return this;
+  };
+
+  var getProto = Object.getPrototypeOf;
+  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+    IteratorPrototype = NativeIteratorPrototype;
+  }
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      prototype[method] = function (arg) {
+        return this._invoke(method, arg);
+      };
+    });
+  }
+
+  exports.isGeneratorFunction = function (genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+  };
+
+  exports.mark = function (genFun) {
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
+
+      if (!(toStringTagSymbol in genFun)) {
+        genFun[toStringTagSymbol] = "GeneratorFunction";
+      }
+    }
+
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
+
+  exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  };
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+
+        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
+          return PromiseImpl.resolve(value.__await).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped;
+          resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+    }
+
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    }
+
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+
+  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+    return this;
+  };
+
+  exports.AsyncIterator = AsyncIterator;
+
+  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    if (PromiseImpl === void 0) PromiseImpl = Promise;
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        }
+
+        return doneResult();
+      }
+
+      context.method = method;
+      context.arg = arg;
+
+      while (true) {
+        var delegate = context.delegate;
+
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+
+        if (context.method === "next") {
+          context.sent = context._sent = context.arg;
+        } else if (context.method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw context.arg;
+          }
+
+          context.dispatchException(context.arg);
+        } else if (context.method === "return") {
+          context.abrupt("return", context.arg);
+        }
+
+        state = GenStateExecuting;
+        var record = tryCatch(innerFn, self, context);
+
+        if (record.type === "normal") {
+          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+          if (record.arg === ContinueSentinel) {
+            continue;
+          }
+
+          return {
+            value: record.arg,
+            done: context.done
+          };
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          context.method = "throw";
+          context.arg = record.arg;
+        }
+      }
+    };
+  }
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (method === undefined) {
+      context.delegate = null;
+
+      if (context.method === "throw") {
+        if (delegate.iterator["return"]) {
+          context.method = "return";
+          context.arg = undefined;
+          maybeInvokeDelegate(delegate, context);
+
+          if (context.method === "throw") {
+            return ContinueSentinel;
+          }
+        }
+
+        context.method = "throw";
+        context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+
+    if (record.type === "throw") {
+      context.method = "throw";
+      context.arg = record.arg;
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    var info = record.arg;
+
+    if (!info) {
+      context.method = "throw";
+      context.arg = new TypeError("iterator result is not an object");
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    if (info.done) {
+      context[delegate.resultName] = info.value;
+      context.next = delegate.nextLoc;
+
+      if (context.method !== "return") {
+        context.method = "next";
+        context.arg = undefined;
+      }
+    } else {
+      return info;
+    }
+
+    context.delegate = null;
+    return ContinueSentinel;
+  }
+
+  defineIteratorMethods(Gp);
+  Gp[toStringTagSymbol] = "Generator";
+
+  Gp[iteratorSymbol] = function () {
+    return this;
+  };
+
+  Gp.toString = function () {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) {
+      keys.push(key);
+    }
+
+    keys.reverse();
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    return {
+      next: doneResult
+    };
+  }
+
+  exports.values = values;
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: true
+    };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+    reset: function reset(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+      this.method = "next";
+      this.arg = undefined;
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+    stop: function stop() {
+      this.done = true;
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+    dispatchException: function dispatchException(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+
+        if (caught) {
+          context.method = "next";
+          context.arg = undefined;
+        }
+
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+    abrupt: function abrupt(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.method = "next";
+        this.next = finallyEntry.finallyLoc;
+        return ContinueSentinel;
+      }
+
+      return this.complete(record);
+    },
+    complete: function complete(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" || record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = this.arg = record.arg;
+        this.method = "return";
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+    finish: function finish(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+    "catch": function _catch(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      }
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      if (this.method === "next") {
+        this.arg = undefined;
+      }
+
+      return ContinueSentinel;
+    }
+  };
+  return exports;
+}(( false ? undefined : _typeof(module)) === "object" ? module.exports : {});
+
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  Function("r", "regeneratorRuntime = r")(runtime);
+}
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(4)(module)))
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function (module) {
+  if (!module.webpackPolyfill) {
+    module.deprecate = function () {};
+
+    module.paths = [];
+    if (!module.children) module.children = [];
+    Object.defineProperty(module, "loaded", {
+      enumerable: true,
+      get: function get() {
+        return module.l;
+      }
+    });
+    Object.defineProperty(module, "id", {
+      enumerable: true,
+      get: function get() {
+        return module.i;
+      }
+    });
+    module.webpackPolyfill = 1;
+  }
+
+  return module;
+};
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -2803,57 +3812,86 @@ exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
 exports.waitOnEventOrTimeout = waitOnEventOrTimeout;
 exports.moveToEndOfArray = moveToEndOfArray;
 exports.WaitOnType = exports.animationStarted = exports.ProgressBar = exports.EventBus = exports.NullL10n = exports.SpreadMode = exports.ScrollMode = exports.TextLayerMode = exports.RendererType = exports.PresentationModeState = exports.VERTICAL_PADDING = exports.SCROLLBAR_PADDING = exports.MAX_AUTO_SCALE = exports.UNKNOWN_SCALE = exports.MAX_SCALE = exports.MIN_SCALE = exports.DEFAULT_SCALE = exports.DEFAULT_SCALE_VALUE = exports.CSS_UNITS = exports.AutoPrintRegExp = void 0;
-const CSS_UNITS = 96.0 / 72.0;
+
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var CSS_UNITS = 96.0 / 72.0;
 exports.CSS_UNITS = CSS_UNITS;
-const DEFAULT_SCALE_VALUE = "auto";
+var DEFAULT_SCALE_VALUE = "auto";
 exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
-const DEFAULT_SCALE = 1.0;
+var DEFAULT_SCALE = 1.0;
 exports.DEFAULT_SCALE = DEFAULT_SCALE;
-const MIN_SCALE = 0.1;
+var MIN_SCALE = 0.1;
 exports.MIN_SCALE = MIN_SCALE;
-const MAX_SCALE = 10.0;
+var MAX_SCALE = 10.0;
 exports.MAX_SCALE = MAX_SCALE;
-const UNKNOWN_SCALE = 0;
+var UNKNOWN_SCALE = 0;
 exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
-const MAX_AUTO_SCALE = 1.25;
+var MAX_AUTO_SCALE = 1.25;
 exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
-const SCROLLBAR_PADDING = 40;
+var SCROLLBAR_PADDING = 40;
 exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
-const VERTICAL_PADDING = 5;
+var VERTICAL_PADDING = 5;
 exports.VERTICAL_PADDING = VERTICAL_PADDING;
-const PresentationModeState = {
+var PresentationModeState = {
   UNKNOWN: 0,
   NORMAL: 1,
   CHANGING: 2,
   FULLSCREEN: 3
 };
 exports.PresentationModeState = PresentationModeState;
-const RendererType = {
+var RendererType = {
   CANVAS: "canvas",
   SVG: "svg"
 };
 exports.RendererType = RendererType;
-const TextLayerMode = {
+var TextLayerMode = {
   DISABLE: 0,
   ENABLE: 1,
   ENABLE_ENHANCE: 2
 };
 exports.TextLayerMode = TextLayerMode;
-const ScrollMode = {
+var ScrollMode = {
   UNKNOWN: -1,
   VERTICAL: 0,
   HORIZONTAL: 1,
   WRAPPED: 2
 };
 exports.ScrollMode = ScrollMode;
-const SpreadMode = {
+var SpreadMode = {
   UNKNOWN: -1,
   NONE: 0,
   ODD: 1,
   EVEN: 2
 };
 exports.SpreadMode = SpreadMode;
-const AutoPrintRegExp = /\bprint\s*\(/;
+var AutoPrintRegExp = /\bprint\s*\(/;
 exports.AutoPrintRegExp = AutoPrintRegExp;
 
 function formatL10nValue(text, args) {
@@ -2861,33 +3899,80 @@ function formatL10nValue(text, args) {
     return text;
   }
 
-  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
+  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, function (all, name) {
     return name in args ? args[name] : "{{" + name + "}}";
   });
 }
 
-const NullL10n = {
-  async getLanguage() {
-    return "en-us";
-  },
+var NullL10n = {
+  getLanguage: function getLanguage() {
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      return _regenerator["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", "en-us");
 
-  async getDirection() {
-    return "ltr";
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }))();
   },
-
-  async get(property, args, fallback) {
-    return formatL10nValue(fallback, args);
+  getDirection: function getDirection() {
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", "ltr");
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }))();
   },
-
-  async translate(element) {}
-
+  get: function get(property, args, fallback) {
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      return _regenerator["default"].wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", formatL10nValue(fallback, args));
+
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }))();
+  },
+  translate: function translate(element) {
+    return _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      return _regenerator["default"].wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }))();
+  }
 };
 exports.NullL10n = NullL10n;
 
 function getOutputScale(ctx) {
-  const devicePixelRatio = window.devicePixelRatio || 1;
-  const backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.msBackingStorePixelRatio || ctx.oBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
-  const pixelRatio = devicePixelRatio / backingStoreRatio;
+  var devicePixelRatio = window.devicePixelRatio || 1;
+  var backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.msBackingStorePixelRatio || ctx.oBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
+  var pixelRatio = devicePixelRatio / backingStoreRatio;
   return {
     sx: pixelRatio,
     sy: pixelRatio,
@@ -2895,16 +3980,17 @@ function getOutputScale(ctx) {
   };
 }
 
-function scrollIntoView(element, spot, skipOverflowHiddenElements = false) {
-  let parent = element.offsetParent;
+function scrollIntoView(element, spot) {
+  var skipOverflowHiddenElements = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var parent = element.offsetParent;
 
   if (!parent) {
     console.error("offsetParent is not set -- cannot scroll");
     return;
   }
 
-  let offsetY = element.offsetTop + element.clientTop;
-  let offsetX = element.offsetLeft + element.clientLeft;
+  var offsetY = element.offsetTop + element.clientTop;
+  var offsetX = element.offsetLeft + element.clientLeft;
 
   while (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent.scrollWidth || skipOverflowHiddenElements && getComputedStyle(parent).overflow === "hidden") {
     if (parent.dataset._scaleY) {
@@ -2936,23 +4022,23 @@ function scrollIntoView(element, spot, skipOverflowHiddenElements = false) {
 }
 
 function watchScroll(viewAreaElement, callback) {
-  const debounceScroll = function (evt) {
+  var debounceScroll = function debounceScroll(evt) {
     if (rAF) {
       return;
     }
 
     rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
       rAF = null;
-      const currentX = viewAreaElement.scrollLeft;
-      const lastX = state.lastX;
+      var currentX = viewAreaElement.scrollLeft;
+      var lastX = state.lastX;
 
       if (currentX !== lastX) {
         state.right = currentX > lastX;
       }
 
       state.lastX = currentX;
-      const currentY = viewAreaElement.scrollTop;
-      const lastY = state.lastY;
+      var currentY = viewAreaElement.scrollTop;
+      var lastY = state.lastY;
 
       if (currentY !== lastY) {
         state.down = currentY > lastY;
@@ -2963,26 +4049,26 @@ function watchScroll(viewAreaElement, callback) {
     });
   };
 
-  const state = {
+  var state = {
     right: true,
     down: true,
     lastX: viewAreaElement.scrollLeft,
     lastY: viewAreaElement.scrollTop,
     _eventHandler: debounceScroll
   };
-  let rAF = null;
+  var rAF = null;
   viewAreaElement.addEventListener("scroll", debounceScroll, true);
   return state;
 }
 
 function parseQueryString(query) {
-  const parts = query.split("&");
-  const params = Object.create(null);
+  var parts = query.split("&");
+  var params = Object.create(null);
 
-  for (let i = 0, ii = parts.length; i < ii; ++i) {
-    const param = parts[i].split("=");
-    const key = param[0].toLowerCase();
-    const value = param.length > 1 ? param[1] : null;
+  for (var i = 0, ii = parts.length; i < ii; ++i) {
+    var param = parts[i].split("=");
+    var key = param[0].toLowerCase();
+    var value = param.length > 1 ? param[1] : null;
     params[decodeURIComponent(key)] = decodeURIComponent(value);
   }
 
@@ -2990,8 +4076,8 @@ function parseQueryString(query) {
 }
 
 function binarySearchFirstItem(items, condition) {
-  let minIndex = 0;
-  let maxIndex = items.length - 1;
+  var minIndex = 0;
+  var maxIndex = items.length - 1;
 
   if (maxIndex < 0 || !condition(items[maxIndex])) {
     return items.length;
@@ -3002,8 +4088,8 @@ function binarySearchFirstItem(items, condition) {
   }
 
   while (minIndex < maxIndex) {
-    const currentIndex = minIndex + maxIndex >> 1;
-    const currentItem = items[currentIndex];
+    var currentIndex = minIndex + maxIndex >> 1;
+    var currentItem = items[currentIndex];
 
     if (condition(currentItem)) {
       maxIndex = currentIndex;
@@ -3020,8 +4106,8 @@ function approximateFraction(x) {
     return [x, 1];
   }
 
-  const xinv = 1 / x;
-  const limit = 8;
+  var xinv = 1 / x;
+  var limit = 8;
 
   if (xinv > limit) {
     return [1, limit];
@@ -3029,15 +4115,15 @@ function approximateFraction(x) {
     return [1, xinv];
   }
 
-  const x_ = x > 1 ? xinv : x;
-  let a = 0,
+  var x_ = x > 1 ? xinv : x;
+  var a = 0,
       b = 1,
       c = 1,
       d = 1;
 
   while (true) {
-    const p = a + c,
-          q = b + d;
+    var p = a + c,
+        q = b + d;
 
     if (q > limit) {
       break;
@@ -3052,7 +4138,7 @@ function approximateFraction(x) {
     }
   }
 
-  let result;
+  var result;
 
   if (x_ - a / b < c / d - x_) {
     result = x_ === x ? [a, b] : [b, a];
@@ -3064,19 +4150,24 @@ function approximateFraction(x) {
 }
 
 function roundToDivide(x, div) {
-  const r = x % div;
+  var r = x % div;
   return r === 0 ? x : Math.round(x - r + div);
 }
 
-function getPageSizeInches({
-  view,
-  userUnit,
-  rotate
-}) {
-  const [x1, y1, x2, y2] = view;
-  const changeOrientation = rotate % 180 !== 0;
-  const width = (x2 - x1) / 72 * userUnit;
-  const height = (y2 - y1) / 72 * userUnit;
+function getPageSizeInches(_ref) {
+  var view = _ref.view,
+      userUnit = _ref.userUnit,
+      rotate = _ref.rotate;
+
+  var _view = _slicedToArray(view, 4),
+      x1 = _view[0],
+      y1 = _view[1],
+      x2 = _view[2],
+      y2 = _view[3];
+
+  var changeOrientation = rotate % 180 !== 0;
+  var width = (x2 - x1) / 72 * userUnit;
+  var height = (y2 - y1) / 72 * userUnit;
   return {
     width: changeOrientation ? height : width,
     height: changeOrientation ? width : height
@@ -3088,15 +4179,15 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
     return index;
   }
 
-  let elt = views[index].div;
-  let pageTop = elt.offsetTop + elt.clientTop;
+  var elt = views[index].div;
+  var pageTop = elt.offsetTop + elt.clientTop;
 
   if (pageTop >= top) {
     elt = views[index - 1].div;
     pageTop = elt.offsetTop + elt.clientTop;
   }
 
-  for (let i = index - 2; i >= 0; --i) {
+  for (var i = index - 2; i >= 0; --i) {
     elt = views[i].div;
 
     if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
@@ -3109,43 +4200,45 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
   return index;
 }
 
-function getVisibleElements(scrollEl, views, sortByVisibility = false, horizontal = false) {
-  const top = scrollEl.scrollTop,
-        bottom = top + scrollEl.clientHeight;
-  const left = scrollEl.scrollLeft,
-        right = left + scrollEl.clientWidth;
+function getVisibleElements(scrollEl, views) {
+  var sortByVisibility = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var horizontal = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var top = scrollEl.scrollTop,
+      bottom = top + scrollEl.clientHeight;
+  var left = scrollEl.scrollLeft,
+      right = left + scrollEl.clientWidth;
 
   function isElementBottomAfterViewTop(view) {
-    const element = view.div;
-    const elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
+    var element = view.div;
+    var elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
     return elementBottom > top;
   }
 
   function isElementRightAfterViewLeft(view) {
-    const element = view.div;
-    const elementRight = element.offsetLeft + element.clientLeft + element.clientWidth;
+    var element = view.div;
+    var elementRight = element.offsetLeft + element.clientLeft + element.clientWidth;
     return elementRight > left;
   }
 
-  const visible = [],
-        numViews = views.length;
-  let firstVisibleElementInd = numViews === 0 ? 0 : binarySearchFirstItem(views, horizontal ? isElementRightAfterViewLeft : isElementBottomAfterViewTop);
+  var visible = [],
+      numViews = views.length;
+  var firstVisibleElementInd = numViews === 0 ? 0 : binarySearchFirstItem(views, horizontal ? isElementRightAfterViewLeft : isElementBottomAfterViewTop);
 
   if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
     firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
   }
 
-  let lastEdge = horizontal ? right : -1;
+  var lastEdge = horizontal ? right : -1;
 
-  for (let i = firstVisibleElementInd; i < numViews; i++) {
-    const view = views[i],
-          element = view.div;
-    const currentWidth = element.offsetLeft + element.clientLeft;
-    const currentHeight = element.offsetTop + element.clientTop;
-    const viewWidth = element.clientWidth,
-          viewHeight = element.clientHeight;
-    const viewRight = currentWidth + viewWidth;
-    const viewBottom = currentHeight + viewHeight;
+  for (var i = firstVisibleElementInd; i < numViews; i++) {
+    var view = views[i],
+        element = view.div;
+    var currentWidth = element.offsetLeft + element.clientLeft;
+    var currentHeight = element.offsetTop + element.clientTop;
+    var viewWidth = element.clientWidth,
+        viewHeight = element.clientHeight;
+    var viewRight = currentWidth + viewWidth;
+    var viewBottom = currentHeight + viewHeight;
 
     if (lastEdge === -1) {
       if (viewBottom >= bottom) {
@@ -3159,24 +4252,24 @@ function getVisibleElements(scrollEl, views, sortByVisibility = false, horizonta
       continue;
     }
 
-    const hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom);
-    const hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);
-    const percent = (viewHeight - hiddenHeight) * (viewWidth - hiddenWidth) * 100 / viewHeight / viewWidth | 0;
+    var hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom);
+    var hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);
+    var percent = (viewHeight - hiddenHeight) * (viewWidth - hiddenWidth) * 100 / viewHeight / viewWidth | 0;
     visible.push({
       id: view.id,
       x: currentWidth,
       y: currentHeight,
-      view,
-      percent
+      view: view,
+      percent: percent
     });
   }
 
-  const first = visible[0],
-        last = visible[visible.length - 1];
+  var first = visible[0],
+      last = visible[visible.length - 1];
 
   if (sortByVisibility) {
     visible.sort(function (a, b) {
-      const pc = a.percent - b.percent;
+      var pc = a.percent - b.percent;
 
       if (Math.abs(pc) > 0.001) {
         return -pc;
@@ -3187,8 +4280,8 @@ function getVisibleElements(scrollEl, views, sortByVisibility = false, horizonta
   }
 
   return {
-    first,
-    last,
+    first: first,
+    last: last,
     views: visible
   };
 }
@@ -3198,8 +4291,8 @@ function noContextMenuHandler(evt) {
 }
 
 function isDataSchema(url) {
-  let i = 0;
-  const ii = url.length;
+  var i = 0;
+  var ii = url.length;
 
   while (i < ii && url[i].trim() === "") {
     i++;
@@ -3208,7 +4301,9 @@ function isDataSchema(url) {
   return url.substring(i, i + 5).toLowerCase() === "data:";
 }
 
-function getPDFFileNameFromURL(url, defaultFilename = "document.pdf") {
+function getPDFFileNameFromURL(url) {
+  var defaultFilename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "document.pdf";
+
   if (typeof url !== "string") {
     return defaultFilename;
   }
@@ -3218,10 +4313,10 @@ function getPDFFileNameFromURL(url, defaultFilename = "document.pdf") {
     return defaultFilename;
   }
 
-  const reURI = /^(?:(?:[^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
-  const reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
-  const splitURI = reURI.exec(url);
-  let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
+  var reURI = /^(?:(?:[^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
+  var reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
+  var splitURI = reURI.exec(url);
+  var suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
 
   if (suggestedFilename) {
     suggestedFilename = suggestedFilename[0];
@@ -3237,17 +4332,17 @@ function getPDFFileNameFromURL(url, defaultFilename = "document.pdf") {
 }
 
 function normalizeWheelEventDelta(evt) {
-  let delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
-  const angle = Math.atan2(evt.deltaY, evt.deltaX);
+  var delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
+  var angle = Math.atan2(evt.deltaY, evt.deltaX);
 
   if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
     delta = -delta;
   }
 
-  const MOUSE_DOM_DELTA_PIXEL_MODE = 0;
-  const MOUSE_DOM_DELTA_LINE_MODE = 1;
-  const MOUSE_PIXELS_PER_LINE = 30;
-  const MOUSE_LINES_PER_PAGE = 30;
+  var MOUSE_DOM_DELTA_PIXEL_MODE = 0;
+  var MOUSE_DOM_DELTA_LINE_MODE = 1;
+  var MOUSE_PIXELS_PER_LINE = 30;
+  var MOUSE_LINES_PER_PAGE = 30;
 
   if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
     delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
@@ -3274,19 +4369,19 @@ function isPortraitOrientation(size) {
   return size.width <= size.height;
 }
 
-const WaitOnType = {
+var WaitOnType = {
   EVENT: "event",
   TIMEOUT: "timeout"
 };
 exports.WaitOnType = WaitOnType;
 
-function waitOnEventOrTimeout({
-  target,
-  name,
-  delay = 0
-}) {
+function waitOnEventOrTimeout(_ref2) {
+  var target = _ref2.target,
+      name = _ref2.name,
+      _ref2$delay = _ref2.delay,
+      delay = _ref2$delay === void 0 ? 0 : _ref2$delay;
   return new Promise(function (resolve, reject) {
-    if (typeof target !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
+    if (_typeof(target) !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
       throw new Error("waitOnEventOrTimeout - invalid parameters.");
     }
 
@@ -3304,7 +4399,7 @@ function waitOnEventOrTimeout({
       resolve(type);
     }
 
-    const eventHandler = handler.bind(null, WaitOnType.EVENT);
+    var eventHandler = handler.bind(null, WaitOnType.EVENT);
 
     if (target instanceof EventBus) {
       target._on(name, eventHandler);
@@ -3312,99 +4407,112 @@ function waitOnEventOrTimeout({
       target.addEventListener(name, eventHandler);
     }
 
-    const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
-    const timeout = setTimeout(timeoutHandler, delay);
+    var timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
+    var timeout = setTimeout(timeoutHandler, delay);
   });
 }
 
-const animationStarted = new Promise(function (resolve) {
+var animationStarted = new Promise(function (resolve) {
   window.requestAnimationFrame(resolve);
 });
 exports.animationStarted = animationStarted;
 
-function dispatchDOMEvent(eventName, args = null) {
+function dispatchDOMEvent(eventName) {
+  var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   throw new Error("Not implemented: dispatchDOMEvent");
 }
 
-class EventBus {
-  constructor(options) {
-    this._listeners = Object.create(null);
-  }
-
-  on(eventName, listener) {
-    this._on(eventName, listener, {
-      external: true
-    });
-  }
+var EventBus = /*#__PURE__*/function () {
+  function EventBus(options) {
+    _classCallCheck(this, EventBus);
 
-  off(eventName, listener) {
-    this._off(eventName, listener, {
-      external: true
-    });
+    this._listeners = Object.create(null);
   }
 
-  dispatch(eventName) {
-    const eventListeners = this._listeners[eventName];
-
-    if (!eventListeners || eventListeners.length === 0) {
-      return;
+  _createClass(EventBus, [{
+    key: "on",
+    value: function on(eventName, listener) {
+      this._on(eventName, listener, {
+        external: true
+      });
     }
+  }, {
+    key: "off",
+    value: function off(eventName, listener) {
+      this._off(eventName, listener, {
+        external: true
+      });
+    }
+  }, {
+    key: "dispatch",
+    value: function dispatch(eventName) {
+      var eventListeners = this._listeners[eventName];
 
-    const args = Array.prototype.slice.call(arguments, 1);
-    let externalListeners;
-    eventListeners.slice(0).forEach(function ({
-      listener,
-      external
-    }) {
-      if (external) {
-        if (!externalListeners) {
-          externalListeners = [];
-        }
-
-        externalListeners.push(listener);
+      if (!eventListeners || eventListeners.length === 0) {
         return;
       }
 
-      listener.apply(null, args);
-    });
+      var args = Array.prototype.slice.call(arguments, 1);
+      var externalListeners;
+      eventListeners.slice(0).forEach(function (_ref3) {
+        var listener = _ref3.listener,
+            external = _ref3.external;
+
+        if (external) {
+          if (!externalListeners) {
+            externalListeners = [];
+          }
+
+          externalListeners.push(listener);
+          return;
+        }
 
-    if (externalListeners) {
-      externalListeners.forEach(function (listener) {
         listener.apply(null, args);
       });
-      externalListeners = null;
-    }
-  }
 
-  _on(eventName, listener, options = null) {
-    let eventListeners = this._listeners[eventName];
-
-    if (!eventListeners) {
-      this._listeners[eventName] = eventListeners = [];
+      if (externalListeners) {
+        externalListeners.forEach(function (listener) {
+          listener.apply(null, args);
+        });
+        externalListeners = null;
+      }
     }
+  }, {
+    key: "_on",
+    value: function _on(eventName, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var eventListeners = this._listeners[eventName];
 
-    eventListeners.push({
-      listener,
-      external: (options && options.external) === true
-    });
-  }
-
-  _off(eventName, listener, options = null) {
-    const eventListeners = this._listeners[eventName];
+      if (!eventListeners) {
+        this._listeners[eventName] = eventListeners = [];
+      }
 
-    if (!eventListeners) {
-      return;
+      eventListeners.push({
+        listener: listener,
+        external: (options && options.external) === true
+      });
     }
+  }, {
+    key: "_off",
+    value: function _off(eventName, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var eventListeners = this._listeners[eventName];
 
-    for (let i = 0, ii = eventListeners.length; i < ii; i++) {
-      if (eventListeners[i].listener === listener) {
-        eventListeners.splice(i, 1);
+      if (!eventListeners) {
         return;
       }
+
+      for (var i = 0, ii = eventListeners.length; i < ii; i++) {
+        if (eventListeners[i].listener === listener) {
+          eventListeners.splice(i, 1);
+          return;
+        }
+      }
     }
-  }
+  }]);
 
-}
+  return EventBus;
+}();
 
 exports.EventBus = EventBus;
 
@@ -3412,12 +4520,15 @@ function clamp(v, min, max) {
   return Math.min(Math.max(v, min), max);
 }
 
-class ProgressBar {
-  constructor(id, {
-    height,
-    width,
-    units
-  } = {}) {
+var ProgressBar = /*#__PURE__*/function () {
+  function ProgressBar(id) {
+    var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        height = _ref4.height,
+        width = _ref4.width,
+        units = _ref4.units;
+
+    _classCallCheck(this, ProgressBar);
+
     this.visible = true;
     this.div = document.querySelector(id + " .progress");
     this.bar = this.div.parentNode;
@@ -3428,72 +4539,79 @@ class ProgressBar {
     this.percent = 0;
   }
 
-  _updateBar() {
-    if (this._indeterminate) {
-      this.div.classList.add("indeterminate");
-      this.div.style.width = this.width + this.units;
-      return;
-    }
-
-    this.div.classList.remove("indeterminate");
-    const progressSize = this.width * this._percent / 100;
-    this.div.style.width = progressSize + this.units;
-  }
-
-  get percent() {
-    return this._percent;
-  }
-
-  set percent(val) {
-    this._indeterminate = isNaN(val);
-    this._percent = clamp(val, 0, 100);
-
-    this._updateBar();
-  }
+  _createClass(ProgressBar, [{
+    key: "_updateBar",
+    value: function _updateBar() {
+      if (this._indeterminate) {
+        this.div.classList.add("indeterminate");
+        this.div.style.width = this.width + this.units;
+        return;
+      }
 
-  setWidth(viewer) {
-    if (!viewer) {
-      return;
+      this.div.classList.remove("indeterminate");
+      var progressSize = this.width * this._percent / 100;
+      this.div.style.width = progressSize + this.units;
     }
+  }, {
+    key: "setWidth",
+    value: function setWidth(viewer) {
+      if (!viewer) {
+        return;
+      }
 
-    const container = viewer.parentNode;
-    const scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
+      var container = viewer.parentNode;
+      var scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
 
-    if (scrollbarWidth > 0) {
-      this.bar.style.width = `calc(100% - ${scrollbarWidth}px)`;
+      if (scrollbarWidth > 0) {
+        this.bar.style.width = "calc(100% - ".concat(scrollbarWidth, "px)");
+      }
     }
-  }
+  }, {
+    key: "hide",
+    value: function hide() {
+      if (!this.visible) {
+        return;
+      }
 
-  hide() {
-    if (!this.visible) {
-      return;
+      this.visible = false;
+      this.bar.classList.add("hidden");
+      document.body.classList.remove("loadingInProgress");
     }
+  }, {
+    key: "show",
+    value: function show() {
+      if (this.visible) {
+        return;
+      }
 
-    this.visible = false;
-    this.bar.classList.add("hidden");
-    document.body.classList.remove("loadingInProgress");
-  }
-
-  show() {
-    if (this.visible) {
-      return;
+      this.visible = true;
+      document.body.classList.add("loadingInProgress");
+      this.bar.classList.remove("hidden");
     }
+  }, {
+    key: "percent",
+    get: function get() {
+      return this._percent;
+    },
+    set: function set(val) {
+      this._indeterminate = isNaN(val);
+      this._percent = clamp(val, 0, 100);
 
-    this.visible = true;
-    document.body.classList.add("loadingInProgress");
-    this.bar.classList.remove("hidden");
-  }
+      this._updateBar();
+    }
+  }]);
 
-}
+  return ProgressBar;
+}();
 
 exports.ProgressBar = ProgressBar;
 
 function moveToEndOfArray(arr, condition) {
-  const moved = [],
-        len = arr.length;
-  let write = 0;
+  var moved = [],
+      len = arr.length;
+  var write = 0;
 
-  for (let read = 0; read < len; ++read) {
+  for (var read = 0; read < len; ++read) {
     if (condition(arr[read])) {
       moved.push(arr[read]);
     } else {
@@ -3502,13 +4620,13 @@ function moveToEndOfArray(arr, condition) {
     }
   }
 
-  for (let read = 0; write < len; ++read, ++write) {
-    arr[write] = moved[read];
+  for (var _read = 0; write < len; ++_read, ++write) {
+    arr[write] = moved[_read];
   }
 }
 
 /***/ }),
-/* 3 */
+/* 6 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -3519,16 +4637,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.OptionKind = exports.AppOptions = void 0;
 
-var _viewer_compatibility = __webpack_require__(4);
+var _viewer_compatibility = __webpack_require__(7);
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-const OptionKind = {
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var OptionKind = {
   VIEWER: 0x02,
   API: 0x04,
   WORKER: 0x08,
   PREFERENCE: 0x80
 };
 exports.OptionKind = OptionKind;
-const defaultOptions = {
+var defaultOptions = {
   cursorToolOnLoad: {
     value: 0,
     kind: OptionKind.VIEWER + OptionKind.PREFERENCE
@@ -3698,74 +4824,84 @@ const defaultOptions = {
     kind: OptionKind.VIEWER
   };
 }
-const userOptions = Object.create(null);
+var userOptions = Object.create(null);
+
+var AppOptions = /*#__PURE__*/function () {
+  function AppOptions() {
+    _classCallCheck(this, AppOptions);
 
-class AppOptions {
-  constructor() {
     throw new Error("Cannot initialize AppOptions.");
   }
 
-  static get(name) {
-    const userOption = userOptions[name];
+  _createClass(AppOptions, null, [{
+    key: "get",
+    value: function get(name) {
+      var userOption = userOptions[name];
 
-    if (userOption !== undefined) {
-      return userOption;
-    }
+      if (userOption !== undefined) {
+        return userOption;
+      }
 
-    const defaultOption = defaultOptions[name];
+      var defaultOption = defaultOptions[name];
 
-    if (defaultOption !== undefined) {
-      return defaultOption.compatibility || defaultOption.value;
-    }
+      if (defaultOption !== undefined) {
+        return defaultOption.compatibility || defaultOption.value;
+      }
 
-    return undefined;
-  }
+      return undefined;
+    }
+  }, {
+    key: "getAll",
+    value: function getAll() {
+      var kind = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var options = Object.create(null);
 
-  static getAll(kind = null) {
-    const options = Object.create(null);
+      for (var name in defaultOptions) {
+        var defaultOption = defaultOptions[name];
 
-    for (const name in defaultOptions) {
-      const defaultOption = defaultOptions[name];
+        if (kind) {
+          if ((kind & defaultOption.kind) === 0) {
+            continue;
+          }
 
-      if (kind) {
-        if ((kind & defaultOption.kind) === 0) {
-          continue;
-        }
+          if (kind === OptionKind.PREFERENCE) {
+            var value = defaultOption.value,
+                valueType = _typeof(value);
 
-        if (kind === OptionKind.PREFERENCE) {
-          const value = defaultOption.value,
-                valueType = typeof value;
+            if (valueType === "boolean" || valueType === "string" || valueType === "number" && Number.isInteger(value)) {
+              options[name] = value;
+              continue;
+            }
 
-          if (valueType === "boolean" || valueType === "string" || valueType === "number" && Number.isInteger(value)) {
-            options[name] = value;
-            continue;
+            throw new Error("Invalid type for preference: ".concat(name));
           }
-
-          throw new Error(`Invalid type for preference: ${name}`);
         }
+
+        var userOption = userOptions[name];
+        options[name] = userOption !== undefined ? userOption : defaultOption.compatibility || defaultOption.value;
       }
 
-      const userOption = userOptions[name];
-      options[name] = userOption !== undefined ? userOption : defaultOption.compatibility || defaultOption.value;
+      return options;
     }
+  }, {
+    key: "set",
+    value: function set(name, value) {
+      userOptions[name] = value;
+    }
+  }, {
+    key: "remove",
+    value: function remove(name) {
+      delete userOptions[name];
+    }
+  }]);
 
-    return options;
-  }
-
-  static set(name, value) {
-    userOptions[name] = value;
-  }
-
-  static remove(name) {
-    delete userOptions[name];
-  }
-
-}
+  return AppOptions;
+}();
 
 exports.AppOptions = AppOptions;
 
 /***/ }),
-/* 4 */
+/* 7 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -3775,15 +4911,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.viewerCompatibilityParams = void 0;
-const compatibilityParams = Object.create(null);
+var compatibilityParams = Object.create(null);
 {
-  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "";
-  const platform = typeof navigator !== "undefined" && navigator.platform || "";
-  const maxTouchPoints = typeof navigator !== "undefined" && navigator.maxTouchPoints || 1;
-  const isAndroid = /Android/.test(userAgent);
-  const isIE = /Trident/.test(userAgent);
-  const isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
-  const isIOSChrome = /CriOS/.test(userAgent);
+  var userAgent = typeof navigator !== "undefined" && navigator.userAgent || "";
+  var platform = typeof navigator !== "undefined" && navigator.platform || "";
+  var maxTouchPoints = typeof navigator !== "undefined" && navigator.maxTouchPoints || 1;
+  var isAndroid = /Android/.test(userAgent);
+  var isIE = /Trident/.test(userAgent);
+  var isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
+  var isIOSChrome = /CriOS/.test(userAgent);
 
   (function checkOnBlobSupport() {
     if (isIE || isIOSChrome) {
@@ -3797,17 +4933,17 @@ const compatibilityParams = Object.create(null);
     }
   })();
 }
-const viewerCompatibilityParams = Object.freeze(compatibilityParams);
+var viewerCompatibilityParams = Object.freeze(compatibilityParams);
 exports.viewerCompatibilityParams = viewerCompatibilityParams;
 
 /***/ }),
-/* 5 */
+/* 8 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 
-let pdfjsLib;
+var pdfjsLib;
 
 if (typeof window !== "undefined" && window["pdfjs-dist/build/pdf"]) {
   pdfjsLib = window["pdfjs-dist/build/pdf"];
@@ -3818,7 +4954,7 @@ if (typeof window !== "undefined" && window["pdfjs-dist/build/pdf"]) {
 module.exports = pdfjsLib;
 
 /***/ }),
-/* 6 */
+/* 9 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -3829,21 +4965,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFCursorTools = exports.CursorTool = void 0;
 
-var _grab_to_pan = __webpack_require__(7);
+var _grab_to_pan = __webpack_require__(10);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-const CursorTool = {
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var CursorTool = {
   SELECT: 0,
   HAND: 1,
   ZOOM: 2
 };
 exports.CursorTool = CursorTool;
 
-class PDFCursorTools {
-  constructor({
-    container,
-    eventBus,
-    cursorToolOnLoad = CursorTool.SELECT
-  }) {
+var PDFCursorTools = /*#__PURE__*/function () {
+  function PDFCursorTools(_ref) {
+    var _this = this;
+
+    var container = _ref.container,
+        eventBus = _ref.eventBus,
+        _ref$cursorToolOnLoad = _ref.cursorToolOnLoad,
+        cursorToolOnLoad = _ref$cursorToolOnLoad === void 0 ? CursorTool.SELECT : _ref$cursorToolOnLoad;
+
+    _classCallCheck(this, PDFCursorTools);
+
     this.container = container;
     this.eventBus = eventBus;
     this.active = CursorTool.SELECT;
@@ -3854,95 +5001,110 @@ class PDFCursorTools {
 
     this._addEventListeners();
 
-    Promise.resolve().then(() => {
-      this.switchTool(cursorToolOnLoad);
+    Promise.resolve().then(function () {
+      _this.switchTool(cursorToolOnLoad);
     });
   }
 
-  get activeTool() {
-    return this.active;
-  }
+  _createClass(PDFCursorTools, [{
+    key: "switchTool",
+    value: function switchTool(tool) {
+      var _this2 = this;
 
-  switchTool(tool) {
-    if (this.activeBeforePresentationMode !== null) {
-      return;
-    }
+      if (this.activeBeforePresentationMode !== null) {
+        return;
+      }
 
-    if (tool === this.active) {
-      return;
-    }
+      if (tool === this.active) {
+        return;
+      }
+
+      var disableActiveTool = function disableActiveTool() {
+        switch (_this2.active) {
+          case CursorTool.SELECT:
+            break;
 
-    const disableActiveTool = () => {
-      switch (this.active) {
+          case CursorTool.HAND:
+            _this2.handTool.deactivate();
+
+            break;
+
+          case CursorTool.ZOOM:
+        }
+      };
+
+      switch (tool) {
         case CursorTool.SELECT:
+          disableActiveTool();
           break;
 
         case CursorTool.HAND:
-          this.handTool.deactivate();
+          disableActiveTool();
+          this.handTool.activate();
           break;
 
         case CursorTool.ZOOM:
+        default:
+          console.error("switchTool: \"".concat(tool, "\" is an unsupported value."));
+          return;
       }
-    };
 
-    switch (tool) {
-      case CursorTool.SELECT:
-        disableActiveTool();
-        break;
+      this.active = tool;
 
-      case CursorTool.HAND:
-        disableActiveTool();
-        this.handTool.activate();
-        break;
-
-      case CursorTool.ZOOM:
-      default:
-        console.error(`switchTool: "${tool}" is an unsupported value.`);
-        return;
+      this._dispatchEvent();
+    }
+  }, {
+    key: "_dispatchEvent",
+    value: function _dispatchEvent() {
+      this.eventBus.dispatch("cursortoolchanged", {
+        source: this,
+        tool: this.active
+      });
     }
+  }, {
+    key: "_addEventListeners",
+    value: function _addEventListeners() {
+      var _this3 = this;
 
-    this.active = tool;
+      this.eventBus._on("switchcursortool", function (evt) {
+        _this3.switchTool(evt.tool);
+      });
 
-    this._dispatchEvent();
-  }
+      this.eventBus._on("presentationmodechanged", function (evt) {
+        if (evt.switchInProgress) {
+          return;
+        }
 
-  _dispatchEvent() {
-    this.eventBus.dispatch("cursortoolchanged", {
-      source: this,
-      tool: this.active
-    });
-  }
+        var previouslyActive;
 
-  _addEventListeners() {
-    this.eventBus._on("switchcursortool", evt => {
-      this.switchTool(evt.tool);
-    });
+        if (evt.active) {
+          previouslyActive = _this3.active;
 
-    this.eventBus._on("presentationmodechanged", evt => {
-      if (evt.switchInProgress) {
-        return;
-      }
+          _this3.switchTool(CursorTool.SELECT);
 
-      let previouslyActive;
+          _this3.activeBeforePresentationMode = previouslyActive;
+        } else {
+          previouslyActive = _this3.activeBeforePresentationMode;
+          _this3.activeBeforePresentationMode = null;
 
-      if (evt.active) {
-        previouslyActive = this.active;
-        this.switchTool(CursorTool.SELECT);
-        this.activeBeforePresentationMode = previouslyActive;
-      } else {
-        previouslyActive = this.activeBeforePresentationMode;
-        this.activeBeforePresentationMode = null;
-        this.switchTool(previouslyActive);
-      }
-    });
-  }
+          _this3.switchTool(previouslyActive);
+        }
+      });
+    }
+  }, {
+    key: "activeTool",
+    get: function get() {
+      return this.active;
+    }
+  }]);
 
-}
+  return PDFCursorTools;
+}();
 
 exports.PDFCursorTools = PDFCursorTools;
 
 /***/ }),
-/* 7 */
+/* 10 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -3968,7 +5130,7 @@ function GrabToPan(options) {
   this._onmousedown = this._onmousedown.bind(this);
   this._onmousemove = this._onmousemove.bind(this);
   this._endPan = this._endPan.bind(this);
-  const overlay = this.overlay = document.createElement("div");
+  var overlay = this.overlay = document.createElement("div");
   overlay.className = "grab-to-pan-grabbing";
 }
 
@@ -4031,7 +5193,7 @@ GrabToPan.prototype = {
     this.element.addEventListener("scroll", this._endPan, true);
     event.preventDefault();
     event.stopPropagation();
-    const focusedElement = document.activeElement;
+    var focusedElement = document.activeElement;
 
     if (focusedElement && !focusedElement.contains(event.target)) {
       focusedElement.blur();
@@ -4046,10 +5208,10 @@ GrabToPan.prototype = {
       return;
     }
 
-    const xDiff = event.clientX - this.clientXStart;
-    const yDiff = event.clientY - this.clientYStart;
-    const scrollTop = this.scrollTopStart - yDiff;
-    const scrollLeft = this.scrollLeftStart - xDiff;
+    var xDiff = event.clientX - this.clientXStart;
+    var yDiff = event.clientY - this.clientYStart;
+    var scrollTop = this.scrollTopStart - yDiff;
+    var scrollLeft = this.scrollLeftStart - xDiff;
 
     if (this.element.scrollTo) {
       this.element.scrollTo({
@@ -4073,9 +5235,9 @@ GrabToPan.prototype = {
     this.overlay.remove();
   }
 };
-let matchesSelector;
+var matchesSelector;
 ["webkitM", "mozM", "msM", "oM", "m"].some(function (prefix) {
-  let name = prefix + "atches";
+  var name = prefix + "atches";
 
   if (name in document.documentElement) {
     matchesSelector = name;
@@ -4089,10 +5251,10 @@ let matchesSelector;
 
   return matchesSelector;
 });
-const isNotIEorIsIE10plus = !document.documentMode || document.documentMode > 9;
-const chrome = window.chrome;
-const isChrome15OrOpera15plus = chrome && (chrome.webstore || chrome.app);
-const isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator.userAgent);
+var isNotIEorIsIE10plus = !document.documentMode || document.documentMode > 9;
+var chrome = window.chrome;
+var isChrome15OrOpera15plus = chrome && (chrome.webstore || chrome.app);
+var isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator.userAgent);
 
 function isLeftMouseReleased(event) {
   if ("buttons" in event && isNotIEorIsIE10plus) {
@@ -4107,7 +5269,7 @@ function isLeftMouseReleased(event) {
 }
 
 /***/ }),
-/* 8 */
+/* 11 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4117,8 +5279,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PDFRenderingQueue = exports.RenderingStates = void 0;
-const CLEANUP_TIMEOUT = 30000;
-const RenderingStates = {
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var CLEANUP_TIMEOUT = 30000;
+var RenderingStates = {
   INITIAL: 0,
   RUNNING: 1,
   PAUSED: 2,
@@ -4126,8 +5295,10 @@ const RenderingStates = {
 };
 exports.RenderingStates = RenderingStates;
 
-class PDFRenderingQueue {
-  constructor() {
+var PDFRenderingQueue = /*#__PURE__*/function () {
+  function PDFRenderingQueue() {
+    _classCallCheck(this, PDFRenderingQueue);
+
     this.pdfViewer = null;
     this.pdfThumbnailViewer = null;
     this.onIdle = null;
@@ -4137,113 +5308,125 @@ class PDFRenderingQueue {
     this.isThumbnailViewEnabled = false;
   }
 
-  setViewer(pdfViewer) {
-    this.pdfViewer = pdfViewer;
-  }
-
-  setThumbnailViewer(pdfThumbnailViewer) {
-    this.pdfThumbnailViewer = pdfThumbnailViewer;
-  }
-
-  isHighestPriority(view) {
-    return this.highestPriorityPage === view.renderingId;
-  }
-
-  renderHighestPriority(currentlyVisiblePages) {
-    if (this.idleTimeout) {
-      clearTimeout(this.idleTimeout);
-      this.idleTimeout = null;
+  _createClass(PDFRenderingQueue, [{
+    key: "setViewer",
+    value: function setViewer(pdfViewer) {
+      this.pdfViewer = pdfViewer;
     }
-
-    if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
-      return;
+  }, {
+    key: "setThumbnailViewer",
+    value: function setThumbnailViewer(pdfThumbnailViewer) {
+      this.pdfThumbnailViewer = pdfThumbnailViewer;
     }
+  }, {
+    key: "isHighestPriority",
+    value: function isHighestPriority(view) {
+      return this.highestPriorityPage === view.renderingId;
+    }
+  }, {
+    key: "renderHighestPriority",
+    value: function renderHighestPriority(currentlyVisiblePages) {
+      if (this.idleTimeout) {
+        clearTimeout(this.idleTimeout);
+        this.idleTimeout = null;
+      }
 
-    if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
-      if (this.pdfThumbnailViewer.forceRendering()) {
+      if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
         return;
       }
-    }
-
-    if (this.printing) {
-      return;
-    }
 
-    if (this.onIdle) {
-      this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
-    }
-  }
+      if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
+        if (this.pdfThumbnailViewer.forceRendering()) {
+          return;
+        }
+      }
 
-  getHighestPriority(visible, views, scrolledDown) {
-    const visibleViews = visible.views;
-    const numVisible = visibleViews.length;
+      if (this.printing) {
+        return;
+      }
 
-    if (numVisible === 0) {
-      return null;
+      if (this.onIdle) {
+        this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
+      }
     }
+  }, {
+    key: "getHighestPriority",
+    value: function getHighestPriority(visible, views, scrolledDown) {
+      var visibleViews = visible.views;
+      var numVisible = visibleViews.length;
 
-    for (let i = 0; i < numVisible; ++i) {
-      const view = visibleViews[i].view;
-
-      if (!this.isViewFinished(view)) {
-        return view;
+      if (numVisible === 0) {
+        return null;
       }
-    }
 
-    if (scrolledDown) {
-      const nextPageIndex = visible.last.id;
+      for (var i = 0; i < numVisible; ++i) {
+        var view = visibleViews[i].view;
 
-      if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
-        return views[nextPageIndex];
+        if (!this.isViewFinished(view)) {
+          return view;
+        }
       }
-    } else {
-      const previousPageIndex = visible.first.id - 2;
 
-      if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
-        return views[previousPageIndex];
+      if (scrolledDown) {
+        var nextPageIndex = visible.last.id;
+
+        if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
+          return views[nextPageIndex];
+        }
+      } else {
+        var previousPageIndex = visible.first.id - 2;
+
+        if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
+          return views[previousPageIndex];
+        }
       }
-    }
 
-    return null;
-  }
+      return null;
+    }
+  }, {
+    key: "isViewFinished",
+    value: function isViewFinished(view) {
+      return view.renderingState === RenderingStates.FINISHED;
+    }
+  }, {
+    key: "renderView",
+    value: function renderView(view) {
+      var _this = this;
 
-  isViewFinished(view) {
-    return view.renderingState === RenderingStates.FINISHED;
-  }
+      switch (view.renderingState) {
+        case RenderingStates.FINISHED:
+          return false;
 
-  renderView(view) {
-    switch (view.renderingState) {
-      case RenderingStates.FINISHED:
-        return false;
+        case RenderingStates.PAUSED:
+          this.highestPriorityPage = view.renderingId;
+          view.resume();
+          break;
 
-      case RenderingStates.PAUSED:
-        this.highestPriorityPage = view.renderingId;
-        view.resume();
-        break;
+        case RenderingStates.RUNNING:
+          this.highestPriorityPage = view.renderingId;
+          break;
 
-      case RenderingStates.RUNNING:
-        this.highestPriorityPage = view.renderingId;
-        break;
+        case RenderingStates.INITIAL:
+          this.highestPriorityPage = view.renderingId;
+          view.draw()["finally"](function () {
+            _this.renderHighestPriority();
+          })["catch"](function (reason) {
+            console.error("renderView: \"".concat(reason, "\""));
+          });
+          break;
+      }
 
-      case RenderingStates.INITIAL:
-        this.highestPriorityPage = view.renderingId;
-        view.draw().finally(() => {
-          this.renderHighestPriority();
-        }).catch(reason => {
-          console.error(`renderView: "${reason}"`);
-        });
-        break;
+      return true;
     }
+  }]);
 
-    return true;
-  }
-
-}
+  return PDFRenderingQueue;
+}();
 
 exports.PDFRenderingQueue = PDFRenderingQueue;
 
 /***/ }),
-/* 9 */
+/* 12 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4254,12 +5437,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFSidebar = exports.SidebarView = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_rendering_queue = __webpack_require__(11);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _pdf_rendering_queue = __webpack_require__(8);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-const UI_NOTIFICATION_CLASS = "pdfSidebarNotification";
-const SidebarView = {
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var UI_NOTIFICATION_CLASS = "pdfSidebarNotification";
+var SidebarView = {
   UNKNOWN: -1,
   NONE: 0,
   THUMBS: 1,
@@ -4269,15 +5458,19 @@ const SidebarView = {
 };
 exports.SidebarView = SidebarView;
 
-class PDFSidebar {
-  constructor({
-    elements,
-    pdfViewer,
-    pdfThumbnailViewer,
-    eventBus,
-    l10n = _ui_utils.NullL10n,
-    disableNotification = false
-  }) {
+var PDFSidebar = /*#__PURE__*/function () {
+  function PDFSidebar(_ref) {
+    var elements = _ref.elements,
+        pdfViewer = _ref.pdfViewer,
+        pdfThumbnailViewer = _ref.pdfThumbnailViewer,
+        eventBus = _ref.eventBus,
+        _ref$l10n = _ref.l10n,
+        l10n = _ref$l10n === void 0 ? _ui_utils.NullL10n : _ref$l10n,
+        _ref$disableNotificat = _ref.disableNotification,
+        disableNotification = _ref$disableNotificat === void 0 ? false : _ref$disableNotificat;
+
+    _classCallCheck(this, PDFSidebar);
+
     this.isOpen = false;
     this.active = SidebarView.THUMBS;
     this.isInitialViewSet = false;
@@ -4300,332 +5493,363 @@ class PDFSidebar {
     this._addEventListeners();
   }
 
-  reset() {
-    this.isInitialViewSet = false;
-
-    this._hideUINotification(null);
-
-    this.switchView(SidebarView.THUMBS);
-    this.outlineButton.disabled = false;
-    this.attachmentsButton.disabled = false;
-  }
-
-  get visibleView() {
-    return this.isOpen ? this.active : SidebarView.NONE;
-  }
+  _createClass(PDFSidebar, [{
+    key: "reset",
+    value: function reset() {
+      this.isInitialViewSet = false;
 
-  get isThumbnailViewVisible() {
-    return this.isOpen && this.active === SidebarView.THUMBS;
-  }
+      this._hideUINotification(null);
 
-  get isOutlineViewVisible() {
-    return this.isOpen && this.active === SidebarView.OUTLINE;
-  }
+      this.switchView(SidebarView.THUMBS);
+      this.outlineButton.disabled = false;
+      this.attachmentsButton.disabled = false;
+    }
+  }, {
+    key: "setInitialView",
+    value: function setInitialView() {
+      var view = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SidebarView.NONE;
 
-  get isAttachmentsViewVisible() {
-    return this.isOpen && this.active === SidebarView.ATTACHMENTS;
-  }
+      if (this.isInitialViewSet) {
+        return;
+      }
 
-  setInitialView(view = SidebarView.NONE) {
-    if (this.isInitialViewSet) {
-      return;
-    }
+      this.isInitialViewSet = true;
 
-    this.isInitialViewSet = true;
+      if (view === SidebarView.NONE || view === SidebarView.UNKNOWN) {
+        this._dispatchEvent();
 
-    if (view === SidebarView.NONE || view === SidebarView.UNKNOWN) {
-      this._dispatchEvent();
+        return;
+      }
 
-      return;
+      if (!this._switchView(view, true)) {
+        this._dispatchEvent();
+      }
     }
+  }, {
+    key: "switchView",
+    value: function switchView(view) {
+      var forceOpen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-    if (!this._switchView(view, true)) {
-      this._dispatchEvent();
+      this._switchView(view, forceOpen);
     }
-  }
+  }, {
+    key: "_switchView",
+    value: function _switchView(view) {
+      var forceOpen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var isViewChanged = view !== this.active;
+      var shouldForceRendering = false;
 
-  switchView(view, forceOpen = false) {
-    this._switchView(view, forceOpen);
-  }
+      switch (view) {
+        case SidebarView.NONE:
+          if (this.isOpen) {
+            this.close();
+            return true;
+          }
 
-  _switchView(view, forceOpen = false) {
-    const isViewChanged = view !== this.active;
-    let shouldForceRendering = false;
+          return false;
 
-    switch (view) {
-      case SidebarView.NONE:
-        if (this.isOpen) {
-          this.close();
-          return true;
-        }
+        case SidebarView.THUMBS:
+          if (this.isOpen && isViewChanged) {
+            shouldForceRendering = true;
+          }
 
-        return false;
+          break;
 
-      case SidebarView.THUMBS:
-        if (this.isOpen && isViewChanged) {
-          shouldForceRendering = true;
-        }
+        case SidebarView.OUTLINE:
+          if (this.outlineButton.disabled) {
+            return false;
+          }
 
-        break;
+          break;
 
-      case SidebarView.OUTLINE:
-        if (this.outlineButton.disabled) {
-          return false;
-        }
+        case SidebarView.ATTACHMENTS:
+          if (this.attachmentsButton.disabled) {
+            return false;
+          }
 
-        break;
+          break;
 
-      case SidebarView.ATTACHMENTS:
-        if (this.attachmentsButton.disabled) {
+        default:
+          console.error("PDFSidebar._switchView: \"".concat(view, "\" is not a valid view."));
           return false;
-        }
+      }
 
-        break;
+      this.active = view;
+      this.thumbnailButton.classList.toggle("toggled", view === SidebarView.THUMBS);
+      this.outlineButton.classList.toggle("toggled", view === SidebarView.OUTLINE);
+      this.attachmentsButton.classList.toggle("toggled", view === SidebarView.ATTACHMENTS);
+      this.thumbnailView.classList.toggle("hidden", view !== SidebarView.THUMBS);
+      this.outlineView.classList.toggle("hidden", view !== SidebarView.OUTLINE);
+      this.attachmentsView.classList.toggle("hidden", view !== SidebarView.ATTACHMENTS);
 
-      default:
-        console.error(`PDFSidebar._switchView: "${view}" is not a valid view.`);
-        return false;
-    }
+      if (forceOpen && !this.isOpen) {
+        this.open();
+        return true;
+      }
 
-    this.active = view;
-    this.thumbnailButton.classList.toggle("toggled", view === SidebarView.THUMBS);
-    this.outlineButton.classList.toggle("toggled", view === SidebarView.OUTLINE);
-    this.attachmentsButton.classList.toggle("toggled", view === SidebarView.ATTACHMENTS);
-    this.thumbnailView.classList.toggle("hidden", view !== SidebarView.THUMBS);
-    this.outlineView.classList.toggle("hidden", view !== SidebarView.OUTLINE);
-    this.attachmentsView.classList.toggle("hidden", view !== SidebarView.ATTACHMENTS);
+      if (shouldForceRendering) {
+        this._updateThumbnailViewer();
 
-    if (forceOpen && !this.isOpen) {
-      this.open();
-      return true;
-    }
+        this._forceRendering();
+      }
 
-    if (shouldForceRendering) {
-      this._updateThumbnailViewer();
+      if (isViewChanged) {
+        this._dispatchEvent();
+      }
 
-      this._forceRendering();
-    }
+      this._hideUINotification(this.active);
 
-    if (isViewChanged) {
-      this._dispatchEvent();
+      return isViewChanged;
     }
+  }, {
+    key: "open",
+    value: function open() {
+      if (this.isOpen) {
+        return;
+      }
 
-    this._hideUINotification(this.active);
+      this.isOpen = true;
+      this.toggleButton.classList.add("toggled");
+      this.outerContainer.classList.add("sidebarMoving", "sidebarOpen");
 
-    return isViewChanged;
-  }
+      if (this.active === SidebarView.THUMBS) {
+        this._updateThumbnailViewer();
+      }
 
-  open() {
-    if (this.isOpen) {
-      return;
-    }
+      this._forceRendering();
 
-    this.isOpen = true;
-    this.toggleButton.classList.add("toggled");
-    this.outerContainer.classList.add("sidebarMoving", "sidebarOpen");
+      this._dispatchEvent();
 
-    if (this.active === SidebarView.THUMBS) {
-      this._updateThumbnailViewer();
+      this._hideUINotification(this.active);
     }
+  }, {
+    key: "close",
+    value: function close() {
+      if (!this.isOpen) {
+        return;
+      }
 
-    this._forceRendering();
-
-    this._dispatchEvent();
+      this.isOpen = false;
+      this.toggleButton.classList.remove("toggled");
+      this.outerContainer.classList.add("sidebarMoving");
+      this.outerContainer.classList.remove("sidebarOpen");
 
-    this._hideUINotification(this.active);
-  }
+      this._forceRendering();
 
-  close() {
-    if (!this.isOpen) {
-      return;
+      this._dispatchEvent();
     }
-
-    this.isOpen = false;
-    this.toggleButton.classList.remove("toggled");
-    this.outerContainer.classList.add("sidebarMoving");
-    this.outerContainer.classList.remove("sidebarOpen");
-
-    this._forceRendering();
-
-    this._dispatchEvent();
-  }
-
-  toggle() {
-    if (this.isOpen) {
-      this.close();
-    } else {
-      this.open();
+  }, {
+    key: "toggle",
+    value: function toggle() {
+      if (this.isOpen) {
+        this.close();
+      } else {
+        this.open();
+      }
     }
-  }
-
-  _dispatchEvent() {
-    this.eventBus.dispatch("sidebarviewchanged", {
-      source: this,
-      view: this.visibleView
-    });
-  }
-
-  _forceRendering() {
-    if (this.onToggled) {
-      this.onToggled();
-    } else {
-      this.pdfViewer.forceRendering();
-      this.pdfThumbnailViewer.forceRendering();
+  }, {
+    key: "_dispatchEvent",
+    value: function _dispatchEvent() {
+      this.eventBus.dispatch("sidebarviewchanged", {
+        source: this,
+        view: this.visibleView
+      });
     }
-  }
-
-  _updateThumbnailViewer() {
-    const {
-      pdfViewer,
-      pdfThumbnailViewer
-    } = this;
-    const pagesCount = pdfViewer.pagesCount;
-
-    for (let pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
-      const pageView = pdfViewer.getPageView(pageIndex);
-
-      if (pageView && pageView.renderingState === _pdf_rendering_queue.RenderingStates.FINISHED) {
-        const thumbnailView = pdfThumbnailViewer.getThumbnail(pageIndex);
-        thumbnailView.setImage(pageView);
+  }, {
+    key: "_forceRendering",
+    value: function _forceRendering() {
+      if (this.onToggled) {
+        this.onToggled();
+      } else {
+        this.pdfViewer.forceRendering();
+        this.pdfThumbnailViewer.forceRendering();
       }
     }
+  }, {
+    key: "_updateThumbnailViewer",
+    value: function _updateThumbnailViewer() {
+      var pdfViewer = this.pdfViewer,
+          pdfThumbnailViewer = this.pdfThumbnailViewer;
+      var pagesCount = pdfViewer.pagesCount;
 
-    pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
-  }
+      for (var pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
+        var pageView = pdfViewer.getPageView(pageIndex);
 
-  _showUINotification(view) {
-    if (this._disableNotification) {
-      return;
-    }
-
-    this.l10n.get("toggle_sidebar_notification.title", null, "Toggle Sidebar (document contains outline/attachments)").then(msg => {
-      this.toggleButton.title = msg;
-    });
+        if (pageView && pageView.renderingState === _pdf_rendering_queue.RenderingStates.FINISHED) {
+          var thumbnailView = pdfThumbnailViewer.getThumbnail(pageIndex);
+          thumbnailView.setImage(pageView);
+        }
+      }
 
-    if (!this.isOpen) {
-      this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
-    } else if (view === this.active) {
-      return;
+      pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
     }
+  }, {
+    key: "_showUINotification",
+    value: function _showUINotification(view) {
+      var _this = this;
 
-    switch (view) {
-      case SidebarView.OUTLINE:
-        this.outlineButton.classList.add(UI_NOTIFICATION_CLASS);
-        break;
+      if (this._disableNotification) {
+        return;
+      }
 
-      case SidebarView.ATTACHMENTS:
-        this.attachmentsButton.classList.add(UI_NOTIFICATION_CLASS);
-        break;
-    }
-  }
+      this.l10n.get("toggle_sidebar_notification.title", null, "Toggle Sidebar (document contains outline/attachments)").then(function (msg) {
+        _this.toggleButton.title = msg;
+      });
 
-  _hideUINotification(view) {
-    if (this._disableNotification) {
-      return;
-    }
+      if (!this.isOpen) {
+        this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
+      } else if (view === this.active) {
+        return;
+      }
 
-    const removeNotification = sidebarView => {
-      switch (sidebarView) {
+      switch (view) {
         case SidebarView.OUTLINE:
-          this.outlineButton.classList.remove(UI_NOTIFICATION_CLASS);
+          this.outlineButton.classList.add(UI_NOTIFICATION_CLASS);
           break;
 
         case SidebarView.ATTACHMENTS:
-          this.attachmentsButton.classList.remove(UI_NOTIFICATION_CLASS);
+          this.attachmentsButton.classList.add(UI_NOTIFICATION_CLASS);
           break;
       }
-    };
-
-    if (!this.isOpen && view !== null) {
-      return;
     }
+  }, {
+    key: "_hideUINotification",
+    value: function _hideUINotification(view) {
+      var _this2 = this;
 
-    this.toggleButton.classList.remove(UI_NOTIFICATION_CLASS);
+      if (this._disableNotification) {
+        return;
+      }
 
-    if (view !== null) {
-      removeNotification(view);
-      return;
-    }
+      var removeNotification = function removeNotification(sidebarView) {
+        switch (sidebarView) {
+          case SidebarView.OUTLINE:
+            _this2.outlineButton.classList.remove(UI_NOTIFICATION_CLASS);
 
-    for (view in SidebarView) {
-      removeNotification(SidebarView[view]);
-    }
+            break;
 
-    this.l10n.get("toggle_sidebar.title", null, "Toggle Sidebar").then(msg => {
-      this.toggleButton.title = msg;
-    });
-  }
+          case SidebarView.ATTACHMENTS:
+            _this2.attachmentsButton.classList.remove(UI_NOTIFICATION_CLASS);
 
-  _addEventListeners() {
-    this.viewerContainer.addEventListener("transitionend", evt => {
-      if (evt.target === this.viewerContainer) {
-        this.outerContainer.classList.remove("sidebarMoving");
+            break;
+        }
+      };
+
+      if (!this.isOpen && view !== null) {
+        return;
       }
-    });
-    this.toggleButton.addEventListener("click", () => {
-      this.toggle();
-    });
-    this.thumbnailButton.addEventListener("click", () => {
-      this.switchView(SidebarView.THUMBS);
-    });
-    this.outlineButton.addEventListener("click", () => {
-      this.switchView(SidebarView.OUTLINE);
-    });
-    this.outlineButton.addEventListener("dblclick", () => {
-      this.eventBus.dispatch("toggleoutlinetree", {
-        source: this
-      });
-    });
-    this.attachmentsButton.addEventListener("click", () => {
-      this.switchView(SidebarView.ATTACHMENTS);
-    });
 
-    this.eventBus._on("outlineloaded", evt => {
-      const outlineCount = evt.outlineCount;
-      this.outlineButton.disabled = !outlineCount;
+      this.toggleButton.classList.remove(UI_NOTIFICATION_CLASS);
 
-      if (outlineCount) {
-        this._showUINotification(SidebarView.OUTLINE);
-      } else if (this.active === SidebarView.OUTLINE) {
-        this.switchView(SidebarView.THUMBS);
+      if (view !== null) {
+        removeNotification(view);
+        return;
+      }
+
+      for (view in SidebarView) {
+        removeNotification(SidebarView[view]);
       }
-    });
 
-    this.eventBus._on("attachmentsloaded", evt => {
-      if (evt.attachmentsCount) {
-        this.attachmentsButton.disabled = false;
+      this.l10n.get("toggle_sidebar.title", null, "Toggle Sidebar").then(function (msg) {
+        _this2.toggleButton.title = msg;
+      });
+    }
+  }, {
+    key: "_addEventListeners",
+    value: function _addEventListeners() {
+      var _this3 = this;
 
-        this._showUINotification(SidebarView.ATTACHMENTS);
+      this.viewerContainer.addEventListener("transitionend", function (evt) {
+        if (evt.target === _this3.viewerContainer) {
+          _this3.outerContainer.classList.remove("sidebarMoving");
+        }
+      });
+      this.toggleButton.addEventListener("click", function () {
+        _this3.toggle();
+      });
+      this.thumbnailButton.addEventListener("click", function () {
+        _this3.switchView(SidebarView.THUMBS);
+      });
+      this.outlineButton.addEventListener("click", function () {
+        _this3.switchView(SidebarView.OUTLINE);
+      });
+      this.outlineButton.addEventListener("dblclick", function () {
+        _this3.eventBus.dispatch("toggleoutlinetree", {
+          source: _this3
+        });
+      });
+      this.attachmentsButton.addEventListener("click", function () {
+        _this3.switchView(SidebarView.ATTACHMENTS);
+      });
 
-        return;
-      }
+      this.eventBus._on("outlineloaded", function (evt) {
+        var outlineCount = evt.outlineCount;
+        _this3.outlineButton.disabled = !outlineCount;
 
-      Promise.resolve().then(() => {
-        if (this.attachmentsView.hasChildNodes()) {
-          return;
+        if (outlineCount) {
+          _this3._showUINotification(SidebarView.OUTLINE);
+        } else if (_this3.active === SidebarView.OUTLINE) {
+          _this3.switchView(SidebarView.THUMBS);
         }
+      });
 
-        this.attachmentsButton.disabled = true;
+      this.eventBus._on("attachmentsloaded", function (evt) {
+        if (evt.attachmentsCount) {
+          _this3.attachmentsButton.disabled = false;
 
-        if (this.active === SidebarView.ATTACHMENTS) {
-          this.switchView(SidebarView.THUMBS);
+          _this3._showUINotification(SidebarView.ATTACHMENTS);
+
+          return;
         }
+
+        Promise.resolve().then(function () {
+          if (_this3.attachmentsView.hasChildNodes()) {
+            return;
+          }
+
+          _this3.attachmentsButton.disabled = true;
+
+          if (_this3.active === SidebarView.ATTACHMENTS) {
+            _this3.switchView(SidebarView.THUMBS);
+          }
+        });
       });
-    });
 
-    this.eventBus._on("presentationmodechanged", evt => {
-      if (!evt.active && !evt.switchInProgress && this.isThumbnailViewVisible) {
-        this._updateThumbnailViewer();
-      }
-    });
-  }
+      this.eventBus._on("presentationmodechanged", function (evt) {
+        if (!evt.active && !evt.switchInProgress && _this3.isThumbnailViewVisible) {
+          _this3._updateThumbnailViewer();
+        }
+      });
+    }
+  }, {
+    key: "visibleView",
+    get: function get() {
+      return this.isOpen ? this.active : SidebarView.NONE;
+    }
+  }, {
+    key: "isThumbnailViewVisible",
+    get: function get() {
+      return this.isOpen && this.active === SidebarView.THUMBS;
+    }
+  }, {
+    key: "isOutlineViewVisible",
+    get: function get() {
+      return this.isOpen && this.active === SidebarView.OUTLINE;
+    }
+  }, {
+    key: "isAttachmentsViewVisible",
+    get: function get() {
+      return this.isOpen && this.active === SidebarView.ATTACHMENTS;
+    }
+  }]);
 
-}
+  return PDFSidebar;
+}();
 
 exports.PDFSidebar = PDFSidebar;
 
 /***/ }),
-/* 10 */
+/* 13 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4636,107 +5860,273 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.OverlayManager = void 0;
 
-class OverlayManager {
-  constructor() {
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var OverlayManager = /*#__PURE__*/function () {
+  function OverlayManager() {
+    _classCallCheck(this, OverlayManager);
+
     this._overlays = {};
     this._active = null;
     this._keyDownBound = this._keyDown.bind(this);
   }
 
-  get active() {
-    return this._active;
-  }
+  _createClass(OverlayManager, [{
+    key: "register",
+    value: function () {
+      var _register = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, element) {
+        var callerCloseMethod,
+            canForceClose,
+            container,
+            _args = arguments;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                callerCloseMethod = _args.length > 2 && _args[2] !== undefined ? _args[2] : null;
+                canForceClose = _args.length > 3 && _args[3] !== undefined ? _args[3] : false;
+
+                if (!(!name || !element || !(container = element.parentNode))) {
+                  _context.next = 6;
+                  break;
+                }
+
+                throw new Error("Not enough parameters.");
+
+              case 6:
+                if (!this._overlays[name]) {
+                  _context.next = 8;
+                  break;
+                }
+
+                throw new Error("The overlay is already registered.");
+
+              case 8:
+                this._overlays[name] = {
+                  element: element,
+                  container: container,
+                  callerCloseMethod: callerCloseMethod,
+                  canForceClose: canForceClose
+                };
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function register(_x, _x2) {
+        return _register.apply(this, arguments);
+      }
+
+      return register;
+    }()
+  }, {
+    key: "unregister",
+    value: function () {
+      var _unregister = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(name) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                throw new Error("The overlay does not exist.");
+
+              case 4:
+                if (!(this._active === name)) {
+                  _context2.next = 6;
+                  break;
+                }
+
+                throw new Error("The overlay cannot be removed while it is active.");
+
+              case 6:
+                delete this._overlays[name];
+
+              case 7:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
 
-  async register(name, element, callerCloseMethod = null, canForceClose = false) {
-    let container;
+      function unregister(_x3) {
+        return _unregister.apply(this, arguments);
+      }
 
-    if (!name || !element || !(container = element.parentNode)) {
-      throw new Error("Not enough parameters.");
-    } else if (this._overlays[name]) {
-      throw new Error("The overlay is already registered.");
-    }
+      return unregister;
+    }()
+  }, {
+    key: "open",
+    value: function () {
+      var _open = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3(name) {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context3.next = 4;
+                  break;
+                }
 
-    this._overlays[name] = {
-      element,
-      container,
-      callerCloseMethod,
-      canForceClose
-    };
-  }
+                throw new Error("The overlay does not exist.");
 
-  async unregister(name) {
-    if (!this._overlays[name]) {
-      throw new Error("The overlay does not exist.");
-    } else if (this._active === name) {
-      throw new Error("The overlay cannot be removed while it is active.");
-    }
+              case 4:
+                if (!this._active) {
+                  _context3.next = 14;
+                  break;
+                }
 
-    delete this._overlays[name];
-  }
+                if (!this._overlays[name].canForceClose) {
+                  _context3.next = 9;
+                  break;
+                }
 
-  async open(name) {
-    if (!this._overlays[name]) {
-      throw new Error("The overlay does not exist.");
-    } else if (this._active) {
-      if (this._overlays[name].canForceClose) {
-        this._closeThroughCaller();
-      } else if (this._active === name) {
-        throw new Error("The overlay is already active.");
-      } else {
-        throw new Error("Another overlay is currently active.");
+                this._closeThroughCaller();
+
+                _context3.next = 14;
+                break;
+
+              case 9:
+                if (!(this._active === name)) {
+                  _context3.next = 13;
+                  break;
+                }
+
+                throw new Error("The overlay is already active.");
+
+              case 13:
+                throw new Error("Another overlay is currently active.");
+
+              case 14:
+                this._active = name;
+
+                this._overlays[this._active].element.classList.remove("hidden");
+
+                this._overlays[this._active].container.classList.remove("hidden");
+
+                window.addEventListener("keydown", this._keyDownBound);
+
+              case 18:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function open(_x4) {
+        return _open.apply(this, arguments);
       }
-    }
 
-    this._active = name;
+      return open;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4(name) {
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (this._overlays[name]) {
+                  _context4.next = 4;
+                  break;
+                }
 
-    this._overlays[this._active].element.classList.remove("hidden");
+                throw new Error("The overlay does not exist.");
 
-    this._overlays[this._active].container.classList.remove("hidden");
+              case 4:
+                if (this._active) {
+                  _context4.next = 8;
+                  break;
+                }
 
-    window.addEventListener("keydown", this._keyDownBound);
-  }
+                throw new Error("The overlay is currently not active.");
 
-  async close(name) {
-    if (!this._overlays[name]) {
-      throw new Error("The overlay does not exist.");
-    } else if (!this._active) {
-      throw new Error("The overlay is currently not active.");
-    } else if (this._active !== name) {
-      throw new Error("Another overlay is currently active.");
-    }
+              case 8:
+                if (!(this._active !== name)) {
+                  _context4.next = 10;
+                  break;
+                }
 
-    this._overlays[this._active].container.classList.add("hidden");
+                throw new Error("Another overlay is currently active.");
 
-    this._overlays[this._active].element.classList.add("hidden");
+              case 10:
+                this._overlays[this._active].container.classList.add("hidden");
 
-    this._active = null;
-    window.removeEventListener("keydown", this._keyDownBound);
-  }
+                this._overlays[this._active].element.classList.add("hidden");
 
-  _keyDown(evt) {
-    if (this._active && evt.keyCode === 27) {
-      this._closeThroughCaller();
+                this._active = null;
+                window.removeEventListener("keydown", this._keyDownBound);
 
-      evt.preventDefault();
-    }
-  }
+              case 14:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function close(_x5) {
+        return _close.apply(this, arguments);
+      }
+
+      return close;
+    }()
+  }, {
+    key: "_keyDown",
+    value: function _keyDown(evt) {
+      if (this._active && evt.keyCode === 27) {
+        this._closeThroughCaller();
 
-  _closeThroughCaller() {
-    if (this._overlays[this._active].callerCloseMethod) {
-      this._overlays[this._active].callerCloseMethod();
+        evt.preventDefault();
+      }
     }
+  }, {
+    key: "_closeThroughCaller",
+    value: function _closeThroughCaller() {
+      if (this._overlays[this._active].callerCloseMethod) {
+        this._overlays[this._active].callerCloseMethod();
+      }
 
-    if (this._active) {
-      this.close(this._active);
+      if (this._active) {
+        this.close(this._active);
+      }
     }
-  }
+  }, {
+    key: "active",
+    get: function get() {
+      return this._active;
+    }
+  }]);
 
-}
+  return OverlayManager;
+}();
 
 exports.OverlayManager = OverlayManager;
 
 /***/ }),
-/* 11 */
+/* 14 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4747,12 +6137,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PasswordPrompt = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+var _pdfjsLib = __webpack_require__(8);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var PasswordPrompt = /*#__PURE__*/function () {
+  function PasswordPrompt(options, overlayManager) {
+    var _this = this;
 
-var _pdfjsLib = __webpack_require__(5);
+    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
+
+    _classCallCheck(this, PasswordPrompt);
 
-class PasswordPrompt {
-  constructor(options, overlayManager, l10n = _ui_utils.NullL10n) {
     this.overlayName = options.overlayName;
     this.container = options.container;
     this.label = options.label;
@@ -4765,57 +6167,69 @@ class PasswordPrompt {
     this.reason = null;
     this.submitButton.addEventListener("click", this.verify.bind(this));
     this.cancelButton.addEventListener("click", this.close.bind(this));
-    this.input.addEventListener("keydown", e => {
+    this.input.addEventListener("keydown", function (e) {
       if (e.keyCode === 13) {
-        this.verify();
+        _this.verify();
       }
     });
     this.overlayManager.register(this.overlayName, this.container, this.close.bind(this), true);
   }
 
-  open() {
-    this.overlayManager.open(this.overlayName).then(() => {
-      this.input.focus();
-      let promptString;
+  _createClass(PasswordPrompt, [{
+    key: "open",
+    value: function open() {
+      var _this2 = this;
 
-      if (this.reason === _pdfjsLib.PasswordResponses.INCORRECT_PASSWORD) {
-        promptString = this.l10n.get("password_invalid", null, "Invalid password. Please try again.");
-      } else {
-        promptString = this.l10n.get("password_label", null, "Enter the password to open this PDF file.");
-      }
+      this.overlayManager.open(this.overlayName).then(function () {
+        _this2.input.focus();
 
-      promptString.then(msg => {
-        this.label.textContent = msg;
-      });
-    });
-  }
+        var promptString;
 
-  close() {
-    this.overlayManager.close(this.overlayName).then(() => {
-      this.input.value = "";
-    });
-  }
+        if (_this2.reason === _pdfjsLib.PasswordResponses.INCORRECT_PASSWORD) {
+          promptString = _this2.l10n.get("password_invalid", null, "Invalid password. Please try again.");
+        } else {
+          promptString = _this2.l10n.get("password_label", null, "Enter the password to open this PDF file.");
+        }
 
-  verify() {
-    const password = this.input.value;
+        promptString.then(function (msg) {
+          _this2.label.textContent = msg;
+        });
+      });
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      var _this3 = this;
 
-    if (password && password.length > 0) {
-      this.close();
-      this.updateCallback(password);
+      this.overlayManager.close(this.overlayName).then(function () {
+        _this3.input.value = "";
+      });
     }
-  }
+  }, {
+    key: "verify",
+    value: function verify() {
+      var password = this.input.value;
 
-  setUpdateCallback(updateCallback, reason) {
-    this.updateCallback = updateCallback;
-    this.reason = reason;
-  }
+      if (password && password.length > 0) {
+        this.close();
+        this.updateCallback(password);
+      }
+    }
+  }, {
+    key: "setUpdateCallback",
+    value: function setUpdateCallback(updateCallback, reason) {
+      this.updateCallback = updateCallback;
+      this.reason = reason;
+    }
+  }]);
 
-}
+  return PasswordPrompt;
+}();
 
 exports.PasswordPrompt = PasswordPrompt;
 
 /***/ }),
-/* 12 */
+/* 15 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4826,14 +6240,22 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFAttachmentViewer = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var PDFAttachmentViewer = /*#__PURE__*/function () {
+  function PDFAttachmentViewer(_ref) {
+    var container = _ref.container,
+        eventBus = _ref.eventBus,
+        downloadManager = _ref.downloadManager;
+
+    _classCallCheck(this, PDFAttachmentViewer);
 
-class PDFAttachmentViewer {
-  constructor({
-    container,
-    eventBus,
-    downloadManager
-  }) {
     this.container = container;
     this.eventBus = eventBus;
     this.downloadManager = downloadManager;
@@ -4842,136 +6264,155 @@ class PDFAttachmentViewer {
     this.eventBus._on("fileattachmentannotation", this._appendAttachment.bind(this));
   }
 
-  reset(keepRenderedCapability = false) {
-    this.attachments = null;
-    this.container.textContent = "";
+  _createClass(PDFAttachmentViewer, [{
+    key: "reset",
+    value: function reset() {
+      var keepRenderedCapability = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      this.attachments = null;
+      this.container.textContent = "";
 
-    if (!keepRenderedCapability) {
-      this._renderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+      if (!keepRenderedCapability) {
+        this._renderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+      }
     }
-  }
-
-  _dispatchEvent(attachmentsCount) {
-    this._renderedCapability.resolve();
+  }, {
+    key: "_dispatchEvent",
+    value: function _dispatchEvent(attachmentsCount) {
+      this._renderedCapability.resolve();
 
-    this.eventBus.dispatch("attachmentsloaded", {
-      source: this,
-      attachmentsCount
-    });
-  }
+      this.eventBus.dispatch("attachmentsloaded", {
+        source: this,
+        attachmentsCount: attachmentsCount
+      });
+    }
+  }, {
+    key: "_bindPdfLink",
+    value: function _bindPdfLink(button, content, filename) {
+      var _this = this;
 
-  _bindPdfLink(button, content, filename) {
-    let blobUrl;
+      var blobUrl;
 
-    button.onclick = () => {
-      if (!blobUrl) {
-        blobUrl = URL.createObjectURL(new Blob([content], {
-          type: "application/pdf"
-        }));
-      }
+      button.onclick = function () {
+        if (!blobUrl) {
+          blobUrl = URL.createObjectURL(new Blob([content], {
+            type: "application/pdf"
+          }));
+        }
 
-      let viewerUrl;
-      viewerUrl = "?file=" + encodeURIComponent(blobUrl + "#" + filename);
+        var viewerUrl;
+        viewerUrl = "?file=" + encodeURIComponent(blobUrl + "#" + filename);
 
-      try {
-        window.open(viewerUrl);
-      } catch (ex) {
-        console.error(`_bindPdfLink: ${ex}`);
-        URL.revokeObjectURL(blobUrl);
-        blobUrl = null;
-        this.downloadManager.downloadData(content, filename, "application/pdf");
-      }
+        try {
+          window.open(viewerUrl);
+        } catch (ex) {
+          console.error("_bindPdfLink: ".concat(ex));
+          URL.revokeObjectURL(blobUrl);
+          blobUrl = null;
 
-      return false;
-    };
-  }
+          _this.downloadManager.downloadData(content, filename, "application/pdf");
+        }
 
-  _bindLink(button, content, filename) {
-    button.onclick = () => {
-      this.downloadManager.downloadData(content, filename, "");
-      return false;
-    };
-  }
+        return false;
+      };
+    }
+  }, {
+    key: "_bindLink",
+    value: function _bindLink(button, content, filename) {
+      var _this2 = this;
 
-  render({
-    attachments,
-    keepRenderedCapability = false
-  }) {
-    let attachmentsCount = 0;
+      button.onclick = function () {
+        _this2.downloadManager.downloadData(content, filename, "");
 
-    if (this.attachments) {
-      this.reset(keepRenderedCapability === true);
+        return false;
+      };
     }
+  }, {
+    key: "render",
+    value: function render(_ref2) {
+      var attachments = _ref2.attachments,
+          _ref2$keepRenderedCap = _ref2.keepRenderedCapability,
+          keepRenderedCapability = _ref2$keepRenderedCap === void 0 ? false : _ref2$keepRenderedCap;
+      var attachmentsCount = 0;
 
-    this.attachments = attachments || null;
+      if (this.attachments) {
+        this.reset(keepRenderedCapability === true);
+      }
 
-    if (!attachments) {
-      this._dispatchEvent(attachmentsCount);
+      this.attachments = attachments || null;
 
-      return;
-    }
+      if (!attachments) {
+        this._dispatchEvent(attachmentsCount);
 
-    const names = Object.keys(attachments).sort(function (a, b) {
-      return a.toLowerCase().localeCompare(b.toLowerCase());
-    });
-    attachmentsCount = names.length;
-
-    for (let i = 0; i < attachmentsCount; i++) {
-      const item = attachments[names[i]];
-      const filename = (0, _pdfjsLib.removeNullCharacters)((0, _pdfjsLib.getFilenameFromUrl)(item.filename));
-      const div = document.createElement("div");
-      div.className = "attachmentsItem";
-      const button = document.createElement("button");
-      button.textContent = filename;
-
-      if (/\.pdf$/i.test(filename) && !this.downloadManager.disableCreateObjectURL) {
-        this._bindPdfLink(button, item.content, filename);
-      } else {
-        this._bindLink(button, item.content, filename);
+        return;
       }
 
-      div.appendChild(button);
-      this.container.appendChild(div);
+      var names = Object.keys(attachments).sort(function (a, b) {
+        return a.toLowerCase().localeCompare(b.toLowerCase());
+      });
+      attachmentsCount = names.length;
+
+      for (var i = 0; i < attachmentsCount; i++) {
+        var item = attachments[names[i]];
+        var filename = (0, _pdfjsLib.removeNullCharacters)((0, _pdfjsLib.getFilenameFromUrl)(item.filename));
+        var div = document.createElement("div");
+        div.className = "attachmentsItem";
+        var button = document.createElement("button");
+        button.textContent = filename;
+
+        if (/\.pdf$/i.test(filename) && !this.downloadManager.disableCreateObjectURL) {
+          this._bindPdfLink(button, item.content, filename);
+        } else {
+          this._bindLink(button, item.content, filename);
+        }
+
+        div.appendChild(button);
+        this.container.appendChild(div);
+      }
+
+      this._dispatchEvent(attachmentsCount);
     }
+  }, {
+    key: "_appendAttachment",
+    value: function _appendAttachment(_ref3) {
+      var _this3 = this;
 
-    this._dispatchEvent(attachmentsCount);
-  }
+      var id = _ref3.id,
+          filename = _ref3.filename,
+          content = _ref3.content;
 
-  _appendAttachment({
-    id,
-    filename,
-    content
-  }) {
-    this._renderedCapability.promise.then(() => {
-      let attachments = this.attachments;
+      this._renderedCapability.promise.then(function () {
+        var attachments = _this3.attachments;
 
-      if (!attachments) {
-        attachments = Object.create(null);
-      } else {
-        for (const name in attachments) {
-          if (id === name) {
-            return;
+        if (!attachments) {
+          attachments = Object.create(null);
+        } else {
+          for (var name in attachments) {
+            if (id === name) {
+              return;
+            }
           }
         }
-      }
 
-      attachments[id] = {
-        filename,
-        content
-      };
-      this.render({
-        attachments,
-        keepRenderedCapability: true
+        attachments[id] = {
+          filename: filename,
+          content: content
+        };
+
+        _this3.render({
+          attachments: attachments,
+          keepRenderedCapability: true
+        });
       });
-    });
-  }
+    }
+  }]);
 
-}
+  return PDFAttachmentViewer;
+}();
 
 exports.PDFAttachmentViewer = PDFAttachmentViewer;
 
 /***/ }),
-/* 13 */
+/* 16 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -4982,34 +6423,65 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFDocumentProperties = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+var _pdfjsLib = __webpack_require__(8);
+
+var _ui_utils = __webpack_require__(5);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-var _ui_utils = __webpack_require__(2);
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-const DEFAULT_FIELD_CONTENT = "-";
-const NON_METRIC_LOCALES = ["en-us", "en-lr", "my"];
-const US_PAGE_NAMES = {
+var DEFAULT_FIELD_CONTENT = "-";
+var NON_METRIC_LOCALES = ["en-us", "en-lr", "my"];
+var US_PAGE_NAMES = {
   "8.5x11": "Letter",
   "8.5x14": "Legal"
 };
-const METRIC_PAGE_NAMES = {
+var METRIC_PAGE_NAMES = {
   "297x420": "A3",
   "210x297": "A4"
 };
 
 function getPageName(size, isPortrait, pageNames) {
-  const width = isPortrait ? size.width : size.height;
-  const height = isPortrait ? size.height : size.width;
-  return pageNames[`${width}x${height}`];
+  var width = isPortrait ? size.width : size.height;
+  var height = isPortrait ? size.height : size.width;
+  return pageNames["".concat(width, "x").concat(height)];
 }
 
-class PDFDocumentProperties {
-  constructor({
-    overlayName,
-    fields,
-    container,
-    closeButton
-  }, overlayManager, eventBus, l10n = _ui_utils.NullL10n) {
+var PDFDocumentProperties = /*#__PURE__*/function () {
+  function PDFDocumentProperties(_ref, overlayManager, eventBus) {
+    var _this = this;
+
+    var overlayName = _ref.overlayName,
+        fields = _ref.fields,
+        container = _ref.container,
+        closeButton = _ref.closeButton;
+    var l10n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _ui_utils.NullL10n;
+
+    _classCallCheck(this, PDFDocumentProperties);
+
     this.overlayName = overlayName;
     this.fields = fields;
     this.container = container;
@@ -5021,252 +6493,367 @@ class PDFDocumentProperties {
     closeButton.addEventListener("click", this.close.bind(this));
     this.overlayManager.register(this.overlayName, this.container, this.close.bind(this));
 
-    eventBus._on("pagechanging", evt => {
-      this._currentPageNumber = evt.pageNumber;
+    eventBus._on("pagechanging", function (evt) {
+      _this._currentPageNumber = evt.pageNumber;
     });
 
-    eventBus._on("rotationchanging", evt => {
-      this._pagesRotation = evt.pagesRotation;
+    eventBus._on("rotationchanging", function (evt) {
+      _this._pagesRotation = evt.pagesRotation;
     });
 
     this._isNonMetricLocale = true;
-    l10n.getLanguage().then(locale => {
-      this._isNonMetricLocale = NON_METRIC_LOCALES.includes(locale);
+    l10n.getLanguage().then(function (locale) {
+      _this._isNonMetricLocale = NON_METRIC_LOCALES.includes(locale);
     });
   }
 
-  open() {
-    const freezeFieldData = data => {
-      Object.defineProperty(this, "fieldData", {
-        value: Object.freeze(data),
-        writable: false,
-        enumerable: true,
-        configurable: true
-      });
-    };
-
-    Promise.all([this.overlayManager.open(this.overlayName), this._dataAvailableCapability.promise]).then(() => {
-      const currentPageNumber = this._currentPageNumber;
-      const pagesRotation = this._pagesRotation;
+  _createClass(PDFDocumentProperties, [{
+    key: "open",
+    value: function open() {
+      var _this2 = this;
 
-      if (this.fieldData && currentPageNumber === this.fieldData._currentPageNumber && pagesRotation === this.fieldData._pagesRotation) {
-        this._updateUI();
-
-        return;
-      }
-
-      this.pdfDocument.getMetadata().then(({
-        info,
-        metadata,
-        contentDispositionFilename
-      }) => {
-        return Promise.all([info, metadata, contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url), this._parseFileSize(this.maybeFileSize), this._parseDate(info.CreationDate), this._parseDate(info.ModDate), this.pdfDocument.getPage(currentPageNumber).then(pdfPage => {
-          return this._parsePageSize((0, _ui_utils.getPageSizeInches)(pdfPage), pagesRotation);
-        }), this._parseLinearization(info.IsLinearized)]);
-      }).then(([info, metadata, fileName, fileSize, creationDate, modDate, pageSize, isLinearized]) => {
-        freezeFieldData({
-          fileName,
-          fileSize,
-          title: info.Title,
-          author: info.Author,
-          subject: info.Subject,
-          keywords: info.Keywords,
-          creationDate,
-          modificationDate: modDate,
-          creator: info.Creator,
-          producer: info.Producer,
-          version: info.PDFFormatVersion,
-          pageCount: this.pdfDocument.numPages,
-          pageSize,
-          linearized: isLinearized,
-          _currentPageNumber: currentPageNumber,
-          _pagesRotation: pagesRotation
+      var freezeFieldData = function freezeFieldData(data) {
+        Object.defineProperty(_this2, "fieldData", {
+          value: Object.freeze(data),
+          writable: false,
+          enumerable: true,
+          configurable: true
         });
+      };
+
+      Promise.all([this.overlayManager.open(this.overlayName), this._dataAvailableCapability.promise]).then(function () {
+        var currentPageNumber = _this2._currentPageNumber;
+        var pagesRotation = _this2._pagesRotation;
 
-        this._updateUI();
+        if (_this2.fieldData && currentPageNumber === _this2.fieldData._currentPageNumber && pagesRotation === _this2.fieldData._pagesRotation) {
+          _this2._updateUI();
 
-        return this.pdfDocument.getDownloadInfo();
-      }).then(({
-        length
-      }) => {
-        this.maybeFileSize = length;
-        return this._parseFileSize(length);
-      }).then(fileSize => {
-        if (fileSize === this.fieldData.fileSize) {
           return;
         }
 
-        const data = Object.assign(Object.create(null), this.fieldData);
-        data.fileSize = fileSize;
-        freezeFieldData(data);
-
-        this._updateUI();
-      });
-    });
-  }
+        _this2.pdfDocument.getMetadata().then(function (_ref2) {
+          var info = _ref2.info,
+              metadata = _ref2.metadata,
+              contentDispositionFilename = _ref2.contentDispositionFilename;
+          return Promise.all([info, metadata, contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(_this2.url), _this2._parseFileSize(_this2.maybeFileSize), _this2._parseDate(info.CreationDate), _this2._parseDate(info.ModDate), _this2.pdfDocument.getPage(currentPageNumber).then(function (pdfPage) {
+            return _this2._parsePageSize((0, _ui_utils.getPageSizeInches)(pdfPage), pagesRotation);
+          }), _this2._parseLinearization(info.IsLinearized)]);
+        }).then(function (_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 8),
+              info = _ref4[0],
+              metadata = _ref4[1],
+              fileName = _ref4[2],
+              fileSize = _ref4[3],
+              creationDate = _ref4[4],
+              modDate = _ref4[5],
+              pageSize = _ref4[6],
+              isLinearized = _ref4[7];
+
+          freezeFieldData({
+            fileName: fileName,
+            fileSize: fileSize,
+            title: info.Title,
+            author: info.Author,
+            subject: info.Subject,
+            keywords: info.Keywords,
+            creationDate: creationDate,
+            modificationDate: modDate,
+            creator: info.Creator,
+            producer: info.Producer,
+            version: info.PDFFormatVersion,
+            pageCount: _this2.pdfDocument.numPages,
+            pageSize: pageSize,
+            linearized: isLinearized,
+            _currentPageNumber: currentPageNumber,
+            _pagesRotation: pagesRotation
+          });
 
-  close() {
-    this.overlayManager.close(this.overlayName);
-  }
+          _this2._updateUI();
 
-  setDocument(pdfDocument, url = null) {
-    if (this.pdfDocument) {
-      this._reset();
+          return _this2.pdfDocument.getDownloadInfo();
+        }).then(function (_ref5) {
+          var length = _ref5.length;
+          _this2.maybeFileSize = length;
+          return _this2._parseFileSize(length);
+        }).then(function (fileSize) {
+          if (fileSize === _this2.fieldData.fileSize) {
+            return;
+          }
 
-      this._updateUI(true);
-    }
+          var data = Object.assign(Object.create(null), _this2.fieldData);
+          data.fileSize = fileSize;
+          freezeFieldData(data);
 
-    if (!pdfDocument) {
-      return;
+          _this2._updateUI();
+        });
+      });
     }
-
-    this.pdfDocument = pdfDocument;
-    this.url = url;
-
-    this._dataAvailableCapability.resolve();
-  }
-
-  setFileSize(fileSize) {
-    if (Number.isInteger(fileSize) && fileSize > 0) {
-      this.maybeFileSize = fileSize;
+  }, {
+    key: "close",
+    value: function close() {
+      this.overlayManager.close(this.overlayName);
     }
-  }
+  }, {
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      var url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
 
-  _reset() {
-    this.pdfDocument = null;
-    this.url = null;
-    this.maybeFileSize = 0;
-    delete this.fieldData;
-    this._dataAvailableCapability = (0, _pdfjsLib.createPromiseCapability)();
-    this._currentPageNumber = 1;
-    this._pagesRotation = 0;
-  }
+      if (this.pdfDocument) {
+        this._reset();
 
-  _updateUI(reset = false) {
-    if (reset || !this.fieldData) {
-      for (const id in this.fields) {
-        this.fields[id].textContent = DEFAULT_FIELD_CONTENT;
+        this._updateUI(true);
       }
 
-      return;
-    }
-
-    if (this.overlayManager.active !== this.overlayName) {
-      return;
-    }
-
-    for (const id in this.fields) {
-      const content = this.fieldData[id];
-      this.fields[id].textContent = content || content === 0 ? content : DEFAULT_FIELD_CONTENT;
-    }
-  }
-
-  async _parseFileSize(fileSize = 0) {
-    const kb = fileSize / 1024;
-
-    if (!kb) {
-      return undefined;
-    } else if (kb < 1024) {
-      return this.l10n.get("document_properties_kb", {
-        size_kb: (+kb.toPrecision(3)).toLocaleString(),
-        size_b: fileSize.toLocaleString()
-      }, "{{size_kb}} KB ({{size_b}} bytes)");
-    }
+      if (!pdfDocument) {
+        return;
+      }
 
-    return this.l10n.get("document_properties_mb", {
-      size_mb: (+(kb / 1024).toPrecision(3)).toLocaleString(),
-      size_b: fileSize.toLocaleString()
-    }, "{{size_mb}} MB ({{size_b}} bytes)");
-  }
+      this.pdfDocument = pdfDocument;
+      this.url = url;
 
-  async _parsePageSize(pageSizeInches, pagesRotation) {
-    if (!pageSizeInches) {
-      return undefined;
+      this._dataAvailableCapability.resolve();
     }
-
-    if (pagesRotation % 180 !== 0) {
-      pageSizeInches = {
-        width: pageSizeInches.height,
-        height: pageSizeInches.width
-      };
+  }, {
+    key: "setFileSize",
+    value: function setFileSize(fileSize) {
+      if (Number.isInteger(fileSize) && fileSize > 0) {
+        this.maybeFileSize = fileSize;
+      }
     }
-
-    const isPortrait = (0, _ui_utils.isPortraitOrientation)(pageSizeInches);
-    let sizeInches = {
-      width: Math.round(pageSizeInches.width * 100) / 100,
-      height: Math.round(pageSizeInches.height * 100) / 100
-    };
-    let sizeMillimeters = {
-      width: Math.round(pageSizeInches.width * 25.4 * 10) / 10,
-      height: Math.round(pageSizeInches.height * 25.4 * 10) / 10
-    };
-    let pageName = null;
-    let rawName = getPageName(sizeInches, isPortrait, US_PAGE_NAMES) || getPageName(sizeMillimeters, isPortrait, METRIC_PAGE_NAMES);
-
-    if (!rawName && !(Number.isInteger(sizeMillimeters.width) && Number.isInteger(sizeMillimeters.height))) {
-      const exactMillimeters = {
-        width: pageSizeInches.width * 25.4,
-        height: pageSizeInches.height * 25.4
-      };
-      const intMillimeters = {
-        width: Math.round(sizeMillimeters.width),
-        height: Math.round(sizeMillimeters.height)
-      };
-
-      if (Math.abs(exactMillimeters.width - intMillimeters.width) < 0.1 && Math.abs(exactMillimeters.height - intMillimeters.height) < 0.1) {
-        rawName = getPageName(intMillimeters, isPortrait, METRIC_PAGE_NAMES);
-
-        if (rawName) {
-          sizeInches = {
-            width: Math.round(intMillimeters.width / 25.4 * 100) / 100,
-            height: Math.round(intMillimeters.height / 25.4 * 100) / 100
-          };
-          sizeMillimeters = intMillimeters;
+  }, {
+    key: "_reset",
+    value: function _reset() {
+      this.pdfDocument = null;
+      this.url = null;
+      this.maybeFileSize = 0;
+      delete this.fieldData;
+      this._dataAvailableCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._currentPageNumber = 1;
+      this._pagesRotation = 0;
+    }
+  }, {
+    key: "_updateUI",
+    value: function _updateUI() {
+      var reset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+      if (reset || !this.fieldData) {
+        for (var id in this.fields) {
+          this.fields[id].textContent = DEFAULT_FIELD_CONTENT;
         }
+
+        return;
       }
-    }
 
-    if (rawName) {
-      pageName = this.l10n.get("document_properties_page_size_name_" + rawName.toLowerCase(), null, rawName);
-    }
+      if (this.overlayManager.active !== this.overlayName) {
+        return;
+      }
 
-    return Promise.all([this._isNonMetricLocale ? sizeInches : sizeMillimeters, this.l10n.get("document_properties_page_size_unit_" + (this._isNonMetricLocale ? "inches" : "millimeters"), null, this._isNonMetricLocale ? "in" : "mm"), pageName, this.l10n.get("document_properties_page_size_orientation_" + (isPortrait ? "portrait" : "landscape"), null, isPortrait ? "portrait" : "landscape")]).then(([{
-      width,
-      height
-    }, unit, name, orientation]) => {
-      return this.l10n.get("document_properties_page_size_dimension_" + (name ? "name_" : "") + "string", {
-        width: width.toLocaleString(),
-        height: height.toLocaleString(),
-        unit,
-        name,
-        orientation
-      }, "{{width}} × {{height}} {{unit}} (" + (name ? "{{name}}, " : "") + "{{orientation}})");
-    });
-  }
+      for (var _id in this.fields) {
+        var content = this.fieldData[_id];
+        this.fields[_id].textContent = content || content === 0 ? content : DEFAULT_FIELD_CONTENT;
+      }
+    }
+  }, {
+    key: "_parseFileSize",
+    value: function () {
+      var _parseFileSize2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var fileSize,
+            kb,
+            _args = arguments;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                fileSize = _args.length > 0 && _args[0] !== undefined ? _args[0] : 0;
+                kb = fileSize / 1024;
+
+                if (kb) {
+                  _context.next = 6;
+                  break;
+                }
+
+                return _context.abrupt("return", undefined);
+
+              case 6:
+                if (!(kb < 1024)) {
+                  _context.next = 8;
+                  break;
+                }
+
+                return _context.abrupt("return", this.l10n.get("document_properties_kb", {
+                  size_kb: (+kb.toPrecision(3)).toLocaleString(),
+                  size_b: fileSize.toLocaleString()
+                }, "{{size_kb}} KB ({{size_b}} bytes)"));
+
+              case 8:
+                return _context.abrupt("return", this.l10n.get("document_properties_mb", {
+                  size_mb: (+(kb / 1024).toPrecision(3)).toLocaleString(),
+                  size_b: fileSize.toLocaleString()
+                }, "{{size_mb}} MB ({{size_b}} bytes)"));
+
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function _parseFileSize() {
+        return _parseFileSize2.apply(this, arguments);
+      }
+
+      return _parseFileSize;
+    }()
+  }, {
+    key: "_parsePageSize",
+    value: function () {
+      var _parsePageSize2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(pageSizeInches, pagesRotation) {
+        var _this3 = this;
+
+        var isPortrait, sizeInches, sizeMillimeters, pageName, rawName, exactMillimeters, intMillimeters;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (pageSizeInches) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                return _context2.abrupt("return", undefined);
+
+              case 2:
+                if (pagesRotation % 180 !== 0) {
+                  pageSizeInches = {
+                    width: pageSizeInches.height,
+                    height: pageSizeInches.width
+                  };
+                }
+
+                isPortrait = (0, _ui_utils.isPortraitOrientation)(pageSizeInches);
+                sizeInches = {
+                  width: Math.round(pageSizeInches.width * 100) / 100,
+                  height: Math.round(pageSizeInches.height * 100) / 100
+                };
+                sizeMillimeters = {
+                  width: Math.round(pageSizeInches.width * 25.4 * 10) / 10,
+                  height: Math.round(pageSizeInches.height * 25.4 * 10) / 10
+                };
+                pageName = null;
+                rawName = getPageName(sizeInches, isPortrait, US_PAGE_NAMES) || getPageName(sizeMillimeters, isPortrait, METRIC_PAGE_NAMES);
+
+                if (!rawName && !(Number.isInteger(sizeMillimeters.width) && Number.isInteger(sizeMillimeters.height))) {
+                  exactMillimeters = {
+                    width: pageSizeInches.width * 25.4,
+                    height: pageSizeInches.height * 25.4
+                  };
+                  intMillimeters = {
+                    width: Math.round(sizeMillimeters.width),
+                    height: Math.round(sizeMillimeters.height)
+                  };
+
+                  if (Math.abs(exactMillimeters.width - intMillimeters.width) < 0.1 && Math.abs(exactMillimeters.height - intMillimeters.height) < 0.1) {
+                    rawName = getPageName(intMillimeters, isPortrait, METRIC_PAGE_NAMES);
+
+                    if (rawName) {
+                      sizeInches = {
+                        width: Math.round(intMillimeters.width / 25.4 * 100) / 100,
+                        height: Math.round(intMillimeters.height / 25.4 * 100) / 100
+                      };
+                      sizeMillimeters = intMillimeters;
+                    }
+                  }
+                }
+
+                if (rawName) {
+                  pageName = this.l10n.get("document_properties_page_size_name_" + rawName.toLowerCase(), null, rawName);
+                }
+
+                return _context2.abrupt("return", Promise.all([this._isNonMetricLocale ? sizeInches : sizeMillimeters, this.l10n.get("document_properties_page_size_unit_" + (this._isNonMetricLocale ? "inches" : "millimeters"), null, this._isNonMetricLocale ? "in" : "mm"), pageName, this.l10n.get("document_properties_page_size_orientation_" + (isPortrait ? "portrait" : "landscape"), null, isPortrait ? "portrait" : "landscape")]).then(function (_ref6) {
+                  var _ref7 = _slicedToArray(_ref6, 4),
+                      _ref7$ = _ref7[0],
+                      width = _ref7$.width,
+                      height = _ref7$.height,
+                      unit = _ref7[1],
+                      name = _ref7[2],
+                      orientation = _ref7[3];
+
+                  return _this3.l10n.get("document_properties_page_size_dimension_" + (name ? "name_" : "") + "string", {
+                    width: width.toLocaleString(),
+                    height: height.toLocaleString(),
+                    unit: unit,
+                    name: name,
+                    orientation: orientation
+                  }, "{{width}} × {{height}} {{unit}} (" + (name ? "{{name}}, " : "") + "{{orientation}})");
+                }));
+
+              case 11:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function _parsePageSize(_x, _x2) {
+        return _parsePageSize2.apply(this, arguments);
+      }
+
+      return _parsePageSize;
+    }()
+  }, {
+    key: "_parseDate",
+    value: function () {
+      var _parseDate2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3(inputDate) {
+        var dateObject;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                dateObject = _pdfjsLib.PDFDateString.toDateObject(inputDate);
+
+                if (dateObject) {
+                  _context3.next = 3;
+                  break;
+                }
+
+                return _context3.abrupt("return", undefined);
+
+              case 3:
+                return _context3.abrupt("return", this.l10n.get("document_properties_date_string", {
+                  date: dateObject.toLocaleDateString(),
+                  time: dateObject.toLocaleTimeString()
+                }, "{{date}}, {{time}}"));
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
 
-  async _parseDate(inputDate) {
-    const dateObject = _pdfjsLib.PDFDateString.toDateObject(inputDate);
+      function _parseDate(_x3) {
+        return _parseDate2.apply(this, arguments);
+      }
 
-    if (!dateObject) {
-      return undefined;
+      return _parseDate;
+    }()
+  }, {
+    key: "_parseLinearization",
+    value: function _parseLinearization(isLinearized) {
+      return this.l10n.get("document_properties_linearized_" + (isLinearized ? "yes" : "no"), null, isLinearized ? "Yes" : "No");
     }
+  }]);
 
-    return this.l10n.get("document_properties_date_string", {
-      date: dateObject.toLocaleDateString(),
-      time: dateObject.toLocaleTimeString()
-    }, "{{date}}, {{time}}");
-  }
-
-  _parseLinearization(isLinearized) {
-    return this.l10n.get("document_properties_linearized_" + (isLinearized ? "yes" : "no"), null, isLinearized ? "Yes" : "No");
-  }
-
-}
+  return PDFDocumentProperties;
+}();
 
 exports.PDFDocumentProperties = PDFDocumentProperties;
 
 /***/ }),
-/* 14 */
+/* 17 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -5277,14 +6864,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFFindBar = void 0;
 
-var _pdf_find_controller = __webpack_require__(15);
+var _pdf_find_controller = __webpack_require__(18);
+
+var _ui_utils = __webpack_require__(5);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var MATCHES_COUNT_LIMIT = 1000;
+
+var PDFFindBar = /*#__PURE__*/function () {
+  function PDFFindBar(options, eventBus) {
+    var _this = this;
 
-var _ui_utils = __webpack_require__(2);
+    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
 
-const MATCHES_COUNT_LIMIT = 1000;
+    _classCallCheck(this, PDFFindBar);
 
-class PDFFindBar {
-  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
     this.opened = false;
     this.bar = options.bar || null;
     this.toggleButton = options.toggleButton || null;
@@ -5298,186 +6897,206 @@ class PDFFindBar {
     this.findNextButton = options.findNextButton || null;
     this.eventBus = eventBus;
     this.l10n = l10n;
-    this.toggleButton.addEventListener("click", () => {
-      this.toggle();
+    this.toggleButton.addEventListener("click", function () {
+      _this.toggle();
     });
-    this.findField.addEventListener("input", () => {
-      this.dispatchEvent("");
+    this.findField.addEventListener("input", function () {
+      _this.dispatchEvent("");
     });
-    this.bar.addEventListener("keydown", e => {
+    this.bar.addEventListener("keydown", function (e) {
       switch (e.keyCode) {
         case 13:
-          if (e.target === this.findField) {
-            this.dispatchEvent("again", e.shiftKey);
+          if (e.target === _this.findField) {
+            _this.dispatchEvent("again", e.shiftKey);
           }
 
           break;
 
         case 27:
-          this.close();
+          _this.close();
+
           break;
       }
     });
-    this.findPreviousButton.addEventListener("click", () => {
-      this.dispatchEvent("again", true);
+    this.findPreviousButton.addEventListener("click", function () {
+      _this.dispatchEvent("again", true);
     });
-    this.findNextButton.addEventListener("click", () => {
-      this.dispatchEvent("again", false);
+    this.findNextButton.addEventListener("click", function () {
+      _this.dispatchEvent("again", false);
     });
-    this.highlightAll.addEventListener("click", () => {
-      this.dispatchEvent("highlightallchange");
+    this.highlightAll.addEventListener("click", function () {
+      _this.dispatchEvent("highlightallchange");
     });
-    this.caseSensitive.addEventListener("click", () => {
-      this.dispatchEvent("casesensitivitychange");
+    this.caseSensitive.addEventListener("click", function () {
+      _this.dispatchEvent("casesensitivitychange");
     });
-    this.entireWord.addEventListener("click", () => {
-      this.dispatchEvent("entirewordchange");
+    this.entireWord.addEventListener("click", function () {
+      _this.dispatchEvent("entirewordchange");
     });
 
     this.eventBus._on("resize", this._adjustWidth.bind(this));
   }
 
-  reset() {
-    this.updateUIState();
-  }
-
-  dispatchEvent(type, findPrev) {
-    this.eventBus.dispatch("find", {
-      source: this,
-      type,
-      query: this.findField.value,
-      phraseSearch: true,
-      caseSensitive: this.caseSensitive.checked,
-      entireWord: this.entireWord.checked,
-      highlightAll: this.highlightAll.checked,
-      findPrevious: findPrev
-    });
-  }
-
-  updateUIState(state, previous, matchesCount) {
-    let notFound = false;
-    let findMsg = "";
-    let status = "";
+  _createClass(PDFFindBar, [{
+    key: "reset",
+    value: function reset() {
+      this.updateUIState();
+    }
+  }, {
+    key: "dispatchEvent",
+    value: function dispatchEvent(type, findPrev) {
+      this.eventBus.dispatch("find", {
+        source: this,
+        type: type,
+        query: this.findField.value,
+        phraseSearch: true,
+        caseSensitive: this.caseSensitive.checked,
+        entireWord: this.entireWord.checked,
+        highlightAll: this.highlightAll.checked,
+        findPrevious: findPrev
+      });
+    }
+  }, {
+    key: "updateUIState",
+    value: function updateUIState(state, previous, matchesCount) {
+      var _this2 = this;
 
-    switch (state) {
-      case _pdf_find_controller.FindState.FOUND:
-        break;
+      var notFound = false;
+      var findMsg = "";
+      var status = "";
 
-      case _pdf_find_controller.FindState.PENDING:
-        status = "pending";
-        break;
+      switch (state) {
+        case _pdf_find_controller.FindState.FOUND:
+          break;
 
-      case _pdf_find_controller.FindState.NOT_FOUND:
-        findMsg = this.l10n.get("find_not_found", null, "Phrase not found");
-        notFound = true;
-        break;
+        case _pdf_find_controller.FindState.PENDING:
+          status = "pending";
+          break;
 
-      case _pdf_find_controller.FindState.WRAPPED:
-        if (previous) {
-          findMsg = this.l10n.get("find_reached_top", null, "Reached top of document, continued from bottom");
-        } else {
-          findMsg = this.l10n.get("find_reached_bottom", null, "Reached end of document, continued from top");
-        }
+        case _pdf_find_controller.FindState.NOT_FOUND:
+          findMsg = this.l10n.get("find_not_found", null, "Phrase not found");
+          notFound = true;
+          break;
 
-        break;
-    }
+        case _pdf_find_controller.FindState.WRAPPED:
+          if (previous) {
+            findMsg = this.l10n.get("find_reached_top", null, "Reached top of document, continued from bottom");
+          } else {
+            findMsg = this.l10n.get("find_reached_bottom", null, "Reached end of document, continued from top");
+          }
 
-    this.findField.classList.toggle("notFound", notFound);
-    this.findField.setAttribute("data-status", status);
-    Promise.resolve(findMsg).then(msg => {
-      this.findMsg.textContent = msg;
+          break;
+      }
 
-      this._adjustWidth();
-    });
-    this.updateResultsCount(matchesCount);
-  }
+      this.findField.classList.toggle("notFound", notFound);
+      this.findField.setAttribute("data-status", status);
+      Promise.resolve(findMsg).then(function (msg) {
+        _this2.findMsg.textContent = msg;
 
-  updateResultsCount({
-    current = 0,
-    total = 0
-  } = {}) {
-    if (!this.findResultsCount) {
-      return;
+        _this2._adjustWidth();
+      });
+      this.updateResultsCount(matchesCount);
     }
+  }, {
+    key: "updateResultsCount",
+    value: function updateResultsCount() {
+      var _this3 = this;
 
-    const limit = MATCHES_COUNT_LIMIT;
-    let matchesCountMsg = "";
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref$current = _ref.current,
+          current = _ref$current === void 0 ? 0 : _ref$current,
+          _ref$total = _ref.total,
+          total = _ref$total === void 0 ? 0 : _ref$total;
 
-    if (total > 0) {
-      if (total > limit) {
-        matchesCountMsg = this.l10n.get("find_match_count_limit", {
-          limit
-        }, "More than {{limit}} match" + (limit !== 1 ? "es" : ""));
-      } else {
-        matchesCountMsg = this.l10n.get("find_match_count", {
-          current,
-          total
-        }, "{{current}} of {{total}} match" + (total !== 1 ? "es" : ""));
+      if (!this.findResultsCount) {
+        return;
       }
-    }
 
-    Promise.resolve(matchesCountMsg).then(msg => {
-      this.findResultsCount.textContent = msg;
-      this.findResultsCount.classList.toggle("hidden", !total);
-
-      this._adjustWidth();
-    });
-  }
+      var limit = MATCHES_COUNT_LIMIT;
+      var matchesCountMsg = "";
 
-  open() {
-    if (!this.opened) {
-      this.opened = true;
-      this.toggleButton.classList.add("toggled");
-      this.bar.classList.remove("hidden");
-    }
+      if (total > 0) {
+        if (total > limit) {
+          matchesCountMsg = this.l10n.get("find_match_count_limit", {
+            limit: limit
+          }, "More than {{limit}} match" + (limit !== 1 ? "es" : ""));
+        } else {
+          matchesCountMsg = this.l10n.get("find_match_count", {
+            current: current,
+            total: total
+          }, "{{current}} of {{total}} match" + (total !== 1 ? "es" : ""));
+        }
+      }
 
-    this.findField.select();
-    this.findField.focus();
+      Promise.resolve(matchesCountMsg).then(function (msg) {
+        _this3.findResultsCount.textContent = msg;
 
-    this._adjustWidth();
-  }
+        _this3.findResultsCount.classList.toggle("hidden", !total);
 
-  close() {
-    if (!this.opened) {
-      return;
+        _this3._adjustWidth();
+      });
     }
+  }, {
+    key: "open",
+    value: function open() {
+      if (!this.opened) {
+        this.opened = true;
+        this.toggleButton.classList.add("toggled");
+        this.bar.classList.remove("hidden");
+      }
 
-    this.opened = false;
-    this.toggleButton.classList.remove("toggled");
-    this.bar.classList.add("hidden");
-    this.eventBus.dispatch("findbarclose", {
-      source: this
-    });
-  }
+      this.findField.select();
+      this.findField.focus();
 
-  toggle() {
-    if (this.opened) {
-      this.close();
-    } else {
-      this.open();
+      this._adjustWidth();
     }
-  }
+  }, {
+    key: "close",
+    value: function close() {
+      if (!this.opened) {
+        return;
+      }
 
-  _adjustWidth() {
-    if (!this.opened) {
-      return;
+      this.opened = false;
+      this.toggleButton.classList.remove("toggled");
+      this.bar.classList.add("hidden");
+      this.eventBus.dispatch("findbarclose", {
+        source: this
+      });
+    }
+  }, {
+    key: "toggle",
+    value: function toggle() {
+      if (this.opened) {
+        this.close();
+      } else {
+        this.open();
+      }
     }
+  }, {
+    key: "_adjustWidth",
+    value: function _adjustWidth() {
+      if (!this.opened) {
+        return;
+      }
 
-    this.bar.classList.remove("wrapContainers");
-    const findbarHeight = this.bar.clientHeight;
-    const inputContainerHeight = this.bar.firstElementChild.clientHeight;
+      this.bar.classList.remove("wrapContainers");
+      var findbarHeight = this.bar.clientHeight;
+      var inputContainerHeight = this.bar.firstElementChild.clientHeight;
 
-    if (findbarHeight > inputContainerHeight) {
-      this.bar.classList.add("wrapContainers");
+      if (findbarHeight > inputContainerHeight) {
+        this.bar.classList.add("wrapContainers");
+      }
     }
-  }
+  }]);
 
-}
+  return PDFFindBar;
+}();
 
 exports.PDFFindBar = PDFFindBar;
 
 /***/ }),
-/* 15 */
+/* 18 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -5488,23 +7107,29 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFFindController = exports.FindState = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
 
-var _pdf_find_utils = __webpack_require__(16);
+var _pdf_find_utils = __webpack_require__(19);
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
 
-const FindState = {
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var FindState = {
   FOUND: 0,
   NOT_FOUND: 1,
   WRAPPED: 2,
   PENDING: 3
 };
 exports.FindState = FindState;
-const FIND_TIMEOUT = 250;
-const MATCH_SCROLL_OFFSET_TOP = -50;
-const MATCH_SCROLL_OFFSET_LEFT = -400;
-const CHARACTERS_TO_NORMALIZE = {
+var FIND_TIMEOUT = 250;
+var MATCH_SCROLL_OFFSET_TOP = -50;
+var MATCH_SCROLL_OFFSET_LEFT = -400;
+var CHARACTERS_TO_NORMALIZE = {
   "\u2018": "'",
   "\u2019": "'",
   "\u201A": "'",
@@ -5513,16 +7138,16 @@ const CHARACTERS_TO_NORMALIZE = {
   "\u201D": '"',
   "\u201E": '"',
   "\u201F": '"',
-  "\u00BC": "1/4",
-  "\u00BD": "1/2",
-  "\u00BE": "3/4"
+  "\xBC": "1/4",
+  "\xBD": "1/2",
+  "\xBE": "3/4"
 };
-let normalizationRegex = null;
+var normalizationRegex = null;
 
 function normalize(text) {
   if (!normalizationRegex) {
-    const replace = Object.keys(CHARACTERS_TO_NORMALIZE).join("");
-    normalizationRegex = new RegExp(`[${replace}]`, "g");
+    var replace = Object.keys(CHARACTERS_TO_NORMALIZE).join("");
+    normalizationRegex = new RegExp("[".concat(replace, "]"), "g");
   }
 
   return text.replace(normalizationRegex, function (ch) {
@@ -5530,11 +7155,13 @@ function normalize(text) {
   });
 }
 
-class PDFFindController {
-  constructor({
-    linkService,
-    eventBus
-  }) {
+var PDFFindController = /*#__PURE__*/function () {
+  function PDFFindController(_ref) {
+    var linkService = _ref.linkService,
+        eventBus = _ref.eventBus;
+
+    _classCallCheck(this, PDFFindController);
+
     this._linkService = linkService;
     this._eventBus = eventBus;
 
@@ -5543,622 +7170,668 @@ class PDFFindController {
     eventBus._on("findbarclose", this._onFindBarClose.bind(this));
   }
 
-  get highlightMatches() {
-    return this._highlightMatches;
-  }
-
-  get pageMatches() {
-    return this._pageMatches;
-  }
-
-  get pageMatchesLength() {
-    return this._pageMatchesLength;
-  }
-
-  get selected() {
-    return this._selected;
-  }
+  _createClass(PDFFindController, [{
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      if (this._pdfDocument) {
+        this._reset();
+      }
 
-  get state() {
-    return this._state;
-  }
+      if (!pdfDocument) {
+        return;
+      }
 
-  setDocument(pdfDocument) {
-    if (this._pdfDocument) {
-      this._reset();
-    }
+      this._pdfDocument = pdfDocument;
 
-    if (!pdfDocument) {
-      return;
+      this._firstPageCapability.resolve();
     }
+  }, {
+    key: "executeCommand",
+    value: function executeCommand(cmd, state) {
+      var _this = this;
 
-    this._pdfDocument = pdfDocument;
-
-    this._firstPageCapability.resolve();
-  }
+      if (!state) {
+        return;
+      }
 
-  executeCommand(cmd, state) {
-    if (!state) {
-      return;
-    }
+      var pdfDocument = this._pdfDocument;
 
-    const pdfDocument = this._pdfDocument;
+      if (this._state === null || this._shouldDirtyMatch(cmd, state)) {
+        this._dirtyMatch = true;
+      }
 
-    if (this._state === null || this._shouldDirtyMatch(cmd, state)) {
-      this._dirtyMatch = true;
-    }
+      this._state = state;
 
-    this._state = state;
+      if (cmd !== "findhighlightallchange") {
+        this._updateUIState(FindState.PENDING);
+      }
 
-    if (cmd !== "findhighlightallchange") {
-      this._updateUIState(FindState.PENDING);
-    }
+      this._firstPageCapability.promise.then(function () {
+        if (!_this._pdfDocument || pdfDocument && _this._pdfDocument !== pdfDocument) {
+          return;
+        }
 
-    this._firstPageCapability.promise.then(() => {
-      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
-        return;
-      }
+        _this._extractText();
 
-      this._extractText();
+        var findbarClosed = !_this._highlightMatches;
+        var pendingTimeout = !!_this._findTimeout;
 
-      const findbarClosed = !this._highlightMatches;
-      const pendingTimeout = !!this._findTimeout;
+        if (_this._findTimeout) {
+          clearTimeout(_this._findTimeout);
+          _this._findTimeout = null;
+        }
 
-      if (this._findTimeout) {
-        clearTimeout(this._findTimeout);
-        this._findTimeout = null;
-      }
+        if (cmd === "find") {
+          _this._findTimeout = setTimeout(function () {
+            _this._nextMatch();
 
-      if (cmd === "find") {
-        this._findTimeout = setTimeout(() => {
-          this._nextMatch();
+            _this._findTimeout = null;
+          }, FIND_TIMEOUT);
+        } else if (_this._dirtyMatch) {
+          _this._nextMatch();
+        } else if (cmd === "findagain") {
+          _this._nextMatch();
 
-          this._findTimeout = null;
-        }, FIND_TIMEOUT);
-      } else if (this._dirtyMatch) {
-        this._nextMatch();
-      } else if (cmd === "findagain") {
-        this._nextMatch();
+          if (findbarClosed && _this._state.highlightAll) {
+            _this._updateAllPages();
+          }
+        } else if (cmd === "findhighlightallchange") {
+          if (pendingTimeout) {
+            _this._nextMatch();
+          } else {
+            _this._highlightMatches = true;
+          }
 
-        if (findbarClosed && this._state.highlightAll) {
-          this._updateAllPages();
-        }
-      } else if (cmd === "findhighlightallchange") {
-        if (pendingTimeout) {
-          this._nextMatch();
+          _this._updateAllPages();
         } else {
-          this._highlightMatches = true;
+          _this._nextMatch();
         }
-
-        this._updateAllPages();
-      } else {
-        this._nextMatch();
+      });
+    }
+  }, {
+    key: "scrollMatchIntoView",
+    value: function scrollMatchIntoView(_ref2) {
+      var _ref2$element = _ref2.element,
+          element = _ref2$element === void 0 ? null : _ref2$element,
+          _ref2$pageIndex = _ref2.pageIndex,
+          pageIndex = _ref2$pageIndex === void 0 ? -1 : _ref2$pageIndex,
+          _ref2$matchIndex = _ref2.matchIndex,
+          matchIndex = _ref2$matchIndex === void 0 ? -1 : _ref2$matchIndex;
+
+      if (!this._scrollMatches || !element) {
+        return;
+      } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {
+        return;
+      } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {
+        return;
       }
-    });
-  }
 
-  scrollMatchIntoView({
-    element = null,
-    pageIndex = -1,
-    matchIndex = -1
-  }) {
-    if (!this._scrollMatches || !element) {
-      return;
-    } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {
-      return;
-    } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {
-      return;
+      this._scrollMatches = false;
+      var spot = {
+        top: MATCH_SCROLL_OFFSET_TOP,
+        left: MATCH_SCROLL_OFFSET_LEFT
+      };
+      (0, _ui_utils.scrollIntoView)(element, spot, true);
     }
+  }, {
+    key: "_reset",
+    value: function _reset() {
+      this._highlightMatches = false;
+      this._scrollMatches = false;
+      this._pdfDocument = null;
+      this._pageMatches = [];
+      this._pageMatchesLength = [];
+      this._state = null;
+      this._selected = {
+        pageIdx: -1,
+        matchIdx: -1
+      };
+      this._offset = {
+        pageIdx: null,
+        matchIdx: null,
+        wrapped: false
+      };
+      this._extractTextPromises = [];
+      this._pageContents = [];
+      this._matchesCountTotal = 0;
+      this._pagesToSearch = null;
+      this._pendingFindMatches = Object.create(null);
+      this._resumePageIdx = null;
+      this._dirtyMatch = false;
+      clearTimeout(this._findTimeout);
+      this._findTimeout = null;
+      this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+    }
+  }, {
+    key: "_shouldDirtyMatch",
+    value: function _shouldDirtyMatch(cmd, state) {
+      if (state.query !== this._state.query) {
+        return true;
+      }
 
-    this._scrollMatches = false;
-    const spot = {
-      top: MATCH_SCROLL_OFFSET_TOP,
-      left: MATCH_SCROLL_OFFSET_LEFT
-    };
-    (0, _ui_utils.scrollIntoView)(element, spot, true);
-  }
-
-  _reset() {
-    this._highlightMatches = false;
-    this._scrollMatches = false;
-    this._pdfDocument = null;
-    this._pageMatches = [];
-    this._pageMatchesLength = [];
-    this._state = null;
-    this._selected = {
-      pageIdx: -1,
-      matchIdx: -1
-    };
-    this._offset = {
-      pageIdx: null,
-      matchIdx: null,
-      wrapped: false
-    };
-    this._extractTextPromises = [];
-    this._pageContents = [];
-    this._matchesCountTotal = 0;
-    this._pagesToSearch = null;
-    this._pendingFindMatches = Object.create(null);
-    this._resumePageIdx = null;
-    this._dirtyMatch = false;
-    clearTimeout(this._findTimeout);
-    this._findTimeout = null;
-    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
-  }
+      switch (cmd) {
+        case "findagain":
+          var pageNumber = this._selected.pageIdx + 1;
+          var linkService = this._linkService;
 
-  get _query() {
-    if (this._state.query !== this._rawQuery) {
-      this._rawQuery = this._state.query;
-      this._normalizedQuery = normalize(this._state.query);
-    }
+          if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
+            return true;
+          }
 
-    return this._normalizedQuery;
-  }
+          return false;
+
+        case "findhighlightallchange":
+          return false;
+      }
 
-  _shouldDirtyMatch(cmd, state) {
-    if (state.query !== this._state.query) {
       return true;
     }
+  }, {
+    key: "_prepareMatches",
+    value: function _prepareMatches(matchesWithLength, matches, matchesLength) {
+      function isSubTerm(currentIndex) {
+        var currentElem = matchesWithLength[currentIndex];
+        var nextElem = matchesWithLength[currentIndex + 1];
 
-    switch (cmd) {
-      case "findagain":
-        const pageNumber = this._selected.pageIdx + 1;
-        const linkService = this._linkService;
-
-        if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
+        if (currentIndex < matchesWithLength.length - 1 && currentElem.match === nextElem.match) {
+          currentElem.skipped = true;
           return true;
         }
 
-        return false;
+        for (var i = currentIndex - 1; i >= 0; i--) {
+          var prevElem = matchesWithLength[i];
 
-      case "findhighlightallchange":
-        return false;
-    }
+          if (prevElem.skipped) {
+            continue;
+          }
 
-    return true;
-  }
+          if (prevElem.match + prevElem.matchLength < currentElem.match) {
+            break;
+          }
 
-  _prepareMatches(matchesWithLength, matches, matchesLength) {
-    function isSubTerm(currentIndex) {
-      const currentElem = matchesWithLength[currentIndex];
-      const nextElem = matchesWithLength[currentIndex + 1];
+          if (prevElem.match + prevElem.matchLength >= currentElem.match + currentElem.matchLength) {
+            currentElem.skipped = true;
+            return true;
+          }
+        }
 
-      if (currentIndex < matchesWithLength.length - 1 && currentElem.match === nextElem.match) {
-        currentElem.skipped = true;
-        return true;
+        return false;
       }
 
-      for (let i = currentIndex - 1; i >= 0; i--) {
-        const prevElem = matchesWithLength[i];
+      matchesWithLength.sort(function (a, b) {
+        return a.match === b.match ? a.matchLength - b.matchLength : a.match - b.match;
+      });
 
-        if (prevElem.skipped) {
+      for (var i = 0, len = matchesWithLength.length; i < len; i++) {
+        if (isSubTerm(i)) {
           continue;
         }
 
-        if (prevElem.match + prevElem.matchLength < currentElem.match) {
-          break;
-        }
-
-        if (prevElem.match + prevElem.matchLength >= currentElem.match + currentElem.matchLength) {
-          currentElem.skipped = true;
-          return true;
-        }
+        matches.push(matchesWithLength[i].match);
+        matchesLength.push(matchesWithLength[i].matchLength);
       }
-
-      return false;
     }
+  }, {
+    key: "_isEntireWord",
+    value: function _isEntireWord(content, startIdx, length) {
+      if (startIdx > 0) {
+        var first = content.charCodeAt(startIdx);
+        var limit = content.charCodeAt(startIdx - 1);
 
-    matchesWithLength.sort(function (a, b) {
-      return a.match === b.match ? a.matchLength - b.matchLength : a.match - b.match;
-    });
-
-    for (let i = 0, len = matchesWithLength.length; i < len; i++) {
-      if (isSubTerm(i)) {
-        continue;
+        if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
+          return false;
+        }
       }
 
-      matches.push(matchesWithLength[i].match);
-      matchesLength.push(matchesWithLength[i].matchLength);
-    }
-  }
-
-  _isEntireWord(content, startIdx, length) {
-    if (startIdx > 0) {
-      const first = content.charCodeAt(startIdx);
-      const limit = content.charCodeAt(startIdx - 1);
-
-      if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
-        return false;
-      }
-    }
+      var endIdx = startIdx + length - 1;
 
-    const endIdx = startIdx + length - 1;
+      if (endIdx < content.length - 1) {
+        var last = content.charCodeAt(endIdx);
 
-    if (endIdx < content.length - 1) {
-      const last = content.charCodeAt(endIdx);
-      const limit = content.charCodeAt(endIdx + 1);
+        var _limit = content.charCodeAt(endIdx + 1);
 
-      if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(limit)) {
-        return false;
+        if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(_limit)) {
+          return false;
+        }
       }
-    }
 
-    return true;
-  }
+      return true;
+    }
+  }, {
+    key: "_calculatePhraseMatch",
+    value: function _calculatePhraseMatch(query, pageIndex, pageContent, entireWord) {
+      var matches = [];
+      var queryLen = query.length;
+      var matchIdx = -queryLen;
 
-  _calculatePhraseMatch(query, pageIndex, pageContent, entireWord) {
-    const matches = [];
-    const queryLen = query.length;
-    let matchIdx = -queryLen;
+      while (true) {
+        matchIdx = pageContent.indexOf(query, matchIdx + queryLen);
 
-    while (true) {
-      matchIdx = pageContent.indexOf(query, matchIdx + queryLen);
+        if (matchIdx === -1) {
+          break;
+        }
 
-      if (matchIdx === -1) {
-        break;
-      }
+        if (entireWord && !this._isEntireWord(pageContent, matchIdx, queryLen)) {
+          continue;
+        }
 
-      if (entireWord && !this._isEntireWord(pageContent, matchIdx, queryLen)) {
-        continue;
+        matches.push(matchIdx);
       }
 
-      matches.push(matchIdx);
+      this._pageMatches[pageIndex] = matches;
     }
+  }, {
+    key: "_calculateWordMatch",
+    value: function _calculateWordMatch(query, pageIndex, pageContent, entireWord) {
+      var matchesWithLength = [];
+      var queryArray = query.match(/\S+/g);
 
-    this._pageMatches[pageIndex] = matches;
-  }
+      for (var i = 0, len = queryArray.length; i < len; i++) {
+        var subquery = queryArray[i];
+        var subqueryLen = subquery.length;
+        var matchIdx = -subqueryLen;
 
-  _calculateWordMatch(query, pageIndex, pageContent, entireWord) {
-    const matchesWithLength = [];
-    const queryArray = query.match(/\S+/g);
+        while (true) {
+          matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen);
 
-    for (let i = 0, len = queryArray.length; i < len; i++) {
-      const subquery = queryArray[i];
-      const subqueryLen = subquery.length;
-      let matchIdx = -subqueryLen;
+          if (matchIdx === -1) {
+            break;
+          }
 
-      while (true) {
-        matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen);
+          if (entireWord && !this._isEntireWord(pageContent, matchIdx, subqueryLen)) {
+            continue;
+          }
 
-        if (matchIdx === -1) {
-          break;
+          matchesWithLength.push({
+            match: matchIdx,
+            matchLength: subqueryLen,
+            skipped: false
+          });
         }
+      }
 
-        if (entireWord && !this._isEntireWord(pageContent, matchIdx, subqueryLen)) {
-          continue;
-        }
+      this._pageMatchesLength[pageIndex] = [];
+      this._pageMatches[pageIndex] = [];
 
-        matchesWithLength.push({
-          match: matchIdx,
-          matchLength: subqueryLen,
-          skipped: false
-        });
-      }
+      this._prepareMatches(matchesWithLength, this._pageMatches[pageIndex], this._pageMatchesLength[pageIndex]);
     }
+  }, {
+    key: "_calculateMatch",
+    value: function _calculateMatch(pageIndex) {
+      var pageContent = this._pageContents[pageIndex];
+      var query = this._query;
+      var _this$_state = this._state,
+          caseSensitive = _this$_state.caseSensitive,
+          entireWord = _this$_state.entireWord,
+          phraseSearch = _this$_state.phraseSearch;
 
-    this._pageMatchesLength[pageIndex] = [];
-    this._pageMatches[pageIndex] = [];
+      if (query.length === 0) {
+        return;
+      }
 
-    this._prepareMatches(matchesWithLength, this._pageMatches[pageIndex], this._pageMatchesLength[pageIndex]);
-  }
+      if (!caseSensitive) {
+        pageContent = pageContent.toLowerCase();
+        query = query.toLowerCase();
+      }
 
-  _calculateMatch(pageIndex) {
-    let pageContent = this._pageContents[pageIndex];
-    let query = this._query;
-    const {
-      caseSensitive,
-      entireWord,
-      phraseSearch
-    } = this._state;
+      if (phraseSearch) {
+        this._calculatePhraseMatch(query, pageIndex, pageContent, entireWord);
+      } else {
+        this._calculateWordMatch(query, pageIndex, pageContent, entireWord);
+      }
 
-    if (query.length === 0) {
-      return;
-    }
+      if (this._state.highlightAll) {
+        this._updatePage(pageIndex);
+      }
 
-    if (!caseSensitive) {
-      pageContent = pageContent.toLowerCase();
-      query = query.toLowerCase();
-    }
+      if (this._resumePageIdx === pageIndex) {
+        this._resumePageIdx = null;
 
-    if (phraseSearch) {
-      this._calculatePhraseMatch(query, pageIndex, pageContent, entireWord);
-    } else {
-      this._calculateWordMatch(query, pageIndex, pageContent, entireWord);
-    }
+        this._nextPageMatch();
+      }
 
-    if (this._state.highlightAll) {
-      this._updatePage(pageIndex);
-    }
+      var pageMatchesCount = this._pageMatches[pageIndex].length;
 
-    if (this._resumePageIdx === pageIndex) {
-      this._resumePageIdx = null;
+      if (pageMatchesCount > 0) {
+        this._matchesCountTotal += pageMatchesCount;
 
-      this._nextPageMatch();
+        this._updateUIResultsCount();
+      }
     }
+  }, {
+    key: "_extractText",
+    value: function _extractText() {
+      var _this2 = this;
 
-    const pageMatchesCount = this._pageMatches[pageIndex].length;
-
-    if (pageMatchesCount > 0) {
-      this._matchesCountTotal += pageMatchesCount;
+      if (this._extractTextPromises.length > 0) {
+        return;
+      }
 
-      this._updateUIResultsCount();
-    }
-  }
+      var promise = Promise.resolve();
 
-  _extractText() {
-    if (this._extractTextPromises.length > 0) {
-      return;
-    }
+      var _loop = function _loop(i, ii) {
+        var extractTextCapability = (0, _pdfjsLib.createPromiseCapability)();
+        _this2._extractTextPromises[i] = extractTextCapability.promise;
+        promise = promise.then(function () {
+          return _this2._pdfDocument.getPage(i + 1).then(function (pdfPage) {
+            return pdfPage.getTextContent({
+              normalizeWhitespace: true
+            });
+          }).then(function (textContent) {
+            var textItems = textContent.items;
+            var strBuf = [];
 
-    let promise = Promise.resolve();
+            for (var j = 0, jj = textItems.length; j < jj; j++) {
+              strBuf.push(textItems[j].str);
+            }
 
-    for (let i = 0, ii = this._linkService.pagesCount; i < ii; i++) {
-      const extractTextCapability = (0, _pdfjsLib.createPromiseCapability)();
-      this._extractTextPromises[i] = extractTextCapability.promise;
-      promise = promise.then(() => {
-        return this._pdfDocument.getPage(i + 1).then(pdfPage => {
-          return pdfPage.getTextContent({
-            normalizeWhitespace: true
+            _this2._pageContents[i] = normalize(strBuf.join(""));
+            extractTextCapability.resolve(i);
+          }, function (reason) {
+            console.error("Unable to get text content for page ".concat(i + 1), reason);
+            _this2._pageContents[i] = "";
+            extractTextCapability.resolve(i);
           });
-        }).then(textContent => {
-          const textItems = textContent.items;
-          const strBuf = [];
+        });
+      };
 
-          for (let j = 0, jj = textItems.length; j < jj; j++) {
-            strBuf.push(textItems[j].str);
-          }
+      for (var i = 0, ii = this._linkService.pagesCount; i < ii; i++) {
+        _loop(i, ii);
+      }
+    }
+  }, {
+    key: "_updatePage",
+    value: function _updatePage(index) {
+      if (this._scrollMatches && this._selected.pageIdx === index) {
+        this._linkService.page = index + 1;
+      }
 
-          this._pageContents[i] = normalize(strBuf.join(""));
-          extractTextCapability.resolve(i);
-        }, reason => {
-          console.error(`Unable to get text content for page ${i + 1}`, reason);
-          this._pageContents[i] = "";
-          extractTextCapability.resolve(i);
-        });
+      this._eventBus.dispatch("updatetextlayermatches", {
+        source: this,
+        pageIndex: index
       });
     }
-  }
-
-  _updatePage(index) {
-    if (this._scrollMatches && this._selected.pageIdx === index) {
-      this._linkService.page = index + 1;
+  }, {
+    key: "_updateAllPages",
+    value: function _updateAllPages() {
+      this._eventBus.dispatch("updatetextlayermatches", {
+        source: this,
+        pageIndex: -1
+      });
     }
+  }, {
+    key: "_nextMatch",
+    value: function _nextMatch() {
+      var _this3 = this;
+
+      var previous = this._state.findPrevious;
+      var currentPageIndex = this._linkService.page - 1;
+      var numPages = this._linkService.pagesCount;
+      this._highlightMatches = true;
+
+      if (this._dirtyMatch) {
+        this._dirtyMatch = false;
+        this._selected.pageIdx = this._selected.matchIdx = -1;
+        this._offset.pageIdx = currentPageIndex;
+        this._offset.matchIdx = null;
+        this._offset.wrapped = false;
+        this._resumePageIdx = null;
+        this._pageMatches.length = 0;
+        this._pageMatchesLength.length = 0;
+        this._matchesCountTotal = 0;
 
-    this._eventBus.dispatch("updatetextlayermatches", {
-      source: this,
-      pageIndex: index
-    });
-  }
-
-  _updateAllPages() {
-    this._eventBus.dispatch("updatetextlayermatches", {
-      source: this,
-      pageIndex: -1
-    });
-  }
+        this._updateAllPages();
 
-  _nextMatch() {
-    const previous = this._state.findPrevious;
-    const currentPageIndex = this._linkService.page - 1;
-    const numPages = this._linkService.pagesCount;
-    this._highlightMatches = true;
+        for (var i = 0; i < numPages; i++) {
+          if (this._pendingFindMatches[i] === true) {
+            continue;
+          }
 
-    if (this._dirtyMatch) {
-      this._dirtyMatch = false;
-      this._selected.pageIdx = this._selected.matchIdx = -1;
-      this._offset.pageIdx = currentPageIndex;
-      this._offset.matchIdx = null;
-      this._offset.wrapped = false;
-      this._resumePageIdx = null;
-      this._pageMatches.length = 0;
-      this._pageMatchesLength.length = 0;
-      this._matchesCountTotal = 0;
+          this._pendingFindMatches[i] = true;
 
-      this._updateAllPages();
+          this._extractTextPromises[i].then(function (pageIdx) {
+            delete _this3._pendingFindMatches[pageIdx];
 
-      for (let i = 0; i < numPages; i++) {
-        if (this._pendingFindMatches[i] === true) {
-          continue;
+            _this3._calculateMatch(pageIdx);
+          });
         }
+      }
 
-        this._pendingFindMatches[i] = true;
-
-        this._extractTextPromises[i].then(pageIdx => {
-          delete this._pendingFindMatches[pageIdx];
+      if (this._query === "") {
+        this._updateUIState(FindState.FOUND);
 
-          this._calculateMatch(pageIdx);
-        });
+        return;
       }
-    }
-
-    if (this._query === "") {
-      this._updateUIState(FindState.FOUND);
 
-      return;
-    }
+      if (this._resumePageIdx) {
+        return;
+      }
 
-    if (this._resumePageIdx) {
-      return;
-    }
+      var offset = this._offset;
+      this._pagesToSearch = numPages;
 
-    const offset = this._offset;
-    this._pagesToSearch = numPages;
+      if (offset.matchIdx !== null) {
+        var numPageMatches = this._pageMatches[offset.pageIdx].length;
 
-    if (offset.matchIdx !== null) {
-      const numPageMatches = this._pageMatches[offset.pageIdx].length;
+        if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
+          offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;
 
-      if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
-        offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;
+          this._updateMatch(true);
 
-        this._updateMatch(true);
+          return;
+        }
 
-        return;
+        this._advanceOffsetPage(previous);
       }
 
-      this._advanceOffsetPage(previous);
+      this._nextPageMatch();
     }
+  }, {
+    key: "_matchesReady",
+    value: function _matchesReady(matches) {
+      var offset = this._offset;
+      var numMatches = matches.length;
+      var previous = this._state.findPrevious;
 
-    this._nextPageMatch();
-  }
-
-  _matchesReady(matches) {
-    const offset = this._offset;
-    const numMatches = matches.length;
-    const previous = this._state.findPrevious;
-
-    if (numMatches) {
-      offset.matchIdx = previous ? numMatches - 1 : 0;
+      if (numMatches) {
+        offset.matchIdx = previous ? numMatches - 1 : 0;
 
-      this._updateMatch(true);
+        this._updateMatch(true);
 
-      return true;
-    }
+        return true;
+      }
 
-    this._advanceOffsetPage(previous);
+      this._advanceOffsetPage(previous);
 
-    if (offset.wrapped) {
-      offset.matchIdx = null;
+      if (offset.wrapped) {
+        offset.matchIdx = null;
 
-      if (this._pagesToSearch < 0) {
-        this._updateMatch(false);
+        if (this._pagesToSearch < 0) {
+          this._updateMatch(false);
 
-        return true;
+          return true;
+        }
       }
-    }
 
-    return false;
-  }
-
-  _nextPageMatch() {
-    if (this._resumePageIdx !== null) {
-      console.error("There can only be one pending page.");
+      return false;
     }
+  }, {
+    key: "_nextPageMatch",
+    value: function _nextPageMatch() {
+      if (this._resumePageIdx !== null) {
+        console.error("There can only be one pending page.");
+      }
 
-    let matches = null;
-
-    do {
-      const pageIdx = this._offset.pageIdx;
-      matches = this._pageMatches[pageIdx];
+      var matches = null;
 
-      if (!matches) {
-        this._resumePageIdx = pageIdx;
-        break;
-      }
-    } while (!this._matchesReady(matches));
-  }
+      do {
+        var pageIdx = this._offset.pageIdx;
+        matches = this._pageMatches[pageIdx];
 
-  _advanceOffsetPage(previous) {
-    const offset = this._offset;
-    const numPages = this._linkService.pagesCount;
-    offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
-    offset.matchIdx = null;
-    this._pagesToSearch--;
+        if (!matches) {
+          this._resumePageIdx = pageIdx;
+          break;
+        }
+      } while (!this._matchesReady(matches));
+    }
+  }, {
+    key: "_advanceOffsetPage",
+    value: function _advanceOffsetPage(previous) {
+      var offset = this._offset;
+      var numPages = this._linkService.pagesCount;
+      offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
+      offset.matchIdx = null;
+      this._pagesToSearch--;
 
-    if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
-      offset.pageIdx = previous ? numPages - 1 : 0;
-      offset.wrapped = true;
+      if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
+        offset.pageIdx = previous ? numPages - 1 : 0;
+        offset.wrapped = true;
+      }
     }
-  }
-
-  _updateMatch(found = false) {
-    let state = FindState.NOT_FOUND;
-    const wrapped = this._offset.wrapped;
-    this._offset.wrapped = false;
+  }, {
+    key: "_updateMatch",
+    value: function _updateMatch() {
+      var found = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var state = FindState.NOT_FOUND;
+      var wrapped = this._offset.wrapped;
+      this._offset.wrapped = false;
 
-    if (found) {
-      const previousPage = this._selected.pageIdx;
-      this._selected.pageIdx = this._offset.pageIdx;
-      this._selected.matchIdx = this._offset.matchIdx;
-      state = wrapped ? FindState.WRAPPED : FindState.FOUND;
+      if (found) {
+        var previousPage = this._selected.pageIdx;
+        this._selected.pageIdx = this._offset.pageIdx;
+        this._selected.matchIdx = this._offset.matchIdx;
+        state = wrapped ? FindState.WRAPPED : FindState.FOUND;
 
-      if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {
-        this._updatePage(previousPage);
+        if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {
+          this._updatePage(previousPage);
+        }
       }
-    }
 
-    this._updateUIState(state, this._state.findPrevious);
+      this._updateUIState(state, this._state.findPrevious);
 
-    if (this._selected.pageIdx !== -1) {
-      this._scrollMatches = true;
+      if (this._selected.pageIdx !== -1) {
+        this._scrollMatches = true;
 
-      this._updatePage(this._selected.pageIdx);
+        this._updatePage(this._selected.pageIdx);
+      }
     }
-  }
+  }, {
+    key: "_onFindBarClose",
+    value: function _onFindBarClose(evt) {
+      var _this4 = this;
 
-  _onFindBarClose(evt) {
-    const pdfDocument = this._pdfDocument;
+      var pdfDocument = this._pdfDocument;
 
-    this._firstPageCapability.promise.then(() => {
-      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
-        return;
-      }
+      this._firstPageCapability.promise.then(function () {
+        if (!_this4._pdfDocument || pdfDocument && _this4._pdfDocument !== pdfDocument) {
+          return;
+        }
 
-      if (this._findTimeout) {
-        clearTimeout(this._findTimeout);
-        this._findTimeout = null;
-      }
+        if (_this4._findTimeout) {
+          clearTimeout(_this4._findTimeout);
+          _this4._findTimeout = null;
+        }
 
-      if (this._resumePageIdx) {
-        this._resumePageIdx = null;
-        this._dirtyMatch = true;
-      }
+        if (_this4._resumePageIdx) {
+          _this4._resumePageIdx = null;
+          _this4._dirtyMatch = true;
+        }
 
-      this._updateUIState(FindState.FOUND);
+        _this4._updateUIState(FindState.FOUND);
 
-      this._highlightMatches = false;
+        _this4._highlightMatches = false;
 
-      this._updateAllPages();
-    });
-  }
+        _this4._updateAllPages();
+      });
+    }
+  }, {
+    key: "_requestMatchesCount",
+    value: function _requestMatchesCount() {
+      var _this$_selected = this._selected,
+          pageIdx = _this$_selected.pageIdx,
+          matchIdx = _this$_selected.matchIdx;
+      var current = 0,
+          total = this._matchesCountTotal;
+
+      if (matchIdx !== -1) {
+        for (var i = 0; i < pageIdx; i++) {
+          current += this._pageMatches[i] && this._pageMatches[i].length || 0;
+        }
 
-  _requestMatchesCount() {
-    const {
-      pageIdx,
-      matchIdx
-    } = this._selected;
-    let current = 0,
-        total = this._matchesCountTotal;
+        current += matchIdx + 1;
+      }
 
-    if (matchIdx !== -1) {
-      for (let i = 0; i < pageIdx; i++) {
-        current += this._pageMatches[i] && this._pageMatches[i].length || 0;
+      if (current < 1 || current > total) {
+        current = total = 0;
       }
 
-      current += matchIdx + 1;
+      return {
+        current: current,
+        total: total
+      };
     }
-
-    if (current < 1 || current > total) {
-      current = total = 0;
+  }, {
+    key: "_updateUIResultsCount",
+    value: function _updateUIResultsCount() {
+      this._eventBus.dispatch("updatefindmatchescount", {
+        source: this,
+        matchesCount: this._requestMatchesCount()
+      });
     }
+  }, {
+    key: "_updateUIState",
+    value: function _updateUIState(state, previous) {
+      this._eventBus.dispatch("updatefindcontrolstate", {
+        source: this,
+        state: state,
+        previous: previous,
+        matchesCount: this._requestMatchesCount()
+      });
+    }
+  }, {
+    key: "highlightMatches",
+    get: function get() {
+      return this._highlightMatches;
+    }
+  }, {
+    key: "pageMatches",
+    get: function get() {
+      return this._pageMatches;
+    }
+  }, {
+    key: "pageMatchesLength",
+    get: function get() {
+      return this._pageMatchesLength;
+    }
+  }, {
+    key: "selected",
+    get: function get() {
+      return this._selected;
+    }
+  }, {
+    key: "state",
+    get: function get() {
+      return this._state;
+    }
+  }, {
+    key: "_query",
+    get: function get() {
+      if (this._state.query !== this._rawQuery) {
+        this._rawQuery = this._state.query;
+        this._normalizedQuery = normalize(this._state.query);
+      }
 
-    return {
-      current,
-      total
-    };
-  }
-
-  _updateUIResultsCount() {
-    this._eventBus.dispatch("updatefindmatchescount", {
-      source: this,
-      matchesCount: this._requestMatchesCount()
-    });
-  }
-
-  _updateUIState(state, previous) {
-    this._eventBus.dispatch("updatefindcontrolstate", {
-      source: this,
-      state,
-      previous,
-      matchesCount: this._requestMatchesCount()
-    });
-  }
+      return this._normalizedQuery;
+    }
+  }]);
 
-}
+  return PDFFindController;
+}();
 
 exports.PDFFindController = PDFFindController;
 
 /***/ }),
-/* 16 */
+/* 19 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -6169,7 +7842,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getCharacterType = getCharacterType;
 exports.CharacterType = void 0;
-const CharacterType = {
+var CharacterType = {
   SPACE: 0,
   ALPHA_LETTER: 1,
   PUNCT: 2,
@@ -6254,7 +7927,7 @@ function getCharacterType(charCode) {
 }
 
 /***/ }),
-/* 17 */
+/* 20 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -6267,21 +7940,45 @@ exports.isDestHashesEqual = isDestHashesEqual;
 exports.isDestArraysEqual = isDestArraysEqual;
 exports.PDFHistory = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
-const HASH_CHANGE_TIMEOUT = 1000;
-const POSITION_UPDATED_THRESHOLD = 50;
-const UPDATE_VIEWAREA_TIMEOUT = 1000;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var HASH_CHANGE_TIMEOUT = 1000;
+var POSITION_UPDATED_THRESHOLD = 50;
+var UPDATE_VIEWAREA_TIMEOUT = 1000;
 
 function getCurrentHash() {
   return document.location.hash;
 }
 
-class PDFHistory {
-  constructor({
-    linkService,
-    eventBus
-  }) {
+var PDFHistory = /*#__PURE__*/function () {
+  function PDFHistory(_ref) {
+    var _this = this;
+
+    var linkService = _ref.linkService,
+        eventBus = _ref.eventBus;
+
+    _classCallCheck(this, PDFHistory);
+
     this.linkService = linkService;
     this.eventBus = eventBus;
     this._initialized = false;
@@ -6290,490 +7987,528 @@ class PDFHistory {
     this._boundEvents = null;
     this._isViewerInPresentationMode = false;
 
-    this.eventBus._on("presentationmodechanged", evt => {
-      this._isViewerInPresentationMode = evt.active || evt.switchInProgress;
+    this.eventBus._on("presentationmodechanged", function (evt) {
+      _this._isViewerInPresentationMode = evt.active || evt.switchInProgress;
     });
 
-    this.eventBus._on("pagesinit", () => {
-      this._isPagesLoaded = false;
+    this.eventBus._on("pagesinit", function () {
+      _this._isPagesLoaded = false;
 
-      const onPagesLoaded = evt => {
-        this.eventBus._off("pagesloaded", onPagesLoaded);
+      var onPagesLoaded = function onPagesLoaded(evt) {
+        _this.eventBus._off("pagesloaded", onPagesLoaded);
 
-        this._isPagesLoaded = !!evt.pagesCount;
+        _this._isPagesLoaded = !!evt.pagesCount;
       };
 
-      this.eventBus._on("pagesloaded", onPagesLoaded);
+      _this.eventBus._on("pagesloaded", onPagesLoaded);
     });
   }
 
-  initialize({
-    fingerprint,
-    resetHistory = false,
-    updateUrl = false
-  }) {
-    if (!fingerprint || typeof fingerprint !== "string") {
-      console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.');
-      return;
-    }
+  _createClass(PDFHistory, [{
+    key: "initialize",
+    value: function initialize(_ref2) {
+      var fingerprint = _ref2.fingerprint,
+          _ref2$resetHistory = _ref2.resetHistory,
+          resetHistory = _ref2$resetHistory === void 0 ? false : _ref2$resetHistory,
+          _ref2$updateUrl = _ref2.updateUrl,
+          updateUrl = _ref2$updateUrl === void 0 ? false : _ref2$updateUrl;
 
-    if (this._initialized) {
-      this.reset();
-    }
+      if (!fingerprint || typeof fingerprint !== "string") {
+        console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.');
+        return;
+      }
 
-    const reInitialized = this._fingerprint !== "" && this._fingerprint !== fingerprint;
-    this._fingerprint = fingerprint;
-    this._updateUrl = updateUrl === true;
-    this._initialized = true;
+      if (this._initialized) {
+        this.reset();
+      }
 
-    this._bindEvents();
+      var reInitialized = this._fingerprint !== "" && this._fingerprint !== fingerprint;
+      this._fingerprint = fingerprint;
+      this._updateUrl = updateUrl === true;
+      this._initialized = true;
 
-    const state = window.history.state;
-    this._popStateInProgress = false;
-    this._blockHashChange = 0;
-    this._currentHash = getCurrentHash();
-    this._numPositionUpdates = 0;
-    this._uid = this._maxUid = 0;
-    this._destination = null;
-    this._position = null;
+      this._bindEvents();
 
-    if (!this._isValidState(state, true) || resetHistory) {
-      const {
-        hash,
-        page,
-        rotation
-      } = this._parseCurrentHash(true);
+      var state = window.history.state;
+      this._popStateInProgress = false;
+      this._blockHashChange = 0;
+      this._currentHash = getCurrentHash();
+      this._numPositionUpdates = 0;
+      this._uid = this._maxUid = 0;
+      this._destination = null;
+      this._position = null;
+
+      if (!this._isValidState(state, true) || resetHistory) {
+        var _this$_parseCurrentHa = this._parseCurrentHash(true),
+            hash = _this$_parseCurrentHa.hash,
+            page = _this$_parseCurrentHa.page,
+            rotation = _this$_parseCurrentHa.rotation;
+
+        if (!hash || reInitialized || resetHistory) {
+          this._pushOrReplaceState(null, true);
 
-      if (!hash || reInitialized || resetHistory) {
-        this._pushOrReplaceState(null, true);
+          return;
+        }
+
+        this._pushOrReplaceState({
+          hash: hash,
+          page: page,
+          rotation: rotation
+        }, true);
 
         return;
       }
 
-      this._pushOrReplaceState({
-        hash,
-        page,
-        rotation
-      }, true);
-
-      return;
-    }
+      var destination = state.destination;
 
-    const destination = state.destination;
+      this._updateInternalState(destination, state.uid, true);
 
-    this._updateInternalState(destination, state.uid, true);
-
-    if (this._uid > this._maxUid) {
-      this._maxUid = this._uid;
-    }
+      if (this._uid > this._maxUid) {
+        this._maxUid = this._uid;
+      }
 
-    if (destination.rotation !== undefined) {
-      this._initialRotation = destination.rotation;
-    }
+      if (destination.rotation !== undefined) {
+        this._initialRotation = destination.rotation;
+      }
 
-    if (destination.dest) {
-      this._initialBookmark = JSON.stringify(destination.dest);
-      this._destination.page = null;
-    } else if (destination.hash) {
-      this._initialBookmark = destination.hash;
-    } else if (destination.page) {
-      this._initialBookmark = `page=${destination.page}`;
+      if (destination.dest) {
+        this._initialBookmark = JSON.stringify(destination.dest);
+        this._destination.page = null;
+      } else if (destination.hash) {
+        this._initialBookmark = destination.hash;
+      } else if (destination.page) {
+        this._initialBookmark = "page=".concat(destination.page);
+      }
     }
-  }
+  }, {
+    key: "reset",
+    value: function reset() {
+      if (this._initialized) {
+        this._pageHide();
 
-  reset() {
-    if (this._initialized) {
-      this._pageHide();
+        this._initialized = false;
 
-      this._initialized = false;
+        this._unbindEvents();
+      }
 
-      this._unbindEvents();
-    }
+      if (this._updateViewareaTimeout) {
+        clearTimeout(this._updateViewareaTimeout);
+        this._updateViewareaTimeout = null;
+      }
 
-    if (this._updateViewareaTimeout) {
-      clearTimeout(this._updateViewareaTimeout);
-      this._updateViewareaTimeout = null;
+      this._initialBookmark = null;
+      this._initialRotation = null;
     }
+  }, {
+    key: "push",
+    value: function push(_ref3) {
+      var _this2 = this;
 
-    this._initialBookmark = null;
-    this._initialRotation = null;
-  }
-
-  push({
-    namedDest = null,
-    explicitDest,
-    pageNumber
-  }) {
-    if (!this._initialized) {
-      return;
-    }
+      var _ref3$namedDest = _ref3.namedDest,
+          namedDest = _ref3$namedDest === void 0 ? null : _ref3$namedDest,
+          explicitDest = _ref3.explicitDest,
+          pageNumber = _ref3.pageNumber;
 
-    if (namedDest && typeof namedDest !== "string") {
-      console.error("PDFHistory.push: " + `"${namedDest}" is not a valid namedDest parameter.`);
-      return;
-    } else if (!Array.isArray(explicitDest)) {
-      console.error("PDFHistory.push: " + `"${explicitDest}" is not a valid explicitDest parameter.`);
-      return;
-    } else if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.linkService.pagesCount)) {
-      if (pageNumber !== null || this._destination) {
-        console.error("PDFHistory.push: " + `"${pageNumber}" is not a valid pageNumber parameter.`);
+      if (!this._initialized) {
         return;
       }
-    }
 
-    const hash = namedDest || JSON.stringify(explicitDest);
-
-    if (!hash) {
-      return;
-    }
+      if (namedDest && typeof namedDest !== "string") {
+        console.error("PDFHistory.push: " + "\"".concat(namedDest, "\" is not a valid namedDest parameter."));
+        return;
+      } else if (!Array.isArray(explicitDest)) {
+        console.error("PDFHistory.push: " + "\"".concat(explicitDest, "\" is not a valid explicitDest parameter."));
+        return;
+      } else if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.linkService.pagesCount)) {
+        if (pageNumber !== null || this._destination) {
+          console.error("PDFHistory.push: " + "\"".concat(pageNumber, "\" is not a valid pageNumber parameter."));
+          return;
+        }
+      }
 
-    let forceReplace = false;
+      var hash = namedDest || JSON.stringify(explicitDest);
 
-    if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
-      if (this._destination.page) {
+      if (!hash) {
         return;
       }
 
-      forceReplace = true;
-    }
+      var forceReplace = false;
 
-    if (this._popStateInProgress && !forceReplace) {
-      return;
-    }
+      if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
+        if (this._destination.page) {
+          return;
+        }
 
-    this._pushOrReplaceState({
-      dest: explicitDest,
-      hash,
-      page: pageNumber,
-      rotation: this.linkService.rotation
-    }, forceReplace);
+        forceReplace = true;
+      }
 
-    if (!this._popStateInProgress) {
-      this._popStateInProgress = true;
-      Promise.resolve().then(() => {
-        this._popStateInProgress = false;
-      });
-    }
-  }
+      if (this._popStateInProgress && !forceReplace) {
+        return;
+      }
 
-  pushCurrentPosition() {
-    if (!this._initialized || this._popStateInProgress) {
-      return;
+      this._pushOrReplaceState({
+        dest: explicitDest,
+        hash: hash,
+        page: pageNumber,
+        rotation: this.linkService.rotation
+      }, forceReplace);
+
+      if (!this._popStateInProgress) {
+        this._popStateInProgress = true;
+        Promise.resolve().then(function () {
+          _this2._popStateInProgress = false;
+        });
+      }
     }
+  }, {
+    key: "pushCurrentPosition",
+    value: function pushCurrentPosition() {
+      if (!this._initialized || this._popStateInProgress) {
+        return;
+      }
 
-    this._tryPushCurrentPosition();
-  }
-
-  back() {
-    if (!this._initialized || this._popStateInProgress) {
-      return;
+      this._tryPushCurrentPosition();
     }
+  }, {
+    key: "back",
+    value: function back() {
+      if (!this._initialized || this._popStateInProgress) {
+        return;
+      }
 
-    const state = window.history.state;
-
-    if (this._isValidState(state) && state.uid > 0) {
-      window.history.back();
-    }
-  }
+      var state = window.history.state;
 
-  forward() {
-    if (!this._initialized || this._popStateInProgress) {
-      return;
+      if (this._isValidState(state) && state.uid > 0) {
+        window.history.back();
+      }
     }
+  }, {
+    key: "forward",
+    value: function forward() {
+      if (!this._initialized || this._popStateInProgress) {
+        return;
+      }
 
-    const state = window.history.state;
+      var state = window.history.state;
 
-    if (this._isValidState(state) && state.uid < this._maxUid) {
-      window.history.forward();
+      if (this._isValidState(state) && state.uid < this._maxUid) {
+        window.history.forward();
+      }
     }
-  }
-
-  get popStateInProgress() {
-    return this._initialized && (this._popStateInProgress || this._blockHashChange > 0);
-  }
-
-  get initialBookmark() {
-    return this._initialized ? this._initialBookmark : null;
-  }
-
-  get initialRotation() {
-    return this._initialized ? this._initialRotation : null;
-  }
+  }, {
+    key: "_pushOrReplaceState",
+    value: function _pushOrReplaceState(destination) {
+      var forceReplace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var shouldReplace = forceReplace || !this._destination;
+      var newState = {
+        fingerprint: this._fingerprint,
+        uid: shouldReplace ? this._uid : this._uid + 1,
+        destination: destination
+      };
 
-  _pushOrReplaceState(destination, forceReplace = false) {
-    const shouldReplace = forceReplace || !this._destination;
-    const newState = {
-      fingerprint: this._fingerprint,
-      uid: shouldReplace ? this._uid : this._uid + 1,
-      destination
-    };
+      this._updateInternalState(destination, newState.uid);
 
-    this._updateInternalState(destination, newState.uid);
+      var newUrl;
 
-    let newUrl;
+      if (this._updateUrl && destination && destination.hash) {
+        var baseUrl = document.location.href.split("#")[0];
 
-    if (this._updateUrl && destination && destination.hash) {
-      const baseUrl = document.location.href.split("#")[0];
+        if (!baseUrl.startsWith("file://")) {
+          newUrl = "".concat(baseUrl, "#").concat(destination.hash);
+        }
+      }
 
-      if (!baseUrl.startsWith("file://")) {
-        newUrl = `${baseUrl}#${destination.hash}`;
+      if (shouldReplace) {
+        window.history.replaceState(newState, "", newUrl);
+      } else {
+        this._maxUid = this._uid;
+        window.history.pushState(newState, "", newUrl);
       }
     }
+  }, {
+    key: "_tryPushCurrentPosition",
+    value: function _tryPushCurrentPosition() {
+      var temporary = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-    if (shouldReplace) {
-      window.history.replaceState(newState, "", newUrl);
-    } else {
-      this._maxUid = this._uid;
-      window.history.pushState(newState, "", newUrl);
-    }
-  }
+      if (!this._position) {
+        return;
+      }
 
-  _tryPushCurrentPosition(temporary = false) {
-    if (!this._position) {
-      return;
-    }
+      var position = this._position;
 
-    let position = this._position;
+      if (temporary) {
+        position = Object.assign(Object.create(null), this._position);
+        position.temporary = true;
+      }
 
-    if (temporary) {
-      position = Object.assign(Object.create(null), this._position);
-      position.temporary = true;
-    }
+      if (!this._destination) {
+        this._pushOrReplaceState(position);
 
-    if (!this._destination) {
-      this._pushOrReplaceState(position);
+        return;
+      }
 
-      return;
-    }
+      if (this._destination.temporary) {
+        this._pushOrReplaceState(position, true);
 
-    if (this._destination.temporary) {
-      this._pushOrReplaceState(position, true);
+        return;
+      }
 
-      return;
-    }
+      if (this._destination.hash === position.hash) {
+        return;
+      }
 
-    if (this._destination.hash === position.hash) {
-      return;
-    }
+      if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
+        return;
+      }
 
-    if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
-      return;
-    }
+      var forceReplace = false;
 
-    let forceReplace = false;
+      if (this._destination.page >= position.first && this._destination.page <= position.page) {
+        if (this._destination.dest || !this._destination.first) {
+          return;
+        }
 
-    if (this._destination.page >= position.first && this._destination.page <= position.page) {
-      if (this._destination.dest || !this._destination.first) {
-        return;
+        forceReplace = true;
       }
 
-      forceReplace = true;
+      this._pushOrReplaceState(position, forceReplace);
     }
+  }, {
+    key: "_isValidState",
+    value: function _isValidState(state) {
+      var checkReload = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-    this._pushOrReplaceState(position, forceReplace);
-  }
-
-  _isValidState(state, checkReload = false) {
-    if (!state) {
-      return false;
-    }
+      if (!state) {
+        return false;
+      }
 
-    if (state.fingerprint !== this._fingerprint) {
-      if (checkReload) {
-        if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
-          return false;
-        }
+      if (state.fingerprint !== this._fingerprint) {
+        if (checkReload) {
+          if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
+            return false;
+          }
 
-        const [perfEntry] = performance.getEntriesByType("navigation");
+          var _performance$getEntri = performance.getEntriesByType("navigation"),
+              _performance$getEntri2 = _slicedToArray(_performance$getEntri, 1),
+              perfEntry = _performance$getEntri2[0];
 
-        if (!perfEntry || perfEntry.type !== "reload") {
+          if (!perfEntry || perfEntry.type !== "reload") {
+            return false;
+          }
+        } else {
           return false;
         }
-      } else {
+      }
+
+      if (!Number.isInteger(state.uid) || state.uid < 0) {
         return false;
       }
-    }
 
-    if (!Number.isInteger(state.uid) || state.uid < 0) {
-      return false;
-    }
+      if (state.destination === null || _typeof(state.destination) !== "object") {
+        return false;
+      }
 
-    if (state.destination === null || typeof state.destination !== "object") {
-      return false;
+      return true;
     }
+  }, {
+    key: "_updateInternalState",
+    value: function _updateInternalState(destination, uid) {
+      var removeTemporary = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 
-    return true;
-  }
+      if (this._updateViewareaTimeout) {
+        clearTimeout(this._updateViewareaTimeout);
+        this._updateViewareaTimeout = null;
+      }
 
-  _updateInternalState(destination, uid, removeTemporary = false) {
-    if (this._updateViewareaTimeout) {
-      clearTimeout(this._updateViewareaTimeout);
-      this._updateViewareaTimeout = null;
-    }
+      if (removeTemporary && destination && destination.temporary) {
+        delete destination.temporary;
+      }
 
-    if (removeTemporary && destination && destination.temporary) {
-      delete destination.temporary;
+      this._destination = destination;
+      this._uid = uid;
+      this._numPositionUpdates = 0;
     }
+  }, {
+    key: "_parseCurrentHash",
+    value: function _parseCurrentHash() {
+      var checkNameddest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var hash = unescape(getCurrentHash()).substring(1);
+      var params = (0, _ui_utils.parseQueryString)(hash);
+      var nameddest = params.nameddest || "";
+      var page = params.page | 0;
 
-    this._destination = destination;
-    this._uid = uid;
-    this._numPositionUpdates = 0;
-  }
-
-  _parseCurrentHash(checkNameddest = false) {
-    const hash = unescape(getCurrentHash()).substring(1);
-    const params = (0, _ui_utils.parseQueryString)(hash);
-    const nameddest = params.nameddest || "";
-    let page = params.page | 0;
+      if (!(Number.isInteger(page) && page > 0 && page <= this.linkService.pagesCount) || checkNameddest && nameddest.length > 0) {
+        page = null;
+      }
 
-    if (!(Number.isInteger(page) && page > 0 && page <= this.linkService.pagesCount) || checkNameddest && nameddest.length > 0) {
-      page = null;
+      return {
+        hash: hash,
+        page: page,
+        rotation: this.linkService.rotation
+      };
     }
+  }, {
+    key: "_updateViewarea",
+    value: function _updateViewarea(_ref4) {
+      var _this3 = this;
 
-    return {
-      hash,
-      page,
-      rotation: this.linkService.rotation
-    };
-  }
+      var location = _ref4.location;
 
-  _updateViewarea({
-    location
-  }) {
-    if (this._updateViewareaTimeout) {
-      clearTimeout(this._updateViewareaTimeout);
-      this._updateViewareaTimeout = null;
-    }
+      if (this._updateViewareaTimeout) {
+        clearTimeout(this._updateViewareaTimeout);
+        this._updateViewareaTimeout = null;
+      }
 
-    this._position = {
-      hash: this._isViewerInPresentationMode ? `page=${location.pageNumber}` : location.pdfOpenParams.substring(1),
-      page: this.linkService.page,
-      first: location.pageNumber,
-      rotation: location.rotation
-    };
+      this._position = {
+        hash: this._isViewerInPresentationMode ? "page=".concat(location.pageNumber) : location.pdfOpenParams.substring(1),
+        page: this.linkService.page,
+        first: location.pageNumber,
+        rotation: location.rotation
+      };
 
-    if (this._popStateInProgress) {
-      return;
-    }
+      if (this._popStateInProgress) {
+        return;
+      }
 
-    if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
-      this._numPositionUpdates++;
-    }
+      if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
+        this._numPositionUpdates++;
+      }
 
-    if (UPDATE_VIEWAREA_TIMEOUT > 0) {
-      this._updateViewareaTimeout = setTimeout(() => {
-        if (!this._popStateInProgress) {
-          this._tryPushCurrentPosition(true);
-        }
+      if (UPDATE_VIEWAREA_TIMEOUT > 0) {
+        this._updateViewareaTimeout = setTimeout(function () {
+          if (!_this3._popStateInProgress) {
+            _this3._tryPushCurrentPosition(true);
+          }
 
-        this._updateViewareaTimeout = null;
-      }, UPDATE_VIEWAREA_TIMEOUT);
+          _this3._updateViewareaTimeout = null;
+        }, UPDATE_VIEWAREA_TIMEOUT);
+      }
     }
-  }
+  }, {
+    key: "_popState",
+    value: function _popState(_ref5) {
+      var _this4 = this;
 
-  _popState({
-    state
-  }) {
-    const newHash = getCurrentHash(),
+      var state = _ref5.state;
+      var newHash = getCurrentHash(),
           hashChanged = this._currentHash !== newHash;
-    this._currentHash = newHash;
+      this._currentHash = newHash;
 
-    if (!state) {
-      this._uid++;
+      if (!state) {
+        this._uid++;
 
-      const {
-        hash,
-        page,
-        rotation
-      } = this._parseCurrentHash();
-
-      this._pushOrReplaceState({
-        hash,
-        page,
-        rotation
-      }, true);
+        var _this$_parseCurrentHa2 = this._parseCurrentHash(),
+            hash = _this$_parseCurrentHa2.hash,
+            page = _this$_parseCurrentHa2.page,
+            rotation = _this$_parseCurrentHa2.rotation;
 
-      return;
-    }
+        this._pushOrReplaceState({
+          hash: hash,
+          page: page,
+          rotation: rotation
+        }, true);
 
-    if (!this._isValidState(state)) {
-      return;
-    }
+        return;
+      }
 
-    this._popStateInProgress = true;
+      if (!this._isValidState(state)) {
+        return;
+      }
 
-    if (hashChanged) {
-      this._blockHashChange++;
-      (0, _ui_utils.waitOnEventOrTimeout)({
-        target: window,
-        name: "hashchange",
-        delay: HASH_CHANGE_TIMEOUT
-      }).then(() => {
-        this._blockHashChange--;
-      });
-    }
+      this._popStateInProgress = true;
 
-    const destination = state.destination;
+      if (hashChanged) {
+        this._blockHashChange++;
+        (0, _ui_utils.waitOnEventOrTimeout)({
+          target: window,
+          name: "hashchange",
+          delay: HASH_CHANGE_TIMEOUT
+        }).then(function () {
+          _this4._blockHashChange--;
+        });
+      }
 
-    this._updateInternalState(destination, state.uid, true);
+      var destination = state.destination;
 
-    if (this._uid > this._maxUid) {
-      this._maxUid = this._uid;
-    }
+      this._updateInternalState(destination, state.uid, true);
 
-    if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
-      this.linkService.rotation = destination.rotation;
-    }
+      if (this._uid > this._maxUid) {
+        this._maxUid = this._uid;
+      }
 
-    if (destination.dest) {
-      this.linkService.navigateTo(destination.dest);
-    } else if (destination.hash) {
-      this.linkService.setHash(destination.hash);
-    } else if (destination.page) {
-      this.linkService.page = destination.page;
-    }
+      if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
+        this.linkService.rotation = destination.rotation;
+      }
 
-    Promise.resolve().then(() => {
-      this._popStateInProgress = false;
-    });
-  }
+      if (destination.dest) {
+        this.linkService.navigateTo(destination.dest);
+      } else if (destination.hash) {
+        this.linkService.setHash(destination.hash);
+      } else if (destination.page) {
+        this.linkService.page = destination.page;
+      }
 
-  _pageHide() {
-    if (!this._destination || this._destination.temporary) {
-      this._tryPushCurrentPosition();
+      Promise.resolve().then(function () {
+        _this4._popStateInProgress = false;
+      });
     }
-  }
-
-  _bindEvents() {
-    if (this._boundEvents) {
-      return;
+  }, {
+    key: "_pageHide",
+    value: function _pageHide() {
+      if (!this._destination || this._destination.temporary) {
+        this._tryPushCurrentPosition();
+      }
     }
+  }, {
+    key: "_bindEvents",
+    value: function _bindEvents() {
+      if (this._boundEvents) {
+        return;
+      }
 
-    this._boundEvents = {
-      updateViewarea: this._updateViewarea.bind(this),
-      popState: this._popState.bind(this),
-      pageHide: this._pageHide.bind(this)
-    };
-
-    this.eventBus._on("updateviewarea", this._boundEvents.updateViewarea);
+      this._boundEvents = {
+        updateViewarea: this._updateViewarea.bind(this),
+        popState: this._popState.bind(this),
+        pageHide: this._pageHide.bind(this)
+      };
 
-    window.addEventListener("popstate", this._boundEvents.popState);
-    window.addEventListener("pagehide", this._boundEvents.pageHide);
-  }
+      this.eventBus._on("updateviewarea", this._boundEvents.updateViewarea);
 
-  _unbindEvents() {
-    if (!this._boundEvents) {
-      return;
+      window.addEventListener("popstate", this._boundEvents.popState);
+      window.addEventListener("pagehide", this._boundEvents.pageHide);
     }
+  }, {
+    key: "_unbindEvents",
+    value: function _unbindEvents() {
+      if (!this._boundEvents) {
+        return;
+      }
 
-    this.eventBus._off("updateviewarea", this._boundEvents.updateViewarea);
+      this.eventBus._off("updateviewarea", this._boundEvents.updateViewarea);
 
-    window.removeEventListener("popstate", this._boundEvents.popState);
-    window.removeEventListener("pagehide", this._boundEvents.pageHide);
-    this._boundEvents = null;
-  }
+      window.removeEventListener("popstate", this._boundEvents.popState);
+      window.removeEventListener("pagehide", this._boundEvents.pageHide);
+      this._boundEvents = null;
+    }
+  }, {
+    key: "popStateInProgress",
+    get: function get() {
+      return this._initialized && (this._popStateInProgress || this._blockHashChange > 0);
+    }
+  }, {
+    key: "initialBookmark",
+    get: function get() {
+      return this._initialized ? this._initialBookmark : null;
+    }
+  }, {
+    key: "initialRotation",
+    get: function get() {
+      return this._initialized ? this._initialRotation : null;
+    }
+  }]);
 
-}
+  return PDFHistory;
+}();
 
 exports.PDFHistory = PDFHistory;
 
@@ -6786,9 +8521,8 @@ function isDestHashesEqual(destHash, pushHash) {
     return true;
   }
 
-  const {
-    nameddest
-  } = (0, _ui_utils.parseQueryString)(destHash);
+  var _parseQueryString = (0, _ui_utils.parseQueryString)(destHash),
+      nameddest = _parseQueryString.nameddest;
 
   if (nameddest === pushHash) {
     return true;
@@ -6799,7 +8533,7 @@ function isDestHashesEqual(destHash, pushHash) {
 
 function isDestArraysEqual(firstDest, secondDest) {
   function isEntryEqual(first, second) {
-    if (typeof first !== typeof second) {
+    if (_typeof(first) !== _typeof(second)) {
       return false;
     }
 
@@ -6807,12 +8541,12 @@ function isDestArraysEqual(firstDest, secondDest) {
       return false;
     }
 
-    if (first !== null && typeof first === "object" && second !== null) {
+    if (first !== null && _typeof(first) === "object" && second !== null) {
       if (Object.keys(first).length !== Object.keys(second).length) {
         return false;
       }
 
-      for (const key in first) {
+      for (var key in first) {
         if (!isEntryEqual(first[key], second[key])) {
           return false;
         }
@@ -6832,7 +8566,7 @@ function isDestArraysEqual(firstDest, secondDest) {
     return false;
   }
 
-  for (let i = 0, ii = firstDest.length; i < ii; i++) {
+  for (var i = 0, ii = firstDest.length; i < ii; i++) {
     if (!isEntryEqual(firstDest[i], secondDest[i])) {
       return false;
     }
@@ -6842,7 +8576,7 @@ function isDestArraysEqual(firstDest, secondDest) {
 }
 
 /***/ }),
-/* 18 */
+/* 21 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -6853,16 +8587,31 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SimpleLinkService = exports.PDFLinkService = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var PDFLinkService = /*#__PURE__*/function () {
+  function PDFLinkService() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        eventBus = _ref.eventBus,
+        _ref$externalLinkTarg = _ref.externalLinkTarget,
+        externalLinkTarget = _ref$externalLinkTarg === void 0 ? null : _ref$externalLinkTarg,
+        _ref$externalLinkRel = _ref.externalLinkRel,
+        externalLinkRel = _ref$externalLinkRel === void 0 ? null : _ref$externalLinkRel,
+        _ref$externalLinkEnab = _ref.externalLinkEnabled,
+        externalLinkEnabled = _ref$externalLinkEnab === void 0 ? true : _ref$externalLinkEnab,
+        _ref$ignoreDestinatio = _ref.ignoreDestinationZoom,
+        ignoreDestinationZoom = _ref$ignoreDestinatio === void 0 ? false : _ref$ignoreDestinatio;
+
+    _classCallCheck(this, PDFLinkService);
 
-class PDFLinkService {
-  constructor({
-    eventBus,
-    externalLinkTarget = null,
-    externalLinkRel = null,
-    externalLinkEnabled = true,
-    ignoreDestinationZoom = false
-  } = {}) {
     this.eventBus = eventBus;
     this.externalLinkTarget = externalLinkTarget;
     this.externalLinkRel = externalLinkRel;
@@ -6875,290 +8624,311 @@ class PDFLinkService {
     this._pagesRefCache = null;
   }
 
-  setDocument(pdfDocument, baseUrl = null) {
-    this.baseUrl = baseUrl;
-    this.pdfDocument = pdfDocument;
-    this._pagesRefCache = Object.create(null);
-  }
-
-  setViewer(pdfViewer) {
-    this.pdfViewer = pdfViewer;
-  }
-
-  setHistory(pdfHistory) {
-    this.pdfHistory = pdfHistory;
-  }
-
-  get pagesCount() {
-    return this.pdfDocument ? this.pdfDocument.numPages : 0;
-  }
-
-  get page() {
-    return this.pdfViewer.currentPageNumber;
-  }
+  _createClass(PDFLinkService, [{
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      var baseUrl = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      this.baseUrl = baseUrl;
+      this.pdfDocument = pdfDocument;
+      this._pagesRefCache = Object.create(null);
+    }
+  }, {
+    key: "setViewer",
+    value: function setViewer(pdfViewer) {
+      this.pdfViewer = pdfViewer;
+    }
+  }, {
+    key: "setHistory",
+    value: function setHistory(pdfHistory) {
+      this.pdfHistory = pdfHistory;
+    }
+  }, {
+    key: "navigateTo",
+    value: function navigateTo(dest) {
+      var _this = this;
+
+      var goToDestination = function goToDestination(_ref2) {
+        var namedDest = _ref2.namedDest,
+            explicitDest = _ref2.explicitDest;
+        var destRef = explicitDest[0];
+        var pageNumber;
+
+        if (destRef instanceof Object) {
+          pageNumber = _this._cachedPageNumber(destRef);
+
+          if (pageNumber === null) {
+            _this.pdfDocument.getPageIndex(destRef).then(function (pageIndex) {
+              _this.cachePageRef(pageIndex + 1, destRef);
+
+              goToDestination({
+                namedDest: namedDest,
+                explicitDest: explicitDest
+              });
+            })["catch"](function () {
+              console.error("PDFLinkService.navigateTo: \"".concat(destRef, "\" is not ") + "a valid page reference, for dest=\"".concat(dest, "\"."));
+            });
 
-  set page(value) {
-    this.pdfViewer.currentPageNumber = value;
-  }
+            return;
+          }
+        } else if (Number.isInteger(destRef)) {
+          pageNumber = destRef + 1;
+        } else {
+          console.error("PDFLinkService.navigateTo: \"".concat(destRef, "\" is not ") + "a valid destination reference, for dest=\"".concat(dest, "\"."));
+          return;
+        }
 
-  get rotation() {
-    return this.pdfViewer.pagesRotation;
-  }
+        if (!pageNumber || pageNumber < 1 || pageNumber > _this.pagesCount) {
+          console.error("PDFLinkService.navigateTo: \"".concat(pageNumber, "\" is not ") + "a valid page number, for dest=\"".concat(dest, "\"."));
+          return;
+        }
 
-  set rotation(value) {
-    this.pdfViewer.pagesRotation = value;
-  }
+        if (_this.pdfHistory) {
+          _this.pdfHistory.pushCurrentPosition();
 
-  navigateTo(dest) {
-    const goToDestination = ({
-      namedDest,
-      explicitDest
-    }) => {
-      const destRef = explicitDest[0];
-      let pageNumber;
+          _this.pdfHistory.push({
+            namedDest: namedDest,
+            explicitDest: explicitDest,
+            pageNumber: pageNumber
+          });
+        }
 
-      if (destRef instanceof Object) {
-        pageNumber = this._cachedPageNumber(destRef);
+        _this.pdfViewer.scrollPageIntoView({
+          pageNumber: pageNumber,
+          destArray: explicitDest,
+          ignoreDestinationZoom: _this._ignoreDestinationZoom
+        });
+      };
 
-        if (pageNumber === null) {
-          this.pdfDocument.getPageIndex(destRef).then(pageIndex => {
-            this.cachePageRef(pageIndex + 1, destRef);
-            goToDestination({
-              namedDest,
-              explicitDest
+      new Promise(function (resolve, reject) {
+        if (typeof dest === "string") {
+          _this.pdfDocument.getDestination(dest).then(function (destArray) {
+            resolve({
+              namedDest: dest,
+              explicitDest: destArray
             });
-          }).catch(() => {
-            console.error(`PDFLinkService.navigateTo: "${destRef}" is not ` + `a valid page reference, for dest="${dest}".`);
           });
+
           return;
         }
-      } else if (Number.isInteger(destRef)) {
-        pageNumber = destRef + 1;
-      } else {
-        console.error(`PDFLinkService.navigateTo: "${destRef}" is not ` + `a valid destination reference, for dest="${dest}".`);
-        return;
-      }
-
-      if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
-        console.error(`PDFLinkService.navigateTo: "${pageNumber}" is not ` + `a valid page number, for dest="${dest}".`);
-        return;
-      }
 
-      if (this.pdfHistory) {
-        this.pdfHistory.pushCurrentPosition();
-        this.pdfHistory.push({
-          namedDest,
-          explicitDest,
-          pageNumber
+        resolve({
+          namedDest: "",
+          explicitDest: dest
         });
-      }
+      }).then(function (data) {
+        if (!Array.isArray(data.explicitDest)) {
+          console.error("PDFLinkService.navigateTo: \"".concat(data.explicitDest, "\" is") + " not a valid destination array, for dest=\"".concat(dest, "\"."));
+          return;
+        }
 
-      this.pdfViewer.scrollPageIntoView({
-        pageNumber,
-        destArray: explicitDest,
-        ignoreDestinationZoom: this._ignoreDestinationZoom
+        goToDestination(data);
       });
-    };
-
-    new Promise((resolve, reject) => {
+    }
+  }, {
+    key: "getDestinationHash",
+    value: function getDestinationHash(dest) {
       if (typeof dest === "string") {
-        this.pdfDocument.getDestination(dest).then(destArray => {
-          resolve({
-            namedDest: dest,
-            explicitDest: destArray
-          });
-        });
-        return;
+        return this.getAnchorUrl("#" + escape(dest));
       }
 
-      resolve({
-        namedDest: "",
-        explicitDest: dest
-      });
-    }).then(data => {
-      if (!Array.isArray(data.explicitDest)) {
-        console.error(`PDFLinkService.navigateTo: "${data.explicitDest}" is` + ` not a valid destination array, for dest="${dest}".`);
-        return;
+      if (Array.isArray(dest)) {
+        var str = JSON.stringify(dest);
+        return this.getAnchorUrl("#" + escape(str));
       }
 
-      goToDestination(data);
-    });
-  }
-
-  getDestinationHash(dest) {
-    if (typeof dest === "string") {
-      return this.getAnchorUrl("#" + escape(dest));
+      return this.getAnchorUrl("");
     }
-
-    if (Array.isArray(dest)) {
-      const str = JSON.stringify(dest);
-      return this.getAnchorUrl("#" + escape(str));
+  }, {
+    key: "getAnchorUrl",
+    value: function getAnchorUrl(anchor) {
+      return (this.baseUrl || "") + anchor;
     }
+  }, {
+    key: "setHash",
+    value: function setHash(hash) {
+      var pageNumber, dest;
 
-    return this.getAnchorUrl("");
-  }
-
-  getAnchorUrl(anchor) {
-    return (this.baseUrl || "") + anchor;
-  }
-
-  setHash(hash) {
-    let pageNumber, dest;
+      if (hash.includes("=")) {
+        var params = (0, _ui_utils.parseQueryString)(hash);
 
-    if (hash.includes("=")) {
-      const params = (0, _ui_utils.parseQueryString)(hash);
-
-      if ("search" in params) {
-        this.eventBus.dispatch("findfromurlhash", {
-          source: this,
-          query: params.search.replace(/"/g, ""),
-          phraseSearch: params.phrase === "true"
-        });
-      }
+        if ("search" in params) {
+          this.eventBus.dispatch("findfromurlhash", {
+            source: this,
+            query: params.search.replace(/"/g, ""),
+            phraseSearch: params.phrase === "true"
+          });
+        }
 
-      if ("page" in params) {
-        pageNumber = params.page | 0 || 1;
-      }
+        if ("page" in params) {
+          pageNumber = params.page | 0 || 1;
+        }
 
-      if ("zoom" in params) {
-        const zoomArgs = params.zoom.split(",");
-        const zoomArg = zoomArgs[0];
-        const zoomArgNumber = parseFloat(zoomArg);
+        if ("zoom" in params) {
+          var zoomArgs = params.zoom.split(",");
+          var zoomArg = zoomArgs[0];
+          var zoomArgNumber = parseFloat(zoomArg);
 
-        if (!zoomArg.includes("Fit")) {
-          dest = [null, {
-            name: "XYZ"
-          }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg];
-        } else {
-          if (zoomArg === "Fit" || zoomArg === "FitB") {
+          if (!zoomArg.includes("Fit")) {
             dest = [null, {
-              name: zoomArg
-            }];
-          } else if (zoomArg === "FitH" || zoomArg === "FitBH" || zoomArg === "FitV" || zoomArg === "FitBV") {
-            dest = [null, {
-              name: zoomArg
-            }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
-          } else if (zoomArg === "FitR") {
-            if (zoomArgs.length !== 5) {
-              console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
-            } else {
+              name: "XYZ"
+            }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg];
+          } else {
+            if (zoomArg === "Fit" || zoomArg === "FitB") {
+              dest = [null, {
+                name: zoomArg
+              }];
+            } else if (zoomArg === "FitH" || zoomArg === "FitBH" || zoomArg === "FitV" || zoomArg === "FitBV") {
               dest = [null, {
                 name: zoomArg
-              }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0];
+              }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
+            } else if (zoomArg === "FitR") {
+              if (zoomArgs.length !== 5) {
+                console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
+              } else {
+                dest = [null, {
+                  name: zoomArg
+                }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0];
+              }
+            } else {
+              console.error("PDFLinkService.setHash: \"".concat(zoomArg, "\" is not ") + "a valid zoom value.");
             }
-          } else {
-            console.error(`PDFLinkService.setHash: "${zoomArg}" is not ` + "a valid zoom value.");
           }
         }
-      }
 
-      if (dest) {
-        this.pdfViewer.scrollPageIntoView({
-          pageNumber: pageNumber || this.page,
-          destArray: dest,
-          allowNegativeOffset: true
-        });
-      } else if (pageNumber) {
-        this.page = pageNumber;
-      }
+        if (dest) {
+          this.pdfViewer.scrollPageIntoView({
+            pageNumber: pageNumber || this.page,
+            destArray: dest,
+            allowNegativeOffset: true
+          });
+        } else if (pageNumber) {
+          this.page = pageNumber;
+        }
 
-      if ("pagemode" in params) {
-        this.eventBus.dispatch("pagemode", {
-          source: this,
-          mode: params.pagemode
-        });
-      }
+        if ("pagemode" in params) {
+          this.eventBus.dispatch("pagemode", {
+            source: this,
+            mode: params.pagemode
+          });
+        }
 
-      if ("nameddest" in params) {
-        this.navigateTo(params.nameddest);
-      }
-    } else {
-      dest = unescape(hash);
+        if ("nameddest" in params) {
+          this.navigateTo(params.nameddest);
+        }
+      } else {
+        dest = unescape(hash);
 
-      try {
-        dest = JSON.parse(dest);
+        try {
+          dest = JSON.parse(dest);
+
+          if (!Array.isArray(dest)) {
+            dest = dest.toString();
+          }
+        } catch (ex) {}
 
-        if (!Array.isArray(dest)) {
-          dest = dest.toString();
+        if (typeof dest === "string" || isValidExplicitDestination(dest)) {
+          this.navigateTo(dest);
+          return;
         }
-      } catch (ex) {}
 
-      if (typeof dest === "string" || isValidExplicitDestination(dest)) {
-        this.navigateTo(dest);
-        return;
+        console.error("PDFLinkService.setHash: \"".concat(unescape(hash), "\" is not ") + "a valid destination.");
       }
-
-      console.error(`PDFLinkService.setHash: "${unescape(hash)}" is not ` + "a valid destination.");
     }
-  }
+  }, {
+    key: "executeNamedAction",
+    value: function executeNamedAction(action) {
+      switch (action) {
+        case "GoBack":
+          if (this.pdfHistory) {
+            this.pdfHistory.back();
+          }
 
-  executeNamedAction(action) {
-    switch (action) {
-      case "GoBack":
-        if (this.pdfHistory) {
-          this.pdfHistory.back();
-        }
+          break;
 
-        break;
+        case "GoForward":
+          if (this.pdfHistory) {
+            this.pdfHistory.forward();
+          }
 
-      case "GoForward":
-        if (this.pdfHistory) {
-          this.pdfHistory.forward();
-        }
+          break;
 
-        break;
+        case "NextPage":
+          if (this.page < this.pagesCount) {
+            this.page++;
+          }
 
-      case "NextPage":
-        if (this.page < this.pagesCount) {
-          this.page++;
-        }
+          break;
 
-        break;
+        case "PrevPage":
+          if (this.page > 1) {
+            this.page--;
+          }
 
-      case "PrevPage":
-        if (this.page > 1) {
-          this.page--;
-        }
+          break;
 
-        break;
+        case "LastPage":
+          this.page = this.pagesCount;
+          break;
 
-      case "LastPage":
-        this.page = this.pagesCount;
-        break;
+        case "FirstPage":
+          this.page = 1;
+          break;
 
-      case "FirstPage":
-        this.page = 1;
-        break;
+        default:
+          break;
+      }
 
-      default:
-        break;
+      this.eventBus.dispatch("namedaction", {
+        source: this,
+        action: action
+      });
     }
+  }, {
+    key: "cachePageRef",
+    value: function cachePageRef(pageNum, pageRef) {
+      if (!pageRef) {
+        return;
+      }
 
-    this.eventBus.dispatch("namedaction", {
-      source: this,
-      action
-    });
-  }
-
-  cachePageRef(pageNum, pageRef) {
-    if (!pageRef) {
-      return;
+      var refStr = pageRef.gen === 0 ? "".concat(pageRef.num, "R") : "".concat(pageRef.num, "R").concat(pageRef.gen);
+      this._pagesRefCache[refStr] = pageNum;
     }
+  }, {
+    key: "_cachedPageNumber",
+    value: function _cachedPageNumber(pageRef) {
+      var refStr = pageRef.gen === 0 ? "".concat(pageRef.num, "R") : "".concat(pageRef.num, "R").concat(pageRef.gen);
+      return this._pagesRefCache && this._pagesRefCache[refStr] || null;
+    }
+  }, {
+    key: "isPageVisible",
+    value: function isPageVisible(pageNumber) {
+      return this.pdfViewer.isPageVisible(pageNumber);
+    }
+  }, {
+    key: "pagesCount",
+    get: function get() {
+      return this.pdfDocument ? this.pdfDocument.numPages : 0;
+    }
+  }, {
+    key: "page",
+    get: function get() {
+      return this.pdfViewer.currentPageNumber;
+    },
+    set: function set(value) {
+      this.pdfViewer.currentPageNumber = value;
+    }
+  }, {
+    key: "rotation",
+    get: function get() {
+      return this.pdfViewer.pagesRotation;
+    },
+    set: function set(value) {
+      this.pdfViewer.pagesRotation = value;
+    }
+  }]);
 
-    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
-    this._pagesRefCache[refStr] = pageNum;
-  }
-
-  _cachedPageNumber(pageRef) {
-    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
-    return this._pagesRefCache && this._pagesRefCache[refStr] || null;
-  }
-
-  isPageVisible(pageNumber) {
-    return this.pdfViewer.isPageVisible(pageNumber);
-  }
-
-}
+  return PDFLinkService;
+}();
 
 exports.PDFLinkService = PDFLinkService;
 
@@ -7167,25 +8937,25 @@ function isValidExplicitDestination(dest) {
     return false;
   }
 
-  const destLength = dest.length;
+  var destLength = dest.length;
 
   if (destLength < 2) {
     return false;
   }
 
-  const page = dest[0];
+  var page = dest[0];
 
-  if (!(typeof page === "object" && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
+  if (!(_typeof(page) === "object" && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
     return false;
   }
 
-  const zoom = dest[1];
+  var zoom = dest[1];
 
-  if (!(typeof zoom === "object" && typeof zoom.name === "string")) {
+  if (!(_typeof(zoom) === "object" && typeof zoom.name === "string")) {
     return false;
   }
 
-  let allowNull = true;
+  var allowNull = true;
 
   switch (zoom.name) {
     case "XYZ":
@@ -7221,8 +8991,8 @@ function isValidExplicitDestination(dest) {
       return false;
   }
 
-  for (let i = 2; i < destLength; i++) {
-    const param = dest[i];
+  for (var i = 2; i < destLength; i++) {
+    var param = dest[i];
 
     if (!(typeof param === "number" || allowNull && param === null)) {
       return false;
@@ -7232,56 +9002,69 @@ function isValidExplicitDestination(dest) {
   return true;
 }
 
-class SimpleLinkService {
-  constructor() {
+var SimpleLinkService = /*#__PURE__*/function () {
+  function SimpleLinkService() {
+    _classCallCheck(this, SimpleLinkService);
+
     this.externalLinkTarget = null;
     this.externalLinkRel = null;
     this.externalLinkEnabled = true;
     this._ignoreDestinationZoom = false;
   }
 
-  get pagesCount() {
-    return 0;
-  }
-
-  get page() {
-    return 0;
-  }
-
-  set page(value) {}
-
-  get rotation() {
-    return 0;
-  }
-
-  set rotation(value) {}
-
-  navigateTo(dest) {}
-
-  getDestinationHash(dest) {
-    return "#";
-  }
-
-  getAnchorUrl(hash) {
-    return "#";
-  }
-
-  setHash(hash) {}
-
-  executeNamedAction(action) {}
-
-  cachePageRef(pageNum, pageRef) {}
-
-  isPageVisible(pageNumber) {
-    return true;
-  }
+  _createClass(SimpleLinkService, [{
+    key: "navigateTo",
+    value: function navigateTo(dest) {}
+  }, {
+    key: "getDestinationHash",
+    value: function getDestinationHash(dest) {
+      return "#";
+    }
+  }, {
+    key: "getAnchorUrl",
+    value: function getAnchorUrl(hash) {
+      return "#";
+    }
+  }, {
+    key: "setHash",
+    value: function setHash(hash) {}
+  }, {
+    key: "executeNamedAction",
+    value: function executeNamedAction(action) {}
+  }, {
+    key: "cachePageRef",
+    value: function cachePageRef(pageNum, pageRef) {}
+  }, {
+    key: "isPageVisible",
+    value: function isPageVisible(pageNumber) {
+      return true;
+    }
+  }, {
+    key: "pagesCount",
+    get: function get() {
+      return 0;
+    }
+  }, {
+    key: "page",
+    get: function get() {
+      return 0;
+    },
+    set: function set(value) {}
+  }, {
+    key: "rotation",
+    get: function get() {
+      return 0;
+    },
+    set: function set(value) {}
+  }]);
 
-}
+  return SimpleLinkService;
+}();
 
 exports.SimpleLinkService = SimpleLinkService;
 
 /***/ }),
-/* 19 */
+/* 22 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -7292,16 +9075,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFOutlineViewer = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
 
-const DEFAULT_TITLE = "\u2013";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DEFAULT_TITLE = "\u2013";
+
+var PDFOutlineViewer = /*#__PURE__*/function () {
+  function PDFOutlineViewer(_ref) {
+    var container = _ref.container,
+        linkService = _ref.linkService,
+        eventBus = _ref.eventBus;
+
+    _classCallCheck(this, PDFOutlineViewer);
 
-class PDFOutlineViewer {
-  constructor({
-    container,
-    linkService,
-    eventBus
-  }) {
     this.container = container;
     this.linkService = linkService;
     this.eventBus = eventBus;
@@ -7310,178 +9107,207 @@ class PDFOutlineViewer {
     eventBus._on("toggleoutlinetree", this.toggleOutlineTree.bind(this));
   }
 
-  reset() {
-    this.outline = null;
-    this.lastToggleIsShow = true;
-    this.container.textContent = "";
-    this.container.classList.remove("outlineWithDeepNesting");
-  }
-
-  _dispatchEvent(outlineCount) {
-    this.eventBus.dispatch("outlineloaded", {
-      source: this,
-      outlineCount
-    });
-  }
-
-  _bindLink(element, {
-    url,
-    newWindow,
-    dest
-  }) {
-    const {
-      linkService
-    } = this;
-
-    if (url) {
-      (0, _pdfjsLib.addLinkAttributes)(element, {
-        url,
-        target: newWindow ? _pdfjsLib.LinkTarget.BLANK : linkService.externalLinkTarget,
-        rel: linkService.externalLinkRel,
-        enabled: linkService.externalLinkEnabled
+  _createClass(PDFOutlineViewer, [{
+    key: "reset",
+    value: function reset() {
+      this.outline = null;
+      this.lastToggleIsShow = true;
+      this.container.textContent = "";
+      this.container.classList.remove("outlineWithDeepNesting");
+    }
+  }, {
+    key: "_dispatchEvent",
+    value: function _dispatchEvent(outlineCount) {
+      this.eventBus.dispatch("outlineloaded", {
+        source: this,
+        outlineCount: outlineCount
       });
-      return;
     }
-
-    element.href = linkService.getDestinationHash(dest);
-
-    element.onclick = () => {
-      if (dest) {
-        linkService.navigateTo(dest);
+  }, {
+    key: "_bindLink",
+    value: function _bindLink(element, _ref2) {
+      var url = _ref2.url,
+          newWindow = _ref2.newWindow,
+          dest = _ref2.dest;
+      var linkService = this.linkService;
+
+      if (url) {
+        (0, _pdfjsLib.addLinkAttributes)(element, {
+          url: url,
+          target: newWindow ? _pdfjsLib.LinkTarget.BLANK : linkService.externalLinkTarget,
+          rel: linkService.externalLinkRel,
+          enabled: linkService.externalLinkEnabled
+        });
+        return;
       }
 
-      return false;
-    };
-  }
+      element.href = linkService.getDestinationHash(dest);
 
-  _setStyles(element, {
-    bold,
-    italic
-  }) {
-    if (bold) {
-      element.style.fontWeight = "bold";
-    }
+      element.onclick = function () {
+        if (dest) {
+          linkService.navigateTo(dest);
+        }
 
-    if (italic) {
-      element.style.fontStyle = "italic";
+        return false;
+      };
     }
-  }
+  }, {
+    key: "_setStyles",
+    value: function _setStyles(element, _ref3) {
+      var bold = _ref3.bold,
+          italic = _ref3.italic;
 
-  _addToggleButton(div, {
-    count,
-    items
-  }) {
-    const toggler = document.createElement("div");
-    toggler.className = "outlineItemToggler";
+      if (bold) {
+        element.style.fontWeight = "bold";
+      }
 
-    if (count < 0 && Math.abs(count) === items.length) {
-      toggler.classList.add("outlineItemsHidden");
+      if (italic) {
+        element.style.fontStyle = "italic";
+      }
     }
+  }, {
+    key: "_addToggleButton",
+    value: function _addToggleButton(div, _ref4) {
+      var _this = this;
 
-    toggler.onclick = evt => {
-      evt.stopPropagation();
-      toggler.classList.toggle("outlineItemsHidden");
-
-      if (evt.shiftKey) {
-        const shouldShowAll = !toggler.classList.contains("outlineItemsHidden");
+      var count = _ref4.count,
+          items = _ref4.items;
+      var toggler = document.createElement("div");
+      toggler.className = "outlineItemToggler";
 
-        this._toggleOutlineItem(div, shouldShowAll);
+      if (count < 0 && Math.abs(count) === items.length) {
+        toggler.classList.add("outlineItemsHidden");
       }
-    };
 
-    div.insertBefore(toggler, div.firstChild);
-  }
+      toggler.onclick = function (evt) {
+        evt.stopPropagation();
+        toggler.classList.toggle("outlineItemsHidden");
 
-  _toggleOutlineItem(root, show = false) {
-    this.lastToggleIsShow = show;
+        if (evt.shiftKey) {
+          var shouldShowAll = !toggler.classList.contains("outlineItemsHidden");
 
-    for (const toggler of root.querySelectorAll(".outlineItemToggler")) {
-      toggler.classList.toggle("outlineItemsHidden", !show);
-    }
-  }
+          _this._toggleOutlineItem(div, shouldShowAll);
+        }
+      };
 
-  toggleOutlineTree() {
-    if (!this.outline) {
-      return;
+      div.insertBefore(toggler, div.firstChild);
     }
+  }, {
+    key: "_toggleOutlineItem",
+    value: function _toggleOutlineItem(root) {
+      var show = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this.lastToggleIsShow = show;
 
-    this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
-  }
+      var _iterator = _createForOfIteratorHelper(root.querySelectorAll(".outlineItemToggler")),
+          _step;
 
-  render({
-    outline
-  }) {
-    let outlineCount = 0;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var toggler = _step.value;
+          toggler.classList.toggle("outlineItemsHidden", !show);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "toggleOutlineTree",
+    value: function toggleOutlineTree() {
+      if (!this.outline) {
+        return;
+      }
 
-    if (this.outline) {
-      this.reset();
+      this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
     }
+  }, {
+    key: "render",
+    value: function render(_ref5) {
+      var outline = _ref5.outline;
+      var outlineCount = 0;
 
-    this.outline = outline || null;
+      if (this.outline) {
+        this.reset();
+      }
 
-    if (!outline) {
-      this._dispatchEvent(outlineCount);
+      this.outline = outline || null;
 
-      return;
-    }
+      if (!outline) {
+        this._dispatchEvent(outlineCount);
 
-    const fragment = document.createDocumentFragment();
-    const queue = [{
-      parent: fragment,
-      items: this.outline
-    }];
-    let hasAnyNesting = false;
+        return;
+      }
 
-    while (queue.length > 0) {
-      const levelData = queue.shift();
+      var fragment = document.createDocumentFragment();
+      var queue = [{
+        parent: fragment,
+        items: this.outline
+      }];
+      var hasAnyNesting = false;
 
-      for (const item of levelData.items) {
-        const div = document.createElement("div");
-        div.className = "outlineItem";
-        const element = document.createElement("a");
+      while (queue.length > 0) {
+        var levelData = queue.shift();
 
-        this._bindLink(element, item);
+        var _iterator2 = _createForOfIteratorHelper(levelData.items),
+            _step2;
 
-        this._setStyles(element, item);
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var item = _step2.value;
+            var div = document.createElement("div");
+            div.className = "outlineItem";
+            var element = document.createElement("a");
 
-        element.textContent = (0, _pdfjsLib.removeNullCharacters)(item.title) || DEFAULT_TITLE;
-        div.appendChild(element);
+            this._bindLink(element, item);
 
-        if (item.items.length > 0) {
-          hasAnyNesting = true;
+            this._setStyles(element, item);
 
-          this._addToggleButton(div, item);
+            element.textContent = (0, _pdfjsLib.removeNullCharacters)(item.title) || DEFAULT_TITLE;
+            div.appendChild(element);
 
-          const itemsDiv = document.createElement("div");
-          itemsDiv.className = "outlineItems";
-          div.appendChild(itemsDiv);
-          queue.push({
-            parent: itemsDiv,
-            items: item.items
-          });
-        }
+            if (item.items.length > 0) {
+              hasAnyNesting = true;
 
-        levelData.parent.appendChild(div);
-        outlineCount++;
+              this._addToggleButton(div, item);
+
+              var itemsDiv = document.createElement("div");
+              itemsDiv.className = "outlineItems";
+              div.appendChild(itemsDiv);
+              queue.push({
+                parent: itemsDiv,
+                items: item.items
+              });
+            }
+
+            levelData.parent.appendChild(div);
+            outlineCount++;
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
       }
-    }
 
-    if (hasAnyNesting) {
-      this.container.classList.add("outlineWithDeepNesting");
-      this.lastToggleIsShow = fragment.querySelectorAll(".outlineItemsHidden").length === 0;
-    }
+      if (hasAnyNesting) {
+        this.container.classList.add("outlineWithDeepNesting");
+        this.lastToggleIsShow = fragment.querySelectorAll(".outlineItemsHidden").length === 0;
+      }
 
-    this.container.appendChild(fragment);
+      this.container.appendChild(fragment);
 
-    this._dispatchEvent(outlineCount);
-  }
+      this._dispatchEvent(outlineCount);
+    }
+  }]);
 
-}
+  return PDFOutlineViewer;
+}();
 
 exports.PDFOutlineViewer = PDFOutlineViewer;
 
 /***/ }),
-/* 20 */
+/* 23 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -7492,24 +9318,35 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFPresentationMode = void 0;
 
-var _ui_utils = __webpack_require__(2);
-
-const DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
-const DELAY_BEFORE_HIDING_CONTROLS = 3000;
-const ACTIVE_SELECTOR = "pdfPresentationMode";
-const CONTROLS_SELECTOR = "pdfPresentationModeControls";
-const MOUSE_SCROLL_COOLDOWN_TIME = 50;
-const PAGE_SWITCH_THRESHOLD = 0.1;
-const SWIPE_MIN_DISTANCE_THRESHOLD = 50;
-const SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
-
-class PDFPresentationMode {
-  constructor({
-    container,
-    pdfViewer,
-    eventBus,
-    contextMenuItems = null
-  }) {
+var _ui_utils = __webpack_require__(5);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
+var DELAY_BEFORE_HIDING_CONTROLS = 3000;
+var ACTIVE_SELECTOR = "pdfPresentationMode";
+var CONTROLS_SELECTOR = "pdfPresentationModeControls";
+var MOUSE_SCROLL_COOLDOWN_TIME = 50;
+var PAGE_SWITCH_THRESHOLD = 0.1;
+var SWIPE_MIN_DISTANCE_THRESHOLD = 50;
+var SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
+
+var PDFPresentationMode = /*#__PURE__*/function () {
+  function PDFPresentationMode(_ref) {
+    var _this = this;
+
+    var container = _ref.container,
+        pdfViewer = _ref.pdfViewer,
+        eventBus = _ref.eventBus,
+        _ref$contextMenuItems = _ref.contextMenuItems,
+        contextMenuItems = _ref$contextMenuItems === void 0 ? null : _ref$contextMenuItems;
+
+    _classCallCheck(this, PDFPresentationMode);
+
     this.container = container;
     this.pdfViewer = pdfViewer;
     this.eventBus = eventBus;
@@ -7521,376 +9358,413 @@ class PDFPresentationMode {
     this.touchSwipeState = null;
 
     if (contextMenuItems) {
-      contextMenuItems.contextFirstPage.addEventListener("click", () => {
-        this.contextMenuOpen = false;
-        this.eventBus.dispatch("firstpage", {
-          source: this
+      contextMenuItems.contextFirstPage.addEventListener("click", function () {
+        _this.contextMenuOpen = false;
+
+        _this.eventBus.dispatch("firstpage", {
+          source: _this
         });
       });
-      contextMenuItems.contextLastPage.addEventListener("click", () => {
-        this.contextMenuOpen = false;
-        this.eventBus.dispatch("lastpage", {
-          source: this
+      contextMenuItems.contextLastPage.addEventListener("click", function () {
+        _this.contextMenuOpen = false;
+
+        _this.eventBus.dispatch("lastpage", {
+          source: _this
         });
       });
-      contextMenuItems.contextPageRotateCw.addEventListener("click", () => {
-        this.contextMenuOpen = false;
-        this.eventBus.dispatch("rotatecw", {
-          source: this
+      contextMenuItems.contextPageRotateCw.addEventListener("click", function () {
+        _this.contextMenuOpen = false;
+
+        _this.eventBus.dispatch("rotatecw", {
+          source: _this
         });
       });
-      contextMenuItems.contextPageRotateCcw.addEventListener("click", () => {
-        this.contextMenuOpen = false;
-        this.eventBus.dispatch("rotateccw", {
-          source: this
+      contextMenuItems.contextPageRotateCcw.addEventListener("click", function () {
+        _this.contextMenuOpen = false;
+
+        _this.eventBus.dispatch("rotateccw", {
+          source: _this
         });
       });
     }
   }
 
-  request() {
-    if (this.switchInProgress || this.active || !this.pdfViewer.pagesCount) {
-      return false;
-    }
-
-    this._addFullscreenChangeListeners();
+  _createClass(PDFPresentationMode, [{
+    key: "request",
+    value: function request() {
+      if (this.switchInProgress || this.active || !this.pdfViewer.pagesCount) {
+        return false;
+      }
 
-    this._setSwitchInProgress();
+      this._addFullscreenChangeListeners();
 
-    this._notifyStateChange();
+      this._setSwitchInProgress();
 
-    if (this.container.requestFullscreen) {
-      this.container.requestFullscreen();
-    } else if (this.container.mozRequestFullScreen) {
-      this.container.mozRequestFullScreen();
-    } else if (this.container.webkitRequestFullscreen) {
-      this.container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
-    } else if (this.container.msRequestFullscreen) {
-      this.container.msRequestFullscreen();
-    } else {
-      return false;
-    }
+      this._notifyStateChange();
 
-    this.args = {
-      page: this.pdfViewer.currentPageNumber,
-      previousScale: this.pdfViewer.currentScaleValue
-    };
-    return true;
-  }
+      if (this.container.requestFullscreen) {
+        this.container.requestFullscreen();
+      } else if (this.container.mozRequestFullScreen) {
+        this.container.mozRequestFullScreen();
+      } else if (this.container.webkitRequestFullscreen) {
+        this.container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
+      } else if (this.container.msRequestFullscreen) {
+        this.container.msRequestFullscreen();
+      } else {
+        return false;
+      }
 
-  _mouseWheel(evt) {
-    if (!this.active) {
-      return;
+      this.args = {
+        page: this.pdfViewer.currentPageNumber,
+        previousScale: this.pdfViewer.currentScaleValue
+      };
+      return true;
     }
+  }, {
+    key: "_mouseWheel",
+    value: function _mouseWheel(evt) {
+      if (!this.active) {
+        return;
+      }
 
-    evt.preventDefault();
-    const delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
-    const currentTime = new Date().getTime();
-    const storedTime = this.mouseScrollTimeStamp;
+      evt.preventDefault();
+      var delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
+      var currentTime = new Date().getTime();
+      var storedTime = this.mouseScrollTimeStamp;
 
-    if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
-      return;
-    }
+      if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
+        return;
+      }
 
-    if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
-      this._resetMouseScrollState();
-    }
+      if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
+        this._resetMouseScrollState();
+      }
 
-    this.mouseScrollDelta += delta;
+      this.mouseScrollDelta += delta;
 
-    if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
-      const totalDelta = this.mouseScrollDelta;
+      if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
+        var totalDelta = this.mouseScrollDelta;
 
-      this._resetMouseScrollState();
+        this._resetMouseScrollState();
 
-      const success = totalDelta > 0 ? this._goToPreviousPage() : this._goToNextPage();
+        var success = totalDelta > 0 ? this._goToPreviousPage() : this._goToNextPage();
 
-      if (success) {
-        this.mouseScrollTimeStamp = currentTime;
+        if (success) {
+          this.mouseScrollTimeStamp = currentTime;
+        }
       }
     }
-  }
-
-  get isFullscreen() {
-    return !!(document.fullscreenElement || document.mozFullScreen || document.webkitIsFullScreen || document.msFullscreenElement);
-  }
+  }, {
+    key: "_goToPreviousPage",
+    value: function _goToPreviousPage() {
+      var page = this.pdfViewer.currentPageNumber;
 
-  _goToPreviousPage() {
-    const page = this.pdfViewer.currentPageNumber;
+      if (page <= 1) {
+        return false;
+      }
 
-    if (page <= 1) {
-      return false;
+      this.pdfViewer.currentPageNumber = page - 1;
+      return true;
     }
+  }, {
+    key: "_goToNextPage",
+    value: function _goToNextPage() {
+      var page = this.pdfViewer.currentPageNumber;
 
-    this.pdfViewer.currentPageNumber = page - 1;
-    return true;
-  }
-
-  _goToNextPage() {
-    const page = this.pdfViewer.currentPageNumber;
+      if (page >= this.pdfViewer.pagesCount) {
+        return false;
+      }
 
-    if (page >= this.pdfViewer.pagesCount) {
-      return false;
+      this.pdfViewer.currentPageNumber = page + 1;
+      return true;
     }
-
-    this.pdfViewer.currentPageNumber = page + 1;
-    return true;
-  }
-
-  _notifyStateChange() {
-    this.eventBus.dispatch("presentationmodechanged", {
-      source: this,
-      active: this.active,
-      switchInProgress: !!this.switchInProgress
-    });
-  }
-
-  _setSwitchInProgress() {
-    if (this.switchInProgress) {
-      clearTimeout(this.switchInProgress);
+  }, {
+    key: "_notifyStateChange",
+    value: function _notifyStateChange() {
+      this.eventBus.dispatch("presentationmodechanged", {
+        source: this,
+        active: this.active,
+        switchInProgress: !!this.switchInProgress
+      });
     }
+  }, {
+    key: "_setSwitchInProgress",
+    value: function _setSwitchInProgress() {
+      var _this2 = this;
 
-    this.switchInProgress = setTimeout(() => {
-      this._removeFullscreenChangeListeners();
+      if (this.switchInProgress) {
+        clearTimeout(this.switchInProgress);
+      }
 
-      delete this.switchInProgress;
+      this.switchInProgress = setTimeout(function () {
+        _this2._removeFullscreenChangeListeners();
 
-      this._notifyStateChange();
-    }, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
-  }
+        delete _this2.switchInProgress;
 
-  _resetSwitchInProgress() {
-    if (this.switchInProgress) {
-      clearTimeout(this.switchInProgress);
-      delete this.switchInProgress;
+        _this2._notifyStateChange();
+      }, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
     }
-  }
+  }, {
+    key: "_resetSwitchInProgress",
+    value: function _resetSwitchInProgress() {
+      if (this.switchInProgress) {
+        clearTimeout(this.switchInProgress);
+        delete this.switchInProgress;
+      }
+    }
+  }, {
+    key: "_enter",
+    value: function _enter() {
+      var _this3 = this;
 
-  _enter() {
-    this.active = true;
+      this.active = true;
 
-    this._resetSwitchInProgress();
+      this._resetSwitchInProgress();
 
-    this._notifyStateChange();
+      this._notifyStateChange();
 
-    this.container.classList.add(ACTIVE_SELECTOR);
-    setTimeout(() => {
-      this.pdfViewer.currentPageNumber = this.args.page;
-      this.pdfViewer.currentScaleValue = "page-fit";
-    }, 0);
+      this.container.classList.add(ACTIVE_SELECTOR);
+      setTimeout(function () {
+        _this3.pdfViewer.currentPageNumber = _this3.args.page;
+        _this3.pdfViewer.currentScaleValue = "page-fit";
+      }, 0);
 
-    this._addWindowListeners();
+      this._addWindowListeners();
 
-    this._showControls();
+      this._showControls();
 
-    this.contextMenuOpen = false;
-    this.container.setAttribute("contextmenu", "viewerContextMenu");
-    window.getSelection().removeAllRanges();
-  }
-
-  _exit() {
-    const page = this.pdfViewer.currentPageNumber;
-    this.container.classList.remove(ACTIVE_SELECTOR);
-    setTimeout(() => {
-      this.active = false;
+      this.contextMenuOpen = false;
+      this.container.setAttribute("contextmenu", "viewerContextMenu");
+      window.getSelection().removeAllRanges();
+    }
+  }, {
+    key: "_exit",
+    value: function _exit() {
+      var _this4 = this;
 
-      this._removeFullscreenChangeListeners();
+      var page = this.pdfViewer.currentPageNumber;
+      this.container.classList.remove(ACTIVE_SELECTOR);
+      setTimeout(function () {
+        _this4.active = false;
 
-      this._notifyStateChange();
+        _this4._removeFullscreenChangeListeners();
 
-      this.pdfViewer.currentScaleValue = this.args.previousScale;
-      this.pdfViewer.currentPageNumber = page;
-      this.args = null;
-    }, 0);
+        _this4._notifyStateChange();
 
-    this._removeWindowListeners();
+        _this4.pdfViewer.currentScaleValue = _this4.args.previousScale;
+        _this4.pdfViewer.currentPageNumber = page;
+        _this4.args = null;
+      }, 0);
 
-    this._hideControls();
+      this._removeWindowListeners();
 
-    this._resetMouseScrollState();
+      this._hideControls();
 
-    this.container.removeAttribute("contextmenu");
-    this.contextMenuOpen = false;
-  }
+      this._resetMouseScrollState();
 
-  _mouseDown(evt) {
-    if (this.contextMenuOpen) {
+      this.container.removeAttribute("contextmenu");
       this.contextMenuOpen = false;
-      evt.preventDefault();
-      return;
     }
+  }, {
+    key: "_mouseDown",
+    value: function _mouseDown(evt) {
+      if (this.contextMenuOpen) {
+        this.contextMenuOpen = false;
+        evt.preventDefault();
+        return;
+      }
 
-    if (evt.button === 0) {
-      const isInternalLink = evt.target.href && evt.target.classList.contains("internalLink");
+      if (evt.button === 0) {
+        var isInternalLink = evt.target.href && evt.target.classList.contains("internalLink");
 
-      if (!isInternalLink) {
-        evt.preventDefault();
+        if (!isInternalLink) {
+          evt.preventDefault();
 
-        if (evt.shiftKey) {
-          this._goToPreviousPage();
-        } else {
-          this._goToNextPage();
+          if (evt.shiftKey) {
+            this._goToPreviousPage();
+          } else {
+            this._goToNextPage();
+          }
         }
       }
     }
-  }
+  }, {
+    key: "_contextMenu",
+    value: function _contextMenu() {
+      this.contextMenuOpen = true;
+    }
+  }, {
+    key: "_showControls",
+    value: function _showControls() {
+      var _this5 = this;
 
-  _contextMenu() {
-    this.contextMenuOpen = true;
-  }
+      if (this.controlsTimeout) {
+        clearTimeout(this.controlsTimeout);
+      } else {
+        this.container.classList.add(CONTROLS_SELECTOR);
+      }
 
-  _showControls() {
-    if (this.controlsTimeout) {
-      clearTimeout(this.controlsTimeout);
-    } else {
-      this.container.classList.add(CONTROLS_SELECTOR);
+      this.controlsTimeout = setTimeout(function () {
+        _this5.container.classList.remove(CONTROLS_SELECTOR);
+
+        delete _this5.controlsTimeout;
+      }, DELAY_BEFORE_HIDING_CONTROLS);
     }
+  }, {
+    key: "_hideControls",
+    value: function _hideControls() {
+      if (!this.controlsTimeout) {
+        return;
+      }
 
-    this.controlsTimeout = setTimeout(() => {
+      clearTimeout(this.controlsTimeout);
       this.container.classList.remove(CONTROLS_SELECTOR);
       delete this.controlsTimeout;
-    }, DELAY_BEFORE_HIDING_CONTROLS);
-  }
-
-  _hideControls() {
-    if (!this.controlsTimeout) {
-      return;
     }
-
-    clearTimeout(this.controlsTimeout);
-    this.container.classList.remove(CONTROLS_SELECTOR);
-    delete this.controlsTimeout;
-  }
-
-  _resetMouseScrollState() {
-    this.mouseScrollTimeStamp = 0;
-    this.mouseScrollDelta = 0;
-  }
-
-  _touchSwipe(evt) {
-    if (!this.active) {
-      return;
+  }, {
+    key: "_resetMouseScrollState",
+    value: function _resetMouseScrollState() {
+      this.mouseScrollTimeStamp = 0;
+      this.mouseScrollDelta = 0;
     }
+  }, {
+    key: "_touchSwipe",
+    value: function _touchSwipe(evt) {
+      if (!this.active) {
+        return;
+      }
 
-    if (evt.touches.length > 1) {
-      this.touchSwipeState = null;
-      return;
-    }
-
-    switch (evt.type) {
-      case "touchstart":
-        this.touchSwipeState = {
-          startX: evt.touches[0].pageX,
-          startY: evt.touches[0].pageY,
-          endX: evt.touches[0].pageX,
-          endY: evt.touches[0].pageY
-        };
-        break;
-
-      case "touchmove":
-        if (this.touchSwipeState === null) {
-          return;
-        }
+      if (evt.touches.length > 1) {
+        this.touchSwipeState = null;
+        return;
+      }
 
-        this.touchSwipeState.endX = evt.touches[0].pageX;
-        this.touchSwipeState.endY = evt.touches[0].pageY;
-        evt.preventDefault();
-        break;
+      switch (evt.type) {
+        case "touchstart":
+          this.touchSwipeState = {
+            startX: evt.touches[0].pageX,
+            startY: evt.touches[0].pageY,
+            endX: evt.touches[0].pageX,
+            endY: evt.touches[0].pageY
+          };
+          break;
 
-      case "touchend":
-        if (this.touchSwipeState === null) {
-          return;
-        }
+        case "touchmove":
+          if (this.touchSwipeState === null) {
+            return;
+          }
 
-        let delta = 0;
-        const dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
-        const dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
-        const absAngle = Math.abs(Math.atan2(dy, dx));
+          this.touchSwipeState.endX = evt.touches[0].pageX;
+          this.touchSwipeState.endY = evt.touches[0].pageY;
+          evt.preventDefault();
+          break;
 
-        if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
-          delta = dx;
-        } else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
-          delta = dy;
-        }
+        case "touchend":
+          if (this.touchSwipeState === null) {
+            return;
+          }
 
-        if (delta > 0) {
-          this._goToPreviousPage();
-        } else if (delta < 0) {
-          this._goToNextPage();
-        }
+          var delta = 0;
+          var dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
+          var dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
+          var absAngle = Math.abs(Math.atan2(dy, dx));
 
-        break;
-    }
-  }
+          if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
+            delta = dx;
+          } else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
+            delta = dy;
+          }
 
-  _addWindowListeners() {
-    this.showControlsBind = this._showControls.bind(this);
-    this.mouseDownBind = this._mouseDown.bind(this);
-    this.mouseWheelBind = this._mouseWheel.bind(this);
-    this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
-    this.contextMenuBind = this._contextMenu.bind(this);
-    this.touchSwipeBind = this._touchSwipe.bind(this);
-    window.addEventListener("mousemove", this.showControlsBind);
-    window.addEventListener("mousedown", this.mouseDownBind);
-    window.addEventListener("wheel", this.mouseWheelBind, {
-      passive: false
-    });
-    window.addEventListener("keydown", this.resetMouseScrollStateBind);
-    window.addEventListener("contextmenu", this.contextMenuBind);
-    window.addEventListener("touchstart", this.touchSwipeBind);
-    window.addEventListener("touchmove", this.touchSwipeBind);
-    window.addEventListener("touchend", this.touchSwipeBind);
-  }
+          if (delta > 0) {
+            this._goToPreviousPage();
+          } else if (delta < 0) {
+            this._goToNextPage();
+          }
 
-  _removeWindowListeners() {
-    window.removeEventListener("mousemove", this.showControlsBind);
-    window.removeEventListener("mousedown", this.mouseDownBind);
-    window.removeEventListener("wheel", this.mouseWheelBind, {
-      passive: false
-    });
-    window.removeEventListener("keydown", this.resetMouseScrollStateBind);
-    window.removeEventListener("contextmenu", this.contextMenuBind);
-    window.removeEventListener("touchstart", this.touchSwipeBind);
-    window.removeEventListener("touchmove", this.touchSwipeBind);
-    window.removeEventListener("touchend", this.touchSwipeBind);
-    delete this.showControlsBind;
-    delete this.mouseDownBind;
-    delete this.mouseWheelBind;
-    delete this.resetMouseScrollStateBind;
-    delete this.contextMenuBind;
-    delete this.touchSwipeBind;
-  }
-
-  _fullscreenChange() {
-    if (this.isFullscreen) {
-      this._enter();
-    } else {
-      this._exit();
+          break;
+      }
     }
-  }
-
-  _addFullscreenChangeListeners() {
-    this.fullscreenChangeBind = this._fullscreenChange.bind(this);
-    window.addEventListener("fullscreenchange", this.fullscreenChangeBind);
-    window.addEventListener("mozfullscreenchange", this.fullscreenChangeBind);
-    window.addEventListener("webkitfullscreenchange", this.fullscreenChangeBind);
-    window.addEventListener("MSFullscreenChange", this.fullscreenChangeBind);
-  }
-
-  _removeFullscreenChangeListeners() {
-    window.removeEventListener("fullscreenchange", this.fullscreenChangeBind);
-    window.removeEventListener("mozfullscreenchange", this.fullscreenChangeBind);
-    window.removeEventListener("webkitfullscreenchange", this.fullscreenChangeBind);
-    window.removeEventListener("MSFullscreenChange", this.fullscreenChangeBind);
-    delete this.fullscreenChangeBind;
-  }
-
-}
+  }, {
+    key: "_addWindowListeners",
+    value: function _addWindowListeners() {
+      this.showControlsBind = this._showControls.bind(this);
+      this.mouseDownBind = this._mouseDown.bind(this);
+      this.mouseWheelBind = this._mouseWheel.bind(this);
+      this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
+      this.contextMenuBind = this._contextMenu.bind(this);
+      this.touchSwipeBind = this._touchSwipe.bind(this);
+      window.addEventListener("mousemove", this.showControlsBind);
+      window.addEventListener("mousedown", this.mouseDownBind);
+      window.addEventListener("wheel", this.mouseWheelBind, {
+        passive: false
+      });
+      window.addEventListener("keydown", this.resetMouseScrollStateBind);
+      window.addEventListener("contextmenu", this.contextMenuBind);
+      window.addEventListener("touchstart", this.touchSwipeBind);
+      window.addEventListener("touchmove", this.touchSwipeBind);
+      window.addEventListener("touchend", this.touchSwipeBind);
+    }
+  }, {
+    key: "_removeWindowListeners",
+    value: function _removeWindowListeners() {
+      window.removeEventListener("mousemove", this.showControlsBind);
+      window.removeEventListener("mousedown", this.mouseDownBind);
+      window.removeEventListener("wheel", this.mouseWheelBind, {
+        passive: false
+      });
+      window.removeEventListener("keydown", this.resetMouseScrollStateBind);
+      window.removeEventListener("contextmenu", this.contextMenuBind);
+      window.removeEventListener("touchstart", this.touchSwipeBind);
+      window.removeEventListener("touchmove", this.touchSwipeBind);
+      window.removeEventListener("touchend", this.touchSwipeBind);
+      delete this.showControlsBind;
+      delete this.mouseDownBind;
+      delete this.mouseWheelBind;
+      delete this.resetMouseScrollStateBind;
+      delete this.contextMenuBind;
+      delete this.touchSwipeBind;
+    }
+  }, {
+    key: "_fullscreenChange",
+    value: function _fullscreenChange() {
+      if (this.isFullscreen) {
+        this._enter();
+      } else {
+        this._exit();
+      }
+    }
+  }, {
+    key: "_addFullscreenChangeListeners",
+    value: function _addFullscreenChangeListeners() {
+      this.fullscreenChangeBind = this._fullscreenChange.bind(this);
+      window.addEventListener("fullscreenchange", this.fullscreenChangeBind);
+      window.addEventListener("mozfullscreenchange", this.fullscreenChangeBind);
+      window.addEventListener("webkitfullscreenchange", this.fullscreenChangeBind);
+      window.addEventListener("MSFullscreenChange", this.fullscreenChangeBind);
+    }
+  }, {
+    key: "_removeFullscreenChangeListeners",
+    value: function _removeFullscreenChangeListeners() {
+      window.removeEventListener("fullscreenchange", this.fullscreenChangeBind);
+      window.removeEventListener("mozfullscreenchange", this.fullscreenChangeBind);
+      window.removeEventListener("webkitfullscreenchange", this.fullscreenChangeBind);
+      window.removeEventListener("MSFullscreenChange", this.fullscreenChangeBind);
+      delete this.fullscreenChangeBind;
+    }
+  }, {
+    key: "isFullscreen",
+    get: function get() {
+      return !!(document.fullscreenElement || document.mozFullScreen || document.webkitIsFullScreen || document.msFullscreenElement);
+    }
+  }]);
+
+  return PDFPresentationMode;
+}();
 
 exports.PDFPresentationMode = PDFPresentationMode;
 
 /***/ }),
-/* 21 */
+/* 24 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -7901,14 +9775,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFSidebarResizer = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var SIDEBAR_WIDTH_VAR = "--sidebar-width";
+var SIDEBAR_MIN_WIDTH = 200;
+var SIDEBAR_RESIZING_CLASS = "sidebarResizing";
+
+var PDFSidebarResizer = /*#__PURE__*/function () {
+  function PDFSidebarResizer(options, eventBus) {
+    var _this = this;
+
+    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
 
-const SIDEBAR_WIDTH_VAR = "--sidebar-width";
-const SIDEBAR_MIN_WIDTH = 200;
-const SIDEBAR_RESIZING_CLASS = "sidebarResizing";
+    _classCallCheck(this, PDFSidebarResizer);
 
-class PDFSidebarResizer {
-  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
     this.enabled = false;
     this.isRTL = false;
     this.sidebarOpen = false;
@@ -7921,125 +9807,138 @@ class PDFSidebarResizer {
     this.eventBus = eventBus;
     this.l10n = l10n;
 
-    if (typeof CSS === "undefined" || typeof CSS.supports !== "function" || !CSS.supports(SIDEBAR_WIDTH_VAR, `calc(-1 * ${SIDEBAR_MIN_WIDTH}px)`)) {
+    if (typeof CSS === "undefined" || typeof CSS.supports !== "function" || !CSS.supports(SIDEBAR_WIDTH_VAR, "calc(-1 * ".concat(SIDEBAR_MIN_WIDTH, "px)"))) {
       console.warn("PDFSidebarResizer: " + "The browser does not support resizing of the sidebar.");
       return;
     }
 
     this.enabled = true;
     this.resizer.classList.remove("hidden");
-    this.l10n.getDirection().then(dir => {
-      this.isRTL = dir === "rtl";
+    this.l10n.getDirection().then(function (dir) {
+      _this.isRTL = dir === "rtl";
     });
 
     this._addEventListeners();
   }
 
-  get outerContainerWidth() {
-    if (!this._outerContainerWidth) {
-      this._outerContainerWidth = this.outerContainer.clientWidth;
-    }
+  _createClass(PDFSidebarResizer, [{
+    key: "_updateWidth",
+    value: function _updateWidth() {
+      var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
 
-    return this._outerContainerWidth;
-  }
+      if (!this.enabled) {
+        return false;
+      }
 
-  _updateWidth(width = 0) {
-    if (!this.enabled) {
-      return false;
-    }
+      var newWidth = (0, _ui_utils.clamp)(width, SIDEBAR_MIN_WIDTH, Math.floor(this.outerContainerWidth / 2));
 
-    const newWidth = (0, _ui_utils.clamp)(width, SIDEBAR_MIN_WIDTH, Math.floor(this.outerContainerWidth / 2));
+      if (newWidth === this._width) {
+        return false;
+      }
 
-    if (newWidth === this._width) {
-      return false;
+      this._width = newWidth;
+      this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, "".concat(newWidth, "px"));
+      return true;
     }
+  }, {
+    key: "_mouseMove",
+    value: function _mouseMove(evt) {
+      var width = evt.clientX;
 
-    this._width = newWidth;
-    this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, `${newWidth}px`);
-    return true;
-  }
-
-  _mouseMove(evt) {
-    let width = evt.clientX;
+      if (this.isRTL) {
+        width = this.outerContainerWidth - width;
+      }
 
-    if (this.isRTL) {
-      width = this.outerContainerWidth - width;
+      this._updateWidth(width);
     }
-
-    this._updateWidth(width);
-  }
-
-  _mouseUp(evt) {
-    this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
-    this.eventBus.dispatch("resize", {
-      source: this
-    });
-    const _boundEvents = this._boundEvents;
-    window.removeEventListener("mousemove", _boundEvents.mouseMove);
-    window.removeEventListener("mouseup", _boundEvents.mouseUp);
-  }
-
-  _addEventListeners() {
-    if (!this.enabled) {
-      return;
+  }, {
+    key: "_mouseUp",
+    value: function _mouseUp(evt) {
+      this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+      this.eventBus.dispatch("resize", {
+        source: this
+      });
+      var _boundEvents = this._boundEvents;
+      window.removeEventListener("mousemove", _boundEvents.mouseMove);
+      window.removeEventListener("mouseup", _boundEvents.mouseUp);
     }
+  }, {
+    key: "_addEventListeners",
+    value: function _addEventListeners() {
+      var _this2 = this;
 
-    const _boundEvents = this._boundEvents;
-    _boundEvents.mouseMove = this._mouseMove.bind(this);
-    _boundEvents.mouseUp = this._mouseUp.bind(this);
-    this.resizer.addEventListener("mousedown", evt => {
-      if (evt.button !== 0) {
+      if (!this.enabled) {
         return;
       }
 
-      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
-      window.addEventListener("mousemove", _boundEvents.mouseMove);
-      window.addEventListener("mouseup", _boundEvents.mouseUp);
-    });
+      var _boundEvents = this._boundEvents;
+      _boundEvents.mouseMove = this._mouseMove.bind(this);
+      _boundEvents.mouseUp = this._mouseUp.bind(this);
+      this.resizer.addEventListener("mousedown", function (evt) {
+        if (evt.button !== 0) {
+          return;
+        }
 
-    this.eventBus._on("sidebarviewchanged", evt => {
-      this.sidebarOpen = !!(evt && evt.view);
-    });
+        _this2.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
 
-    this.eventBus._on("resize", evt => {
-      if (!evt || evt.source !== window) {
-        return;
-      }
+        window.addEventListener("mousemove", _boundEvents.mouseMove);
+        window.addEventListener("mouseup", _boundEvents.mouseUp);
+      });
 
-      this._outerContainerWidth = null;
+      this.eventBus._on("sidebarviewchanged", function (evt) {
+        _this2.sidebarOpen = !!(evt && evt.view);
+      });
 
-      if (!this._width) {
-        return;
-      }
+      this.eventBus._on("resize", function (evt) {
+        if (!evt || evt.source !== window) {
+          return;
+        }
 
-      if (!this.sidebarOpen) {
-        this._updateWidth(this._width);
+        _this2._outerContainerWidth = null;
 
-        return;
-      }
+        if (!_this2._width) {
+          return;
+        }
 
-      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
+        if (!_this2.sidebarOpen) {
+          _this2._updateWidth(_this2._width);
 
-      const updated = this._updateWidth(this._width);
+          return;
+        }
 
-      Promise.resolve().then(() => {
-        this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+        _this2.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
 
-        if (updated) {
-          this.eventBus.dispatch("resize", {
-            source: this
-          });
-        }
+        var updated = _this2._updateWidth(_this2._width);
+
+        Promise.resolve().then(function () {
+          _this2.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+
+          if (updated) {
+            _this2.eventBus.dispatch("resize", {
+              source: _this2
+            });
+          }
+        });
       });
-    });
-  }
+    }
+  }, {
+    key: "outerContainerWidth",
+    get: function get() {
+      if (!this._outerContainerWidth) {
+        this._outerContainerWidth = this.outerContainer.clientWidth;
+      }
 
-}
+      return this._outerContainerWidth;
+    }
+  }]);
+
+  return PDFSidebarResizer;
+}();
 
 exports.PDFSidebarResizer = PDFSidebarResizer;
 
 /***/ }),
-/* 22 */
+/* 25 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -8050,20 +9949,29 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFThumbnailViewer = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_thumbnail_view = __webpack_require__(26);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-var _pdf_thumbnail_view = __webpack_require__(23);
+var THUMBNAIL_SCROLL_MARGIN = -19;
+var THUMBNAIL_SELECTED_CLASS = "selected";
 
-const THUMBNAIL_SCROLL_MARGIN = -19;
-const THUMBNAIL_SELECTED_CLASS = "selected";
+var PDFThumbnailViewer = /*#__PURE__*/function () {
+  function PDFThumbnailViewer(_ref) {
+    var container = _ref.container,
+        linkService = _ref.linkService,
+        renderingQueue = _ref.renderingQueue,
+        _ref$l10n = _ref.l10n,
+        l10n = _ref$l10n === void 0 ? _ui_utils.NullL10n : _ref$l10n;
+
+    _classCallCheck(this, PDFThumbnailViewer);
 
-class PDFThumbnailViewer {
-  constructor({
-    container,
-    linkService,
-    renderingQueue,
-    l10n = _ui_utils.NullL10n
-  }) {
     this.container = container;
     this.linkService = linkService;
     this.renderingQueue = renderingQueue;
@@ -8073,230 +9981,250 @@ class PDFThumbnailViewer {
     this._resetView();
   }
 
-  _scrollUpdated() {
-    this.renderingQueue.renderHighestPriority();
-  }
-
-  getThumbnail(index) {
-    return this._thumbnails[index];
-  }
-
-  _getVisibleThumbs() {
-    return (0, _ui_utils.getVisibleElements)(this.container, this._thumbnails);
-  }
-
-  scrollThumbnailIntoView(pageNumber) {
-    if (!this.pdfDocument) {
-      return;
+  _createClass(PDFThumbnailViewer, [{
+    key: "_scrollUpdated",
+    value: function _scrollUpdated() {
+      this.renderingQueue.renderHighestPriority();
     }
-
-    const thumbnailView = this._thumbnails[pageNumber - 1];
-
-    if (!thumbnailView) {
-      console.error('scrollThumbnailIntoView: Invalid "pageNumber" parameter.');
-      return;
+  }, {
+    key: "getThumbnail",
+    value: function getThumbnail(index) {
+      return this._thumbnails[index];
     }
-
-    if (pageNumber !== this._currentPageNumber) {
-      const prevThumbnailView = this._thumbnails[this._currentPageNumber - 1];
-      prevThumbnailView.div.classList.remove(THUMBNAIL_SELECTED_CLASS);
-      thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
+  }, {
+    key: "_getVisibleThumbs",
+    value: function _getVisibleThumbs() {
+      return (0, _ui_utils.getVisibleElements)(this.container, this._thumbnails);
     }
+  }, {
+    key: "scrollThumbnailIntoView",
+    value: function scrollThumbnailIntoView(pageNumber) {
+      if (!this.pdfDocument) {
+        return;
+      }
 
-    const visibleThumbs = this._getVisibleThumbs();
+      var thumbnailView = this._thumbnails[pageNumber - 1];
 
-    const numVisibleThumbs = visibleThumbs.views.length;
+      if (!thumbnailView) {
+        console.error('scrollThumbnailIntoView: Invalid "pageNumber" parameter.');
+        return;
+      }
 
-    if (numVisibleThumbs > 0) {
-      const first = visibleThumbs.first.id;
-      const last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
-      let shouldScroll = false;
+      if (pageNumber !== this._currentPageNumber) {
+        var prevThumbnailView = this._thumbnails[this._currentPageNumber - 1];
+        prevThumbnailView.div.classList.remove(THUMBNAIL_SELECTED_CLASS);
+        thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
+      }
 
-      if (pageNumber <= first || pageNumber >= last) {
-        shouldScroll = true;
-      } else {
-        visibleThumbs.views.some(function (view) {
-          if (view.id !== pageNumber) {
-            return false;
-          }
+      var visibleThumbs = this._getVisibleThumbs();
 
-          shouldScroll = view.percent < 100;
-          return true;
-        });
-      }
+      var numVisibleThumbs = visibleThumbs.views.length;
 
-      if (shouldScroll) {
-        (0, _ui_utils.scrollIntoView)(thumbnailView.div, {
-          top: THUMBNAIL_SCROLL_MARGIN
-        });
-      }
-    }
+      if (numVisibleThumbs > 0) {
+        var first = visibleThumbs.first.id;
+        var last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
+        var shouldScroll = false;
 
-    this._currentPageNumber = pageNumber;
-  }
+        if (pageNumber <= first || pageNumber >= last) {
+          shouldScroll = true;
+        } else {
+          visibleThumbs.views.some(function (view) {
+            if (view.id !== pageNumber) {
+              return false;
+            }
 
-  get pagesRotation() {
-    return this._pagesRotation;
-  }
+            shouldScroll = view.percent < 100;
+            return true;
+          });
+        }
 
-  set pagesRotation(rotation) {
-    if (!(0, _ui_utils.isValidRotation)(rotation)) {
-      throw new Error("Invalid thumbnails rotation angle.");
-    }
+        if (shouldScroll) {
+          (0, _ui_utils.scrollIntoView)(thumbnailView.div, {
+            top: THUMBNAIL_SCROLL_MARGIN
+          });
+        }
+      }
 
-    if (!this.pdfDocument) {
-      return;
+      this._currentPageNumber = pageNumber;
     }
-
-    if (this._pagesRotation === rotation) {
-      return;
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      _pdf_thumbnail_view.PDFThumbnailView.cleanup();
+    }
+  }, {
+    key: "_resetView",
+    value: function _resetView() {
+      this._thumbnails = [];
+      this._currentPageNumber = 1;
+      this._pageLabels = null;
+      this._pagesRotation = 0;
+      this._pagesRequests = new WeakMap();
+      this.container.textContent = "";
     }
+  }, {
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      var _this = this;
 
-    this._pagesRotation = rotation;
+      if (this.pdfDocument) {
+        this._cancelRendering();
 
-    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
-      this._thumbnails[i].update(rotation);
-    }
-  }
+        this._resetView();
+      }
 
-  cleanup() {
-    _pdf_thumbnail_view.PDFThumbnailView.cleanup();
-  }
+      this.pdfDocument = pdfDocument;
 
-  _resetView() {
-    this._thumbnails = [];
-    this._currentPageNumber = 1;
-    this._pageLabels = null;
-    this._pagesRotation = 0;
-    this._pagesRequests = new WeakMap();
-    this.container.textContent = "";
-  }
+      if (!pdfDocument) {
+        return;
+      }
 
-  setDocument(pdfDocument) {
-    if (this.pdfDocument) {
-      this._cancelRendering();
+      pdfDocument.getPage(1).then(function (firstPdfPage) {
+        var pagesCount = pdfDocument.numPages;
+        var viewport = firstPdfPage.getViewport({
+          scale: 1
+        });
 
-      this._resetView();
-    }
+        for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+          var thumbnail = new _pdf_thumbnail_view.PDFThumbnailView({
+            container: _this.container,
+            id: pageNum,
+            defaultViewport: viewport.clone(),
+            linkService: _this.linkService,
+            renderingQueue: _this.renderingQueue,
+            disableCanvasToImageConversion: false,
+            l10n: _this.l10n
+          });
 
-    this.pdfDocument = pdfDocument;
+          _this._thumbnails.push(thumbnail);
+        }
 
-    if (!pdfDocument) {
-      return;
-    }
+        var firstThumbnailView = _this._thumbnails[0];
 
-    pdfDocument.getPage(1).then(firstPdfPage => {
-      const pagesCount = pdfDocument.numPages;
-      const viewport = firstPdfPage.getViewport({
-        scale: 1
-      });
+        if (firstThumbnailView) {
+          firstThumbnailView.setPdfPage(firstPdfPage);
+        }
 
-      for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
-        const thumbnail = new _pdf_thumbnail_view.PDFThumbnailView({
-          container: this.container,
-          id: pageNum,
-          defaultViewport: viewport.clone(),
-          linkService: this.linkService,
-          renderingQueue: this.renderingQueue,
-          disableCanvasToImageConversion: false,
-          l10n: this.l10n
-        });
+        var thumbnailView = _this._thumbnails[_this._currentPageNumber - 1];
+        thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
+      })["catch"](function (reason) {
+        console.error("Unable to initialize thumbnail viewer", reason);
+      });
+    }
+  }, {
+    key: "_cancelRendering",
+    value: function _cancelRendering() {
+      for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
+        if (this._thumbnails[i]) {
+          this._thumbnails[i].cancelRendering();
+        }
+      }
+    }
+  }, {
+    key: "setPageLabels",
+    value: function setPageLabels(labels) {
+      if (!this.pdfDocument) {
+        return;
+      }
 
-        this._thumbnails.push(thumbnail);
+      if (!labels) {
+        this._pageLabels = null;
+      } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
+        this._pageLabels = null;
+        console.error("PDFThumbnailViewer_setPageLabels: Invalid page labels.");
+      } else {
+        this._pageLabels = labels;
       }
 
-      const firstThumbnailView = this._thumbnails[0];
+      for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
+        var label = this._pageLabels && this._pageLabels[i];
 
-      if (firstThumbnailView) {
-        firstThumbnailView.setPdfPage(firstPdfPage);
+        this._thumbnails[i].setPageLabel(label);
       }
+    }
+  }, {
+    key: "_ensurePdfPageLoaded",
+    value: function _ensurePdfPageLoaded(thumbView) {
+      var _this2 = this;
 
-      const thumbnailView = this._thumbnails[this._currentPageNumber - 1];
-      thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
-    }).catch(reason => {
-      console.error("Unable to initialize thumbnail viewer", reason);
-    });
-  }
+      if (thumbView.pdfPage) {
+        return Promise.resolve(thumbView.pdfPage);
+      }
 
-  _cancelRendering() {
-    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
-      if (this._thumbnails[i]) {
-        this._thumbnails[i].cancelRendering();
+      if (this._pagesRequests.has(thumbView)) {
+        return this._pagesRequests.get(thumbView);
       }
-    }
-  }
 
-  setPageLabels(labels) {
-    if (!this.pdfDocument) {
-      return;
-    }
+      var promise = this.pdfDocument.getPage(thumbView.id).then(function (pdfPage) {
+        if (!thumbView.pdfPage) {
+          thumbView.setPdfPage(pdfPage);
+        }
 
-    if (!labels) {
-      this._pageLabels = null;
-    } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
-      this._pageLabels = null;
-      console.error("PDFThumbnailViewer_setPageLabels: Invalid page labels.");
-    } else {
-      this._pageLabels = labels;
-    }
+        _this2._pagesRequests["delete"](thumbView);
 
-    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
-      const label = this._pageLabels && this._pageLabels[i];
+        return pdfPage;
+      })["catch"](function (reason) {
+        console.error("Unable to get page for thumb view", reason);
 
-      this._thumbnails[i].setPageLabel(label);
-    }
-  }
+        _this2._pagesRequests["delete"](thumbView);
+      });
 
-  _ensurePdfPageLoaded(thumbView) {
-    if (thumbView.pdfPage) {
-      return Promise.resolve(thumbView.pdfPage);
-    }
+      this._pagesRequests.set(thumbView, promise);
 
-    if (this._pagesRequests.has(thumbView)) {
-      return this._pagesRequests.get(thumbView);
+      return promise;
     }
+  }, {
+    key: "forceRendering",
+    value: function forceRendering() {
+      var _this3 = this;
 
-    const promise = this.pdfDocument.getPage(thumbView.id).then(pdfPage => {
-      if (!thumbView.pdfPage) {
-        thumbView.setPdfPage(pdfPage);
-      }
+      var visibleThumbs = this._getVisibleThumbs();
 
-      this._pagesRequests.delete(thumbView);
+      var thumbView = this.renderingQueue.getHighestPriority(visibleThumbs, this._thumbnails, this.scroll.down);
 
-      return pdfPage;
-    }).catch(reason => {
-      console.error("Unable to get page for thumb view", reason);
+      if (thumbView) {
+        this._ensurePdfPageLoaded(thumbView).then(function () {
+          _this3.renderingQueue.renderView(thumbView);
+        });
 
-      this._pagesRequests.delete(thumbView);
-    });
+        return true;
+      }
 
-    this._pagesRequests.set(thumbView, promise);
+      return false;
+    }
+  }, {
+    key: "pagesRotation",
+    get: function get() {
+      return this._pagesRotation;
+    },
+    set: function set(rotation) {
+      if (!(0, _ui_utils.isValidRotation)(rotation)) {
+        throw new Error("Invalid thumbnails rotation angle.");
+      }
 
-    return promise;
-  }
+      if (!this.pdfDocument) {
+        return;
+      }
 
-  forceRendering() {
-    const visibleThumbs = this._getVisibleThumbs();
+      if (this._pagesRotation === rotation) {
+        return;
+      }
 
-    const thumbView = this.renderingQueue.getHighestPriority(visibleThumbs, this._thumbnails, this.scroll.down);
+      this._pagesRotation = rotation;
 
-    if (thumbView) {
-      this._ensurePdfPageLoaded(thumbView).then(() => {
-        this.renderingQueue.renderView(thumbView);
-      });
-
-      return true;
+      for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
+        this._thumbnails[i].update(rotation);
+      }
     }
+  }]);
 
-    return false;
-  }
-
-}
+  return PDFThumbnailViewer;
+}();
 
 exports.PDFThumbnailViewer = PDFThumbnailViewer;
 
 /***/ }),
-/* 23 */
+/* 26 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -8307,21 +10235,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFThumbnailView = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
+
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_rendering_queue = __webpack_require__(11);
 
-var _ui_utils = __webpack_require__(2);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _pdf_rendering_queue = __webpack_require__(8);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-const MAX_NUM_SCALING_STEPS = 3;
-const THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
-const THUMBNAIL_WIDTH = 98;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-const TempImageFactory = function TempImageFactoryClosure() {
-  let tempCanvasCache = null;
+var MAX_NUM_SCALING_STEPS = 3;
+var THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
+var THUMBNAIL_WIDTH = 98;
+
+var TempImageFactory = function TempImageFactoryClosure() {
+  var tempCanvasCache = null;
   return {
-    getCanvas(width, height) {
-      let tempCanvas = tempCanvasCache;
+    getCanvas: function getCanvas(width, height) {
+      var tempCanvas = tempCanvasCache;
 
       if (!tempCanvas) {
         tempCanvas = document.createElement("canvas");
@@ -8331,7 +10265,7 @@ const TempImageFactory = function TempImageFactoryClosure() {
       tempCanvas.width = width;
       tempCanvas.height = height;
       tempCanvas.mozOpaque = true;
-      const ctx = tempCanvas.getContext("2d", {
+      var ctx = tempCanvas.getContext("2d", {
         alpha: false
       });
       ctx.save();
@@ -8340,9 +10274,8 @@ const TempImageFactory = function TempImageFactoryClosure() {
       ctx.restore();
       return tempCanvas;
     },
-
-    destroyCanvas() {
-      const tempCanvas = tempCanvasCache;
+    destroyCanvas: function destroyCanvas() {
+      var tempCanvas = tempCanvasCache;
 
       if (tempCanvas) {
         tempCanvas.width = 0;
@@ -8351,20 +10284,23 @@ const TempImageFactory = function TempImageFactoryClosure() {
 
       tempCanvasCache = null;
     }
-
   };
 }();
 
-class PDFThumbnailView {
-  constructor({
-    container,
-    id,
-    defaultViewport,
-    linkService,
-    renderingQueue,
-    disableCanvasToImageConversion = false,
-    l10n = _ui_utils.NullL10n
-  }) {
+var PDFThumbnailView = /*#__PURE__*/function () {
+  function PDFThumbnailView(_ref) {
+    var container = _ref.container,
+        id = _ref.id,
+        defaultViewport = _ref.defaultViewport,
+        linkService = _ref.linkService,
+        renderingQueue = _ref.renderingQueue,
+        _ref$disableCanvasToI = _ref.disableCanvasToImageConversion,
+        disableCanvasToImageConversion = _ref$disableCanvasToI === void 0 ? false : _ref$disableCanvasToI,
+        _ref$l10n = _ref.l10n,
+        l10n = _ref$l10n === void 0 ? _ui_utils.NullL10n : _ref$l10n;
+
+    _classCallCheck(this, PDFThumbnailView);
+
     this.id = id;
     this.renderingId = "thumbnail" + id;
     this.pageLabel = null;
@@ -8385,10 +10321,10 @@ class PDFThumbnailView {
     this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
     this.scale = this.canvasWidth / this.pageWidth;
     this.l10n = l10n;
-    const anchor = document.createElement("a");
+    var anchor = document.createElement("a");
     anchor.href = linkService.getAnchorUrl("#page=" + id);
 
-    this._thumbPageTitle.then(msg => {
+    this._thumbPageTitle.then(function (msg) {
       anchor.title = msg;
     });
 
@@ -8398,13 +10334,13 @@ class PDFThumbnailView {
     };
 
     this.anchor = anchor;
-    const div = document.createElement("div");
+    var div = document.createElement("div");
     div.className = "thumbnail";
     div.setAttribute("data-page-number", this.id);
     this.div = div;
-    const ring = document.createElement("div");
+    var ring = document.createElement("div");
     ring.className = "thumbnailSelectionRing";
-    const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+    var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
     ring.style.width = this.canvasWidth + borderAdjustment + "px";
     ring.style.height = this.canvasHeight + borderAdjustment + "px";
     this.ring = ring;
@@ -8413,387 +10349,468 @@ class PDFThumbnailView {
     container.appendChild(anchor);
   }
 
-  setPdfPage(pdfPage) {
-    this.pdfPage = pdfPage;
-    this.pdfPageRotate = pdfPage.rotate;
-    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
-    this.viewport = pdfPage.getViewport({
-      scale: 1,
-      rotation: totalRotation
-    });
-    this.reset();
-  }
+  _createClass(PDFThumbnailView, [{
+    key: "setPdfPage",
+    value: function setPdfPage(pdfPage) {
+      this.pdfPage = pdfPage;
+      this.pdfPageRotate = pdfPage.rotate;
+      var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+      this.viewport = pdfPage.getViewport({
+        scale: 1,
+        rotation: totalRotation
+      });
+      this.reset();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.cancelRendering();
+      this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+      this.pageWidth = this.viewport.width;
+      this.pageHeight = this.viewport.height;
+      this.pageRatio = this.pageWidth / this.pageHeight;
+      this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
+      this.scale = this.canvasWidth / this.pageWidth;
+      this.div.removeAttribute("data-loaded");
+      var ring = this.ring;
+      var childNodes = ring.childNodes;
 
-  reset() {
-    this.cancelRendering();
-    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
-    this.pageWidth = this.viewport.width;
-    this.pageHeight = this.viewport.height;
-    this.pageRatio = this.pageWidth / this.pageHeight;
-    this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
-    this.scale = this.canvasWidth / this.pageWidth;
-    this.div.removeAttribute("data-loaded");
-    const ring = this.ring;
-    const childNodes = ring.childNodes;
+      for (var i = childNodes.length - 1; i >= 0; i--) {
+        ring.removeChild(childNodes[i]);
+      }
 
-    for (let i = childNodes.length - 1; i >= 0; i--) {
-      ring.removeChild(childNodes[i]);
-    }
+      var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+      ring.style.width = this.canvasWidth + borderAdjustment + "px";
+      ring.style.height = this.canvasHeight + borderAdjustment + "px";
 
-    const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
-    ring.style.width = this.canvasWidth + borderAdjustment + "px";
-    ring.style.height = this.canvasHeight + borderAdjustment + "px";
+      if (this.canvas) {
+        this.canvas.width = 0;
+        this.canvas.height = 0;
+        delete this.canvas;
+      }
 
-    if (this.canvas) {
-      this.canvas.width = 0;
-      this.canvas.height = 0;
-      delete this.canvas;
+      if (this.image) {
+        this.image.removeAttribute("src");
+        delete this.image;
+      }
     }
+  }, {
+    key: "update",
+    value: function update(rotation) {
+      if (typeof rotation !== "undefined") {
+        this.rotation = rotation;
+      }
 
-    if (this.image) {
-      this.image.removeAttribute("src");
-      delete this.image;
+      var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+      this.viewport = this.viewport.clone({
+        scale: 1,
+        rotation: totalRotation
+      });
+      this.reset();
     }
-  }
+  }, {
+    key: "cancelRendering",
+    value: function cancelRendering() {
+      if (this.renderTask) {
+        this.renderTask.cancel();
+        this.renderTask = null;
+      }
 
-  update(rotation) {
-    if (typeof rotation !== "undefined") {
-      this.rotation = rotation;
+      this.resume = null;
     }
+  }, {
+    key: "_getPageDrawContext",
+    value: function _getPageDrawContext() {
+      var noCtxScale = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var canvas = document.createElement("canvas");
+      this.canvas = canvas;
+      canvas.mozOpaque = true;
+      var ctx = canvas.getContext("2d", {
+        alpha: false
+      });
+      var outputScale = (0, _ui_utils.getOutputScale)(ctx);
+      canvas.width = this.canvasWidth * outputScale.sx | 0;
+      canvas.height = this.canvasHeight * outputScale.sy | 0;
+      canvas.style.width = this.canvasWidth + "px";
+      canvas.style.height = this.canvasHeight + "px";
 
-    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
-    this.viewport = this.viewport.clone({
-      scale: 1,
-      rotation: totalRotation
-    });
-    this.reset();
-  }
+      if (!noCtxScale && outputScale.scaled) {
+        ctx.scale(outputScale.sx, outputScale.sy);
+      }
 
-  cancelRendering() {
-    if (this.renderTask) {
-      this.renderTask.cancel();
-      this.renderTask = null;
+      return ctx;
     }
+  }, {
+    key: "_convertCanvasToImage",
+    value: function _convertCanvasToImage() {
+      var _this = this;
 
-    this.resume = null;
-  }
-
-  _getPageDrawContext(noCtxScale = false) {
-    const canvas = document.createElement("canvas");
-    this.canvas = canvas;
-    canvas.mozOpaque = true;
-    const ctx = canvas.getContext("2d", {
-      alpha: false
-    });
-    const outputScale = (0, _ui_utils.getOutputScale)(ctx);
-    canvas.width = this.canvasWidth * outputScale.sx | 0;
-    canvas.height = this.canvasHeight * outputScale.sy | 0;
-    canvas.style.width = this.canvasWidth + "px";
-    canvas.style.height = this.canvasHeight + "px";
+      if (!this.canvas) {
+        return;
+      }
 
-    if (!noCtxScale && outputScale.scaled) {
-      ctx.scale(outputScale.sx, outputScale.sy);
-    }
+      if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+        return;
+      }
 
-    return ctx;
-  }
+      var className = "thumbnailImage";
 
-  _convertCanvasToImage() {
-    if (!this.canvas) {
-      return;
-    }
+      if (this.disableCanvasToImageConversion) {
+        this.canvas.className = className;
 
-    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
-      return;
-    }
+        this._thumbPageCanvas.then(function (msg) {
+          _this.canvas.setAttribute("aria-label", msg);
+        });
 
-    const className = "thumbnailImage";
+        this.div.setAttribute("data-loaded", true);
+        this.ring.appendChild(this.canvas);
+        return;
+      }
 
-    if (this.disableCanvasToImageConversion) {
-      this.canvas.className = className;
+      var image = document.createElement("img");
+      image.className = className;
 
-      this._thumbPageCanvas.then(msg => {
-        this.canvas.setAttribute("aria-label", msg);
+      this._thumbPageCanvas.then(function (msg) {
+        image.setAttribute("aria-label", msg);
       });
 
+      image.style.width = this.canvasWidth + "px";
+      image.style.height = this.canvasHeight + "px";
+      image.src = this.canvas.toDataURL();
+      this.image = image;
       this.div.setAttribute("data-loaded", true);
-      this.ring.appendChild(this.canvas);
-      return;
+      this.ring.appendChild(image);
+      this.canvas.width = 0;
+      this.canvas.height = 0;
+      delete this.canvas;
     }
+  }, {
+    key: "draw",
+    value: function draw() {
+      var _this2 = this;
 
-    const image = document.createElement("img");
-    image.className = className;
+      if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
+        console.error("Must be in new state before drawing");
+        return Promise.resolve(undefined);
+      }
 
-    this._thumbPageCanvas.then(msg => {
-      image.setAttribute("aria-label", msg);
-    });
+      var pdfPage = this.pdfPage;
 
-    image.style.width = this.canvasWidth + "px";
-    image.style.height = this.canvasHeight + "px";
-    image.src = this.canvas.toDataURL();
-    this.image = image;
-    this.div.setAttribute("data-loaded", true);
-    this.ring.appendChild(image);
-    this.canvas.width = 0;
-    this.canvas.height = 0;
-    delete this.canvas;
-  }
+      if (!pdfPage) {
+        this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+        return Promise.reject(new Error("pdfPage is not loaded"));
+      }
 
-  draw() {
-    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
-      console.error("Must be in new state before drawing");
-      return Promise.resolve(undefined);
-    }
+      this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+      var renderCapability = (0, _pdfjsLib.createPromiseCapability)();
 
-    const {
-      pdfPage
-    } = this;
+      var finishRenderTask = function finishRenderTask(error) {
+        if (renderTask === _this2.renderTask) {
+          _this2.renderTask = null;
+        }
 
-    if (!pdfPage) {
-      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
-      return Promise.reject(new Error("pdfPage is not loaded"));
-    }
+        if (error instanceof _pdfjsLib.RenderingCancelledException) {
+          renderCapability.resolve(undefined);
+          return;
+        }
 
-    this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
-    const renderCapability = (0, _pdfjsLib.createPromiseCapability)();
+        _this2.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
 
-    const finishRenderTask = error => {
-      if (renderTask === this.renderTask) {
-        this.renderTask = null;
-      }
+        _this2._convertCanvasToImage();
 
-      if (error instanceof _pdfjsLib.RenderingCancelledException) {
-        renderCapability.resolve(undefined);
+        if (!error) {
+          renderCapability.resolve(undefined);
+        } else {
+          renderCapability.reject(error);
+        }
+      };
+
+      var ctx = this._getPageDrawContext();
+
+      var drawViewport = this.viewport.clone({
+        scale: this.scale
+      });
+
+      var renderContinueCallback = function renderContinueCallback(cont) {
+        if (!_this2.renderingQueue.isHighestPriority(_this2)) {
+          _this2.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
+
+          _this2.resume = function () {
+            _this2.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+            cont();
+          };
+
+          return;
+        }
+
+        cont();
+      };
+
+      var renderContext = {
+        canvasContext: ctx,
+        viewport: drawViewport
+      };
+      var renderTask = this.renderTask = pdfPage.render(renderContext);
+      renderTask.onContinue = renderContinueCallback;
+      renderTask.promise.then(function () {
+        finishRenderTask(null);
+      }, function (error) {
+        finishRenderTask(error);
+      });
+      return renderCapability.promise;
+    }
+  }, {
+    key: "setImage",
+    value: function setImage(pageView) {
+      if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
         return;
       }
 
-      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+      var img = pageView.canvas;
 
-      this._convertCanvasToImage();
+      if (!img) {
+        return;
+      }
 
-      if (!error) {
-        renderCapability.resolve(undefined);
-      } else {
-        renderCapability.reject(error);
+      if (!this.pdfPage) {
+        this.setPdfPage(pageView.pdfPage);
       }
-    };
 
-    const ctx = this._getPageDrawContext();
+      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
 
-    const drawViewport = this.viewport.clone({
-      scale: this.scale
-    });
+      var ctx = this._getPageDrawContext(true);
 
-    const renderContinueCallback = cont => {
-      if (!this.renderingQueue.isHighestPriority(this)) {
-        this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
+      var canvas = ctx.canvas;
 
-        this.resume = () => {
-          this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
-          cont();
-        };
+      if (img.width <= 2 * canvas.width) {
+        ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+
+        this._convertCanvasToImage();
 
         return;
       }
 
-      cont();
-    };
+      var reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
+      var reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
+      var reducedImage = TempImageFactory.getCanvas(reducedWidth, reducedHeight);
+      var reducedImageCtx = reducedImage.getContext("2d");
 
-    const renderContext = {
-      canvasContext: ctx,
-      viewport: drawViewport
-    };
-    const renderTask = this.renderTask = pdfPage.render(renderContext);
-    renderTask.onContinue = renderContinueCallback;
-    renderTask.promise.then(function () {
-      finishRenderTask(null);
-    }, function (error) {
-      finishRenderTask(error);
-    });
-    return renderCapability.promise;
-  }
+      while (reducedWidth > img.width || reducedHeight > img.height) {
+        reducedWidth >>= 1;
+        reducedHeight >>= 1;
+      }
 
-  setImage(pageView) {
-    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
-      return;
-    }
+      reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0, reducedWidth, reducedHeight);
+
+      while (reducedWidth > 2 * canvas.width) {
+        reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
+        reducedWidth >>= 1;
+        reducedHeight >>= 1;
+      }
 
-    const img = pageView.canvas;
+      ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, canvas.width, canvas.height);
 
-    if (!img) {
-      return;
+      this._convertCanvasToImage();
     }
+  }, {
+    key: "setPageLabel",
+    value: function setPageLabel(label) {
+      var _this3 = this;
+
+      this.pageLabel = typeof label === "string" ? label : null;
+
+      this._thumbPageTitle.then(function (msg) {
+        _this3.anchor.title = msg;
+      });
 
-    if (!this.pdfPage) {
-      this.setPdfPage(pageView.pdfPage);
+      if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+        return;
+      }
+
+      this._thumbPageCanvas.then(function (msg) {
+        if (_this3.image) {
+          _this3.image.setAttribute("aria-label", msg);
+        } else if (_this3.disableCanvasToImageConversion && _this3.canvas) {
+          _this3.canvas.setAttribute("aria-label", msg);
+        }
+      });
+    }
+  }, {
+    key: "_thumbPageTitle",
+    get: function get() {
+      return this.l10n.get("thumb_page_title", {
+        page: this.pageLabel !== null ? this.pageLabel : this.id
+      }, "Page {{page}}");
+    }
+  }, {
+    key: "_thumbPageCanvas",
+    get: function get() {
+      return this.l10n.get("thumb_page_canvas", {
+        page: this.pageLabel !== null ? this.pageLabel : this.id
+      }, "Thumbnail of Page {{page}}");
+    }
+  }], [{
+    key: "cleanup",
+    value: function cleanup() {
+      TempImageFactory.destroyCanvas();
     }
+  }]);
 
-    this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+  return PDFThumbnailView;
+}();
 
-    const ctx = this._getPageDrawContext(true);
+exports.PDFThumbnailView = PDFThumbnailView;
 
-    const canvas = ctx.canvas;
+/***/ }),
+/* 27 */
+/***/ (function(module, exports, __webpack_require__) {
 
-    if (img.width <= 2 * canvas.width) {
-      ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+"use strict";
 
-      this._convertCanvasToImage();
 
-      return;
-    }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PDFViewer = void 0;
 
-    let reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
-    let reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
-    const reducedImage = TempImageFactory.getCanvas(reducedWidth, reducedHeight);
-    const reducedImageCtx = reducedImage.getContext("2d");
+var _base_viewer = __webpack_require__(28);
 
-    while (reducedWidth > img.width || reducedHeight > img.height) {
-      reducedWidth >>= 1;
-      reducedHeight >>= 1;
-    }
+var _pdfjsLib = __webpack_require__(8);
 
-    reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0, reducedWidth, reducedHeight);
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-    while (reducedWidth > 2 * canvas.width) {
-      reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
-      reducedWidth >>= 1;
-      reducedHeight >>= 1;
-    }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-    ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, canvas.width, canvas.height);
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-    this._convertCanvasToImage();
-  }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-  get _thumbPageTitle() {
-    return this.l10n.get("thumb_page_title", {
-      page: this.pageLabel !== null ? this.pageLabel : this.id
-    }, "Page {{page}}");
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  get _thumbPageCanvas() {
-    return this.l10n.get("thumb_page_canvas", {
-      page: this.pageLabel !== null ? this.pageLabel : this.id
-    }, "Thumbnail of Page {{page}}");
-  }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-  setPageLabel(label) {
-    this.pageLabel = typeof label === "string" ? label : null;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-    this._thumbPageTitle.then(msg => {
-      this.anchor.title = msg;
-    });
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
 
-    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
-      return;
-    }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-    this._thumbPageCanvas.then(msg => {
-      if (this.image) {
-        this.image.setAttribute("aria-label", msg);
-      } else if (this.disableCanvasToImageConversion && this.canvas) {
-        this.canvas.setAttribute("aria-label", msg);
-      }
-    });
-  }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-  static cleanup() {
-    TempImageFactory.destroyCanvas();
-  }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-}
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-exports.PDFThumbnailView = PDFThumbnailView;
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-/***/ }),
-/* 24 */
-/***/ (function(module, exports, __webpack_require__) {
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-"use strict";
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PDFViewer = void 0;
+var PDFViewer = /*#__PURE__*/function (_BaseViewer) {
+  _inherits(PDFViewer, _BaseViewer);
 
-var _base_viewer = __webpack_require__(25);
+  var _super = _createSuper(PDFViewer);
 
-var _pdfjsLib = __webpack_require__(5);
+  function PDFViewer() {
+    _classCallCheck(this, PDFViewer);
 
-class PDFViewer extends _base_viewer.BaseViewer {
-  get _viewerElement() {
-    return (0, _pdfjsLib.shadow)(this, "_viewerElement", this.viewer);
+    return _super.apply(this, arguments);
   }
 
-  _scrollIntoView({
-    pageDiv,
-    pageSpot = null,
-    pageNumber = null
-  }) {
-    if (!pageSpot && !this.isInPresentationMode) {
-      const left = pageDiv.offsetLeft + pageDiv.clientLeft;
-      const right = left + pageDiv.clientWidth;
-      const {
-        scrollLeft,
-        clientWidth
-      } = this.container;
+  _createClass(PDFViewer, [{
+    key: "_scrollIntoView",
+    value: function _scrollIntoView(_ref) {
+      var pageDiv = _ref.pageDiv,
+          _ref$pageSpot = _ref.pageSpot,
+          pageSpot = _ref$pageSpot === void 0 ? null : _ref$pageSpot,
+          _ref$pageNumber = _ref.pageNumber,
+          pageNumber = _ref$pageNumber === void 0 ? null : _ref$pageNumber;
 
-      if (this._isScrollModeHorizontal || left < scrollLeft || right > scrollLeft + clientWidth) {
-        pageSpot = {
-          left: 0,
-          top: 0
-        };
+      if (!pageSpot && !this.isInPresentationMode) {
+        var left = pageDiv.offsetLeft + pageDiv.clientLeft;
+        var right = left + pageDiv.clientWidth;
+        var _this$container = this.container,
+            scrollLeft = _this$container.scrollLeft,
+            clientWidth = _this$container.clientWidth;
+
+        if (this._isScrollModeHorizontal || left < scrollLeft || right > scrollLeft + clientWidth) {
+          pageSpot = {
+            left: 0,
+            top: 0
+          };
+        }
       }
-    }
 
-    super._scrollIntoView({
-      pageDiv,
-      pageSpot,
-      pageNumber
-    });
-  }
+      _get(_getPrototypeOf(PDFViewer.prototype), "_scrollIntoView", this).call(this, {
+        pageDiv: pageDiv,
+        pageSpot: pageSpot,
+        pageNumber: pageNumber
+      });
+    }
+  }, {
+    key: "_getVisiblePages",
+    value: function _getVisiblePages() {
+      if (this.isInPresentationMode) {
+        return this._getCurrentVisiblePage();
+      }
 
-  _getVisiblePages() {
-    if (this.isInPresentationMode) {
-      return this._getCurrentVisiblePage();
+      return _get(_getPrototypeOf(PDFViewer.prototype), "_getVisiblePages", this).call(this);
     }
+  }, {
+    key: "_updateHelper",
+    value: function _updateHelper(visiblePages) {
+      if (this.isInPresentationMode) {
+        return;
+      }
 
-    return super._getVisiblePages();
-  }
+      var currentId = this._currentPageNumber;
+      var stillFullyVisible = false;
 
-  _updateHelper(visiblePages) {
-    if (this.isInPresentationMode) {
-      return;
-    }
+      var _iterator = _createForOfIteratorHelper(visiblePages),
+          _step;
 
-    let currentId = this._currentPageNumber;
-    let stillFullyVisible = false;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var page = _step.value;
 
-    for (const page of visiblePages) {
-      if (page.percent < 100) {
-        break;
+          if (page.percent < 100) {
+            break;
+          }
+
+          if (page.id === currentId) {
+            stillFullyVisible = true;
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
 
-      if (page.id === currentId) {
-        stillFullyVisible = true;
-        break;
+      if (!stillFullyVisible) {
+        currentId = visiblePages[0].id;
       }
-    }
 
-    if (!stillFullyVisible) {
-      currentId = visiblePages[0].id;
+      this._setCurrentPageNumber(currentId);
     }
+  }, {
+    key: "_viewerElement",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "_viewerElement", this.viewer);
+    }
+  }]);
 
-    this._setCurrentPageNumber(currentId);
-  }
-
-}
+  return PDFViewer;
+}(_base_viewer.BaseViewer);
 
 exports.PDFViewer = PDFViewer;
 
 /***/ }),
-/* 25 */
+/* 28 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -8804,27 +10821,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BaseViewer = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_rendering_queue = __webpack_require__(11);
+
+var _annotation_layer_builder = __webpack_require__(29);
 
-var _pdf_rendering_queue = __webpack_require__(8);
+var _pdfjsLib = __webpack_require__(8);
 
-var _annotation_layer_builder = __webpack_require__(26);
+var _pdf_page_view = __webpack_require__(30);
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdf_link_service = __webpack_require__(21);
 
-var _pdf_page_view = __webpack_require__(27);
+var _text_layer_builder = __webpack_require__(31);
 
-var _pdf_link_service = __webpack_require__(18);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _text_layer_builder = __webpack_require__(28);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-const DEFAULT_CACHE_SIZE = 10;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DEFAULT_CACHE_SIZE = 10;
 
 function PDFPageViewBuffer(size) {
-  const data = [];
+  var data = [];
 
   this.push = function (view) {
-    const i = data.indexOf(view);
+    var i = data.indexOf(view);
 
     if (i >= 0) {
       data.splice(i, 1);
@@ -8841,9 +10864,9 @@ function PDFPageViewBuffer(size) {
     size = newSize;
 
     if (pagesToKeep) {
-      const pageIdsToKeep = new Set();
+      var pageIdsToKeep = new Set();
 
-      for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
+      for (var i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
         pageIdsToKeep.add(pagesToKeep[i].id);
       }
 
@@ -8870,8 +10893,12 @@ function isSameScale(oldScale, newScale) {
   return false;
 }
 
-class BaseViewer {
-  constructor(options) {
+var BaseViewer = /*#__PURE__*/function () {
+  function BaseViewer(options) {
+    var _this = this;
+
+    _classCallCheck(this, BaseViewer);
+
     if (this.constructor === BaseViewer) {
       throw new Error("Cannot initialize BaseViewer.");
     }
@@ -8912,1008 +10939,1082 @@ class BaseViewer {
       this.viewer.classList.add("removePageBorders");
     }
 
-    Promise.resolve().then(() => {
-      this.eventBus.dispatch("baseviewerinit", {
-        source: this
+    Promise.resolve().then(function () {
+      _this.eventBus.dispatch("baseviewerinit", {
+        source: _this
       });
     });
   }
 
-  get pagesCount() {
-    return this._pages.length;
-  }
-
-  getPageView(index) {
-    return this._pages[index];
-  }
-
-  get pageViewsReady() {
-    if (!this._pagesCapability.settled) {
-      return false;
+  _createClass(BaseViewer, [{
+    key: "getPageView",
+    value: function getPageView(index) {
+      return this._pages[index];
     }
+  }, {
+    key: "_setCurrentPageNumber",
+    value: function _setCurrentPageNumber(val) {
+      var resetCurrentPageView = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-    return this._pages.every(function (pageView) {
-      return pageView && pageView.pdfPage;
-    });
-  }
-
-  get currentPageNumber() {
-    return this._currentPageNumber;
-  }
+      if (this._currentPageNumber === val) {
+        if (resetCurrentPageView) {
+          this._resetCurrentPageView();
+        }
 
-  set currentPageNumber(val) {
-    if (!Number.isInteger(val)) {
-      throw new Error("Invalid page number.");
-    }
+        return true;
+      }
 
-    if (!this.pdfDocument) {
-      return;
-    }
+      if (!(0 < val && val <= this.pagesCount)) {
+        return false;
+      }
 
-    if (!this._setCurrentPageNumber(val, true)) {
-      console.error(`${this._name}.currentPageNumber: "${val}" is not a valid page.`);
-    }
-  }
+      this._currentPageNumber = val;
+      this.eventBus.dispatch("pagechanging", {
+        source: this,
+        pageNumber: val,
+        pageLabel: this._pageLabels && this._pageLabels[val - 1]
+      });
 
-  _setCurrentPageNumber(val, resetCurrentPageView = false) {
-    if (this._currentPageNumber === val) {
       if (resetCurrentPageView) {
         this._resetCurrentPageView();
       }
 
       return true;
     }
+  }, {
+    key: "_onePageRenderedOrForceFetch",
+    value: function _onePageRenderedOrForceFetch() {
+      if (!this.container.offsetParent || this._getVisiblePages().views.length === 0) {
+        return Promise.resolve();
+      }
 
-    if (!(0 < val && val <= this.pagesCount)) {
-      return false;
-    }
-
-    this._currentPageNumber = val;
-    this.eventBus.dispatch("pagechanging", {
-      source: this,
-      pageNumber: val,
-      pageLabel: this._pageLabels && this._pageLabels[val - 1]
-    });
-
-    if (resetCurrentPageView) {
-      this._resetCurrentPageView();
+      return this._onePageRenderedCapability.promise;
     }
+  }, {
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      var _this2 = this;
 
-    return true;
-  }
-
-  get currentPageLabel() {
-    return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
-  }
+      if (this.pdfDocument) {
+        this._cancelRendering();
 
-  set currentPageLabel(val) {
-    if (!this.pdfDocument) {
-      return;
-    }
+        this._resetView();
 
-    let page = val | 0;
+        if (this.findController) {
+          this.findController.setDocument(null);
+        }
+      }
 
-    if (this._pageLabels) {
-      const i = this._pageLabels.indexOf(val);
+      this.pdfDocument = pdfDocument;
 
-      if (i >= 0) {
-        page = i + 1;
+      if (!pdfDocument) {
+        return;
       }
-    }
 
-    if (!this._setCurrentPageNumber(page, true)) {
-      console.error(`${this._name}.currentPageLabel: "${val}" is not a valid page.`);
-    }
-  }
+      var pagesCount = pdfDocument.numPages;
+      var firstPagePromise = pdfDocument.getPage(1);
 
-  get currentScale() {
-    return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
-  }
+      this._pagesCapability.promise.then(function () {
+        _this2.eventBus.dispatch("pagesloaded", {
+          source: _this2,
+          pagesCount: pagesCount
+        });
+      });
 
-  set currentScale(val) {
-    if (isNaN(val)) {
-      throw new Error("Invalid numeric scale.");
-    }
+      this._onBeforeDraw = function (evt) {
+        var pageView = _this2._pages[evt.pageNumber - 1];
 
-    if (!this.pdfDocument) {
-      return;
-    }
+        if (!pageView) {
+          return;
+        }
 
-    this._setScale(val, false);
-  }
+        _this2._buffer.push(pageView);
+      };
 
-  get currentScaleValue() {
-    return this._currentScaleValue;
-  }
+      this.eventBus._on("pagerender", this._onBeforeDraw);
 
-  set currentScaleValue(val) {
-    if (!this.pdfDocument) {
-      return;
-    }
+      this._onAfterDraw = function (evt) {
+        if (evt.cssTransform || _this2._onePageRenderedCapability.settled) {
+          return;
+        }
 
-    this._setScale(val, false);
-  }
+        _this2._onePageRenderedCapability.resolve();
 
-  get pagesRotation() {
-    return this._pagesRotation;
-  }
+        _this2.eventBus._off("pagerendered", _this2._onAfterDraw);
 
-  set pagesRotation(rotation) {
-    if (!(0, _ui_utils.isValidRotation)(rotation)) {
-      throw new Error("Invalid pages rotation angle.");
-    }
+        _this2._onAfterDraw = null;
+      };
 
-    if (!this.pdfDocument) {
-      return;
-    }
+      this.eventBus._on("pagerendered", this._onAfterDraw);
 
-    if (this._pagesRotation === rotation) {
-      return;
-    }
+      firstPagePromise.then(function (firstPdfPage) {
+        _this2._firstPageCapability.resolve(firstPdfPage);
 
-    this._pagesRotation = rotation;
-    const pageNumber = this._currentPageNumber;
+        var scale = _this2.currentScale;
+        var viewport = firstPdfPage.getViewport({
+          scale: scale * _ui_utils.CSS_UNITS
+        });
+        var textLayerFactory = _this2.textLayerMode !== _ui_utils.TextLayerMode.DISABLE ? _this2 : null;
+
+        for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+          var pageView = new _pdf_page_view.PDFPageView({
+            container: _this2._viewerElement,
+            eventBus: _this2.eventBus,
+            id: pageNum,
+            scale: scale,
+            defaultViewport: viewport.clone(),
+            renderingQueue: _this2.renderingQueue,
+            textLayerFactory: textLayerFactory,
+            textLayerMode: _this2.textLayerMode,
+            annotationLayerFactory: _this2,
+            imageResourcesPath: _this2.imageResourcesPath,
+            renderInteractiveForms: _this2.renderInteractiveForms,
+            renderer: _this2.renderer,
+            enableWebGL: _this2.enableWebGL,
+            useOnlyCssZoom: _this2.useOnlyCssZoom,
+            maxCanvasPixels: _this2.maxCanvasPixels,
+            l10n: _this2.l10n
+          });
 
-    for (let i = 0, ii = this._pages.length; i < ii; i++) {
-      const pageView = this._pages[i];
-      pageView.update(pageView.scale, rotation);
-    }
+          _this2._pages.push(pageView);
+        }
 
-    if (this._currentScaleValue) {
-      this._setScale(this._currentScaleValue, true);
-    }
+        var firstPageView = _this2._pages[0];
 
-    this.eventBus.dispatch("rotationchanging", {
-      source: this,
-      pagesRotation: rotation,
-      pageNumber
-    });
+        if (firstPageView) {
+          firstPageView.setPdfPage(firstPdfPage);
 
-    if (this.defaultRenderingQueue) {
-      this.update();
-    }
-  }
+          _this2.linkService.cachePageRef(1, firstPdfPage.ref);
+        }
 
-  get firstPagePromise() {
-    return this.pdfDocument ? this._firstPageCapability.promise : null;
-  }
+        if (_this2._spreadMode !== _ui_utils.SpreadMode.NONE) {
+          _this2._updateSpreadMode();
+        }
 
-  get onePageRendered() {
-    return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
-  }
+        _this2._onePageRenderedOrForceFetch().then(function () {
+          if (_this2.findController) {
+            _this2.findController.setDocument(pdfDocument);
+          }
 
-  get pagesPromise() {
-    return this.pdfDocument ? this._pagesCapability.promise : null;
-  }
+          if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
+            _this2._pagesCapability.resolve();
 
-  get _viewerElement() {
-    throw new Error("Not implemented: _viewerElement");
-  }
+            return;
+          }
 
-  _onePageRenderedOrForceFetch() {
-    if (!this.container.offsetParent || this._getVisiblePages().views.length === 0) {
-      return Promise.resolve();
-    }
+          var getPagesLeft = pagesCount - 1;
 
-    return this._onePageRenderedCapability.promise;
-  }
+          if (getPagesLeft <= 0) {
+            _this2._pagesCapability.resolve();
 
-  setDocument(pdfDocument) {
-    if (this.pdfDocument) {
-      this._cancelRendering();
+            return;
+          }
 
-      this._resetView();
+          var _loop = function _loop(_pageNum) {
+            pdfDocument.getPage(_pageNum).then(function (pdfPage) {
+              var pageView = _this2._pages[_pageNum - 1];
 
-      if (this.findController) {
-        this.findController.setDocument(null);
-      }
-    }
+              if (!pageView.pdfPage) {
+                pageView.setPdfPage(pdfPage);
+              }
 
-    this.pdfDocument = pdfDocument;
+              _this2.linkService.cachePageRef(_pageNum, pdfPage.ref);
 
-    if (!pdfDocument) {
-      return;
-    }
+              if (--getPagesLeft === 0) {
+                _this2._pagesCapability.resolve();
+              }
+            }, function (reason) {
+              console.error("Unable to get page ".concat(_pageNum, " to initialize viewer"), reason);
 
-    const pagesCount = pdfDocument.numPages;
-    const firstPagePromise = pdfDocument.getPage(1);
+              if (--getPagesLeft === 0) {
+                _this2._pagesCapability.resolve();
+              }
+            });
+          };
 
-    this._pagesCapability.promise.then(() => {
-      this.eventBus.dispatch("pagesloaded", {
-        source: this,
-        pagesCount
-      });
-    });
+          for (var _pageNum = 2; _pageNum <= pagesCount; ++_pageNum) {
+            _loop(_pageNum);
+          }
+        });
 
-    this._onBeforeDraw = evt => {
-      const pageView = this._pages[evt.pageNumber - 1];
+        _this2.eventBus.dispatch("pagesinit", {
+          source: _this2
+        });
 
-      if (!pageView) {
+        if (_this2.defaultRenderingQueue) {
+          _this2.update();
+        }
+      })["catch"](function (reason) {
+        console.error("Unable to initialize viewer", reason);
+      });
+    }
+  }, {
+    key: "setPageLabels",
+    value: function setPageLabels(labels) {
+      if (!this.pdfDocument) {
         return;
       }
 
-      this._buffer.push(pageView);
-    };
-
-    this.eventBus._on("pagerender", this._onBeforeDraw);
-
-    this._onAfterDraw = evt => {
-      if (evt.cssTransform || this._onePageRenderedCapability.settled) {
-        return;
+      if (!labels) {
+        this._pageLabels = null;
+      } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
+        this._pageLabels = null;
+        console.error("".concat(this._name, ".setPageLabels: Invalid page labels."));
+      } else {
+        this._pageLabels = labels;
       }
 
-      this._onePageRenderedCapability.resolve();
-
-      this.eventBus._off("pagerendered", this._onAfterDraw);
-
-      this._onAfterDraw = null;
-    };
+      for (var i = 0, ii = this._pages.length; i < ii; i++) {
+        var pageView = this._pages[i];
+        var label = this._pageLabels && this._pageLabels[i];
+        pageView.setPageLabel(label);
+      }
+    }
+  }, {
+    key: "_resetView",
+    value: function _resetView() {
+      this._pages = [];
+      this._currentPageNumber = 1;
+      this._currentScale = _ui_utils.UNKNOWN_SCALE;
+      this._currentScaleValue = null;
+      this._pageLabels = null;
+      this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
+      this._location = null;
+      this._pagesRotation = 0;
+      this._pagesRequests = new WeakMap();
+      this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
+      this._spreadMode = _ui_utils.SpreadMode.NONE;
 
-    this.eventBus._on("pagerendered", this._onAfterDraw);
-
-    firstPagePromise.then(firstPdfPage => {
-      this._firstPageCapability.resolve(firstPdfPage);
-
-      const scale = this.currentScale;
-      const viewport = firstPdfPage.getViewport({
-        scale: scale * _ui_utils.CSS_UNITS
-      });
-      const textLayerFactory = this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE ? this : null;
-
-      for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
-        const pageView = new _pdf_page_view.PDFPageView({
-          container: this._viewerElement,
-          eventBus: this.eventBus,
-          id: pageNum,
-          scale,
-          defaultViewport: viewport.clone(),
-          renderingQueue: this.renderingQueue,
-          textLayerFactory,
-          textLayerMode: this.textLayerMode,
-          annotationLayerFactory: this,
-          imageResourcesPath: this.imageResourcesPath,
-          renderInteractiveForms: this.renderInteractiveForms,
-          renderer: this.renderer,
-          enableWebGL: this.enableWebGL,
-          useOnlyCssZoom: this.useOnlyCssZoom,
-          maxCanvasPixels: this.maxCanvasPixels,
-          l10n: this.l10n
-        });
+      if (this._onBeforeDraw) {
+        this.eventBus._off("pagerender", this._onBeforeDraw);
 
-        this._pages.push(pageView);
+        this._onBeforeDraw = null;
       }
 
-      const firstPageView = this._pages[0];
+      if (this._onAfterDraw) {
+        this.eventBus._off("pagerendered", this._onAfterDraw);
 
-      if (firstPageView) {
-        firstPageView.setPdfPage(firstPdfPage);
-        this.linkService.cachePageRef(1, firstPdfPage.ref);
+        this._onAfterDraw = null;
       }
 
-      if (this._spreadMode !== _ui_utils.SpreadMode.NONE) {
-        this._updateSpreadMode();
+      this.viewer.textContent = "";
+
+      this._updateScrollMode();
+    }
+  }, {
+    key: "_scrollUpdate",
+    value: function _scrollUpdate() {
+      if (this.pagesCount === 0) {
+        return;
       }
 
-      this._onePageRenderedOrForceFetch().then(() => {
-        if (this.findController) {
-          this.findController.setDocument(pdfDocument);
+      this.update();
+    }
+  }, {
+    key: "_scrollIntoView",
+    value: function _scrollIntoView(_ref) {
+      var pageDiv = _ref.pageDiv,
+          _ref$pageSpot = _ref.pageSpot,
+          pageSpot = _ref$pageSpot === void 0 ? null : _ref$pageSpot,
+          _ref$pageNumber = _ref.pageNumber,
+          pageNumber = _ref$pageNumber === void 0 ? null : _ref$pageNumber;
+      (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
+    }
+  }, {
+    key: "_setScaleUpdatePages",
+    value: function _setScaleUpdatePages(newScale, newValue) {
+      var noScroll = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var preset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      this._currentScaleValue = newValue.toString();
+
+      if (isSameScale(this._currentScale, newScale)) {
+        if (preset) {
+          this.eventBus.dispatch("scalechanging", {
+            source: this,
+            scale: newScale,
+            presetValue: newValue
+          });
         }
 
-        if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
-          this._pagesCapability.resolve();
+        return;
+      }
 
-          return;
-        }
+      for (var i = 0, ii = this._pages.length; i < ii; i++) {
+        this._pages[i].update(newScale);
+      }
 
-        let getPagesLeft = pagesCount - 1;
+      this._currentScale = newScale;
 
-        if (getPagesLeft <= 0) {
-          this._pagesCapability.resolve();
+      if (!noScroll) {
+        var page = this._currentPageNumber,
+            dest;
 
-          return;
+        if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
+          page = this._location.pageNumber;
+          dest = [null, {
+            name: "XYZ"
+          }, this._location.left, this._location.top, null];
         }
 
-        for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
-          pdfDocument.getPage(pageNum).then(pdfPage => {
-            const pageView = this._pages[pageNum - 1];
-
-            if (!pageView.pdfPage) {
-              pageView.setPdfPage(pdfPage);
-            }
-
-            this.linkService.cachePageRef(pageNum, pdfPage.ref);
-
-            if (--getPagesLeft === 0) {
-              this._pagesCapability.resolve();
-            }
-          }, reason => {
-            console.error(`Unable to get page ${pageNum} to initialize viewer`, reason);
-
-            if (--getPagesLeft === 0) {
-              this._pagesCapability.resolve();
-            }
-          });
-        }
-      });
+        this.scrollPageIntoView({
+          pageNumber: page,
+          destArray: dest,
+          allowNegativeOffset: true
+        });
+      }
 
-      this.eventBus.dispatch("pagesinit", {
-        source: this
+      this.eventBus.dispatch("scalechanging", {
+        source: this,
+        scale: newScale,
+        presetValue: preset ? newValue : undefined
       });
 
       if (this.defaultRenderingQueue) {
         this.update();
       }
-    }).catch(reason => {
-      console.error("Unable to initialize viewer", reason);
-    });
-  }
-
-  setPageLabels(labels) {
-    if (!this.pdfDocument) {
-      return;
-    }
-
-    if (!labels) {
-      this._pageLabels = null;
-    } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
-      this._pageLabels = null;
-      console.error(`${this._name}.setPageLabels: Invalid page labels.`);
-    } else {
-      this._pageLabels = labels;
     }
+  }, {
+    key: "_setScale",
+    value: function _setScale(value) {
+      var noScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var scale = parseFloat(value);
 
-    for (let i = 0, ii = this._pages.length; i < ii; i++) {
-      const pageView = this._pages[i];
-      const label = this._pageLabels && this._pageLabels[i];
-      pageView.setPageLabel(label);
-    }
-  }
-
-  _resetView() {
-    this._pages = [];
-    this._currentPageNumber = 1;
-    this._currentScale = _ui_utils.UNKNOWN_SCALE;
-    this._currentScaleValue = null;
-    this._pageLabels = null;
-    this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
-    this._location = null;
-    this._pagesRotation = 0;
-    this._pagesRequests = new WeakMap();
-    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
-    this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)();
-    this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)();
-    this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
-    this._spreadMode = _ui_utils.SpreadMode.NONE;
+      if (scale > 0) {
+        this._setScaleUpdatePages(scale, value, noScroll, false);
+      } else {
+        var currentPage = this._pages[this._currentPageNumber - 1];
 
-    if (this._onBeforeDraw) {
-      this.eventBus._off("pagerender", this._onBeforeDraw);
+        if (!currentPage) {
+          return;
+        }
 
-      this._onBeforeDraw = null;
-    }
+        var noPadding = this.isInPresentationMode || this.removePageBorders;
+        var hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING;
+        var vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING;
 
-    if (this._onAfterDraw) {
-      this.eventBus._off("pagerendered", this._onAfterDraw);
+        if (!noPadding && this._isScrollModeHorizontal) {
+          var _ref2 = [vPadding, hPadding];
+          hPadding = _ref2[0];
+          vPadding = _ref2[1];
+        }
 
-      this._onAfterDraw = null;
-    }
+        var pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale;
+        var pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
 
-    this.viewer.textContent = "";
+        switch (value) {
+          case "page-actual":
+            scale = 1;
+            break;
 
-    this._updateScrollMode();
-  }
+          case "page-width":
+            scale = pageWidthScale;
+            break;
 
-  _scrollUpdate() {
-    if (this.pagesCount === 0) {
-      return;
-    }
+          case "page-height":
+            scale = pageHeightScale;
+            break;
 
-    this.update();
-  }
+          case "page-fit":
+            scale = Math.min(pageWidthScale, pageHeightScale);
+            break;
 
-  _scrollIntoView({
-    pageDiv,
-    pageSpot = null,
-    pageNumber = null
-  }) {
-    (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
-  }
+          case "auto":
+            var horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
+            scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
+            break;
 
-  _setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {
-    this._currentScaleValue = newValue.toString();
+          default:
+            console.error("".concat(this._name, "._setScale: \"").concat(value, "\" is an unknown zoom value."));
+            return;
+        }
 
-    if (isSameScale(this._currentScale, newScale)) {
-      if (preset) {
-        this.eventBus.dispatch("scalechanging", {
-          source: this,
-          scale: newScale,
-          presetValue: newValue
-        });
+        this._setScaleUpdatePages(scale, value, noScroll, true);
       }
-
-      return;
-    }
-
-    for (let i = 0, ii = this._pages.length; i < ii; i++) {
-      this._pages[i].update(newScale);
     }
-
-    this._currentScale = newScale;
-
-    if (!noScroll) {
-      let page = this._currentPageNumber,
-          dest;
-
-      if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
-        page = this._location.pageNumber;
-        dest = [null, {
-          name: "XYZ"
-        }, this._location.left, this._location.top, null];
+  }, {
+    key: "_resetCurrentPageView",
+    value: function _resetCurrentPageView() {
+      if (this.isInPresentationMode) {
+        this._setScale(this._currentScaleValue, true);
       }
 
-      this.scrollPageIntoView({
-        pageNumber: page,
-        destArray: dest,
-        allowNegativeOffset: true
-      });
-    }
+      var pageView = this._pages[this._currentPageNumber - 1];
 
-    this.eventBus.dispatch("scalechanging", {
-      source: this,
-      scale: newScale,
-      presetValue: preset ? newValue : undefined
-    });
-
-    if (this.defaultRenderingQueue) {
-      this.update();
+      this._scrollIntoView({
+        pageDiv: pageView.div
+      });
     }
-  }
-
-  _setScale(value, noScroll = false) {
-    let scale = parseFloat(value);
+  }, {
+    key: "scrollPageIntoView",
+    value: function scrollPageIntoView(_ref3) {
+      var pageNumber = _ref3.pageNumber,
+          _ref3$destArray = _ref3.destArray,
+          destArray = _ref3$destArray === void 0 ? null : _ref3$destArray,
+          _ref3$allowNegativeOf = _ref3.allowNegativeOffset,
+          allowNegativeOffset = _ref3$allowNegativeOf === void 0 ? false : _ref3$allowNegativeOf,
+          _ref3$ignoreDestinati = _ref3.ignoreDestinationZoom,
+          ignoreDestinationZoom = _ref3$ignoreDestinati === void 0 ? false : _ref3$ignoreDestinati;
+
+      if (!this.pdfDocument) {
+        return;
+      }
 
-    if (scale > 0) {
-      this._setScaleUpdatePages(scale, value, noScroll, false);
-    } else {
-      const currentPage = this._pages[this._currentPageNumber - 1];
+      var pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
 
-      if (!currentPage) {
+      if (!pageView) {
+        console.error("".concat(this._name, ".scrollPageIntoView: ") + "\"".concat(pageNumber, "\" is not a valid pageNumber parameter."));
         return;
       }
 
-      const noPadding = this.isInPresentationMode || this.removePageBorders;
-      let hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING;
-      let vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING;
+      if (this.isInPresentationMode || !destArray) {
+        this._setCurrentPageNumber(pageNumber, true);
 
-      if (!noPadding && this._isScrollModeHorizontal) {
-        [hPadding, vPadding] = [vPadding, hPadding];
+        return;
       }
 
-      const pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale;
-      const pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
-
-      switch (value) {
-        case "page-actual":
-          scale = 1;
+      var x = 0,
+          y = 0;
+      var width = 0,
+          height = 0,
+          widthScale,
+          heightScale;
+      var changeOrientation = pageView.rotation % 180 !== 0;
+      var pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS;
+      var pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS;
+      var scale = 0;
+
+      switch (destArray[1].name) {
+        case "XYZ":
+          x = destArray[2];
+          y = destArray[3];
+          scale = destArray[4];
+          x = x !== null ? x : 0;
+          y = y !== null ? y : pageHeight;
           break;
 
-        case "page-width":
-          scale = pageWidthScale;
+        case "Fit":
+        case "FitB":
+          scale = "page-fit";
           break;
 
-        case "page-height":
-          scale = pageHeightScale;
+        case "FitH":
+        case "FitBH":
+          y = destArray[2];
+          scale = "page-width";
+
+          if (y === null && this._location) {
+            x = this._location.left;
+            y = this._location.top;
+          }
+
           break;
 
-        case "page-fit":
-          scale = Math.min(pageWidthScale, pageHeightScale);
+        case "FitV":
+        case "FitBV":
+          x = destArray[2];
+          width = pageWidth;
+          height = pageHeight;
+          scale = "page-height";
           break;
 
-        case "auto":
-          const horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
-          scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
+        case "FitR":
+          x = destArray[2];
+          y = destArray[3];
+          width = destArray[4] - x;
+          height = destArray[5] - y;
+          var hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
+          var vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
+          widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS;
+          heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS;
+          scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
           break;
 
         default:
-          console.error(`${this._name}._setScale: "${value}" is an unknown zoom value.`);
+          console.error("".concat(this._name, ".scrollPageIntoView: ") + "\"".concat(destArray[1].name, "\" is not a valid destination type."));
           return;
       }
 
-      this._setScaleUpdatePages(scale, value, noScroll, true);
-    }
-  }
+      if (!ignoreDestinationZoom) {
+        if (scale && scale !== this._currentScale) {
+          this.currentScaleValue = scale;
+        } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
+          this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+        }
+      }
 
-  _resetCurrentPageView() {
-    if (this.isInPresentationMode) {
-      this._setScale(this._currentScaleValue, true);
-    }
+      if (scale === "page-fit" && !destArray[4]) {
+        this._scrollIntoView({
+          pageDiv: pageView.div,
+          pageNumber: pageNumber
+        });
 
-    const pageView = this._pages[this._currentPageNumber - 1];
+        return;
+      }
 
-    this._scrollIntoView({
-      pageDiv: pageView.div
-    });
-  }
+      var boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
+      var left = Math.min(boundingRect[0][0], boundingRect[1][0]);
+      var top = Math.min(boundingRect[0][1], boundingRect[1][1]);
 
-  scrollPageIntoView({
-    pageNumber,
-    destArray = null,
-    allowNegativeOffset = false,
-    ignoreDestinationZoom = false
-  }) {
-    if (!this.pdfDocument) {
-      return;
-    }
-
-    const pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
+      if (!allowNegativeOffset) {
+        left = Math.max(left, 0);
+        top = Math.max(top, 0);
+      }
 
-    if (!pageView) {
-      console.error(`${this._name}.scrollPageIntoView: ` + `"${pageNumber}" is not a valid pageNumber parameter.`);
-      return;
+      this._scrollIntoView({
+        pageDiv: pageView.div,
+        pageSpot: {
+          left: left,
+          top: top
+        },
+        pageNumber: pageNumber
+      });
     }
-
-    if (this.isInPresentationMode || !destArray) {
-      this._setCurrentPageNumber(pageNumber, true);
-
-      return;
+  }, {
+    key: "_updateLocation",
+    value: function _updateLocation(firstPage) {
+      var currentScale = this._currentScale;
+      var currentScaleValue = this._currentScaleValue;
+      var normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
+      var pageNumber = firstPage.id;
+      var pdfOpenParams = "#page=" + pageNumber;
+      pdfOpenParams += "&zoom=" + normalizedScaleValue;
+      var currentPageView = this._pages[pageNumber - 1];
+      var container = this.container;
+      var topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
+      var intLeft = Math.round(topLeft[0]);
+      var intTop = Math.round(topLeft[1]);
+      pdfOpenParams += "," + intLeft + "," + intTop;
+      this._location = {
+        pageNumber: pageNumber,
+        scale: normalizedScaleValue,
+        top: intTop,
+        left: intLeft,
+        rotation: this._pagesRotation,
+        pdfOpenParams: pdfOpenParams
+      };
+    }
+  }, {
+    key: "_updateHelper",
+    value: function _updateHelper(visiblePages) {
+      throw new Error("Not implemented: _updateHelper");
     }
+  }, {
+    key: "update",
+    value: function update() {
+      var visible = this._getVisiblePages();
 
-    let x = 0,
-        y = 0;
-    let width = 0,
-        height = 0,
-        widthScale,
-        heightScale;
-    const changeOrientation = pageView.rotation % 180 !== 0;
-    const pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS;
-    const pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS;
-    let scale = 0;
-
-    switch (destArray[1].name) {
-      case "XYZ":
-        x = destArray[2];
-        y = destArray[3];
-        scale = destArray[4];
-        x = x !== null ? x : 0;
-        y = y !== null ? y : pageHeight;
-        break;
+      var visiblePages = visible.views,
+          numVisiblePages = visiblePages.length;
 
-      case "Fit":
-      case "FitB":
-        scale = "page-fit";
-        break;
+      if (numVisiblePages === 0) {
+        return;
+      }
 
-      case "FitH":
-      case "FitBH":
-        y = destArray[2];
-        scale = "page-width";
+      var newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
 
-        if (y === null && this._location) {
-          x = this._location.left;
-          y = this._location.top;
-        }
+      this._buffer.resize(newCacheSize, visiblePages);
 
-        break;
+      this.renderingQueue.renderHighestPriority(visible);
 
-      case "FitV":
-      case "FitBV":
-        x = destArray[2];
-        width = pageWidth;
-        height = pageHeight;
-        scale = "page-height";
-        break;
+      this._updateHelper(visiblePages);
 
-      case "FitR":
-        x = destArray[2];
-        y = destArray[3];
-        width = destArray[4] - x;
-        height = destArray[5] - y;
-        const hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
-        const vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
-        widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS;
-        heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS;
-        scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
-        break;
+      this._updateLocation(visible.first);
 
-      default:
-        console.error(`${this._name}.scrollPageIntoView: ` + `"${destArray[1].name}" is not a valid destination type.`);
-        return;
+      this.eventBus.dispatch("updateviewarea", {
+        source: this,
+        location: this._location
+      });
     }
-
-    if (!ignoreDestinationZoom) {
-      if (scale && scale !== this._currentScale) {
-        this.currentScaleValue = scale;
-      } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
-        this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+  }, {
+    key: "containsElement",
+    value: function containsElement(element) {
+      return this.container.contains(element);
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      this.container.focus();
+    }
+  }, {
+    key: "_getCurrentVisiblePage",
+    value: function _getCurrentVisiblePage() {
+      if (!this.pagesCount) {
+        return {
+          views: []
+        };
       }
-    }
-
-    if (scale === "page-fit" && !destArray[4]) {
-      this._scrollIntoView({
-        pageDiv: pageView.div,
-        pageNumber
-      });
 
-      return;
+      var pageView = this._pages[this._currentPageNumber - 1];
+      var element = pageView.div;
+      var view = {
+        id: pageView.id,
+        x: element.offsetLeft + element.clientLeft,
+        y: element.offsetTop + element.clientTop,
+        view: pageView
+      };
+      return {
+        first: view,
+        last: view,
+        views: [view]
+      };
     }
-
-    const boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
-    let left = Math.min(boundingRect[0][0], boundingRect[1][0]);
-    let top = Math.min(boundingRect[0][1], boundingRect[1][1]);
-
-    if (!allowNegativeOffset) {
-      left = Math.max(left, 0);
-      top = Math.max(top, 0);
+  }, {
+    key: "_getVisiblePages",
+    value: function _getVisiblePages() {
+      return (0, _ui_utils.getVisibleElements)(this.container, this._pages, true, this._isScrollModeHorizontal);
     }
+  }, {
+    key: "isPageVisible",
+    value: function isPageVisible(pageNumber) {
+      if (!this.pdfDocument) {
+        return false;
+      }
 
-    this._scrollIntoView({
-      pageDiv: pageView.div,
-      pageSpot: {
-        left,
-        top
-      },
-      pageNumber
-    });
-  }
-
-  _updateLocation(firstPage) {
-    const currentScale = this._currentScale;
-    const currentScaleValue = this._currentScaleValue;
-    const normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
-    const pageNumber = firstPage.id;
-    let pdfOpenParams = "#page=" + pageNumber;
-    pdfOpenParams += "&zoom=" + normalizedScaleValue;
-    const currentPageView = this._pages[pageNumber - 1];
-    const container = this.container;
-    const topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
-    const intLeft = Math.round(topLeft[0]);
-    const intTop = Math.round(topLeft[1]);
-    pdfOpenParams += "," + intLeft + "," + intTop;
-    this._location = {
-      pageNumber,
-      scale: normalizedScaleValue,
-      top: intTop,
-      left: intLeft,
-      rotation: this._pagesRotation,
-      pdfOpenParams
-    };
-  }
-
-  _updateHelper(visiblePages) {
-    throw new Error("Not implemented: _updateHelper");
-  }
-
-  update() {
-    const visible = this._getVisiblePages();
-
-    const visiblePages = visible.views,
-          numVisiblePages = visiblePages.length;
+      if (pageNumber < 1 || pageNumber > this.pagesCount) {
+        console.error("".concat(this._name, ".isPageVisible: \"").concat(pageNumber, "\" is out of bounds."));
+        return false;
+      }
 
-    if (numVisiblePages === 0) {
-      return;
+      return this._getVisiblePages().views.some(function (view) {
+        return view.id === pageNumber;
+      });
     }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      for (var i = 0, ii = this._pages.length; i < ii; i++) {
+        if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+          this._pages[i].reset();
+        }
+      }
+    }
+  }, {
+    key: "_cancelRendering",
+    value: function _cancelRendering() {
+      for (var i = 0, ii = this._pages.length; i < ii; i++) {
+        if (this._pages[i]) {
+          this._pages[i].cancelRendering();
+        }
+      }
+    }
+  }, {
+    key: "_ensurePdfPageLoaded",
+    value: function _ensurePdfPageLoaded(pageView) {
+      var _this3 = this;
 
-    const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
-
-    this._buffer.resize(newCacheSize, visiblePages);
+      if (pageView.pdfPage) {
+        return Promise.resolve(pageView.pdfPage);
+      }
 
-    this.renderingQueue.renderHighestPriority(visible);
+      if (this._pagesRequests.has(pageView)) {
+        return this._pagesRequests.get(pageView);
+      }
 
-    this._updateHelper(visiblePages);
+      var promise = this.pdfDocument.getPage(pageView.id).then(function (pdfPage) {
+        if (!pageView.pdfPage) {
+          pageView.setPdfPage(pdfPage);
+        }
 
-    this._updateLocation(visible.first);
+        _this3._pagesRequests["delete"](pageView);
 
-    this.eventBus.dispatch("updateviewarea", {
-      source: this,
-      location: this._location
-    });
-  }
+        return pdfPage;
+      })["catch"](function (reason) {
+        console.error("Unable to get page for page view", reason);
 
-  containsElement(element) {
-    return this.container.contains(element);
-  }
+        _this3._pagesRequests["delete"](pageView);
+      });
 
-  focus() {
-    this.container.focus();
-  }
+      this._pagesRequests.set(pageView, promise);
 
-  get _isScrollModeHorizontal() {
-    return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL;
-  }
+      return promise;
+    }
+  }, {
+    key: "forceRendering",
+    value: function forceRendering(currentlyVisiblePages) {
+      var _this4 = this;
 
-  get isInPresentationMode() {
-    return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
-  }
+      var visiblePages = currentlyVisiblePages || this._getVisiblePages();
 
-  get isChangingPresentationMode() {
-    return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
-  }
+      var scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down;
+      var pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead);
 
-  get isHorizontalScrollbarEnabled() {
-    return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
-  }
+      if (pageView) {
+        this._ensurePdfPageLoaded(pageView).then(function () {
+          _this4.renderingQueue.renderView(pageView);
+        });
 
-  get isVerticalScrollbarEnabled() {
-    return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
-  }
+        return true;
+      }
 
-  _getCurrentVisiblePage() {
-    if (!this.pagesCount) {
-      return {
-        views: []
-      };
+      return false;
     }
+  }, {
+    key: "createTextLayerBuilder",
+    value: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) {
+      var enhanceTextSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var eventBus = arguments.length > 4 ? arguments[4] : undefined;
+      return new _text_layer_builder.TextLayerBuilder({
+        textLayerDiv: textLayerDiv,
+        eventBus: eventBus,
+        pageIndex: pageIndex,
+        viewport: viewport,
+        findController: this.isInPresentationMode ? null : this.findController,
+        enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
+      });
+    }
+  }, {
+    key: "createAnnotationLayerBuilder",
+    value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
+      var imageResourcesPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+      var renderInteractiveForms = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var l10n = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _ui_utils.NullL10n;
+      return new _annotation_layer_builder.AnnotationLayerBuilder({
+        pageDiv: pageDiv,
+        pdfPage: pdfPage,
+        imageResourcesPath: imageResourcesPath,
+        renderInteractiveForms: renderInteractiveForms,
+        linkService: this.linkService,
+        downloadManager: this.downloadManager,
+        l10n: l10n
+      });
+    }
+  }, {
+    key: "getPagesOverview",
+    value: function getPagesOverview() {
+      var pagesOverview = this._pages.map(function (pageView) {
+        var viewport = pageView.pdfPage.getViewport({
+          scale: 1
+        });
+        return {
+          width: viewport.width,
+          height: viewport.height,
+          rotation: viewport.rotation
+        };
+      });
 
-    const pageView = this._pages[this._currentPageNumber - 1];
-    const element = pageView.div;
-    const view = {
-      id: pageView.id,
-      x: element.offsetLeft + element.clientLeft,
-      y: element.offsetTop + element.clientTop,
-      view: pageView
-    };
-    return {
-      first: view,
-      last: view,
-      views: [view]
-    };
-  }
-
-  _getVisiblePages() {
-    return (0, _ui_utils.getVisibleElements)(this.container, this._pages, true, this._isScrollModeHorizontal);
-  }
+      if (!this.enablePrintAutoRotate) {
+        return pagesOverview;
+      }
 
-  isPageVisible(pageNumber) {
-    if (!this.pdfDocument) {
-      return false;
-    }
+      var isFirstPagePortrait = (0, _ui_utils.isPortraitOrientation)(pagesOverview[0]);
+      return pagesOverview.map(function (size) {
+        if (isFirstPagePortrait === (0, _ui_utils.isPortraitOrientation)(size)) {
+          return size;
+        }
 
-    if (pageNumber < 1 || pageNumber > this.pagesCount) {
-      console.error(`${this._name}.isPageVisible: "${pageNumber}" is out of bounds.`);
-      return false;
+        return {
+          width: size.height,
+          height: size.width,
+          rotation: (size.rotation + 90) % 360
+        };
+      });
     }
+  }, {
+    key: "_updateScrollMode",
+    value: function _updateScrollMode() {
+      var pageNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var scrollMode = this._scrollMode,
+          viewer = this.viewer;
+      viewer.classList.toggle("scrollHorizontal", scrollMode === _ui_utils.ScrollMode.HORIZONTAL);
+      viewer.classList.toggle("scrollWrapped", scrollMode === _ui_utils.ScrollMode.WRAPPED);
 
-    return this._getVisiblePages().views.some(function (view) {
-      return view.id === pageNumber;
-    });
-  }
-
-  cleanup() {
-    for (let i = 0, ii = this._pages.length; i < ii; i++) {
-      if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
-        this._pages[i].reset();
+      if (!this.pdfDocument || !pageNumber) {
+        return;
       }
-    }
-  }
 
-  _cancelRendering() {
-    for (let i = 0, ii = this._pages.length; i < ii; i++) {
-      if (this._pages[i]) {
-        this._pages[i].cancelRendering();
+      if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+        this._setScale(this._currentScaleValue, true);
       }
-    }
-  }
 
-  _ensurePdfPageLoaded(pageView) {
-    if (pageView.pdfPage) {
-      return Promise.resolve(pageView.pdfPage);
-    }
+      this._setCurrentPageNumber(pageNumber, true);
 
-    if (this._pagesRequests.has(pageView)) {
-      return this._pagesRequests.get(pageView);
+      this.update();
     }
+  }, {
+    key: "_updateSpreadMode",
+    value: function _updateSpreadMode() {
+      var pageNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
 
-    const promise = this.pdfDocument.getPage(pageView.id).then(pdfPage => {
-      if (!pageView.pdfPage) {
-        pageView.setPdfPage(pdfPage);
+      if (!this.pdfDocument) {
+        return;
       }
 
-      this._pagesRequests.delete(pageView);
-
-      return pdfPage;
-    }).catch(reason => {
-      console.error("Unable to get page for page view", reason);
+      var viewer = this.viewer,
+          pages = this._pages;
+      viewer.textContent = "";
 
-      this._pagesRequests.delete(pageView);
-    });
+      if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
+        for (var i = 0, iMax = pages.length; i < iMax; ++i) {
+          viewer.appendChild(pages[i].div);
+        }
+      } else {
+        var parity = this._spreadMode - 1;
+        var spread = null;
+
+        for (var _i = 0, _iMax = pages.length; _i < _iMax; ++_i) {
+          if (spread === null) {
+            spread = document.createElement("div");
+            spread.className = "spread";
+            viewer.appendChild(spread);
+          } else if (_i % 2 === parity) {
+            spread = spread.cloneNode(false);
+            viewer.appendChild(spread);
+          }
 
-    this._pagesRequests.set(pageView, promise);
+          spread.appendChild(pages[_i].div);
+        }
+      }
 
-    return promise;
-  }
+      if (!pageNumber) {
+        return;
+      }
 
-  forceRendering(currentlyVisiblePages) {
-    const visiblePages = currentlyVisiblePages || this._getVisiblePages();
+      this._setCurrentPageNumber(pageNumber, true);
 
-    const scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down;
-    const pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead);
+      this.update();
+    }
+  }, {
+    key: "pagesCount",
+    get: function get() {
+      return this._pages.length;
+    }
+  }, {
+    key: "pageViewsReady",
+    get: function get() {
+      if (!this._pagesCapability.settled) {
+        return false;
+      }
 
-    if (pageView) {
-      this._ensurePdfPageLoaded(pageView).then(() => {
-        this.renderingQueue.renderView(pageView);
+      return this._pages.every(function (pageView) {
+        return pageView && pageView.pdfPage;
       });
-
-      return true;
     }
+  }, {
+    key: "currentPageNumber",
+    get: function get() {
+      return this._currentPageNumber;
+    },
+    set: function set(val) {
+      if (!Number.isInteger(val)) {
+        throw new Error("Invalid page number.");
+      }
 
-    return false;
-  }
-
-  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
-    return new _text_layer_builder.TextLayerBuilder({
-      textLayerDiv,
-      eventBus,
-      pageIndex,
-      viewport,
-      findController: this.isInPresentationMode ? null : this.findController,
-      enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
-    });
-  }
-
-  createAnnotationLayerBuilder(pageDiv, pdfPage, imageResourcesPath = "", renderInteractiveForms = false, l10n = _ui_utils.NullL10n) {
-    return new _annotation_layer_builder.AnnotationLayerBuilder({
-      pageDiv,
-      pdfPage,
-      imageResourcesPath,
-      renderInteractiveForms,
-      linkService: this.linkService,
-      downloadManager: this.downloadManager,
-      l10n
-    });
-  }
-
-  get hasEqualPageSizes() {
-    const firstPageView = this._pages[0];
-
-    for (let i = 1, ii = this._pages.length; i < ii; ++i) {
-      const pageView = this._pages[i];
+      if (!this.pdfDocument) {
+        return;
+      }
 
-      if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
-        return false;
+      if (!this._setCurrentPageNumber(val, true)) {
+        console.error("".concat(this._name, ".currentPageNumber: \"").concat(val, "\" is not a valid page."));
       }
     }
+  }, {
+    key: "currentPageLabel",
+    get: function get() {
+      return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
+    },
+    set: function set(val) {
+      if (!this.pdfDocument) {
+        return;
+      }
 
-    return true;
-  }
-
-  getPagesOverview() {
-    const pagesOverview = this._pages.map(function (pageView) {
-      const viewport = pageView.pdfPage.getViewport({
-        scale: 1
-      });
-      return {
-        width: viewport.width,
-        height: viewport.height,
-        rotation: viewport.rotation
-      };
-    });
+      var page = val | 0;
 
-    if (!this.enablePrintAutoRotate) {
-      return pagesOverview;
-    }
+      if (this._pageLabels) {
+        var i = this._pageLabels.indexOf(val);
 
-    const isFirstPagePortrait = (0, _ui_utils.isPortraitOrientation)(pagesOverview[0]);
-    return pagesOverview.map(function (size) {
-      if (isFirstPagePortrait === (0, _ui_utils.isPortraitOrientation)(size)) {
-        return size;
+        if (i >= 0) {
+          page = i + 1;
+        }
       }
 
-      return {
-        width: size.height,
-        height: size.width,
-        rotation: (size.rotation + 90) % 360
-      };
-    });
-  }
+      if (!this._setCurrentPageNumber(page, true)) {
+        console.error("".concat(this._name, ".currentPageLabel: \"").concat(val, "\" is not a valid page."));
+      }
+    }
+  }, {
+    key: "currentScale",
+    get: function get() {
+      return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
+    },
+    set: function set(val) {
+      if (isNaN(val)) {
+        throw new Error("Invalid numeric scale.");
+      }
 
-  get scrollMode() {
-    return this._scrollMode;
-  }
+      if (!this.pdfDocument) {
+        return;
+      }
 
-  set scrollMode(mode) {
-    if (this._scrollMode === mode) {
-      return;
+      this._setScale(val, false);
     }
+  }, {
+    key: "currentScaleValue",
+    get: function get() {
+      return this._currentScaleValue;
+    },
+    set: function set(val) {
+      if (!this.pdfDocument) {
+        return;
+      }
 
-    if (!(0, _ui_utils.isValidScrollMode)(mode)) {
-      throw new Error(`Invalid scroll mode: ${mode}`);
+      this._setScale(val, false);
     }
+  }, {
+    key: "pagesRotation",
+    get: function get() {
+      return this._pagesRotation;
+    },
+    set: function set(rotation) {
+      if (!(0, _ui_utils.isValidRotation)(rotation)) {
+        throw new Error("Invalid pages rotation angle.");
+      }
 
-    this._scrollMode = mode;
-    this.eventBus.dispatch("scrollmodechanged", {
-      source: this,
-      mode
-    });
-
-    this._updateScrollMode(this._currentPageNumber);
-  }
-
-  _updateScrollMode(pageNumber = null) {
-    const scrollMode = this._scrollMode,
-          viewer = this.viewer;
-    viewer.classList.toggle("scrollHorizontal", scrollMode === _ui_utils.ScrollMode.HORIZONTAL);
-    viewer.classList.toggle("scrollWrapped", scrollMode === _ui_utils.ScrollMode.WRAPPED);
+      if (!this.pdfDocument) {
+        return;
+      }
 
-    if (!this.pdfDocument || !pageNumber) {
-      return;
-    }
+      if (this._pagesRotation === rotation) {
+        return;
+      }
 
-    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
-      this._setScale(this._currentScaleValue, true);
-    }
+      this._pagesRotation = rotation;
+      var pageNumber = this._currentPageNumber;
 
-    this._setCurrentPageNumber(pageNumber, true);
+      for (var i = 0, ii = this._pages.length; i < ii; i++) {
+        var pageView = this._pages[i];
+        pageView.update(pageView.scale, rotation);
+      }
 
-    this.update();
-  }
+      if (this._currentScaleValue) {
+        this._setScale(this._currentScaleValue, true);
+      }
 
-  get spreadMode() {
-    return this._spreadMode;
-  }
+      this.eventBus.dispatch("rotationchanging", {
+        source: this,
+        pagesRotation: rotation,
+        pageNumber: pageNumber
+      });
 
-  set spreadMode(mode) {
-    if (this._spreadMode === mode) {
-      return;
+      if (this.defaultRenderingQueue) {
+        this.update();
+      }
     }
+  }, {
+    key: "firstPagePromise",
+    get: function get() {
+      return this.pdfDocument ? this._firstPageCapability.promise : null;
+    }
+  }, {
+    key: "onePageRendered",
+    get: function get() {
+      return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
+    }
+  }, {
+    key: "pagesPromise",
+    get: function get() {
+      return this.pdfDocument ? this._pagesCapability.promise : null;
+    }
+  }, {
+    key: "_viewerElement",
+    get: function get() {
+      throw new Error("Not implemented: _viewerElement");
+    }
+  }, {
+    key: "_isScrollModeHorizontal",
+    get: function get() {
+      return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL;
+    }
+  }, {
+    key: "isInPresentationMode",
+    get: function get() {
+      return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
+    }
+  }, {
+    key: "isChangingPresentationMode",
+    get: function get() {
+      return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
+    }
+  }, {
+    key: "isHorizontalScrollbarEnabled",
+    get: function get() {
+      return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
+    }
+  }, {
+    key: "isVerticalScrollbarEnabled",
+    get: function get() {
+      return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
+    }
+  }, {
+    key: "hasEqualPageSizes",
+    get: function get() {
+      var firstPageView = this._pages[0];
+
+      for (var i = 1, ii = this._pages.length; i < ii; ++i) {
+        var pageView = this._pages[i];
+
+        if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
+          return false;
+        }
+      }
 
-    if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
-      throw new Error(`Invalid spread mode: ${mode}`);
+      return true;
     }
+  }, {
+    key: "scrollMode",
+    get: function get() {
+      return this._scrollMode;
+    },
+    set: function set(mode) {
+      if (this._scrollMode === mode) {
+        return;
+      }
 
-    this._spreadMode = mode;
-    this.eventBus.dispatch("spreadmodechanged", {
-      source: this,
-      mode
-    });
+      if (!(0, _ui_utils.isValidScrollMode)(mode)) {
+        throw new Error("Invalid scroll mode: ".concat(mode));
+      }
 
-    this._updateSpreadMode(this._currentPageNumber);
-  }
+      this._scrollMode = mode;
+      this.eventBus.dispatch("scrollmodechanged", {
+        source: this,
+        mode: mode
+      });
 
-  _updateSpreadMode(pageNumber = null) {
-    if (!this.pdfDocument) {
-      return;
+      this._updateScrollMode(this._currentPageNumber);
     }
-
-    const viewer = this.viewer,
-          pages = this._pages;
-    viewer.textContent = "";
-
-    if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
-      for (let i = 0, iMax = pages.length; i < iMax; ++i) {
-        viewer.appendChild(pages[i].div);
+  }, {
+    key: "spreadMode",
+    get: function get() {
+      return this._spreadMode;
+    },
+    set: function set(mode) {
+      if (this._spreadMode === mode) {
+        return;
       }
-    } else {
-      const parity = this._spreadMode - 1;
-      let spread = null;
-
-      for (let i = 0, iMax = pages.length; i < iMax; ++i) {
-        if (spread === null) {
-          spread = document.createElement("div");
-          spread.className = "spread";
-          viewer.appendChild(spread);
-        } else if (i % 2 === parity) {
-          spread = spread.cloneNode(false);
-          viewer.appendChild(spread);
-        }
 
-        spread.appendChild(pages[i].div);
+      if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
+        throw new Error("Invalid spread mode: ".concat(mode));
       }
-    }
 
-    if (!pageNumber) {
-      return;
-    }
-
-    this._setCurrentPageNumber(pageNumber, true);
+      this._spreadMode = mode;
+      this.eventBus.dispatch("spreadmodechanged", {
+        source: this,
+        mode: mode
+      });
 
-    this.update();
-  }
+      this._updateSpreadMode(this._currentPageNumber);
+    }
+  }]);
 
-}
+  return BaseViewer;
+}();
 
 exports.BaseViewer = BaseViewer;
 
 /***/ }),
-/* 26 */
+/* 29 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -9924,22 +12025,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DefaultAnnotationLayerFactory = exports.AnnotationLayerBuilder = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
+
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_link_service = __webpack_require__(21);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-var _ui_utils = __webpack_require__(2);
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-var _pdf_link_service = __webpack_require__(18);
+var AnnotationLayerBuilder = /*#__PURE__*/function () {
+  function AnnotationLayerBuilder(_ref) {
+    var pageDiv = _ref.pageDiv,
+        pdfPage = _ref.pdfPage,
+        linkService = _ref.linkService,
+        downloadManager = _ref.downloadManager,
+        _ref$imageResourcesPa = _ref.imageResourcesPath,
+        imageResourcesPath = _ref$imageResourcesPa === void 0 ? "" : _ref$imageResourcesPa,
+        _ref$renderInteractiv = _ref.renderInteractiveForms,
+        renderInteractiveForms = _ref$renderInteractiv === void 0 ? false : _ref$renderInteractiv,
+        _ref$l10n = _ref.l10n,
+        l10n = _ref$l10n === void 0 ? _ui_utils.NullL10n : _ref$l10n;
+
+    _classCallCheck(this, AnnotationLayerBuilder);
 
-class AnnotationLayerBuilder {
-  constructor({
-    pageDiv,
-    pdfPage,
-    linkService,
-    downloadManager,
-    imageResourcesPath = "",
-    renderInteractiveForms = false,
-    l10n = _ui_utils.NullL10n
-  }) {
     this.pageDiv = pageDiv;
     this.pdfPage = pdfPage;
     this.linkService = linkService;
@@ -9951,80 +12063,102 @@ class AnnotationLayerBuilder {
     this._cancelled = false;
   }
 
-  render(viewport, intent = "display") {
-    this.pdfPage.getAnnotations({
-      intent
-    }).then(annotations => {
-      if (this._cancelled) {
-        return;
-      }
-
-      const parameters = {
-        viewport: viewport.clone({
-          dontFlip: true
-        }),
-        div: this.div,
-        annotations,
-        page: this.pdfPage,
-        imageResourcesPath: this.imageResourcesPath,
-        renderInteractiveForms: this.renderInteractiveForms,
-        linkService: this.linkService,
-        downloadManager: this.downloadManager
-      };
+  _createClass(AnnotationLayerBuilder, [{
+    key: "render",
+    value: function render(viewport) {
+      var _this = this;
 
-      if (this.div) {
-        _pdfjsLib.AnnotationLayer.update(parameters);
-      } else {
-        if (annotations.length === 0) {
+      var intent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "display";
+      this.pdfPage.getAnnotations({
+        intent: intent
+      }).then(function (annotations) {
+        if (_this._cancelled) {
           return;
         }
 
-        this.div = document.createElement("div");
-        this.div.className = "annotationLayer";
-        this.pageDiv.appendChild(this.div);
-        parameters.div = this.div;
+        var parameters = {
+          viewport: viewport.clone({
+            dontFlip: true
+          }),
+          div: _this.div,
+          annotations: annotations,
+          page: _this.pdfPage,
+          imageResourcesPath: _this.imageResourcesPath,
+          renderInteractiveForms: _this.renderInteractiveForms,
+          linkService: _this.linkService,
+          downloadManager: _this.downloadManager
+        };
 
-        _pdfjsLib.AnnotationLayer.render(parameters);
+        if (_this.div) {
+          _pdfjsLib.AnnotationLayer.update(parameters);
+        } else {
+          if (annotations.length === 0) {
+            return;
+          }
 
-        this.l10n.translate(this.div);
-      }
-    });
-  }
+          _this.div = document.createElement("div");
+          _this.div.className = "annotationLayer";
 
-  cancel() {
-    this._cancelled = true;
-  }
+          _this.pageDiv.appendChild(_this.div);
 
-  hide() {
-    if (!this.div) {
-      return;
+          parameters.div = _this.div;
+
+          _pdfjsLib.AnnotationLayer.render(parameters);
+
+          _this.l10n.translate(_this.div);
+        }
+      });
     }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this._cancelled = true;
+    }
+  }, {
+    key: "hide",
+    value: function hide() {
+      if (!this.div) {
+        return;
+      }
 
-    this.div.setAttribute("hidden", "true");
-  }
+      this.div.setAttribute("hidden", "true");
+    }
+  }]);
 
-}
+  return AnnotationLayerBuilder;
+}();
 
 exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
 
-class DefaultAnnotationLayerFactory {
-  createAnnotationLayerBuilder(pageDiv, pdfPage, imageResourcesPath = "", renderInteractiveForms = false, l10n = _ui_utils.NullL10n) {
-    return new AnnotationLayerBuilder({
-      pageDiv,
-      pdfPage,
-      imageResourcesPath,
-      renderInteractiveForms,
-      linkService: new _pdf_link_service.SimpleLinkService(),
-      l10n
-    });
-  }
+var DefaultAnnotationLayerFactory = /*#__PURE__*/function () {
+  function DefaultAnnotationLayerFactory() {
+    _classCallCheck(this, DefaultAnnotationLayerFactory);
+  }
+
+  _createClass(DefaultAnnotationLayerFactory, [{
+    key: "createAnnotationLayerBuilder",
+    value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
+      var imageResourcesPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";
+      var renderInteractiveForms = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var l10n = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _ui_utils.NullL10n;
+      return new AnnotationLayerBuilder({
+        pageDiv: pageDiv,
+        pdfPage: pdfPage,
+        imageResourcesPath: imageResourcesPath,
+        renderInteractiveForms: renderInteractiveForms,
+        linkService: new _pdf_link_service.SimpleLinkService(),
+        l10n: l10n
+      });
+    }
+  }]);
 
-}
+  return DefaultAnnotationLayerFactory;
+}();
 
 exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
 
 /***/ }),
-/* 27 */
+/* 30 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -10035,20 +12169,36 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFPageView = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+var _ui_utils = __webpack_require__(5);
+
+var _pdfjsLib = __webpack_require__(8);
+
+var _pdf_rendering_queue = __webpack_require__(11);
+
+var _viewer_compatibility = __webpack_require__(7);
 
-var _pdfjsLib = __webpack_require__(5);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-var _pdf_rendering_queue = __webpack_require__(8);
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-var _viewer_compatibility = __webpack_require__(4);
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-const MAX_CANVAS_PIXELS = _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels || 16777216;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-class PDFPageView {
-  constructor(options) {
-    const container = options.container;
-    const defaultViewport = options.defaultViewport;
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var MAX_CANVAS_PIXELS = _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels || 16777216;
+
+var PDFPageView = /*#__PURE__*/function () {
+  function PDFPageView(options) {
+    _classCallCheck(this, PDFPageView);
+
+    var container = options.container;
+    var defaultViewport = options.defaultViewport;
     this.id = options.id;
     this.renderingId = "page" + this.id;
     this.pdfPage = null;
@@ -10078,7 +12228,7 @@ class PDFPageView {
     this.annotationLayer = null;
     this.textLayer = null;
     this.zoomLayer = null;
-    const div = document.createElement("div");
+    var div = document.createElement("div");
     div.className = "page";
     div.style.width = Math.floor(this.viewport.width) + "px";
     div.style.height = Math.floor(this.viewport.height) + "px";
@@ -10087,130 +12237,118 @@ class PDFPageView {
     container.appendChild(div);
   }
 
-  setPdfPage(pdfPage) {
-    this.pdfPage = pdfPage;
-    this.pdfPageRotate = pdfPage.rotate;
-    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
-    this.viewport = pdfPage.getViewport({
-      scale: this.scale * _ui_utils.CSS_UNITS,
-      rotation: totalRotation
-    });
-    this.stats = pdfPage.stats;
-    this.reset();
-  }
-
-  destroy() {
-    this.reset();
-
-    if (this.pdfPage) {
-      this.pdfPage.cleanup();
-    }
-  }
-
-  _resetZoomLayer(removeFromDOM = false) {
-    if (!this.zoomLayer) {
-      return;
+  _createClass(PDFPageView, [{
+    key: "setPdfPage",
+    value: function setPdfPage(pdfPage) {
+      this.pdfPage = pdfPage;
+      this.pdfPageRotate = pdfPage.rotate;
+      var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+      this.viewport = pdfPage.getViewport({
+        scale: this.scale * _ui_utils.CSS_UNITS,
+        rotation: totalRotation
+      });
+      this.stats = pdfPage.stats;
+      this.reset();
     }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.reset();
 
-    const zoomLayerCanvas = this.zoomLayer.firstChild;
-    this.paintedViewportMap.delete(zoomLayerCanvas);
-    zoomLayerCanvas.width = 0;
-    zoomLayerCanvas.height = 0;
-
-    if (removeFromDOM) {
-      this.zoomLayer.remove();
+      if (this.pdfPage) {
+        this.pdfPage.cleanup();
+      }
     }
+  }, {
+    key: "_resetZoomLayer",
+    value: function _resetZoomLayer() {
+      var removeFromDOM = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-    this.zoomLayer = null;
-  }
-
-  reset(keepZoomLayer = false, keepAnnotations = false) {
-    this.cancelRendering(keepAnnotations);
-    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
-    const div = this.div;
-    div.style.width = Math.floor(this.viewport.width) + "px";
-    div.style.height = Math.floor(this.viewport.height) + "px";
-    const childNodes = div.childNodes;
-    const currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null;
-    const currentAnnotationNode = keepAnnotations && this.annotationLayer && this.annotationLayer.div || null;
+      if (!this.zoomLayer) {
+        return;
+      }
 
-    for (let i = childNodes.length - 1; i >= 0; i--) {
-      const node = childNodes[i];
+      var zoomLayerCanvas = this.zoomLayer.firstChild;
+      this.paintedViewportMap["delete"](zoomLayerCanvas);
+      zoomLayerCanvas.width = 0;
+      zoomLayerCanvas.height = 0;
 
-      if (currentZoomLayerNode === node || currentAnnotationNode === node) {
-        continue;
+      if (removeFromDOM) {
+        this.zoomLayer.remove();
       }
 
-      div.removeChild(node);
+      this.zoomLayer = null;
     }
+  }, {
+    key: "reset",
+    value: function reset() {
+      var keepZoomLayer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var keepAnnotations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this.cancelRendering(keepAnnotations);
+      this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+      var div = this.div;
+      div.style.width = Math.floor(this.viewport.width) + "px";
+      div.style.height = Math.floor(this.viewport.height) + "px";
+      var childNodes = div.childNodes;
+      var currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null;
+      var currentAnnotationNode = keepAnnotations && this.annotationLayer && this.annotationLayer.div || null;
 
-    div.removeAttribute("data-loaded");
+      for (var i = childNodes.length - 1; i >= 0; i--) {
+        var node = childNodes[i];
 
-    if (currentAnnotationNode) {
-      this.annotationLayer.hide();
-    } else if (this.annotationLayer) {
-      this.annotationLayer.cancel();
-      this.annotationLayer = null;
-    }
+        if (currentZoomLayerNode === node || currentAnnotationNode === node) {
+          continue;
+        }
 
-    if (!currentZoomLayerNode) {
-      if (this.canvas) {
-        this.paintedViewportMap.delete(this.canvas);
-        this.canvas.width = 0;
-        this.canvas.height = 0;
-        delete this.canvas;
+        div.removeChild(node);
       }
 
-      this._resetZoomLayer();
-    }
-
-    if (this.svg) {
-      this.paintedViewportMap.delete(this.svg);
-      delete this.svg;
-    }
+      div.removeAttribute("data-loaded");
 
-    this.loadingIconDiv = document.createElement("div");
-    this.loadingIconDiv.className = "loadingIcon";
-    div.appendChild(this.loadingIconDiv);
-  }
+      if (currentAnnotationNode) {
+        this.annotationLayer.hide();
+      } else if (this.annotationLayer) {
+        this.annotationLayer.cancel();
+        this.annotationLayer = null;
+      }
 
-  update(scale, rotation) {
-    this.scale = scale || this.scale;
+      if (!currentZoomLayerNode) {
+        if (this.canvas) {
+          this.paintedViewportMap["delete"](this.canvas);
+          this.canvas.width = 0;
+          this.canvas.height = 0;
+          delete this.canvas;
+        }
 
-    if (typeof rotation !== "undefined") {
-      this.rotation = rotation;
-    }
+        this._resetZoomLayer();
+      }
 
-    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
-    this.viewport = this.viewport.clone({
-      scale: this.scale * _ui_utils.CSS_UNITS,
-      rotation: totalRotation
-    });
+      if (this.svg) {
+        this.paintedViewportMap["delete"](this.svg);
+        delete this.svg;
+      }
 
-    if (this.svg) {
-      this.cssTransform(this.svg, true);
-      this.eventBus.dispatch("pagerendered", {
-        source: this,
-        pageNumber: this.id,
-        cssTransform: true,
-        timestamp: performance.now()
-      });
-      return;
+      this.loadingIconDiv = document.createElement("div");
+      this.loadingIconDiv.className = "loadingIcon";
+      div.appendChild(this.loadingIconDiv);
     }
+  }, {
+    key: "update",
+    value: function update(scale, rotation) {
+      this.scale = scale || this.scale;
 
-    let isScalingRestricted = false;
-
-    if (this.canvas && this.maxCanvasPixels > 0) {
-      const outputScale = this.outputScale;
-
-      if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
-        isScalingRestricted = true;
+      if (typeof rotation !== "undefined") {
+        this.rotation = rotation;
       }
-    }
 
-    if (this.canvas) {
-      if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
-        this.cssTransform(this.canvas, true);
+      var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+      this.viewport = this.viewport.clone({
+        scale: this.scale * _ui_utils.CSS_UNITS,
+        rotation: totalRotation
+      });
+
+      if (this.svg) {
+        this.cssTransform(this.svg, true);
         this.eventBus.dispatch("pagerendered", {
           source: this,
           pageNumber: this.id,
@@ -10220,409 +12358,468 @@ class PDFPageView {
         return;
       }
 
-      if (!this.zoomLayer && !this.canvas.hasAttribute("hidden")) {
-        this.zoomLayer = this.canvas.parentNode;
-        this.zoomLayer.style.position = "absolute";
-      }
-    }
+      var isScalingRestricted = false;
 
-    if (this.zoomLayer) {
-      this.cssTransform(this.zoomLayer.firstChild);
-    }
+      if (this.canvas && this.maxCanvasPixels > 0) {
+        var outputScale = this.outputScale;
 
-    this.reset(true, true);
-  }
+        if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
+          isScalingRestricted = true;
+        }
+      }
 
-  cancelRendering(keepAnnotations = false) {
-    if (this.paintTask) {
-      this.paintTask.cancel();
-      this.paintTask = null;
-    }
+      if (this.canvas) {
+        if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
+          this.cssTransform(this.canvas, true);
+          this.eventBus.dispatch("pagerendered", {
+            source: this,
+            pageNumber: this.id,
+            cssTransform: true,
+            timestamp: performance.now()
+          });
+          return;
+        }
 
-    this.resume = null;
+        if (!this.zoomLayer && !this.canvas.hasAttribute("hidden")) {
+          this.zoomLayer = this.canvas.parentNode;
+          this.zoomLayer.style.position = "absolute";
+        }
+      }
 
-    if (this.textLayer) {
-      this.textLayer.cancel();
-      this.textLayer = null;
-    }
+      if (this.zoomLayer) {
+        this.cssTransform(this.zoomLayer.firstChild);
+      }
 
-    if (!keepAnnotations && this.annotationLayer) {
-      this.annotationLayer.cancel();
-      this.annotationLayer = null;
+      this.reset(true, true);
     }
-  }
+  }, {
+    key: "cancelRendering",
+    value: function cancelRendering() {
+      var keepAnnotations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-  cssTransform(target, redrawAnnotations = false) {
-    const width = this.viewport.width;
-    const height = this.viewport.height;
-    const div = this.div;
-    target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + "px";
-    target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + "px";
-    const relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation;
-    const absRotation = Math.abs(relativeRotation);
-    let scaleX = 1,
-        scaleY = 1;
+      if (this.paintTask) {
+        this.paintTask.cancel();
+        this.paintTask = null;
+      }
 
-    if (absRotation === 90 || absRotation === 270) {
-      scaleX = height / width;
-      scaleY = width / height;
-    }
+      this.resume = null;
 
-    const cssTransform = "rotate(" + relativeRotation + "deg) " + "scale(" + scaleX + "," + scaleY + ")";
-    target.style.transform = cssTransform;
+      if (this.textLayer) {
+        this.textLayer.cancel();
+        this.textLayer = null;
+      }
 
-    if (this.textLayer) {
-      const textLayerViewport = this.textLayer.viewport;
-      const textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
-      const textAbsRotation = Math.abs(textRelativeRotation);
-      let scale = width / textLayerViewport.width;
+      if (!keepAnnotations && this.annotationLayer) {
+        this.annotationLayer.cancel();
+        this.annotationLayer = null;
+      }
+    }
+  }, {
+    key: "cssTransform",
+    value: function cssTransform(target) {
+      var redrawAnnotations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var width = this.viewport.width;
+      var height = this.viewport.height;
+      var div = this.div;
+      target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + "px";
+      target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + "px";
+      var relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation;
+      var absRotation = Math.abs(relativeRotation);
+      var scaleX = 1,
+          scaleY = 1;
 
-      if (textAbsRotation === 90 || textAbsRotation === 270) {
-        scale = width / textLayerViewport.height;
+      if (absRotation === 90 || absRotation === 270) {
+        scaleX = height / width;
+        scaleY = width / height;
       }
 
-      const textLayerDiv = this.textLayer.textLayerDiv;
-      let transX, transY;
+      var cssTransform = "rotate(" + relativeRotation + "deg) " + "scale(" + scaleX + "," + scaleY + ")";
+      target.style.transform = cssTransform;
 
-      switch (textAbsRotation) {
-        case 0:
-          transX = transY = 0;
-          break;
-
-        case 90:
-          transX = 0;
-          transY = "-" + textLayerDiv.style.height;
-          break;
+      if (this.textLayer) {
+        var textLayerViewport = this.textLayer.viewport;
+        var textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
+        var textAbsRotation = Math.abs(textRelativeRotation);
+        var scale = width / textLayerViewport.width;
 
-        case 180:
-          transX = "-" + textLayerDiv.style.width;
-          transY = "-" + textLayerDiv.style.height;
-          break;
+        if (textAbsRotation === 90 || textAbsRotation === 270) {
+          scale = width / textLayerViewport.height;
+        }
 
-        case 270:
-          transX = "-" + textLayerDiv.style.width;
-          transY = 0;
-          break;
+        var textLayerDiv = this.textLayer.textLayerDiv;
+        var transX, transY;
 
-        default:
-          console.error("Bad rotation value.");
-          break;
-      }
+        switch (textAbsRotation) {
+          case 0:
+            transX = transY = 0;
+            break;
 
-      textLayerDiv.style.transform = "rotate(" + textAbsRotation + "deg) " + "scale(" + scale + ", " + scale + ") " + "translate(" + transX + ", " + transY + ")";
-      textLayerDiv.style.transformOrigin = "0% 0%";
-    }
+          case 90:
+            transX = 0;
+            transY = "-" + textLayerDiv.style.height;
+            break;
 
-    if (redrawAnnotations && this.annotationLayer) {
-      this.annotationLayer.render(this.viewport, "display");
-    }
-  }
+          case 180:
+            transX = "-" + textLayerDiv.style.width;
+            transY = "-" + textLayerDiv.style.height;
+            break;
 
-  get width() {
-    return this.viewport.width;
-  }
+          case 270:
+            transX = "-" + textLayerDiv.style.width;
+            transY = 0;
+            break;
 
-  get height() {
-    return this.viewport.height;
-  }
+          default:
+            console.error("Bad rotation value.");
+            break;
+        }
 
-  getPagePoint(x, y) {
-    return this.viewport.convertToPdfPoint(x, y);
-  }
+        textLayerDiv.style.transform = "rotate(" + textAbsRotation + "deg) " + "scale(" + scale + ", " + scale + ") " + "translate(" + transX + ", " + transY + ")";
+        textLayerDiv.style.transformOrigin = "0% 0%";
+      }
 
-  draw() {
-    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
-      console.error("Must be in new state before drawing");
-      this.reset();
+      if (redrawAnnotations && this.annotationLayer) {
+        this.annotationLayer.render(this.viewport, "display");
+      }
     }
+  }, {
+    key: "getPagePoint",
+    value: function getPagePoint(x, y) {
+      return this.viewport.convertToPdfPoint(x, y);
+    }
+  }, {
+    key: "draw",
+    value: function draw() {
+      var _this = this;
 
-    const {
-      div,
-      pdfPage
-    } = this;
-
-    if (!pdfPage) {
-      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
-
-      if (this.loadingIconDiv) {
-        div.removeChild(this.loadingIconDiv);
-        delete this.loadingIconDiv;
+      if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
+        console.error("Must be in new state before drawing");
+        this.reset();
       }
 
-      return Promise.reject(new Error("pdfPage is not loaded"));
-    }
+      var div = this.div,
+          pdfPage = this.pdfPage;
 
-    this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
-    const canvasWrapper = document.createElement("div");
-    canvasWrapper.style.width = div.style.width;
-    canvasWrapper.style.height = div.style.height;
-    canvasWrapper.classList.add("canvasWrapper");
+      if (!pdfPage) {
+        this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
 
-    if (this.annotationLayer && this.annotationLayer.div) {
-      div.insertBefore(canvasWrapper, this.annotationLayer.div);
-    } else {
-      div.appendChild(canvasWrapper);
-    }
+        if (this.loadingIconDiv) {
+          div.removeChild(this.loadingIconDiv);
+          delete this.loadingIconDiv;
+        }
 
-    let textLayer = null;
+        return Promise.reject(new Error("pdfPage is not loaded"));
+      }
 
-    if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
-      const textLayerDiv = document.createElement("div");
-      textLayerDiv.className = "textLayer";
-      textLayerDiv.style.width = canvasWrapper.style.width;
-      textLayerDiv.style.height = canvasWrapper.style.height;
+      this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+      var canvasWrapper = document.createElement("div");
+      canvasWrapper.style.width = div.style.width;
+      canvasWrapper.style.height = div.style.height;
+      canvasWrapper.classList.add("canvasWrapper");
 
       if (this.annotationLayer && this.annotationLayer.div) {
-        div.insertBefore(textLayerDiv, this.annotationLayer.div);
+        div.insertBefore(canvasWrapper, this.annotationLayer.div);
       } else {
-        div.appendChild(textLayerDiv);
+        div.appendChild(canvasWrapper);
       }
 
-      textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus);
-    }
+      var textLayer = null;
 
-    this.textLayer = textLayer;
-    let renderContinueCallback = null;
+      if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
+        var textLayerDiv = document.createElement("div");
+        textLayerDiv.className = "textLayer";
+        textLayerDiv.style.width = canvasWrapper.style.width;
+        textLayerDiv.style.height = canvasWrapper.style.height;
 
-    if (this.renderingQueue) {
-      renderContinueCallback = cont => {
-        if (!this.renderingQueue.isHighestPriority(this)) {
-          this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
+        if (this.annotationLayer && this.annotationLayer.div) {
+          div.insertBefore(textLayerDiv, this.annotationLayer.div);
+        } else {
+          div.appendChild(textLayerDiv);
+        }
 
-          this.resume = () => {
-            this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
-            cont();
-          };
+        textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus);
+      }
 
-          return;
-        }
+      this.textLayer = textLayer;
+      var renderContinueCallback = null;
 
-        cont();
-      };
-    }
+      if (this.renderingQueue) {
+        renderContinueCallback = function renderContinueCallback(cont) {
+          if (!_this.renderingQueue.isHighestPriority(_this)) {
+            _this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
 
-    const finishPaintTask = async error => {
-      if (paintTask === this.paintTask) {
-        this.paintTask = null;
-      }
+            _this.resume = function () {
+              _this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+              cont();
+            };
 
-      if (error instanceof _pdfjsLib.RenderingCancelledException) {
-        this.error = null;
-        return;
+            return;
+          }
+
+          cont();
+        };
       }
 
-      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+      var finishPaintTask = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(error) {
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  if (paintTask === _this.paintTask) {
+                    _this.paintTask = null;
+                  }
 
-      if (this.loadingIconDiv) {
-        div.removeChild(this.loadingIconDiv);
-        delete this.loadingIconDiv;
-      }
+                  if (!(error instanceof _pdfjsLib.RenderingCancelledException)) {
+                    _context.next = 4;
+                    break;
+                  }
 
-      this._resetZoomLayer(true);
+                  _this.error = null;
+                  return _context.abrupt("return");
 
-      this.error = error;
-      this.stats = pdfPage.stats;
-      this.eventBus.dispatch("pagerendered", {
-        source: this,
-        pageNumber: this.id,
-        cssTransform: false,
-        timestamp: performance.now()
-      });
+                case 4:
+                  _this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
 
-      if (error) {
-        throw error;
-      }
-    };
+                  if (_this.loadingIconDiv) {
+                    div.removeChild(_this.loadingIconDiv);
+                    delete _this.loadingIconDiv;
+                  }
 
-    const paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
-    paintTask.onRenderContinue = renderContinueCallback;
-    this.paintTask = paintTask;
-    const resultPromise = paintTask.promise.then(function () {
-      return finishPaintTask(null).then(function () {
-        if (textLayer) {
-          const readableStream = pdfPage.streamTextContent({
-            normalizeWhitespace: true
-          });
-          textLayer.setTextContentStream(readableStream);
-          textLayer.render();
-        }
-      });
-    }, function (reason) {
-      return finishPaintTask(reason);
-    });
+                  _this._resetZoomLayer(true);
 
-    if (this.annotationLayerFactory) {
-      if (!this.annotationLayer) {
-        this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, this.imageResourcesPath, this.renderInteractiveForms, this.l10n);
-      }
+                  _this.error = error;
+                  _this.stats = pdfPage.stats;
 
-      this.annotationLayer.render(this.viewport, "display");
-    }
+                  _this.eventBus.dispatch("pagerendered", {
+                    source: _this,
+                    pageNumber: _this.id,
+                    cssTransform: false,
+                    timestamp: performance.now()
+                  });
 
-    div.setAttribute("data-loaded", true);
-    this.eventBus.dispatch("pagerender", {
-      source: this,
-      pageNumber: this.id
-    });
-    return resultPromise;
-  }
+                  if (!error) {
+                    _context.next = 12;
+                    break;
+                  }
 
-  paintOnCanvas(canvasWrapper) {
-    const renderCapability = (0, _pdfjsLib.createPromiseCapability)();
-    const result = {
-      promise: renderCapability.promise,
+                  throw error;
 
-      onRenderContinue(cont) {
-        cont();
-      },
+                case 12:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
 
-      cancel() {
-        renderTask.cancel();
-      }
+        return function finishPaintTask(_x) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+
+      var paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
+      paintTask.onRenderContinue = renderContinueCallback;
+      this.paintTask = paintTask;
+      var resultPromise = paintTask.promise.then(function () {
+        return finishPaintTask(null).then(function () {
+          if (textLayer) {
+            var readableStream = pdfPage.streamTextContent({
+              normalizeWhitespace: true
+            });
+            textLayer.setTextContentStream(readableStream);
+            textLayer.render();
+          }
+        });
+      }, function (reason) {
+        return finishPaintTask(reason);
+      });
 
-    };
-    const viewport = this.viewport;
-    const canvas = document.createElement("canvas");
-    this.l10n.get("page_canvas", {
-      page: this.id
-    }, "Page {{page}}").then(msg => {
-      canvas.setAttribute("aria-label", msg);
-    });
-    canvas.setAttribute("hidden", "hidden");
-    let isCanvasHidden = true;
+      if (this.annotationLayerFactory) {
+        if (!this.annotationLayer) {
+          this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, this.imageResourcesPath, this.renderInteractiveForms, this.l10n);
+        }
 
-    const showCanvas = function () {
-      if (isCanvasHidden) {
-        canvas.removeAttribute("hidden");
-        isCanvasHidden = false;
+        this.annotationLayer.render(this.viewport, "display");
       }
-    };
-
-    canvasWrapper.appendChild(canvas);
-    this.canvas = canvas;
-    canvas.mozOpaque = true;
-    const ctx = canvas.getContext("2d", {
-      alpha: false
-    });
-    const outputScale = (0, _ui_utils.getOutputScale)(ctx);
-    this.outputScale = outputScale;
 
-    if (this.useOnlyCssZoom) {
-      const actualSizeViewport = viewport.clone({
-        scale: _ui_utils.CSS_UNITS
+      div.setAttribute("data-loaded", true);
+      this.eventBus.dispatch("pagerender", {
+        source: this,
+        pageNumber: this.id
       });
-      outputScale.sx *= actualSizeViewport.width / viewport.width;
-      outputScale.sy *= actualSizeViewport.height / viewport.height;
-      outputScale.scaled = true;
-    }
+      return resultPromise;
+    }
+  }, {
+    key: "paintOnCanvas",
+    value: function paintOnCanvas(canvasWrapper) {
+      var renderCapability = (0, _pdfjsLib.createPromiseCapability)();
+      var result = {
+        promise: renderCapability.promise,
+        onRenderContinue: function onRenderContinue(cont) {
+          cont();
+        },
+        cancel: function cancel() {
+          renderTask.cancel();
+        }
+      };
+      var viewport = this.viewport;
+      var canvas = document.createElement("canvas");
+      this.l10n.get("page_canvas", {
+        page: this.id
+      }, "Page {{page}}").then(function (msg) {
+        canvas.setAttribute("aria-label", msg);
+      });
+      canvas.setAttribute("hidden", "hidden");
+      var isCanvasHidden = true;
 
-    if (this.maxCanvasPixels > 0) {
-      const pixelsInViewport = viewport.width * viewport.height;
-      const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);
+      var showCanvas = function showCanvas() {
+        if (isCanvasHidden) {
+          canvas.removeAttribute("hidden");
+          isCanvasHidden = false;
+        }
+      };
+
+      canvasWrapper.appendChild(canvas);
+      this.canvas = canvas;
+      canvas.mozOpaque = true;
+      var ctx = canvas.getContext("2d", {
+        alpha: false
+      });
+      var outputScale = (0, _ui_utils.getOutputScale)(ctx);
+      this.outputScale = outputScale;
 
-      if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
-        outputScale.sx = maxScale;
-        outputScale.sy = maxScale;
+      if (this.useOnlyCssZoom) {
+        var actualSizeViewport = viewport.clone({
+          scale: _ui_utils.CSS_UNITS
+        });
+        outputScale.sx *= actualSizeViewport.width / viewport.width;
+        outputScale.sy *= actualSizeViewport.height / viewport.height;
         outputScale.scaled = true;
-        this.hasRestrictedScaling = true;
-      } else {
-        this.hasRestrictedScaling = false;
       }
-    }
-
-    const sfx = (0, _ui_utils.approximateFraction)(outputScale.sx);
-    const sfy = (0, _ui_utils.approximateFraction)(outputScale.sy);
-    canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0]);
-    canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0]);
-    canvas.style.width = (0, _ui_utils.roundToDivide)(viewport.width, sfx[1]) + "px";
-    canvas.style.height = (0, _ui_utils.roundToDivide)(viewport.height, sfy[1]) + "px";
-    this.paintedViewportMap.set(canvas, viewport);
-    const transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0, outputScale.sy, 0, 0];
-    const renderContext = {
-      canvasContext: ctx,
-      transform,
-      viewport: this.viewport,
-      enableWebGL: this.enableWebGL,
-      renderInteractiveForms: this.renderInteractiveForms
-    };
-    const renderTask = this.pdfPage.render(renderContext);
 
-    renderTask.onContinue = function (cont) {
-      showCanvas();
+      if (this.maxCanvasPixels > 0) {
+        var pixelsInViewport = viewport.width * viewport.height;
+        var maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);
 
-      if (result.onRenderContinue) {
-        result.onRenderContinue(cont);
-      } else {
-        cont();
+        if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
+          outputScale.sx = maxScale;
+          outputScale.sy = maxScale;
+          outputScale.scaled = true;
+          this.hasRestrictedScaling = true;
+        } else {
+          this.hasRestrictedScaling = false;
+        }
       }
-    };
 
-    renderTask.promise.then(function () {
-      showCanvas();
-      renderCapability.resolve(undefined);
-    }, function (error) {
-      showCanvas();
-      renderCapability.reject(error);
-    });
-    return result;
-  }
+      var sfx = (0, _ui_utils.approximateFraction)(outputScale.sx);
+      var sfy = (0, _ui_utils.approximateFraction)(outputScale.sy);
+      canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0]);
+      canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0]);
+      canvas.style.width = (0, _ui_utils.roundToDivide)(viewport.width, sfx[1]) + "px";
+      canvas.style.height = (0, _ui_utils.roundToDivide)(viewport.height, sfy[1]) + "px";
+      this.paintedViewportMap.set(canvas, viewport);
+      var transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0, outputScale.sy, 0, 0];
+      var renderContext = {
+        canvasContext: ctx,
+        transform: transform,
+        viewport: this.viewport,
+        enableWebGL: this.enableWebGL,
+        renderInteractiveForms: this.renderInteractiveForms
+      };
+      var renderTask = this.pdfPage.render(renderContext);
 
-  paintOnSvg(wrapper) {
-    let cancelled = false;
+      renderTask.onContinue = function (cont) {
+        showCanvas();
 
-    const ensureNotCancelled = () => {
-      if (cancelled) {
-        throw new _pdfjsLib.RenderingCancelledException(`Rendering cancelled, page ${this.id}`, "svg");
-      }
-    };
+        if (result.onRenderContinue) {
+          result.onRenderContinue(cont);
+        } else {
+          cont();
+        }
+      };
 
-    const pdfPage = this.pdfPage;
-    const actualSizeViewport = this.viewport.clone({
-      scale: _ui_utils.CSS_UNITS
-    });
-    const promise = pdfPage.getOperatorList().then(opList => {
-      ensureNotCancelled();
-      const svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs, pdfPage.objs);
-      return svgGfx.getSVG(opList, actualSizeViewport).then(svg => {
-        ensureNotCancelled();
-        this.svg = svg;
-        this.paintedViewportMap.set(svg, actualSizeViewport);
-        svg.style.width = wrapper.style.width;
-        svg.style.height = wrapper.style.height;
-        this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
-        wrapper.appendChild(svg);
+      renderTask.promise.then(function () {
+        showCanvas();
+        renderCapability.resolve(undefined);
+      }, function (error) {
+        showCanvas();
+        renderCapability.reject(error);
       });
-    });
-    return {
-      promise,
+      return result;
+    }
+  }, {
+    key: "paintOnSvg",
+    value: function paintOnSvg(wrapper) {
+      var _this2 = this;
 
-      onRenderContinue(cont) {
-        cont();
-      },
+      var cancelled = false;
 
-      cancel() {
-        cancelled = true;
-      }
+      var ensureNotCancelled = function ensureNotCancelled() {
+        if (cancelled) {
+          throw new _pdfjsLib.RenderingCancelledException("Rendering cancelled, page ".concat(_this2.id), "svg");
+        }
+      };
 
-    };
-  }
+      var pdfPage = this.pdfPage;
+      var actualSizeViewport = this.viewport.clone({
+        scale: _ui_utils.CSS_UNITS
+      });
+      var promise = pdfPage.getOperatorList().then(function (opList) {
+        ensureNotCancelled();
+        var svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs, pdfPage.objs);
+        return svgGfx.getSVG(opList, actualSizeViewport).then(function (svg) {
+          ensureNotCancelled();
+          _this2.svg = svg;
 
-  setPageLabel(label) {
-    this.pageLabel = typeof label === "string" ? label : null;
+          _this2.paintedViewportMap.set(svg, actualSizeViewport);
 
-    if (this.pageLabel !== null) {
-      this.div.setAttribute("data-page-label", this.pageLabel);
-    } else {
-      this.div.removeAttribute("data-page-label");
+          svg.style.width = wrapper.style.width;
+          svg.style.height = wrapper.style.height;
+          _this2.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+          wrapper.appendChild(svg);
+        });
+      });
+      return {
+        promise: promise,
+        onRenderContinue: function onRenderContinue(cont) {
+          cont();
+        },
+        cancel: function cancel() {
+          cancelled = true;
+        }
+      };
     }
-  }
+  }, {
+    key: "setPageLabel",
+    value: function setPageLabel(label) {
+      this.pageLabel = typeof label === "string" ? label : null;
 
-}
+      if (this.pageLabel !== null) {
+        this.div.setAttribute("data-page-label", this.pageLabel);
+      } else {
+        this.div.removeAttribute("data-page-label");
+      }
+    }
+  }, {
+    key: "width",
+    get: function get() {
+      return this.viewport.width;
+    }
+  }, {
+    key: "height",
+    get: function get() {
+      return this.viewport.height;
+    }
+  }]);
+
+  return PDFPageView;
+}();
 
 exports.PDFPageView = PDFPageView;
 
 /***/ }),
-/* 28 */
+/* 31 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -10633,19 +12830,29 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DefaultTextLayerFactory = exports.TextLayerBuilder = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-const EXPAND_DIVS_TIMEOUT = 300;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var EXPAND_DIVS_TIMEOUT = 300;
+
+var TextLayerBuilder = /*#__PURE__*/function () {
+  function TextLayerBuilder(_ref) {
+    var textLayerDiv = _ref.textLayerDiv,
+        eventBus = _ref.eventBus,
+        pageIndex = _ref.pageIndex,
+        viewport = _ref.viewport,
+        _ref$findController = _ref.findController,
+        findController = _ref$findController === void 0 ? null : _ref$findController,
+        _ref$enhanceTextSelec = _ref.enhanceTextSelection,
+        enhanceTextSelection = _ref$enhanceTextSelec === void 0 ? false : _ref$enhanceTextSelec;
+
+    _classCallCheck(this, TextLayerBuilder);
 
-class TextLayerBuilder {
-  constructor({
-    textLayerDiv,
-    eventBus,
-    pageIndex,
-    viewport,
-    findController = null,
-    enhanceTextSelection = false
-  }) {
     this.textLayerDiv = textLayerDiv;
     this.eventBus = eventBus;
     this.textContent = null;
@@ -10665,348 +12872,370 @@ class TextLayerBuilder {
     this._bindMouse();
   }
 
-  _finishRendering() {
-    this.renderingDone = true;
-
-    if (!this.enhanceTextSelection) {
-      const endOfContent = document.createElement("div");
-      endOfContent.className = "endOfContent";
-      this.textLayerDiv.appendChild(endOfContent);
-    }
+  _createClass(TextLayerBuilder, [{
+    key: "_finishRendering",
+    value: function _finishRendering() {
+      this.renderingDone = true;
 
-    this.eventBus.dispatch("textlayerrendered", {
-      source: this,
-      pageNumber: this.pageNumber,
-      numTextDivs: this.textDivs.length
-    });
-  }
+      if (!this.enhanceTextSelection) {
+        var endOfContent = document.createElement("div");
+        endOfContent.className = "endOfContent";
+        this.textLayerDiv.appendChild(endOfContent);
+      }
 
-  render(timeout = 0) {
-    if (!(this.textContent || this.textContentStream) || this.renderingDone) {
-      return;
+      this.eventBus.dispatch("textlayerrendered", {
+        source: this,
+        pageNumber: this.pageNumber,
+        numTextDivs: this.textDivs.length
+      });
     }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this = this;
 
-    this.cancel();
-    this.textDivs = [];
-    const textLayerFrag = document.createDocumentFragment();
-    this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
-      textContent: this.textContent,
-      textContentStream: this.textContentStream,
-      container: textLayerFrag,
-      viewport: this.viewport,
-      textDivs: this.textDivs,
-      textContentItemsStr: this.textContentItemsStr,
-      timeout,
-      enhanceTextSelection: this.enhanceTextSelection
-    });
-    this.textLayerRenderTask.promise.then(() => {
-      this.textLayerDiv.appendChild(textLayerFrag);
+      var timeout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
 
-      this._finishRendering();
+      if (!(this.textContent || this.textContentStream) || this.renderingDone) {
+        return;
+      }
 
-      this._updateMatches();
-    }, function (reason) {});
+      this.cancel();
+      this.textDivs = [];
+      var textLayerFrag = document.createDocumentFragment();
+      this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
+        textContent: this.textContent,
+        textContentStream: this.textContentStream,
+        container: textLayerFrag,
+        viewport: this.viewport,
+        textDivs: this.textDivs,
+        textContentItemsStr: this.textContentItemsStr,
+        timeout: timeout,
+        enhanceTextSelection: this.enhanceTextSelection
+      });
+      this.textLayerRenderTask.promise.then(function () {
+        _this.textLayerDiv.appendChild(textLayerFrag);
 
-    if (!this._onUpdateTextLayerMatches) {
-      this._onUpdateTextLayerMatches = evt => {
-        if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {
-          this._updateMatches();
-        }
-      };
+        _this._finishRendering();
 
-      this.eventBus._on("updatetextlayermatches", this._onUpdateTextLayerMatches);
-    }
-  }
+        _this._updateMatches();
+      }, function (reason) {});
+
+      if (!this._onUpdateTextLayerMatches) {
+        this._onUpdateTextLayerMatches = function (evt) {
+          if (evt.pageIndex === _this.pageIdx || evt.pageIndex === -1) {
+            _this._updateMatches();
+          }
+        };
 
-  cancel() {
-    if (this.textLayerRenderTask) {
-      this.textLayerRenderTask.cancel();
-      this.textLayerRenderTask = null;
+        this.eventBus._on("updatetextlayermatches", this._onUpdateTextLayerMatches);
+      }
     }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      if (this.textLayerRenderTask) {
+        this.textLayerRenderTask.cancel();
+        this.textLayerRenderTask = null;
+      }
 
-    if (this._onUpdateTextLayerMatches) {
-      this.eventBus._off("updatetextlayermatches", this._onUpdateTextLayerMatches);
+      if (this._onUpdateTextLayerMatches) {
+        this.eventBus._off("updatetextlayermatches", this._onUpdateTextLayerMatches);
 
-      this._onUpdateTextLayerMatches = null;
+        this._onUpdateTextLayerMatches = null;
+      }
     }
-  }
+  }, {
+    key: "setTextContentStream",
+    value: function setTextContentStream(readableStream) {
+      this.cancel();
+      this.textContentStream = readableStream;
+    }
+  }, {
+    key: "setTextContent",
+    value: function setTextContent(textContent) {
+      this.cancel();
+      this.textContent = textContent;
+    }
+  }, {
+    key: "_convertMatches",
+    value: function _convertMatches(matches, matchesLength) {
+      if (!matches) {
+        return [];
+      }
 
-  setTextContentStream(readableStream) {
-    this.cancel();
-    this.textContentStream = readableStream;
-  }
+      var findController = this.findController,
+          textContentItemsStr = this.textContentItemsStr;
+      var i = 0,
+          iIndex = 0;
+      var end = textContentItemsStr.length - 1;
+      var queryLen = findController.state.query.length;
+      var result = [];
 
-  setTextContent(textContent) {
-    this.cancel();
-    this.textContent = textContent;
-  }
+      for (var m = 0, mm = matches.length; m < mm; m++) {
+        var matchIdx = matches[m];
 
-  _convertMatches(matches, matchesLength) {
-    if (!matches) {
-      return [];
-    }
+        while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
+          iIndex += textContentItemsStr[i].length;
+          i++;
+        }
 
-    const {
-      findController,
-      textContentItemsStr
-    } = this;
-    let i = 0,
-        iIndex = 0;
-    const end = textContentItemsStr.length - 1;
-    const queryLen = findController.state.query.length;
-    const result = [];
+        if (i === textContentItemsStr.length) {
+          console.error("Could not find a matching mapping");
+        }
 
-    for (let m = 0, mm = matches.length; m < mm; m++) {
-      let matchIdx = matches[m];
+        var match = {
+          begin: {
+            divIdx: i,
+            offset: matchIdx - iIndex
+          }
+        };
 
-      while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
-        iIndex += textContentItemsStr[i].length;
-        i++;
-      }
+        if (matchesLength) {
+          matchIdx += matchesLength[m];
+        } else {
+          matchIdx += queryLen;
+        }
 
-      if (i === textContentItemsStr.length) {
-        console.error("Could not find a matching mapping");
-      }
+        while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
+          iIndex += textContentItemsStr[i].length;
+          i++;
+        }
 
-      const match = {
-        begin: {
+        match.end = {
           divIdx: i,
           offset: matchIdx - iIndex
-        }
-      };
-
-      if (matchesLength) {
-        matchIdx += matchesLength[m];
-      } else {
-        matchIdx += queryLen;
+        };
+        result.push(match);
       }
 
-      while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
-        iIndex += textContentItemsStr[i].length;
-        i++;
+      return result;
+    }
+  }, {
+    key: "_renderMatches",
+    value: function _renderMatches(matches) {
+      if (matches.length === 0) {
+        return;
       }
 
-      match.end = {
-        divIdx: i,
-        offset: matchIdx - iIndex
+      var findController = this.findController,
+          pageIdx = this.pageIdx,
+          textContentItemsStr = this.textContentItemsStr,
+          textDivs = this.textDivs;
+      var isSelectedPage = pageIdx === findController.selected.pageIdx;
+      var selectedMatchIdx = findController.selected.matchIdx;
+      var highlightAll = findController.state.highlightAll;
+      var prevEnd = null;
+      var infinity = {
+        divIdx: -1,
+        offset: undefined
       };
-      result.push(match);
-    }
 
-    return result;
-  }
+      function beginText(begin, className) {
+        var divIdx = begin.divIdx;
+        textDivs[divIdx].textContent = "";
+        appendTextToDiv(divIdx, 0, begin.offset, className);
+      }
 
-  _renderMatches(matches) {
-    if (matches.length === 0) {
-      return;
-    }
+      function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
+        var div = textDivs[divIdx];
+        var content = textContentItemsStr[divIdx].substring(fromOffset, toOffset);
+        var node = document.createTextNode(content);
 
-    const {
-      findController,
-      pageIdx,
-      textContentItemsStr,
-      textDivs
-    } = this;
-    const isSelectedPage = pageIdx === findController.selected.pageIdx;
-    const selectedMatchIdx = findController.selected.matchIdx;
-    const highlightAll = findController.state.highlightAll;
-    let prevEnd = null;
-    const infinity = {
-      divIdx: -1,
-      offset: undefined
-    };
+        if (className) {
+          var span = document.createElement("span");
+          span.className = className;
+          span.appendChild(node);
+          div.appendChild(span);
+          return;
+        }
 
-    function beginText(begin, className) {
-      const divIdx = begin.divIdx;
-      textDivs[divIdx].textContent = "";
-      appendTextToDiv(divIdx, 0, begin.offset, className);
-    }
+        div.appendChild(node);
+      }
 
-    function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
-      const div = textDivs[divIdx];
-      const content = textContentItemsStr[divIdx].substring(fromOffset, toOffset);
-      const node = document.createTextNode(content);
+      var i0 = selectedMatchIdx,
+          i1 = i0 + 1;
 
-      if (className) {
-        const span = document.createElement("span");
-        span.className = className;
-        span.appendChild(node);
-        div.appendChild(span);
+      if (highlightAll) {
+        i0 = 0;
+        i1 = matches.length;
+      } else if (!isSelectedPage) {
         return;
       }
 
-      div.appendChild(node);
-    }
-
-    let i0 = selectedMatchIdx,
-        i1 = i0 + 1;
+      for (var i = i0; i < i1; i++) {
+        var match = matches[i];
+        var begin = match.begin;
+        var end = match.end;
+        var isSelected = isSelectedPage && i === selectedMatchIdx;
+        var highlightSuffix = isSelected ? " selected" : "";
 
-    if (highlightAll) {
-      i0 = 0;
-      i1 = matches.length;
-    } else if (!isSelectedPage) {
-      return;
-    }
-
-    for (let i = i0; i < i1; i++) {
-      const match = matches[i];
-      const begin = match.begin;
-      const end = match.end;
-      const isSelected = isSelectedPage && i === selectedMatchIdx;
-      const highlightSuffix = isSelected ? " selected" : "";
+        if (isSelected) {
+          findController.scrollMatchIntoView({
+            element: textDivs[begin.divIdx],
+            pageIndex: pageIdx,
+            matchIndex: selectedMatchIdx
+          });
+        }
 
-      if (isSelected) {
-        findController.scrollMatchIntoView({
-          element: textDivs[begin.divIdx],
-          pageIndex: pageIdx,
-          matchIndex: selectedMatchIdx
-        });
-      }
+        if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
+          if (prevEnd !== null) {
+            appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+          }
 
-      if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
-        if (prevEnd !== null) {
-          appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+          beginText(begin);
+        } else {
+          appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
         }
 
-        beginText(begin);
-      } else {
-        appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
-      }
+        if (begin.divIdx === end.divIdx) {
+          appendTextToDiv(begin.divIdx, begin.offset, end.offset, "highlight" + highlightSuffix);
+        } else {
+          appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, "highlight begin" + highlightSuffix);
 
-      if (begin.divIdx === end.divIdx) {
-        appendTextToDiv(begin.divIdx, begin.offset, end.offset, "highlight" + highlightSuffix);
-      } else {
-        appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, "highlight begin" + highlightSuffix);
+          for (var n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
+            textDivs[n0].className = "highlight middle" + highlightSuffix;
+          }
 
-        for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
-          textDivs[n0].className = "highlight middle" + highlightSuffix;
+          beginText(end, "highlight end" + highlightSuffix);
         }
 
-        beginText(end, "highlight end" + highlightSuffix);
+        prevEnd = end;
       }
 
-      prevEnd = end;
+      if (prevEnd) {
+        appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+      }
     }
+  }, {
+    key: "_updateMatches",
+    value: function _updateMatches() {
+      if (!this.renderingDone) {
+        return;
+      }
 
-    if (prevEnd) {
-      appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
-    }
-  }
+      var findController = this.findController,
+          matches = this.matches,
+          pageIdx = this.pageIdx,
+          textContentItemsStr = this.textContentItemsStr,
+          textDivs = this.textDivs;
+      var clearedUntilDivIdx = -1;
 
-  _updateMatches() {
-    if (!this.renderingDone) {
-      return;
-    }
+      for (var i = 0, ii = matches.length; i < ii; i++) {
+        var match = matches[i];
+        var begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
 
-    const {
-      findController,
-      matches,
-      pageIdx,
-      textContentItemsStr,
-      textDivs
-    } = this;
-    let clearedUntilDivIdx = -1;
+        for (var n = begin, end = match.end.divIdx; n <= end; n++) {
+          var div = textDivs[n];
+          div.textContent = textContentItemsStr[n];
+          div.className = "";
+        }
 
-    for (let i = 0, ii = matches.length; i < ii; i++) {
-      const match = matches[i];
-      const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
+        clearedUntilDivIdx = match.end.divIdx + 1;
+      }
 
-      for (let n = begin, end = match.end.divIdx; n <= end; n++) {
-        const div = textDivs[n];
-        div.textContent = textContentItemsStr[n];
-        div.className = "";
+      if (!findController || !findController.highlightMatches) {
+        return;
       }
 
-      clearedUntilDivIdx = match.end.divIdx + 1;
-    }
+      var pageMatches = findController.pageMatches[pageIdx] || null;
+      var pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;
+      this.matches = this._convertMatches(pageMatches, pageMatchesLength);
 
-    if (!findController || !findController.highlightMatches) {
-      return;
+      this._renderMatches(this.matches);
     }
+  }, {
+    key: "_bindMouse",
+    value: function _bindMouse() {
+      var _this2 = this;
 
-    const pageMatches = findController.pageMatches[pageIdx] || null;
-    const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;
-    this.matches = this._convertMatches(pageMatches, pageMatchesLength);
-
-    this._renderMatches(this.matches);
-  }
+      var div = this.textLayerDiv;
+      var expandDivsTimer = null;
+      div.addEventListener("mousedown", function (evt) {
+        if (_this2.enhanceTextSelection && _this2.textLayerRenderTask) {
+          _this2.textLayerRenderTask.expandTextDivs(true);
 
-  _bindMouse() {
-    const div = this.textLayerDiv;
-    let expandDivsTimer = null;
-    div.addEventListener("mousedown", evt => {
-      if (this.enhanceTextSelection && this.textLayerRenderTask) {
-        this.textLayerRenderTask.expandTextDivs(true);
+          if (expandDivsTimer) {
+            clearTimeout(expandDivsTimer);
+            expandDivsTimer = null;
+          }
 
-        if (expandDivsTimer) {
-          clearTimeout(expandDivsTimer);
-          expandDivsTimer = null;
+          return;
         }
 
-        return;
-      }
-
-      const end = div.querySelector(".endOfContent");
+        var end = div.querySelector(".endOfContent");
 
-      if (!end) {
-        return;
-      }
+        if (!end) {
+          return;
+        }
 
-      let adjustTop = evt.target !== div;
-      adjustTop = adjustTop && window.getComputedStyle(end).getPropertyValue("-moz-user-select") !== "none";
+        var adjustTop = evt.target !== div;
+        adjustTop = adjustTop && window.getComputedStyle(end).getPropertyValue("-moz-user-select") !== "none";
 
-      if (adjustTop) {
-        const divBounds = div.getBoundingClientRect();
-        const r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height);
-        end.style.top = (r * 100).toFixed(2) + "%";
-      }
+        if (adjustTop) {
+          var divBounds = div.getBoundingClientRect();
+          var r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height);
+          end.style.top = (r * 100).toFixed(2) + "%";
+        }
 
-      end.classList.add("active");
-    });
-    div.addEventListener("mouseup", () => {
-      if (this.enhanceTextSelection && this.textLayerRenderTask) {
-        expandDivsTimer = setTimeout(() => {
-          if (this.textLayerRenderTask) {
-            this.textLayerRenderTask.expandTextDivs(false);
-          }
+        end.classList.add("active");
+      });
+      div.addEventListener("mouseup", function () {
+        if (_this2.enhanceTextSelection && _this2.textLayerRenderTask) {
+          expandDivsTimer = setTimeout(function () {
+            if (_this2.textLayerRenderTask) {
+              _this2.textLayerRenderTask.expandTextDivs(false);
+            }
 
-          expandDivsTimer = null;
-        }, EXPAND_DIVS_TIMEOUT);
-        return;
-      }
+            expandDivsTimer = null;
+          }, EXPAND_DIVS_TIMEOUT);
+          return;
+        }
 
-      const end = div.querySelector(".endOfContent");
+        var end = div.querySelector(".endOfContent");
 
-      if (!end) {
-        return;
-      }
+        if (!end) {
+          return;
+        }
 
-      end.style.top = "";
-      end.classList.remove("active");
-    });
-  }
+        end.style.top = "";
+        end.classList.remove("active");
+      });
+    }
+  }]);
 
-}
+  return TextLayerBuilder;
+}();
 
 exports.TextLayerBuilder = TextLayerBuilder;
 
-class DefaultTextLayerFactory {
-  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
-    return new TextLayerBuilder({
-      textLayerDiv,
-      pageIndex,
-      viewport,
-      enhanceTextSelection,
-      eventBus
-    });
-  }
+var DefaultTextLayerFactory = /*#__PURE__*/function () {
+  function DefaultTextLayerFactory() {
+    _classCallCheck(this, DefaultTextLayerFactory);
+  }
+
+  _createClass(DefaultTextLayerFactory, [{
+    key: "createTextLayerBuilder",
+    value: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) {
+      var enhanceTextSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var eventBus = arguments.length > 4 ? arguments[4] : undefined;
+      return new TextLayerBuilder({
+        textLayerDiv: textLayerDiv,
+        pageIndex: pageIndex,
+        viewport: viewport,
+        enhanceTextSelection: enhanceTextSelection,
+        eventBus: eventBus
+      });
+    }
+  }]);
 
-}
+  return DefaultTextLayerFactory;
+}();
 
 exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
 
 /***/ }),
-/* 29 */
+/* 32 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11017,14 +13246,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SecondaryToolbar = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
+
+var _pdf_cursor_tools = __webpack_require__(9);
+
+var _pdf_single_page_viewer = __webpack_require__(33);
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var _pdf_cursor_tools = __webpack_require__(6);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _pdf_single_page_viewer = __webpack_require__(30);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var SecondaryToolbar = /*#__PURE__*/function () {
+  function SecondaryToolbar(options, mainContainer, eventBus) {
+    var _this = this;
+
+    _classCallCheck(this, SecondaryToolbar);
 
-class SecondaryToolbar {
-  constructor(options, mainContainer, eventBus) {
     this.toolbar = options.toolbar;
     this.toggleButton = options.toggleButton;
     this.toolbarButtonContainer = options.toolbarButtonContainer;
@@ -11148,183 +13393,215 @@ class SecondaryToolbar {
 
     this.eventBus._on("resize", this._setMaxHeight.bind(this));
 
-    this.eventBus._on("baseviewerinit", evt => {
+    this.eventBus._on("baseviewerinit", function (evt) {
       if (evt.source instanceof _pdf_single_page_viewer.PDFSinglePageViewer) {
-        this.toolbarButtonContainer.classList.add("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
+        _this.toolbarButtonContainer.classList.add("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
       } else {
-        this.toolbarButtonContainer.classList.remove("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
+        _this.toolbarButtonContainer.classList.remove("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
       }
     });
   }
 
-  get isOpen() {
-    return this.opened;
-  }
+  _createClass(SecondaryToolbar, [{
+    key: "setPageNumber",
+    value: function setPageNumber(pageNumber) {
+      this.pageNumber = pageNumber;
 
-  setPageNumber(pageNumber) {
-    this.pageNumber = pageNumber;
+      this._updateUIState();
+    }
+  }, {
+    key: "setPagesCount",
+    value: function setPagesCount(pagesCount) {
+      this.pagesCount = pagesCount;
 
-    this._updateUIState();
-  }
+      this._updateUIState();
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.pageNumber = 0;
+      this.pagesCount = 0;
 
-  setPagesCount(pagesCount) {
-    this.pagesCount = pagesCount;
+      this._updateUIState();
 
-    this._updateUIState();
-  }
+      this.eventBus.dispatch("secondarytoolbarreset", {
+        source: this
+      });
+    }
+  }, {
+    key: "_updateUIState",
+    value: function _updateUIState() {
+      this.items.firstPage.disabled = this.pageNumber <= 1;
+      this.items.lastPage.disabled = this.pageNumber >= this.pagesCount;
+      this.items.pageRotateCw.disabled = this.pagesCount === 0;
+      this.items.pageRotateCcw.disabled = this.pagesCount === 0;
+    }
+  }, {
+    key: "_bindClickListeners",
+    value: function _bindClickListeners() {
+      var _this2 = this;
 
-  reset() {
-    this.pageNumber = 0;
-    this.pagesCount = 0;
+      this.toggleButton.addEventListener("click", this.toggle.bind(this));
 
-    this._updateUIState();
+      var _iterator = _createForOfIteratorHelper(this.buttons),
+          _step;
 
-    this.eventBus.dispatch("secondarytoolbarreset", {
-      source: this
-    });
-  }
+      try {
+        var _loop = function _loop() {
+          var _step$value = _step.value,
+              element = _step$value.element,
+              eventName = _step$value.eventName,
+              close = _step$value.close,
+              eventDetails = _step$value.eventDetails;
+          element.addEventListener("click", function (evt) {
+            if (eventName !== null) {
+              var details = {
+                source: _this2
+              };
+
+              for (var property in eventDetails) {
+                details[property] = eventDetails[property];
+              }
 
-  _updateUIState() {
-    this.items.firstPage.disabled = this.pageNumber <= 1;
-    this.items.lastPage.disabled = this.pageNumber >= this.pagesCount;
-    this.items.pageRotateCw.disabled = this.pagesCount === 0;
-    this.items.pageRotateCcw.disabled = this.pagesCount === 0;
-  }
+              _this2.eventBus.dispatch(eventName, details);
+            }
 
-  _bindClickListeners() {
-    this.toggleButton.addEventListener("click", this.toggle.bind(this));
+            if (close) {
+              _this2.close();
+            }
+          });
+        };
 
-    for (const {
-      element,
-      eventName,
-      close,
-      eventDetails
-    } of this.buttons) {
-      element.addEventListener("click", evt => {
-        if (eventName !== null) {
-          const details = {
-            source: this
-          };
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "_bindCursorToolsListener",
+    value: function _bindCursorToolsListener(buttons) {
+      this.eventBus._on("cursortoolchanged", function (_ref) {
+        var tool = _ref.tool;
+        buttons.cursorSelectToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.SELECT);
+        buttons.cursorHandToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.HAND);
+      });
+    }
+  }, {
+    key: "_bindScrollModeListener",
+    value: function _bindScrollModeListener(buttons) {
+      var _this3 = this;
 
-          for (const property in eventDetails) {
-            details[property] = eventDetails[property];
-          }
+      function scrollModeChanged(_ref2) {
+        var mode = _ref2.mode;
+        buttons.scrollVerticalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.VERTICAL);
+        buttons.scrollHorizontalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.HORIZONTAL);
+        buttons.scrollWrappedButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.WRAPPED);
+        var isScrollModeHorizontal = mode === _ui_utils.ScrollMode.HORIZONTAL;
+        buttons.spreadNoneButton.disabled = isScrollModeHorizontal;
+        buttons.spreadOddButton.disabled = isScrollModeHorizontal;
+        buttons.spreadEvenButton.disabled = isScrollModeHorizontal;
+      }
 
-          this.eventBus.dispatch(eventName, details);
-        }
+      this.eventBus._on("scrollmodechanged", scrollModeChanged);
 
-        if (close) {
-          this.close();
+      this.eventBus._on("secondarytoolbarreset", function (evt) {
+        if (evt.source === _this3) {
+          scrollModeChanged({
+            mode: _ui_utils.ScrollMode.VERTICAL
+          });
         }
       });
     }
-  }
-
-  _bindCursorToolsListener(buttons) {
-    this.eventBus._on("cursortoolchanged", function ({
-      tool
-    }) {
-      buttons.cursorSelectToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.SELECT);
-      buttons.cursorHandToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.HAND);
-    });
-  }
+  }, {
+    key: "_bindSpreadModeListener",
+    value: function _bindSpreadModeListener(buttons) {
+      var _this4 = this;
 
-  _bindScrollModeListener(buttons) {
-    function scrollModeChanged({
-      mode
-    }) {
-      buttons.scrollVerticalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.VERTICAL);
-      buttons.scrollHorizontalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.HORIZONTAL);
-      buttons.scrollWrappedButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.WRAPPED);
-      const isScrollModeHorizontal = mode === _ui_utils.ScrollMode.HORIZONTAL;
-      buttons.spreadNoneButton.disabled = isScrollModeHorizontal;
-      buttons.spreadOddButton.disabled = isScrollModeHorizontal;
-      buttons.spreadEvenButton.disabled = isScrollModeHorizontal;
-    }
+      function spreadModeChanged(_ref3) {
+        var mode = _ref3.mode;
+        buttons.spreadNoneButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.NONE);
+        buttons.spreadOddButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.ODD);
+        buttons.spreadEvenButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.EVEN);
+      }
 
-    this.eventBus._on("scrollmodechanged", scrollModeChanged);
+      this.eventBus._on("spreadmodechanged", spreadModeChanged);
 
-    this.eventBus._on("secondarytoolbarreset", evt => {
-      if (evt.source === this) {
-        scrollModeChanged({
-          mode: _ui_utils.ScrollMode.VERTICAL
-        });
+      this.eventBus._on("secondarytoolbarreset", function (evt) {
+        if (evt.source === _this4) {
+          spreadModeChanged({
+            mode: _ui_utils.SpreadMode.NONE
+          });
+        }
+      });
+    }
+  }, {
+    key: "open",
+    value: function open() {
+      if (this.opened) {
+        return;
       }
-    });
-  }
 
-  _bindSpreadModeListener(buttons) {
-    function spreadModeChanged({
-      mode
-    }) {
-      buttons.spreadNoneButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.NONE);
-      buttons.spreadOddButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.ODD);
-      buttons.spreadEvenButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.EVEN);
-    }
+      this.opened = true;
 
-    this.eventBus._on("spreadmodechanged", spreadModeChanged);
+      this._setMaxHeight();
 
-    this.eventBus._on("secondarytoolbarreset", evt => {
-      if (evt.source === this) {
-        spreadModeChanged({
-          mode: _ui_utils.SpreadMode.NONE
-        });
+      this.toggleButton.classList.add("toggled");
+      this.toolbar.classList.remove("hidden");
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      if (!this.opened) {
+        return;
       }
-    });
-  }
 
-  open() {
-    if (this.opened) {
-      return;
+      this.opened = false;
+      this.toolbar.classList.add("hidden");
+      this.toggleButton.classList.remove("toggled");
     }
-
-    this.opened = true;
-
-    this._setMaxHeight();
-
-    this.toggleButton.classList.add("toggled");
-    this.toolbar.classList.remove("hidden");
-  }
-
-  close() {
-    if (!this.opened) {
-      return;
+  }, {
+    key: "toggle",
+    value: function toggle() {
+      if (this.opened) {
+        this.close();
+      } else {
+        this.open();
+      }
     }
+  }, {
+    key: "_setMaxHeight",
+    value: function _setMaxHeight() {
+      if (!this.opened) {
+        return;
+      }
 
-    this.opened = false;
-    this.toolbar.classList.add("hidden");
-    this.toggleButton.classList.remove("toggled");
-  }
+      this.containerHeight = this.mainContainer.clientHeight;
 
-  toggle() {
-    if (this.opened) {
-      this.close();
-    } else {
-      this.open();
-    }
-  }
+      if (this.containerHeight === this.previousContainerHeight) {
+        return;
+      }
 
-  _setMaxHeight() {
-    if (!this.opened) {
-      return;
+      this.toolbarButtonContainer.style.maxHeight = "".concat(this.containerHeight - _ui_utils.SCROLLBAR_PADDING, "px");
+      this.previousContainerHeight = this.containerHeight;
     }
-
-    this.containerHeight = this.mainContainer.clientHeight;
-
-    if (this.containerHeight === this.previousContainerHeight) {
-      return;
+  }, {
+    key: "isOpen",
+    get: function get() {
+      return this.opened;
     }
+  }]);
 
-    this.toolbarButtonContainer.style.maxHeight = `${this.containerHeight - _ui_utils.SCROLLBAR_PADDING}px`;
-    this.previousContainerHeight = this.containerHeight;
-  }
-
-}
+  return SecondaryToolbar;
+}();
 
 exports.SecondaryToolbar = SecondaryToolbar;
 
 /***/ }),
-/* 30 */
+/* 33 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11335,118 +13612,171 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFSinglePageViewer = void 0;
 
-var _base_viewer = __webpack_require__(25);
+var _base_viewer = __webpack_require__(28);
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
 
-class PDFSinglePageViewer extends _base_viewer.BaseViewer {
-  constructor(options) {
-    super(options);
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-    this.eventBus._on("pagesinit", evt => {
-      this._ensurePageViewVisible();
-    });
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  get _viewerElement() {
-    return (0, _pdfjsLib.shadow)(this, "_viewerElement", this._shadowViewer);
-  }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-  _resetView() {
-    super._resetView();
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-    this._previousPageNumber = 1;
-    this._shadowViewer = document.createDocumentFragment();
-    this._updateScrollDown = null;
-  }
+function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
 
-  _ensurePageViewVisible() {
-    const pageView = this._pages[this._currentPageNumber - 1];
-    const previousPageView = this._pages[this._previousPageNumber - 1];
-    const viewerNodes = this.viewer.childNodes;
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 
-    switch (viewerNodes.length) {
-      case 0:
-        this.viewer.appendChild(pageView.div);
-        break;
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-      case 1:
-        if (viewerNodes[0] !== previousPageView.div) {
-          throw new Error("_ensurePageViewVisible: Unexpected previously visible page.");
-        }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-        if (pageView === previousPageView) {
-          break;
-        }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-        this._shadowViewer.appendChild(previousPageView.div);
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-        this.viewer.appendChild(pageView.div);
-        this.container.scrollTop = 0;
-        break;
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-      default:
-        throw new Error("_ensurePageViewVisible: Only one page should be visible at a time.");
-    }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
 
-    this._previousPageNumber = this._currentPageNumber;
-  }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-  _scrollUpdate() {
-    if (this._updateScrollDown) {
-      this._updateScrollDown();
-    }
+var PDFSinglePageViewer = /*#__PURE__*/function (_BaseViewer) {
+  _inherits(PDFSinglePageViewer, _BaseViewer);
+
+  var _super = _createSuper(PDFSinglePageViewer);
+
+  function PDFSinglePageViewer(options) {
+    var _this;
 
-    super._scrollUpdate();
+    _classCallCheck(this, PDFSinglePageViewer);
+
+    _this = _super.call(this, options);
+
+    _this.eventBus._on("pagesinit", function (evt) {
+      _this._ensurePageViewVisible();
+    });
+
+    return _this;
   }
 
-  _scrollIntoView({
-    pageDiv,
-    pageSpot = null,
-    pageNumber = null
-  }) {
-    if (pageNumber) {
-      this._setCurrentPageNumber(pageNumber);
+  _createClass(PDFSinglePageViewer, [{
+    key: "_resetView",
+    value: function _resetView() {
+      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_resetView", this).call(this);
+
+      this._previousPageNumber = 1;
+      this._shadowViewer = document.createDocumentFragment();
+      this._updateScrollDown = null;
     }
+  }, {
+    key: "_ensurePageViewVisible",
+    value: function _ensurePageViewVisible() {
+      var pageView = this._pages[this._currentPageNumber - 1];
+      var previousPageView = this._pages[this._previousPageNumber - 1];
+      var viewerNodes = this.viewer.childNodes;
 
-    const scrolledDown = this._currentPageNumber >= this._previousPageNumber;
+      switch (viewerNodes.length) {
+        case 0:
+          this.viewer.appendChild(pageView.div);
+          break;
 
-    this._ensurePageViewVisible();
+        case 1:
+          if (viewerNodes[0] !== previousPageView.div) {
+            throw new Error("_ensurePageViewVisible: Unexpected previously visible page.");
+          }
 
-    this.update();
+          if (pageView === previousPageView) {
+            break;
+          }
 
-    super._scrollIntoView({
-      pageDiv,
-      pageSpot,
-      pageNumber
-    });
+          this._shadowViewer.appendChild(previousPageView.div);
 
-    this._updateScrollDown = () => {
-      this.scroll.down = scrolledDown;
-      this._updateScrollDown = null;
-    };
-  }
+          this.viewer.appendChild(pageView.div);
+          this.container.scrollTop = 0;
+          break;
 
-  _getVisiblePages() {
-    return this._getCurrentVisiblePage();
-  }
+        default:
+          throw new Error("_ensurePageViewVisible: Only one page should be visible at a time.");
+      }
 
-  _updateHelper(visiblePages) {}
+      this._previousPageNumber = this._currentPageNumber;
+    }
+  }, {
+    key: "_scrollUpdate",
+    value: function _scrollUpdate() {
+      if (this._updateScrollDown) {
+        this._updateScrollDown();
+      }
 
-  get _isScrollModeHorizontal() {
-    return (0, _pdfjsLib.shadow)(this, "_isScrollModeHorizontal", false);
-  }
+      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_scrollUpdate", this).call(this);
+    }
+  }, {
+    key: "_scrollIntoView",
+    value: function _scrollIntoView(_ref) {
+      var _this2 = this;
 
-  _updateScrollMode() {}
+      var pageDiv = _ref.pageDiv,
+          _ref$pageSpot = _ref.pageSpot,
+          pageSpot = _ref$pageSpot === void 0 ? null : _ref$pageSpot,
+          _ref$pageNumber = _ref.pageNumber,
+          pageNumber = _ref$pageNumber === void 0 ? null : _ref$pageNumber;
 
-  _updateSpreadMode() {}
+      if (pageNumber) {
+        this._setCurrentPageNumber(pageNumber);
+      }
 
-}
+      var scrolledDown = this._currentPageNumber >= this._previousPageNumber;
+
+      this._ensurePageViewVisible();
+
+      this.update();
+
+      _get(_getPrototypeOf(PDFSinglePageViewer.prototype), "_scrollIntoView", this).call(this, {
+        pageDiv: pageDiv,
+        pageSpot: pageSpot,
+        pageNumber: pageNumber
+      });
+
+      this._updateScrollDown = function () {
+        _this2.scroll.down = scrolledDown;
+        _this2._updateScrollDown = null;
+      };
+    }
+  }, {
+    key: "_getVisiblePages",
+    value: function _getVisiblePages() {
+      return this._getCurrentVisiblePage();
+    }
+  }, {
+    key: "_updateHelper",
+    value: function _updateHelper(visiblePages) {}
+  }, {
+    key: "_updateScrollMode",
+    value: function _updateScrollMode() {}
+  }, {
+    key: "_updateSpreadMode",
+    value: function _updateSpreadMode() {}
+  }, {
+    key: "_viewerElement",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "_viewerElement", this._shadowViewer);
+    }
+  }, {
+    key: "_isScrollModeHorizontal",
+    get: function get() {
+      return (0, _pdfjsLib.shadow)(this, "_isScrollModeHorizontal", false);
+    }
+  }]);
+
+  return PDFSinglePageViewer;
+}(_base_viewer.BaseViewer);
 
 exports.PDFSinglePageViewer = PDFSinglePageViewer;
 
 /***/ }),
-/* 31 */
+/* 34 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11457,14 +13787,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Toolbar = void 0;
 
-var _ui_utils = __webpack_require__(2);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+var _ui_utils = __webpack_require__(5);
 
-const PAGE_NUMBER_LOADING_INDICATOR = "visiblePageIsLoading";
-const SCALE_SELECT_CONTAINER_WIDTH = 140;
-const SCALE_SELECT_WIDTH = 162;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var PAGE_NUMBER_LOADING_INDICATOR = "visiblePageIsLoading";
+var SCALE_SELECT_CONTAINER_WIDTH = 140;
+var SCALE_SELECT_WIDTH = 162;
+
+var Toolbar = /*#__PURE__*/function () {
+  function Toolbar(options, eventBus) {
+    var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils.NullL10n;
+
+    _classCallCheck(this, Toolbar);
 
-class Toolbar {
-  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
     this.toolbar = options.container;
     this.eventBus = eventBus;
     this.l10n = l10n;
@@ -11513,210 +13867,277 @@ class Toolbar {
     this._bindListeners();
   }
 
-  setPageNumber(pageNumber, pageLabel) {
-    this.pageNumber = pageNumber;
-    this.pageLabel = pageLabel;
+  _createClass(Toolbar, [{
+    key: "setPageNumber",
+    value: function setPageNumber(pageNumber, pageLabel) {
+      this.pageNumber = pageNumber;
+      this.pageLabel = pageLabel;
 
-    this._updateUIState(false);
-  }
+      this._updateUIState(false);
+    }
+  }, {
+    key: "setPagesCount",
+    value: function setPagesCount(pagesCount, hasPageLabels) {
+      this.pagesCount = pagesCount;
+      this.hasPageLabels = hasPageLabels;
 
-  setPagesCount(pagesCount, hasPageLabels) {
-    this.pagesCount = pagesCount;
-    this.hasPageLabels = hasPageLabels;
+      this._updateUIState(true);
+    }
+  }, {
+    key: "setPageScale",
+    value: function setPageScale(pageScaleValue, pageScale) {
+      this.pageScaleValue = (pageScaleValue || pageScale).toString();
+      this.pageScale = pageScale;
 
-    this._updateUIState(true);
-  }
+      this._updateUIState(false);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.pageNumber = 0;
+      this.pageLabel = null;
+      this.hasPageLabels = false;
+      this.pagesCount = 0;
+      this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+      this.pageScale = _ui_utils.DEFAULT_SCALE;
 
-  setPageScale(pageScaleValue, pageScale) {
-    this.pageScaleValue = (pageScaleValue || pageScale).toString();
-    this.pageScale = pageScale;
+      this._updateUIState(true);
 
-    this._updateUIState(false);
-  }
+      this.updateLoadingIndicatorState();
+    }
+  }, {
+    key: "_bindListeners",
+    value: function _bindListeners() {
+      var _this = this;
 
-  reset() {
-    this.pageNumber = 0;
-    this.pageLabel = null;
-    this.hasPageLabels = false;
-    this.pagesCount = 0;
-    this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
-    this.pageScale = _ui_utils.DEFAULT_SCALE;
-
-    this._updateUIState(true);
-
-    this.updateLoadingIndicatorState();
-  }
-
-  _bindListeners() {
-    const {
-      pageNumber,
-      scaleSelect
-    } = this.items;
-    const self = this;
-
-    for (const {
-      element,
-      eventName
-    } of this.buttons) {
-      element.addEventListener("click", evt => {
-        if (eventName !== null) {
-          this.eventBus.dispatch(eventName, {
-            source: this
+      var _this$items = this.items,
+          pageNumber = _this$items.pageNumber,
+          scaleSelect = _this$items.scaleSelect;
+      var self = this;
+
+      var _iterator = _createForOfIteratorHelper(this.buttons),
+          _step;
+
+      try {
+        var _loop = function _loop() {
+          var _step$value = _step.value,
+              element = _step$value.element,
+              eventName = _step$value.eventName;
+          element.addEventListener("click", function (evt) {
+            if (eventName !== null) {
+              _this.eventBus.dispatch(eventName, {
+                source: _this
+              });
+            }
           });
-        }
-      });
-    }
+        };
 
-    pageNumber.addEventListener("click", function () {
-      this.select();
-    });
-    pageNumber.addEventListener("change", function () {
-      self.eventBus.dispatch("pagenumberchanged", {
-        source: self,
-        value: this.value
-      });
-    });
-    scaleSelect.addEventListener("change", function () {
-      if (this.value === "custom") {
-        return;
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
 
-      self.eventBus.dispatch("scalechanged", {
-        source: self,
-        value: this.value
+      pageNumber.addEventListener("click", function () {
+        this.select();
       });
-    });
-    scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;
+      pageNumber.addEventListener("change", function () {
+        self.eventBus.dispatch("pagenumberchanged", {
+          source: self,
+          value: this.value
+        });
+      });
+      scaleSelect.addEventListener("change", function () {
+        if (this.value === "custom") {
+          return;
+        }
 
-    this.eventBus._on("localized", () => {
-      this._wasLocalized = true;
+        self.eventBus.dispatch("scalechanged", {
+          source: self,
+          value: this.value
+        });
+      });
+      scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;
 
-      this._adjustScaleWidth();
+      this.eventBus._on("localized", function () {
+        _this._wasLocalized = true;
 
-      this._updateUIState(true);
-    });
-  }
+        _this._adjustScaleWidth();
 
-  _updateUIState(resetNumPages = false) {
-    if (!this._wasLocalized) {
-      return;
+        _this._updateUIState(true);
+      });
     }
+  }, {
+    key: "_updateUIState",
+    value: function _updateUIState() {
+      var resetNumPages = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
-    const {
-      pageNumber,
-      pagesCount,
-      pageScaleValue,
-      pageScale,
-      items
-    } = this;
-
-    if (resetNumPages) {
-      if (this.hasPageLabels) {
-        items.pageNumber.type = "text";
-      } else {
-        items.pageNumber.type = "number";
-        this.l10n.get("of_pages", {
-          pagesCount
-        }, "of {{pagesCount}}").then(msg => {
-          items.numPages.textContent = msg;
-        });
+      if (!this._wasLocalized) {
+        return;
       }
 
-      items.pageNumber.max = pagesCount;
-    }
+      var pageNumber = this.pageNumber,
+          pagesCount = this.pagesCount,
+          pageScaleValue = this.pageScaleValue,
+          pageScale = this.pageScale,
+          items = this.items;
 
-    if (this.hasPageLabels) {
-      items.pageNumber.value = this.pageLabel;
-      this.l10n.get("page_of_pages", {
-        pageNumber,
-        pagesCount
-      }, "({{pageNumber}} of {{pagesCount}})").then(msg => {
-        items.numPages.textContent = msg;
-      });
-    } else {
-      items.pageNumber.value = pageNumber;
-    }
-
-    items.previous.disabled = pageNumber <= 1;
-    items.next.disabled = pageNumber >= pagesCount;
-    items.zoomOut.disabled = pageScale <= _ui_utils.MIN_SCALE;
-    items.zoomIn.disabled = pageScale >= _ui_utils.MAX_SCALE;
-    const customScale = Math.round(pageScale * 10000) / 100;
-    this.l10n.get("page_scale_percent", {
-      scale: customScale
-    }, "{{scale}}%").then(msg => {
-      let predefinedValueFound = false;
-
-      for (const option of items.scaleSelect.options) {
-        if (option.value !== pageScaleValue) {
-          option.selected = false;
-          continue;
+      if (resetNumPages) {
+        if (this.hasPageLabels) {
+          items.pageNumber.type = "text";
+        } else {
+          items.pageNumber.type = "number";
+          this.l10n.get("of_pages", {
+            pagesCount: pagesCount
+          }, "of {{pagesCount}}").then(function (msg) {
+            items.numPages.textContent = msg;
+          });
         }
 
-        option.selected = true;
-        predefinedValueFound = true;
+        items.pageNumber.max = pagesCount;
       }
 
-      if (!predefinedValueFound) {
-        items.customScaleOption.textContent = msg;
-        items.customScaleOption.selected = true;
+      if (this.hasPageLabels) {
+        items.pageNumber.value = this.pageLabel;
+        this.l10n.get("page_of_pages", {
+          pageNumber: pageNumber,
+          pagesCount: pagesCount
+        }, "({{pageNumber}} of {{pagesCount}})").then(function (msg) {
+          items.numPages.textContent = msg;
+        });
+      } else {
+        items.pageNumber.value = pageNumber;
       }
-    });
-  }
 
-  updateLoadingIndicatorState(loading = false) {
-    const pageNumberInput = this.items.pageNumber;
-    pageNumberInput.classList.toggle(PAGE_NUMBER_LOADING_INDICATOR, loading);
-  }
+      items.previous.disabled = pageNumber <= 1;
+      items.next.disabled = pageNumber >= pagesCount;
+      items.zoomOut.disabled = pageScale <= _ui_utils.MIN_SCALE;
+      items.zoomIn.disabled = pageScale >= _ui_utils.MAX_SCALE;
+      var customScale = Math.round(pageScale * 10000) / 100;
+      this.l10n.get("page_scale_percent", {
+        scale: customScale
+      }, "{{scale}}%").then(function (msg) {
+        var predefinedValueFound = false;
 
-  async _adjustScaleWidth() {
-    const {
-      items,
-      l10n
-    } = this;
-    const predefinedValuesPromise = Promise.all([l10n.get("page_scale_auto", null, "Automatic Zoom"), l10n.get("page_scale_actual", null, "Actual Size"), l10n.get("page_scale_fit", null, "Page Fit"), l10n.get("page_scale_width", null, "Page Width")]);
-    let canvas = document.createElement("canvas");
-    canvas.mozOpaque = true;
-    let ctx = canvas.getContext("2d", {
-      alpha: false
-    });
-    await _ui_utils.animationStarted;
-    const {
-      fontSize,
-      fontFamily
-    } = getComputedStyle(items.scaleSelect);
-    ctx.font = `${fontSize} ${fontFamily}`;
-    let maxWidth = 0;
+        var _iterator2 = _createForOfIteratorHelper(items.scaleSelect.options),
+            _step2;
 
-    for (const predefinedValue of await predefinedValuesPromise) {
-      const {
-        width
-      } = ctx.measureText(predefinedValue);
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var option = _step2.value;
 
-      if (width > maxWidth) {
-        maxWidth = width;
-      }
-    }
+            if (option.value !== pageScaleValue) {
+              option.selected = false;
+              continue;
+            }
 
-    const overflow = SCALE_SELECT_WIDTH - SCALE_SELECT_CONTAINER_WIDTH;
-    maxWidth += 1.5 * overflow;
+            option.selected = true;
+            predefinedValueFound = true;
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
 
-    if (maxWidth > SCALE_SELECT_CONTAINER_WIDTH) {
-      items.scaleSelect.style.width = `${maxWidth + overflow}px`;
-      items.scaleSelectContainer.style.width = `${maxWidth}px`;
+        if (!predefinedValueFound) {
+          items.customScaleOption.textContent = msg;
+          items.customScaleOption.selected = true;
+        }
+      });
     }
+  }, {
+    key: "updateLoadingIndicatorState",
+    value: function updateLoadingIndicatorState() {
+      var loading = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var pageNumberInput = this.items.pageNumber;
+      pageNumberInput.classList.toggle(PAGE_NUMBER_LOADING_INDICATOR, loading);
+    }
+  }, {
+    key: "_adjustScaleWidth",
+    value: function () {
+      var _adjustScaleWidth2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var items, l10n, predefinedValuesPromise, canvas, ctx, _getComputedStyle, fontSize, fontFamily, maxWidth, _iterator3, _step3, predefinedValue, _ctx$measureText, width, overflow;
+
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                items = this.items, l10n = this.l10n;
+                predefinedValuesPromise = Promise.all([l10n.get("page_scale_auto", null, "Automatic Zoom"), l10n.get("page_scale_actual", null, "Actual Size"), l10n.get("page_scale_fit", null, "Page Fit"), l10n.get("page_scale_width", null, "Page Width")]);
+                canvas = document.createElement("canvas");
+                canvas.mozOpaque = true;
+                ctx = canvas.getContext("2d", {
+                  alpha: false
+                });
+                _context.next = 7;
+                return _ui_utils.animationStarted;
+
+              case 7:
+                _getComputedStyle = getComputedStyle(items.scaleSelect), fontSize = _getComputedStyle.fontSize, fontFamily = _getComputedStyle.fontFamily;
+                ctx.font = "".concat(fontSize, " ").concat(fontFamily);
+                maxWidth = 0;
+                _context.t0 = _createForOfIteratorHelper;
+                _context.next = 13;
+                return predefinedValuesPromise;
+
+              case 13:
+                _context.t1 = _context.sent;
+                _iterator3 = (0, _context.t0)(_context.t1);
+
+                try {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                    predefinedValue = _step3.value;
+                    _ctx$measureText = ctx.measureText(predefinedValue), width = _ctx$measureText.width;
+
+                    if (width > maxWidth) {
+                      maxWidth = width;
+                    }
+                  }
+                } catch (err) {
+                  _iterator3.e(err);
+                } finally {
+                  _iterator3.f();
+                }
+
+                overflow = SCALE_SELECT_WIDTH - SCALE_SELECT_CONTAINER_WIDTH;
+                maxWidth += 1.5 * overflow;
+
+                if (maxWidth > SCALE_SELECT_CONTAINER_WIDTH) {
+                  items.scaleSelect.style.width = "".concat(maxWidth + overflow, "px");
+                  items.scaleSelectContainer.style.width = "".concat(maxWidth, "px");
+                }
+
+                canvas.width = 0;
+                canvas.height = 0;
+                canvas = ctx = null;
+
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    canvas.width = 0;
-    canvas.height = 0;
-    canvas = ctx = null;
-  }
+      function _adjustScaleWidth() {
+        return _adjustScaleWidth2.apply(this, arguments);
+      }
 
-}
+      return _adjustScaleWidth;
+    }()
+  }]);
+
+  return Toolbar;
+}();
 
 exports.Toolbar = Toolbar;
 
 /***/ }),
-/* 32 */
+/* 35 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11726,27 +14147,48 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ViewHistory = void 0;
-const DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
 
-class ViewHistory {
-  constructor(fingerprint, cacheSize = DEFAULT_VIEW_HISTORY_CACHE_SIZE) {
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
+
+var ViewHistory = /*#__PURE__*/function () {
+  function ViewHistory(fingerprint) {
+    var _this = this;
+
+    var cacheSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_VIEW_HISTORY_CACHE_SIZE;
+
+    _classCallCheck(this, ViewHistory);
+
     this.fingerprint = fingerprint;
     this.cacheSize = cacheSize;
-    this._initializedPromise = this._readFromStorage().then(databaseStr => {
-      const database = JSON.parse(databaseStr || "{}");
-      let index = -1;
+    this._initializedPromise = this._readFromStorage().then(function (databaseStr) {
+      var database = JSON.parse(databaseStr || "{}");
+      var index = -1;
 
       if (!Array.isArray(database.files)) {
         database.files = [];
       } else {
-        while (database.files.length >= this.cacheSize) {
+        while (database.files.length >= _this.cacheSize) {
           database.files.shift();
         }
 
-        for (let i = 0, ii = database.files.length; i < ii; i++) {
-          const branch = database.files[i];
+        for (var i = 0, ii = database.files.length; i < ii; i++) {
+          var branch = database.files[i];
 
-          if (branch.fingerprint === this.fingerprint) {
+          if (branch.fingerprint === _this.fingerprint) {
             index = i;
             break;
           }
@@ -11755,64 +14197,202 @@ class ViewHistory {
 
       if (index === -1) {
         index = database.files.push({
-          fingerprint: this.fingerprint
+          fingerprint: _this.fingerprint
         }) - 1;
       }
 
-      this.file = database.files[index];
-      this.database = database;
+      _this.file = database.files[index];
+      _this.database = database;
     });
   }
 
-  async _writeToStorage() {
-    const databaseStr = JSON.stringify(this.database);
-    localStorage.setItem("pdfjs.history", databaseStr);
-  }
+  _createClass(ViewHistory, [{
+    key: "_writeToStorage",
+    value: function () {
+      var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var databaseStr;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                databaseStr = JSON.stringify(this.database);
+                localStorage.setItem("pdfjs.history", databaseStr);
 
-  async _readFromStorage() {
-    return localStorage.getItem("pdfjs.history");
-  }
-
-  async set(name, val) {
-    await this._initializedPromise;
-    this.file[name] = val;
-    return this._writeToStorage();
-  }
-
-  async setMultiple(properties) {
-    await this._initializedPromise;
-
-    for (const name in properties) {
-      this.file[name] = properties[name];
-    }
-
-    return this._writeToStorage();
-  }
-
-  async get(name, defaultValue) {
-    await this._initializedPromise;
-    const val = this.file[name];
-    return val !== undefined ? val : defaultValue;
-  }
-
-  async getMultiple(properties) {
-    await this._initializedPromise;
-    const values = Object.create(null);
+              case 2:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function _writeToStorage() {
+        return _writeToStorage2.apply(this, arguments);
+      }
+
+      return _writeToStorage;
+    }()
+  }, {
+    key: "_readFromStorage",
+    value: function () {
+      var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", localStorage.getItem("pdfjs.history"));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function _readFromStorage() {
+        return _readFromStorage2.apply(this, arguments);
+      }
+
+      return _readFromStorage;
+    }()
+  }, {
+    key: "set",
+    value: function () {
+      var _set = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3(name, val) {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                this.file[name] = val;
+                return _context3.abrupt("return", this._writeToStorage());
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function set(_x, _x2) {
+        return _set.apply(this, arguments);
+      }
+
+      return set;
+    }()
+  }, {
+    key: "setMultiple",
+    value: function () {
+      var _setMultiple = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4(properties) {
+        var name;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                for (name in properties) {
+                  this.file[name] = properties[name];
+                }
+
+                return _context4.abrupt("return", this._writeToStorage());
+
+              case 4:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+
+      function setMultiple(_x3) {
+        return _setMultiple.apply(this, arguments);
+      }
+
+      return setMultiple;
+    }()
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee5(name, defaultValue) {
+        var val;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                val = this.file[name];
+                return _context5.abrupt("return", val !== undefined ? val : defaultValue);
+
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function get(_x4, _x5) {
+        return _get.apply(this, arguments);
+      }
+
+      return get;
+    }()
+  }, {
+    key: "getMultiple",
+    value: function () {
+      var _getMultiple = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee6(properties) {
+        var values, name, val;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                values = Object.create(null);
+
+                for (name in properties) {
+                  val = this.file[name];
+                  values[name] = val !== undefined ? val : properties[name];
+                }
+
+                return _context6.abrupt("return", values);
+
+              case 5:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
 
-    for (const name in properties) {
-      const val = this.file[name];
-      values[name] = val !== undefined ? val : properties[name];
-    }
+      function getMultiple(_x6) {
+        return _getMultiple.apply(this, arguments);
+      }
 
-    return values;
-  }
+      return getMultiple;
+    }()
+  }]);
 
-}
+  return ViewHistory;
+}();
 
 exports.ViewHistory = ViewHistory;
 
 /***/ }),
-/* 33 */
+/* 36 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11823,50 +14403,149 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.GenericCom = void 0;
 
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
 var _app = __webpack_require__(1);
 
-var _preferences = __webpack_require__(34);
+var _preferences = __webpack_require__(37);
 
-var _download_manager = __webpack_require__(35);
+var _download_manager = __webpack_require__(38);
 
-var _genericl10n = __webpack_require__(36);
+var _genericl10n = __webpack_require__(39);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 ;
-const GenericCom = {};
+var GenericCom = {};
 exports.GenericCom = GenericCom;
 
-class GenericPreferences extends _preferences.BasePreferences {
-  async _writeToStorage(prefObj) {
-    localStorage.setItem("pdfjs.preferences", JSON.stringify(prefObj));
-  }
+var GenericPreferences = /*#__PURE__*/function (_BasePreferences) {
+  _inherits(GenericPreferences, _BasePreferences);
 
-  async _readFromStorage(prefObj) {
-    return JSON.parse(localStorage.getItem("pdfjs.preferences"));
-  }
+  var _super = _createSuper(GenericPreferences);
 
-}
+  function GenericPreferences() {
+    _classCallCheck(this, GenericPreferences);
 
-class GenericExternalServices extends _app.DefaultExternalServices {
-  static createDownloadManager(options) {
-    return new _download_manager.DownloadManager(options);
+    return _super.apply(this, arguments);
   }
 
-  static createPreferences() {
-    return new GenericPreferences();
-  }
+  _createClass(GenericPreferences, [{
+    key: "_writeToStorage",
+    value: function () {
+      var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(prefObj) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                localStorage.setItem("pdfjs.preferences", JSON.stringify(prefObj));
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function _writeToStorage(_x) {
+        return _writeToStorage2.apply(this, arguments);
+      }
+
+      return _writeToStorage;
+    }()
+  }, {
+    key: "_readFromStorage",
+    value: function () {
+      var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(prefObj) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", JSON.parse(localStorage.getItem("pdfjs.preferences")));
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
 
-  static createL10n({
-    locale = "en-US"
-  }) {
-    return new _genericl10n.GenericL10n(locale);
+      function _readFromStorage(_x2) {
+        return _readFromStorage2.apply(this, arguments);
+      }
+
+      return _readFromStorage;
+    }()
+  }]);
+
+  return GenericPreferences;
+}(_preferences.BasePreferences);
+
+var GenericExternalServices = /*#__PURE__*/function (_DefaultExternalServi) {
+  _inherits(GenericExternalServices, _DefaultExternalServi);
+
+  var _super2 = _createSuper(GenericExternalServices);
+
+  function GenericExternalServices() {
+    _classCallCheck(this, GenericExternalServices);
+
+    return _super2.apply(this, arguments);
   }
 
-}
+  _createClass(GenericExternalServices, null, [{
+    key: "createDownloadManager",
+    value: function createDownloadManager(options) {
+      return new _download_manager.DownloadManager(options);
+    }
+  }, {
+    key: "createPreferences",
+    value: function createPreferences() {
+      return new GenericPreferences();
+    }
+  }, {
+    key: "createL10n",
+    value: function createL10n(_ref) {
+      var _ref$locale = _ref.locale,
+          locale = _ref$locale === void 0 ? "en-US" : _ref$locale;
+      return new _genericl10n.GenericL10n(locale);
+    }
+  }]);
+
+  return GenericExternalServices;
+}(_app.DefaultExternalServices);
 
 _app.PDFViewerApplication.externalServices = GenericExternalServices;
 
 /***/ }),
-/* 34 */
+/* 37 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -11877,9 +14556,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BasePreferences = void 0;
 
-var _app_options = __webpack_require__(3);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+var _app_options = __webpack_require__(6);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
-let defaultPreferences = null;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var defaultPreferences = null;
 
 function getDefaultPreferences() {
   if (!defaultPreferences) {
@@ -11912,111 +14607,288 @@ function getDefaultPreferences() {
   return defaultPreferences;
 }
 
-class BasePreferences {
-  constructor() {
+var BasePreferences = /*#__PURE__*/function () {
+  function BasePreferences() {
+    var _this = this;
+
+    _classCallCheck(this, BasePreferences);
+
     if (this.constructor === BasePreferences) {
       throw new Error("Cannot initialize BasePreferences.");
     }
 
     this.prefs = null;
-    this._initializedPromise = getDefaultPreferences().then(defaults => {
-      Object.defineProperty(this, "defaults", {
+    this._initializedPromise = getDefaultPreferences().then(function (defaults) {
+      Object.defineProperty(_this, "defaults", {
         value: Object.freeze(defaults),
         writable: false,
         enumerable: true,
         configurable: false
       });
-      this.prefs = Object.assign(Object.create(null), defaults);
-      return this._readFromStorage(defaults);
-    }).then(prefs => {
+      _this.prefs = Object.assign(Object.create(null), defaults);
+      return _this._readFromStorage(defaults);
+    }).then(function (prefs) {
       if (!prefs) {
         return;
       }
 
-      for (const name in prefs) {
-        const defaultValue = this.defaults[name],
-              prefValue = prefs[name];
+      for (var name in prefs) {
+        var defaultValue = _this.defaults[name],
+            prefValue = prefs[name];
 
-        if (defaultValue === undefined || typeof prefValue !== typeof defaultValue) {
+        if (defaultValue === undefined || _typeof(prefValue) !== _typeof(defaultValue)) {
           continue;
         }
 
-        this.prefs[name] = prefValue;
+        _this.prefs[name] = prefValue;
       }
     });
   }
 
-  async _writeToStorage(prefObj) {
-    throw new Error("Not implemented: _writeToStorage");
-  }
+  _createClass(BasePreferences, [{
+    key: "_writeToStorage",
+    value: function () {
+      var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(prefObj) {
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                throw new Error("Not implemented: _writeToStorage");
 
-  async _readFromStorage(prefObj) {
-    throw new Error("Not implemented: _readFromStorage");
-  }
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function _writeToStorage(_x) {
+        return _writeToStorage2.apply(this, arguments);
+      }
+
+      return _writeToStorage;
+    }()
+  }, {
+    key: "_readFromStorage",
+    value: function () {
+      var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(prefObj) {
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                throw new Error("Not implemented: _readFromStorage");
+
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function _readFromStorage(_x2) {
+        return _readFromStorage2.apply(this, arguments);
+      }
+
+      return _readFromStorage;
+    }()
+  }, {
+    key: "reset",
+    value: function () {
+      var _reset = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                this.prefs = Object.assign(Object.create(null), this.defaults);
+                return _context3.abrupt("return", this._writeToStorage(this.defaults));
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function reset() {
+        return _reset.apply(this, arguments);
+      }
+
+      return reset;
+    }()
+  }, {
+    key: "set",
+    value: function () {
+      var _set = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4(name, value) {
+        var defaultValue, valueType, defaultType;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                defaultValue = this.defaults[name];
+
+                if (!(defaultValue === undefined)) {
+                  _context4.next = 7;
+                  break;
+                }
+
+                throw new Error("Set preference: \"".concat(name, "\" is undefined."));
+
+              case 7:
+                if (!(value === undefined)) {
+                  _context4.next = 9;
+                  break;
+                }
+
+                throw new Error("Set preference: no value is specified.");
+
+              case 9:
+                valueType = _typeof(value);
+                defaultType = _typeof(defaultValue);
+
+                if (!(valueType !== defaultType)) {
+                  _context4.next = 19;
+                  break;
+                }
+
+                if (!(valueType === "number" && defaultType === "string")) {
+                  _context4.next = 16;
+                  break;
+                }
+
+                value = value.toString();
+                _context4.next = 17;
+                break;
+
+              case 16:
+                throw new Error("Set preference: \"".concat(value, "\" is a ").concat(valueType, ", ") + "expected a ".concat(defaultType, "."));
+
+              case 17:
+                _context4.next = 21;
+                break;
+
+              case 19:
+                if (!(valueType === "number" && !Number.isInteger(value))) {
+                  _context4.next = 21;
+                  break;
+                }
+
+                throw new Error("Set preference: \"".concat(value, "\" must be an integer."));
+
+              case 21:
+                this.prefs[name] = value;
+                return _context4.abrupt("return", this._writeToStorage(this.prefs));
+
+              case 23:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
 
-  async reset() {
-    await this._initializedPromise;
-    this.prefs = Object.assign(Object.create(null), this.defaults);
-    return this._writeToStorage(this.defaults);
-  }
+      function set(_x3, _x4) {
+        return _set.apply(this, arguments);
+      }
 
-  async set(name, value) {
-    await this._initializedPromise;
-    const defaultValue = this.defaults[name];
+      return set;
+    }()
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee5(name) {
+        var defaultValue, prefValue;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return this._initializedPromise;
 
-    if (defaultValue === undefined) {
-      throw new Error(`Set preference: "${name}" is undefined.`);
-    } else if (value === undefined) {
-      throw new Error("Set preference: no value is specified.");
-    }
+              case 2:
+                defaultValue = this.defaults[name];
 
-    const valueType = typeof value;
-    const defaultType = typeof defaultValue;
+                if (!(defaultValue === undefined)) {
+                  _context5.next = 7;
+                  break;
+                }
 
-    if (valueType !== defaultType) {
-      if (valueType === "number" && defaultType === "string") {
-        value = value.toString();
-      } else {
-        throw new Error(`Set preference: "${value}" is a ${valueType}, ` + `expected a ${defaultType}.`);
-      }
-    } else {
-      if (valueType === "number" && !Number.isInteger(value)) {
-        throw new Error(`Set preference: "${value}" must be an integer.`);
-      }
-    }
+                throw new Error("Get preference: \"".concat(name, "\" is undefined."));
 
-    this.prefs[name] = value;
-    return this._writeToStorage(this.prefs);
-  }
+              case 7:
+                prefValue = this.prefs[name];
 
-  async get(name) {
-    await this._initializedPromise;
-    const defaultValue = this.defaults[name];
+                if (!(prefValue !== undefined)) {
+                  _context5.next = 10;
+                  break;
+                }
 
-    if (defaultValue === undefined) {
-      throw new Error(`Get preference: "${name}" is undefined.`);
-    } else {
-      const prefValue = this.prefs[name];
+                return _context5.abrupt("return", prefValue);
 
-      if (prefValue !== undefined) {
-        return prefValue;
-      }
-    }
+              case 10:
+                return _context5.abrupt("return", defaultValue);
 
-    return defaultValue;
-  }
+              case 11:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function get(_x5) {
+        return _get.apply(this, arguments);
+      }
+
+      return get;
+    }()
+  }, {
+    key: "getAll",
+    value: function () {
+      var _getAll = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _context6.next = 2;
+                return this._initializedPromise;
+
+              case 2:
+                return _context6.abrupt("return", Object.assign(Object.create(null), this.defaults, this.prefs));
+
+              case 3:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this);
+      }));
 
-  async getAll() {
-    await this._initializedPromise;
-    return Object.assign(Object.create(null), this.defaults, this.prefs);
-  }
+      function getAll() {
+        return _getAll.apply(this, arguments);
+      }
 
-}
+      return getAll;
+    }()
+  }]);
+
+  return BasePreferences;
+}();
 
 exports.BasePreferences = BasePreferences;
 
 /***/ }),
-/* 35 */
+/* 38 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -12027,15 +14899,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DownloadManager = void 0;
 
-var _pdfjsLib = __webpack_require__(5);
+var _pdfjsLib = __webpack_require__(8);
 
-var _viewer_compatibility = __webpack_require__(4);
+var _viewer_compatibility = __webpack_require__(7);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
 ;
-const DISABLE_CREATE_OBJECT_URL = _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL || false;
+var DISABLE_CREATE_OBJECT_URL = _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL || false;
 
-function download(blobUrl, filename) {
-  const a = document.createElement("a");
+function _download(blobUrl, filename) {
+  var a = document.createElement("a");
 
   if (!a.click) {
     throw new Error('DownloadManager: "a.click()" is not supported.');
@@ -12053,57 +14931,68 @@ function download(blobUrl, filename) {
   a.remove();
 }
 
-class DownloadManager {
-  constructor({
-    disableCreateObjectURL = DISABLE_CREATE_OBJECT_URL
-  }) {
+var DownloadManager = /*#__PURE__*/function () {
+  function DownloadManager(_ref) {
+    var _ref$disableCreateObj = _ref.disableCreateObjectURL,
+        disableCreateObjectURL = _ref$disableCreateObj === void 0 ? DISABLE_CREATE_OBJECT_URL : _ref$disableCreateObj;
+
+    _classCallCheck(this, DownloadManager);
+
     this.disableCreateObjectURL = disableCreateObjectURL;
   }
 
-  downloadUrl(url, filename) {
-    if (!(0, _pdfjsLib.createValidAbsoluteUrl)(url, "http://example.com")) {
-      return;
+  _createClass(DownloadManager, [{
+    key: "downloadUrl",
+    value: function downloadUrl(url, filename) {
+      if (!(0, _pdfjsLib.createValidAbsoluteUrl)(url, "http://example.com")) {
+        return;
+      }
+
+      _download(url + "#pdfjs.action=download", filename);
     }
+  }, {
+    key: "downloadData",
+    value: function downloadData(data, filename, contentType) {
+      if (navigator.msSaveBlob) {
+        navigator.msSaveBlob(new Blob([data], {
+          type: contentType
+        }), filename);
+        return;
+      }
 
-    download(url + "#pdfjs.action=download", filename);
-  }
+      var blobUrl = (0, _pdfjsLib.createObjectURL)(data, contentType, this.disableCreateObjectURL);
 
-  downloadData(data, filename, contentType) {
-    if (navigator.msSaveBlob) {
-      navigator.msSaveBlob(new Blob([data], {
-        type: contentType
-      }), filename);
-      return;
+      _download(blobUrl, filename);
     }
+  }, {
+    key: "download",
+    value: function download(blob, url, filename) {
+      if (navigator.msSaveBlob) {
+        if (!navigator.msSaveBlob(blob, filename)) {
+          this.downloadUrl(url, filename);
+        }
 
-    const blobUrl = (0, _pdfjsLib.createObjectURL)(data, contentType, this.disableCreateObjectURL);
-    download(blobUrl, filename);
-  }
+        return;
+      }
 
-  download(blob, url, filename) {
-    if (navigator.msSaveBlob) {
-      if (!navigator.msSaveBlob(blob, filename)) {
+      if (this.disableCreateObjectURL) {
         this.downloadUrl(url, filename);
+        return;
       }
 
-      return;
-    }
+      var blobUrl = URL.createObjectURL(blob);
 
-    if (this.disableCreateObjectURL) {
-      this.downloadUrl(url, filename);
-      return;
+      _download(blobUrl, filename);
     }
+  }]);
 
-    const blobUrl = URL.createObjectURL(blob);
-    download(blobUrl, filename);
-  }
-
-}
+  return DownloadManager;
+}();
 
 exports.DownloadManager = DownloadManager;
 
 /***/ }),
-/* 36 */
+/* 39 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -12114,46 +15003,165 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.GenericL10n = void 0;
 
-__webpack_require__(37);
+var _regenerator = _interopRequireDefault(__webpack_require__(2));
+
+__webpack_require__(40);
 
-const webL10n = document.webL10n;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var webL10n = document.webL10n;
+
+var GenericL10n = /*#__PURE__*/function () {
+  function GenericL10n(lang) {
+    _classCallCheck(this, GenericL10n);
 
-class GenericL10n {
-  constructor(lang) {
     this._lang = lang;
-    this._ready = new Promise((resolve, reject) => {
-      webL10n.setLanguage(lang, () => {
+    this._ready = new Promise(function (resolve, reject) {
+      webL10n.setLanguage(lang, function () {
         resolve(webL10n);
       });
     });
   }
 
-  async getLanguage() {
-    const l10n = await this._ready;
-    return l10n.getLanguage();
-  }
+  _createClass(GenericL10n, [{
+    key: "getLanguage",
+    value: function () {
+      var _getLanguage = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var l10n;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this._ready;
 
-  async getDirection() {
-    const l10n = await this._ready;
-    return l10n.getDirection();
-  }
+              case 2:
+                l10n = _context.sent;
+                return _context.abrupt("return", l10n.getLanguage());
 
-  async get(property, args, fallback) {
-    const l10n = await this._ready;
-    return l10n.get(property, args, fallback);
-  }
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getLanguage() {
+        return _getLanguage.apply(this, arguments);
+      }
+
+      return getLanguage;
+    }()
+  }, {
+    key: "getDirection",
+    value: function () {
+      var _getDirection = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var l10n;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return this._ready;
+
+              case 2:
+                l10n = _context2.sent;
+                return _context2.abrupt("return", l10n.getDirection());
+
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function getDirection() {
+        return _getDirection.apply(this, arguments);
+      }
+
+      return getDirection;
+    }()
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3(property, args, fallback) {
+        var l10n;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this._ready;
+
+              case 2:
+                l10n = _context3.sent;
+                return _context3.abrupt("return", l10n.get(property, args, fallback));
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function get(_x, _x2, _x3) {
+        return _get.apply(this, arguments);
+      }
+
+      return get;
+    }()
+  }, {
+    key: "translate",
+    value: function () {
+      var _translate = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee4(element) {
+        var l10n;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return this._ready;
+
+              case 2:
+                l10n = _context4.sent;
+                return _context4.abrupt("return", l10n.translate(element));
+
+              case 4:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
 
-  async translate(element) {
-    const l10n = await this._ready;
-    return l10n.translate(element);
-  }
+      function translate(_x4) {
+        return _translate.apply(this, arguments);
+      }
 
-}
+      return translate;
+    }()
+  }]);
+
+  return GenericL10n;
+}();
 
 exports.GenericL10n = GenericL10n;
 
 /***/ }),
-/* 37 */
+/* 40 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -12386,7 +15394,7 @@ document.webL10n = function (window, document, undefined) {
     var onResourceLoaded = null;
     var gResourceCount = 0;
 
-    onResourceLoaded = function () {
+    onResourceLoaded = function onResourceLoaded() {
       gResourceCount++;
 
       if (gResourceCount >= langCount) {
@@ -12603,10 +15611,10 @@ document.webL10n = function (window, document, undefined) {
     }
 
     var pluralRules = {
-      '0': function (n) {
+      '0': function _(n) {
         return 'other';
       },
-      '1': function (n) {
+      '1': function _(n) {
         if (isBetween(n % 100, 3, 10)) return 'few';
         if (n === 0) return 'zero';
         if (isBetween(n % 100, 11, 99)) return 'many';
@@ -12614,85 +15622,85 @@ document.webL10n = function (window, document, undefined) {
         if (n == 1) return 'one';
         return 'other';
       },
-      '2': function (n) {
+      '2': function _(n) {
         if (n !== 0 && n % 10 === 0) return 'many';
         if (n == 2) return 'two';
         if (n == 1) return 'one';
         return 'other';
       },
-      '3': function (n) {
+      '3': function _(n) {
         if (n == 1) return 'one';
         return 'other';
       },
-      '4': function (n) {
+      '4': function _(n) {
         if (isBetween(n, 0, 1)) return 'one';
         return 'other';
       },
-      '5': function (n) {
+      '5': function _(n) {
         if (isBetween(n, 0, 2) && n != 2) return 'one';
         return 'other';
       },
-      '6': function (n) {
+      '6': function _(n) {
         if (n === 0) return 'zero';
         if (n % 10 == 1 && n % 100 != 11) return 'one';
         return 'other';
       },
-      '7': function (n) {
+      '7': function _(n) {
         if (n == 2) return 'two';
         if (n == 1) return 'one';
         return 'other';
       },
-      '8': function (n) {
+      '8': function _(n) {
         if (isBetween(n, 3, 6)) return 'few';
         if (isBetween(n, 7, 10)) return 'many';
         if (n == 2) return 'two';
         if (n == 1) return 'one';
         return 'other';
       },
-      '9': function (n) {
+      '9': function _(n) {
         if (n === 0 || n != 1 && isBetween(n % 100, 1, 19)) return 'few';
         if (n == 1) return 'one';
         return 'other';
       },
-      '10': function (n) {
+      '10': function _(n) {
         if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19)) return 'few';
         if (n % 10 == 1 && !isBetween(n % 100, 11, 19)) return 'one';
         return 'other';
       },
-      '11': function (n) {
+      '11': function _(n) {
         if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few';
         if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n % 100, 11, 14)) return 'many';
         if (n % 10 == 1 && n % 100 != 11) return 'one';
         return 'other';
       },
-      '12': function (n) {
+      '12': function _(n) {
         if (isBetween(n, 2, 4)) return 'few';
         if (n == 1) return 'one';
         return 'other';
       },
-      '13': function (n) {
+      '13': function _(n) {
         if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few';
         if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) || isBetween(n % 100, 12, 14)) return 'many';
         if (n == 1) return 'one';
         return 'other';
       },
-      '14': function (n) {
+      '14': function _(n) {
         if (isBetween(n % 100, 3, 4)) return 'few';
         if (n % 100 == 2) return 'two';
         if (n % 100 == 1) return 'one';
         return 'other';
       },
-      '15': function (n) {
+      '15': function _(n) {
         if (n === 0 || isBetween(n % 100, 2, 10)) return 'few';
         if (isBetween(n % 100, 11, 19)) return 'many';
         if (n == 1) return 'one';
         return 'other';
       },
-      '16': function (n) {
+      '16': function _(n) {
         if (n % 10 == 1 && n != 11) return 'one';
         return 'other';
       },
-      '17': function (n) {
+      '17': function _(n) {
         if (n == 3) return 'few';
         if (n === 0) return 'zero';
         if (n == 6) return 'many';
@@ -12700,37 +15708,37 @@ document.webL10n = function (window, document, undefined) {
         if (n == 1) return 'one';
         return 'other';
       },
-      '18': function (n) {
+      '18': function _(n) {
         if (n === 0) return 'zero';
         if (isBetween(n, 0, 2) && n !== 0 && n != 2) return 'one';
         return 'other';
       },
-      '19': function (n) {
+      '19': function _(n) {
         if (isBetween(n, 2, 10)) return 'few';
         if (isBetween(n, 0, 1)) return 'one';
         return 'other';
       },
-      '20': function (n) {
+      '20': function _(n) {
         if ((isBetween(n % 10, 3, 4) || n % 10 == 9) && !(isBetween(n % 100, 10, 19) || isBetween(n % 100, 70, 79) || isBetween(n % 100, 90, 99))) return 'few';
         if (n % 1000000 === 0 && n !== 0) return 'many';
         if (n % 10 == 2 && !isIn(n % 100, [12, 72, 92])) return 'two';
         if (n % 10 == 1 && !isIn(n % 100, [11, 71, 91])) return 'one';
         return 'other';
       },
-      '21': function (n) {
+      '21': function _(n) {
         if (n === 0) return 'zero';
         if (n == 1) return 'one';
         return 'other';
       },
-      '22': function (n) {
+      '22': function _(n) {
         if (isBetween(n, 0, 1) || isBetween(n, 11, 99)) return 'one';
         return 'other';
       },
-      '23': function (n) {
+      '23': function _(n) {
         if (isBetween(n % 10, 1, 2) || n % 20 === 0) return 'one';
         return 'other';
       },
-      '24': function (n) {
+      '24': function _(n) {
         if (isBetween(n, 3, 10) || isBetween(n, 13, 19)) return 'few';
         if (isIn(n, [2, 12])) return 'two';
         if (isIn(n, [1, 11])) return 'one';
@@ -12911,7 +15919,7 @@ document.webL10n = function (window, document, undefined) {
   }
 
   return {
-    get: function (key, args, fallbackString) {
+    get: function get(key, args, fallbackString) {
       var index = key.lastIndexOf('.');
       var prop = gTextProp;
 
@@ -12935,30 +15943,30 @@ document.webL10n = function (window, document, undefined) {
 
       return '{{' + key + '}}';
     },
-    getData: function () {
+    getData: function getData() {
       return gL10nData;
     },
-    getText: function () {
+    getText: function getText() {
       return gTextData;
     },
-    getLanguage: function () {
+    getLanguage: function getLanguage() {
       return gLanguage;
     },
-    setLanguage: function (lang, callback) {
+    setLanguage: function setLanguage(lang, callback) {
       loadLocale(lang, function () {
         if (callback) callback();
       });
     },
-    getDirection: function () {
+    getDirection: function getDirection() {
       var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
       var shortCode = gLanguage.split('-', 1)[0];
       return rtlList.indexOf(shortCode) >= 0 ? 'rtl' : 'ltr';
     },
     translate: translateFragment,
-    getReadyState: function () {
+    getReadyState: function getReadyState() {
       return gReadyState;
     },
-    ready: function (callback) {
+    ready: function ready(callback) {
       if (!callback) {
         return;
       } else if (gReadyState == 'complete' || gReadyState == 'interactive') {
@@ -12976,7 +15984,7 @@ document.webL10n = function (window, document, undefined) {
 }(window, document);
 
 /***/ }),
-/* 38 */
+/* 41 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
@@ -12987,30 +15995,30 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PDFPrintService = PDFPrintService;
 
-var _ui_utils = __webpack_require__(2);
+var _ui_utils = __webpack_require__(5);
 
 var _app = __webpack_require__(1);
 
-var _app_options = __webpack_require__(3);
+var _app_options = __webpack_require__(6);
 
-let activeService = null;
-let overlayManager = null;
+var activeService = null;
+var overlayManager = null;
 
 function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size) {
-  const scratchCanvas = activeService.scratchCanvas;
-  const PRINT_RESOLUTION = _app_options.AppOptions.get("printResolution") || 150;
-  const PRINT_UNITS = PRINT_RESOLUTION / 72.0;
+  var scratchCanvas = activeService.scratchCanvas;
+  var PRINT_RESOLUTION = _app_options.AppOptions.get("printResolution") || 150;
+  var PRINT_UNITS = PRINT_RESOLUTION / 72.0;
   scratchCanvas.width = Math.floor(size.width * PRINT_UNITS);
   scratchCanvas.height = Math.floor(size.height * PRINT_UNITS);
-  const width = Math.floor(size.width * _ui_utils.CSS_UNITS) + "px";
-  const height = Math.floor(size.height * _ui_utils.CSS_UNITS) + "px";
-  const ctx = scratchCanvas.getContext("2d");
+  var width = Math.floor(size.width * _ui_utils.CSS_UNITS) + "px";
+  var height = Math.floor(size.height * _ui_utils.CSS_UNITS) + "px";
+  var ctx = scratchCanvas.getContext("2d");
   ctx.save();
   ctx.fillStyle = "rgb(255, 255, 255)";
   ctx.fillRect(0, 0, scratchCanvas.width, scratchCanvas.height);
   ctx.restore();
   return pdfDocument.getPage(pageNumber).then(function (pdfPage) {
-    const renderContext = {
+    var renderContext = {
       canvasContext: ctx,
       transform: [PRINT_UNITS, 0, 0, PRINT_UNITS, 0, 0],
       viewport: pdfPage.getViewport({
@@ -13022,8 +16030,8 @@ function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size) {
     return pdfPage.render(renderContext).promise;
   }).then(function () {
     return {
-      width,
-      height
+      width: width,
+      height: height
     };
   });
 }
@@ -13039,11 +16047,11 @@ function PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
 }
 
 PDFPrintService.prototype = {
-  layout() {
+  layout: function layout() {
     this.throwIfInactive();
-    const body = document.querySelector("body");
+    var body = document.querySelector("body");
     body.setAttribute("data-pdfjsprinting", true);
-    const hasEqualPageSizes = this.pagesOverview.every(function (size) {
+    var hasEqualPageSizes = this.pagesOverview.every(function (size) {
       return size.width === this.pagesOverview[0].width && size.height === this.pagesOverview[0].height;
     }, this);
 
@@ -13052,18 +16060,17 @@ PDFPrintService.prototype = {
     }
 
     this.pageStyleSheet = document.createElement("style");
-    const pageSize = this.pagesOverview[0];
+    var pageSize = this.pagesOverview[0];
     this.pageStyleSheet.textContent = "@supports ((size:A4) and (size:1pt 1pt)) {" + "@page { size: " + pageSize.width + "pt " + pageSize.height + "pt;}" + "}";
     body.appendChild(this.pageStyleSheet);
   },
-
-  destroy() {
+  destroy: function destroy() {
     if (activeService !== this) {
       return;
     }
 
     this.printContainer.textContent = "";
-    const body = document.querySelector("body");
+    var body = document.querySelector("body");
     body.removeAttribute("data-pdfjsprinting");
 
     if (this.pageStyleSheet) {
@@ -13082,35 +16089,35 @@ PDFPrintService.prototype = {
       overlayManager.close("printServiceOverlay");
     });
   },
+  renderPages: function renderPages() {
+    var _this = this;
 
-  renderPages() {
-    const pageCount = this.pagesOverview.length;
+    var pageCount = this.pagesOverview.length;
 
-    const renderNextPage = (resolve, reject) => {
-      this.throwIfInactive();
+    var renderNextPage = function renderNextPage(resolve, reject) {
+      _this.throwIfInactive();
 
-      if (++this.currentPage >= pageCount) {
-        renderProgress(pageCount, pageCount, this.l10n);
+      if (++_this.currentPage >= pageCount) {
+        renderProgress(pageCount, pageCount, _this.l10n);
         resolve();
         return;
       }
 
-      const index = this.currentPage;
-      renderProgress(index, pageCount, this.l10n);
-      renderPage(this, this.pdfDocument, index + 1, this.pagesOverview[index]).then(this.useRenderedPage.bind(this)).then(function () {
+      var index = _this.currentPage;
+      renderProgress(index, pageCount, _this.l10n);
+      renderPage(_this, _this.pdfDocument, index + 1, _this.pagesOverview[index]).then(_this.useRenderedPage.bind(_this)).then(function () {
         renderNextPage(resolve, reject);
       }, reject);
     };
 
     return new Promise(renderNextPage);
   },
-
-  useRenderedPage(printItem) {
+  useRenderedPage: function useRenderedPage(printItem) {
     this.throwIfInactive();
-    const img = document.createElement("img");
+    var img = document.createElement("img");
     img.style.width = printItem.width;
     img.style.height = printItem.height;
-    const scratchCanvas = this.scratchCanvas;
+    var scratchCanvas = this.scratchCanvas;
 
     if ("toBlob" in scratchCanvas && !this.disableCreateObjectURL) {
       scratchCanvas.toBlob(function (blob) {
@@ -13120,7 +16127,7 @@ PDFPrintService.prototype = {
       img.src = scratchCanvas.toDataURL();
     }
 
-    const wrapper = document.createElement("div");
+    var wrapper = document.createElement("div");
     wrapper.appendChild(img);
     this.printContainer.appendChild(wrapper);
     return new Promise(function (resolve, reject) {
@@ -13128,12 +16135,13 @@ PDFPrintService.prototype = {
       img.onerror = reject;
     });
   },
+  performPrint: function performPrint() {
+    var _this2 = this;
 
-  performPrint() {
     this.throwIfInactive();
-    return new Promise(resolve => {
-      setTimeout(() => {
-        if (!this.active) {
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        if (!_this2.active) {
           resolve();
           return;
         }
@@ -13148,14 +16156,13 @@ PDFPrintService.prototype = {
     return this === activeService;
   },
 
-  throwIfInactive() {
+  throwIfInactive: function throwIfInactive() {
     if (!this.active) {
       throw new Error("This print request was cancelled or completed.");
     }
   }
-
 };
-const print = window.print;
+var print = window.print;
 
 window.print = function () {
   if (activeService) {
@@ -13182,10 +16189,10 @@ window.print = function () {
       return;
     }
 
-    const activeServiceOnEntry = activeService;
+    var activeServiceOnEntry = activeService;
     activeService.renderPages().then(function () {
       return activeServiceOnEntry.performPrint();
-    }).catch(function () {}).then(function () {
+    })["catch"](function () {}).then(function () {
       if (activeServiceOnEntry.active) {
         abort();
       }
@@ -13194,7 +16201,7 @@ window.print = function () {
 };
 
 function dispatchEvent(eventType) {
-  const event = document.createEvent("CustomEvent");
+  var event = document.createEvent("CustomEvent");
   event.initCustomEvent(eventType, false, false, "custom");
   window.dispatchEvent(event);
 }
@@ -13207,14 +16214,14 @@ function abort() {
 }
 
 function renderProgress(index, total, l10n) {
-  const progressContainer = document.getElementById("printServiceOverlay");
-  const progress = Math.round(100 * index / total);
-  const progressBar = progressContainer.querySelector("progress");
-  const progressPerc = progressContainer.querySelector(".relative-progress");
+  var progressContainer = document.getElementById("printServiceOverlay");
+  var progress = Math.round(100 * index / total);
+  var progressBar = progressContainer.querySelector("progress");
+  var progressPerc = progressContainer.querySelector(".relative-progress");
   progressBar.value = progress;
   l10n.get("print_progress_percent", {
-    progress
-  }, progress + "%").then(msg => {
+    progress: progress
+  }, progress + "%").then(function (msg) {
     progressPerc.textContent = msg;
   });
 }
@@ -13233,7 +16240,7 @@ window.addEventListener("keydown", function (event) {
 }, true);
 
 if ("onbeforeprint" in window) {
-  const stopPropagationIfNeeded = function (event) {
+  var stopPropagationIfNeeded = function stopPropagationIfNeeded(event) {
     if (event.detail !== "custom" && event.stopImmediatePropagation) {
       event.stopImmediatePropagation();
     }
@@ -13243,7 +16250,7 @@ if ("onbeforeprint" in window) {
   window.addEventListener("afterprint", stopPropagationIfNeeded);
 }
 
-let overlayPromise;
+var overlayPromise;
 
 function ensureOverlay() {
   if (!overlayPromise) {
@@ -13262,8 +16269,7 @@ function ensureOverlay() {
 
 _app.PDFPrintServiceFactory.instance = {
   supportsPrinting: true,
-
-  createPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
+  createPrintService: function createPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
     if (activeService) {
       throw new Error("The print service is created and active.");
     }
@@ -13271,7 +16277,6 @@ _app.PDFPrintServiceFactory.instance = {
     activeService = new PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n);
     return activeService;
   }
-
 };
 
 /***/ })