pdfjs-dist 2.0.550 → 2.3.200

package/lib/web/base_viewer.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,98 +19,106 @@
  * @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.SpreadMode = exports.ScrollMode = exports.BaseViewer = undefined;
+exports.BaseViewer = void 0;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _ui_utils = require("./ui_utils");
 
-var _ui_utils = require('./ui_utils');
+var _pdf_rendering_queue = require("./pdf_rendering_queue");
 
-var _pdf_rendering_queue = require('./pdf_rendering_queue');
+var _annotation_layer_builder = require("./annotation_layer_builder");
 
-var _annotation_layer_builder = require('./annotation_layer_builder');
+var _pdf = require("../pdf");
 
-var _pdf = require('../pdf');
+var _pdf_page_view = require("./pdf_page_view");
 
-var _dom_events = require('./dom_events');
+var _pdf_link_service = require("./pdf_link_service");
 
-var _pdf_page_view = require('./pdf_page_view');
+var _text_layer_builder = require("./text_layer_builder");
 
-var _pdf_link_service = require('./pdf_link_service');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _text_layer_builder = require('./text_layer_builder');
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
 var DEFAULT_CACHE_SIZE = 10;
-var ScrollMode = {
-  VERTICAL: 0,
-  HORIZONTAL: 1,
-  WRAPPED: 2
-};
-var SpreadMode = {
-  NONE: 0,
-  ODD: 1,
-  EVEN: 2
-};
+
 function PDFPageViewBuffer(size) {
   var data = [];
+
   this.push = function (view) {
     var i = data.indexOf(view);
+
     if (i >= 0) {
       data.splice(i, 1);
     }
+
     data.push(view);
+
     if (data.length > size) {
       data.shift().destroy();
     }
   };
+
   this.resize = function (newSize, pagesToKeep) {
     size = newSize;
+
     if (pagesToKeep) {
       var pageIdsToKeep = new Set();
+
       for (var i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
         pageIdsToKeep.add(pagesToKeep[i].id);
       }
+
       (0, _ui_utils.moveToEndOfArray)(data, function (page) {
         return pageIdsToKeep.has(page.id);
       });
     }
+
     while (data.length > size) {
       data.shift().destroy();
     }
   };
 }
+
 function isSameScale(oldScale, newScale) {
   if (newScale === oldScale) {
     return true;
   }
+
   if (Math.abs(newScale - oldScale) < 1e-15) {
     return true;
   }
+
   return false;
 }
 
-var BaseViewer = function () {
+var BaseViewer =
+/*#__PURE__*/
+function () {
   function BaseViewer(options) {
+    var _this = this;
+
     _classCallCheck(this, BaseViewer);
 
     if (this.constructor === BaseViewer) {
       throw new Error('Cannot initialize BaseViewer.');
     }
+
     this._name = this.constructor.name;
     this.container = options.container;
     this.viewer = options.viewer || options.container.firstElementChild;
-    this.eventBus = options.eventBus || (0, _dom_events.getGlobalEventBus)();
+    this.eventBus = options.eventBus || (0, _ui_utils.getGlobalEventBus)();
     this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService();
     this.downloadManager = options.downloadManager || null;
+    this.findController = options.findController || null;
     this.removePageBorders = options.removePageBorders || false;
     this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE;
-    this.enhanceTextSelection = options.enhanceTextSelection || false;
     this.imageResourcesPath = options.imageResourcesPath || '';
     this.renderInteractiveForms = options.renderInteractiveForms || false;
     this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
@@ -119,31 +127,39 @@ var BaseViewer = function () {
     this.useOnlyCssZoom = options.useOnlyCssZoom || false;
     this.maxCanvasPixels = options.maxCanvasPixels;
     this.l10n = options.l10n || _ui_utils.NullL10n;
-    this.scrollMode = options.scrollMode || ScrollMode.VERTICAL;
-    this.spreadMode = options.spreadMode || SpreadMode.NONE;
     this.defaultRenderingQueue = !options.renderingQueue;
+
     if (this.defaultRenderingQueue) {
       this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
       this.renderingQueue.setViewer(this);
     } else {
       this.renderingQueue = options.renderingQueue;
     }
+
     this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this));
     this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
+    this._onBeforeDraw = this._onAfterDraw = null;
+
     this._resetView();
+
     if (this.removePageBorders) {
       this.viewer.classList.add('removePageBorders');
     }
-    this._updateScrollModeClasses();
+
+    Promise.resolve().then(function () {
+      _this.eventBus.dispatch('baseviewerinit', {
+        source: _this
+      });
+    });
   }
 
   _createClass(BaseViewer, [{
-    key: 'getPageView',
+    key: "getPageView",
     value: function getPageView(index) {
       return this._pages[index];
     }
   }, {
-    key: '_setCurrentPageNumber',
+    key: "_setCurrentPageNumber",
     value: function _setCurrentPageNumber(val) {
       var resetCurrentPageView = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
@@ -151,114 +167,156 @@ var BaseViewer = function () {
         if (resetCurrentPageView) {
           this._resetCurrentPageView();
         }
-        return;
+
+        return true;
       }
+
       if (!(0 < val && val <= this.pagesCount)) {
-        console.error(this._name + '._setCurrentPageNumber: "' + val + '" is out of bounds.');
-        return;
+        return false;
       }
-      var arg = {
+
+      this._currentPageNumber = val;
+      this.eventBus.dispatch('pagechanging', {
         source: this,
         pageNumber: val,
         pageLabel: this._pageLabels && this._pageLabels[val - 1]
-      };
-      this._currentPageNumber = val;
-      this.eventBus.dispatch('pagechanging', arg);
-      this.eventBus.dispatch('pagechange', arg);
+      });
+
       if (resetCurrentPageView) {
         this._resetCurrentPageView();
       }
+
+      return true;
     }
   }, {
-    key: 'setDocument',
+    key: "setDocument",
     value: function setDocument(pdfDocument) {
-      var _this = this;
+      var _this2 = this;
 
       if (this.pdfDocument) {
         this._cancelRendering();
+
         this._resetView();
+
+        if (this.findController) {
+          this.findController.setDocument(null);
+        }
       }
+
       this.pdfDocument = pdfDocument;
+
       if (!pdfDocument) {
         return;
       }
+
       var pagesCount = pdfDocument.numPages;
       var pagesCapability = (0, _pdf.createPromiseCapability)();
       this.pagesPromise = pagesCapability.promise;
       pagesCapability.promise.then(function () {
-        _this._pageViewsReady = true;
-        _this.eventBus.dispatch('pagesloaded', {
-          source: _this,
+        _this2._pageViewsReady = true;
+
+        _this2.eventBus.dispatch('pagesloaded', {
+          source: _this2,
           pagesCount: pagesCount
         });
       });
-      var isOnePageRenderedResolved = false;
       var onePageRenderedCapability = (0, _pdf.createPromiseCapability)();
       this.onePageRendered = onePageRenderedCapability.promise;
-      var bindOnAfterAndBeforeDraw = function bindOnAfterAndBeforeDraw(pageView) {
-        pageView.onBeforeDraw = function () {
-          _this._buffer.push(pageView);
-        };
-        pageView.onAfterDraw = function () {
-          if (!isOnePageRenderedResolved) {
-            isOnePageRenderedResolved = true;
-            onePageRenderedCapability.resolve();
-          }
-        };
-      };
       var firstPagePromise = pdfDocument.getPage(1);
       this.firstPagePromise = firstPagePromise;
+
+      this._onBeforeDraw = function (evt) {
+        var pageView = _this2._pages[evt.pageNumber - 1];
+
+        if (!pageView) {
+          return;
+        }
+
+        _this2._buffer.push(pageView);
+      };
+
+      this.eventBus.on('pagerender', this._onBeforeDraw);
+
+      this._onAfterDraw = function (evt) {
+        if (evt.cssTransform || onePageRenderedCapability.settled) {
+          return;
+        }
+
+        onePageRenderedCapability.resolve();
+
+        _this2.eventBus.off('pagerendered', _this2._onAfterDraw);
+
+        _this2._onAfterDraw = null;
+      };
+
+      this.eventBus.on('pagerendered', this._onAfterDraw);
       firstPagePromise.then(function (pdfPage) {
-        var scale = _this.currentScale;
-        var viewport = pdfPage.getViewport(scale * _ui_utils.CSS_UNITS);
+        var scale = _this2.currentScale;
+        var viewport = pdfPage.getViewport({
+          scale: scale * _ui_utils.CSS_UNITS
+        });
+
         for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
           var textLayerFactory = null;
-          if (_this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE) {
-            textLayerFactory = _this;
+
+          if (_this2.textLayerMode !== _ui_utils.TextLayerMode.DISABLE) {
+            textLayerFactory = _this2;
           }
+
           var pageView = new _pdf_page_view.PDFPageView({
-            container: _this._setDocumentViewerElement,
-            eventBus: _this.eventBus,
+            container: _this2._setDocumentViewerElement,
+            eventBus: _this2.eventBus,
             id: pageNum,
             scale: scale,
             defaultViewport: viewport.clone(),
-            renderingQueue: _this.renderingQueue,
+            renderingQueue: _this2.renderingQueue,
             textLayerFactory: textLayerFactory,
-            textLayerMode: _this.textLayerMode,
-            annotationLayerFactory: _this,
-            imageResourcesPath: _this.imageResourcesPath,
-            renderInteractiveForms: _this.renderInteractiveForms,
-            renderer: _this.renderer,
-            enableWebGL: _this.enableWebGL,
-            useOnlyCssZoom: _this.useOnlyCssZoom,
-            maxCanvasPixels: _this.maxCanvasPixels,
-            l10n: _this.l10n
+            textLayerMode: _this2.textLayerMode,
+            annotationLayerFactory: _this2,
+            imageResourcesPath: _this2.imageResourcesPath,
+            renderInteractiveForms: _this2.renderInteractiveForms,
+            renderer: _this2.renderer,
+            enableWebGL: _this2.enableWebGL,
+            useOnlyCssZoom: _this2.useOnlyCssZoom,
+            maxCanvasPixels: _this2.maxCanvasPixels,
+            l10n: _this2.l10n
           });
-          bindOnAfterAndBeforeDraw(pageView);
-          _this._pages.push(pageView);
+
+          _this2._pages.push(pageView);
         }
-        if (_this.spreadMode !== SpreadMode.NONE) {
-          _this._regroupSpreads();
+
+        if (_this2._spreadMode !== _ui_utils.SpreadMode.NONE) {
+          _this2._updateSpreadMode();
         }
+
         onePageRenderedCapability.promise.then(function () {
+          if (_this2.findController) {
+            _this2.findController.setDocument(pdfDocument);
+          }
+
           if (pdfDocument.loadingParams['disableAutoFetch']) {
             pagesCapability.resolve();
             return;
           }
+
           var getPagesLeft = pagesCount;
 
           var _loop = function _loop(_pageNum) {
             pdfDocument.getPage(_pageNum).then(function (pdfPage) {
-              var pageView = _this._pages[_pageNum - 1];
+              var pageView = _this2._pages[_pageNum - 1];
+
               if (!pageView.pdfPage) {
                 pageView.setPdfPage(pdfPage);
               }
-              _this.linkService.cachePageRef(_pageNum, pdfPage.ref);
+
+              _this2.linkService.cachePageRef(_pageNum, pdfPage.ref);
+
               if (--getPagesLeft === 0) {
                 pagesCapability.resolve();
               }
             }, function (reason) {
-              console.error('Unable to get page ' + _pageNum + ' to initialize viewer', reason);
+              console.error("Unable to get page ".concat(_pageNum, " to initialize viewer"), reason);
+
               if (--getPagesLeft === 0) {
                 pagesCapability.resolve();
               }
@@ -269,31 +327,34 @@ var BaseViewer = function () {
             _loop(_pageNum);
           }
         });
-        _this.eventBus.dispatch('pagesinit', { source: _this });
-        if (_this.defaultRenderingQueue) {
-          _this.update();
-        }
-        if (_this.findController) {
-          _this.findController.resolveFirstPage();
+
+        _this2.eventBus.dispatch('pagesinit', {
+          source: _this2
+        });
+
+        if (_this2.defaultRenderingQueue) {
+          _this2.update();
         }
-      }).catch(function (reason) {
+      })["catch"](function (reason) {
         console.error('Unable to initialize viewer', reason);
       });
     }
   }, {
-    key: 'setPageLabels',
+    key: "setPageLabels",
     value: function setPageLabels(labels) {
       if (!this.pdfDocument) {
         return;
       }
+
       if (!labels) {
         this._pageLabels = null;
-      } else if (!(labels instanceof Array && this.pdfDocument.numPages === labels.length)) {
+      } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
         this._pageLabels = null;
-        console.error(this._name + '.setPageLabels: Invalid page labels.');
+        console.error("".concat(this._name, ".setPageLabels: Invalid page labels."));
       } else {
         this._pageLabels = labels;
       }
+
       for (var i = 0, ii = this._pages.length; i < ii; i++) {
         var pageView = this._pages[i];
         var label = this._pageLabels && this._pageLabels[i];
@@ -301,7 +362,7 @@ var BaseViewer = function () {
       }
     }
   }, {
-    key: '_resetView',
+    key: "_resetView",
     value: function _resetView() {
       this._pages = [];
       this._currentPageNumber = 1;
@@ -313,220 +374,278 @@ var BaseViewer = function () {
       this._pagesRotation = 0;
       this._pagesRequests = [];
       this._pageViewsReady = false;
+      this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
+      this._spreadMode = _ui_utils.SpreadMode.NONE;
+
+      if (this._onBeforeDraw) {
+        this.eventBus.off('pagerender', this._onBeforeDraw);
+        this._onBeforeDraw = null;
+      }
+
+      if (this._onAfterDraw) {
+        this.eventBus.off('pagerendered', this._onAfterDraw);
+        this._onAfterDraw = null;
+      }
+
       this.viewer.textContent = '';
+
+      this._updateScrollMode();
     }
   }, {
-    key: '_scrollUpdate',
+    key: "_scrollUpdate",
     value: function _scrollUpdate() {
       if (this.pagesCount === 0) {
         return;
       }
+
       this.update();
     }
   }, {
-    key: '_scrollIntoView',
+    key: "_scrollIntoView",
     value: function _scrollIntoView(_ref) {
       var pageDiv = _ref.pageDiv,
           _ref$pageSpot = _ref.pageSpot,
-          pageSpot = _ref$pageSpot === undefined ? null : _ref$pageSpot,
+          pageSpot = _ref$pageSpot === void 0 ? null : _ref$pageSpot,
           _ref$pageNumber = _ref.pageNumber,
-          pageNumber = _ref$pageNumber === undefined ? null : _ref$pageNumber;
-
-      throw new Error('Not implemented: _scrollIntoView');
+          pageNumber = _ref$pageNumber === void 0 ? null : _ref$pageNumber;
+      (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
     }
   }, {
-    key: '_setScaleDispatchEvent',
-    value: function _setScaleDispatchEvent(newScale, newValue) {
-      var preset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-      var arg = {
-        source: this,
-        scale: newScale,
-        presetValue: preset ? newValue : undefined
-      };
-      this.eventBus.dispatch('scalechanging', arg);
-      this.eventBus.dispatch('scalechange', arg);
-    }
-  }, {
-    key: '_setScaleUpdatePages',
+    key: "_setScaleUpdatePages",
     value: function _setScaleUpdatePages(newScale, newValue) {
       var noScroll = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var preset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
       this._currentScaleValue = newValue.toString();
+
       if (isSameScale(this._currentScale, newScale)) {
         if (preset) {
-          this._setScaleDispatchEvent(newScale, newValue, true);
+          this.eventBus.dispatch('scalechanging', {
+            source: this,
+            scale: newScale,
+            presetValue: newValue
+          });
         }
+
         return;
       }
+
       for (var i = 0, ii = this._pages.length; i < ii; i++) {
         this._pages[i].update(newScale);
       }
+
       this._currentScale = newScale;
+
       if (!noScroll) {
         var page = this._currentPageNumber,
-            dest = void 0;
+            dest;
+
         if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
           page = this._location.pageNumber;
-          dest = [null, { name: 'XYZ' }, this._location.left, this._location.top, null];
+          dest = [null, {
+            name: 'XYZ'
+          }, this._location.left, this._location.top, null];
         }
+
         this.scrollPageIntoView({
           pageNumber: page,
           destArray: dest,
           allowNegativeOffset: true
         });
       }
-      this._setScaleDispatchEvent(newScale, newValue, preset);
+
+      this.eventBus.dispatch('scalechanging', {
+        source: this,
+        scale: newScale,
+        presetValue: preset ? newValue : undefined
+      });
+
       if (this.defaultRenderingQueue) {
         this.update();
       }
     }
   }, {
-    key: '_setScale',
+    key: "_setScale",
     value: function _setScale(value) {
       var noScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
       var scale = parseFloat(value);
+
       if (scale > 0) {
         this._setScaleUpdatePages(scale, value, noScroll, false);
       } else {
         var currentPage = this._pages[this._currentPageNumber - 1];
+
         if (!currentPage) {
           return;
         }
-        var hPadding = this.isInPresentationMode || this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
-        var vPadding = this.isInPresentationMode || this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
-        if (this.scrollMode === ScrollMode.HORIZONTAL) {
-          var temp = hPadding;
-          hPadding = vPadding;
-          vPadding = temp;
+
+        var noPadding = this.isInPresentationMode || this.removePageBorders;
+        var hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING;
+        var vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING;
+
+        if (!noPadding && this._isScrollModeHorizontal) {
+          var _ref2 = [vPadding, hPadding];
+          hPadding = _ref2[0];
+          vPadding = _ref2[1];
         }
+
         var pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale;
         var pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
+
         switch (value) {
           case 'page-actual':
             scale = 1;
             break;
+
           case 'page-width':
             scale = pageWidthScale;
             break;
+
           case 'page-height':
             scale = pageHeightScale;
             break;
+
           case 'page-fit':
             scale = Math.min(pageWidthScale, pageHeightScale);
             break;
+
           case 'auto':
             var horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
             scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
             break;
+
           default:
-            console.error(this._name + '._setScale: "' + value + '" is an unknown zoom value.');
+            console.error("".concat(this._name, "._setScale: \"").concat(value, "\" is an unknown zoom value."));
             return;
         }
+
         this._setScaleUpdatePages(scale, value, noScroll, true);
       }
     }
   }, {
-    key: '_resetCurrentPageView',
+    key: "_resetCurrentPageView",
     value: function _resetCurrentPageView() {
       if (this.isInPresentationMode) {
         this._setScale(this._currentScaleValue, true);
       }
+
       var pageView = this._pages[this._currentPageNumber - 1];
-      this._scrollIntoView({ pageDiv: pageView.div });
+
+      this._scrollIntoView({
+        pageDiv: pageView.div
+      });
     }
   }, {
-    key: 'scrollPageIntoView',
-    value: function scrollPageIntoView(params) {
+    key: "scrollPageIntoView",
+    value: function scrollPageIntoView(_ref3) {
+      var pageNumber = _ref3.pageNumber,
+          _ref3$destArray = _ref3.destArray,
+          destArray = _ref3$destArray === void 0 ? null : _ref3$destArray,
+          _ref3$allowNegativeOf = _ref3.allowNegativeOffset,
+          allowNegativeOffset = _ref3$allowNegativeOf === void 0 ? false : _ref3$allowNegativeOf;
+
       if (!this.pdfDocument) {
         return;
       }
-      var pageNumber = params.pageNumber || 0;
-      var dest = params.destArray || null;
-      var allowNegativeOffset = params.allowNegativeOffset || false;
-      if (this.isInPresentationMode || !dest) {
-        this._setCurrentPageNumber(pageNumber, true);
+
+      var pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
+
+      if (!pageView) {
+        console.error("".concat(this._name, ".scrollPageIntoView: ") + "\"".concat(pageNumber, "\" is not a valid pageNumber parameter."));
         return;
       }
-      var pageView = this._pages[pageNumber - 1];
-      if (!pageView) {
-        console.error(this._name + '.scrollPageIntoView: Invalid "pageNumber" parameter.');
+
+      if (this.isInPresentationMode || !destArray) {
+        this._setCurrentPageNumber(pageNumber, true);
+
         return;
       }
+
       var x = 0,
           y = 0;
       var width = 0,
           height = 0,
-          widthScale = void 0,
-          heightScale = void 0;
+          widthScale,
+          heightScale;
       var changeOrientation = pageView.rotation % 180 === 0 ? false : true;
       var pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS;
       var pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS;
       var scale = 0;
-      switch (dest[1].name) {
+
+      switch (destArray[1].name) {
         case 'XYZ':
-          x = dest[2];
-          y = dest[3];
-          scale = dest[4];
+          x = destArray[2];
+          y = destArray[3];
+          scale = destArray[4];
           x = x !== null ? x : 0;
           y = y !== null ? y : pageHeight;
           break;
+
         case 'Fit':
         case 'FitB':
           scale = 'page-fit';
           break;
+
         case 'FitH':
         case 'FitBH':
-          y = dest[2];
+          y = destArray[2];
           scale = 'page-width';
+
           if (y === null && this._location) {
             x = this._location.left;
             y = this._location.top;
           }
+
           break;
+
         case 'FitV':
         case 'FitBV':
-          x = dest[2];
+          x = destArray[2];
           width = pageWidth;
           height = pageHeight;
           scale = 'page-height';
           break;
+
         case 'FitR':
-          x = dest[2];
-          y = dest[3];
-          width = dest[4] - x;
-          height = dest[5] - y;
+          x = destArray[2];
+          y = destArray[3];
+          width = destArray[4] - x;
+          height = destArray[5] - y;
           var hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
           var vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
           widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS;
           heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS;
           scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
           break;
+
         default:
-          console.error(this._name + '.scrollPageIntoView: "' + dest[1].name + '" ' + 'is not a valid destination type.');
+          console.error("".concat(this._name, ".scrollPageIntoView: ") + "\"".concat(destArray[1].name, "\" is not a valid destination type."));
           return;
       }
+
       if (scale && scale !== this._currentScale) {
         this.currentScaleValue = scale;
       } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
         this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
       }
-      if (scale === 'page-fit' && !dest[4]) {
+
+      if (scale === 'page-fit' && !destArray[4]) {
         this._scrollIntoView({
           pageDiv: pageView.div,
           pageNumber: pageNumber
         });
+
         return;
       }
+
       var boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
       var left = Math.min(boundingRect[0][0], boundingRect[1][0]);
       var top = Math.min(boundingRect[0][1], boundingRect[1][1]);
+
       if (!allowNegativeOffset) {
         left = Math.max(left, 0);
         top = Math.max(top, 0);
       }
+
       this._scrollIntoView({
         pageDiv: pageView.div,
         pageSpot: {
@@ -537,13 +656,7 @@ var BaseViewer = function () {
       });
     }
   }, {
-    key: '_resizeBuffer',
-    value: function _resizeBuffer(numVisiblePages, visiblePages) {
-      var suggestedCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
-      this._buffer.resize(suggestedCacheSize, visiblePages);
-    }
-  }, {
-    key: '_updateLocation',
+    key: "_updateLocation",
     value: function _updateLocation(firstPage) {
       var currentScale = this._currentScale;
       var currentScaleValue = this._currentScaleValue;
@@ -567,27 +680,93 @@ var BaseViewer = function () {
       };
     }
   }, {
-    key: 'update',
+    key: "_updateHelper",
+    value: function _updateHelper(visiblePages) {
+      throw new Error('Not implemented: _updateHelper');
+    }
+  }, {
+    key: "update",
     value: function update() {
-      throw new Error('Not implemented: update');
+      var visible = this._getVisiblePages();
+
+      var visiblePages = visible.views,
+          numVisiblePages = visiblePages.length;
+
+      if (numVisiblePages === 0) {
+        return;
+      }
+
+      var newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
+
+      this._buffer.resize(newCacheSize, visiblePages);
+
+      this.renderingQueue.renderHighestPriority(visible);
+
+      this._updateHelper(visiblePages);
+
+      this._updateLocation(visible.first);
+
+      this.eventBus.dispatch('updateviewarea', {
+        source: this,
+        location: this._location
+      });
     }
   }, {
-    key: 'containsElement',
+    key: "containsElement",
     value: function containsElement(element) {
       return this.container.contains(element);
     }
   }, {
-    key: 'focus',
+    key: "focus",
     value: function focus() {
       this.container.focus();
     }
   }, {
-    key: '_getVisiblePages',
+    key: "_getCurrentVisiblePage",
+    value: function _getCurrentVisiblePage() {
+      if (!this.pagesCount) {
+        return {
+          views: []
+        };
+      }
+
+      var pageView = this._pages[this._currentPageNumber - 1];
+      var element = pageView.div;
+      var view = {
+        id: pageView.id,
+        x: element.offsetLeft + element.clientLeft,
+        y: element.offsetTop + element.clientTop,
+        view: pageView
+      };
+      return {
+        first: view,
+        last: view,
+        views: [view]
+      };
+    }
+  }, {
+    key: "_getVisiblePages",
     value: function _getVisiblePages() {
-      throw new Error('Not implemented: _getVisiblePages');
+      return (0, _ui_utils.getVisibleElements)(this.container, this._pages, true, this._isScrollModeHorizontal);
     }
   }, {
-    key: 'cleanup',
+    key: "isPageVisible",
+    value: function isPageVisible(pageNumber) {
+      if (!this.pdfDocument) {
+        return false;
+      }
+
+      if (this.pageNumber < 1 || pageNumber > this.pagesCount) {
+        console.error("".concat(this._name, ".isPageVisible: \"").concat(pageNumber, "\" is out of bounds."));
+        return false;
+      }
+
+      return this._getVisiblePages().views.some(function (view) {
+        return view.id === pageNumber;
+      });
+    }
+  }, {
+    key: "cleanup",
     value: function cleanup() {
       for (var i = 0, ii = this._pages.length; i < ii; i++) {
         if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
@@ -596,7 +775,7 @@ var BaseViewer = function () {
       }
     }
   }, {
-    key: '_cancelRendering',
+    key: "_cancelRendering",
     value: function _cancelRendering() {
       for (var i = 0, ii = this._pages.length; i < ii; i++) {
         if (this._pages[i]) {
@@ -605,58 +784,58 @@ var BaseViewer = function () {
       }
     }
   }, {
-    key: '_ensurePdfPageLoaded',
+    key: "_ensurePdfPageLoaded",
     value: function _ensurePdfPageLoaded(pageView) {
-      var _this2 = this;
+      var _this3 = this;
 
       if (pageView.pdfPage) {
         return Promise.resolve(pageView.pdfPage);
       }
+
       var pageNumber = pageView.id;
+
       if (this._pagesRequests[pageNumber]) {
         return this._pagesRequests[pageNumber];
       }
+
       var promise = this.pdfDocument.getPage(pageNumber).then(function (pdfPage) {
         if (!pageView.pdfPage) {
           pageView.setPdfPage(pdfPage);
         }
-        _this2._pagesRequests[pageNumber] = null;
+
+        _this3._pagesRequests[pageNumber] = null;
         return pdfPage;
-      }).catch(function (reason) {
+      })["catch"](function (reason) {
         console.error('Unable to get page for page view', reason);
-        _this2._pagesRequests[pageNumber] = null;
+        _this3._pagesRequests[pageNumber] = null;
       });
       this._pagesRequests[pageNumber] = promise;
       return promise;
     }
   }, {
-    key: 'forceRendering',
+    key: "forceRendering",
     value: function forceRendering(currentlyVisiblePages) {
-      var _this3 = this;
+      var _this4 = this;
 
       var visiblePages = currentlyVisiblePages || this._getVisiblePages();
-      var scrollAhead = this.scrollMode === ScrollMode.HORIZONTAL ? this.scroll.right : this.scroll.down;
+
+      var scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down;
       var pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead);
+
       if (pageView) {
         this._ensurePdfPageLoaded(pageView).then(function () {
-          _this3.renderingQueue.renderView(pageView);
+          _this4.renderingQueue.renderView(pageView);
         });
+
         return true;
       }
+
       return false;
     }
   }, {
-    key: 'getPageTextContent',
-    value: function getPageTextContent(pageIndex) {
-      return this.pdfDocument.getPage(pageIndex + 1).then(function (page) {
-        return page.getTextContent({ normalizeWhitespace: true });
-      });
-    }
-  }, {
-    key: 'createTextLayerBuilder',
+    key: "createTextLayerBuilder",
     value: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) {
       var enhanceTextSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
       return new _text_layer_builder.TextLayerBuilder({
         textLayerDiv: textLayerDiv,
         eventBus: this.eventBus,
@@ -667,12 +846,11 @@ var BaseViewer = function () {
       });
     }
   }, {
-    key: 'createAnnotationLayerBuilder',
+    key: "createAnnotationLayerBuilder",
     value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
       var imageResourcesPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
       var renderInteractiveForms = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
       var l10n = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _ui_utils.NullL10n;
-
       return new _annotation_layer_builder.AnnotationLayerBuilder({
         pageDiv: pageDiv,
         pdfPage: pdfPage,
@@ -684,29 +862,29 @@ var BaseViewer = function () {
       });
     }
   }, {
-    key: 'setFindController',
-    value: function setFindController(findController) {
-      this.findController = findController;
-    }
-  }, {
-    key: 'getPagesOverview',
+    key: "getPagesOverview",
     value: function getPagesOverview() {
       var pagesOverview = this._pages.map(function (pageView) {
-        var viewport = pageView.pdfPage.getViewport(1);
+        var viewport = pageView.pdfPage.getViewport({
+          scale: 1
+        });
         return {
           width: viewport.width,
           height: viewport.height,
           rotation: viewport.rotation
         };
       });
+
       if (!this.enablePrintAutoRotate) {
         return pagesOverview;
       }
+
       var isFirstPagePortrait = (0, _ui_utils.isPortraitOrientation)(pagesOverview[0]);
       return pagesOverview.map(function (size) {
         if (isFirstPagePortrait === (0, _ui_utils.isPortraitOrientation)(size)) {
           return size;
         }
+
         return {
           width: size.height,
           height: size.width,
@@ -715,52 +893,81 @@ var BaseViewer = function () {
       });
     }
   }, {
-    key: 'setScrollMode',
-    value: function setScrollMode(mode) {
-      if (mode !== this.scrollMode) {
-        this.scrollMode = mode;
-        this._updateScrollModeClasses();
-        this.eventBus.dispatch('scrollmodechanged', { mode: mode });
-        var pageNumber = this._currentPageNumber;
-        if (isNaN(this._currentScaleValue)) {
-          this._setScale(this._currentScaleValue, this.isInPresentationMode);
-        }
-        this.scrollPageIntoView({ pageNumber: pageNumber });
-        this.update();
+    key: "_updateScrollMode",
+    value: function _updateScrollMode() {
+      var pageNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var scrollMode = this._scrollMode,
+          viewer = this.viewer;
+      viewer.classList.toggle('scrollHorizontal', scrollMode === _ui_utils.ScrollMode.HORIZONTAL);
+      viewer.classList.toggle('scrollWrapped', scrollMode === _ui_utils.ScrollMode.WRAPPED);
+
+      if (!this.pdfDocument || !pageNumber) {
+        return;
       }
+
+      if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+        this._setScale(this._currentScaleValue, true);
+      }
+
+      this._setCurrentPageNumber(pageNumber, true);
+
+      this.update();
     }
   }, {
-    key: '_updateScrollModeClasses',
-    value: function _updateScrollModeClasses() {
-      var mode = this.scrollMode,
-          classList = this.viewer.classList;
-      classList.toggle('scrollHorizontal', mode === ScrollMode.HORIZONTAL);
-      classList.toggle('scrollWrapped', mode === ScrollMode.WRAPPED);
-    }
-  }, {
-    key: 'setSpreadMode',
-    value: function setSpreadMode(mode) {
-      if (mode !== this.spreadMode) {
-        this.spreadMode = mode;
-        this.eventBus.dispatch('spreadmodechanged', { mode: mode });
-        this._regroupSpreads();
+    key: "_updateSpreadMode",
+    value: function _updateSpreadMode() {
+      var pageNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+      if (!this.pdfDocument) {
+        return;
+      }
+
+      var viewer = this.viewer,
+          pages = this._pages;
+      viewer.textContent = '';
+
+      if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
+        for (var i = 0, iMax = pages.length; i < iMax; ++i) {
+          viewer.appendChild(pages[i].div);
+        }
+      } else {
+        var parity = this._spreadMode - 1;
+        var spread = null;
+
+        for (var _i = 0, _iMax = pages.length; _i < _iMax; ++_i) {
+          if (spread === null) {
+            spread = document.createElement('div');
+            spread.className = 'spread';
+            viewer.appendChild(spread);
+          } else if (_i % 2 === parity) {
+            spread = spread.cloneNode(false);
+            viewer.appendChild(spread);
+          }
+
+          spread.appendChild(pages[_i].div);
+        }
       }
+
+      if (!pageNumber) {
+        return;
+      }
+
+      this._setCurrentPageNumber(pageNumber, true);
+
+      this.update();
     }
   }, {
-    key: '_regroupSpreads',
-    value: function _regroupSpreads() {}
-  }, {
-    key: 'pagesCount',
+    key: "pagesCount",
     get: function get() {
       return this._pages.length;
     }
   }, {
-    key: 'pageViewsReady',
+    key: "pageViewsReady",
     get: function get() {
       return this._pageViewsReady;
     }
   }, {
-    key: 'currentPageNumber',
+    key: "currentPageNumber",
     get: function get() {
       return this._currentPageNumber;
     },
@@ -768,42 +975,57 @@ var BaseViewer = function () {
       if (!Number.isInteger(val)) {
         throw new Error('Invalid page number.');
       }
+
       if (!this.pdfDocument) {
         return;
       }
-      this._setCurrentPageNumber(val, true);
+
+      if (!this._setCurrentPageNumber(val, true)) {
+        console.error("".concat(this._name, ".currentPageNumber: \"").concat(val, "\" is not a valid page."));
+      }
     }
   }, {
-    key: 'currentPageLabel',
+    key: "currentPageLabel",
     get: function get() {
       return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
     },
     set: function set(val) {
-      var pageNumber = val | 0;
+      if (!this.pdfDocument) {
+        return;
+      }
+
+      var page = val | 0;
+
       if (this._pageLabels) {
         var i = this._pageLabels.indexOf(val);
+
         if (i >= 0) {
-          pageNumber = i + 1;
+          page = i + 1;
         }
       }
-      this.currentPageNumber = pageNumber;
+
+      if (!this._setCurrentPageNumber(page, true)) {
+        console.error("".concat(this._name, ".currentPageLabel: \"").concat(val, "\" is not a valid page."));
+      }
     }
   }, {
-    key: 'currentScale',
+    key: "currentScale",
     get: function get() {
       return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
     },
     set: function set(val) {
       if (isNaN(val)) {
-        throw new Error('Invalid numeric scale');
+        throw new Error('Invalid numeric scale.');
       }
+
       if (!this.pdfDocument) {
         return;
       }
+
       this._setScale(val, false);
     }
   }, {
-    key: 'currentScaleValue',
+    key: "currentScaleValue",
     get: function get() {
       return this._currentScaleValue;
     },
@@ -811,10 +1033,11 @@ var BaseViewer = function () {
       if (!this.pdfDocument) {
         return;
       }
+
       this._setScale(val, false);
     }
   }, {
-    key: 'pagesRotation',
+    key: "pagesRotation",
     get: function get() {
       return this._pagesRotation;
     },
@@ -822,72 +1045,129 @@ var BaseViewer = function () {
       if (!(0, _ui_utils.isValidRotation)(rotation)) {
         throw new Error('Invalid pages rotation angle.');
       }
+
       if (!this.pdfDocument) {
         return;
       }
+
       if (this._pagesRotation === rotation) {
         return;
       }
+
       this._pagesRotation = rotation;
       var pageNumber = this._currentPageNumber;
+
       for (var i = 0, ii = this._pages.length; i < ii; i++) {
         var pageView = this._pages[i];
         pageView.update(pageView.scale, rotation);
       }
+
       if (this._currentScaleValue) {
         this._setScale(this._currentScaleValue, true);
       }
+
       this.eventBus.dispatch('rotationchanging', {
         source: this,
         pagesRotation: rotation,
         pageNumber: pageNumber
       });
+
       if (this.defaultRenderingQueue) {
         this.update();
       }
     }
   }, {
-    key: '_setDocumentViewerElement',
+    key: "_setDocumentViewerElement",
     get: function get() {
       throw new Error('Not implemented: _setDocumentViewerElement');
     }
   }, {
-    key: 'isInPresentationMode',
+    key: "_isScrollModeHorizontal",
+    get: function get() {
+      return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL;
+    }
+  }, {
+    key: "isInPresentationMode",
     get: function get() {
       return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
     }
   }, {
-    key: 'isChangingPresentationMode',
+    key: "isChangingPresentationMode",
     get: function get() {
       return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
     }
   }, {
-    key: 'isHorizontalScrollbarEnabled',
+    key: "isHorizontalScrollbarEnabled",
     get: function get() {
       return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
     }
   }, {
-    key: 'isVerticalScrollbarEnabled',
+    key: "isVerticalScrollbarEnabled",
     get: function get() {
       return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
     }
   }, {
-    key: 'hasEqualPageSizes',
+    key: "hasEqualPageSizes",
     get: function get() {
       var firstPageView = this._pages[0];
+
       for (var i = 1, ii = this._pages.length; i < ii; ++i) {
         var pageView = this._pages[i];
+
         if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
           return false;
         }
       }
+
       return true;
     }
+  }, {
+    key: "scrollMode",
+    get: function get() {
+      return this._scrollMode;
+    },
+    set: function set(mode) {
+      if (this._scrollMode === mode) {
+        return;
+      }
+
+      if (!(0, _ui_utils.isValidScrollMode)(mode)) {
+        throw new Error("Invalid scroll mode: ".concat(mode));
+      }
+
+      this._scrollMode = mode;
+      this.eventBus.dispatch('scrollmodechanged', {
+        source: this,
+        mode: mode
+      });
+
+      this._updateScrollMode(this._currentPageNumber);
+    }
+  }, {
+    key: "spreadMode",
+    get: function get() {
+      return this._spreadMode;
+    },
+    set: function set(mode) {
+      if (this._spreadMode === mode) {
+        return;
+      }
+
+      if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
+        throw new Error("Invalid spread mode: ".concat(mode));
+      }
+
+      this._spreadMode = mode;
+      this.eventBus.dispatch('spreadmodechanged', {
+        source: this,
+        mode: mode
+      });
+
+      this._updateSpreadMode(this._currentPageNumber);
+    }
   }]);
 
   return BaseViewer;
 }();
 
-exports.BaseViewer = BaseViewer;
-exports.ScrollMode = ScrollMode;
-exports.SpreadMode = SpreadMode;
+exports.BaseViewer = BaseViewer;