pdfjs-dist 2.0.550 → 2.3.200

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 2017 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,103 +19,164 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.build = exports.version = exports.setPDFNetworkStreamFactory = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.getDocument = undefined;
+exports.getDocument = getDocument;
+exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
+exports.build = exports.version = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = void 0;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var _util = require("../shared/util");
 
-var _util = require('../shared/util');
+var _display_utils = require("./display_utils");
 
-var _dom_utils = require('./dom_utils');
+var _font_loader = require("./font_loader");
 
-var _font_loader = require('./font_loader');
+var _api_compatibility = require("./api_compatibility");
 
-var _api_compatibility = require('./api_compatibility');
+var _canvas = require("./canvas");
 
-var _canvas = require('./canvas');
+var _global_scope = _interopRequireDefault(require("../shared/global_scope"));
 
-var _global_scope = require('../shared/global_scope');
+var _worker_options = require("./worker_options");
 
-var _global_scope2 = _interopRequireDefault(_global_scope);
+var _message_handler = require("../shared/message_handler");
 
-var _worker_options = require('./worker_options');
+var _metadata = require("./metadata");
 
-var _message_handler = require('../shared/message_handler');
+var _transport_stream = require("./transport_stream");
 
-var _metadata = require('./metadata');
+var _webgl = require("./webgl");
 
-var _transport_stream = require('./transport_stream');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _webgl = require('./webgl');
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _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 RENDERING_CANCELLED_TIMEOUT = 100;
 var isWorkerDisabled = false;
-var workerSrc = void 0;
-var pdfjsFilePath = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : null;
+var fallbackWorkerSrc;
 var fakeWorkerFilesLoader = null;
-var useRequireEnsure = false;
 {
+  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) {
-    workerSrc = requirejs.toUrl('pdfjs-dist/build/pdf.worker.js');
+    fallbackWorkerSrc = requirejs.toUrl('pdfjs-dist/build/pdf.worker.js');
   }
+
   var dynamicLoaderSupported = typeof requirejs !== 'undefined' && requirejs.load;
-  fakeWorkerFilesLoader = useRequireEnsure ? function (callback) {
-    require.ensure([], function () {
-      var worker;
-      worker = require('../pdf.worker.js');
-      callback(worker.WorkerMessageHandler);
+  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 (callback) {
-    requirejs(['pdfjs-dist/build/pdf.worker'], function (worker) {
-      callback(worker.WorkerMessageHandler);
+  } : 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;
+
 function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
   createPDFNetworkStream = pdfNetworkStreamFactory;
 }
+
 function getDocument(src) {
   var task = new PDFDocumentLoadingTask();
   var source;
+
   if (typeof src === 'string') {
-    source = { url: src };
+    source = {
+      url: src
+    };
   } else if ((0, _util.isArrayBuffer)(src)) {
-    source = { data: src };
+    source = {
+      data: src
+    };
   } else if (src instanceof PDFDataRangeTransport) {
-    source = { range: src };
+    source = {
+      range: src
+    };
   } else {
-    if ((typeof src === 'undefined' ? 'undefined' : _typeof(src)) !== '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');
     }
+
     source = src;
   }
+
   var params = Object.create(null);
-  var rangeTransport = null;
-  var worker = null;
-  var CMapReaderFactory = _dom_utils.DOMCMapReaderFactory;
+  var rangeTransport = null,
+      worker = null;
+
   for (var key in source) {
     if (key === 'url' && typeof window !== 'undefined') {
       params[key] = new URL(source[key], window.location).href;
@@ -128,79 +189,90 @@ function getDocument(src) {
       continue;
     } else if (key === 'data' && !(source[key] instanceof Uint8Array)) {
       var pdfBytes = source[key];
+
       if (typeof pdfBytes === 'string') {
         params[key] = (0, _util.stringToBytes)(pdfBytes);
-      } else if ((typeof pdfBytes === 'undefined' ? 'undefined' : _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.');
       }
-      continue;
-    } else if (key === 'CMapReaderFactory') {
-      CMapReaderFactory = source[key];
+
       continue;
     }
+
     params[key] = source[key];
   }
+
   params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
+  params.CMapReaderFactory = params.CMapReaderFactory || _display_utils.DOMCMapReaderFactory;
   params.ignoreErrors = params.stopAtErrors !== 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') {
     params.isEvalSupported = true;
   }
+
   if (typeof params.disableFontFace !== 'boolean') {
     params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
   }
+
   if (typeof params.disableRange !== 'boolean') {
-    params.disableRange = _api_compatibility.apiCompatibilityParams.disableRange || false;
+    params.disableRange = false;
   }
+
   if (typeof params.disableStream !== 'boolean') {
-    params.disableStream = _api_compatibility.apiCompatibilityParams.disableStream || false;
+    params.disableStream = false;
   }
+
   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,
-      verbosity: params.verbosity
+      verbosity: params.verbosity,
+      port: _worker_options.GlobalWorkerOptions.workerPort
     };
-    var workerPort = _worker_options.GlobalWorkerOptions.workerPort;
-    if (workerPort) {
-      workerParams.port = workerPort;
-      worker = PDFWorker.fromPort(workerParams);
-    } else {
-      worker = new PDFWorker(workerParams);
-    }
+    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
     task._worker = worker;
   }
+
   var docId = task.docId;
   worker.promise.then(function () {
     if (task.destroyed) {
       throw new Error('Loading aborted');
     }
+
     return _fetchDocument(worker, params, rangeTransport, docId).then(function (workerId) {
       if (task.destroyed) {
         throw new Error('Loading aborted');
       }
-      var networkStream = void 0;
+
+      var networkStream;
+
       if (rangeTransport) {
         networkStream = new _transport_stream.PDFDataTransportStream({
           length: params.length,
           initialData: params.initialData,
+          progressiveDone: params.progressiveDone,
           disableRange: params.disableRange,
           disableStream: params.disableStream
         }, rangeTransport);
@@ -215,26 +287,31 @@ function getDocument(src) {
           disableStream: params.disableStream
         });
       }
+
       var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
       messageHandler.postMessageTransfers = worker.postMessageTransfers;
-      var transport = new WorkerTransport(messageHandler, task, networkStream, params, CMapReaderFactory);
+      var transport = new WorkerTransport(messageHandler, task, networkStream, params);
       task._transport = transport;
       messageHandler.send('Ready', null);
     });
-  }).catch(task._capability.reject);
+  })["catch"](task._capability.reject);
   return task;
 }
+
 function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
   if (worker.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.0.550',
+    apiVersion: '2.3.200',
     source: {
       data: source.data,
       url: source.url,
@@ -255,175 +332,388 @@ function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
     if (worker.destroyed) {
       throw new Error('Worker was destroyed');
     }
+
     return workerId;
   });
 }
+
 var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
   var nextDocumentId = 0;
-  function PDFDocumentLoadingTask() {
-    this._capability = (0, _util.createPromiseCapability)();
-    this._transport = null;
-    this._worker = null;
-    this.docId = 'd' + nextDocumentId++;
-    this.destroyed = false;
-    this.onPassword = null;
-    this.onProgress = null;
-    this.onUnsupportedFeature = null;
-  }
-  PDFDocumentLoadingTask.prototype = {
-    get promise() {
-      return this._capability.promise;
-    },
-    destroy: function destroy() {
-      var _this = this;
 
-      this.destroyed = true;
-      var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
-      return transportDestroyed.then(function () {
-        _this._transport = null;
-        if (_this._worker) {
-          _this._worker.destroy();
-          _this._worker = null;
-        }
-      });
-    },
+  var PDFDocumentLoadingTask =
+  /*#__PURE__*/
+  function () {
+    function PDFDocumentLoadingTask() {
+      _classCallCheck(this, PDFDocumentLoadingTask);
 
-    then: function PDFDocumentLoadingTask_then(onFulfilled, onRejected) {
-      return this.promise.then.apply(this.promise, arguments);
+      this._capability = (0, _util.createPromiseCapability)();
+      this._transport = null;
+      this._worker = null;
+      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;
+
+        this.destroyed = true;
+        var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
+        return transportDestroyed.then(function () {
+          _this._transport = null;
+
+          if (_this._worker) {
+            _this._worker.destroy();
+
+            _this._worker = null;
+          }
+        });
+      }
+    }, {
+      key: "then",
+      value: function then(onFulfilled, onRejected) {
+        (0, _display_utils.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;
+      }
+    }]);
+
+    return PDFDocumentLoadingTask;
+  }();
+
   return PDFDocumentLoadingTask;
 }();
-var PDFDataRangeTransport = function pdfDataRangeTransportClosure() {
+
+var PDFDataRangeTransport =
+/*#__PURE__*/
+function () {
   function PDFDataRangeTransport(length, initialData) {
+    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    _classCallCheck(this, PDFDataRangeTransport);
+
     this.length = length;
     this.initialData = initialData;
+    this.progressiveDone = progressiveDone;
     this._rangeListeners = [];
     this._progressListeners = [];
     this._progressiveReadListeners = [];
+    this._progressiveDoneListeners = [];
     this._readyCapability = (0, _util.createPromiseCapability)();
   }
-  PDFDataRangeTransport.prototype = {
-    addRangeListener: function PDFDataRangeTransport_addRangeListener(listener) {
+
+  _createClass(PDFDataRangeTransport, [{
+    key: "addRangeListener",
+    value: function addRangeListener(listener) {
       this._rangeListeners.push(listener);
-    },
-    addProgressListener: function PDFDataRangeTransport_addProgressListener(listener) {
+    }
+  }, {
+    key: "addProgressListener",
+    value: function addProgressListener(listener) {
       this._progressListeners.push(listener);
-    },
-    addProgressiveReadListener: function PDFDataRangeTransport_addProgressiveReadListener(listener) {
+    }
+  }, {
+    key: "addProgressiveReadListener",
+    value: function addProgressiveReadListener(listener) {
       this._progressiveReadListeners.push(listener);
-    },
-    onDataRange: function PDFDataRangeTransport_onDataRange(begin, chunk) {
-      var listeners = this._rangeListeners;
-      for (var i = 0, n = listeners.length; i < n; ++i) {
-        listeners[i](begin, chunk);
+    }
+  }, {
+    key: "addProgressiveDoneListener",
+    value: function addProgressiveDoneListener(listener) {
+      this._progressiveDoneListeners.push(listener);
+    }
+  }, {
+    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: function PDFDataRangeTransport_onDataProgress(loaded) {
+    }
+  }, {
+    key: "onDataProgress",
+    value: function onDataProgress(loaded, total) {
       var _this2 = this;
 
       this._readyCapability.promise.then(function () {
-        var listeners = _this2._progressListeners;
-        for (var i = 0, n = listeners.length; i < n; ++i) {
-          listeners[i](loaded);
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = _this2._progressListeners[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var listener = _step2.value;
+            listener(loaded, total);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
+              _iterator2["return"]();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
         }
       });
-    },
-    onDataProgressiveRead: function PDFDataRangeTransport_onDataProgress(chunk) {
+    }
+  }, {
+    key: "onDataProgressiveRead",
+    value: function onDataProgressiveRead(chunk) {
       var _this3 = this;
 
       this._readyCapability.promise.then(function () {
-        var listeners = _this3._progressiveReadListeners;
-        for (var i = 0, n = listeners.length; i < n; ++i) {
-          listeners[i](chunk);
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
+
+        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;
+            }
+          }
         }
       });
-    },
-    transportReady: function PDFDataRangeTransport_transportReady() {
+    }
+  }, {
+    key: "onDataProgressiveDone",
+    value: function onDataProgressiveDone() {
+      var _this4 = this;
+
+      this._readyCapability.promise.then(function () {
+        var _iteratorNormalCompletion4 = true;
+        var _didIteratorError4 = false;
+        var _iteratorError4 = undefined;
+
+        try {
+          for (var _iterator4 = _this4._progressiveDoneListeners[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var listener = _step4.value;
+            listener();
+          }
+        } catch (err) {
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
+              _iterator4["return"]();
+            }
+          } finally {
+            if (_didIteratorError4) {
+              throw _iteratorError4;
+            }
+          }
+        }
+      });
+    }
+  }, {
+    key: "transportReady",
+    value: function transportReady() {
       this._readyCapability.resolve();
-    },
-    requestDataRange: function PDFDataRangeTransport_requestDataRange(begin, end) {
+    }
+  }, {
+    key: "requestDataRange",
+    value: function requestDataRange(begin, end) {
       (0, _util.unreachable)('Abstract method PDFDataRangeTransport.requestDataRange');
-    },
-    abort: function PDFDataRangeTransport_abort() {}
-  };
+    }
+  }, {
+    key: "abort",
+    value: function abort() {}
+  }]);
+
   return PDFDataRangeTransport;
 }();
-var PDFDocumentProxy = function PDFDocumentProxyClosure() {
-  function PDFDocumentProxy(pdfInfo, transport, loadingTask) {
-    this.pdfInfo = pdfInfo;
-    this.transport = transport;
-    this.loadingTask = loadingTask;
-  }
-  PDFDocumentProxy.prototype = {
-    get numPages() {
-      return this.pdfInfo.numPages;
-    },
-    get fingerprint() {
-      return this.pdfInfo.fingerprint;
-    },
-    getPage: function getPage(pageNumber) {
-      return this.transport.getPage(pageNumber);
-    },
 
-    getPageIndex: function PDFDocumentProxy_getPageIndex(ref) {
-      return this.transport.getPageIndex(ref);
-    },
-    getDestinations: function PDFDocumentProxy_getDestinations() {
-      return this.transport.getDestinations();
-    },
-    getDestination: function PDFDocumentProxy_getDestination(id) {
-      return this.transport.getDestination(id);
-    },
-    getPageLabels: function PDFDocumentProxy_getPageLabels() {
-      return this.transport.getPageLabels();
-    },
-    getPageMode: function getPageMode() {
-      return this.transport.getPageMode();
-    },
+exports.PDFDataRangeTransport = PDFDataRangeTransport;
 
-    getAttachments: function PDFDocumentProxy_getAttachments() {
-      return this.transport.getAttachments();
-    },
-    getJavaScript: function getJavaScript() {
-      return this.transport.getJavaScript();
-    },
+var PDFDocumentProxy =
+/*#__PURE__*/
+function () {
+  function PDFDocumentProxy(pdfInfo, transport) {
+    _classCallCheck(this, PDFDocumentProxy);
 
-    getOutline: function PDFDocumentProxy_getOutline() {
-      return this.transport.getOutline();
-    },
-    getMetadata: function PDFDocumentProxy_getMetadata() {
-      return this.transport.getMetadata();
-    },
-    getData: function PDFDocumentProxy_getData() {
-      return this.transport.getData();
-    },
-    getDownloadInfo: function PDFDocumentProxy_getDownloadInfo() {
-      return this.transport.downloadInfoCapability.promise;
-    },
-    getStats: function PDFDocumentProxy_getStats() {
-      return this.transport.getStats();
-    },
-    cleanup: function PDFDocumentProxy_cleanup() {
-      this.transport.startCleanup();
-    },
-    destroy: function PDFDocumentProxy_destroy() {
+    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: "getPageLayout",
+    value: function getPageLayout() {
+      return this._transport.getPageLayout();
+    }
+  }, {
+    key: "getPageMode",
+    value: function getPageMode() {
+      return this._transport.getPageMode();
+    }
+  }, {
+    key: "getViewerPreferences",
+    value: function getViewerPreferences() {
+      return this._transport.getViewerPreferences();
+    }
+  }, {
+    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();
-    },
-    get loadingParams() {
-      return this.transport.loadingParams;
     }
-  };
+  }, {
+    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;
+    }
+  }, {
+    key: "loadingTask",
+    get: function get() {
+      return this._transport.loadingTask;
+    }
+  }]);
+
   return PDFDocumentProxy;
 }();
-var PDFPageProxy = function PDFPageProxyClosure() {
+
+exports.PDFDocumentProxy = PDFDocumentProxy;
+
+var PDFPageProxy =
+/*#__PURE__*/
+function () {
   function PDFPageProxy(pageIndex, pageInfo, transport) {
     var pdfBug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
+    _classCallCheck(this, PDFPageProxy);
+
     this.pageIndex = pageIndex;
-    this.pageInfo = pageInfo;
-    this.transport = transport;
-    this._stats = pdfBug ? new _dom_utils.StatTimer() : _dom_utils.DummyStatTimer;
+    this._pageInfo = pageInfo;
+    this._transport = transport;
+    this._stats = pdfBug ? new _display_utils.StatTimer() : _display_utils.DummyStatTimer;
     this._pdfBug = pdfBug;
     this.commonObjs = transport.commonObjs;
     this.objs = new PDFObjects();
@@ -432,57 +722,88 @@ var PDFPageProxy = function PDFPageProxyClosure() {
     this.intentStates = Object.create(null);
     this.destroyed = false;
   }
-  PDFPageProxy.prototype = {
-    get pageNumber() {
-      return this.pageIndex + 1;
-    },
-    get rotate() {
-      return this.pageInfo.rotate;
-    },
-    get ref() {
-      return this.pageInfo.ref;
-    },
-    get userUnit() {
-      return this.pageInfo.userUnit;
-    },
-    get view() {
-      return this.pageInfo.view;
-    },
-    getViewport: function getViewport(scale) {
-      var rotate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.rotate;
-      var dontFlip = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
 
-      return new _dom_utils.PageViewport({
+  _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, _display_utils.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 _display_utils.PageViewport({
         viewBox: this.view,
         scale: scale,
-        rotation: rotate,
+        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;
 
-    getAnnotations: function PDFPageProxy_getAnnotations(params) {
-      var intent = params && params.intent || null;
       if (!this.annotationsPromise || this.annotationsIntent !== intent) {
-        this.annotationsPromise = this.transport.getAnnotations(this.pageIndex, intent);
+        this.annotationsPromise = this._transport.getAnnotations(this.pageIndex, intent);
         this.annotationsIntent = intent;
       }
+
       return this.annotationsPromise;
-    },
-    render: function PDFPageProxy_render(params) {
-      var _this4 = this;
+    }
+  }, {
+    key: "render",
+    value: function render(_ref3) {
+      var _this5 = 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');
+      var renderingIntent = intent === 'print' ? 'print' : 'display';
       this.pendingCleanup = false;
-      var renderingIntent = params.intent === 'print' ? 'print' : 'display';
-      var canvasFactory = params.canvasFactory || new _dom_utils.DOMCanvasFactory();
-      var webGLContext = new _webgl.WebGLContext({ enable: params.enableWebGL });
+
       if (!this.intentStates[renderingIntent]) {
         this.intentStates[renderingIntent] = Object.create(null);
       }
+
       var intentState = this.intentStates[renderingIntent];
+
+      if (intentState.streamReaderCancelTimeout) {
+        clearTimeout(intentState.streamReaderCancelTimeout);
+        intentState.streamReaderCancelTimeout = null;
+      }
+
+      var canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory();
+      var webGLContext = new _webgl.WebGLContext({
+        enable: enableWebGL
+      });
+
       if (!intentState.displayReadyCapability) {
-        intentState.receivingOperatorList = true;
         intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
         intentState.operatorList = {
           fnArray: [],
@@ -490,67 +811,105 @@ var PDFPageProxy = function PDFPageProxyClosure() {
           lastChunk: false
         };
         stats.time('Page Request');
-        this.transport.messageHandler.send('RenderPageRequest', {
+
+        this._pumpOperatorList({
           pageIndex: this.pageNumber - 1,
           intent: renderingIntent,
-          renderInteractiveForms: params.renderInteractiveForms === true
+          renderInteractiveForms: renderInteractiveForms === true
         });
       }
+
       var complete = function complete(error) {
         var i = intentState.renderTasks.indexOf(internalRenderTask);
+
         if (i >= 0) {
           intentState.renderTasks.splice(i, 1);
         }
-        if (_this4.cleanupAfterRender) {
-          _this4.pendingCleanup = true;
+
+        if (_this5.cleanupAfterRender || renderingIntent === 'print') {
+          _this5.pendingCleanup = true;
         }
-        _this4._tryCleanup();
+
+        _this5._tryCleanup();
+
         if (error) {
           internalRenderTask.capability.reject(error);
+
+          _this5._abortOperatorList({
+            intentState: intentState,
+            reason: error
+          });
         } else {
           internalRenderTask.capability.resolve();
         }
+
         stats.timeEnd('Rendering');
         stats.timeEnd('Overall');
       };
-      var internalRenderTask = new InternalRenderTask(complete, params, this.objs, this.commonObjs, intentState.operatorList, this.pageNumber, canvasFactory, webGLContext, this._pdfBug);
-      internalRenderTask.useRequestAnimationFrame = renderingIntent !== 'print';
+
+      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
+      });
+
       if (!intentState.renderTasks) {
         intentState.renderTasks = [];
       }
+
       intentState.renderTasks.push(internalRenderTask);
       var renderTask = internalRenderTask.task;
       intentState.displayReadyCapability.promise.then(function (transparency) {
-        if (_this4.pendingCleanup) {
+        if (_this5.pendingCleanup) {
           complete();
           return;
         }
+
         stats.time('Rendering');
         internalRenderTask.initializeGraphics(transparency);
         internalRenderTask.operatorListChanged();
-      }).catch(complete);
+      })["catch"](complete);
       return renderTask;
-    },
-    getOperatorList: function PDFPageProxy_getOperatorList() {
+    }
+  }, {
+    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);
           }
         }
       }
+
       var renderingIntent = 'oplist';
+
       if (!this.intentStates[renderingIntent]) {
         this.intentStates[renderingIntent] = Object.create(null);
       }
+
       var intentState = this.intentStates[renderingIntent];
       var opListTask;
+
       if (!intentState.opListReadCapability) {
         opListTask = {};
         opListTask.operatorListChanged = operatorListChanged;
-        intentState.receivingOperatorList = true;
         intentState.opListReadCapability = (0, _util.createPromiseCapability)();
         intentState.renderTasks = [];
         intentState.renderTasks.push(opListTask);
@@ -559,47 +918,64 @@ var PDFPageProxy = function PDFPageProxyClosure() {
           argsArray: [],
           lastChunk: false
         };
-        this.transport.messageHandler.send('RenderPageRequest', {
+
+        this._stats.time('Page Request');
+
+        this._pumpOperatorList({
           pageIndex: this.pageIndex,
           intent: renderingIntent
         });
       }
+
       return intentState.opListReadCapability.promise;
-    },
-    streamTextContent: function streamTextContent() {
-      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    }
+  }, {
+    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', {
+      return this._transport.messageHandler.sendWithStream('GetTextContent', {
         pageIndex: this.pageNumber - 1,
-        normalizeWhitespace: params.normalizeWhitespace === true,
-        combineTextItems: params.disableCombineTextItems !== true
+        normalizeWhitespace: normalizeWhitespace === true,
+        combineTextItems: disableCombineTextItems !== true
       }, {
         highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
         size: function size(textContent) {
           return textContent.items.length;
         }
       });
-    },
-
-    getTextContent: function PDFPageProxy_getTextContent(params) {
-      params = params || {};
+    }
+  }, {
+    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 (_ref) {
-            var value = _ref.value,
-                done = _ref.done;
+          reader.read().then(function (_ref5) {
+            var _textContent$items;
+
+            var value = _ref5.value,
+                done = _ref5.done;
 
             if (done) {
               resolve(textContent);
               return;
             }
-            _util.Util.extendObj(textContent.styles, value.styles);
-            _util.Util.appendToArray(textContent.items, value.items);
+
+            Object.assign(textContent.styles, value.styles);
+
+            (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items));
+
             pump();
           }, reject);
         }
+
         var reader = readableStream.getReader();
         var textContent = {
           items: [],
@@ -607,83 +983,256 @@ var PDFPageProxy = function PDFPageProxyClosure() {
         };
         pump();
       });
-    },
-    _destroy: function PDFPageProxy_destroy() {
+    }
+  }, {
+    key: "_destroy",
+    value: function _destroy() {
+      var _this6 = this;
+
       this.destroyed = true;
-      this.transport.pageCache[this.pageIndex] = null;
+      this._transport.pageCache[this.pageIndex] = null;
       var waitOn = [];
       Object.keys(this.intentStates).forEach(function (intent) {
+        var intentState = _this6.intentStates[intent];
+
+        _this6._abortOperatorList({
+          intentState: intentState,
+          reason: new Error('Page was destroyed.'),
+          force: true
+        });
+
         if (intent === 'oplist') {
           return;
         }
-        var intentState = this.intentStates[intent];
+
         intentState.renderTasks.forEach(function (renderTask) {
-          var renderCompleted = renderTask.capability.promise.catch(function () {});
+          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);
-    },
-    cleanup: function cleanup() {
+    }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
       var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
       this.pendingCleanup = true;
+
       this._tryCleanup(resetStats);
-    },
-    _tryCleanup: function _tryCleanup() {
+    }
+  }, {
+    key: "_tryCleanup",
+    value: function _tryCleanup() {
+      var _this7 = this;
+
       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)) {
+        var intentState = _this7.intentStates[intent];
+        return intentState.renderTasks.length !== 0 || !intentState.operatorList.lastChunk;
+      })) {
         return;
       }
+
       Object.keys(this.intentStates).forEach(function (intent) {
-        delete this.intentStates[intent];
-      }, this);
+        delete _this7.intentStates[intent];
+      });
       this.objs.clear();
       this.annotationsPromise = null;
-      if (resetStats && this._stats instanceof _dom_utils.StatTimer) {
-        this._stats = new _dom_utils.StatTimer();
+
+      if (resetStats && this._stats instanceof _display_utils.StatTimer) {
+        this._stats = new _display_utils.StatTimer();
       }
-      this.pendingCleanup = false;
-    },
 
-    _startRenderPage: function PDFPageProxy_startRenderPage(transparency, intent) {
+      this.pendingCleanup = false;
+    }
+  }, {
+    key: "_startRenderPage",
+    value: function _startRenderPage(transparency, intent) {
       var intentState = this.intentStates[intent];
+
+      if (!intentState) {
+        return;
+      }
+
+      this._stats.timeEnd('Page Request');
+
       if (intentState.displayReadyCapability) {
         intentState.displayReadyCapability.resolve(transparency);
       }
-    },
-    _renderPageChunk: function PDFPageProxy_renderPageChunk(operatorListChunk, intent) {
-      var intentState = this.intentStates[intent];
-      var i, ii;
-      for (i = 0, ii = operatorListChunk.length; i < ii; i++) {
+    }
+  }, {
+    key: "_renderPageChunk",
+    value: function _renderPageChunk(operatorListChunk, intentState) {
+      for (var 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;
-      for (i = 0; i < intentState.renderTasks.length; i++) {
-        intentState.renderTasks[i].operatorListChanged();
+
+      for (var _i = 0; _i < intentState.renderTasks.length; _i++) {
+        intentState.renderTasks[_i].operatorListChanged();
       }
+
       if (operatorListChunk.lastChunk) {
-        intentState.receivingOperatorList = false;
         this._tryCleanup();
       }
-    },
-    get stats() {
-      return this._stats instanceof _dom_utils.StatTimer ? this._stats : null;
     }
-  };
+  }, {
+    key: "_pumpOperatorList",
+    value: function _pumpOperatorList(args) {
+      var _this8 = this;
+
+      (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
+
+      var readableStream = this._transport.messageHandler.sendWithStream('GetOperatorList', args);
+
+      var reader = readableStream.getReader();
+      var intentState = this.intentStates[args.intent];
+      intentState.streamReader = reader;
+
+      var pump = function pump() {
+        reader.read().then(function (_ref6) {
+          var value = _ref6.value,
+              done = _ref6.done;
+
+          if (done) {
+            intentState.streamReader = null;
+            return;
+          }
+
+          if (_this8._transport.destroyed) {
+            return;
+          }
+
+          _this8._renderPageChunk(value, intentState);
+
+          pump();
+        }, function (reason) {
+          intentState.streamReader = null;
+
+          if (_this8._transport.destroyed) {
+            return;
+          }
+
+          if (intentState.operatorList) {
+            intentState.operatorList.lastChunk = true;
+
+            for (var i = 0; i < intentState.renderTasks.length; i++) {
+              intentState.renderTasks[i].operatorListChanged();
+            }
+
+            _this8._tryCleanup();
+          }
+
+          if (intentState.displayReadyCapability) {
+            intentState.displayReadyCapability.reject(reason);
+          } else if (intentState.opListReadCapability) {
+            intentState.opListReadCapability.reject(reason);
+          } else {
+            throw reason;
+          }
+        });
+      };
+
+      pump();
+    }
+  }, {
+    key: "_abortOperatorList",
+    value: function _abortOperatorList(_ref7) {
+      var _this9 = this;
+
+      var intentState = _ref7.intentState,
+          reason = _ref7.reason,
+          _ref7$force = _ref7.force,
+          force = _ref7$force === void 0 ? false : _ref7$force;
+      (0, _util.assert)(reason instanceof Error, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
+
+      if (!intentState.streamReader) {
+        return;
+      }
+
+      if (!force) {
+        if (intentState.renderTasks.length !== 0) {
+          return;
+        }
+
+        if (reason instanceof _display_utils.RenderingCancelledException) {
+          intentState.streamReaderCancelTimeout = setTimeout(function () {
+            _this9._abortOperatorList({
+              intentState: intentState,
+              reason: reason,
+              force: true
+            });
+
+            intentState.streamReaderCancelTimeout = null;
+          }, RENDERING_CANCELLED_TIMEOUT);
+          return;
+        }
+      }
+
+      intentState.streamReader.cancel(new _util.AbortException(reason && reason.message));
+      intentState.streamReader = null;
+
+      if (this._transport.destroyed) {
+        return;
+      }
+
+      Object.keys(this.intentStates).some(function (intent) {
+        if (_this9.intentStates[intent] === intentState) {
+          delete _this9.intentStates[intent];
+          return true;
+        }
+
+        return false;
+      });
+      this.cleanup();
+    }
+  }, {
+    key: "pageNumber",
+    get: function get() {
+      return this.pageIndex + 1;
+    }
+  }, {
+    key: "rotate",
+    get: function get() {
+      return this._pageInfo.rotate;
+    }
+  }, {
+    key: "ref",
+    get: function get() {
+      return this._pageInfo.ref;
+    }
+  }, {
+    key: "userUnit",
+    get: function get() {
+      return this._pageInfo.userUnit;
+    }
+  }, {
+    key: "view",
+    get: function get() {
+      return this._pageInfo.view;
+    }
+  }, {
+    key: "stats",
+    get: function get() {
+      return this._stats instanceof _display_utils.StatTimer ? this._stats : null;
+    }
+  }]);
+
   return PDFPageProxy;
 }();
 
-var LoopbackPort = function () {
+exports.PDFPageProxy = PDFPageProxy;
+
+var LoopbackPort =
+/*#__PURE__*/
+function () {
   function LoopbackPort() {
     var defer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
@@ -695,21 +1244,24 @@ var LoopbackPort = function () {
   }
 
   _createClass(LoopbackPort, [{
-    key: 'postMessage',
+    key: "postMessage",
     value: function postMessage(obj, transfers) {
-      var _this5 = this;
+      var _this10 = this;
 
       function cloneValue(value) {
-        if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object' || value === null) {
+        if (_typeof(value) !== 'object' || value === null) {
           return value;
         }
+
         if (cloned.has(value)) {
           return cloned.get(value);
         }
-        var result;
-        var buffer;
+
+        var buffer, result;
+
         if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
           var transferable = transfers && transfers.includes(buffer);
+
           if (value === buffer) {
             result = value;
           } else if (transferable) {
@@ -717,380 +1269,503 @@ var LoopbackPort = function () {
           } else {
             result = new value.constructor(value);
           }
+
           cloned.set(value, result);
           return result;
         }
+
         result = Array.isArray(value) ? [] : {};
         cloned.set(value, result);
+
         for (var i in value) {
-          var desc,
+          var desc = void 0,
               p = value;
+
           while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
             p = Object.getPrototypeOf(p);
           }
-          if (typeof desc.value === 'undefined' || typeof desc.value === 'function') {
+
+          if (typeof desc.value === 'undefined') {
+            continue;
+          }
+
+          if (typeof desc.value === 'function') {
+            if (value.hasOwnProperty && value.hasOwnProperty(i)) {
+              throw new Error("LoopbackPort.postMessage - cannot clone: ".concat(value[i]));
+            }
+
             continue;
           }
+
           result[i] = cloneValue(desc.value);
         }
+
         return result;
       }
+
       if (!this._defer) {
         this._listeners.forEach(function (listener) {
-          listener.call(this, { data: obj });
-        }, this);
+          listener.call(_this10, {
+            data: obj
+          });
+        });
+
         return;
       }
+
       var cloned = new WeakMap();
-      var e = { data: cloneValue(obj) };
+      var e = {
+        data: cloneValue(obj)
+      };
+
       this._deferred.then(function () {
-        _this5._listeners.forEach(function (listener) {
-          listener.call(this, e);
-        }, _this5);
+        _this10._listeners.forEach(function (listener) {
+          listener.call(_this10, e);
+        });
       });
     }
   }, {
-    key: 'addEventListener',
+    key: "addEventListener",
     value: function addEventListener(name, listener) {
       this._listeners.push(listener);
     }
   }, {
-    key: 'removeEventListener',
+    key: "removeEventListener",
     value: function removeEventListener(name, listener) {
       var i = this._listeners.indexOf(listener);
+
       this._listeners.splice(i, 1);
     }
   }, {
-    key: 'terminate',
+    key: "terminate",
     value: function terminate() {
-      this._listeners = [];
+      this._listeners.length = 0;
     }
   }]);
 
   return LoopbackPort;
 }();
 
+exports.LoopbackPort = LoopbackPort;
+
 var PDFWorker = function PDFWorkerClosure() {
+  var pdfWorkerPorts = new WeakMap();
   var nextFakeWorkerId = 0;
-  function getWorkerSrc() {
+  var fakeWorkerFilesLoadedCapability;
+
+  function _getWorkerSrc() {
     if (_worker_options.GlobalWorkerOptions.workerSrc) {
       return _worker_options.GlobalWorkerOptions.workerSrc;
     }
-    if (typeof workerSrc !== 'undefined') {
-      return workerSrc;
-    }
-    if (pdfjsFilePath) {
-      return pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, '.worker$1$2');
+
+    if (typeof fallbackWorkerSrc !== 'undefined') {
+      return fallbackWorkerSrc;
     }
+
     throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
   }
+
   function getMainThreadWorkerMessageHandler() {
-    if (typeof window === 'undefined') {
-      return null;
-    }
-    return window.pdfjsWorker && window.pdfjsWorker.WorkerMessageHandler;
+    try {
+      if (typeof window !== 'undefined') {
+        return window.pdfjsWorker && window.pdfjsWorker.WorkerMessageHandler;
+      }
+    } catch (ex) {}
+
+    return null;
   }
-  var fakeWorkerFilesLoadedCapability = void 0;
+
   function setupFakeWorkerGlobal() {
     if (fakeWorkerFilesLoadedCapability) {
       return fakeWorkerFilesLoadedCapability.promise;
     }
+
     fakeWorkerFilesLoadedCapability = (0, _util.createPromiseCapability)();
     var mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+
     if (mainWorkerMessageHandler) {
       fakeWorkerFilesLoadedCapability.resolve(mainWorkerMessageHandler);
       return fakeWorkerFilesLoadedCapability.promise;
     }
-    var loader = fakeWorkerFilesLoader || function (callback) {
-      _util.Util.loadScript(getWorkerSrc(), function () {
-        callback(window.pdfjsWorker.WorkerMessageHandler);
+
+    var loader = fakeWorkerFilesLoader || function () {
+      return (0, _display_utils.loadScript)(_getWorkerSrc()).then(function () {
+        return window.pdfjsWorker.WorkerMessageHandler;
       });
     };
-    loader(fakeWorkerFilesLoadedCapability.resolve);
+
+    loader().then(fakeWorkerFilesLoadedCapability.resolve, fakeWorkerFilesLoadedCapability.reject);
     return fakeWorkerFilesLoadedCapability.promise;
   }
+
   function createCDNWrapper(url) {
     var wrapper = 'importScripts(\'' + url + '\');';
     return URL.createObjectURL(new Blob([wrapper]));
   }
-  var pdfWorkerPorts = new WeakMap();
-  function PDFWorker() {
-    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref2$name = _ref2.name,
-        name = _ref2$name === undefined ? null : _ref2$name,
-        _ref2$port = _ref2.port,
-        port = _ref2$port === undefined ? null : _ref2$port,
-        _ref2$postMessageTran = _ref2.postMessageTransfers,
-        postMessageTransfers = _ref2$postMessageTran === undefined ? true : _ref2$postMessageTran,
-        _ref2$verbosity = _ref2.verbosity,
-        verbosity = _ref2$verbosity === undefined ? null : _ref2$verbosity;
-
-    if (port && pdfWorkerPorts.has(port)) {
-      throw new Error('Cannot use more than one PDFWorker per port');
-    }
-    this.name = name;
-    this.destroyed = false;
-    this.postMessageTransfers = postMessageTransfers !== false;
-    this.verbosity = (0, _util.isNum)(verbosity) ? verbosity : (0, _util.getVerbosityLevel)();
-    this._readyCapability = (0, _util.createPromiseCapability)();
-    this._port = null;
-    this._webWorker = null;
-    this._messageHandler = null;
-    if (port) {
-      pdfWorkerPorts.set(port, this);
-      this._initializeFromPort(port);
-      return;
-    }
-    this._initialize();
-  }
-  PDFWorker.prototype = {
-    get promise() {
-      return this._readyCapability.promise;
-    },
-    get port() {
-      return this._port;
-    },
-    get messageHandler() {
-      return this._messageHandler;
-    },
-    _initializeFromPort: function PDFWorker_initializeFromPort(port) {
-      this._port = port;
-      this._messageHandler = new _message_handler.MessageHandler('main', 'worker', port);
-      this._messageHandler.on('ready', function () {});
-      this._readyCapability.resolve();
-    },
-    _initialize: function PDFWorker_initialize() {
-      var _this6 = this;
 
-      if (typeof Worker !== 'undefined' && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
-        var workerSrc = getWorkerSrc();
-        try {
-          if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
-            workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
-          }
-          var worker = new Worker(workerSrc);
-          var messageHandler = new _message_handler.MessageHandler('main', 'worker', worker);
-          var terminateEarly = function terminateEarly() {
-            worker.removeEventListener('error', onWorkerError);
-            messageHandler.destroy();
-            worker.terminate();
-            if (_this6.destroyed) {
-              _this6._readyCapability.reject(new Error('Worker was destroyed'));
-            } else {
-              _this6._setupFakeWorker();
-            }
-          };
-          var onWorkerError = function onWorkerError() {
-            if (!_this6._webWorker) {
-              terminateEarly();
-            }
-          };
-          worker.addEventListener('error', onWorkerError);
-          messageHandler.on('test', function (data) {
-            worker.removeEventListener('error', onWorkerError);
-            if (_this6.destroyed) {
-              terminateEarly();
-              return;
-            }
-            var supportTypedArray = data && data.supportTypedArray;
-            if (supportTypedArray) {
-              _this6._messageHandler = messageHandler;
-              _this6._port = worker;
-              _this6._webWorker = worker;
-              if (!data.supportTransfers) {
-                _this6.postMessageTransfers = false;
-              }
-              _this6._readyCapability.resolve();
-              messageHandler.send('configure', { verbosity: _this6.verbosity });
-            } else {
-              _this6._setupFakeWorker();
-              messageHandler.destroy();
-              worker.terminate();
-            }
-          });
-          messageHandler.on('ready', function (data) {
-            worker.removeEventListener('error', onWorkerError);
-            if (_this6.destroyed) {
-              terminateEarly();
-              return;
-            }
-            try {
-              sendTest();
-            } catch (e) {
-              _this6._setupFakeWorker();
-            }
-          });
-          var sendTest = function sendTest() {
-            var testObj = new Uint8Array([_this6.postMessageTransfers ? 255 : 0]);
-            try {
-              messageHandler.send('test', testObj, [testObj.buffer]);
-            } catch (ex) {
-              (0, _util.info)('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();
-    },
-    _setupFakeWorker: function PDFWorker_setupFakeWorker() {
-      var _this7 = this;
+  var PDFWorker =
+  /*#__PURE__*/
+  function () {
+    function PDFWorker() {
+      var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref8$name = _ref8.name,
+          name = _ref8$name === void 0 ? null : _ref8$name,
+          _ref8$port = _ref8.port,
+          port = _ref8$port === void 0 ? null : _ref8$port,
+          _ref8$verbosity = _ref8.verbosity,
+          verbosity = _ref8$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref8$verbosity;
 
-      if (!isWorkerDisabled) {
-        (0, _util.warn)('Setting up fake worker.');
-        isWorkerDisabled = true;
-      }
-      setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
-        if (_this7.destroyed) {
-          _this7._readyCapability.reject(new Error('Worker was destroyed'));
-          return;
-        }
-        var isTypedArraysPresent = Uint8Array !== Float32Array;
-        var port = new LoopbackPort(isTypedArraysPresent);
-        _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;
-        _this7._readyCapability.resolve();
-      });
-    },
-    destroy: function PDFWorker_destroy() {
-      this.destroyed = true;
-      if (this._webWorker) {
-        this._webWorker.terminate();
-        this._webWorker = null;
+      _classCallCheck(this, PDFWorker);
+
+      if (port && pdfWorkerPorts.has(port)) {
+        throw new Error('Cannot use more than one PDFWorker per port');
       }
-      pdfWorkerPorts.delete(this._port);
+
+      this.name = name;
+      this.destroyed = false;
+      this.postMessageTransfers = true;
+      this.verbosity = verbosity;
+      this._readyCapability = (0, _util.createPromiseCapability)();
       this._port = null;
-      if (this._messageHandler) {
-        this._messageHandler.destroy();
-        this._messageHandler = null;
+      this._webWorker = null;
+      this._messageHandler = null;
+
+      if (port) {
+        pdfWorkerPorts.set(port, this);
+
+        this._initializeFromPort(port);
+
+        return;
       }
+
+      this._initialize();
     }
-  };
-  PDFWorker.fromPort = function (params) {
-    if (pdfWorkerPorts.has(params.port)) {
-      return pdfWorkerPorts.get(params.port);
-    }
-    return new PDFWorker(params);
-  };
-  PDFWorker.getWorkerSrc = function () {
-    return getWorkerSrc();
-  };
-  return PDFWorker;
-}();
-var WorkerTransport = function WorkerTransportClosure() {
-  function WorkerTransport(messageHandler, loadingTask, networkStream, params, CMapReaderFactory) {
-    this.messageHandler = messageHandler;
-    this.loadingTask = loadingTask;
-    this.commonObjs = new PDFObjects();
-    this.fontLoader = new _font_loader.FontLoader(loadingTask.docId);
-    this._params = params;
-    this.CMapReaderFactory = new CMapReaderFactory({
-      baseUrl: params.cMapUrl,
-      isCompressed: params.cMapPacked
-    });
-    this.destroyed = false;
-    this.destroyCapability = null;
-    this._passwordCapability = null;
-    this._networkStream = networkStream;
-    this._fullReader = null;
-    this._lastProgress = null;
-    this.pageCache = [];
-    this.pagePromises = [];
-    this.downloadInfoCapability = (0, _util.createPromiseCapability)();
-    this.setupMessageHandler();
-  }
-  WorkerTransport.prototype = {
-    destroy: function WorkerTransport_destroy() {
-      var _this8 = this;
 
-      if (this.destroyCapability) {
-        return this.destroyCapability.promise;
+    _createClass(PDFWorker, [{
+      key: "_initializeFromPort",
+      value: function _initializeFromPort(port) {
+        this._port = port;
+        this._messageHandler = new _message_handler.MessageHandler('main', 'worker', port);
+
+        this._messageHandler.on('ready', function () {});
+
+        this._readyCapability.resolve();
       }
-      this.destroyed = true;
+    }, {
+      key: "_initialize",
+      value: function _initialize() {
+        var _this11 = this;
+
+        if (typeof Worker !== 'undefined' && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
+          var workerSrc = _getWorkerSrc();
+
+          try {
+            if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
+              workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
+            }
+
+            var worker = new Worker(workerSrc);
+            var messageHandler = new _message_handler.MessageHandler('main', 'worker', worker);
+
+            var terminateEarly = function terminateEarly() {
+              worker.removeEventListener('error', onWorkerError);
+              messageHandler.destroy();
+              worker.terminate();
+
+              if (_this11.destroyed) {
+                _this11._readyCapability.reject(new Error('Worker was destroyed'));
+              } else {
+                _this11._setupFakeWorker();
+              }
+            };
+
+            var onWorkerError = function onWorkerError() {
+              if (!_this11._webWorker) {
+                terminateEarly();
+              }
+            };
+
+            worker.addEventListener('error', onWorkerError);
+            messageHandler.on('test', function (data) {
+              worker.removeEventListener('error', onWorkerError);
+
+              if (_this11.destroyed) {
+                terminateEarly();
+                return;
+              }
+
+              if (data) {
+                _this11._messageHandler = messageHandler;
+                _this11._port = worker;
+                _this11._webWorker = worker;
+
+                if (!data.supportTransfers) {
+                  _this11.postMessageTransfers = false;
+                }
+
+                _this11._readyCapability.resolve();
+
+                messageHandler.send('configure', {
+                  verbosity: _this11.verbosity
+                });
+              } else {
+                _this11._setupFakeWorker();
+
+                messageHandler.destroy();
+                worker.terminate();
+              }
+            });
+            messageHandler.on('ready', function (data) {
+              worker.removeEventListener('error', onWorkerError);
+
+              if (_this11.destroyed) {
+                terminateEarly();
+                return;
+              }
+
+              try {
+                sendTest();
+              } catch (e) {
+                _this11._setupFakeWorker();
+              }
+            });
+
+            var sendTest = function sendTest() {
+              var testObj = new Uint8Array([_this11.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();
+      }
+    }, {
+      key: "_setupFakeWorker",
+      value: function _setupFakeWorker() {
+        var _this12 = this;
+
+        if (!isWorkerDisabled) {
+          (0, _util.warn)('Setting up fake worker.');
+          isWorkerDisabled = true;
+        }
+
+        setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
+          if (_this12.destroyed) {
+            _this12._readyCapability.reject(new Error('Worker was destroyed'));
+
+            return;
+          }
+
+          var port = new LoopbackPort();
+          _this12._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);
+          _this12._messageHandler = messageHandler;
+
+          _this12._readyCapability.resolve();
+        })["catch"](function (reason) {
+          _this12._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\".")));
+        });
+      }
+    }, {
+      key: "destroy",
+      value: function destroy() {
+        this.destroyed = true;
+
+        if (this._webWorker) {
+          this._webWorker.terminate();
+
+          this._webWorker = null;
+        }
+
+        pdfWorkerPorts["delete"](this._port);
+        this._port = null;
+
+        if (this._messageHandler) {
+          this._messageHandler.destroy();
+
+          this._messageHandler = null;
+        }
+      }
+    }, {
+      key: "promise",
+      get: function get() {
+        return this._readyCapability.promise;
+      }
+    }, {
+      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);
+      }
+    }, {
+      key: "getWorkerSrc",
+      value: function getWorkerSrc() {
+        return _getWorkerSrc();
+      }
+    }]);
+
+    return PDFWorker;
+  }();
+
+  return PDFWorker;
+}();
+
+exports.PDFWorker = PDFWorker;
+
+var WorkerTransport =
+/*#__PURE__*/
+function () {
+  function WorkerTransport(messageHandler, loadingTask, networkStream, params) {
+    _classCallCheck(this, WorkerTransport);
+
+    this.messageHandler = messageHandler;
+    this.loadingTask = loadingTask;
+    this.commonObjs = new PDFObjects();
+    this.fontLoader = new _font_loader.FontLoader({
+      docId: loadingTask.docId,
+      onUnsupportedFeature: this._onUnsupportedFeature.bind(this)
+    });
+    this._params = params;
+    this.CMapReaderFactory = new params.CMapReaderFactory({
+      baseUrl: params.cMapUrl,
+      isCompressed: params.cMapPacked
+    });
+    this.destroyed = false;
+    this.destroyCapability = null;
+    this._passwordCapability = null;
+    this._networkStream = networkStream;
+    this._fullReader = null;
+    this._lastProgress = null;
+    this.pageCache = [];
+    this.pagePromises = [];
+    this.downloadInfoCapability = (0, _util.createPromiseCapability)();
+    this.setupMessageHandler();
+  }
+
+  _createClass(WorkerTransport, [{
+    key: "destroy",
+    value: function destroy() {
+      var _this13 = this;
+
+      if (this.destroyCapability) {
+        return this.destroyCapability.promise;
+      }
+
+      this.destroyed = true;
       this.destroyCapability = (0, _util.createPromiseCapability)();
+
       if (this._passwordCapability) {
         this._passwordCapability.reject(new Error('Worker was destroyed during onPassword callback'));
       }
+
       var waitOn = [];
       this.pageCache.forEach(function (page) {
         if (page) {
           waitOn.push(page._destroy());
         }
       });
-      this.pageCache = [];
-      this.pagePromises = [];
+      this.pageCache.length = 0;
+      this.pagePromises.length = 0;
       var terminated = this.messageHandler.sendWithPromise('Terminate', null);
       waitOn.push(terminated);
       Promise.all(waitOn).then(function () {
-        _this8.fontLoader.clear();
-        if (_this8._networkStream) {
-          _this8._networkStream.cancelAllRequests();
+        _this13.fontLoader.clear();
+
+        if (_this13._networkStream) {
+          _this13._networkStream.cancelAllRequests(new _util.AbortException('Worker was terminated.'));
         }
-        if (_this8.messageHandler) {
-          _this8.messageHandler.destroy();
-          _this8.messageHandler = null;
+
+        if (_this13.messageHandler) {
+          _this13.messageHandler.destroy();
+
+          _this13.messageHandler = null;
         }
-        _this8.destroyCapability.resolve();
+
+        _this13.destroyCapability.resolve();
       }, this.destroyCapability.reject);
       return this.destroyCapability.promise;
-    },
-    setupMessageHandler: function WorkerTransport_setupMessageHandler() {
-      var messageHandler = this.messageHandler;
-      var loadingTask = this.loadingTask;
+    }
+  }, {
+    key: "setupMessageHandler",
+    value: function setupMessageHandler() {
+      var _this14 = this;
+
+      var messageHandler = this.messageHandler,
+          loadingTask = this.loadingTask;
       messageHandler.on('GetReader', function (data, sink) {
-        var _this9 = this;
+        (0, _util.assert)(_this14._networkStream);
+        _this14._fullReader = _this14._networkStream.getFullReader();
 
-        (0, _util.assert)(this._networkStream);
-        this._fullReader = this._networkStream.getFullReader();
-        this._fullReader.onProgress = function (evt) {
-          _this9._lastProgress = {
+        _this14._fullReader.onProgress = function (evt) {
+          _this14._lastProgress = {
             loaded: evt.loaded,
             total: evt.total
           };
         };
+
         sink.onPull = function () {
-          _this9._fullReader.read().then(function (_ref3) {
-            var value = _ref3.value,
-                done = _ref3.done;
+          _this14._fullReader.read().then(function (_ref9) {
+            var value = _ref9.value,
+                done = _ref9.done;
 
             if (done) {
               sink.close();
               return;
             }
+
             (0, _util.assert)((0, _util.isArrayBuffer)(value));
             sink.enqueue(new Uint8Array(value), 1, [value]);
-          }).catch(function (reason) {
+          })["catch"](function (reason) {
             sink.error(reason);
           });
         };
+
         sink.onCancel = function (reason) {
-          _this9._fullReader.cancel(reason);
+          _this14._fullReader.cancel(reason);
         };
-      }, this);
+      });
       messageHandler.on('ReaderHeadersReady', function (data) {
-        var _this10 = this;
-
         var headersCapability = (0, _util.createPromiseCapability)();
-        var fullReader = this._fullReader;
+        var fullReader = _this14._fullReader;
         fullReader.headersReady.then(function () {
           if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
-            if (_this10._lastProgress) {
-              var _loadingTask = _this10.loadingTask;
-              if (_loadingTask.onProgress) {
-                _loadingTask.onProgress(_this10._lastProgress);
-              }
+            if (_this14._lastProgress && loadingTask.onProgress) {
+              loadingTask.onProgress(_this14._lastProgress);
             }
+
             fullReader.onProgress = function (evt) {
-              var loadingTask = _this10.loadingTask;
               if (loadingTask.onProgress) {
                 loadingTask.onProgress({
                   loaded: evt.loaded,
@@ -1099,6 +1774,7 @@ var WorkerTransport = function WorkerTransportClosure() {
               }
             };
           }
+
           headersCapability.resolve({
             isStreamingSupported: fullReader.isStreamingSupported,
             isRangeSupported: fullReader.isRangeSupported,
@@ -1106,574 +1782,814 @@ var WorkerTransport = function WorkerTransportClosure() {
           });
         }, headersCapability.reject);
         return headersCapability.promise;
-      }, this);
+      });
       messageHandler.on('GetRangeReader', function (data, sink) {
-        (0, _util.assert)(this._networkStream);
-        var _rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
+        (0, _util.assert)(_this14._networkStream);
+
+        var rangeReader = _this14._networkStream.getRangeReader(data.begin, data.end);
+
+        if (!rangeReader) {
+          sink.close();
+          return;
+        }
+
         sink.onPull = function () {
-          _rangeReader.read().then(function (_ref4) {
-            var value = _ref4.value,
-                done = _ref4.done;
+          rangeReader.read().then(function (_ref10) {
+            var value = _ref10.value,
+                done = _ref10.done;
 
             if (done) {
               sink.close();
               return;
             }
+
             (0, _util.assert)((0, _util.isArrayBuffer)(value));
             sink.enqueue(new Uint8Array(value), 1, [value]);
-          }).catch(function (reason) {
+          })["catch"](function (reason) {
             sink.error(reason);
           });
         };
+
         sink.onCancel = function (reason) {
-          _rangeReader.cancel(reason);
+          rangeReader.cancel(reason);
         };
-      }, this);
-      messageHandler.on('GetDoc', function transportDoc(_ref5) {
-        var pdfInfo = _ref5.pdfInfo;
-
-        this.numPages = pdfInfo.numPages;
-        var loadingTask = this.loadingTask;
-        var pdfDocument = new PDFDocumentProxy(pdfInfo, this, loadingTask);
-        this.pdfDocument = pdfDocument;
-        loadingTask._capability.resolve(pdfDocument);
-      }, this);
-      messageHandler.on('PasswordRequest', function transportPasswordRequest(exception) {
-        var _this11 = this;
+      });
+      messageHandler.on('GetDoc', function (_ref11) {
+        var pdfInfo = _ref11.pdfInfo;
+        _this14._numPages = pdfInfo.numPages;
+
+        loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, _this14));
+      });
+      messageHandler.on('PasswordRequest', function (exception) {
+        _this14._passwordCapability = (0, _util.createPromiseCapability)();
 
-        this._passwordCapability = (0, _util.createPromiseCapability)();
         if (loadingTask.onPassword) {
           var updatePassword = function updatePassword(password) {
-            _this11._passwordCapability.resolve({ password: password });
+            _this14._passwordCapability.resolve({
+              password: password
+            });
           };
+
           try {
             loadingTask.onPassword(updatePassword, exception.code);
           } catch (ex) {
-            this._passwordCapability.reject(ex);
+            _this14._passwordCapability.reject(ex);
           }
         } else {
-          this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
+          _this14._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
         }
-        return this._passwordCapability.promise;
-      }, this);
-      messageHandler.on('PasswordException', function transportPasswordException(exception) {
+
+        return _this14._passwordCapability.promise;
+      });
+      messageHandler.on('PasswordException', function (exception) {
         loadingTask._capability.reject(new _util.PasswordException(exception.message, exception.code));
-      }, this);
-      messageHandler.on('InvalidPDF', function transportInvalidPDF(exception) {
-        this.loadingTask._capability.reject(new _util.InvalidPDFException(exception.message));
-      }, this);
-      messageHandler.on('MissingPDF', function transportMissingPDF(exception) {
-        this.loadingTask._capability.reject(new _util.MissingPDFException(exception.message));
-      }, this);
-      messageHandler.on('UnexpectedResponse', function transportUnexpectedResponse(exception) {
-        this.loadingTask._capability.reject(new _util.UnexpectedResponseException(exception.message, exception.status));
-      }, this);
-      messageHandler.on('UnknownError', function transportUnknownError(exception) {
-        this.loadingTask._capability.reject(new _util.UnknownErrorException(exception.message, exception.details));
-      }, this);
-      messageHandler.on('DataLoaded', function transportPage(data) {
-        this.downloadInfoCapability.resolve(data);
-      }, this);
-      messageHandler.on('PDFManagerReady', function transportPage(data) {}, this);
-      messageHandler.on('StartRenderPage', function transportRender(data) {
-        if (this.destroyed) {
-          return;
+      });
+      messageHandler.on('InvalidPDF', function (exception) {
+        loadingTask._capability.reject(new _util.InvalidPDFException(exception.message));
+      });
+      messageHandler.on('MissingPDF', function (exception) {
+        loadingTask._capability.reject(new _util.MissingPDFException(exception.message));
+      });
+      messageHandler.on('UnexpectedResponse', function (exception) {
+        loadingTask._capability.reject(new _util.UnexpectedResponseException(exception.message, exception.status));
+      });
+      messageHandler.on('UnknownError', function (exception) {
+        loadingTask._capability.reject(new _util.UnknownErrorException(exception.message, exception.details));
+      });
+      messageHandler.on('DataLoaded', function (data) {
+        if (loadingTask.onProgress) {
+          loadingTask.onProgress({
+            loaded: data.length,
+            total: data.length
+          });
         }
-        var page = this.pageCache[data.pageIndex];
-        page._stats.timeEnd('Page Request');
-        page._startRenderPage(data.transparency, data.intent);
-      }, this);
-      messageHandler.on('RenderPageChunk', function transportRender(data) {
-        if (this.destroyed) {
+
+        _this14.downloadInfoCapability.resolve(data);
+      });
+      messageHandler.on('StartRenderPage', function (data) {
+        if (_this14.destroyed) {
           return;
         }
-        var page = this.pageCache[data.pageIndex];
-        page._renderPageChunk(data.operatorList, data.intent);
-      }, this);
-      messageHandler.on('commonobj', function transportObj(data) {
-        var _this12 = this;
 
-        if (this.destroyed) {
+        var page = _this14.pageCache[data.pageIndex];
+
+        page._startRenderPage(data.transparency, data.intent);
+      });
+      messageHandler.on('commonobj', function (data) {
+        if (_this14.destroyed) {
           return;
         }
-        var id = data[0];
-        var type = data[1];
-        if (this.commonObjs.hasData(id)) {
+
+        var _data = _slicedToArray(data, 3),
+            id = _data[0],
+            type = _data[1],
+            exportedData = _data[2];
+
+        if (_this14.commonObjs.has(id)) {
           return;
         }
+
         switch (type) {
           case 'Font':
-            var exportedData = data[2];
-            var params = this._params;
+            var params = _this14._params;
+
             if ('error' in exportedData) {
               var exportedError = exportedData.error;
-              (0, _util.warn)('Error during font loading: ' + exportedError);
-              this.commonObjs.resolve(id, exportedError);
+              (0, _util.warn)("Error during font loading: ".concat(exportedError));
+
+              _this14.commonObjs.resolve(id, exportedError);
+
               break;
             }
+
             var fontRegistry = null;
-            if (params.pdfBug && _global_scope2.default.FontInspector && _global_scope2.default.FontInspector.enabled) {
+
+            if (params.pdfBug && _global_scope["default"].FontInspector && _global_scope["default"].FontInspector.enabled) {
               fontRegistry = {
                 registerFont: function registerFont(font, url) {
-                  _global_scope2.default['FontInspector'].fontAdded(font, url);
+                  _global_scope["default"]['FontInspector'].fontAdded(font, url);
                 }
               };
             }
+
             var font = new _font_loader.FontFaceObject(exportedData, {
               isEvalSupported: params.isEvalSupported,
               disableFontFace: params.disableFontFace,
+              ignoreErrors: params.ignoreErrors,
+              onUnsupportedFeature: _this14._onUnsupportedFeature.bind(_this14),
               fontRegistry: fontRegistry
             });
-            var fontReady = function fontReady(fontObjs) {
-              _this12.commonObjs.resolve(id, font);
-            };
-            this.fontLoader.bind([font], fontReady);
+
+            _this14.fontLoader.bind(font).then(function () {
+              _this14.commonObjs.resolve(id, font);
+            }, function (reason) {
+              messageHandler.sendWithPromise('FontFallback', {
+                id: id
+              })["finally"](function () {
+                _this14.commonObjs.resolve(id, font);
+              });
+            });
+
             break;
+
           case 'FontPath':
-            this.commonObjs.resolve(id, data[2]);
+          case 'FontType3Res':
+            _this14.commonObjs.resolve(id, exportedData);
+
             break;
+
           default:
-            throw new Error('Got unknown common object type ' + type);
+            throw new Error("Got unknown common object type ".concat(type));
         }
-      }, this);
-      messageHandler.on('obj', function transportObj(data) {
-        if (this.destroyed) {
-          return;
+      });
+      messageHandler.on('obj', function (data) {
+        if (_this14.destroyed) {
+          return undefined;
         }
-        var id = data[0];
-        var pageIndex = data[1];
-        var type = data[2];
-        var pageProxy = this.pageCache[pageIndex];
-        var imageData;
-        if (pageProxy.objs.hasData(id)) {
-          return;
+
+        var _data2 = _slicedToArray(data, 4),
+            id = _data2[0],
+            pageIndex = _data2[1],
+            type = _data2[2],
+            imageData = _data2[3];
+
+        var pageProxy = _this14.pageCache[pageIndex];
+
+        if (pageProxy.objs.has(id)) {
+          return undefined;
         }
+
         switch (type) {
           case 'JpegStream':
-            imageData = data[3];
             return new Promise(function (resolve, reject) {
               var img = new Image();
+
               img.onload = function () {
                 resolve(img);
               };
+
               img.onerror = function () {
                 reject(new Error('Error during JPEG image loading'));
+                (0, _display_utils.releaseImageResources)(img);
               };
+
               img.src = imageData;
             }).then(function (img) {
               pageProxy.objs.resolve(id, img);
             });
+
           case 'Image':
-            imageData = data[3];
             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;
             }
+
             break;
+
           default:
-            throw new Error('Got unknown object type ' + type);
+            throw new Error("Got unknown object type ".concat(type));
         }
-      }, this);
-      messageHandler.on('DocProgress', function transportDocProgress(data) {
-        if (this.destroyed) {
+
+        return undefined;
+      });
+      messageHandler.on('DocProgress', function (data) {
+        if (_this14.destroyed) {
           return;
         }
-        var loadingTask = this.loadingTask;
+
         if (loadingTask.onProgress) {
           loadingTask.onProgress({
             loaded: data.loaded,
             total: data.total
           });
         }
-      }, this);
-      messageHandler.on('PageError', function transportError(data) {
-        if (this.destroyed) {
-          return;
-        }
-        var page = this.pageCache[data.pageNum - 1];
-        var intentState = page.intentStates[data.intent];
-        if (intentState.displayReadyCapability) {
-          intentState.displayReadyCapability.reject(data.error);
-        } else {
-          throw new Error(data.error);
-        }
-        if (intentState.operatorList) {
-          intentState.operatorList.lastChunk = true;
-          for (var i = 0; i < intentState.renderTasks.length; i++) {
-            intentState.renderTasks[i].operatorListChanged();
-          }
-        }
-      }, this);
-      messageHandler.on('UnsupportedFeature', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-        var loadingTask = this.loadingTask;
-        if (loadingTask.onUnsupportedFeature) {
-          loadingTask.onUnsupportedFeature(data.featureId);
-        }
-      }, this);
+      });
+      messageHandler.on('UnsupportedFeature', this._onUnsupportedFeature.bind(this));
       messageHandler.on('JpegDecode', function (data) {
-        if (this.destroyed) {
+        if (_this14.destroyed) {
           return Promise.reject(new Error('Worker was destroyed'));
         }
+
         if (typeof document === 'undefined') {
           return Promise.reject(new Error('"document" is not defined.'));
         }
-        var imageUrl = data[0];
-        var components = data[1];
+
+        var _data3 = _slicedToArray(data, 2),
+            imageUrl = _data3[0],
+            components = _data3[1];
+
         if (components !== 3 && components !== 1) {
           return Promise.reject(new Error('Only 3 components or 1 component can be returned'));
         }
+
         return new Promise(function (resolve, reject) {
           var img = new Image();
+
           img.onload = function () {
-            var width = img.width;
-            var height = img.height;
+            var width = img.width,
+                height = img.height;
             var size = width * height;
             var rgbaLength = size * 4;
-            var buf = new Uint8Array(size * components);
+            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;
-            var i, j;
+
             if (components === 3) {
-              for (i = 0, j = 0; i < rgbaLength; i += 4, j += 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 (i = 0, j = 0; i < rgbaLength; i += 4, j++) {
-                buf[j] = data[i];
+              for (var _i2 = 0, _j = 0; _i2 < rgbaLength; _i2 += 4, _j++) {
+                buf[_j] = data[_i2];
               }
             }
+
             resolve({
               data: buf,
               width: width,
               height: height
             });
+            (0, _display_utils.releaseImageResources)(img);
+            tmpCanvas.width = 0;
+            tmpCanvas.height = 0;
+            tmpCanvas = null;
+            tmpCtx = null;
           };
+
           img.onerror = function () {
             reject(new Error('JpegDecode failed to load image'));
+            (0, _display_utils.releaseImageResources)(img);
           };
+
           img.src = imageUrl;
         });
-      }, this);
-      messageHandler.on('FetchBuiltInCMap', function (data) {
-        if (this.destroyed) {
-          return Promise.reject(new Error('Worker was destroyed'));
+      });
+      messageHandler.on('FetchBuiltInCMap', function (data, sink) {
+        if (_this14.destroyed) {
+          sink.error(new Error('Worker was destroyed'));
+          return;
         }
-        return this.CMapReaderFactory.fetch({ name: data.name });
-      }, this);
-    },
-    getData: function WorkerTransport_getData() {
+
+        var fetched = false;
+
+        sink.onPull = function () {
+          if (fetched) {
+            sink.close();
+            return;
+          }
+
+          fetched = true;
+
+          _this14.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
+            sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
+          })["catch"](function (reason) {
+            sink.error(reason);
+          });
+        };
+      });
+    }
+  }, {
+    key: "_onUnsupportedFeature",
+    value: function _onUnsupportedFeature(_ref12) {
+      var featureId = _ref12.featureId;
+
+      if (this.destroyed) {
+        return;
+      }
+
+      if (this.loadingTask.onUnsupportedFeature) {
+        this.loadingTask.onUnsupportedFeature(featureId);
+      }
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
       return this.messageHandler.sendWithPromise('GetData', null);
-    },
-    getPage: function getPage(pageNumber) {
-      var _this13 = this;
+    }
+  }, {
+    key: "getPage",
+    value: function getPage(pageNumber) {
+      var _this15 = this;
 
-      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this.numPages) {
+      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
         return Promise.reject(new Error('Invalid page request'));
       }
+
       var pageIndex = pageNumber - 1;
+
       if (pageIndex in this.pagePromises) {
         return this.pagePromises[pageIndex];
       }
-      var promise = this.messageHandler.sendWithPromise('GetPage', { pageIndex: pageIndex }).then(function (pageInfo) {
-        if (_this13.destroyed) {
+
+      var promise = this.messageHandler.sendWithPromise('GetPage', {
+        pageIndex: pageIndex
+      }).then(function (pageInfo) {
+        if (_this15.destroyed) {
           throw new Error('Transport destroyed');
         }
-        var page = new PDFPageProxy(pageIndex, pageInfo, _this13, _this13._params.pdfBug);
-        _this13.pageCache[pageIndex] = page;
+
+        var page = new PDFPageProxy(pageIndex, pageInfo, _this15, _this15._params.pdfBug);
+        _this15.pageCache[pageIndex] = page;
         return page;
       });
       this.pagePromises[pageIndex] = promise;
       return promise;
-    },
-
-    getPageIndex: function WorkerTransport_getPageIndexByRef(ref) {
-      return this.messageHandler.sendWithPromise('GetPageIndex', { ref: ref }).catch(function (reason) {
+    }
+  }, {
+    key: "getPageIndex",
+    value: function getPageIndex(ref) {
+      return this.messageHandler.sendWithPromise('GetPageIndex', {
+        ref: ref
+      })["catch"](function (reason) {
         return Promise.reject(new Error(reason));
       });
-    },
-    getAnnotations: function WorkerTransport_getAnnotations(pageIndex, intent) {
+    }
+  }, {
+    key: "getAnnotations",
+    value: function getAnnotations(pageIndex, intent) {
       return this.messageHandler.sendWithPromise('GetAnnotations', {
         pageIndex: pageIndex,
         intent: intent
       });
-    },
-    getDestinations: function WorkerTransport_getDestinations() {
+    }
+  }, {
+    key: "getDestinations",
+    value: function getDestinations() {
       return this.messageHandler.sendWithPromise('GetDestinations', null);
-    },
-    getDestination: function WorkerTransport_getDestination(id) {
-      return this.messageHandler.sendWithPromise('GetDestination', { id: id });
-    },
-    getPageLabels: function WorkerTransport_getPageLabels() {
+    }
+  }, {
+    key: "getDestination",
+    value: function getDestination(id) {
+      if (typeof id !== 'string') {
+        return Promise.reject(new Error('Invalid destination request.'));
+      }
+
+      return this.messageHandler.sendWithPromise('GetDestination', {
+        id: id
+      });
+    }
+  }, {
+    key: "getPageLabels",
+    value: function getPageLabels() {
       return this.messageHandler.sendWithPromise('GetPageLabels', null);
-    },
-    getPageMode: function getPageMode() {
+    }
+  }, {
+    key: "getPageLayout",
+    value: function getPageLayout() {
+      return this.messageHandler.sendWithPromise('GetPageLayout', null);
+    }
+  }, {
+    key: "getPageMode",
+    value: function getPageMode() {
       return this.messageHandler.sendWithPromise('GetPageMode', null);
-    },
-
-    getAttachments: function WorkerTransport_getAttachments() {
+    }
+  }, {
+    key: "getViewerPreferences",
+    value: function getViewerPreferences() {
+      return this.messageHandler.sendWithPromise('GetViewerPreferences', null);
+    }
+  }, {
+    key: "getOpenActionDestination",
+    value: function getOpenActionDestination() {
+      return this.messageHandler.sendWithPromise('GetOpenActionDestination', null);
+    }
+  }, {
+    key: "getAttachments",
+    value: function getAttachments() {
       return this.messageHandler.sendWithPromise('GetAttachments', null);
-    },
-    getJavaScript: function WorkerTransport_getJavaScript() {
+    }
+  }, {
+    key: "getJavaScript",
+    value: function getJavaScript() {
       return this.messageHandler.sendWithPromise('GetJavaScript', null);
-    },
-    getOutline: function WorkerTransport_getOutline() {
+    }
+  }, {
+    key: "getOutline",
+    value: function getOutline() {
       return this.messageHandler.sendWithPromise('GetOutline', null);
-    },
-    getMetadata: function WorkerTransport_getMetadata() {
-      var _this14 = this;
+    }
+  }, {
+    key: "getPermissions",
+    value: function getPermissions() {
+      return this.messageHandler.sendWithPromise('GetPermissions', null);
+    }
+  }, {
+    key: "getMetadata",
+    value: function getMetadata() {
+      var _this16 = 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
+          contentDispositionFilename: _this16._fullReader ? _this16._fullReader.filename : null
         };
       });
-    },
-    getStats: function WorkerTransport_getStats() {
+    }
+  }, {
+    key: "getStats",
+    value: function getStats() {
       return this.messageHandler.sendWithPromise('GetStats', null);
-    },
-    startCleanup: function WorkerTransport_startCleanup() {
-      var _this15 = this;
+    }
+  }, {
+    key: "startCleanup",
+    value: function startCleanup() {
+      var _this17 = this;
 
       this.messageHandler.sendWithPromise('Cleanup', null).then(function () {
-        for (var i = 0, ii = _this15.pageCache.length; i < ii; i++) {
-          var page = _this15.pageCache[i];
+        for (var i = 0, ii = _this17.pageCache.length; i < ii; i++) {
+          var page = _this17.pageCache[i];
+
           if (page) {
             page.cleanup();
           }
         }
-        _this15.commonObjs.clear();
-        _this15.fontLoader.clear();
+
+        _this17.commonObjs.clear();
+
+        _this17.fontLoader.clear();
       });
-    },
-    get loadingParams() {
+    }
+  }, {
+    key: "loadingParams",
+    get: function get() {
       var params = this._params;
       return (0, _util.shadow)(this, 'loadingParams', {
-        disableRange: params.disableRange,
-        disableStream: params.disableStream,
         disableAutoFetch: params.disableAutoFetch,
         disableCreateObjectURL: params.disableCreateObjectURL,
         disableFontFace: params.disableFontFace,
         nativeImageDecoderSupport: params.nativeImageDecoderSupport
       });
     }
-  };
+  }]);
+
   return WorkerTransport;
 }();
-var PDFObjects = function PDFObjectsClosure() {
+
+var PDFObjects =
+/*#__PURE__*/
+function () {
   function PDFObjects() {
-    this.objs = Object.create(null);
+    _classCallCheck(this, PDFObjects);
+
+    this._objs = Object.create(null);
   }
-  PDFObjects.prototype = {
-    ensureObj: function PDFObjects_ensureObj(objId) {
-      if (this.objs[objId]) {
-        return this.objs[objId];
+
+  _createClass(PDFObjects, [{
+    key: "_ensureObj",
+    value: function _ensureObj(objId) {
+      if (this._objs[objId]) {
+        return this._objs[objId];
       }
-      var obj = {
+
+      return this._objs[objId] = {
         capability: (0, _util.createPromiseCapability)(),
         data: null,
         resolved: false
       };
-      this.objs[objId] = obj;
-      return obj;
-    },
-    get: function PDFObjects_get(objId, callback) {
+    }
+  }, {
+    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);
+        this._ensureObj(objId).capability.promise.then(callback);
+
         return null;
       }
-      var obj = this.objs[objId];
+
+      var obj = this._objs[objId];
+
       if (!obj || !obj.resolved) {
-        throw new Error('Requesting object that isn\'t resolved yet ' + objId);
+        throw new Error("Requesting object that isn't resolved yet ".concat(objId, "."));
       }
+
       return obj.data;
-    },
-    resolve: function PDFObjects_resolve(objId, data) {
-      var obj = this.ensureObj(objId);
+    }
+  }, {
+    key: "has",
+    value: function has(objId) {
+      var obj = this._objs[objId];
+      return obj ? obj.resolved : false;
+    }
+  }, {
+    key: "resolve",
+    value: function resolve(objId, data) {
+      var obj = this._ensureObj(objId);
+
       obj.resolved = true;
       obj.data = data;
       obj.capability.resolve(data);
-    },
-    isResolved: function PDFObjects_isResolved(objId) {
-      var objs = this.objs;
-      if (!objs[objId]) {
-        return false;
-      }
-      return objs[objId].resolved;
-    },
-    hasData: function PDFObjects_hasData(objId) {
-      return this.isResolved(objId);
-    },
-    getData: function PDFObjects_getData(objId) {
-      var objs = this.objs;
-      if (!objs[objId] || !objs[objId].resolved) {
-        return null;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      for (var objId in this._objs) {
+        var data = this._objs[objId].data;
+
+        if (typeof Image !== 'undefined' && data instanceof Image) {
+          (0, _display_utils.releaseImageResources)(data);
+        }
       }
-      return objs[objId].data;
-    },
-    clear: function PDFObjects_clear() {
-      this.objs = Object.create(null);
+
+      this._objs = Object.create(null);
     }
-  };
+  }]);
+
   return PDFObjects;
 }();
-var RenderTask = function RenderTaskClosure() {
+
+var RenderTask =
+/*#__PURE__*/
+function () {
   function RenderTask(internalRenderTask) {
+    _classCallCheck(this, RenderTask);
+
     this._internalRenderTask = internalRenderTask;
     this.onContinue = null;
   }
-  RenderTask.prototype = {
-    get promise() {
-      return this._internalRenderTask.capability.promise;
-    },
-    cancel: function RenderTask_cancel() {
+
+  _createClass(RenderTask, [{
+    key: "cancel",
+    value: function cancel() {
       this._internalRenderTask.cancel();
-    },
-    then: function RenderTask_then(onFulfilled, onRejected) {
+    }
+  }, {
+    key: "then",
+    value: function then(onFulfilled, onRejected) {
+      (0, _display_utils.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;
+    }
+  }]);
+
   return RenderTask;
 }();
+
 var InternalRenderTask = function InternalRenderTaskClosure() {
-  var canvasInRendering = new WeakMap();
-  function InternalRenderTask(callback, params, objs, commonObjs, operatorList, pageNumber, canvasFactory, webGLContext) {
-    var pdfBug = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : false;
-
-    this.callback = callback;
-    this.params = params;
-    this.objs = objs;
-    this.commonObjs = commonObjs;
-    this.operatorListIdx = null;
-    this.operatorList = operatorList;
-    this.pageNumber = pageNumber;
-    this.canvasFactory = canvasFactory;
-    this.webGLContext = webGLContext;
-    this._pdfBug = pdfBug;
-    this.running = false;
-    this.graphicsReadyCallback = null;
-    this.graphicsReady = false;
-    this.useRequestAnimationFrame = false;
-    this.cancelled = false;
-    this.capability = (0, _util.createPromiseCapability)();
-    this.task = new RenderTask(this);
-    this._continueBound = this._continue.bind(this);
-    this._scheduleNextBound = this._scheduleNext.bind(this);
-    this._nextBound = this._next.bind(this);
-    this._canvas = params.canvasContext.canvas;
-  }
-  InternalRenderTask.prototype = {
-    initializeGraphics: function InternalRenderTask_initializeGraphics(transparency) {
-      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.set(this._canvas, this);
-      }
-      if (this.cancelled) {
-        return;
-      }
-      if (this._pdfBug && _global_scope2.default.StepperManager && _global_scope2.default.StepperManager.enabled) {
-        this.stepper = _global_scope2.default.StepperManager.create(this.pageNumber - 1);
-        this.stepper.init(this.operatorList);
-        this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
-      }
-      var params = this.params;
-      this.gfx = new _canvas.CanvasGraphics(params.canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, params.imageLayer);
-      this.gfx.beginDrawing({
-        transform: params.transform,
-        viewport: params.viewport,
-        transparency: transparency,
-        background: params.background
-      });
-      this.operatorListIdx = 0;
-      this.graphicsReady = true;
-      if (this.graphicsReadyCallback) {
-        this.graphicsReadyCallback();
-      }
-    },
-    cancel: function InternalRenderTask_cancel() {
+  var canvasInRendering = new WeakSet();
+
+  var InternalRenderTask =
+  /*#__PURE__*/
+  function () {
+    function InternalRenderTask(_ref13) {
+      var callback = _ref13.callback,
+          params = _ref13.params,
+          objs = _ref13.objs,
+          commonObjs = _ref13.commonObjs,
+          operatorList = _ref13.operatorList,
+          pageNumber = _ref13.pageNumber,
+          canvasFactory = _ref13.canvasFactory,
+          webGLContext = _ref13.webGLContext,
+          _ref13$useRequestAnim = _ref13.useRequestAnimationFrame,
+          useRequestAnimationFrame = _ref13$useRequestAnim === void 0 ? false : _ref13$useRequestAnim,
+          _ref13$pdfBug = _ref13.pdfBug,
+          pdfBug = _ref13$pdfBug === void 0 ? false : _ref13$pdfBug;
+
+      _classCallCheck(this, InternalRenderTask);
+
+      this.callback = callback;
+      this.params = params;
+      this.objs = objs;
+      this.commonObjs = commonObjs;
+      this.operatorListIdx = null;
+      this.operatorList = operatorList;
+      this.pageNumber = pageNumber;
+      this.canvasFactory = canvasFactory;
+      this.webGLContext = webGLContext;
+      this._pdfBug = pdfBug;
       this.running = false;
-      this.cancelled = true;
-      if (this._canvas) {
-        canvasInRendering.delete(this._canvas);
-      }
-      this.callback(new _dom_utils.RenderingCancelledException('Rendering cancelled, page ' + this.pageNumber, 'canvas'));
-    },
-    operatorListChanged: function InternalRenderTask_operatorListChanged() {
-      if (!this.graphicsReady) {
-        if (!this.graphicsReadyCallback) {
-          this.graphicsReadyCallback = this._continueBound;
+      this.graphicsReadyCallback = null;
+      this.graphicsReady = false;
+      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== 'undefined';
+      this.cancelled = false;
+      this.capability = (0, _util.createPromiseCapability)();
+      this.task = new RenderTask(this);
+      this._continueBound = this._continue.bind(this);
+      this._scheduleNextBound = this._scheduleNext.bind(this);
+      this._nextBound = this._next.bind(this);
+      this._canvas = params.canvasContext.canvas;
+    }
+
+    _createClass(InternalRenderTask, [{
+      key: "initializeGraphics",
+      value: function initializeGraphics() {
+        var transparency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+        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.');
+          }
+
+          canvasInRendering.add(this._canvas);
+        }
+
+        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();
+        }
+
+        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();
         }
-        return;
-      }
-      if (this.stepper) {
-        this.stepper.updateOperatorList(this.operatorList);
-      }
-      if (this.running) {
-        return;
-      }
-      this._continue();
-    },
-    _continue: function InternalRenderTask__continue() {
-      this.running = true;
-      if (this.cancelled) {
-        return;
-      }
-      if (this.task.onContinue) {
-        this.task.onContinue(this._scheduleNextBound);
-      } else {
-        this._scheduleNext();
-      }
-    },
-    _scheduleNext: function InternalRenderTask__scheduleNext() {
-      if (this.useRequestAnimationFrame && typeof window !== 'undefined') {
-        window.requestAnimationFrame(this._nextBound);
-      } else {
-        Promise.resolve(undefined).then(this._nextBound);
-      }
-    },
-    _next: function InternalRenderTask__next() {
-      if (this.cancelled) {
-        return;
       }
-      this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
-      if (this.operatorListIdx === this.operatorList.argsArray.length) {
+    }, {
+      key: "cancel",
+      value: function cancel() {
+        var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
         this.running = false;
-        if (this.operatorList.lastChunk) {
+        this.cancelled = true;
+
+        if (this.gfx) {
           this.gfx.endDrawing();
-          if (this._canvas) {
-            canvasInRendering.delete(this._canvas);
+        }
+
+        if (this._canvas) {
+          canvasInRendering["delete"](this._canvas);
+        }
+
+        this.callback(error || new _display_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this.pageNumber), 'canvas'));
+      }
+    }, {
+      key: "operatorListChanged",
+      value: function operatorListChanged() {
+        if (!this.graphicsReady) {
+          if (!this.graphicsReadyCallback) {
+            this.graphicsReadyCallback = this._continueBound;
           }
-          this.callback();
+
+          return;
         }
+
+        if (this.stepper) {
+          this.stepper.updateOperatorList(this.operatorList);
+        }
+
+        if (this.running) {
+          return;
+        }
+
+        this._continue();
       }
-    }
-  };
+    }, {
+      key: "_continue",
+      value: function _continue() {
+        this.running = true;
+
+        if (this.cancelled) {
+          return;
+        }
+
+        if (this.task.onContinue) {
+          this.task.onContinue(this._scheduleNextBound);
+        } else {
+          this._scheduleNext();
+        }
+      }
+    }, {
+      key: "_scheduleNext",
+      value: function _scheduleNext() {
+        var _this18 = this;
+
+        if (this._useRequestAnimationFrame) {
+          window.requestAnimationFrame(function () {
+            _this18._nextBound()["catch"](_this18.cancel.bind(_this18));
+          });
+        } else {
+          Promise.resolve().then(this._nextBound)["catch"](this.cancel.bind(this));
+        }
+      }
+    }, {
+      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);
+        }
+
+        return _next;
+      }()
+    }]);
+
+    return InternalRenderTask;
+  }();
+
   return InternalRenderTask;
 }();
-var version, build;
-{
-  exports.version = version = '2.0.550';
-  exports.build = build = '76337fdc';
-}
-exports.getDocument = getDocument;
-exports.LoopbackPort = LoopbackPort;
-exports.PDFDataRangeTransport = PDFDataRangeTransport;
-exports.PDFWorker = PDFWorker;
-exports.PDFDocumentProxy = PDFDocumentProxy;
-exports.PDFPageProxy = PDFPageProxy;
-exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
+
+var version = '2.3.200';
 exports.version = version;
+var build = '4ae3f9fc';
 exports.build = build;