pdfjs-dist 2.1.266 → 2.5.207

package/lib/display/api.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,127 +28,41 @@ exports.getDocument = getDocument;
 exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
 exports.build = exports.version = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
+var _display_utils = require("./display_utils.js");
 
-var _dom_utils = require("./dom_utils");
+var _font_loader = require("./font_loader.js");
 
-var _font_loader = require("./font_loader");
+var _api_compatibility = require("./api_compatibility.js");
 
-var _api_compatibility = require("./api_compatibility");
+var _canvas = require("./canvas.js");
 
-var _canvas = require("./canvas");
+var _worker_options = require("./worker_options.js");
 
-var _global_scope = _interopRequireDefault(require("../shared/global_scope"));
+var _is_node = require("../shared/is_node.js");
 
-var _worker_options = require("./worker_options");
+var _message_handler = require("../shared/message_handler.js");
 
-var _message_handler = require("../shared/message_handler");
+var _metadata = require("./metadata.js");
 
-var _metadata = require("./metadata");
+var _transport_stream = require("./transport_stream.js");
 
-var _transport_stream = require("./transport_stream");
+var _webgl = require("./webgl.js");
 
-var _webgl = require("./webgl");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var DEFAULT_RANGE_CHUNK_SIZE = 65536;
-var isWorkerDisabled = false;
-var fallbackWorkerSrc;
-var fakeWorkerFilesLoader = null;
-{
-  var useRequireEnsure = false;
-
-  if (typeof window === 'undefined') {
-    isWorkerDisabled = true;
-
-    if (typeof require.ensure === 'undefined') {
-      require.ensure = require('node-ensure');
-    }
-
-    useRequireEnsure = true;
-  } else if (typeof require !== 'undefined' && typeof require.ensure === 'function') {
-    useRequireEnsure = true;
-  }
-
-  if (typeof requirejs !== 'undefined' && requirejs.toUrl) {
-    fallbackWorkerSrc = requirejs.toUrl('pdfjs-dist/build/pdf.worker.js');
-  }
-
-  var dynamicLoaderSupported = typeof requirejs !== 'undefined' && requirejs.load;
-  fakeWorkerFilesLoader = useRequireEnsure ? function () {
-    return new Promise(function (resolve, reject) {
-      require.ensure([], function () {
-        try {
-          var worker;
-          worker = require('../pdf.worker.js');
-          resolve(worker.WorkerMessageHandler);
-        } catch (ex) {
-          reject(ex);
-        }
-      }, reject, 'pdfjsWorker');
-    });
-  } : dynamicLoaderSupported ? function () {
-    return new Promise(function (resolve, reject) {
-      requirejs(['pdfjs-dist/build/pdf.worker'], function (worker) {
-        try {
-          resolve(worker.WorkerMessageHandler);
-        } catch (ex) {
-          reject(ex);
-        }
-      }, reject);
-    });
-  } : null;
-
-  if (!fallbackWorkerSrc && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object' && 'currentScript' in document) {
-    var pdfjsFilePath = document.currentScript && document.currentScript.src;
-
-    if (pdfjsFilePath) {
-      fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, '.worker$1$2');
-    }
-  }
-}
-var createPDFNetworkStream;
+const DEFAULT_RANGE_CHUNK_SIZE = 65536;
+const RENDERING_CANCELLED_TIMEOUT = 100;
+let createPDFNetworkStream;
 
 function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
   createPDFNetworkStream = pdfNetworkStreamFactory;
 }
 
 function getDocument(src) {
-  var task = new PDFDocumentLoadingTask();
-  var source;
+  const task = new PDFDocumentLoadingTask();
+  let source;
 
-  if (typeof src === 'string') {
+  if (typeof src === "string") {
     source = {
       url: src
     };
@@ -161,42 +75,42 @@ function getDocument(src) {
       range: src
     };
   } else {
-    if (_typeof(src) !== 'object') {
-      throw new Error('Invalid parameter in getDocument, ' + 'need either Uint8Array, string or a parameter object');
+    if (typeof src !== "object") {
+      throw new Error("Invalid parameter in getDocument, " + "need either Uint8Array, string or a parameter object");
     }
 
     if (!src.url && !src.data && !src.range) {
-      throw new Error('Invalid parameter object: need either .data, .range or .url');
+      throw new Error("Invalid parameter object: need either .data, .range or .url");
     }
 
     source = src;
   }
 
-  var params = Object.create(null);
-  var rangeTransport = null,
+  const params = Object.create(null);
+  let rangeTransport = null,
       worker = null;
 
-  for (var key in source) {
-    if (key === 'url' && typeof window !== 'undefined') {
-      params[key] = new _util.URL(source[key], window.location).href;
+  for (const key in source) {
+    if (key === "url" && typeof window !== "undefined") {
+      params[key] = new URL(source[key], window.location).href;
       continue;
-    } else if (key === 'range') {
+    } else if (key === "range") {
       rangeTransport = source[key];
       continue;
-    } else if (key === 'worker') {
+    } else if (key === "worker") {
       worker = source[key];
       continue;
-    } else if (key === 'data' && !(source[key] instanceof Uint8Array)) {
-      var pdfBytes = source[key];
+    } else if (key === "data" && !(source[key] instanceof Uint8Array)) {
+      const pdfBytes = source[key];
 
-      if (typeof pdfBytes === 'string') {
+      if (typeof pdfBytes === "string") {
         params[key] = (0, _util.stringToBytes)(pdfBytes);
-      } else if (_typeof(pdfBytes) === 'object' && pdfBytes !== null && !isNaN(pdfBytes.length)) {
+      } else if (typeof pdfBytes === "object" && pdfBytes !== null && !isNaN(pdfBytes.length)) {
         params[key] = new Uint8Array(pdfBytes);
       } else if ((0, _util.isArrayBuffer)(pdfBytes)) {
         params[key] = new Uint8Array(pdfBytes);
       } else {
-        throw new Error('Invalid PDF binary data: either typed array, ' + 'string or array-like object is expected in the ' + 'data property.');
+        throw new Error("Invalid PDF binary data: either typed array, " + "string or array-like object is expected in the " + "data property.");
       }
 
       continue;
@@ -206,48 +120,39 @@ function getDocument(src) {
   }
 
   params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
-  params.CMapReaderFactory = params.CMapReaderFactory || _dom_utils.DOMCMapReaderFactory;
+  params.CMapReaderFactory = params.CMapReaderFactory || _display_utils.DOMCMapReaderFactory;
   params.ignoreErrors = params.stopAtErrors !== true;
+  params.fontExtraProperties = params.fontExtraProperties === true;
   params.pdfBug = params.pdfBug === true;
-  var NativeImageDecoderValues = Object.values(_util.NativeImageDecoding);
-
-  if (params.nativeImageDecoderSupport === undefined || !NativeImageDecoderValues.includes(params.nativeImageDecoderSupport)) {
-    params.nativeImageDecoderSupport = _api_compatibility.apiCompatibilityParams.nativeImageDecoderSupport || _util.NativeImageDecoding.DECODE;
-  }
 
   if (!Number.isInteger(params.maxImageSize)) {
     params.maxImageSize = -1;
   }
 
-  if (typeof params.isEvalSupported !== 'boolean') {
+  if (typeof params.isEvalSupported !== "boolean") {
     params.isEvalSupported = true;
   }
 
-  if (typeof params.disableFontFace !== 'boolean') {
+  if (typeof params.disableFontFace !== "boolean") {
     params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
   }
 
-  if (typeof params.disableRange !== 'boolean') {
+  if (typeof params.disableRange !== "boolean") {
     params.disableRange = false;
   }
 
-  if (typeof params.disableStream !== 'boolean') {
+  if (typeof params.disableStream !== "boolean") {
     params.disableStream = false;
   }
 
-  if (typeof params.disableAutoFetch !== 'boolean') {
+  if (typeof params.disableAutoFetch !== "boolean") {
     params.disableAutoFetch = false;
   }
 
-  if (typeof params.disableCreateObjectURL !== 'boolean') {
-    params.disableCreateObjectURL = _api_compatibility.apiCompatibilityParams.disableCreateObjectURL || false;
-  }
-
   (0, _util.setVerbosityLevel)(params.verbosity);
 
   if (!worker) {
-    var workerParams = {
-      postMessageTransfers: params.postMessageTransfers,
+    const workerParams = {
       verbosity: params.verbosity,
       port: _worker_options.GlobalWorkerOptions.workerPort
     };
@@ -255,23 +160,22 @@ function getDocument(src) {
     task._worker = worker;
   }
 
-  var docId = task.docId;
+  const docId = task.docId;
   worker.promise.then(function () {
     if (task.destroyed) {
-      throw new Error('Loading aborted');
+      throw new Error("Loading aborted");
     }
 
-    return _fetchDocument(worker, params, rangeTransport, docId).then(function (workerId) {
-      if (task.destroyed) {
-        throw new Error('Loading aborted');
-      }
+    const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
 
-      var networkStream;
+    const networkStreamPromise = new Promise(function (resolve) {
+      let networkStream;
 
       if (rangeTransport) {
         networkStream = new _transport_stream.PDFDataTransportStream({
           length: params.length,
           initialData: params.initialData,
+          progressiveDone: params.progressiveDone,
           disableRange: params.disableRange,
           disableStream: params.disableStream
         }, rangeTransport);
@@ -287,11 +191,18 @@ function getDocument(src) {
         });
       }
 
-      var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
+      resolve(networkStream);
+    });
+    return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
+      if (task.destroyed) {
+        throw new Error("Loading aborted");
+      }
+
+      const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
       messageHandler.postMessageTransfers = worker.postMessageTransfers;
-      var transport = new WorkerTransport(messageHandler, task, networkStream, params);
+      const transport = new WorkerTransport(messageHandler, task, networkStream, params);
       task._transport = transport;
-      messageHandler.send('Ready', null);
+      messageHandler.send("Ready", null);
     });
   }).catch(task._capability.reject);
   return task;
@@ -299,17 +210,18 @@ function getDocument(src) {
 
 function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
   if (worker.destroyed) {
-    return Promise.reject(new Error('Worker was destroyed'));
+    return Promise.reject(new Error("Worker was destroyed"));
   }
 
   if (pdfDataRangeTransport) {
     source.length = pdfDataRangeTransport.length;
     source.initialData = pdfDataRangeTransport.initialData;
+    source.progressiveDone = pdfDataRangeTransport.progressiveDone;
   }
 
-  return worker.messageHandler.sendWithPromise('GetDocRequest', {
-    docId: docId,
-    apiVersion: '2.1.266',
+  return worker.messageHandler.sendWithPromise("GetDocRequest", {
+    docId,
+    apiVersion: '2.5.207',
     source: {
       data: source.data,
       url: source.url,
@@ -320,849 +232,850 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
     },
     maxImageSize: source.maxImageSize,
     disableFontFace: source.disableFontFace,
-    disableCreateObjectURL: source.disableCreateObjectURL,
     postMessageTransfers: worker.postMessageTransfers,
     docBaseUrl: source.docBaseUrl,
-    nativeImageDecoderSupport: source.nativeImageDecoderSupport,
     ignoreErrors: source.ignoreErrors,
-    isEvalSupported: source.isEvalSupported
+    isEvalSupported: source.isEvalSupported,
+    fontExtraProperties: source.fontExtraProperties
   }).then(function (workerId) {
     if (worker.destroyed) {
-      throw new Error('Worker was destroyed');
+      throw new Error("Worker was destroyed");
     }
 
     return workerId;
   });
 }
 
-var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
-  var nextDocumentId = 0;
-
-  var PDFDocumentLoadingTask =
-  /*#__PURE__*/
-  function () {
-    function PDFDocumentLoadingTask() {
-      _classCallCheck(this, PDFDocumentLoadingTask);
+const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
+  let nextDocumentId = 0;
 
+  class PDFDocumentLoadingTask {
+    constructor() {
       this._capability = (0, _util.createPromiseCapability)();
       this._transport = null;
       this._worker = null;
-      this.docId = 'd' + nextDocumentId++;
+      this.docId = "d" + nextDocumentId++;
       this.destroyed = false;
       this.onPassword = null;
       this.onProgress = null;
       this.onUnsupportedFeature = null;
     }
 
-    _createClass(PDFDocumentLoadingTask, [{
-      key: "destroy",
-      value: function destroy() {
-        var _this = this;
+    get promise() {
+      return this._capability.promise;
+    }
 
-        this.destroyed = true;
-        var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
-        return transportDestroyed.then(function () {
-          _this._transport = null;
+    destroy() {
+      this.destroyed = true;
+      const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
+      return transportDestroyed.then(() => {
+        this._transport = null;
 
-          if (_this._worker) {
-            _this._worker.destroy();
+        if (this._worker) {
+          this._worker.destroy();
 
-            _this._worker = null;
-          }
-        });
-      }
-    }, {
-      key: "then",
-      value: function then(onFulfilled, onRejected) {
-        (0, _util.deprecated)('PDFDocumentLoadingTask.then method, ' + 'use the `promise` getter instead.');
-        return this.promise.then.apply(this.promise, arguments);
-      }
-    }, {
-      key: "promise",
-      get: function get() {
-        return this._capability.promise;
-      }
-    }]);
+          this._worker = null;
+        }
+      });
+    }
 
-    return PDFDocumentLoadingTask;
-  }();
+  }
 
   return PDFDocumentLoadingTask;
 }();
 
-var PDFDataRangeTransport =
-/*#__PURE__*/
-function () {
-  function PDFDataRangeTransport(length, initialData) {
-    _classCallCheck(this, PDFDataRangeTransport);
-
+class PDFDataRangeTransport {
+  constructor(length, initialData, progressiveDone = false) {
     this.length = length;
     this.initialData = initialData;
+    this.progressiveDone = progressiveDone;
     this._rangeListeners = [];
     this._progressListeners = [];
     this._progressiveReadListeners = [];
+    this._progressiveDoneListeners = [];
     this._readyCapability = (0, _util.createPromiseCapability)();
   }
 
-  _createClass(PDFDataRangeTransport, [{
-    key: "addRangeListener",
-    value: function addRangeListener(listener) {
-      this._rangeListeners.push(listener);
-    }
-  }, {
-    key: "addProgressListener",
-    value: function addProgressListener(listener) {
-      this._progressListeners.push(listener);
-    }
-  }, {
-    key: "addProgressiveReadListener",
-    value: function addProgressiveReadListener(listener) {
-      this._progressiveReadListeners.push(listener);
+  addRangeListener(listener) {
+    this._rangeListeners.push(listener);
+  }
+
+  addProgressListener(listener) {
+    this._progressListeners.push(listener);
+  }
+
+  addProgressiveReadListener(listener) {
+    this._progressiveReadListeners.push(listener);
+  }
+
+  addProgressiveDoneListener(listener) {
+    this._progressiveDoneListeners.push(listener);
+  }
+
+  onDataRange(begin, chunk) {
+    for (const listener of this._rangeListeners) {
+      listener(begin, chunk);
     }
-  }, {
-    key: "onDataRange",
-    value: function onDataRange(begin, chunk) {
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = this._rangeListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var listener = _step.value;
-          listener(begin, chunk);
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
+  }
+
+  onDataProgress(loaded, total) {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressListeners) {
+        listener(loaded, total);
       }
-    }
-  }, {
-    key: "onDataProgress",
-    value: function onDataProgress(loaded) {
-      var _this2 = this;
+    });
+  }
 
-      this._readyCapability.promise.then(function () {
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
+  onDataProgressiveRead(chunk) {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressiveReadListeners) {
+        listener(chunk);
+      }
+    });
+  }
 
-        try {
-          for (var _iterator2 = _this2._progressListeners[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var listener = _step2.value;
-            listener(loaded);
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "onDataProgressiveRead",
-    value: function onDataProgressiveRead(chunk) {
-      var _this3 = this;
+  onDataProgressiveDone() {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressiveDoneListeners) {
+        listener();
+      }
+    });
+  }
 
-      this._readyCapability.promise.then(function () {
-        var _iteratorNormalCompletion3 = true;
-        var _didIteratorError3 = false;
-        var _iteratorError3 = undefined;
+  transportReady() {
+    this._readyCapability.resolve();
+  }
 
-        try {
-          for (var _iterator3 = _this3._progressiveReadListeners[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-            var listener = _step3.value;
-            listener(chunk);
-          }
-        } catch (err) {
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-              _iterator3.return();
-            }
-          } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "transportReady",
-    value: function transportReady() {
-      this._readyCapability.resolve();
-    }
-  }, {
-    key: "requestDataRange",
-    value: function requestDataRange(begin, end) {
-      (0, _util.unreachable)('Abstract method PDFDataRangeTransport.requestDataRange');
-    }
-  }, {
-    key: "abort",
-    value: function abort() {}
-  }]);
+  requestDataRange(begin, end) {
+    (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
+  }
 
-  return PDFDataRangeTransport;
-}();
+  abort() {}
 
-exports.PDFDataRangeTransport = PDFDataRangeTransport;
+}
 
-var PDFDocumentProxy =
-/*#__PURE__*/
-function () {
-  function PDFDocumentProxy(pdfInfo, transport, loadingTask) {
-    _classCallCheck(this, PDFDocumentProxy);
+exports.PDFDataRangeTransport = PDFDataRangeTransport;
 
-    this.loadingTask = loadingTask;
+class PDFDocumentProxy {
+  constructor(pdfInfo, transport) {
     this._pdfInfo = pdfInfo;
     this._transport = transport;
   }
 
-  _createClass(PDFDocumentProxy, [{
-    key: "getPage",
-    value: function getPage(pageNumber) {
-      return this._transport.getPage(pageNumber);
-    }
-  }, {
-    key: "getPageIndex",
-    value: function getPageIndex(ref) {
-      return this._transport.getPageIndex(ref);
-    }
-  }, {
-    key: "getDestinations",
-    value: function getDestinations() {
-      return this._transport.getDestinations();
-    }
-  }, {
-    key: "getDestination",
-    value: function getDestination(id) {
-      return this._transport.getDestination(id);
-    }
-  }, {
-    key: "getPageLabels",
-    value: function getPageLabels() {
-      return this._transport.getPageLabels();
-    }
-  }, {
-    key: "getPageMode",
-    value: function getPageMode() {
-      return this._transport.getPageMode();
-    }
-  }, {
-    key: "getOpenActionDestination",
-    value: function getOpenActionDestination() {
-      return this._transport.getOpenActionDestination();
-    }
-  }, {
-    key: "getAttachments",
-    value: function getAttachments() {
-      return this._transport.getAttachments();
-    }
-  }, {
-    key: "getJavaScript",
-    value: function getJavaScript() {
-      return this._transport.getJavaScript();
-    }
-  }, {
-    key: "getOutline",
-    value: function getOutline() {
-      return this._transport.getOutline();
-    }
-  }, {
-    key: "getPermissions",
-    value: function getPermissions() {
-      return this._transport.getPermissions();
-    }
-  }, {
-    key: "getMetadata",
-    value: function getMetadata() {
-      return this._transport.getMetadata();
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this._transport.getData();
-    }
-  }, {
-    key: "getDownloadInfo",
-    value: function getDownloadInfo() {
-      return this._transport.downloadInfoCapability.promise;
-    }
-  }, {
-    key: "getStats",
-    value: function getStats() {
-      return this._transport.getStats();
-    }
-  }, {
-    key: "cleanup",
-    value: function cleanup() {
-      this._transport.startCleanup();
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      return this.loadingTask.destroy();
-    }
-  }, {
-    key: "numPages",
-    get: function get() {
-      return this._pdfInfo.numPages;
-    }
-  }, {
-    key: "fingerprint",
-    get: function get() {
-      return this._pdfInfo.fingerprint;
-    }
-  }, {
-    key: "loadingParams",
-    get: function get() {
-      return this._transport.loadingParams;
-    }
-  }]);
+  get numPages() {
+    return this._pdfInfo.numPages;
+  }
 
-  return PDFDocumentProxy;
-}();
+  get fingerprint() {
+    return this._pdfInfo.fingerprint;
+  }
 
-exports.PDFDocumentProxy = PDFDocumentProxy;
+  getPage(pageNumber) {
+    return this._transport.getPage(pageNumber);
+  }
 
-var PDFPageProxy =
-/*#__PURE__*/
-function () {
-  function PDFPageProxy(pageIndex, pageInfo, transport) {
-    var pdfBug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  getPageIndex(ref) {
+    return this._transport.getPageIndex(ref);
+  }
 
-    _classCallCheck(this, PDFPageProxy);
+  getDestinations() {
+    return this._transport.getDestinations();
+  }
 
-    this.pageIndex = pageIndex;
-    this._pageInfo = pageInfo;
-    this._transport = transport;
-    this._stats = pdfBug ? new _dom_utils.StatTimer() : _dom_utils.DummyStatTimer;
-    this._pdfBug = pdfBug;
-    this.commonObjs = transport.commonObjs;
-    this.objs = new PDFObjects();
-    this.cleanupAfterRender = false;
-    this.pendingCleanup = false;
-    this.intentStates = Object.create(null);
-    this.destroyed = false;
+  getDestination(id) {
+    return this._transport.getDestination(id);
   }
 
-  _createClass(PDFPageProxy, [{
-    key: "getViewport",
-    value: function getViewport() {
-      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          scale = _ref.scale,
-          _ref$rotation = _ref.rotation,
-          rotation = _ref$rotation === void 0 ? this.rotate : _ref$rotation,
-          _ref$dontFlip = _ref.dontFlip,
-          dontFlip = _ref$dontFlip === void 0 ? false : _ref$dontFlip;
-
-      if (arguments.length > 1 || typeof arguments[0] === 'number') {
-        (0, _util.deprecated)('getViewport is called with obsolete arguments.');
-        scale = arguments[0];
-        rotation = typeof arguments[1] === 'number' ? arguments[1] : this.rotate;
-        dontFlip = typeof arguments[2] === 'boolean' ? arguments[2] : false;
-      }
-
-      return new _dom_utils.PageViewport({
-        viewBox: this.view,
-        scale: scale,
-        rotation: rotation,
-        dontFlip: dontFlip
-      });
-    }
-  }, {
-    key: "getAnnotations",
-    value: function getAnnotations() {
-      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref2$intent = _ref2.intent,
-          intent = _ref2$intent === void 0 ? null : _ref2$intent;
+  getPageLabels() {
+    return this._transport.getPageLabels();
+  }
 
-      if (!this.annotationsPromise || this.annotationsIntent !== intent) {
-        this.annotationsPromise = this._transport.getAnnotations(this.pageIndex, intent);
-        this.annotationsIntent = intent;
-      }
+  getPageLayout() {
+    return this._transport.getPageLayout();
+  }
 
-      return this.annotationsPromise;
-    }
-  }, {
-    key: "render",
-    value: function render(_ref3) {
-      var _this4 = this;
-
-      var canvasContext = _ref3.canvasContext,
-          viewport = _ref3.viewport,
-          _ref3$intent = _ref3.intent,
-          intent = _ref3$intent === void 0 ? 'display' : _ref3$intent,
-          _ref3$enableWebGL = _ref3.enableWebGL,
-          enableWebGL = _ref3$enableWebGL === void 0 ? false : _ref3$enableWebGL,
-          _ref3$renderInteracti = _ref3.renderInteractiveForms,
-          renderInteractiveForms = _ref3$renderInteracti === void 0 ? false : _ref3$renderInteracti,
-          _ref3$transform = _ref3.transform,
-          transform = _ref3$transform === void 0 ? null : _ref3$transform,
-          _ref3$imageLayer = _ref3.imageLayer,
-          imageLayer = _ref3$imageLayer === void 0 ? null : _ref3$imageLayer,
-          _ref3$canvasFactory = _ref3.canvasFactory,
-          canvasFactory = _ref3$canvasFactory === void 0 ? null : _ref3$canvasFactory,
-          _ref3$background = _ref3.background,
-          background = _ref3$background === void 0 ? null : _ref3$background;
-      var stats = this._stats;
-      stats.time('Overall');
-      this.pendingCleanup = false;
-      var renderingIntent = intent === 'print' ? 'print' : 'display';
-      var canvasFactoryInstance = canvasFactory || new _dom_utils.DOMCanvasFactory();
-      var webGLContext = new _webgl.WebGLContext({
-        enable: enableWebGL
-      });
+  getPageMode() {
+    return this._transport.getPageMode();
+  }
 
-      if (!this.intentStates[renderingIntent]) {
-        this.intentStates[renderingIntent] = Object.create(null);
-      }
+  getViewerPreferences() {
+    return this._transport.getViewerPreferences();
+  }
 
-      var intentState = this.intentStates[renderingIntent];
+  getOpenAction() {
+    return this._transport.getOpenAction();
+  }
 
-      if (!intentState.displayReadyCapability) {
-        intentState.receivingOperatorList = true;
-        intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
-        intentState.operatorList = {
-          fnArray: [],
-          argsArray: [],
-          lastChunk: false
-        };
-        stats.time('Page Request');
+  getOpenActionDestination() {
+    (0, _display_utils.deprecated)("getOpenActionDestination, use getOpenAction instead.");
+    return this.getOpenAction().then(function (openAction) {
+      return openAction && openAction.dest ? openAction.dest : null;
+    });
+  }
 
-        this._transport.messageHandler.send('RenderPageRequest', {
-          pageIndex: this.pageNumber - 1,
-          intent: renderingIntent,
-          renderInteractiveForms: renderInteractiveForms === true
-        });
-      }
+  getAttachments() {
+    return this._transport.getAttachments();
+  }
 
-      var complete = function complete(error) {
-        var i = intentState.renderTasks.indexOf(internalRenderTask);
+  getJavaScript() {
+    return this._transport.getJavaScript();
+  }
 
-        if (i >= 0) {
-          intentState.renderTasks.splice(i, 1);
-        }
+  getOutline() {
+    return this._transport.getOutline();
+  }
 
-        if (_this4.cleanupAfterRender) {
-          _this4.pendingCleanup = true;
-        }
+  getPermissions() {
+    return this._transport.getPermissions();
+  }
 
-        _this4._tryCleanup();
+  getMetadata() {
+    return this._transport.getMetadata();
+  }
 
-        if (error) {
-          internalRenderTask.capability.reject(error);
-        } else {
-          internalRenderTask.capability.resolve();
-        }
+  getData() {
+    return this._transport.getData();
+  }
 
-        stats.timeEnd('Rendering');
-        stats.timeEnd('Overall');
-      };
+  getDownloadInfo() {
+    return this._transport.downloadInfoCapability.promise;
+  }
 
-      var internalRenderTask = new InternalRenderTask({
-        callback: complete,
-        params: {
-          canvasContext: canvasContext,
-          viewport: viewport,
-          transform: transform,
-          imageLayer: imageLayer,
-          background: background
-        },
-        objs: this.objs,
-        commonObjs: this.commonObjs,
-        operatorList: intentState.operatorList,
-        pageNumber: this.pageNumber,
-        canvasFactory: canvasFactoryInstance,
-        webGLContext: webGLContext,
-        useRequestAnimationFrame: renderingIntent !== 'print',
-        pdfBug: this._pdfBug
-      });
+  getStats() {
+    return this._transport.getStats();
+  }
 
-      if (!intentState.renderTasks) {
-        intentState.renderTasks = [];
-      }
+  cleanup() {
+    return this._transport.startCleanup();
+  }
 
-      intentState.renderTasks.push(internalRenderTask);
-      var renderTask = internalRenderTask.task;
-      intentState.displayReadyCapability.promise.then(function (transparency) {
-        if (_this4.pendingCleanup) {
-          complete();
-          return;
-        }
+  destroy() {
+    return this.loadingTask.destroy();
+  }
 
-        stats.time('Rendering');
-        internalRenderTask.initializeGraphics(transparency);
-        internalRenderTask.operatorListChanged();
-      }).catch(complete);
-      return renderTask;
-    }
-  }, {
-    key: "getOperatorList",
-    value: function getOperatorList() {
-      function operatorListChanged() {
-        if (intentState.operatorList.lastChunk) {
-          intentState.opListReadCapability.resolve(intentState.operatorList);
-          var i = intentState.renderTasks.indexOf(opListTask);
-
-          if (i >= 0) {
-            intentState.renderTasks.splice(i, 1);
-          }
-        }
-      }
+  get loadingParams() {
+    return this._transport.loadingParams;
+  }
 
-      var renderingIntent = 'oplist';
+  get loadingTask() {
+    return this._transport.loadingTask;
+  }
 
-      if (!this.intentStates[renderingIntent]) {
-        this.intentStates[renderingIntent] = Object.create(null);
-      }
+}
 
-      var intentState = this.intentStates[renderingIntent];
-      var opListTask;
+exports.PDFDocumentProxy = PDFDocumentProxy;
 
-      if (!intentState.opListReadCapability) {
-        opListTask = {};
-        opListTask.operatorListChanged = operatorListChanged;
-        intentState.receivingOperatorList = true;
-        intentState.opListReadCapability = (0, _util.createPromiseCapability)();
-        intentState.renderTasks = [];
-        intentState.renderTasks.push(opListTask);
-        intentState.operatorList = {
-          fnArray: [],
-          argsArray: [],
-          lastChunk: false
-        };
+class PDFPageProxy {
+  constructor(pageIndex, pageInfo, transport, pdfBug = false) {
+    this._pageIndex = pageIndex;
+    this._pageInfo = pageInfo;
+    this._transport = transport;
+    this._stats = pdfBug ? new _display_utils.StatTimer() : null;
+    this._pdfBug = pdfBug;
+    this.commonObjs = transport.commonObjs;
+    this.objs = new PDFObjects();
+    this.cleanupAfterRender = false;
+    this.pendingCleanup = false;
+    this.intentStates = Object.create(null);
+    this.destroyed = false;
+  }
 
-        this._stats.time('Page Request');
+  get pageNumber() {
+    return this._pageIndex + 1;
+  }
 
-        this._transport.messageHandler.send('RenderPageRequest', {
-          pageIndex: this.pageIndex,
-          intent: renderingIntent
-        });
-      }
+  get rotate() {
+    return this._pageInfo.rotate;
+  }
 
-      return intentState.opListReadCapability.promise;
-    }
-  }, {
-    key: "streamTextContent",
-    value: function streamTextContent() {
-      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref4$normalizeWhites = _ref4.normalizeWhitespace,
-          normalizeWhitespace = _ref4$normalizeWhites === void 0 ? false : _ref4$normalizeWhites,
-          _ref4$disableCombineT = _ref4.disableCombineTextItems,
-          disableCombineTextItems = _ref4$disableCombineT === void 0 ? false : _ref4$disableCombineT;
-
-      var TEXT_CONTENT_CHUNK_SIZE = 100;
-      return this._transport.messageHandler.sendWithStream('GetTextContent', {
-        pageIndex: this.pageNumber - 1,
-        normalizeWhitespace: normalizeWhitespace === true,
-        combineTextItems: disableCombineTextItems !== true
-      }, {
-        highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
-        size: function size(textContent) {
-          return textContent.items.length;
-        }
-      });
-    }
-  }, {
-    key: "getTextContent",
-    value: function getTextContent() {
-      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var readableStream = this.streamTextContent(params);
-      return new Promise(function (resolve, reject) {
-        function pump() {
-          reader.read().then(function (_ref5) {
-            var _textContent$items;
-
-            var value = _ref5.value,
-                done = _ref5.done;
-
-            if (done) {
-              resolve(textContent);
-              return;
-            }
+  get ref() {
+    return this._pageInfo.ref;
+  }
 
-            Object.assign(textContent.styles, value.styles);
+  get userUnit() {
+    return this._pageInfo.userUnit;
+  }
 
-            (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items));
+  get view() {
+    return this._pageInfo.view;
+  }
 
-            pump();
-          }, reject);
-        }
+  getViewport({
+    scale,
+    rotation = this.rotate,
+    offsetX = 0,
+    offsetY = 0,
+    dontFlip = false
+  } = {}) {
+    return new _display_utils.PageViewport({
+      viewBox: this.view,
+      scale,
+      rotation,
+      offsetX,
+      offsetY,
+      dontFlip
+    });
+  }
 
-        var reader = readableStream.getReader();
-        var textContent = {
-          items: [],
-          styles: Object.create(null)
-        };
-        pump();
-      });
+  getAnnotations({
+    intent = null
+  } = {}) {
+    if (!this.annotationsPromise || this.annotationsIntent !== intent) {
+      this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
+      this.annotationsIntent = intent;
     }
-  }, {
-    key: "_destroy",
-    value: function _destroy() {
-      this.destroyed = true;
-      this._transport.pageCache[this.pageIndex] = null;
-      var waitOn = [];
-      Object.keys(this.intentStates).forEach(function (intent) {
-        if (intent === 'oplist') {
-          return;
-        }
 
-        var intentState = this.intentStates[intent];
-        intentState.renderTasks.forEach(function (renderTask) {
-          var renderCompleted = renderTask.capability.promise.catch(function () {});
-          waitOn.push(renderCompleted);
-          renderTask.cancel();
-        });
-      }, this);
-      this.objs.clear();
-      this.annotationsPromise = null;
-      this.pendingCleanup = false;
-      return Promise.all(waitOn);
+    return this.annotationsPromise;
+  }
+
+  render({
+    canvasContext,
+    viewport,
+    intent = "display",
+    enableWebGL = false,
+    renderInteractiveForms = false,
+    transform = null,
+    imageLayer = null,
+    canvasFactory = null,
+    background = null
+  }) {
+    if (this._stats) {
+      this._stats.time("Overall");
+    }
+
+    const renderingIntent = intent === "print" ? "print" : "display";
+    this.pendingCleanup = false;
+
+    if (!this.intentStates[renderingIntent]) {
+      this.intentStates[renderingIntent] = Object.create(null);
     }
-  }, {
-    key: "cleanup",
-    value: function cleanup() {
-      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      this.pendingCleanup = true;
 
-      this._tryCleanup(resetStats);
+    const intentState = this.intentStates[renderingIntent];
+
+    if (intentState.streamReaderCancelTimeout) {
+      clearTimeout(intentState.streamReaderCancelTimeout);
+      intentState.streamReaderCancelTimeout = null;
     }
-  }, {
-    key: "_tryCleanup",
-    value: function _tryCleanup() {
-      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-      if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) {
-        var intentState = this.intentStates[intent];
-        return intentState.renderTasks.length !== 0 || intentState.receivingOperatorList;
-      }, this)) {
-        return;
-      }
 
-      Object.keys(this.intentStates).forEach(function (intent) {
-        delete this.intentStates[intent];
-      }, this);
-      this.objs.clear();
-      this.annotationsPromise = null;
+    const canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory();
+    const webGLContext = new _webgl.WebGLContext({
+      enable: enableWebGL
+    });
+
+    if (!intentState.displayReadyCapability) {
+      intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
+      intentState.operatorList = {
+        fnArray: [],
+        argsArray: [],
+        lastChunk: false
+      };
 
-      if (resetStats && this._stats instanceof _dom_utils.StatTimer) {
-        this._stats = new _dom_utils.StatTimer();
+      if (this._stats) {
+        this._stats.time("Page Request");
       }
 
-      this.pendingCleanup = false;
+      this._pumpOperatorList({
+        pageIndex: this._pageIndex,
+        intent: renderingIntent,
+        renderInteractiveForms: renderInteractiveForms === true
+      });
     }
-  }, {
-    key: "_startRenderPage",
-    value: function _startRenderPage(transparency, intent) {
-      var intentState = this.intentStates[intent];
 
-      if (intentState.displayReadyCapability) {
-        intentState.displayReadyCapability.resolve(transparency);
+    const complete = error => {
+      const i = intentState.renderTasks.indexOf(internalRenderTask);
+
+      if (i >= 0) {
+        intentState.renderTasks.splice(i, 1);
       }
-    }
-  }, {
-    key: "_renderPageChunk",
-    value: function _renderPageChunk(operatorListChunk, intent) {
-      var intentState = this.intentStates[intent];
 
-      for (var i = 0, ii = operatorListChunk.length; i < ii; i++) {
-        intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
-        intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
+      if (this.cleanupAfterRender || renderingIntent === "print") {
+        this.pendingCleanup = true;
       }
 
-      intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
+      this._tryCleanup();
 
-      for (var _i = 0; _i < intentState.renderTasks.length; _i++) {
-        intentState.renderTasks[_i].operatorListChanged();
+      if (error) {
+        internalRenderTask.capability.reject(error);
+
+        this._abortOperatorList({
+          intentState,
+          reason: error
+        });
+      } else {
+        internalRenderTask.capability.resolve();
       }
 
-      if (operatorListChunk.lastChunk) {
-        intentState.receivingOperatorList = false;
+      if (this._stats) {
+        this._stats.timeEnd("Rendering");
 
-        this._tryCleanup();
+        this._stats.timeEnd("Overall");
       }
+    };
+
+    const internalRenderTask = new InternalRenderTask({
+      callback: complete,
+      params: {
+        canvasContext,
+        viewport,
+        transform,
+        imageLayer,
+        background
+      },
+      objs: this.objs,
+      commonObjs: this.commonObjs,
+      operatorList: intentState.operatorList,
+      pageIndex: this._pageIndex,
+      canvasFactory: canvasFactoryInstance,
+      webGLContext,
+      useRequestAnimationFrame: renderingIntent !== "print",
+      pdfBug: this._pdfBug
+    });
+
+    if (!intentState.renderTasks) {
+      intentState.renderTasks = [];
     }
-  }, {
-    key: "pageNumber",
-    get: function get() {
-      return this.pageIndex + 1;
-    }
-  }, {
-    key: "rotate",
-    get: function get() {
-      return this._pageInfo.rotate;
+
+    intentState.renderTasks.push(internalRenderTask);
+    const renderTask = internalRenderTask.task;
+    intentState.displayReadyCapability.promise.then(transparency => {
+      if (this.pendingCleanup) {
+        complete();
+        return;
+      }
+
+      if (this._stats) {
+        this._stats.time("Rendering");
+      }
+
+      internalRenderTask.initializeGraphics(transparency);
+      internalRenderTask.operatorListChanged();
+    }).catch(complete);
+    return renderTask;
+  }
+
+  getOperatorList() {
+    function operatorListChanged() {
+      if (intentState.operatorList.lastChunk) {
+        intentState.opListReadCapability.resolve(intentState.operatorList);
+        const i = intentState.renderTasks.indexOf(opListTask);
+
+        if (i >= 0) {
+          intentState.renderTasks.splice(i, 1);
+        }
+      }
     }
-  }, {
-    key: "ref",
-    get: function get() {
-      return this._pageInfo.ref;
+
+    const renderingIntent = "oplist";
+
+    if (!this.intentStates[renderingIntent]) {
+      this.intentStates[renderingIntent] = Object.create(null);
     }
-  }, {
-    key: "userUnit",
-    get: function get() {
-      return this._pageInfo.userUnit;
+
+    const intentState = this.intentStates[renderingIntent];
+    let opListTask;
+
+    if (!intentState.opListReadCapability) {
+      opListTask = {};
+      opListTask.operatorListChanged = operatorListChanged;
+      intentState.opListReadCapability = (0, _util.createPromiseCapability)();
+      intentState.renderTasks = [];
+      intentState.renderTasks.push(opListTask);
+      intentState.operatorList = {
+        fnArray: [],
+        argsArray: [],
+        lastChunk: false
+      };
+
+      if (this._stats) {
+        this._stats.time("Page Request");
+      }
+
+      this._pumpOperatorList({
+        pageIndex: this._pageIndex,
+        intent: renderingIntent
+      });
     }
-  }, {
-    key: "view",
-    get: function get() {
-      return this._pageInfo.view;
+
+    return intentState.opListReadCapability.promise;
+  }
+
+  streamTextContent({
+    normalizeWhitespace = false,
+    disableCombineTextItems = false
+  } = {}) {
+    const TEXT_CONTENT_CHUNK_SIZE = 100;
+    return this._transport.messageHandler.sendWithStream("GetTextContent", {
+      pageIndex: this._pageIndex,
+      normalizeWhitespace: normalizeWhitespace === true,
+      combineTextItems: disableCombineTextItems !== true
+    }, {
+      highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
+
+      size(textContent) {
+        return textContent.items.length;
+      }
+
+    });
+  }
+
+  getTextContent(params = {}) {
+    const readableStream = this.streamTextContent(params);
+    return new Promise(function (resolve, reject) {
+      function pump() {
+        reader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            resolve(textContent);
+            return;
+          }
+
+          Object.assign(textContent.styles, value.styles);
+          textContent.items.push(...value.items);
+          pump();
+        }, reject);
+      }
+
+      const reader = readableStream.getReader();
+      const textContent = {
+        items: [],
+        styles: Object.create(null)
+      };
+      pump();
+    });
+  }
+
+  _destroy() {
+    this.destroyed = true;
+    this._transport.pageCache[this._pageIndex] = null;
+    const waitOn = [];
+    Object.keys(this.intentStates).forEach(intent => {
+      const intentState = this.intentStates[intent];
+
+      this._abortOperatorList({
+        intentState,
+        reason: new Error("Page was destroyed."),
+        force: true
+      });
+
+      if (intent === "oplist") {
+        return;
+      }
+
+      intentState.renderTasks.forEach(function (renderTask) {
+        const renderCompleted = renderTask.capability.promise.catch(function () {});
+        waitOn.push(renderCompleted);
+        renderTask.cancel();
+      });
+    });
+    this.objs.clear();
+    this.annotationsPromise = null;
+    this.pendingCleanup = false;
+    return Promise.all(waitOn);
+  }
+
+  cleanup(resetStats = false) {
+    this.pendingCleanup = true;
+    return this._tryCleanup(resetStats);
+  }
+
+  _tryCleanup(resetStats = false) {
+    if (!this.pendingCleanup || Object.keys(this.intentStates).some(intent => {
+      const intentState = this.intentStates[intent];
+      return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk;
+    })) {
+      return false;
     }
-  }, {
-    key: "stats",
-    get: function get() {
-      return this._stats instanceof _dom_utils.StatTimer ? this._stats : null;
+
+    Object.keys(this.intentStates).forEach(intent => {
+      delete this.intentStates[intent];
+    });
+    this.objs.clear();
+    this.annotationsPromise = null;
+
+    if (resetStats && this._stats) {
+      this._stats = new _display_utils.StatTimer();
     }
-  }]);
 
-  return PDFPageProxy;
-}();
+    this.pendingCleanup = false;
+    return true;
+  }
 
-exports.PDFPageProxy = PDFPageProxy;
+  _startRenderPage(transparency, intent) {
+    const intentState = this.intentStates[intent];
 
-var LoopbackPort =
-/*#__PURE__*/
-function () {
-  function LoopbackPort() {
-    var defer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (!intentState) {
+      return;
+    }
 
-    _classCallCheck(this, LoopbackPort);
+    if (this._stats) {
+      this._stats.timeEnd("Page Request");
+    }
 
-    this._listeners = [];
-    this._defer = defer;
-    this._deferred = Promise.resolve(undefined);
+    if (intentState.displayReadyCapability) {
+      intentState.displayReadyCapability.resolve(transparency);
+    }
   }
 
-  _createClass(LoopbackPort, [{
-    key: "postMessage",
-    value: function postMessage(obj, transfers) {
-      var _this5 = this;
+  _renderPageChunk(operatorListChunk, intentState) {
+    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
+      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
+      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
+    }
+
+    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
 
-      function cloneValue(value) {
-        if (_typeof(value) !== 'object' || value === null) {
-          return value;
-        }
+    for (let i = 0; i < intentState.renderTasks.length; i++) {
+      intentState.renderTasks[i].operatorListChanged();
+    }
 
-        if (cloned.has(value)) {
-          return cloned.get(value);
-        }
+    if (operatorListChunk.lastChunk) {
+      this._tryCleanup();
+    }
+  }
 
-        var buffer, result;
+  _pumpOperatorList(args) {
+    (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
 
-        if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
-          var transferable = transfers && transfers.includes(buffer);
+    const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
 
-          if (value === buffer) {
-            result = value;
-          } else if (transferable) {
-            result = new value.constructor(buffer, value.byteOffset, value.byteLength);
-          } else {
-            result = new value.constructor(value);
-          }
+    const reader = readableStream.getReader();
+    const intentState = this.intentStates[args.intent];
+    intentState.streamReader = reader;
 
-          cloned.set(value, result);
-          return result;
+    const pump = () => {
+      reader.read().then(({
+        value,
+        done
+      }) => {
+        if (done) {
+          intentState.streamReader = null;
+          return;
         }
 
-        result = Array.isArray(value) ? [] : {};
-        cloned.set(value, result);
+        if (this._transport.destroyed) {
+          return;
+        }
 
-        for (var i in value) {
-          var desc = void 0,
-              p = value;
+        this._renderPageChunk(value, intentState);
 
-          while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
-            p = Object.getPrototypeOf(p);
-          }
+        pump();
+      }, reason => {
+        intentState.streamReader = null;
+
+        if (this._transport.destroyed) {
+          return;
+        }
 
-          if (typeof desc.value === 'undefined' || typeof desc.value === 'function') {
-            continue;
+        if (intentState.operatorList) {
+          intentState.operatorList.lastChunk = true;
+
+          for (let i = 0; i < intentState.renderTasks.length; i++) {
+            intentState.renderTasks[i].operatorListChanged();
           }
 
-          result[i] = cloneValue(desc.value);
+          this._tryCleanup();
         }
 
-        return result;
+        if (intentState.displayReadyCapability) {
+          intentState.displayReadyCapability.reject(reason);
+        } else if (intentState.opListReadCapability) {
+          intentState.opListReadCapability.reject(reason);
+        } else {
+          throw reason;
+        }
+      });
+    };
+
+    pump();
+  }
+
+  _abortOperatorList({
+    intentState,
+    reason,
+    force = false
+  }) {
+    (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
+
+    if (!intentState.streamReader) {
+      return;
+    }
+
+    if (!force) {
+      if (intentState.renderTasks.length !== 0) {
+        return;
       }
 
-      if (!this._defer) {
-        this._listeners.forEach(function (listener) {
-          listener.call(this, {
-            data: obj
+      if (reason instanceof _display_utils.RenderingCancelledException) {
+        intentState.streamReaderCancelTimeout = setTimeout(() => {
+          this._abortOperatorList({
+            intentState,
+            reason,
+            force: true
           });
-        }, this);
 
+          intentState.streamReaderCancelTimeout = null;
+        }, RENDERING_CANCELLED_TIMEOUT);
         return;
       }
+    }
 
-      var cloned = new WeakMap();
-      var e = {
-        data: cloneValue(obj)
-      };
+    intentState.streamReader.cancel(new _util.AbortException(reason && reason.message));
+    intentState.streamReader = null;
 
-      this._deferred.then(function () {
-        _this5._listeners.forEach(function (listener) {
-          listener.call(this, e);
-        }, _this5);
-      });
+    if (this._transport.destroyed) {
+      return;
     }
-  }, {
-    key: "addEventListener",
-    value: function addEventListener(name, listener) {
-      this._listeners.push(listener);
-    }
-  }, {
-    key: "removeEventListener",
-    value: function removeEventListener(name, listener) {
-      var i = this._listeners.indexOf(listener);
 
-      this._listeners.splice(i, 1);
+    Object.keys(this.intentStates).some(intent => {
+      if (this.intentStates[intent] === intentState) {
+        delete this.intentStates[intent];
+        return true;
+      }
+
+      return false;
+    });
+    this.cleanup();
+  }
+
+  get stats() {
+    return this._stats;
+  }
+
+}
+
+exports.PDFPageProxy = PDFPageProxy;
+
+class LoopbackPort {
+  constructor(defer = true) {
+    this._listeners = [];
+    this._defer = defer;
+    this._deferred = Promise.resolve(undefined);
+  }
+
+  postMessage(obj, transfers) {
+    function cloneValue(value) {
+      if (typeof value !== "object" || value === null) {
+        return value;
+      }
+
+      if (cloned.has(value)) {
+        return cloned.get(value);
+      }
+
+      let buffer, result;
+
+      if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
+        const transferable = transfers && transfers.includes(buffer);
+
+        if (transferable) {
+          result = new value.constructor(buffer, value.byteOffset, value.byteLength);
+        } else {
+          result = new value.constructor(value);
+        }
+
+        cloned.set(value, result);
+        return result;
+      }
+
+      result = Array.isArray(value) ? [] : {};
+      cloned.set(value, result);
+
+      for (const i in value) {
+        let desc,
+            p = value;
+
+        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
+          p = Object.getPrototypeOf(p);
+        }
+
+        if (typeof desc.value === "undefined") {
+          continue;
+        }
+
+        if (typeof desc.value === "function") {
+          if (value.hasOwnProperty && value.hasOwnProperty(i)) {
+            throw new Error(`LoopbackPort.postMessage - cannot clone: ${value[i]}`);
+          }
+
+          continue;
+        }
+
+        result[i] = cloneValue(desc.value);
+      }
+
+      return result;
     }
-  }, {
-    key: "terminate",
-    value: function terminate() {
-      this._listeners = [];
+
+    if (!this._defer) {
+      this._listeners.forEach(listener => {
+        listener.call(this, {
+          data: obj
+        });
+      });
+
+      return;
     }
-  }]);
 
-  return LoopbackPort;
-}();
+    const cloned = new WeakMap();
+    const e = {
+      data: cloneValue(obj)
+    };
+
+    this._deferred.then(() => {
+      this._listeners.forEach(listener => {
+        listener.call(this, e);
+      });
+    });
+  }
+
+  addEventListener(name, listener) {
+    this._listeners.push(listener);
+  }
+
+  removeEventListener(name, listener) {
+    const i = this._listeners.indexOf(listener);
+
+    this._listeners.splice(i, 1);
+  }
+
+  terminate() {
+    this._listeners.length = 0;
+  }
+
+}
 
 exports.LoopbackPort = LoopbackPort;
 
-var PDFWorker = function PDFWorkerClosure() {
-  var pdfWorkerPorts = new WeakMap();
-  var nextFakeWorkerId = 0;
-  var fakeWorkerFilesLoadedCapability;
+const PDFWorker = function PDFWorkerClosure() {
+  const pdfWorkerPorts = new WeakMap();
+  let isWorkerDisabled = false;
+  let fallbackWorkerSrc;
+  let nextFakeWorkerId = 0;
+  let fakeWorkerCapability;
+
+  if (_is_node.isNodeJS && typeof require === "function") {
+    isWorkerDisabled = true;
+    fallbackWorkerSrc = "../pdf.worker.js";
+  } else if (typeof document === "object" && "currentScript" in document) {
+    const pdfjsFilePath = document.currentScript && document.currentScript.src;
+
+    if (pdfjsFilePath) {
+      fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, ".worker$1$2");
+    }
+  }
 
-  function _getWorkerSrc() {
+  function getWorkerSrc() {
     if (_worker_options.GlobalWorkerOptions.workerSrc) {
       return _worker_options.GlobalWorkerOptions.workerSrc;
     }
 
-    if (typeof fallbackWorkerSrc !== 'undefined') {
+    if (typeof fallbackWorkerSrc !== "undefined") {
+      if (!_is_node.isNodeJS) {
+        (0, _display_utils.deprecated)('No "GlobalWorkerOptions.workerSrc" specified.');
+      }
+
       return fallbackWorkerSrc;
     }
 
@@ -1170,66 +1083,60 @@ var PDFWorker = function PDFWorkerClosure() {
   }
 
   function getMainThreadWorkerMessageHandler() {
+    let mainWorkerMessageHandler;
+
     try {
-      if (typeof window !== 'undefined') {
-        return window.pdfjsWorker && window.pdfjsWorker.WorkerMessageHandler;
-      }
+      mainWorkerMessageHandler = globalThis.pdfjsWorker && globalThis.pdfjsWorker.WorkerMessageHandler;
     } catch (ex) {}
 
-    return null;
+    return mainWorkerMessageHandler || null;
   }
 
   function setupFakeWorkerGlobal() {
-    if (fakeWorkerFilesLoadedCapability) {
-      return fakeWorkerFilesLoadedCapability.promise;
+    if (fakeWorkerCapability) {
+      return fakeWorkerCapability.promise;
     }
 
-    fakeWorkerFilesLoadedCapability = (0, _util.createPromiseCapability)();
-    var mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+    fakeWorkerCapability = (0, _util.createPromiseCapability)();
 
-    if (mainWorkerMessageHandler) {
-      fakeWorkerFilesLoadedCapability.resolve(mainWorkerMessageHandler);
-      return fakeWorkerFilesLoadedCapability.promise;
-    }
+    const loader = async function () {
+      const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
 
-    var loader = fakeWorkerFilesLoader || function () {
-      return (0, _dom_utils.loadScript)(_getWorkerSrc()).then(function () {
-        return window.pdfjsWorker.WorkerMessageHandler;
-      });
+      if (mainWorkerMessageHandler) {
+        return mainWorkerMessageHandler;
+      }
+
+      if (_is_node.isNodeJS && typeof require === "function") {
+        const worker = eval("require")(getWorkerSrc());
+        return worker.WorkerMessageHandler;
+      }
+
+      await (0, _display_utils.loadScript)(getWorkerSrc());
+      return window.pdfjsWorker.WorkerMessageHandler;
     };
 
-    loader().then(fakeWorkerFilesLoadedCapability.resolve, fakeWorkerFilesLoadedCapability.reject);
-    return fakeWorkerFilesLoadedCapability.promise;
+    loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);
+    return fakeWorkerCapability.promise;
   }
 
   function createCDNWrapper(url) {
-    var wrapper = 'importScripts(\'' + url + '\');';
-    return _util.URL.createObjectURL(new Blob([wrapper]));
-  }
-
-  var PDFWorker =
-  /*#__PURE__*/
-  function () {
-    function PDFWorker() {
-      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref6$name = _ref6.name,
-          name = _ref6$name === void 0 ? null : _ref6$name,
-          _ref6$port = _ref6.port,
-          port = _ref6$port === void 0 ? null : _ref6$port,
-          _ref6$postMessageTran = _ref6.postMessageTransfers,
-          postMessageTransfers = _ref6$postMessageTran === void 0 ? true : _ref6$postMessageTran,
-          _ref6$verbosity = _ref6.verbosity,
-          verbosity = _ref6$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref6$verbosity;
-
-      _classCallCheck(this, PDFWorker);
+    const wrapper = "importScripts('" + url + "');";
+    return URL.createObjectURL(new Blob([wrapper]));
+  }
 
+  class PDFWorker {
+    constructor({
+      name = null,
+      port = null,
+      verbosity = (0, _util.getVerbosityLevel)()
+    } = {}) {
       if (port && pdfWorkerPorts.has(port)) {
-        throw new Error('Cannot use more than one PDFWorker per port');
+        throw new Error("Cannot use more than one PDFWorker per port");
       }
 
       this.name = name;
       this.destroyed = false;
-      this.postMessageTransfers = postMessageTransfers !== false;
+      this.postMessageTransfers = true;
       this.verbosity = verbosity;
       this._readyCapability = (0, _util.createPromiseCapability)();
       this._port = null;
@@ -1247,215 +1154,199 @@ var PDFWorker = function PDFWorkerClosure() {
       this._initialize();
     }
 
-    _createClass(PDFWorker, [{
-      key: "_initializeFromPort",
-      value: function _initializeFromPort(port) {
-        this._port = port;
-        this._messageHandler = new _message_handler.MessageHandler('main', 'worker', port);
+    get promise() {
+      return this._readyCapability.promise;
+    }
 
-        this._messageHandler.on('ready', function () {});
+    get port() {
+      return this._port;
+    }
 
-        this._readyCapability.resolve();
-      }
-    }, {
-      key: "_initialize",
-      value: function _initialize() {
-        var _this6 = this;
+    get messageHandler() {
+      return this._messageHandler;
+    }
 
-        if (typeof Worker !== 'undefined' && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
-          var workerSrc = _getWorkerSrc();
+    _initializeFromPort(port) {
+      this._port = port;
+      this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
 
-          try {
-            if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
-              workerSrc = createCDNWrapper(new _util.URL(workerSrc, window.location).href);
-            }
+      this._messageHandler.on("ready", function () {});
 
-            var worker = new Worker(workerSrc);
-            var messageHandler = new _message_handler.MessageHandler('main', 'worker', worker);
+      this._readyCapability.resolve();
+    }
 
-            var terminateEarly = function terminateEarly() {
-              worker.removeEventListener('error', onWorkerError);
-              messageHandler.destroy();
-              worker.terminate();
+    _initialize() {
+      if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
+        let workerSrc = getWorkerSrc();
 
-              if (_this6.destroyed) {
-                _this6._readyCapability.reject(new Error('Worker was destroyed'));
-              } else {
-                _this6._setupFakeWorker();
-              }
-            };
+        try {
+          if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
+            workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
+          }
 
-            var onWorkerError = function onWorkerError() {
-              if (!_this6._webWorker) {
-                terminateEarly();
-              }
-            };
+          const worker = new Worker(workerSrc);
+          const messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
 
-            worker.addEventListener('error', onWorkerError);
-            messageHandler.on('test', function (data) {
-              worker.removeEventListener('error', onWorkerError);
+          const terminateEarly = () => {
+            worker.removeEventListener("error", onWorkerError);
+            messageHandler.destroy();
+            worker.terminate();
 
-              if (_this6.destroyed) {
-                terminateEarly();
-                return;
-              }
+            if (this.destroyed) {
+              this._readyCapability.reject(new Error("Worker was destroyed"));
+            } else {
+              this._setupFakeWorker();
+            }
+          };
 
-              if (data && data.supportTypedArray) {
-                _this6._messageHandler = messageHandler;
-                _this6._port = worker;
-                _this6._webWorker = worker;
+          const onWorkerError = () => {
+            if (!this._webWorker) {
+              terminateEarly();
+            }
+          };
 
-                if (!data.supportTransfers) {
-                  _this6.postMessageTransfers = false;
-                }
+          worker.addEventListener("error", onWorkerError);
+          messageHandler.on("test", data => {
+            worker.removeEventListener("error", onWorkerError);
 
-                _this6._readyCapability.resolve();
+            if (this.destroyed) {
+              terminateEarly();
+              return;
+            }
 
-                messageHandler.send('configure', {
-                  verbosity: _this6.verbosity
-                });
-              } else {
-                _this6._setupFakeWorker();
+            if (data) {
+              this._messageHandler = messageHandler;
+              this._port = worker;
+              this._webWorker = worker;
 
-                messageHandler.destroy();
-                worker.terminate();
+              if (!data.supportTransfers) {
+                this.postMessageTransfers = false;
               }
-            });
-            messageHandler.on('ready', function (data) {
-              worker.removeEventListener('error', onWorkerError);
 
-              if (_this6.destroyed) {
-                terminateEarly();
-                return;
-              }
+              this._readyCapability.resolve();
 
-              try {
-                sendTest();
-              } catch (e) {
-                _this6._setupFakeWorker();
-              }
-            });
+              messageHandler.send("configure", {
+                verbosity: this.verbosity
+              });
+            } else {
+              this._setupFakeWorker();
 
-            var sendTest = function sendTest() {
-              var testObj = new Uint8Array([_this6.postMessageTransfers ? 255 : 0]);
+              messageHandler.destroy();
+              worker.terminate();
+            }
+          });
+          messageHandler.on("ready", data => {
+            worker.removeEventListener("error", onWorkerError);
 
-              try {
-                messageHandler.send('test', testObj, [testObj.buffer]);
-              } catch (ex) {
-                (0, _util.info)('Cannot use postMessage transfers');
-                testObj[0] = 0;
-                messageHandler.send('test', testObj);
-              }
-            };
+            if (this.destroyed) {
+              terminateEarly();
+              return;
+            }
 
-            sendTest();
-            return;
-          } catch (e) {
-            (0, _util.info)('The worker has been disabled.');
-          }
+            try {
+              sendTest();
+            } catch (e) {
+              this._setupFakeWorker();
+            }
+          });
+
+          const sendTest = () => {
+            const testObj = new Uint8Array([this.postMessageTransfers ? 255 : 0]);
+
+            try {
+              messageHandler.send("test", testObj, [testObj.buffer]);
+            } catch (ex) {
+              (0, _util.warn)("Cannot use postMessage transfers.");
+              testObj[0] = 0;
+              messageHandler.send("test", testObj);
+            }
+          };
+
+          sendTest();
+          return;
+        } catch (e) {
+          (0, _util.info)("The worker has been disabled.");
         }
+      }
 
-        this._setupFakeWorker();
+      this._setupFakeWorker();
+    }
+
+    _setupFakeWorker() {
+      if (!isWorkerDisabled) {
+        (0, _util.warn)("Setting up fake worker.");
+        isWorkerDisabled = true;
       }
-    }, {
-      key: "_setupFakeWorker",
-      value: function _setupFakeWorker() {
-        var _this7 = this;
 
-        if (!isWorkerDisabled) {
-          (0, _util.warn)('Setting up fake worker.');
-          isWorkerDisabled = true;
-        }
+      setupFakeWorkerGlobal().then(WorkerMessageHandler => {
+        if (this.destroyed) {
+          this._readyCapability.reject(new Error("Worker was destroyed"));
 
-        setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
-          if (_this7.destroyed) {
-            _this7._readyCapability.reject(new Error('Worker was destroyed'));
+          return;
+        }
 
-            return;
-          }
+        const port = new LoopbackPort();
+        this._port = port;
+        const id = "fake" + nextFakeWorkerId++;
+        const workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
+        WorkerMessageHandler.setup(workerHandler, port);
+        const messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
+        this._messageHandler = messageHandler;
 
-          var port = new LoopbackPort();
-          _this7._port = port;
-          var id = 'fake' + nextFakeWorkerId++;
-          var workerHandler = new _message_handler.MessageHandler(id + '_worker', id, port);
-          WorkerMessageHandler.setup(workerHandler, port);
-          var messageHandler = new _message_handler.MessageHandler(id, id + '_worker', port);
-          _this7._messageHandler = messageHandler;
+        this._readyCapability.resolve();
 
-          _this7._readyCapability.resolve();
-        }).catch(function (reason) {
-          _this7._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\".")));
+        messageHandler.send("configure", {
+          verbosity: this.verbosity
         });
-      }
-    }, {
-      key: "destroy",
-      value: function destroy() {
-        this.destroyed = true;
+      }).catch(reason => {
+        this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`));
+      });
+    }
 
-        if (this._webWorker) {
-          this._webWorker.terminate();
+    destroy() {
+      this.destroyed = true;
 
-          this._webWorker = null;
-        }
+      if (this._webWorker) {
+        this._webWorker.terminate();
+
+        this._webWorker = null;
+      }
 
-        pdfWorkerPorts.delete(this._port);
-        this._port = null;
+      pdfWorkerPorts.delete(this._port);
+      this._port = null;
 
-        if (this._messageHandler) {
-          this._messageHandler.destroy();
+      if (this._messageHandler) {
+        this._messageHandler.destroy();
 
-          this._messageHandler = null;
-        }
-      }
-    }, {
-      key: "promise",
-      get: function get() {
-        return this._readyCapability.promise;
+        this._messageHandler = null;
       }
-    }, {
-      key: "port",
-      get: function get() {
-        return this._port;
-      }
-    }, {
-      key: "messageHandler",
-      get: function get() {
-        return this._messageHandler;
-      }
-    }], [{
-      key: "fromPort",
-      value: function fromPort(params) {
-        if (!params || !params.port) {
-          throw new Error('PDFWorker.fromPort - invalid method signature.');
-        }
-
-        if (pdfWorkerPorts.has(params.port)) {
-          return pdfWorkerPorts.get(params.port);
-        }
+    }
 
-        return new PDFWorker(params);
+    static fromPort(params) {
+      if (!params || !params.port) {
+        throw new Error("PDFWorker.fromPort - invalid method signature.");
       }
-    }, {
-      key: "getWorkerSrc",
-      value: function getWorkerSrc() {
-        return _getWorkerSrc();
+
+      if (pdfWorkerPorts.has(params.port)) {
+        return pdfWorkerPorts.get(params.port);
       }
-    }]);
 
-    return PDFWorker;
-  }();
+      return new PDFWorker(params);
+    }
+
+    static getWorkerSrc() {
+      return getWorkerSrc();
+    }
+
+  }
 
   return PDFWorker;
 }();
 
 exports.PDFWorker = PDFWorker;
 
-var WorkerTransport =
-/*#__PURE__*/
-function () {
-  function WorkerTransport(messageHandler, loadingTask, networkStream, params) {
-    _classCallCheck(this, WorkerTransport);
-
+class WorkerTransport {
+  constructor(messageHandler, loadingTask, networkStream, params) {
     this.messageHandler = messageHandler;
     this.loadingTask = loadingTask;
     this.commonObjs = new PDFObjects();
@@ -1480,735 +1371,591 @@ function () {
     this.setupMessageHandler();
   }
 
-  _createClass(WorkerTransport, [{
-    key: "destroy",
-    value: function destroy() {
-      var _this8 = this;
+  destroy() {
+    if (this.destroyCapability) {
+      return this.destroyCapability.promise;
+    }
 
-      if (this.destroyCapability) {
-        return this.destroyCapability.promise;
-      }
+    this.destroyed = true;
+    this.destroyCapability = (0, _util.createPromiseCapability)();
 
-      this.destroyed = true;
-      this.destroyCapability = (0, _util.createPromiseCapability)();
+    if (this._passwordCapability) {
+      this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback"));
+    }
 
-      if (this._passwordCapability) {
-        this._passwordCapability.reject(new Error('Worker was destroyed during onPassword callback'));
+    const waitOn = [];
+    this.pageCache.forEach(function (page) {
+      if (page) {
+        waitOn.push(page._destroy());
+      }
+    });
+    this.pageCache.length = 0;
+    this.pagePromises.length = 0;
+    const terminated = this.messageHandler.sendWithPromise("Terminate", null);
+    waitOn.push(terminated);
+    Promise.all(waitOn).then(() => {
+      this.fontLoader.clear();
+
+      if (this._networkStream) {
+        this._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
       }
 
-      var waitOn = [];
-      this.pageCache.forEach(function (page) {
-        if (page) {
-          waitOn.push(page._destroy());
-        }
-      });
-      this.pageCache = [];
-      this.pagePromises = [];
-      var terminated = this.messageHandler.sendWithPromise('Terminate', null);
-      waitOn.push(terminated);
-      Promise.all(waitOn).then(function () {
-        _this8.fontLoader.clear();
-
-        if (_this8._networkStream) {
-          _this8._networkStream.cancelAllRequests();
-        }
-
-        if (_this8.messageHandler) {
-          _this8.messageHandler.destroy();
+      if (this.messageHandler) {
+        this.messageHandler.destroy();
+        this.messageHandler = null;
+      }
 
-          _this8.messageHandler = null;
-        }
+      this.destroyCapability.resolve();
+    }, this.destroyCapability.reject);
+    return this.destroyCapability.promise;
+  }
 
-        _this8.destroyCapability.resolve();
-      }, this.destroyCapability.reject);
-      return this.destroyCapability.promise;
-    }
-  }, {
-    key: "setupMessageHandler",
-    value: function setupMessageHandler() {
-      var messageHandler = this.messageHandler,
-          loadingTask = this.loadingTask;
-      messageHandler.on('GetReader', function (data, sink) {
-        var _this9 = this;
-
-        (0, _util.assert)(this._networkStream);
-        this._fullReader = this._networkStream.getFullReader();
-
-        this._fullReader.onProgress = function (evt) {
-          _this9._lastProgress = {
-            loaded: evt.loaded,
-            total: evt.total
-          };
+  setupMessageHandler() {
+    const {
+      messageHandler,
+      loadingTask
+    } = this;
+    messageHandler.on("GetReader", (data, sink) => {
+      (0, _util.assert)(this._networkStream, "GetReader - no `IPDFStream` instance available.");
+      this._fullReader = this._networkStream.getFullReader();
+
+      this._fullReader.onProgress = evt => {
+        this._lastProgress = {
+          loaded: evt.loaded,
+          total: evt.total
         };
+      };
 
-        sink.onPull = function () {
-          _this9._fullReader.read().then(function (_ref7) {
-            var value = _ref7.value,
-                done = _ref7.done;
+      sink.onPull = () => {
+        this._fullReader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            sink.close();
+            return;
+          }
 
-            if (done) {
-              sink.close();
-              return;
-            }
+          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
+          sink.enqueue(new Uint8Array(value), 1, [value]);
+        }).catch(reason => {
+          sink.error(reason);
+        });
+      };
 
-            (0, _util.assert)((0, _util.isArrayBuffer)(value));
-            sink.enqueue(new Uint8Array(value), 1, [value]);
-          }).catch(function (reason) {
-            sink.error(reason);
-          });
-        };
+      sink.onCancel = reason => {
+        this._fullReader.cancel(reason);
+      };
+    });
+    messageHandler.on("ReaderHeadersReady", data => {
+      const headersCapability = (0, _util.createPromiseCapability)();
+      const fullReader = this._fullReader;
+      fullReader.headersReady.then(() => {
+        if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
+          if (this._lastProgress && loadingTask.onProgress) {
+            loadingTask.onProgress(this._lastProgress);
+          }
 
-        sink.onCancel = function (reason) {
-          _this9._fullReader.cancel(reason);
-        };
-      }, this);
-      messageHandler.on('ReaderHeadersReady', function (data) {
-        var _this10 = this;
-
-        var headersCapability = (0, _util.createPromiseCapability)();
-        var fullReader = this._fullReader;
-        fullReader.headersReady.then(function () {
-          if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
-            if (_this10._lastProgress && loadingTask.onProgress) {
-              loadingTask.onProgress(_this10._lastProgress);
+          fullReader.onProgress = evt => {
+            if (loadingTask.onProgress) {
+              loadingTask.onProgress({
+                loaded: evt.loaded,
+                total: evt.total
+              });
             }
+          };
+        }
 
-            fullReader.onProgress = function (evt) {
-              if (loadingTask.onProgress) {
-                loadingTask.onProgress({
-                  loaded: evt.loaded,
-                  total: evt.total
-                });
-              }
-            };
-          }
-
-          headersCapability.resolve({
-            isStreamingSupported: fullReader.isStreamingSupported,
-            isRangeSupported: fullReader.isRangeSupported,
-            contentLength: fullReader.contentLength
-          });
-        }, headersCapability.reject);
-        return headersCapability.promise;
-      }, this);
-      messageHandler.on('GetRangeReader', function (data, sink) {
-        (0, _util.assert)(this._networkStream);
+        headersCapability.resolve({
+          isStreamingSupported: fullReader.isStreamingSupported,
+          isRangeSupported: fullReader.isRangeSupported,
+          contentLength: fullReader.contentLength
+        });
+      }, headersCapability.reject);
+      return headersCapability.promise;
+    });
+    messageHandler.on("GetRangeReader", (data, sink) => {
+      (0, _util.assert)(this._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
 
-        var rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
+      const rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
 
-        sink.onPull = function () {
-          rangeReader.read().then(function (_ref8) {
-            var value = _ref8.value,
-                done = _ref8.done;
+      if (!rangeReader) {
+        sink.close();
+        return;
+      }
 
-            if (done) {
-              sink.close();
-              return;
-            }
+      sink.onPull = () => {
+        rangeReader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            sink.close();
+            return;
+          }
 
-            (0, _util.assert)((0, _util.isArrayBuffer)(value));
-            sink.enqueue(new Uint8Array(value), 1, [value]);
-          }).catch(function (reason) {
-            sink.error(reason);
-          });
-        };
+          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
+          sink.enqueue(new Uint8Array(value), 1, [value]);
+        }).catch(reason => {
+          sink.error(reason);
+        });
+      };
 
-        sink.onCancel = function (reason) {
-          rangeReader.cancel(reason);
-        };
-      }, this);
-      messageHandler.on('GetDoc', function (_ref9) {
-        var pdfInfo = _ref9.pdfInfo;
-        this.numPages = pdfInfo.numPages;
-        this.pdfDocument = new PDFDocumentProxy(pdfInfo, this, loadingTask);
-
-        loadingTask._capability.resolve(this.pdfDocument);
-      }, this);
-      messageHandler.on('PasswordRequest', function (exception) {
-        var _this11 = this;
-
-        this._passwordCapability = (0, _util.createPromiseCapability)();
-
-        if (loadingTask.onPassword) {
-          var updatePassword = function updatePassword(password) {
-            _this11._passwordCapability.resolve({
-              password: password
-            });
-          };
+      sink.onCancel = reason => {
+        rangeReader.cancel(reason);
+      };
+    });
+    messageHandler.on("GetDoc", ({
+      pdfInfo
+    }) => {
+      this._numPages = pdfInfo.numPages;
 
-          try {
-            loadingTask.onPassword(updatePassword, exception.code);
-          } catch (ex) {
-            this._passwordCapability.reject(ex);
-          }
-        } else {
-          this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
-        }
+      loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));
+    });
+    messageHandler.on("DocException", function (ex) {
+      let reason;
 
-        return this._passwordCapability.promise;
-      }, this);
-      messageHandler.on('PasswordException', function (exception) {
-        loadingTask._capability.reject(new _util.PasswordException(exception.message, exception.code));
-      }, this);
-      messageHandler.on('InvalidPDF', function (exception) {
-        loadingTask._capability.reject(new _util.InvalidPDFException(exception.message));
-      }, this);
-      messageHandler.on('MissingPDF', function (exception) {
-        loadingTask._capability.reject(new _util.MissingPDFException(exception.message));
-      }, this);
-      messageHandler.on('UnexpectedResponse', function (exception) {
-        loadingTask._capability.reject(new _util.UnexpectedResponseException(exception.message, exception.status));
-      }, this);
-      messageHandler.on('UnknownError', function (exception) {
-        loadingTask._capability.reject(new _util.UnknownErrorException(exception.message, exception.details));
-      }, this);
-      messageHandler.on('DataLoaded', function (data) {
-        if (loadingTask.onProgress) {
-          loadingTask.onProgress({
-            loaded: data.length,
-            total: data.length
-          });
-        }
+      switch (ex.name) {
+        case "PasswordException":
+          reason = new _util.PasswordException(ex.message, ex.code);
+          break;
 
-        this.downloadInfoCapability.resolve(data);
-      }, this);
-      messageHandler.on('StartRenderPage', function (data) {
-        if (this.destroyed) {
-          return;
-        }
+        case "InvalidPDFException":
+          reason = new _util.InvalidPDFException(ex.message);
+          break;
 
-        var page = this.pageCache[data.pageIndex];
+        case "MissingPDFException":
+          reason = new _util.MissingPDFException(ex.message);
+          break;
 
-        page._stats.timeEnd('Page Request');
+        case "UnexpectedResponseException":
+          reason = new _util.UnexpectedResponseException(ex.message, ex.status);
+          break;
 
-        page._startRenderPage(data.transparency, data.intent);
-      }, this);
-      messageHandler.on('RenderPageChunk', function (data) {
-        if (this.destroyed) {
-          return;
-        }
+        case "UnknownErrorException":
+          reason = new _util.UnknownErrorException(ex.message, ex.details);
+          break;
+      }
 
-        var page = this.pageCache[data.pageIndex];
+      loadingTask._capability.reject(reason);
+    });
+    messageHandler.on("PasswordRequest", exception => {
+      this._passwordCapability = (0, _util.createPromiseCapability)();
 
-        page._renderPageChunk(data.operatorList, data.intent);
-      }, this);
-      messageHandler.on('commonobj', function (data) {
-        var _this12 = this;
+      if (loadingTask.onPassword) {
+        const updatePassword = password => {
+          this._passwordCapability.resolve({
+            password
+          });
+        };
 
-        if (this.destroyed) {
-          return;
+        try {
+          loadingTask.onPassword(updatePassword, exception.code);
+        } catch (ex) {
+          this._passwordCapability.reject(ex);
         }
+      } else {
+        this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
+      }
 
-        var _data = _slicedToArray(data, 3),
-            id = _data[0],
-            type = _data[1],
-            exportedData = _data[2];
+      return this._passwordCapability.promise;
+    });
+    messageHandler.on("DataLoaded", data => {
+      if (loadingTask.onProgress) {
+        loadingTask.onProgress({
+          loaded: data.length,
+          total: data.length
+        });
+      }
 
-        if (this.commonObjs.has(id)) {
-          return;
-        }
+      this.downloadInfoCapability.resolve(data);
+    });
+    messageHandler.on("StartRenderPage", data => {
+      if (this.destroyed) {
+        return;
+      }
 
-        switch (type) {
-          case 'Font':
-            var params = this._params;
+      const page = this.pageCache[data.pageIndex];
 
-            if ('error' in exportedData) {
-              var exportedError = exportedData.error;
-              (0, _util.warn)("Error during font loading: ".concat(exportedError));
-              this.commonObjs.resolve(id, exportedError);
-              break;
-            }
+      page._startRenderPage(data.transparency, data.intent);
+    });
+    messageHandler.on("commonobj", data => {
+      if (this.destroyed) {
+        return;
+      }
 
-            var fontRegistry = null;
+      const [id, type, exportedData] = data;
 
-            if (params.pdfBug && _global_scope.default.FontInspector && _global_scope.default.FontInspector.enabled) {
-              fontRegistry = {
-                registerFont: function registerFont(font, url) {
-                  _global_scope.default['FontInspector'].fontAdded(font, url);
-                }
-              };
-            }
+      if (this.commonObjs.has(id)) {
+        return;
+      }
 
-            var font = new _font_loader.FontFaceObject(exportedData, {
-              isEvalSupported: params.isEvalSupported,
-              disableFontFace: params.disableFontFace,
-              ignoreErrors: params.ignoreErrors,
-              onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
-              fontRegistry: fontRegistry
-            });
-            this.fontLoader.bind(font).then(function () {
-              _this12.commonObjs.resolve(id, font);
-            }, function (reason) {
-              messageHandler.sendWithPromise('FontFallback', {
-                id: id
-              }).finally(function () {
-                _this12.commonObjs.resolve(id, font);
-              });
-            });
-            break;
+      switch (type) {
+        case "Font":
+          const params = this._params;
 
-          case 'FontPath':
-            this.commonObjs.resolve(id, exportedData);
+          if ("error" in exportedData) {
+            const exportedError = exportedData.error;
+            (0, _util.warn)(`Error during font loading: ${exportedError}`);
+            this.commonObjs.resolve(id, exportedError);
             break;
+          }
 
-          default:
-            throw new Error("Got unknown common object type ".concat(type));
-        }
-      }, this);
-      messageHandler.on('obj', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-
-        var _data2 = _slicedToArray(data, 4),
-            id = _data2[0],
-            pageIndex = _data2[1],
-            type = _data2[2],
-            imageData = _data2[3];
-
-        var pageProxy = this.pageCache[pageIndex];
-
-        if (pageProxy.objs.has(id)) {
-          return;
-        }
-
-        switch (type) {
-          case 'JpegStream':
-            return new Promise(function (resolve, reject) {
-              var img = new Image();
+          let fontRegistry = null;
 
-              img.onload = function () {
-                resolve(img);
-              };
+          if (params.pdfBug && globalThis.FontInspector && globalThis.FontInspector.enabled) {
+            fontRegistry = {
+              registerFont(font, url) {
+                globalThis.FontInspector.fontAdded(font, url);
+              }
 
-              img.onerror = function () {
-                reject(new Error('Error during JPEG image loading'));
-              };
+            };
+          }
 
-              img.src = imageData;
-            }).then(function (img) {
-              pageProxy.objs.resolve(id, img);
+          const font = new _font_loader.FontFaceObject(exportedData, {
+            isEvalSupported: params.isEvalSupported,
+            disableFontFace: params.disableFontFace,
+            ignoreErrors: params.ignoreErrors,
+            onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
+            fontRegistry
+          });
+          this.fontLoader.bind(font).catch(reason => {
+            return messageHandler.sendWithPromise("FontFallback", {
+              id
             });
-
-          case 'Image':
-            pageProxy.objs.resolve(id, imageData);
-            var MAX_IMAGE_SIZE_TO_STORE = 8000000;
-
-            if (imageData && 'data' in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
-              pageProxy.cleanupAfterRender = true;
+          }).finally(() => {
+            if (!params.fontExtraProperties && font.data) {
+              font.data = null;
             }
 
-            break;
+            this.commonObjs.resolve(id, font);
+          });
+          break;
 
-          default:
-            throw new Error("Got unknown object type ".concat(type));
-        }
-      }, this);
-      messageHandler.on('DocProgress', function (data) {
-        if (this.destroyed) {
-          return;
-        }
+        case "FontPath":
+        case "FontType3Res":
+        case "Image":
+          this.commonObjs.resolve(id, exportedData);
+          break;
 
-        if (loadingTask.onProgress) {
-          loadingTask.onProgress({
-            loaded: data.loaded,
-            total: data.total
-          });
-        }
-      }, this);
-      messageHandler.on('PageError', function (data) {
-        if (this.destroyed) {
-          return;
-        }
+        default:
+          throw new Error(`Got unknown common object type ${type}`);
+      }
+    });
+    messageHandler.on("obj", data => {
+      if (this.destroyed) {
+        return undefined;
+      }
 
-        var page = this.pageCache[data.pageNum - 1];
-        var intentState = page.intentStates[data.intent];
+      const [id, pageIndex, type, imageData] = data;
+      const pageProxy = this.pageCache[pageIndex];
 
-        if (intentState.displayReadyCapability) {
-          intentState.displayReadyCapability.reject(data.error);
-        } else {
-          throw new Error(data.error);
-        }
+      if (pageProxy.objs.has(id)) {
+        return undefined;
+      }
 
-        if (intentState.operatorList) {
-          intentState.operatorList.lastChunk = true;
+      switch (type) {
+        case "Image":
+          pageProxy.objs.resolve(id, imageData);
+          const MAX_IMAGE_SIZE_TO_STORE = 8000000;
 
-          for (var i = 0; i < intentState.renderTasks.length; i++) {
-            intentState.renderTasks[i].operatorListChanged();
+          if (imageData && "data" in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
+            pageProxy.cleanupAfterRender = true;
           }
-        }
-      }, this);
-      messageHandler.on('UnsupportedFeature', this._onUnsupportedFeature, this);
-      messageHandler.on('JpegDecode', function (data) {
-        if (this.destroyed) {
-          return Promise.reject(new Error('Worker was destroyed'));
-        }
 
-        if (typeof document === 'undefined') {
-          return Promise.reject(new Error('"document" is not defined.'));
-        }
-
-        var _data3 = _slicedToArray(data, 2),
-            imageUrl = _data3[0],
-            components = _data3[1];
+          break;
 
-        if (components !== 3 && components !== 1) {
-          return Promise.reject(new Error('Only 3 components or 1 component can be returned'));
-        }
+        default:
+          throw new Error(`Got unknown object type ${type}`);
+      }
 
-        return new Promise(function (resolve, reject) {
-          var img = new Image();
-
-          img.onload = function () {
-            var width = img.width;
-            var height = img.height;
-            var size = width * height;
-            var rgbaLength = size * 4;
-            var buf = new Uint8ClampedArray(size * components);
-            var tmpCanvas = document.createElement('canvas');
-            tmpCanvas.width = width;
-            tmpCanvas.height = height;
-            var tmpCtx = tmpCanvas.getContext('2d');
-            tmpCtx.drawImage(img, 0, 0);
-            var data = tmpCtx.getImageData(0, 0, width, height).data;
-
-            if (components === 3) {
-              for (var i = 0, j = 0; i < rgbaLength; i += 4, j += 3) {
-                buf[j] = data[i];
-                buf[j + 1] = data[i + 1];
-                buf[j + 2] = data[i + 2];
-              }
-            } else if (components === 1) {
-              for (var _i2 = 0, _j = 0; _i2 < rgbaLength; _i2 += 4, _j++) {
-                buf[_j] = data[_i2];
-              }
-            }
+      return undefined;
+    });
+    messageHandler.on("DocProgress", data => {
+      if (this.destroyed) {
+        return;
+      }
 
-            resolve({
-              data: buf,
-              width: width,
-              height: height
-            });
-          };
+      if (loadingTask.onProgress) {
+        loadingTask.onProgress({
+          loaded: data.loaded,
+          total: data.total
+        });
+      }
+    });
+    messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
+    messageHandler.on("FetchBuiltInCMap", (data, sink) => {
+      if (this.destroyed) {
+        sink.error(new Error("Worker was destroyed"));
+        return;
+      }
 
-          img.onerror = function () {
-            reject(new Error('JpegDecode failed to load image'));
-          };
+      let fetched = false;
 
-          img.src = imageUrl;
-        });
-      }, this);
-      messageHandler.on('FetchBuiltInCMap', function (data) {
-        if (this.destroyed) {
-          return Promise.reject(new Error('Worker was destroyed'));
+      sink.onPull = () => {
+        if (fetched) {
+          sink.close();
+          return;
         }
 
-        return this.CMapReaderFactory.fetch({
-          name: data.name
+        fetched = true;
+        this.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
+          sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
+        }).catch(function (reason) {
+          sink.error(reason);
         });
-      }, this);
+      };
+    });
+  }
+
+  _onUnsupportedFeature({
+    featureId
+  }) {
+    if (this.destroyed) {
+      return;
     }
-  }, {
-    key: "_onUnsupportedFeature",
-    value: function _onUnsupportedFeature(_ref10) {
-      var featureId = _ref10.featureId;
 
-      if (this.destroyed) {
-        return;
-      }
+    if (this.loadingTask.onUnsupportedFeature) {
+      this.loadingTask.onUnsupportedFeature(featureId);
+    }
+  }
 
-      if (this.loadingTask.onUnsupportedFeature) {
-        this.loadingTask.onUnsupportedFeature(featureId);
-      }
+  getData() {
+    return this.messageHandler.sendWithPromise("GetData", null);
+  }
+
+  getPage(pageNumber) {
+    if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
+      return Promise.reject(new Error("Invalid page request"));
     }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this.messageHandler.sendWithPromise('GetData', null);
+
+    const pageIndex = pageNumber - 1;
+
+    if (pageIndex in this.pagePromises) {
+      return this.pagePromises[pageIndex];
     }
-  }, {
-    key: "getPage",
-    value: function getPage(pageNumber) {
-      var _this13 = this;
 
-      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this.numPages) {
-        return Promise.reject(new Error('Invalid page request'));
+    const promise = this.messageHandler.sendWithPromise("GetPage", {
+      pageIndex
+    }).then(pageInfo => {
+      if (this.destroyed) {
+        throw new Error("Transport destroyed");
       }
 
-      var pageIndex = pageNumber - 1;
+      const page = new PDFPageProxy(pageIndex, pageInfo, this, this._params.pdfBug);
+      this.pageCache[pageIndex] = page;
+      return page;
+    });
+    this.pagePromises[pageIndex] = promise;
+    return promise;
+  }
 
-      if (pageIndex in this.pagePromises) {
-        return this.pagePromises[pageIndex];
-      }
+  getPageIndex(ref) {
+    return this.messageHandler.sendWithPromise("GetPageIndex", {
+      ref
+    }).catch(function (reason) {
+      return Promise.reject(new Error(reason));
+    });
+  }
 
-      var promise = this.messageHandler.sendWithPromise('GetPage', {
-        pageIndex: pageIndex
-      }).then(function (pageInfo) {
-        if (_this13.destroyed) {
-          throw new Error('Transport destroyed');
-        }
+  getAnnotations(pageIndex, intent) {
+    return this.messageHandler.sendWithPromise("GetAnnotations", {
+      pageIndex,
+      intent
+    });
+  }
 
-        var page = new PDFPageProxy(pageIndex, pageInfo, _this13, _this13._params.pdfBug);
-        _this13.pageCache[pageIndex] = page;
-        return page;
-      });
-      this.pagePromises[pageIndex] = promise;
-      return promise;
-    }
-  }, {
-    key: "getPageIndex",
-    value: function getPageIndex(ref) {
-      return this.messageHandler.sendWithPromise('GetPageIndex', {
-        ref: ref
-      }).catch(function (reason) {
-        return Promise.reject(new Error(reason));
-      });
-    }
-  }, {
-    key: "getAnnotations",
-    value: function getAnnotations(pageIndex, intent) {
-      return this.messageHandler.sendWithPromise('GetAnnotations', {
-        pageIndex: pageIndex,
-        intent: intent
-      });
-    }
-  }, {
-    key: "getDestinations",
-    value: function getDestinations() {
-      return this.messageHandler.sendWithPromise('GetDestinations', null);
-    }
-  }, {
-    key: "getDestination",
-    value: function getDestination(id) {
-      if (typeof id !== 'string') {
-        return Promise.reject(new Error('Invalid destination request.'));
-      }
+  getDestinations() {
+    return this.messageHandler.sendWithPromise("GetDestinations", null);
+  }
 
-      return this.messageHandler.sendWithPromise('GetDestination', {
-        id: id
-      });
-    }
-  }, {
-    key: "getPageLabels",
-    value: function getPageLabels() {
-      return this.messageHandler.sendWithPromise('GetPageLabels', null);
-    }
-  }, {
-    key: "getPageMode",
-    value: function getPageMode() {
-      return this.messageHandler.sendWithPromise('GetPageMode', null);
-    }
-  }, {
-    key: "getOpenActionDestination",
-    value: function getOpenActionDestination() {
-      return this.messageHandler.sendWithPromise('getOpenActionDestination', null);
-    }
-  }, {
-    key: "getAttachments",
-    value: function getAttachments() {
-      return this.messageHandler.sendWithPromise('GetAttachments', null);
-    }
-  }, {
-    key: "getJavaScript",
-    value: function getJavaScript() {
-      return this.messageHandler.sendWithPromise('GetJavaScript', null);
-    }
-  }, {
-    key: "getOutline",
-    value: function getOutline() {
-      return this.messageHandler.sendWithPromise('GetOutline', null);
-    }
-  }, {
-    key: "getPermissions",
-    value: function getPermissions() {
-      return this.messageHandler.sendWithPromise('GetPermissions', null);
-    }
-  }, {
-    key: "getMetadata",
-    value: function getMetadata() {
-      var _this14 = this;
-
-      return this.messageHandler.sendWithPromise('GetMetadata', null).then(function (results) {
-        return {
-          info: results[0],
-          metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
-          contentDispositionFilename: _this14._fullReader ? _this14._fullReader.filename : null
-        };
-      });
+  getDestination(id) {
+    if (typeof id !== "string") {
+      return Promise.reject(new Error("Invalid destination request."));
     }
-  }, {
-    key: "getStats",
-    value: function getStats() {
-      return this.messageHandler.sendWithPromise('GetStats', null);
-    }
-  }, {
-    key: "startCleanup",
-    value: function startCleanup() {
-      var _this15 = this;
 
-      this.messageHandler.sendWithPromise('Cleanup', null).then(function () {
-        for (var i = 0, ii = _this15.pageCache.length; i < ii; i++) {
-          var page = _this15.pageCache[i];
+    return this.messageHandler.sendWithPromise("GetDestination", {
+      id
+    });
+  }
 
-          if (page) {
-            page.cleanup();
-          }
-        }
+  getPageLabels() {
+    return this.messageHandler.sendWithPromise("GetPageLabels", null);
+  }
 
-        _this15.commonObjs.clear();
+  getPageLayout() {
+    return this.messageHandler.sendWithPromise("GetPageLayout", null);
+  }
 
-        _this15.fontLoader.clear();
-      });
-    }
-  }, {
-    key: "loadingParams",
-    get: function get() {
-      var params = this._params;
-      return (0, _util.shadow)(this, 'loadingParams', {
-        disableAutoFetch: params.disableAutoFetch,
-        disableCreateObjectURL: params.disableCreateObjectURL,
-        disableFontFace: params.disableFontFace,
-        nativeImageDecoderSupport: params.nativeImageDecoderSupport
-      });
-    }
-  }]);
+  getPageMode() {
+    return this.messageHandler.sendWithPromise("GetPageMode", null);
+  }
 
-  return WorkerTransport;
-}();
+  getViewerPreferences() {
+    return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
+  }
 
-var PDFObjects =
-/*#__PURE__*/
-function () {
-  function PDFObjects() {
-    _classCallCheck(this, PDFObjects);
+  getOpenAction() {
+    return this.messageHandler.sendWithPromise("GetOpenAction", null);
+  }
 
-    this._objs = Object.create(null);
+  getAttachments() {
+    return this.messageHandler.sendWithPromise("GetAttachments", null);
   }
 
-  _createClass(PDFObjects, [{
-    key: "_ensureObj",
-    value: function _ensureObj(objId) {
-      if (this._objs[objId]) {
-        return this._objs[objId];
-      }
+  getJavaScript() {
+    return this.messageHandler.sendWithPromise("GetJavaScript", null);
+  }
+
+  getOutline() {
+    return this.messageHandler.sendWithPromise("GetOutline", null);
+  }
+
+  getPermissions() {
+    return this.messageHandler.sendWithPromise("GetPermissions", null);
+  }
 
-      return this._objs[objId] = {
-        capability: (0, _util.createPromiseCapability)(),
-        data: null,
-        resolved: false
+  getMetadata() {
+    return this.messageHandler.sendWithPromise("GetMetadata", null).then(results => {
+      return {
+        info: results[0],
+        metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
+        contentDispositionFilename: this._fullReader ? this._fullReader.filename : null
       };
-    }
-  }, {
-    key: "get",
-    value: function get(objId) {
-      var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    });
+  }
 
-      if (callback) {
-        this._ensureObj(objId).capability.promise.then(callback);
+  getStats() {
+    return this.messageHandler.sendWithPromise("GetStats", null);
+  }
 
-        return null;
-      }
+  startCleanup() {
+    return this.messageHandler.sendWithPromise("Cleanup", null).then(() => {
+      for (let i = 0, ii = this.pageCache.length; i < ii; i++) {
+        const page = this.pageCache[i];
 
-      var obj = this._objs[objId];
+        if (page) {
+          const cleanupSuccessful = page.cleanup();
 
-      if (!obj || !obj.resolved) {
-        throw new Error("Requesting object that isn't resolved yet ".concat(objId, "."));
+          if (!cleanupSuccessful) {
+            throw new Error(`startCleanup: Page ${i + 1} is currently rendering.`);
+          }
+        }
       }
 
-      return obj.data;
-    }
-  }, {
-    key: "has",
-    value: function has(objId) {
-      var obj = this._objs[objId];
-      return obj ? obj.resolved : false;
+      this.commonObjs.clear();
+      this.fontLoader.clear();
+    });
+  }
+
+  get loadingParams() {
+    const params = this._params;
+    return (0, _util.shadow)(this, "loadingParams", {
+      disableAutoFetch: params.disableAutoFetch,
+      disableFontFace: params.disableFontFace
+    });
+  }
+
+}
+
+class PDFObjects {
+  constructor() {
+    this._objs = Object.create(null);
+  }
+
+  _ensureObj(objId) {
+    if (this._objs[objId]) {
+      return this._objs[objId];
     }
-  }, {
-    key: "resolve",
-    value: function resolve(objId, data) {
-      var obj = this._ensureObj(objId);
-
-      obj.resolved = true;
-      obj.data = data;
-      obj.capability.resolve(data);
+
+    return this._objs[objId] = {
+      capability: (0, _util.createPromiseCapability)(),
+      data: null,
+      resolved: false
+    };
+  }
+
+  get(objId, callback = null) {
+    if (callback) {
+      this._ensureObj(objId).capability.promise.then(callback);
+
+      return null;
     }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this._objs = Object.create(null);
+
+    const obj = this._objs[objId];
+
+    if (!obj || !obj.resolved) {
+      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
     }
-  }]);
 
-  return PDFObjects;
-}();
+    return obj.data;
+  }
+
+  has(objId) {
+    const obj = this._objs[objId];
+    return obj ? obj.resolved : false;
+  }
 
-var RenderTask =
-/*#__PURE__*/
-function () {
-  function RenderTask(internalRenderTask) {
-    _classCallCheck(this, RenderTask);
+  resolve(objId, data) {
+    const obj = this._ensureObj(objId);
 
+    obj.resolved = true;
+    obj.data = data;
+    obj.capability.resolve(data);
+  }
+
+  clear() {
+    this._objs = Object.create(null);
+  }
+
+}
+
+class RenderTask {
+  constructor(internalRenderTask) {
     this._internalRenderTask = internalRenderTask;
     this.onContinue = null;
   }
 
-  _createClass(RenderTask, [{
-    key: "cancel",
-    value: function cancel() {
-      this._internalRenderTask.cancel();
-    }
-  }, {
-    key: "then",
-    value: function then(onFulfilled, onRejected) {
-      (0, _util.deprecated)('RenderTask.then method, use the `promise` getter instead.');
-      return this.promise.then.apply(this.promise, arguments);
-    }
-  }, {
-    key: "promise",
-    get: function get() {
-      return this._internalRenderTask.capability.promise;
-    }
-  }]);
+  get promise() {
+    return this._internalRenderTask.capability.promise;
+  }
 
-  return RenderTask;
-}();
+  cancel() {
+    this._internalRenderTask.cancel();
+  }
 
-var InternalRenderTask = function InternalRenderTaskClosure() {
-  var canvasInRendering = new WeakSet();
-
-  var InternalRenderTask =
-  /*#__PURE__*/
-  function () {
-    function InternalRenderTask(_ref11) {
-      var callback = _ref11.callback,
-          params = _ref11.params,
-          objs = _ref11.objs,
-          commonObjs = _ref11.commonObjs,
-          operatorList = _ref11.operatorList,
-          pageNumber = _ref11.pageNumber,
-          canvasFactory = _ref11.canvasFactory,
-          webGLContext = _ref11.webGLContext,
-          _ref11$useRequestAnim = _ref11.useRequestAnimationFrame,
-          useRequestAnimationFrame = _ref11$useRequestAnim === void 0 ? false : _ref11$useRequestAnim,
-          _ref11$pdfBug = _ref11.pdfBug,
-          pdfBug = _ref11$pdfBug === void 0 ? false : _ref11$pdfBug;
-
-      _classCallCheck(this, InternalRenderTask);
+}
 
+const InternalRenderTask = function InternalRenderTaskClosure() {
+  const canvasInRendering = new WeakSet();
+
+  class InternalRenderTask {
+    constructor({
+      callback,
+      params,
+      objs,
+      commonObjs,
+      operatorList,
+      pageIndex,
+      canvasFactory,
+      webGLContext,
+      useRequestAnimationFrame = false,
+      pdfBug = false
+    }) {
       this.callback = callback;
       this.params = params;
       this.objs = objs;
       this.commonObjs = commonObjs;
       this.operatorListIdx = null;
       this.operatorList = operatorList;
-      this.pageNumber = pageNumber;
+      this._pageIndex = pageIndex;
       this.canvasFactory = canvasFactory;
       this.webGLContext = webGLContext;
       this._pdfBug = pdfBug;
       this.running = false;
       this.graphicsReadyCallback = null;
       this.graphicsReady = false;
-      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== 'undefined';
+      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== "undefined";
       this.cancelled = false;
       this.capability = (0, _util.createPromiseCapability)();
       this.task = new RenderTask(this);
@@ -2218,172 +1965,134 @@ var InternalRenderTask = function InternalRenderTaskClosure() {
       this._canvas = params.canvasContext.canvas;
     }
 
-    _createClass(InternalRenderTask, [{
-      key: "initializeGraphics",
-      value: function initializeGraphics() {
-        var transparency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    initializeGraphics(transparency = false) {
+      if (this.cancelled) {
+        return;
+      }
 
-        if (this.cancelled) {
-          return;
+      if (this._canvas) {
+        if (canvasInRendering.has(this._canvas)) {
+          throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed.");
         }
 
-        if (this._canvas) {
-          if (canvasInRendering.has(this._canvas)) {
-            throw new Error('Cannot use the same canvas during multiple render() operations. ' + 'Use different canvas or ensure previous operations were ' + 'cancelled or completed.');
-          }
+        canvasInRendering.add(this._canvas);
+      }
 
-          canvasInRendering.add(this._canvas);
-        }
+      if (this._pdfBug && globalThis.StepperManager && globalThis.StepperManager.enabled) {
+        this.stepper = globalThis.StepperManager.create(this._pageIndex);
+        this.stepper.init(this.operatorList);
+        this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
+      }
 
-        if (this._pdfBug && _global_scope.default.StepperManager && _global_scope.default.StepperManager.enabled) {
-          this.stepper = _global_scope.default.StepperManager.create(this.pageNumber - 1);
-          this.stepper.init(this.operatorList);
-          this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
-        }
+      const {
+        canvasContext,
+        viewport,
+        transform,
+        imageLayer,
+        background
+      } = this.params;
+      this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer);
+      this.gfx.beginDrawing({
+        transform,
+        viewport,
+        transparency,
+        background
+      });
+      this.operatorListIdx = 0;
+      this.graphicsReady = true;
 
-        var _this$params = this.params,
-            canvasContext = _this$params.canvasContext,
-            viewport = _this$params.viewport,
-            transform = _this$params.transform,
-            imageLayer = _this$params.imageLayer,
-            background = _this$params.background;
-        this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer);
-        this.gfx.beginDrawing({
-          transform: transform,
-          viewport: viewport,
-          transparency: transparency,
-          background: background
-        });
-        this.operatorListIdx = 0;
-        this.graphicsReady = true;
+      if (this.graphicsReadyCallback) {
+        this.graphicsReadyCallback();
+      }
+    }
 
-        if (this.graphicsReadyCallback) {
-          this.graphicsReadyCallback();
-        }
+    cancel(error = null) {
+      this.running = false;
+      this.cancelled = true;
+
+      if (this.gfx) {
+        this.gfx.endDrawing();
       }
-    }, {
-      key: "cancel",
-      value: function cancel() {
-        var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-        this.running = false;
-        this.cancelled = true;
 
-        if (this.gfx) {
-          this.gfx.endDrawing();
-        }
+      if (this._canvas) {
+        canvasInRendering.delete(this._canvas);
+      }
+
+      this.callback(error || new _display_utils.RenderingCancelledException(`Rendering cancelled, page ${this._pageIndex + 1}`, "canvas"));
+    }
 
-        if (this._canvas) {
-          canvasInRendering.delete(this._canvas);
+    operatorListChanged() {
+      if (!this.graphicsReady) {
+        if (!this.graphicsReadyCallback) {
+          this.graphicsReadyCallback = this._continueBound;
         }
 
-        this.callback(error || new _dom_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this.pageNumber), 'canvas'));
+        return;
       }
-    }, {
-      key: "operatorListChanged",
-      value: function operatorListChanged() {
-        if (!this.graphicsReady) {
-          if (!this.graphicsReadyCallback) {
-            this.graphicsReadyCallback = this._continueBound;
-          }
 
-          return;
-        }
+      if (this.stepper) {
+        this.stepper.updateOperatorList(this.operatorList);
+      }
 
-        if (this.stepper) {
-          this.stepper.updateOperatorList(this.operatorList);
-        }
+      if (this.running) {
+        return;
+      }
 
-        if (this.running) {
-          return;
-        }
+      this._continue();
+    }
+
+    _continue() {
+      this.running = true;
 
-        this._continue();
+      if (this.cancelled) {
+        return;
       }
-    }, {
-      key: "_continue",
-      value: function _continue() {
-        this.running = true;
 
-        if (this.cancelled) {
-          return;
-        }
+      if (this.task.onContinue) {
+        this.task.onContinue(this._scheduleNextBound);
+      } else {
+        this._scheduleNext();
+      }
+    }
 
-        if (this.task.onContinue) {
-          this.task.onContinue(this._scheduleNextBound);
-        } else {
-          this._scheduleNext();
-        }
+    _scheduleNext() {
+      if (this._useRequestAnimationFrame) {
+        window.requestAnimationFrame(() => {
+          this._nextBound().catch(this.cancel.bind(this));
+        });
+      } else {
+        Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));
       }
-    }, {
-      key: "_scheduleNext",
-      value: function _scheduleNext() {
-        var _this16 = this;
+    }
 
-        if (this._useRequestAnimationFrame) {
-          window.requestAnimationFrame(function () {
-            _this16._nextBound().catch(_this16.cancel.bind(_this16));
-          });
-        } else {
-          Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));
-        }
+    async _next() {
+      if (this.cancelled) {
+        return;
       }
-    }, {
-      key: "_next",
-      value: function () {
-        var _next2 = _asyncToGenerator(
-        /*#__PURE__*/
-        _regenerator.default.mark(function _callee() {
-          return _regenerator.default.wrap(function _callee$(_context) {
-            while (1) {
-              switch (_context.prev = _context.next) {
-                case 0:
-                  if (!this.cancelled) {
-                    _context.next = 2;
-                    break;
-                  }
-
-                  return _context.abrupt("return");
-
-                case 2:
-                  this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
-
-                  if (this.operatorListIdx === this.operatorList.argsArray.length) {
-                    this.running = false;
-
-                    if (this.operatorList.lastChunk) {
-                      this.gfx.endDrawing();
-
-                      if (this._canvas) {
-                        canvasInRendering.delete(this._canvas);
-                      }
-
-                      this.callback();
-                    }
-                  }
-
-                case 4:
-                case "end":
-                  return _context.stop();
-              }
-            }
-          }, _callee, this);
-        }));
 
-        function _next() {
-          return _next2.apply(this, arguments);
-        }
+      this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
+
+      if (this.operatorListIdx === this.operatorList.argsArray.length) {
+        this.running = false;
 
-        return _next;
-      }()
-    }]);
+        if (this.operatorList.lastChunk) {
+          this.gfx.endDrawing();
+
+          if (this._canvas) {
+            canvasInRendering.delete(this._canvas);
+          }
 
-    return InternalRenderTask;
-  }();
+          this.callback();
+        }
+      }
+    }
+
+  }
 
   return InternalRenderTask;
 }();
 
-var version = '2.1.266';
+const version = '2.5.207';
 exports.version = version;
-var build = '81f5835c';
+const build = '0974d605';
 exports.build = build;