pdfjs-dist 2.0.550 → 2.3.200

package/lib/web/app.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,65 +19,85 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PDFPrintServiceFactory = exports.DefaultExternalServices = exports.PDFViewerApplication = undefined;
+exports.PDFPrintServiceFactory = exports.DefaultExternalServices = exports.PDFViewerApplication = void 0;
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { 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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
-var _ui_utils = require('./ui_utils');
+var _ui_utils = require("./ui_utils");
 
-var _pdf = require('../pdf');
+var _app_options = require("./app_options");
 
-var _pdf_cursor_tools = require('./pdf_cursor_tools');
+var _pdf = require("../pdf");
 
-var _pdf_rendering_queue = require('./pdf_rendering_queue');
+var _pdf_cursor_tools = require("./pdf_cursor_tools");
 
-var _pdf_sidebar = require('./pdf_sidebar');
+var _pdf_rendering_queue = require("./pdf_rendering_queue");
 
-var _app_options = require('./app_options');
+var _pdf_sidebar = require("./pdf_sidebar");
 
-var _dom_events = require('./dom_events');
+var _overlay_manager = require("./overlay_manager");
 
-var _overlay_manager = require('./overlay_manager');
+var _password_prompt = require("./password_prompt");
 
-var _password_prompt = require('./password_prompt');
+var _pdf_attachment_viewer = require("./pdf_attachment_viewer");
 
-var _pdf_attachment_viewer = require('./pdf_attachment_viewer');
+var _pdf_document_properties = require("./pdf_document_properties");
 
-var _pdf_document_properties = require('./pdf_document_properties');
+var _pdf_find_bar = require("./pdf_find_bar");
 
-var _pdf_find_bar = require('./pdf_find_bar');
+var _pdf_find_controller = require("./pdf_find_controller");
 
-var _pdf_find_controller = require('./pdf_find_controller');
+var _pdf_history = require("./pdf_history");
 
-var _pdf_history = require('./pdf_history');
+var _pdf_link_service = require("./pdf_link_service");
 
-var _pdf_link_service = require('./pdf_link_service');
+var _pdf_outline_viewer = require("./pdf_outline_viewer");
 
-var _pdf_outline_viewer = require('./pdf_outline_viewer');
+var _pdf_presentation_mode = require("./pdf_presentation_mode");
 
-var _pdf_presentation_mode = require('./pdf_presentation_mode');
+var _pdf_sidebar_resizer = require("./pdf_sidebar_resizer");
 
-var _pdf_sidebar_resizer = require('./pdf_sidebar_resizer');
+var _pdf_thumbnail_viewer = require("./pdf_thumbnail_viewer");
 
-var _pdf_thumbnail_viewer = require('./pdf_thumbnail_viewer');
+var _pdf_viewer = require("./pdf_viewer");
 
-var _pdf_viewer = require('./pdf_viewer');
+var _secondary_toolbar = require("./secondary_toolbar");
 
-var _secondary_toolbar = require('./secondary_toolbar');
+var _toolbar = require("./toolbar");
 
-var _toolbar = require('./toolbar');
+var _view_history = require("./view_history");
 
-var _view_history = require('./view_history');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { 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 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 ViewOnLoad = {
+  UNKNOWN: -1,
+  PREVIOUS: 0,
+  INITIAL: 1
+};
 var DefaultExternalServices = {
   updateFindControlState: function updateFindControlState(data) {},
+  updateFindMatchesCount: function updateFindMatchesCount(data) {},
   initPassiveLoading: function initPassiveLoading(callbacks) {},
   fallback: function fallback(data, callback) {},
   reportTelemetry: function reportTelemetry(data) {},
@@ -90,7 +110,6 @@ var DefaultExternalServices = {
   createL10n: function createL10n(options) {
     throw new Error('Not implemented: createL10n');
   },
-
   supportsIntegratedFind: false,
   supportsDocumentFonts: true,
   supportsDocumentColors: true,
@@ -99,6 +118,7 @@ var DefaultExternalServices = {
     metaKey: true
   }
 };
+exports.DefaultExternalServices = DefaultExternalServices;
 var PDFViewerApplication = {
   initialBookmark: document.location.hash.substring(1),
   initialized: false,
@@ -135,341 +155,479 @@ var PDFViewerApplication = {
   externalServices: DefaultExternalServices,
   _boundEvents: {},
   contentDispositionFilename: null,
-  initialize: function initialize(appConfig) {
-    var _this = this;
-
-    this.preferences = this.externalServices.createPreferences();
-    this.appConfig = appConfig;
-    return this._readPreferences().then(function () {
-      return _this._parseHashParameters();
-    }).then(function () {
-      return _this._initializeL10n();
-    }).then(function () {
-      return _this._initializeViewerComponents();
-    }).then(function () {
-      _this.bindEvents();
-      _this.bindWindowEvents();
-      var appContainer = appConfig.appContainer || document.documentElement;
-      _this.l10n.translate(appContainer).then(function () {
-        _this.eventBus.dispatch('localized');
-      });
-      if (_this.isViewerEmbedded && _app_options.AppOptions.get('externalLinkTarget') === _pdf.LinkTarget.NONE) {
-        _app_options.AppOptions.set('externalLinkTarget', _pdf.LinkTarget.TOP);
-      }
-      _this.initialized = true;
-    });
-  },
-  _readPreferences: function _readPreferences() {
-    var preferences = this.preferences;
-
-    return Promise.all([preferences.get('enableWebGL').then(function resolved(value) {
-      _app_options.AppOptions.set('enableWebGL', value);
-    }), preferences.get('sidebarViewOnLoad').then(function resolved(value) {
-      _app_options.AppOptions.set('sidebarViewOnLoad', value);
-    }), preferences.get('cursorToolOnLoad').then(function resolved(value) {
-      _app_options.AppOptions.set('cursorToolOnLoad', value);
-    }), preferences.get('pdfBugEnabled').then(function resolved(value) {
-      _app_options.AppOptions.set('pdfBugEnabled', value);
-    }), preferences.get('showPreviousViewOnLoad').then(function resolved(value) {
-      _app_options.AppOptions.set('showPreviousViewOnLoad', value);
-    }), preferences.get('defaultZoomValue').then(function resolved(value) {
-      _app_options.AppOptions.set('defaultZoomValue', value);
-    }), preferences.get('textLayerMode').then(function resolved(value) {
-      if (_app_options.AppOptions.get('textLayerMode') === _ui_utils.TextLayerMode.DISABLE) {
-        return;
-      }
-      _app_options.AppOptions.set('textLayerMode', value);
-    }), preferences.get('disableRange').then(function resolved(value) {
-      if (_app_options.AppOptions.get('disableRange') === true) {
-        return;
-      }
-      _app_options.AppOptions.set('disableRange', value);
-    }), preferences.get('disableStream').then(function resolved(value) {
-      if (_app_options.AppOptions.get('disableStream') === true) {
-        return;
-      }
-      _app_options.AppOptions.set('disableStream', value);
-    }), preferences.get('disableAutoFetch').then(function resolved(value) {
-      _app_options.AppOptions.set('disableAutoFetch', value);
-    }), preferences.get('disableFontFace').then(function resolved(value) {
-      if (_app_options.AppOptions.get('disableFontFace') === true) {
-        return;
-      }
-      _app_options.AppOptions.set('disableFontFace', value);
-    }), preferences.get('useOnlyCssZoom').then(function resolved(value) {
-      _app_options.AppOptions.set('useOnlyCssZoom', value);
-    }), preferences.get('externalLinkTarget').then(function resolved(value) {
-      if (_app_options.AppOptions.get('externalLinkTarget') !== _pdf.LinkTarget.NONE) {
-        return;
-      }
-      _app_options.AppOptions.set('externalLinkTarget', value);
-    }), preferences.get('renderer').then(function resolved(value) {
-      _app_options.AppOptions.set('renderer', value);
-    }), preferences.get('renderInteractiveForms').then(function resolved(value) {
-      _app_options.AppOptions.set('renderInteractiveForms', value);
-    }), preferences.get('disablePageMode').then(function resolved(value) {
-      _app_options.AppOptions.set('disablePageMode', value);
-    }), preferences.get('disablePageLabels').then(function resolved(value) {
-      _app_options.AppOptions.set('disablePageLabels', value);
-    }), preferences.get('enablePrintAutoRotate').then(function resolved(value) {
-      _app_options.AppOptions.set('enablePrintAutoRotate', value);
-    }), preferences.get('scrollModeOnLoad').then(function resolved(value) {
-      _app_options.AppOptions.set('scrollModeOnLoad', value);
-    }), preferences.get('spreadModeOnLoad').then(function resolved(value) {
-      _app_options.AppOptions.set('spreadModeOnLoad', value);
-    })]).catch(function (reason) {});
-  },
-  _parseHashParameters: function _parseHashParameters() {
-    var appConfig = this.appConfig;
-
-    var waitOn = [];
-    if (_app_options.AppOptions.get('pdfBugEnabled')) {
-      var hash = document.location.hash.substring(1);
-      var hashParams = (0, _ui_utils.parseQueryString)(hash);
-      if ('disableworker' in hashParams && hashParams['disableworker'] === 'true') {
-        waitOn.push(loadFakeWorker());
-      }
-      if ('disablerange' in hashParams) {
-        _app_options.AppOptions.set('disableRange', hashParams['disablerange'] === 'true');
-      }
-      if ('disablestream' in hashParams) {
-        _app_options.AppOptions.set('disableStream', hashParams['disablestream'] === 'true');
-      }
-      if ('disableautofetch' in hashParams) {
-        _app_options.AppOptions.set('disableAutoFetch', hashParams['disableautofetch'] === 'true');
-      }
-      if ('disablefontface' in hashParams) {
-        _app_options.AppOptions.set('disableFontFace', hashParams['disablefontface'] === 'true');
-      }
-      if ('disablehistory' in hashParams) {
-        _app_options.AppOptions.set('disableHistory', hashParams['disablehistory'] === 'true');
-      }
-      if ('webgl' in hashParams) {
-        _app_options.AppOptions.set('enableWebGL', hashParams['webgl'] === 'true');
-      }
-      if ('useonlycsszoom' in hashParams) {
-        _app_options.AppOptions.set('useOnlyCssZoom', hashParams['useonlycsszoom'] === 'true');
-      }
-      if ('verbosity' in hashParams) {
-        _app_options.AppOptions.set('verbosity', hashParams['verbosity'] | 0);
-      }
-      if ('textlayer' in hashParams) {
-        switch (hashParams['textlayer']) {
-          case 'off':
-            _app_options.AppOptions.set('textLayerMode', _ui_utils.TextLayerMode.DISABLE);
-            break;
-          case 'visible':
-          case 'shadow':
-          case 'hover':
-            var viewer = appConfig.viewerContainer;
-            viewer.classList.add('textLayer-' + hashParams['textlayer']);
-            break;
+  initialize: function () {
+    var _initialize = _asyncToGenerator(
+    /*#__PURE__*/
+    _regenerator["default"].mark(function _callee(appConfig) {
+      var _this = this;
+
+      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') === _pdf.LinkTarget.NONE) {
+                _app_options.AppOptions.set('externalLinkTarget', _pdf.LinkTarget.TOP);
+              }
+
+              _context.next = 11;
+              return this._initializeViewerComponents();
+
+            case 11:
+              this.bindEvents();
+              this.bindWindowEvents();
+              appContainer = appConfig.appContainer || document.documentElement;
+              this.l10n.translate(appContainer).then(function () {
+                _this.eventBus.dispatch('localized', {
+                  source: _this
+                });
+              });
+              this.initialized = true;
+
+            case 16:
+            case "end":
+              return _context.stop();
+          }
         }
-      }
-      if ('pdfbug' in hashParams) {
-        _app_options.AppOptions.set('pdfBug', true);
-        var enabled = hashParams['pdfbug'].split(',');
-        waitOn.push(loadAndEnablePDFBug(enabled));
-      }
-      if ('locale' in hashParams) {
-        _app_options.AppOptions.set('locale', hashParams['locale']);
-      }
+      }, _callee, this);
+    }));
+
+    function initialize(_x) {
+      return _initialize.apply(this, arguments);
     }
-    return Promise.all(waitOn);
-  },
-  _initializeL10n: function _initializeL10n() {
-    this.l10n = this.externalServices.createL10n({ locale: _app_options.AppOptions.get('locale') });
-    return this.l10n.getDirection().then(function (dir) {
-      document.getElementsByTagName('html')[0].dir = dir;
-    });
-  },
-  _initializeViewerComponents: function _initializeViewerComponents() {
-    var _this2 = this;
-
-    var appConfig = this.appConfig;
-
-    return new Promise(function (resolve, reject) {
-      _this2.overlayManager = new _overlay_manager.OverlayManager();
-      var eventBus = appConfig.eventBus || (0, _dom_events.getGlobalEventBus)();
-      _this2.eventBus = eventBus;
-      var pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
-      pdfRenderingQueue.onIdle = _this2.cleanup.bind(_this2);
-      _this2.pdfRenderingQueue = pdfRenderingQueue;
-      var pdfLinkService = new _pdf_link_service.PDFLinkService({
-        eventBus: eventBus,
-        externalLinkTarget: _app_options.AppOptions.get('externalLinkTarget'),
-        externalLinkRel: _app_options.AppOptions.get('externalLinkRel')
-      });
-      _this2.pdfLinkService = pdfLinkService;
-      var downloadManager = _this2.externalServices.createDownloadManager({ disableCreateObjectURL: _app_options.AppOptions.get('disableCreateObjectURL') });
-      _this2.downloadManager = downloadManager;
-      var container = appConfig.mainContainer;
-      var viewer = appConfig.viewerContainer;
-      _this2.pdfViewer = new _pdf_viewer.PDFViewer({
-        container: container,
-        viewer: viewer,
-        eventBus: eventBus,
-        renderingQueue: pdfRenderingQueue,
-        linkService: pdfLinkService,
-        downloadManager: downloadManager,
-        renderer: _app_options.AppOptions.get('renderer'),
-        enableWebGL: _app_options.AppOptions.get('enableWebGL'),
-        l10n: _this2.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(_this2.pdfViewer);
-      pdfLinkService.setViewer(_this2.pdfViewer);
-      var thumbnailContainer = appConfig.sidebar.thumbnailView;
-      _this2.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
-        container: thumbnailContainer,
-        renderingQueue: pdfRenderingQueue,
-        linkService: pdfLinkService,
-        l10n: _this2.l10n
-      });
-      pdfRenderingQueue.setThumbnailViewer(_this2.pdfThumbnailViewer);
-      _this2.pdfHistory = new _pdf_history.PDFHistory({
-        linkService: pdfLinkService,
-        eventBus: eventBus
-      });
-      pdfLinkService.setHistory(_this2.pdfHistory);
-      _this2.findController = new _pdf_find_controller.PDFFindController({ pdfViewer: _this2.pdfViewer });
-      _this2.findController.onUpdateResultsCount = function (matchCount) {
-        if (_this2.supportsIntegratedFind) {
-          return;
+
+    return initialize;
+  }(),
+  _readPreferences: function () {
+    var _readPreferences2 = _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') === true)) {
+                _context2.next = 2;
+                break;
+              }
+
+              return _context2.abrupt("return");
+
+            case 2:
+              _context2.prev = 2;
+              _context2.next = 5;
+              return this.preferences.getAll();
+
+            case 5:
+              prefs = _context2.sent;
+
+              for (name in prefs) {
+                _app_options.AppOptions.set(name, prefs[name]);
+              }
+
+              _context2.next = 12;
+              break;
+
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](2);
+              console.error("_readPreferences: \"".concat(_context2.t0.message, "\"."));
+
+            case 12:
+            case "end":
+              return _context2.stop();
+          }
         }
-        _this2.findBar.updateResultsCount(matchCount);
-      };
-      _this2.findController.onUpdateState = function (state, previous, matchCount) {
-        if (_this2.supportsIntegratedFind) {
-          _this2.externalServices.updateFindControlState({
-            result: state,
-            findPrevious: previous
-          });
-        } else {
-          _this2.findBar.updateUIState(state, previous, matchCount);
+      }, _callee2, this, [[2, 9]]);
+    }));
+
+    function _readPreferences() {
+      return _readPreferences2.apply(this, arguments);
+    }
+
+    return _readPreferences;
+  }(),
+  _parseHashParameters: function () {
+    var _parseHashParameters2 = _asyncToGenerator(
+    /*#__PURE__*/
+    _regenerator["default"].mark(function _callee3() {
+      var waitOn, hash, hashParams, 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;
+              }
+
+              return _context3.abrupt("return", undefined);
+
+            case 2:
+              waitOn = [];
+              hash = document.location.hash.substring(1);
+              hashParams = (0, _ui_utils.parseQueryString)(hash);
+
+              if ('disableworker' in hashParams && hashParams['disableworker'] === 'true') {
+                waitOn.push(loadFakeWorker());
+              }
+
+              if ('disablerange' in hashParams) {
+                _app_options.AppOptions.set('disableRange', hashParams['disablerange'] === 'true');
+              }
+
+              if ('disablestream' in hashParams) {
+                _app_options.AppOptions.set('disableStream', hashParams['disablestream'] === 'true');
+              }
+
+              if ('disableautofetch' in hashParams) {
+                _app_options.AppOptions.set('disableAutoFetch', hashParams['disableautofetch'] === 'true');
+              }
+
+              if ('disablefontface' in hashParams) {
+                _app_options.AppOptions.set('disableFontFace', hashParams['disablefontface'] === 'true');
+              }
+
+              if ('disablehistory' in hashParams) {
+                _app_options.AppOptions.set('disableHistory', hashParams['disablehistory'] === 'true');
+              }
+
+              if ('webgl' in hashParams) {
+                _app_options.AppOptions.set('enableWebGL', hashParams['webgl'] === 'true');
+              }
+
+              if ('useonlycsszoom' in hashParams) {
+                _app_options.AppOptions.set('useOnlyCssZoom', hashParams['useonlycsszoom'] === 'true');
+              }
+
+              if ('verbosity' in hashParams) {
+                _app_options.AppOptions.set('verbosity', hashParams['verbosity'] | 0);
+              }
+
+              if (!('textlayer' in hashParams)) {
+                _context3.next = 23;
+                break;
+              }
+
+              _context3.t0 = hashParams['textlayer'];
+              _context3.next = _context3.t0 === 'off' ? 18 : _context3.t0 === 'visible' ? 20 : _context3.t0 === 'shadow' ? 20 : _context3.t0 === 'hover' ? 20 : 23;
+              break;
+
+            case 18:
+              _app_options.AppOptions.set('textLayerMode', _ui_utils.TextLayerMode.DISABLE);
+
+              return _context3.abrupt("break", 23);
+
+            case 20:
+              viewer = this.appConfig.viewerContainer;
+              viewer.classList.add('textLayer-' + hashParams['textlayer']);
+              return _context3.abrupt("break", 23);
+
+            case 23:
+              if ('pdfbug' in hashParams) {
+                _app_options.AppOptions.set('pdfBug', 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();
+          }
         }
-      };
-      _this2.pdfViewer.setFindController(_this2.findController);
-      var findBarConfig = Object.create(appConfig.findBar);
-      findBarConfig.findController = _this2.findController;
-      findBarConfig.eventBus = eventBus;
-      _this2.findBar = new _pdf_find_bar.PDFFindBar(findBarConfig, _this2.l10n);
-      _this2.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, _this2.overlayManager, eventBus, _this2.l10n);
-      _this2.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
-        container: container,
-        eventBus: eventBus,
-        cursorToolOnLoad: _app_options.AppOptions.get('cursorToolOnLoad')
-      });
-      _this2.toolbar = new _toolbar.Toolbar(appConfig.toolbar, container, eventBus, _this2.l10n);
-      _this2.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
-      if (_this2.supportsFullscreen) {
-        _this2.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
-          container: container,
-          viewer: viewer,
-          pdfViewer: _this2.pdfViewer,
-          eventBus: eventBus,
-          contextMenuItems: appConfig.fullscreen
-        });
-      }
-      _this2.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, _this2.overlayManager, _this2.l10n);
-      _this2.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
-        container: appConfig.sidebar.outlineView,
-        eventBus: eventBus,
-        linkService: pdfLinkService
-      });
-      _this2.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
-        container: appConfig.sidebar.attachmentsView,
-        eventBus: eventBus,
-        downloadManager: downloadManager
-      });
-      var sidebarConfig = Object.create(appConfig.sidebar);
-      sidebarConfig.pdfViewer = _this2.pdfViewer;
-      sidebarConfig.pdfThumbnailViewer = _this2.pdfThumbnailViewer;
-      sidebarConfig.pdfOutlineViewer = _this2.pdfOutlineViewer;
-      sidebarConfig.eventBus = eventBus;
-      _this2.pdfSidebar = new _pdf_sidebar.PDFSidebar(sidebarConfig, _this2.l10n);
-      _this2.pdfSidebar.onToggled = _this2.forceRendering.bind(_this2);
-      _this2.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, _this2.l10n);
-      resolve(undefined);
-    });
-  },
+      }, _callee3, this);
+    }));
+
+    function _parseHashParameters() {
+      return _parseHashParameters2.apply(this, arguments);
+    }
+
+    return _parseHashParameters;
+  }(),
+  _initializeL10n: function () {
+    var _initializeL10n2 = _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:
+              this.l10n = this.externalServices.createL10n({
+                locale: _app_options.AppOptions.get('locale')
+              });
+              _context4.next = 3;
+              return this.l10n.getDirection();
+
+            case 3:
+              dir = _context4.sent;
+              document.getElementsByTagName('html')[0].dir = dir;
+
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function _initializeL10n() {
+      return _initializeL10n2.apply(this, arguments);
+    }
+
+    return _initializeL10n;
+  }(),
+  _initializeViewerComponents: function () {
+    var _initializeViewerComponents2 = _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 = this.appConfig;
+              this.overlayManager = new _overlay_manager.OverlayManager();
+              eventBus = appConfig.eventBus || (0, _ui_utils.getGlobalEventBus)(_app_options.AppOptions.get('eventBusDispatchToDOM'));
+              this.eventBus = eventBus;
+              pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
+              pdfRenderingQueue.onIdle = this.cleanup.bind(this);
+              this.pdfRenderingQueue = pdfRenderingQueue;
+              pdfLinkService = new _pdf_link_service.PDFLinkService({
+                eventBus: eventBus,
+                externalLinkTarget: _app_options.AppOptions.get('externalLinkTarget'),
+                externalLinkRel: _app_options.AppOptions.get('externalLinkRel')
+              });
+              this.pdfLinkService = pdfLinkService;
+              downloadManager = this.externalServices.createDownloadManager({
+                disableCreateObjectURL: _app_options.AppOptions.get('disableCreateObjectURL')
+              });
+              this.downloadManager = downloadManager;
+              findController = new _pdf_find_controller.PDFFindController({
+                linkService: pdfLinkService,
+                eventBus: eventBus
+              });
+              this.findController = findController;
+              container = appConfig.mainContainer;
+              viewer = appConfig.viewerContainer;
+              this.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: 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: eventBus
+              });
+              pdfLinkService.setHistory(this.pdfHistory);
+
+              if (!this.supportsIntegratedFind) {
+                this.findBar = new _pdf_find_bar.PDFFindBar(appConfig.findBar, eventBus, this.l10n);
+              }
+
+              this.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, this.l10n);
+              this.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
+                container: container,
+                eventBus: 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);
+
+              if (this.supportsFullscreen) {
+                this.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
+                  container: container,
+                  viewer: viewer,
+                  pdfViewer: this.pdfViewer,
+                  eventBus: eventBus,
+                  contextMenuItems: appConfig.fullscreen
+                });
+              }
+
+              this.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.l10n);
+              this.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
+                container: appConfig.sidebar.outlineView,
+                eventBus: eventBus,
+                linkService: pdfLinkService
+              });
+              this.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
+                container: appConfig.sidebar.attachmentsView,
+                eventBus: eventBus,
+                downloadManager: downloadManager
+              });
+              this.pdfSidebar = new _pdf_sidebar.PDFSidebar({
+                elements: appConfig.sidebar,
+                pdfViewer: this.pdfViewer,
+                pdfThumbnailViewer: this.pdfThumbnailViewer,
+                eventBus: eventBus,
+                l10n: this.l10n
+              });
+              this.pdfSidebar.onToggled = this.forceRendering.bind(this);
+              this.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, this.l10n);
+
+            case 34:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function _initializeViewerComponents() {
+      return _initializeViewerComponents2.apply(this, arguments);
+    }
+
+    return _initializeViewerComponents;
+  }(),
   run: function run(config) {
     this.initialize(config).then(webViewerInitialized);
   },
   zoomIn: function zoomIn(ticks) {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
     var newScale = this.pdfViewer.currentScale;
+
     do {
       newScale = (newScale * DEFAULT_SCALE_DELTA).toFixed(2);
       newScale = Math.ceil(newScale * 10) / 10;
       newScale = Math.min(_ui_utils.MAX_SCALE, newScale);
     } while (--ticks > 0 && newScale < _ui_utils.MAX_SCALE);
+
     this.pdfViewer.currentScaleValue = newScale;
   },
   zoomOut: function zoomOut(ticks) {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
     var newScale = this.pdfViewer.currentScale;
+
     do {
       newScale = (newScale / DEFAULT_SCALE_DELTA).toFixed(2);
       newScale = Math.floor(newScale * 10) / 10;
       newScale = Math.max(_ui_utils.MIN_SCALE, newScale);
     } while (--ticks > 0 && newScale > _ui_utils.MIN_SCALE);
+
     this.pdfViewer.currentScaleValue = newScale;
   },
+  zoomReset: function zoomReset() {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
+    this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+  },
 
   get pagesCount() {
     return this.pdfDocument ? this.pdfDocument.numPages : 0;
   },
+
   set page(val) {
     this.pdfViewer.currentPageNumber = val;
   },
+
   get page() {
     return this.pdfViewer.currentPageNumber;
   },
+
   get printing() {
     return !!this.printService;
   },
+
   get supportsPrinting() {
     return PDFPrintServiceFactory.instance.supportsPrinting;
   },
+
   get supportsFullscreen() {
-    var support = void 0;
+    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) {
       support = false;
     }
-    if (support && _app_options.AppOptions.get('disableFullscreen') === true) {
-      support = false;
-    }
+
     return (0, _pdf.shadow)(this, 'supportsFullscreen', support);
   },
+
   get supportsIntegratedFind() {
     return this.externalServices.supportsIntegratedFind;
   },
+
   get supportsDocumentFonts() {
     return this.externalServices.supportsDocumentFonts;
   },
+
   get supportsDocumentColors() {
     return this.externalServices.supportsDocumentColors;
   },
+
   get loadingBar() {
     var bar = new _ui_utils.ProgressBar('#loadingBar');
     return (0, _pdf.shadow)(this, 'loadingBar', bar);
   },
+
   get supportedMouseWheelZoomModifierKeys() {
     return this.externalServices.supportedMouseWheelZoomModifierKeys;
   },
+
   initPassiveLoading: function initPassiveLoading() {
     throw new Error('Not implemented: initPassiveLoading');
   },
-  setTitleUsingUrl: function setTitleUsingUrl(url) {
+  setTitleUsingUrl: function setTitleUsingUrl() {
+    var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
     this.url = url;
     this.baseUrl = url.split('#')[0];
     var title = (0, _ui_utils.getPDFFileNameFromURL)(url, '');
+
     if (!title) {
       try {
         title = decodeURIComponent((0, _pdf.getFilenameFromUrl)(url)) || url;
@@ -477,138 +635,233 @@ var PDFViewerApplication = {
         title = url;
       }
     }
+
     this.setTitle(title);
   },
   setTitle: function setTitle(title) {
     if (this.isViewerEmbedded) {
       return;
     }
+
     document.title = title;
   },
-  close: function close() {
-    var errorWrapper = this.appConfig.errorWrapper.container;
-    errorWrapper.setAttribute('hidden', 'true');
-    if (!this.pdfLoadingTask) {
-      return Promise.resolve();
-    }
-    var promise = this.pdfLoadingTask.destroy();
-    this.pdfLoadingTask = null;
-    if (this.pdfDocument) {
-      this.pdfDocument = null;
-      this.pdfThumbnailViewer.setDocument(null);
-      this.pdfViewer.setDocument(null);
-      this.pdfLinkService.setDocument(null, null);
-      this.pdfDocumentProperties.setDocument(null, null);
-    }
-    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();
-    this.findController.reset();
-    this.findBar.reset();
-    this.toolbar.reset();
-    this.secondaryToolbar.reset();
-    if (typeof PDFBug !== 'undefined') {
-      PDFBug.cleanup();
-    }
-    return promise;
-  },
-  open: function open(file, args) {
-    var _this3 = this;
+  close: function () {
+    var _close = _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 = this.appConfig.errorWrapper.container;
+              errorWrapper.setAttribute('hidden', 'true');
 
-    if (this.pdfLoadingTask) {
-      return this.close().then(function () {
-        _this3.preferences.reload();
-        return _this3.open(file, args);
-      });
-    }
-    var workerParameters = _app_options.AppOptions.getAll('worker');
-    for (var key in workerParameters) {
-      _pdf.GlobalWorkerOptions[key] = workerParameters[key];
-    }
-    var parameters = Object.create(null);
-    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;
-    }
-    var apiParameters = _app_options.AppOptions.getAll('api');
-    for (var _key in apiParameters) {
-      parameters[_key] = apiParameters[_key];
+              if (this.pdfLoadingTask) {
+                _context6.next = 4;
+                break;
+              }
+
+              return _context6.abrupt("return", undefined);
+
+            case 4:
+              promise = this.pdfLoadingTask.destroy();
+              this.pdfLoadingTask = null;
+
+              if (this.pdfDocument) {
+                this.pdfDocument = null;
+                this.pdfThumbnailViewer.setDocument(null);
+                this.pdfViewer.setDocument(null);
+                this.pdfLinkService.setDocument(null);
+                this.pdfDocumentProperties.setDocument(null);
+              }
+
+              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();
+
+              if (this.findBar) {
+                this.findBar.reset();
+              }
+
+              this.toolbar.reset();
+              this.secondaryToolbar.reset();
+
+              if (typeof PDFBug !== 'undefined') {
+                PDFBug.cleanup();
+              }
+
+              return _context6.abrupt("return", promise);
+
+            case 21:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function close() {
+      return _close.apply(this, arguments);
     }
-    if (args) {
-      for (var prop in args) {
-        if (prop === 'length') {
-          this.pdfDocumentProperties.setFileSize(args[prop]);
+
+    return close;
+  }(),
+  open: function () {
+    var _open = _asyncToGenerator(
+    /*#__PURE__*/
+    _regenerator["default"].mark(function _callee7(file, args) {
+      var _this2 = this;
+
+      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 (!this.pdfLoadingTask) {
+                _context7.next = 3;
+                break;
+              }
+
+              _context7.next = 3;
+              return this.close();
+
+            case 3:
+              workerParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.WORKER);
+
+              for (key in workerParameters) {
+                _pdf.GlobalWorkerOptions[key] = workerParameters[key];
+              }
+
+              parameters = Object.create(null);
+
+              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;
+              }
+
+              apiParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.API);
+
+              for (_key in apiParameters) {
+                value = apiParameters[_key];
+
+                if (_key === 'docBaseUrl' && !value) {}
+
+                parameters[_key] = value;
+              }
+
+              if (args) {
+                for (_key2 in args) {
+                  _value = args[_key2];
+
+                  if (_key2 === 'length') {
+                    this.pdfDocumentProperties.setFileSize(_value);
+                  }
+
+                  parameters[_key2] = _value;
+                }
+              }
+
+              loadingTask = (0, _pdf.getDocument)(parameters);
+              this.pdfLoadingTask = loadingTask;
+
+              loadingTask.onPassword = function (updateCallback, reason) {
+                _this2.pdfLinkService.externalLinkEnabled = false;
+
+                _this2.passwordPrompt.setUpdateCallback(updateCallback, reason);
+
+                _this2.passwordPrompt.open();
+              };
+
+              loadingTask.onProgress = function (_ref) {
+                var loaded = _ref.loaded,
+                    total = _ref.total;
+
+                _this2.progress(loaded / total);
+              };
+
+              loadingTask.onUnsupportedFeature = this.fallback.bind(this);
+              return _context7.abrupt("return", loadingTask.promise.then(function (pdfDocument) {
+                _this2.load(pdfDocument);
+              }, function (exception) {
+                if (loadingTask !== _this2.pdfLoadingTask) {
+                  return undefined;
+                }
+
+                var message = exception && exception.message;
+                var loadingErrorMessage;
+
+                if (exception instanceof _pdf.InvalidPDFException) {
+                  loadingErrorMessage = _this2.l10n.get('invalid_file_error', null, 'Invalid or corrupted PDF file.');
+                } else if (exception instanceof _pdf.MissingPDFException) {
+                  loadingErrorMessage = _this2.l10n.get('missing_file_error', null, 'Missing PDF file.');
+                } else if (exception instanceof _pdf.UnexpectedResponseException) {
+                  loadingErrorMessage = _this2.l10n.get('unexpected_response_error', null, 'Unexpected server response.');
+                } else {
+                  loadingErrorMessage = _this2.l10n.get('loading_error', null, 'An error occurred while loading the PDF.');
+                }
+
+                return loadingErrorMessage.then(function (msg) {
+                  _this2.error(msg, {
+                    message: message
+                  });
+
+                  throw new Error(msg);
+                });
+              }));
+
+            case 16:
+            case "end":
+              return _context7.stop();
+          }
         }
-        parameters[prop] = args[prop];
-      }
+      }, _callee7, this);
+    }));
+
+    function open(_x2, _x3) {
+      return _open.apply(this, arguments);
     }
-    var loadingTask = (0, _pdf.getDocument)(parameters);
-    this.pdfLoadingTask = loadingTask;
-    loadingTask.onPassword = function (updateCallback, reason) {
-      _this3.passwordPrompt.setUpdateCallback(updateCallback, reason);
-      _this3.passwordPrompt.open();
-    };
-    loadingTask.onProgress = function (_ref) {
-      var loaded = _ref.loaded,
-          total = _ref.total;
 
-      _this3.progress(loaded / total);
-    };
-    loadingTask.onUnsupportedFeature = this.fallback.bind(this);
-    return loadingTask.promise.then(function (pdfDocument) {
-      _this3.load(pdfDocument);
-    }, function (exception) {
-      if (loadingTask !== _this3.pdfLoadingTask) {
-        return;
-      }
-      var message = exception && exception.message;
-      var loadingErrorMessage = void 0;
-      if (exception instanceof _pdf.InvalidPDFException) {
-        loadingErrorMessage = _this3.l10n.get('invalid_file_error', null, 'Invalid or corrupted PDF file.');
-      } else if (exception instanceof _pdf.MissingPDFException) {
-        loadingErrorMessage = _this3.l10n.get('missing_file_error', null, 'Missing PDF file.');
-      } else if (exception instanceof _pdf.UnexpectedResponseException) {
-        loadingErrorMessage = _this3.l10n.get('unexpected_response_error', null, 'Unexpected server response.');
-      } else {
-        loadingErrorMessage = _this3.l10n.get('loading_error', null, 'An error occurred while loading the PDF.');
-      }
-      return loadingErrorMessage.then(function (msg) {
-        _this3.error(msg, { message: message });
-        throw new Error(msg);
-      });
-    });
-  },
+    return open;
+  }(),
   download: function download() {
-    var _this4 = this;
+    var _this3 = this;
 
     function downloadByUrl() {
       downloadManager.downloadUrl(url, filename);
     }
+
     var url = this.baseUrl;
     var filename = this.contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
     var downloadManager = this.downloadManager;
+
     downloadManager.onerror = function (err) {
-      _this4.error('PDF failed to download: ' + err);
+      _this3.error("PDF failed to download: ".concat(err));
     };
+
     if (!this.pdfDocument || !this.downloadComplete) {
       downloadByUrl();
       return;
     }
+
     this.pdfDocument.getData().then(function (data) {
-      var blob = (0, _pdf.createBlob)(data, 'application/pdf');
+      var blob = new Blob([data], {
+        type: 'application/pdf'
+      });
       downloadManager.download(blob, url, filename);
-    }).catch(downloadByUrl);
+    })["catch"](downloadByUrl);
   },
   fallback: function fallback(featureId) {},
   error: function error(message, moreInfo) {
@@ -616,42 +869,59 @@ var PDFViewerApplication = {
       version: _pdf.version || '?',
       build: _pdf.build || '?'
     }, 'PDF.js v{{version}} (build: {{build}})')];
+
     if (moreInfo) {
-      moreInfoText.push(this.l10n.get('error_message', { message: moreInfo.message }, 'Message: {{message}}'));
+      moreInfoText.push(this.l10n.get('error_message', {
+        message: moreInfo.message
+      }, 'Message: {{message}}'));
+
       if (moreInfo.stack) {
-        moreInfoText.push(this.l10n.get('error_stack', { stack: moreInfo.stack }, 'Stack: {{stack}}'));
+        moreInfoText.push(this.l10n.get('error_stack', {
+          stack: moreInfo.stack
+        }, 'Stack: {{stack}}'));
       } else {
         if (moreInfo.filename) {
-          moreInfoText.push(this.l10n.get('error_file', { file: moreInfo.filename }, 'File: {{file}}'));
+          moreInfoText.push(this.l10n.get('error_file', {
+            file: moreInfo.filename
+          }, 'File: {{file}}'));
         }
+
         if (moreInfo.lineNumber) {
-          moreInfoText.push(this.l10n.get('error_line', { line: moreInfo.lineNumber }, 'Line: {{line}}'));
+          moreInfoText.push(this.l10n.get('error_line', {
+            line: moreInfo.lineNumber
+          }, 'Line: {{line}}'));
         }
       }
     }
+
     var errorWrapperConfig = this.appConfig.errorWrapper;
     var errorWrapper = errorWrapperConfig.container;
     errorWrapper.removeAttribute('hidden');
     var errorMessage = errorWrapperConfig.errorMessage;
     errorMessage.textContent = message;
     var closeButton = errorWrapperConfig.closeButton;
+
     closeButton.onclick = function () {
       errorWrapper.setAttribute('hidden', 'true');
     };
+
     var errorMoreInfo = errorWrapperConfig.errorMoreInfo;
     var moreInfoButton = errorWrapperConfig.moreInfoButton;
     var lessInfoButton = errorWrapperConfig.lessInfoButton;
+
     moreInfoButton.onclick = function () {
       errorMoreInfo.removeAttribute('hidden');
       moreInfoButton.setAttribute('hidden', 'true');
       lessInfoButton.removeAttribute('hidden');
       errorMoreInfo.style.height = errorMoreInfo.scrollHeight + 'px';
     };
+
     lessInfoButton.onclick = function () {
       errorMoreInfo.setAttribute('hidden', 'true');
       moreInfoButton.removeAttribute('hidden');
       lessInfoButton.setAttribute('hidden', 'true');
     };
+
     moreInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
     lessInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
     closeButton.oncontextmenu = _ui_utils.noContextMenuHandler;
@@ -662,45 +932,55 @@ var PDFViewerApplication = {
     });
   },
   progress: function progress(level) {
-    var _this5 = this;
+    var _this4 = this;
 
     if (this.downloadComplete) {
       return;
     }
+
     var percent = Math.round(level * 100);
+
     if (percent > this.loadingBar.percent || isNaN(percent)) {
       this.loadingBar.percent = percent;
       var disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams['disableAutoFetch'] : _app_options.AppOptions.get('disableAutoFetch');
+
       if (disableAutoFetch && percent) {
         if (this.disableAutoFetchLoadingBarTimeout) {
           clearTimeout(this.disableAutoFetchLoadingBarTimeout);
           this.disableAutoFetchLoadingBarTimeout = null;
         }
+
         this.loadingBar.show();
         this.disableAutoFetchLoadingBarTimeout = setTimeout(function () {
-          _this5.loadingBar.hide();
-          _this5.disableAutoFetchLoadingBarTimeout = null;
+          _this4.loadingBar.hide();
+
+          _this4.disableAutoFetchLoadingBarTimeout = null;
         }, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
       }
     }
   },
   load: function load(pdfDocument) {
-    var _this6 = this;
+    var _this5 = this;
 
     this.pdfDocument = pdfDocument;
     pdfDocument.getDownloadInfo().then(function () {
-      _this6.downloadComplete = true;
-      _this6.loadingBar.hide();
+      _this5.downloadComplete = true;
+
+      _this5.loadingBar.hide();
+
       firstPagePromise.then(function () {
-        _this6.eventBus.dispatch('documentload', { source: _this6 });
+        _this5.eventBus.dispatch('documentloaded', {
+          source: _this5
+        });
       });
     });
-    var pageModePromise = pdfDocument.getPageMode().catch(function () {});
+    var pageLayoutPromise = pdfDocument.getPageLayout()["catch"](function () {});
+    var pageModePromise = pdfDocument.getPageMode()["catch"](function () {});
+    var openActionDestPromise = pdfDocument.getOpenActionDestination()["catch"](function () {});
     this.toolbar.setPagesCount(pdfDocument.numPages, false);
     this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
-    var id = this.documentFingerprint = pdfDocument.fingerprint;
-    var store = this.store = new _view_history.ViewHistory(id);
-    var baseDocumentUrl = void 0;
+    var store = this.store = new _view_history.ViewHistory(pdfDocument.fingerprint);
+    var baseDocumentUrl;
     baseDocumentUrl = null;
     this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
     this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
@@ -712,91 +992,127 @@ var PDFViewerApplication = {
     var pdfThumbnailViewer = this.pdfThumbnailViewer;
     pdfThumbnailViewer.setDocument(pdfDocument);
     firstPagePromise.then(function (pdfPage) {
-      _this6.loadingBar.setWidth(_this6.appConfig.viewerContainer);
-      if (!_app_options.AppOptions.get('disableHistory') && !_this6.isViewerEmbedded) {
-        var resetHistory = !_app_options.AppOptions.get('showPreviousViewOnLoad');
-        _this6.pdfHistory.initialize(id, resetHistory);
-        if (_this6.pdfHistory.initialBookmark) {
-          _this6.initialBookmark = _this6.pdfHistory.initialBookmark;
-          _this6.initialRotation = _this6.pdfHistory.initialRotation;
-        }
-      }
-      var initialParams = {
-        bookmark: null,
-        hash: null
-      };
+      _this5.loadingBar.setWidth(_this5.appConfig.viewerContainer);
+
       var storePromise = store.getMultiple({
-        exists: false,
-        page: '1',
+        page: null,
         zoom: _ui_utils.DEFAULT_SCALE_VALUE,
         scrollLeft: '0',
         scrollTop: '0',
         rotation: null,
-        sidebarView: _pdf_sidebar.SidebarView.NONE,
-        scrollMode: null,
-        spreadMode: null
-      }).catch(function () {});
-      Promise.all([storePromise, pageModePromise]).then(function (_ref2) {
-        var _ref3 = _slicedToArray(_ref2, 2),
-            _ref3$ = _ref3[0],
-            values = _ref3$ === undefined ? {} : _ref3$,
-            pageMode = _ref3[1];
-
-        var hash = _app_options.AppOptions.get('defaultZoomValue') ? 'zoom=' + _app_options.AppOptions.get('defaultZoomValue') : null;
-        var rotation = null;
-        var sidebarView = _app_options.AppOptions.get('sidebarViewOnLoad');
-        var scrollMode = _app_options.AppOptions.get('scrollModeOnLoad');
-        var spreadMode = _app_options.AppOptions.get('spreadModeOnLoad');
-        if (values.exists && _app_options.AppOptions.get('showPreviousViewOnLoad')) {
-          hash = 'page=' + values.page + '&zoom=' + (_app_options.AppOptions.get('defaultZoomValue') || values.zoom) + ',' + values.scrollLeft + ',' + values.scrollTop;
-          rotation = parseInt(values.rotation, 10);
-          sidebarView = sidebarView || values.sidebarView | 0;
-          if (values.scrollMode !== null) {
-            scrollMode = values.scrollMode;
-          }
-          if (values.spreadMode !== null) {
-            spreadMode = values.spreadMode;
-          }
-        }
-        if (pageMode && !_app_options.AppOptions.get('disablePageMode')) {
-          sidebarView = sidebarView || apiPageModeToSidebarView(pageMode);
-        }
-        return {
-          hash: hash,
-          rotation: rotation,
-          sidebarView: sidebarView,
-          scrollMode: scrollMode,
-          spreadMode: spreadMode
+        sidebarView: _pdf_sidebar.SidebarView.UNKNOWN,
+        scrollMode: _ui_utils.ScrollMode.UNKNOWN,
+        spreadMode: _ui_utils.SpreadMode.UNKNOWN
+      })["catch"](function () {});
+      Promise.all([_ui_utils.animationStarted, storePromise, pageLayoutPromise, pageModePromise, openActionDestPromise]).then(
+      /*#__PURE__*/
+      function () {
+        var _ref3 = _asyncToGenerator(
+        /*#__PURE__*/
+        _regenerator["default"].mark(function _callee8(_ref2) {
+          var _ref4, timeStamp, _ref4$, values, pageLayout, pageMode, openActionDest, 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], _ref4$ = _ref4[1], values = _ref4$ === void 0 ? {} : _ref4$, pageLayout = _ref4[2], pageMode = _ref4[3], openActionDest = _ref4[4];
+                  viewOnLoad = _app_options.AppOptions.get('viewOnLoad');
+
+                  _this5._initializePdfHistory({
+                    fingerprint: pdfDocument.fingerprint,
+                    viewOnLoad: viewOnLoad,
+                    initialDest: openActionDest
+                  });
+
+                  initialBookmark = _this5.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 (values.page && viewOnLoad !== ViewOnLoad.INITIAL) {
+                    hash = "page=".concat(values.page, "&zoom=").concat(zoom || values.zoom, ",") + "".concat(values.scrollLeft, ",").concat(values.scrollTop);
+                    rotation = parseInt(values.rotation, 10);
+
+                    if (sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+                      sidebarView = values.sidebarView | 0;
+                    }
+
+                    if (scrollMode === _ui_utils.ScrollMode.UNKNOWN) {
+                      scrollMode = values.scrollMode | 0;
+                    }
+
+                    if (spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+                      spreadMode = values.spreadMode | 0;
+                    }
+                  }
+
+                  if (pageMode && sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+                    sidebarView = apiPageModeToSidebarView(pageMode);
+                  }
+
+                  if (pageLayout && spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+                    spreadMode = apiPageLayoutToSpreadMode(pageLayout);
+                  }
+
+                  _this5.setInitialView(hash, {
+                    rotation: rotation,
+                    sidebarView: sidebarView,
+                    scrollMode: scrollMode,
+                    spreadMode: spreadMode
+                  });
+
+                  _this5.eventBus.dispatch('documentinit', {
+                    source: _this5
+                  });
+
+                  if (!_this5.isViewerEmbedded) {
+                    pdfViewer.focus();
+                  }
+
+                  _context8.next = 18;
+                  return Promise.race([pagesPromise, new Promise(function (resolve) {
+                    setTimeout(resolve, FORCE_PAGES_LOADED_TIMEOUT);
+                  })]);
+
+                case 18:
+                  if (!(!initialBookmark && !hash)) {
+                    _context8.next = 20;
+                    break;
+                  }
+
+                  return _context8.abrupt("return");
+
+                case 20:
+                  if (!pdfViewer.hasEqualPageSizes) {
+                    _context8.next = 22;
+                    break;
+                  }
+
+                  return _context8.abrupt("return");
+
+                case 22:
+                  _this5.initialBookmark = initialBookmark;
+                  pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
+
+                  _this5.setInitialView(hash);
+
+                case 25:
+                case "end":
+                  return _context8.stop();
+              }
+            }
+          }, _callee8);
+        }));
+
+        return function (_x4) {
+          return _ref3.apply(this, arguments);
         };
-      }).then(function (_ref4) {
-        var hash = _ref4.hash,
-            rotation = _ref4.rotation,
-            sidebarView = _ref4.sidebarView,
-            scrollMode = _ref4.scrollMode,
-            spreadMode = _ref4.spreadMode;
-
-        initialParams.bookmark = _this6.initialBookmark;
-        initialParams.hash = hash;
-        _this6.setInitialView(hash, {
-          rotation: rotation,
-          sidebarView: sidebarView,
-          scrollMode: scrollMode,
-          spreadMode: spreadMode
-        });
-        if (!_this6.isViewerEmbedded) {
-          pdfViewer.focus();
-        }
-        return pagesPromise;
-      }).then(function () {
-        if (!initialParams.bookmark && !initialParams.hash) {
-          return;
-        }
-        if (pdfViewer.hasEqualPageSizes) {
-          return;
-        }
-        _this6.initialBookmark = initialParams.bookmark;
-        pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
-        _this6.setInitialView(initialParams.hash);
+      }())["catch"](function () {
+        _this5.setInitialView();
       }).then(function () {
         pdfViewer.update();
       });
@@ -805,42 +1121,56 @@ var PDFViewerApplication = {
       if (!labels || _app_options.AppOptions.get('disablePageLabels')) {
         return;
       }
+
       var i = 0,
           numLabels = labels.length;
-      if (numLabels !== _this6.pagesCount) {
+
+      if (numLabels !== _this5.pagesCount) {
         console.error('The number of Page Labels does not match ' + 'the number of pages in the document.');
         return;
       }
+
       while (i < numLabels && labels[i] === (i + 1).toString()) {
         i++;
       }
+
       if (i === numLabels) {
         return;
       }
+
       pdfViewer.setPageLabels(labels);
       pdfThumbnailViewer.setPageLabels(labels);
-      _this6.toolbar.setPagesCount(pdfDocument.numPages, true);
-      _this6.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
+
+      _this5.toolbar.setPagesCount(pdfDocument.numPages, true);
+
+      _this5.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
     });
     pagesPromise.then(function () {
-      if (!_this6.supportsPrinting) {
+      if (!_this5.supportsPrinting) {
         return;
       }
+
       pdfDocument.getJavaScript().then(function (javaScript) {
         if (!javaScript) {
           return;
         }
+
         javaScript.some(function (js) {
           if (!js) {
             return false;
           }
+
           console.warn('Warning: JavaScript is not supported');
-          _this6.fallback(_pdf.UNSUPPORTED_FEATURES.javaScript);
+
+          _this5.fallback(_pdf.UNSUPPORTED_FEATURES.javaScript);
+
           return true;
         });
         var regex = /\bprint\s*\(/;
+
         for (var i = 0, ii = javaScript.length; i < ii; i++) {
           var js = javaScript[i];
+
           if (js && regex.test(js)) {
             setTimeout(function () {
               window.print();
@@ -850,66 +1180,111 @@ var PDFViewerApplication = {
         }
       });
     });
-    Promise.all([onePageRendered, _ui_utils.animationStarted]).then(function () {
+    onePageRendered.then(function () {
       pdfDocument.getOutline().then(function (outline) {
-        _this6.pdfOutlineViewer.render({ outline: outline });
+        _this5.pdfOutlineViewer.render({
+          outline: outline
+        });
       });
       pdfDocument.getAttachments().then(function (attachments) {
-        _this6.pdfAttachmentViewer.render({ attachments: attachments });
+        _this5.pdfAttachmentViewer.render({
+          attachments: attachments
+        });
       });
     });
     pdfDocument.getMetadata().then(function (_ref5) {
       var info = _ref5.info,
           metadata = _ref5.metadata,
           contentDispositionFilename = _ref5.contentDispositionFilename;
-
-      _this6.documentInfo = info;
-      _this6.metadata = metadata;
-      _this6.contentDispositionFilename = contentDispositionFilename;
+      _this5.documentInfo = info;
+      _this5.metadata = metadata;
+      _this5.contentDispositionFilename = contentDispositionFilename;
       console.log('PDF ' + pdfDocument.fingerprint + ' [' + info.PDFFormatVersion + ' ' + (info.Producer || '-').trim() + ' / ' + (info.Creator || '-').trim() + ']' + ' (PDF.js: ' + (_pdf.version || '-') + (_app_options.AppOptions.get('enableWebGL') ? ' [WebGL]' : '') + ')');
-      var pdfTitle = void 0;
+      var pdfTitle;
+
       if (metadata && metadata.has('dc:title')) {
         var title = metadata.get('dc:title');
+
         if (title !== 'Untitled') {
           pdfTitle = title;
         }
       }
+
       if (!pdfTitle && info && info['Title']) {
         pdfTitle = info['Title'];
       }
+
       if (pdfTitle) {
-        _this6.setTitle(pdfTitle + ' - ' + (contentDispositionFilename || document.title));
+        _this5.setTitle("".concat(pdfTitle, " - ").concat(contentDispositionFilename || document.title));
       } else if (contentDispositionFilename) {
-        _this6.setTitle(contentDispositionFilename);
+        _this5.setTitle(contentDispositionFilename);
       }
+
       if (info.IsAcroFormPresent) {
         console.warn('Warning: AcroForm/XFA is not supported');
-        _this6.fallback(_pdf.UNSUPPORTED_FEATURES.forms);
+
+        _this5.fallback(_pdf.UNSUPPORTED_FEATURES.forms);
       }
     });
   },
+  _initializePdfHistory: function _initializePdfHistory(_ref6) {
+    var fingerprint = _ref6.fingerprint,
+        viewOnLoad = _ref6.viewOnLoad,
+        _ref6$initialDest = _ref6.initialDest,
+        initialDest = _ref6$initialDest === void 0 ? null : _ref6$initialDest;
+
+    if (_app_options.AppOptions.get('disableHistory') || this.isViewerEmbedded) {
+      return;
+    }
+
+    this.pdfHistory.initialize({
+      fingerprint: fingerprint,
+      resetHistory: viewOnLoad === ViewOnLoad.INITIAL,
+      updateUrl: _app_options.AppOptions.get('historyUpdateUrl')
+    });
+
+    if (this.pdfHistory.initialBookmark) {
+      this.initialBookmark = this.pdfHistory.initialBookmark;
+      this.initialRotation = this.pdfHistory.initialRotation;
+    }
+
+    if (initialDest && !this.initialBookmark && viewOnLoad === ViewOnLoad.UNKNOWN) {
+      this.initialBookmark = JSON.stringify(initialDest);
+      this.pdfHistory.push({
+        explicitDest: initialDest,
+        pageNumber: null
+      });
+    }
+  },
   setInitialView: function setInitialView(storedHash) {
-    var _this7 = this;
+    var _this6 = this;
 
-    var values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var rotation = values.rotation,
-        sidebarView = values.sidebarView,
-        scrollMode = values.scrollMode,
-        spreadMode = values.spreadMode;
+    var _ref7 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        rotation = _ref7.rotation,
+        sidebarView = _ref7.sidebarView,
+        scrollMode = _ref7.scrollMode,
+        spreadMode = _ref7.spreadMode;
 
     var setRotation = function setRotation(angle) {
       if ((0, _ui_utils.isValidRotation)(angle)) {
-        _this7.pdfViewer.pagesRotation = angle;
+        _this6.pdfViewer.pagesRotation = angle;
       }
     };
-    if (Number.isInteger(scrollMode)) {
-      this.pdfViewer.setScrollMode(scrollMode);
-    }
-    if (Number.isInteger(spreadMode)) {
-      this.pdfViewer.setSpreadMode(spreadMode);
-    }
+
+    var setViewerModes = function setViewerModes(scroll, spread) {
+      if ((0, _ui_utils.isValidScrollMode)(scroll)) {
+        _this6.pdfViewer.scrollMode = scroll;
+      }
+
+      if ((0, _ui_utils.isValidSpreadMode)(spread)) {
+        _this6.pdfViewer.spreadMode = spread;
+      }
+    };
+
     this.isInitialViewSet = true;
     this.pdfSidebar.setInitialView(sidebarView);
+    setViewerModes(scrollMode, spreadMode);
+
     if (this.initialBookmark) {
       setRotation(this.initialRotation);
       delete this.initialRotation;
@@ -919,8 +1294,10 @@ var PDFViewerApplication = {
       setRotation(rotation);
       this.pdfLinkService.setHash(storedHash);
     }
+
     this.toolbar.setPageNumber(this.pdfViewer.currentPageNumber, this.pdfViewer.currentPageLabel);
     this.secondaryToolbar.setPageNumber(this.pdfViewer.currentPageNumber);
+
     if (!this.pdfViewer.currentScaleValue) {
       this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
     }
@@ -929,8 +1306,10 @@ var PDFViewerApplication = {
     if (!this.pdfDocument) {
       return;
     }
+
     this.pdfViewer.cleanup();
     this.pdfThumbnailViewer.cleanup();
+
     if (this.pdfViewer.renderer !== _ui_utils.RendererType.SVG) {
       this.pdfDocument.cleanup();
     }
@@ -941,23 +1320,26 @@ var PDFViewerApplication = {
     this.pdfRenderingQueue.renderHighestPriority();
   },
   beforePrint: function beforePrint() {
-    var _this8 = this;
+    var _this7 = this;
 
     if (this.printService) {
       return;
     }
+
     if (!this.supportsPrinting) {
       this.l10n.get('printing_not_supported', null, 'Warning: Printing is not fully supported by ' + 'this browser.').then(function (printMessage) {
-        _this8.error(printMessage);
+        _this7.error(printMessage);
       });
       return;
     }
+
     if (!this.pdfViewer.pageViewsReady) {
       this.l10n.get('printing_not_ready', null, 'Warning: The PDF is not fully loaded for printing.').then(function (notReadyMessage) {
         window.alert(notReadyMessage);
       });
       return;
     }
+
     var pagesOverview = this.pdfViewer.getPagesOverview();
     var printContainer = this.appConfig.printContainer;
     var printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, this.l10n);
@@ -965,18 +1347,19 @@ var PDFViewerApplication = {
     this.forceRendering();
     printService.layout();
   },
-
-  afterPrint: function pdfViewSetupAfterPrint() {
+  afterPrint: function afterPrint() {
     if (this.printService) {
       this.printService.destroy();
       this.printService = null;
     }
+
     this.forceRendering();
   },
   rotatePages: function rotatePages(delta) {
     if (!this.pdfDocument) {
       return;
     }
+
     var newRotation = (this.pdfViewer.pagesRotation + 360 + delta) % 360;
     this.pdfViewer.pagesRotation = newRotation;
   },
@@ -984,12 +1367,12 @@ var PDFViewerApplication = {
     if (!this.pdfPresentationMode) {
       return;
     }
+
     this.pdfPresentationMode.request();
   },
   bindEvents: function bindEvents() {
     var eventBus = this.eventBus,
         _boundEvents = this._boundEvents;
-
     _boundEvents.beforePrint = this.beforePrint.bind(this);
     _boundEvents.afterPrint = this.afterPrint.bind(this);
     eventBus.on('resize', webViewerResize);
@@ -1016,6 +1399,7 @@ var PDFViewerApplication = {
     eventBus.on('previouspage', webViewerPreviousPage);
     eventBus.on('zoomin', webViewerZoomIn);
     eventBus.on('zoomout', webViewerZoomOut);
+    eventBus.on('zoomreset', webViewerZoomReset);
     eventBus.on('pagenumberchanged', webViewerPageNumberChanged);
     eventBus.on('scalechanged', webViewerScaleChanged);
     eventBus.on('rotatecw', webViewerRotateCw);
@@ -1027,6 +1411,8 @@ var PDFViewerApplication = {
     eventBus.on('documentproperties', webViewerDocumentProperties);
     eventBus.on('find', webViewerFind);
     eventBus.on('findfromurlhash', webViewerFindFromUrlHash);
+    eventBus.on('updatefindmatchescount', webViewerUpdateFindMatchesCount);
+    eventBus.on('updatefindcontrolstate', webViewerUpdateFindControlState);
     eventBus.on('fileinputchange', webViewerFileInputChange);
   },
   bindWindowEvents: function bindWindowEvents() {
@@ -1034,18 +1420,34 @@ var PDFViewerApplication = {
         _boundEvents = this._boundEvents;
 
     _boundEvents.windowResize = function () {
-      eventBus.dispatch('resize', { source: window });
+      eventBus.dispatch('resize', {
+        source: window
+      });
     };
+
     _boundEvents.windowHashChange = function () {
-      eventBus.dispatch('hashchange', { hash: document.location.hash.substring(1) });
+      eventBus.dispatch('hashchange', {
+        source: window,
+        hash: document.location.hash.substring(1)
+      });
     };
+
     _boundEvents.windowBeforePrint = function () {
-      eventBus.dispatch('beforeprint');
+      eventBus.dispatch('beforeprint', {
+        source: window
+      });
     };
+
     _boundEvents.windowAfterPrint = function () {
-      eventBus.dispatch('afterprint');
+      eventBus.dispatch('afterprint', {
+        source: window
+      });
     };
-    window.addEventListener('wheel', webViewerWheel);
+
+    window.addEventListener('visibilitychange', webViewerVisibilityChange);
+    window.addEventListener('wheel', webViewerWheel, {
+      passive: false
+    });
     window.addEventListener('click', webViewerClick);
     window.addEventListener('keydown', webViewerKeyDown);
     window.addEventListener('resize', _boundEvents.windowResize);
@@ -1056,7 +1458,6 @@ var PDFViewerApplication = {
   unbindEvents: function unbindEvents() {
     var eventBus = this.eventBus,
         _boundEvents = this._boundEvents;
-
     eventBus.off('resize', webViewerResize);
     eventBus.off('hashchange', webViewerHashchange);
     eventBus.off('beforeprint', _boundEvents.beforePrint);
@@ -1081,6 +1482,7 @@ var PDFViewerApplication = {
     eventBus.off('previouspage', webViewerPreviousPage);
     eventBus.off('zoomin', webViewerZoomIn);
     eventBus.off('zoomout', webViewerZoomOut);
+    eventBus.off('zoomreset', webViewerZoomReset);
     eventBus.off('pagenumberchanged', webViewerPageNumberChanged);
     eventBus.off('scalechanged', webViewerScaleChanged);
     eventBus.off('rotatecw', webViewerRotateCw);
@@ -1092,13 +1494,15 @@ var PDFViewerApplication = {
     eventBus.off('documentproperties', webViewerDocumentProperties);
     eventBus.off('find', webViewerFind);
     eventBus.off('findfromurlhash', webViewerFindFromUrlHash);
+    eventBus.off('updatefindmatchescount', webViewerUpdateFindMatchesCount);
+    eventBus.off('updatefindcontrolstate', webViewerUpdateFindControlState);
     eventBus.off('fileinputchange', webViewerFileInputChange);
     _boundEvents.beforePrint = null;
     _boundEvents.afterPrint = null;
   },
   unbindWindowEvents: function unbindWindowEvents() {
     var _boundEvents = this._boundEvents;
-
+    window.removeEventListener('visibilitychange', webViewerVisibilityChange);
     window.removeEventListener('wheel', webViewerWheel);
     window.removeEventListener('click', webViewerClick);
     window.removeEventListener('keydown', webViewerKeyDown);
@@ -1112,22 +1516,26 @@ var PDFViewerApplication = {
     _boundEvents.windowAfterPrint = null;
   }
 };
-var validateFileURL = void 0;
+exports.PDFViewerApplication = PDFViewerApplication;
+var validateFileURL;
 {
   var HOSTED_VIEWER_ORIGINS = ['null', 'http://mozilla.github.io', 'https://mozilla.github.io'];
+
   validateFileURL = function validateFileURL(file) {
     if (file === undefined) {
       return;
     }
+
     try {
       var viewerOrigin = new URL(window.location.href).origin || 'null';
+
       if (HOSTED_VIEWER_ORIGINS.includes(viewerOrigin)) {
         return;
       }
 
-      var _ref6 = new URL(file, window.location.href),
-          origin = _ref6.origin,
-          protocol = _ref6.protocol;
+      var _ref8 = new URL(file, window.location.href),
+          origin = _ref8.origin,
+          protocol = _ref8.protocol;
 
       if (origin !== viewerOrigin && protocol !== 'blob:') {
         throw new Error('file origin does not match viewer\'s');
@@ -1135,47 +1543,37 @@ var validateFileURL = void 0;
     } catch (ex) {
       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 });
+        PDFViewerApplication.error(loadingErrorMessage, {
+          message: message
+        });
       });
       throw ex;
     }
   };
 }
+
 function loadFakeWorker() {
-  return new Promise(function (resolve, reject) {
-    if (!_pdf.GlobalWorkerOptions.workerSrc) {
-      _pdf.GlobalWorkerOptions.workerSrc = _app_options.AppOptions.get('workerSrc');
-    }
-    var script = document.createElement('script');
-    script.src = _pdf.PDFWorker.getWorkerSrc();
-    script.onload = function () {
-      resolve();
-    };
-    script.onerror = function () {
-      reject(new Error('Cannot load fake worker at: ' + script.src));
-    };
-    (document.head || document.documentElement).appendChild(script);
-  });
+  if (!_pdf.GlobalWorkerOptions.workerSrc) {
+    _pdf.GlobalWorkerOptions.workerSrc = _app_options.AppOptions.get('workerSrc');
+  }
+
+  return (0, _pdf.loadScript)(_pdf.PDFWorker.getWorkerSrc());
 }
+
 function loadAndEnablePDFBug(enabledTabs) {
-  return new Promise(function (resolve, reject) {
-    var appConfig = PDFViewerApplication.appConfig;
-    var script = document.createElement('script');
-    script.src = appConfig.debuggerScriptPath;
-    script.onload = function () {
-      PDFBug.enable(enabledTabs);
-      PDFBug.init({ OPS: _pdf.OPS }, appConfig.mainContainer);
-      resolve();
-    };
-    script.onerror = function () {
-      reject(new Error('Cannot load debugger at ' + script.src));
-    };
-    (document.getElementsByTagName('head')[0] || document.body).appendChild(script);
+  var appConfig = PDFViewerApplication.appConfig;
+  return (0, _pdf.loadScript)(appConfig.debuggerScriptPath).then(function () {
+    PDFBug.enable(enabledTabs);
+    PDFBug.init({
+      OPS: _pdf.OPS,
+      createObjectURL: _pdf.createObjectURL
+    }, appConfig.mainContainer);
   });
 }
+
 function webViewerInitialized() {
   var appConfig = PDFViewerApplication.appConfig;
-  var file = void 0;
+  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');
@@ -1186,155 +1584,205 @@ function webViewerInitialized() {
   fileInput.setAttribute('type', 'file');
   fileInput.oncontextmenu = _ui_utils.noContextMenuHandler;
   document.body.appendChild(fileInput);
+
   if (!window.File || !window.FileReader || !window.FileList || !window.Blob) {
     appConfig.toolbar.openFile.setAttribute('hidden', 'true');
     appConfig.secondaryToolbar.openFileButton.setAttribute('hidden', 'true');
   } else {
     fileInput.value = null;
   }
+
   fileInput.addEventListener('change', function (evt) {
     var files = evt.target.files;
+
+    if (!files || files.length === 0) {
+      return;
+    }
+
+    PDFViewerApplication.eventBus.dispatch('fileinputchange', {
+      source: this,
+      fileInput: evt.target
+    });
+  });
+  appConfig.mainContainer.addEventListener('dragover', function (evt) {
+    evt.preventDefault();
+    evt.dataTransfer.dropEffect = 'move';
+  });
+  appConfig.mainContainer.addEventListener('drop', function (evt) {
+    evt.preventDefault();
+    var files = evt.dataTransfer.files;
+
     if (!files || files.length === 0) {
       return;
     }
-    PDFViewerApplication.eventBus.dispatch('fileinputchange', { fileInput: evt.target });
+
+    PDFViewerApplication.eventBus.dispatch('fileinputchange', {
+      source: this,
+      fileInput: evt.dataTransfer
+    });
   });
+
   if (!PDFViewerApplication.supportsPrinting) {
     appConfig.toolbar.print.classList.add('hidden');
     appConfig.secondaryToolbar.printButton.classList.add('hidden');
   }
+
   if (!PDFViewerApplication.supportsFullscreen) {
     appConfig.toolbar.presentationModeButton.classList.add('hidden');
     appConfig.secondaryToolbar.presentationModeButton.classList.add('hidden');
   }
+
   if (PDFViewerApplication.supportsIntegratedFind) {
     appConfig.toolbar.viewFind.classList.add('hidden');
   }
+
   appConfig.mainContainer.addEventListener('transitionend', function (evt) {
     if (evt.target === this) {
-      PDFViewerApplication.eventBus.dispatch('resize', { source: this });
+      PDFViewerApplication.eventBus.dispatch('resize', {
+        source: this
+      });
     }
   }, true);
-  appConfig.sidebar.toggleButton.addEventListener('click', function () {
-    PDFViewerApplication.pdfSidebar.toggle();
-  });
-  Promise.resolve().then(function () {
+
+  try {
     webViewerOpenFileViaURL(file);
-  }).catch(function (reason) {
+  } catch (reason) {
     PDFViewerApplication.l10n.get('loading_error', null, 'An error occurred while loading the PDF.').then(function (msg) {
       PDFViewerApplication.error(msg, reason);
     });
-  });
+  }
 }
-var webViewerOpenFileViaURL = void 0;
+
+var webViewerOpenFileViaURL;
 {
   webViewerOpenFileViaURL = function webViewerOpenFileViaURL(file) {
     if (file && file.lastIndexOf('file:', 0) === 0) {
       PDFViewerApplication.setTitleUsingUrl(file);
       var xhr = new XMLHttpRequest();
+
       xhr.onload = function () {
         PDFViewerApplication.open(new Uint8Array(xhr.response));
       };
-      try {
-        xhr.open('GET', file);
-        xhr.responseType = 'arraybuffer';
-        xhr.send();
-      } catch (ex) {
-        throw ex;
-      }
+
+      xhr.open('GET', file);
+      xhr.responseType = 'arraybuffer';
+      xhr.send();
       return;
     }
+
     if (file) {
       PDFViewerApplication.open(file);
     }
   };
 }
+
 function webViewerPageRendered(evt) {
   var pageNumber = evt.pageNumber;
   var pageIndex = pageNumber - 1;
   var pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
+
   if (pageNumber === PDFViewerApplication.page) {
     PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
   }
+
   if (!pageView) {
     return;
   }
+
   if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
     var thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
     thumbnailView.setImage(pageView);
   }
+
   if (typeof Stats !== 'undefined' && Stats.enabled && pageView.stats) {
     Stats.add(pageNumber, pageView.stats);
   }
+
   if (pageView.error) {
     PDFViewerApplication.l10n.get('rendering_error', null, 'An error occurred while rendering the page.').then(function (msg) {
       PDFViewerApplication.error(msg, pageView.error);
     });
   }
 }
+
 function webViewerTextLayerRendered(evt) {}
+
 function webViewerPageMode(evt) {
   var mode = evt.mode,
-      view = void 0;
+      view;
+
   switch (mode) {
     case 'thumbs':
       view = _pdf_sidebar.SidebarView.THUMBS;
       break;
+
     case 'bookmarks':
     case 'outline':
       view = _pdf_sidebar.SidebarView.OUTLINE;
       break;
+
     case 'attachments':
       view = _pdf_sidebar.SidebarView.ATTACHMENTS;
       break;
+
     case 'none':
       view = _pdf_sidebar.SidebarView.NONE;
       break;
+
     default:
       console.error('Invalid "pagemode" hash parameter: ' + mode);
       return;
   }
+
   PDFViewerApplication.pdfSidebar.switchView(view, true);
 }
+
 function webViewerNamedAction(evt) {
   var action = evt.action;
+
   switch (action) {
     case 'GoToPage':
       PDFViewerApplication.appConfig.toolbar.pageNumber.select();
       break;
+
     case 'Find':
       if (!PDFViewerApplication.supportsIntegratedFind) {
         PDFViewerApplication.findBar.toggle();
       }
+
       break;
   }
 }
+
 function webViewerPresentationModeChanged(evt) {
   var active = evt.active,
       switchInProgress = evt.switchInProgress;
-
   PDFViewerApplication.pdfViewer.presentationModeState = switchInProgress ? _ui_utils.PresentationModeState.CHANGING : active ? _ui_utils.PresentationModeState.FULLSCREEN : _ui_utils.PresentationModeState.NORMAL;
 }
+
 function webViewerSidebarViewChanged(evt) {
   PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar.isThumbnailViewVisible;
   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) {
   var location = evt.location,
       store = PDFViewerApplication.store;
+
   if (store && PDFViewerApplication.isInitialViewSet) {
     store.setMultiple({
-      'exists': true,
       'page': location.pageNumber,
       'zoom': location.scale,
       'scrollLeft': location.left,
       'scrollTop': location.top,
       'rotation': location.rotation
-    }).catch(function () {});
+    })["catch"](function () {});
   }
+
   var href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
   PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
   PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
@@ -1342,18 +1790,23 @@ function webViewerUpdateViewarea(evt) {
   var loading = currentPage.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED;
   PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
 }
+
 function webViewerScrollModeChanged(evt) {
   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) {
   var store = PDFViewerApplication.store;
+
   if (store && PDFViewerApplication.isInitialViewSet) {
-    store.set('spreadMode', evt.mode).catch(function () {});
+    store.set('spreadMode', evt.mode)["catch"](function () {});
   }
 }
+
 function webViewerResize() {
   var pdfDocument = PDFViewerApplication.pdfDocument,
       pdfViewer = PDFViewerApplication.pdfViewer;
@@ -1361,38 +1814,62 @@ function webViewerResize() {
   if (!pdfDocument) {
     return;
   }
+
   var currentScaleValue = pdfViewer.currentScaleValue;
+
   if (currentScaleValue === 'auto' || currentScaleValue === 'page-fit' || currentScaleValue === 'page-width') {
     pdfViewer.currentScaleValue = currentScaleValue;
   }
+
   pdfViewer.update();
 }
+
 function webViewerHashchange(evt) {
   var hash = evt.hash;
+
   if (!hash) {
     return;
   }
+
   if (!PDFViewerApplication.isInitialViewSet) {
     PDFViewerApplication.initialBookmark = hash;
   } else if (!PDFViewerApplication.pdfHistory.popStateInProgress) {
     PDFViewerApplication.pdfLinkService.setHash(hash);
   }
 }
-var webViewerFileInputChange = void 0;
+
+var webViewerFileInputChange;
 {
   webViewerFileInputChange = function webViewerFileInputChange(evt) {
+    if (PDFViewerApplication.pdfViewer && PDFViewerApplication.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
     var file = evt.fileInput.files[0];
+
     if (URL.createObjectURL && !_app_options.AppOptions.get('disableCreateObjectURL')) {
-      PDFViewerApplication.open(URL.createObjectURL(file));
+      var url = URL.createObjectURL(file);
+
+      if (file.name) {
+        url = {
+          url: url,
+          originalUrl: file.name
+        };
+      }
+
+      PDFViewerApplication.open(url);
     } else {
+      PDFViewerApplication.setTitleUsingUrl(file.name);
       var fileReader = new FileReader();
+
       fileReader.onload = function webViewerChangeFileReaderOnload(evt) {
         var buffer = evt.target.result;
         PDFViewerApplication.open(new Uint8Array(buffer));
       };
+
       fileReader.readAsArrayBuffer(file);
     }
-    PDFViewerApplication.setTitleUsingUrl(file.name);
+
     var appConfig = PDFViewerApplication.appConfig;
     appConfig.toolbar.viewBookmark.setAttribute('hidden', 'true');
     appConfig.secondaryToolbar.viewBookmarkButton.setAttribute('hidden', 'true');
@@ -1400,133 +1877,215 @@ var webViewerFileInputChange = void 0;
     appConfig.secondaryToolbar.downloadButton.setAttribute('hidden', 'true');
   };
 }
+
 function webViewerPresentationMode() {
   PDFViewerApplication.requestPresentationMode();
 }
+
 function webViewerOpenFile() {
   var openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
   document.getElementById(openFileInputName).click();
 }
+
 function webViewerPrint() {
   window.print();
 }
+
 function webViewerDownload() {
   PDFViewerApplication.download();
 }
+
 function webViewerFirstPage() {
   if (PDFViewerApplication.pdfDocument) {
     PDFViewerApplication.page = 1;
   }
 }
+
 function webViewerLastPage() {
   if (PDFViewerApplication.pdfDocument) {
     PDFViewerApplication.page = PDFViewerApplication.pagesCount;
   }
 }
+
 function webViewerNextPage() {
   PDFViewerApplication.page++;
 }
+
 function webViewerPreviousPage() {
   PDFViewerApplication.page--;
 }
+
 function webViewerZoomIn() {
   PDFViewerApplication.zoomIn();
 }
+
 function webViewerZoomOut() {
   PDFViewerApplication.zoomOut();
 }
+
+function webViewerZoomReset() {
+  PDFViewerApplication.zoomReset();
+}
+
 function webViewerPageNumberChanged(evt) {
   var pdfViewer = PDFViewerApplication.pdfViewer;
-  pdfViewer.currentPageLabel = evt.value;
+
+  if (evt.value !== '') {
+    pdfViewer.currentPageLabel = evt.value;
+  }
+
   if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer.currentPageLabel) {
     PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
   }
 }
+
 function webViewerScaleChanged(evt) {
   PDFViewerApplication.pdfViewer.currentScaleValue = evt.value;
 }
+
 function webViewerRotateCw() {
   PDFViewerApplication.rotatePages(90);
 }
+
 function webViewerRotateCcw() {
   PDFViewerApplication.rotatePages(-90);
 }
+
 function webViewerSwitchScrollMode(evt) {
-  PDFViewerApplication.pdfViewer.setScrollMode(evt.mode);
+  PDFViewerApplication.pdfViewer.scrollMode = evt.mode;
 }
+
 function webViewerSwitchSpreadMode(evt) {
-  PDFViewerApplication.pdfViewer.setSpreadMode(evt.mode);
+  PDFViewerApplication.pdfViewer.spreadMode = evt.mode;
 }
+
 function webViewerDocumentProperties() {
   PDFViewerApplication.pdfDocumentProperties.open();
 }
+
 function webViewerFind(evt) {
   PDFViewerApplication.findController.executeCommand('find' + evt.type, {
     query: evt.query,
     phraseSearch: evt.phraseSearch,
     caseSensitive: evt.caseSensitive,
+    entireWord: evt.entireWord,
     highlightAll: evt.highlightAll,
     findPrevious: evt.findPrevious
   });
 }
+
 function webViewerFindFromUrlHash(evt) {
   PDFViewerApplication.findController.executeCommand('find', {
     query: evt.query,
     phraseSearch: evt.phraseSearch,
     caseSensitive: false,
+    entireWord: false,
     highlightAll: true,
     findPrevious: false
   });
 }
+
+function webViewerUpdateFindMatchesCount(_ref9) {
+  var matchesCount = _ref9.matchesCount;
+
+  if (PDFViewerApplication.supportsIntegratedFind) {
+    PDFViewerApplication.externalServices.updateFindMatchesCount(matchesCount);
+  } else {
+    PDFViewerApplication.findBar.updateResultsCount(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
+    });
+  } else {
+    PDFViewerApplication.findBar.updateUIState(state, previous, matchesCount);
+  }
+}
+
 function webViewerScaleChanging(evt) {
   PDFViewerApplication.toolbar.setPageScale(evt.presetValue, evt.scale);
   PDFViewerApplication.pdfViewer.update();
 }
+
 function webViewerRotationChanging(evt) {
   PDFViewerApplication.pdfThumbnailViewer.pagesRotation = evt.pagesRotation;
   PDFViewerApplication.forceRendering();
   PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
 }
+
 function webViewerPageChanging(evt) {
   var page = evt.pageNumber;
   PDFViewerApplication.toolbar.setPageNumber(page, evt.pageLabel || null);
   PDFViewerApplication.secondaryToolbar.setPageNumber(page);
+
   if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
     PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(page);
   }
+
   if (typeof Stats !== 'undefined' && Stats.enabled) {
     var pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
+
     if (pageView && pageView.stats) {
       Stats.add(page, pageView.stats);
     }
   }
 }
-var zoomDisabled = false,
-    zoomDisabledTimeout = void 0;
+
+function webViewerVisibilityChange(evt) {
+  if (document.visibilityState === 'visible') {
+    setZoomDisabledTimeout();
+  }
+}
+
+var zoomDisabledTimeout = null;
+
+function setZoomDisabledTimeout() {
+  if (zoomDisabledTimeout) {
+    clearTimeout(zoomDisabledTimeout);
+  }
+
+  zoomDisabledTimeout = setTimeout(function () {
+    zoomDisabledTimeout = null;
+  }, WHEEL_ZOOM_DISABLED_TIMEOUT);
+}
+
 function webViewerWheel(evt) {
-  var pdfViewer = PDFViewerApplication.pdfViewer;
+  var pdfViewer = PDFViewerApplication.pdfViewer,
+      supportedMouseWheelZoomModifierKeys = PDFViewerApplication.supportedMouseWheelZoomModifierKeys;
+
   if (pdfViewer.isInPresentationMode) {
     return;
   }
-  if (evt.ctrlKey || evt.metaKey) {
-    var support = PDFViewerApplication.supportedMouseWheelZoomModifierKeys;
-    if (evt.ctrlKey && !support.ctrlKey || evt.metaKey && !support.metaKey) {
-      return;
-    }
+
+  if (evt.ctrlKey && supportedMouseWheelZoomModifierKeys.ctrlKey || evt.metaKey && supportedMouseWheelZoomModifierKeys.metaKey) {
     evt.preventDefault();
-    if (zoomDisabled) {
+
+    if (zoomDisabledTimeout || document.visibilityState === 'hidden') {
       return;
     }
+
     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);
     } else {
       PDFViewerApplication.zoomIn(ticks);
     }
+
     var currentScale = pdfViewer.currentScale;
+
     if (previousScale !== currentScale) {
       var scaleCorrectionFactor = currentScale / previousScale - 1;
       var rect = pdfViewer.container.getBoundingClientRect();
@@ -1536,31 +2095,33 @@ function webViewerWheel(evt) {
       pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
     }
   } else {
-    zoomDisabled = true;
-    clearTimeout(zoomDisabledTimeout);
-    zoomDisabledTimeout = setTimeout(function () {
-      zoomDisabled = false;
-    }, 1000);
+    setZoomDisabledTimeout();
   }
 }
+
 function webViewerClick(evt) {
   if (!PDFViewerApplication.secondaryToolbar.isOpen) {
     return;
   }
+
   var appConfig = PDFViewerApplication.appConfig;
+
   if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
     PDFViewerApplication.secondaryToolbar.close();
   }
 }
+
 function webViewerKeyDown(evt) {
   if (PDFViewerApplication.overlayManager.active) {
     return;
   }
+
   var handled = false,
       ensureViewerFocused = false;
   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) {
       case 70:
@@ -1568,22 +2129,29 @@ function webViewerKeyDown(evt) {
           PDFViewerApplication.findBar.open();
           handled = true;
         }
+
         break;
+
       case 71:
         if (!PDFViewerApplication.supportsIntegratedFind) {
           var findState = PDFViewerApplication.findController.state;
+
           if (findState) {
             PDFViewerApplication.findController.executeCommand('findagain', {
               query: findState.query,
               phraseSearch: findState.phraseSearch,
               caseSensitive: findState.caseSensitive,
+              entireWord: findState.entireWord,
               highlightAll: findState.highlightAll,
               findPrevious: cmd === 5 || cmd === 12
             });
           }
+
           handled = true;
         }
+
         break;
+
       case 61:
       case 107:
       case 187:
@@ -1591,41 +2159,51 @@ function webViewerKeyDown(evt) {
         if (!isViewerInPresentationMode) {
           PDFViewerApplication.zoomIn();
         }
+
         handled = true;
         break;
+
       case 173:
       case 109:
       case 189:
         if (!isViewerInPresentationMode) {
           PDFViewerApplication.zoomOut();
         }
+
         handled = true;
         break;
+
       case 48:
       case 96:
         if (!isViewerInPresentationMode) {
           setTimeout(function () {
-            pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+            PDFViewerApplication.zoomReset();
           });
           handled = false;
         }
+
         break;
+
       case 38:
         if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
           PDFViewerApplication.page = 1;
           handled = true;
           ensureViewerFocused = true;
         }
+
         break;
+
       case 40:
         if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
           PDFViewerApplication.page = PDFViewerApplication.pagesCount;
           handled = true;
           ensureViewerFocused = true;
         }
+
         break;
     }
   }
+
   if (cmd === 1 || cmd === 8) {
     switch (evt.keyCode) {
       case 83:
@@ -1634,113 +2212,147 @@ function webViewerKeyDown(evt) {
         break;
     }
   }
+
   if (cmd === 3 || cmd === 10) {
     switch (evt.keyCode) {
       case 80:
         PDFViewerApplication.requestPresentationMode();
         handled = true;
         break;
+
       case 71:
         PDFViewerApplication.appConfig.toolbar.pageNumber.select();
         handled = true;
         break;
     }
   }
+
   if (handled) {
     if (ensureViewerFocused && !isViewerInPresentationMode) {
       pdfViewer.focus();
     }
+
     evt.preventDefault();
     return;
   }
+
   var curElement = document.activeElement || document.querySelector(':focus');
   var curElementTagName = curElement && curElement.tagName.toUpperCase();
+
   if (curElementTagName === 'INPUT' || curElementTagName === 'TEXTAREA' || curElementTagName === 'SELECT') {
     if (evt.keyCode !== 27) {
       return;
     }
   }
+
   if (cmd === 0) {
     var turnPage = 0,
         turnOnlyIfPageFit = false;
+
     switch (evt.keyCode) {
       case 38:
       case 33:
         if (pdfViewer.isVerticalScrollbarEnabled) {
           turnOnlyIfPageFit = true;
         }
+
         turnPage = -1;
         break;
+
       case 8:
         if (!isViewerInPresentationMode) {
           turnOnlyIfPageFit = true;
         }
+
         turnPage = -1;
         break;
+
       case 37:
         if (pdfViewer.isHorizontalScrollbarEnabled) {
           turnOnlyIfPageFit = true;
         }
+
       case 75:
       case 80:
         turnPage = -1;
         break;
+
       case 27:
         if (PDFViewerApplication.secondaryToolbar.isOpen) {
           PDFViewerApplication.secondaryToolbar.close();
           handled = true;
         }
+
         if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication.findBar.opened) {
           PDFViewerApplication.findBar.close();
           handled = true;
         }
+
         break;
+
       case 40:
       case 34:
         if (pdfViewer.isVerticalScrollbarEnabled) {
           turnOnlyIfPageFit = true;
         }
+
         turnPage = 1;
         break;
+
       case 13:
       case 32:
         if (!isViewerInPresentationMode) {
           turnOnlyIfPageFit = true;
         }
+
         turnPage = 1;
         break;
+
       case 39:
         if (pdfViewer.isHorizontalScrollbarEnabled) {
           turnOnlyIfPageFit = true;
         }
+
       case 74:
       case 78:
         turnPage = 1;
         break;
+
       case 36:
         if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
           PDFViewerApplication.page = 1;
           handled = true;
           ensureViewerFocused = true;
         }
+
         break;
+
       case 35:
         if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
           PDFViewerApplication.page = PDFViewerApplication.pagesCount;
           handled = true;
           ensureViewerFocused = true;
         }
+
         break;
+
       case 83:
         PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.SELECT);
         break;
+
       case 72:
         PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.HAND);
         break;
+
       case 82:
         PDFViewerApplication.rotatePages(90);
         break;
+
+      case 115:
+        PDFViewerApplication.pdfSidebar.toggle();
+        break;
     }
+
     if (turnPage !== 0 && (!turnOnlyIfPageFit || pdfViewer.currentScaleValue === 'page-fit')) {
       if (turnPage > 0) {
         if (PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
@@ -1751,9 +2363,11 @@ function webViewerKeyDown(evt) {
           PDFViewerApplication.page--;
         }
       }
+
       handled = true;
     }
   }
+
   if (cmd === 4) {
     switch (evt.keyCode) {
       case 13:
@@ -1761,42 +2375,73 @@ function webViewerKeyDown(evt) {
         if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
           break;
         }
+
         if (PDFViewerApplication.page > 1) {
           PDFViewerApplication.page--;
         }
+
         handled = true;
         break;
+
       case 82:
         PDFViewerApplication.rotatePages(-90);
         break;
     }
   }
+
   if (!handled && !isViewerInPresentationMode) {
     if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !== 'BUTTON') {
       ensureViewerFocused = true;
     }
   }
+
   if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
     pdfViewer.focus();
   }
+
   if (handled) {
     evt.preventDefault();
   }
 }
+
+function apiPageLayoutToSpreadMode(layout) {
+  switch (layout) {
+    case 'SinglePage':
+    case 'OneColumn':
+      return _ui_utils.SpreadMode.NONE;
+
+    case 'TwoColumnLeft':
+    case 'TwoPageLeft':
+      return _ui_utils.SpreadMode.ODD;
+
+    case 'TwoColumnRight':
+    case 'TwoPageRight':
+      return _ui_utils.SpreadMode.EVEN;
+  }
+
+  return _ui_utils.SpreadMode.NONE;
+}
+
 function apiPageModeToSidebarView(mode) {
   switch (mode) {
     case 'UseNone':
       return _pdf_sidebar.SidebarView.NONE;
+
     case 'UseThumbs':
       return _pdf_sidebar.SidebarView.THUMBS;
+
     case 'UseOutlines':
       return _pdf_sidebar.SidebarView.OUTLINE;
+
     case 'UseAttachments':
       return _pdf_sidebar.SidebarView.ATTACHMENTS;
+
     case 'UseOC':
   }
+
   return _pdf_sidebar.SidebarView.NONE;
 }
+
 var PDFPrintServiceFactory = {
   instance: {
     supportsPrinting: false,
@@ -1805,6 +2450,4 @@ var PDFPrintServiceFactory = {
     }
   }
 };
-exports.PDFViewerApplication = PDFViewerApplication;
-exports.DefaultExternalServices = DefaultExternalServices;
 exports.PDFPrintServiceFactory = PDFPrintServiceFactory;