pdfjs-dist 2.1.266 → 2.5.207

package/lib/core/worker.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,33 +26,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.WorkerMessageHandler = exports.WorkerTask = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
+var _primitives = require("./primitives.js");
 
-var _pdf_manager = require("./pdf_manager");
+var _pdf_manager = require("./pdf_manager.js");
 
-var _is_node = _interopRequireDefault(require("../shared/is_node"));
+var _is_node = require("../shared/is_node.js");
 
-var _message_handler = require("../shared/message_handler");
+var _message_handler = require("../shared/message_handler.js");
 
-var _primitives = require("./primitives");
+var _worker_stream = require("./worker_stream.js");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+var _core_utils = require("./core_utils.js");
 
 var WorkerTask = function WorkerTaskClosure() {
   function WorkerTask(name) {
@@ -66,161 +52,29 @@ var WorkerTask = function WorkerTaskClosure() {
       return this._capability.promise;
     },
 
-    finish: function finish() {
+    finish() {
       this._capability.resolve();
     },
-    terminate: function terminate() {
+
+    terminate() {
       this.terminated = true;
     },
-    ensureNotTerminated: function ensureNotTerminated() {
+
+    ensureNotTerminated() {
       if (this.terminated) {
-        throw new Error('Worker task was terminated');
+        throw new Error("Worker task was terminated");
       }
     }
+
   };
   return WorkerTask;
 }();
 
 exports.WorkerTask = WorkerTask;
-
-var PDFWorkerStream = function PDFWorkerStreamClosure() {
-  function PDFWorkerStream(msgHandler) {
-    this._msgHandler = msgHandler;
-    this._contentLength = null;
-    this._fullRequestReader = null;
-    this._rangeRequestReaders = [];
-  }
-
-  PDFWorkerStream.prototype = {
-    getFullReader: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      this._fullRequestReader = new PDFWorkerStreamReader(this._msgHandler);
-      return this._fullRequestReader;
-    },
-    getRangeReader: function getRangeReader(begin, end) {
-      var reader = new PDFWorkerStreamRangeReader(begin, end, this._msgHandler);
-
-      this._rangeRequestReaders.push(reader);
-
-      return reader;
-    },
-    cancelAllRequests: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
-
-      var readers = this._rangeRequestReaders.slice(0);
-
-      readers.forEach(function (reader) {
-        reader.cancel(reason);
-      });
-    }
-  };
-
-  function PDFWorkerStreamReader(msgHandler) {
-    var _this = this;
-
-    this._msgHandler = msgHandler;
-    this._contentLength = null;
-    this._isRangeSupported = false;
-    this._isStreamingSupported = false;
-
-    var readableStream = this._msgHandler.sendWithStream('GetReader');
-
-    this._reader = readableStream.getReader();
-    this._headersReady = this._msgHandler.sendWithPromise('ReaderHeadersReady').then(function (data) {
-      _this._isStreamingSupported = data.isStreamingSupported;
-      _this._isRangeSupported = data.isRangeSupported;
-      _this._contentLength = data.contentLength;
-    });
-  }
-
-  PDFWorkerStreamReader.prototype = {
-    get headersReady() {
-      return this._headersReady;
-    },
-
-    get contentLength() {
-      return this._contentLength;
-    },
-
-    get isStreamingSupported() {
-      return this._isStreamingSupported;
-    },
-
-    get isRangeSupported() {
-      return this._isRangeSupported;
-    },
-
-    read: function read() {
-      return this._reader.read().then(function (_ref) {
-        var value = _ref.value,
-            done = _ref.done;
-
-        if (done) {
-          return {
-            value: undefined,
-            done: true
-          };
-        }
-
-        return {
-          value: value.buffer,
-          done: false
-        };
-      });
-    },
-    cancel: function cancel(reason) {
-      this._reader.cancel(reason);
-    }
-  };
-
-  function PDFWorkerStreamRangeReader(begin, end, msgHandler) {
-    this._msgHandler = msgHandler;
-    this.onProgress = null;
-
-    var readableStream = this._msgHandler.sendWithStream('GetRangeReader', {
-      begin: begin,
-      end: end
-    });
-
-    this._reader = readableStream.getReader();
-  }
-
-  PDFWorkerStreamRangeReader.prototype = {
-    get isStreamingSupported() {
-      return false;
-    },
-
-    read: function read() {
-      return this._reader.read().then(function (_ref2) {
-        var value = _ref2.value,
-            done = _ref2.done;
-
-        if (done) {
-          return {
-            value: undefined,
-            done: true
-          };
-        }
-
-        return {
-          value: value.buffer,
-          done: false
-        };
-      });
-    },
-    cancel: function cancel(reason) {
-      this._reader.cancel(reason);
-    }
-  };
-  return PDFWorkerStream;
-}();
-
 var WorkerMessageHandler = {
-  setup: function setup(handler, port) {
+  setup(handler, port) {
     var testMessageProcessed = false;
-    handler.on('test', function wphSetupTest(data) {
+    handler.on("test", function wphSetupTest(data) {
       if (testMessageProcessed) {
         return;
       }
@@ -228,59 +82,60 @@ var WorkerMessageHandler = {
       testMessageProcessed = true;
 
       if (!(data instanceof Uint8Array)) {
-        handler.send('test', false);
+        handler.send("test", null);
         return;
       }
 
-      var supportTransfers = data[0] === 255;
+      const supportTransfers = data[0] === 255;
       handler.postMessageTransfers = supportTransfers;
-      var xhr = new XMLHttpRequest();
-      var responseExists = 'response' in xhr;
-
-      try {
-        xhr.responseType;
-      } catch (e) {
-        responseExists = false;
-      }
-
-      if (!responseExists) {
-        handler.send('test', false);
-        return;
-      }
-
-      handler.send('test', {
-        supportTypedArray: true,
-        supportTransfers: supportTransfers
+      handler.send("test", {
+        supportTransfers
       });
     });
-    handler.on('configure', function wphConfigure(data) {
+    handler.on("configure", function wphConfigure(data) {
       (0, _util.setVerbosityLevel)(data.verbosity);
     });
-    handler.on('GetDocRequest', function wphSetupDoc(data) {
+    handler.on("GetDocRequest", function wphSetupDoc(data) {
       return WorkerMessageHandler.createDocumentHandler(data, port);
     });
   },
-  createDocumentHandler: function createDocumentHandler(docParams, port) {
+
+  createDocumentHandler(docParams, port) {
     var pdfManager;
     var terminated = false;
     var cancelXHRs = null;
     var WorkerTasks = [];
-    var apiVersion = docParams.apiVersion;
-    var workerVersion = '2.1.266';
+    const verbosity = (0, _util.getVerbosityLevel)();
+    const apiVersion = docParams.apiVersion;
+    const workerVersion = '2.5.207';
 
     if (apiVersion !== workerVersion) {
-      throw new Error("The API version \"".concat(apiVersion, "\" does not match ") + "the Worker version \"".concat(workerVersion, "\"."));
+      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
+    }
+
+    const enumerableProperties = [];
+
+    for (const property in []) {
+      enumerableProperties.push(property);
+    }
+
+    if (enumerableProperties.length) {
+      throw new Error("The `Array.prototype` contains unexpected enumerable properties: " + enumerableProperties.join(", ") + "; thus breaking e.g. `for...in` iteration of `Array`s.");
+    }
+
+    if (typeof ReadableStream === "undefined" || typeof Promise.allSettled === "undefined") {
+      throw new Error("The browser/environment lacks native support for critical " + "functionality used by the PDF.js library (e.g. " + "`ReadableStream` and/or `Promise.allSettled`); " + "please use an ES5-compatible build instead.");
     }
 
     var docId = docParams.docId;
     var docBaseUrl = docParams.docBaseUrl;
-    var workerHandlerName = docParams.docId + '_worker';
+    var workerHandlerName = docParams.docId + "_worker";
     var handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
     handler.postMessageTransfers = docParams.postMessageTransfers;
 
     function ensureNotTerminated() {
       if (terminated) {
-        throw new Error('Worker was terminated');
+        throw new Error("Worker was terminated");
       }
     }
 
@@ -294,73 +149,31 @@ var WorkerMessageHandler = {
       WorkerTasks.splice(i, 1);
     }
 
-    function loadDocument(_x) {
-      return _loadDocument.apply(this, arguments);
-    }
+    async function loadDocument(recoveryMode) {
+      await pdfManager.ensureDoc("checkHeader");
+      await pdfManager.ensureDoc("parseStartXRef");
+      await pdfManager.ensureDoc("parse", [recoveryMode]);
 
-    function _loadDocument() {
-      _loadDocument = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee(recoveryMode) {
-        var _ref6, _ref7, numPages, fingerprint;
-
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.next = 2;
-                return pdfManager.ensureDoc('checkHeader');
-
-              case 2:
-                _context.next = 4;
-                return pdfManager.ensureDoc('parseStartXRef');
-
-              case 4:
-                _context.next = 6;
-                return pdfManager.ensureDoc('parse', [recoveryMode]);
-
-              case 6:
-                if (recoveryMode) {
-                  _context.next = 9;
-                  break;
-                }
-
-                _context.next = 9;
-                return pdfManager.ensureDoc('checkFirstPage');
-
-              case 9:
-                _context.next = 11;
-                return Promise.all([pdfManager.ensureDoc('numPages'), pdfManager.ensureDoc('fingerprint')]);
-
-              case 11:
-                _ref6 = _context.sent;
-                _ref7 = _slicedToArray(_ref6, 2);
-                numPages = _ref7[0];
-                fingerprint = _ref7[1];
-                return _context.abrupt("return", {
-                  numPages: numPages,
-                  fingerprint: fingerprint
-                });
-
-              case 16:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-      return _loadDocument.apply(this, arguments);
+      if (!recoveryMode) {
+        await pdfManager.ensureDoc("checkFirstPage");
+      }
+
+      const [numPages, fingerprint] = await Promise.all([pdfManager.ensureDoc("numPages"), pdfManager.ensureDoc("fingerprint")]);
+      return {
+        numPages,
+        fingerprint
+      };
     }
 
     function getPdfManager(data, evaluatorOptions) {
       var pdfManagerCapability = (0, _util.createPromiseCapability)();
-      var pdfManager;
+      let newPdfManager;
       var source = data.source;
 
       if (source.data) {
         try {
-          pdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
-          pdfManagerCapability.resolve(pdfManager);
+          newPdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
+          pdfManagerCapability.resolve(newPdfManager);
         } catch (ex) {
           pdfManagerCapability.reject(ex);
         }
@@ -372,7 +185,7 @@ var WorkerMessageHandler = {
           cachedChunks = [];
 
       try {
-        pdfStream = new PDFWorkerStream(handler);
+        pdfStream = new _worker_stream.PDFWorkerStream(handler);
       } catch (ex) {
         pdfManagerCapability.reject(ex);
         return pdfManagerCapability.promise;
@@ -385,20 +198,20 @@ var WorkerMessageHandler = {
         }
 
         var disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
-        pdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
+        newPdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
           msgHandler: handler,
           password: source.password,
           length: fullRequest.contentLength,
-          disableAutoFetch: disableAutoFetch,
+          disableAutoFetch,
           rangeChunkSize: source.rangeChunkSize
         }, evaluatorOptions, docBaseUrl);
 
-        for (var i = 0; i < cachedChunks.length; i++) {
-          pdfManager.sendProgressiveData(cachedChunks[i]);
+        for (let i = 0; i < cachedChunks.length; i++) {
+          newPdfManager.sendProgressiveData(cachedChunks[i]);
         }
 
         cachedChunks = [];
-        pdfManagerCapability.resolve(pdfManager);
+        pdfManagerCapability.resolve(newPdfManager);
         cancelXHRs = null;
       }).catch(function (reason) {
         pdfManagerCapability.reject(reason);
@@ -406,16 +219,16 @@ var WorkerMessageHandler = {
       });
       var loaded = 0;
 
-      var flushChunks = function flushChunks() {
+      var flushChunks = function () {
         var pdfFile = (0, _util.arraysToBytes)(cachedChunks);
 
         if (source.length && pdfFile.length !== source.length) {
-          (0, _util.warn)('reported HTTP length is different from actual');
+          (0, _util.warn)("reported HTTP length is different from actual");
         }
 
         try {
-          pdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
-          pdfManagerCapability.resolve(pdfManager);
+          newPdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
+          pdfManagerCapability.resolve(newPdfManager);
         } catch (ex) {
           pdfManagerCapability.reject(ex);
         }
@@ -424,12 +237,15 @@ var WorkerMessageHandler = {
       };
 
       var readPromise = new Promise(function (resolve, reject) {
-        var readChunk = function readChunk(chunk) {
+        var readChunk = function ({
+          value,
+          done
+        }) {
           try {
             ensureNotTerminated();
 
-            if (chunk.done) {
-              if (!pdfManager) {
+            if (done) {
+              if (!newPdfManager) {
                 flushChunks();
               }
 
@@ -437,20 +253,19 @@ var WorkerMessageHandler = {
               return;
             }
 
-            var data = chunk.value;
-            loaded += (0, _util.arrayByteLength)(data);
+            loaded += (0, _util.arrayByteLength)(value);
 
             if (!fullRequest.isStreamingSupported) {
-              handler.send('DocProgress', {
-                loaded: loaded,
+              handler.send("DocProgress", {
+                loaded,
                 total: Math.max(loaded, fullRequest.contentLength || 0)
               });
             }
 
-            if (pdfManager) {
-              pdfManager.sendProgressiveData(data);
+            if (newPdfManager) {
+              newPdfManager.sendProgressiveData(value);
             } else {
-              cachedChunks.push(data);
+              cachedChunks.push(value);
             }
 
             fullRequest.read().then(readChunk, reject);
@@ -466,8 +281,8 @@ var WorkerMessageHandler = {
         cancelXHRs = null;
       });
 
-      cancelXHRs = function cancelXHRs() {
-        pdfStream.cancelAllRequests('abort');
+      cancelXHRs = function (reason) {
+        pdfStream.cancelAllRequests(reason);
       };
 
       return pdfManagerCapability.promise;
@@ -476,33 +291,31 @@ var WorkerMessageHandler = {
     function setupDoc(data) {
       function onSuccess(doc) {
         ensureNotTerminated();
-        handler.send('GetDoc', {
+        handler.send("GetDoc", {
           pdfInfo: doc
         });
       }
 
-      function onFailure(e) {
+      function onFailure(ex) {
         ensureNotTerminated();
 
-        if (e instanceof _util.PasswordException) {
-          var task = new WorkerTask('PasswordException: response ' + e.code);
+        if (ex instanceof _util.PasswordException) {
+          var task = new WorkerTask(`PasswordException: response ${ex.code}`);
           startWorkerTask(task);
-          handler.sendWithPromise('PasswordRequest', e).then(function (data) {
+          handler.sendWithPromise("PasswordRequest", ex).then(function ({
+            password
+          }) {
             finishWorkerTask(task);
-            pdfManager.updatePassword(data.password);
+            pdfManager.updatePassword(password);
             pdfManagerReady();
-          }).catch(function (boundException) {
+          }).catch(function () {
             finishWorkerTask(task);
-            handler.send('PasswordException', boundException);
-          }.bind(null, e));
-        } else if (e instanceof _util.InvalidPDFException) {
-          handler.send('InvalidPDF', e);
-        } else if (e instanceof _util.MissingPDFException) {
-          handler.send('MissingPDF', e);
-        } else if (e instanceof _util.UnexpectedResponseException) {
-          handler.send('UnexpectedResponse', e);
+            handler.send("DocException", ex);
+          });
+        } else if (ex instanceof _util.InvalidPDFException || ex instanceof _util.MissingPDFException || ex instanceof _util.UnexpectedResponseException || ex instanceof _util.UnknownErrorException) {
+          handler.send("DocException", ex);
         } else {
-          handler.send('UnknownError', new _util.UnknownErrorException(e.message, e.toString()));
+          handler.send("DocException", new _util.UnknownErrorException(ex.message, ex.toString()));
         }
       }
 
@@ -511,7 +324,7 @@ var WorkerMessageHandler = {
         loadDocument(false).then(onSuccess, function loadFailure(ex) {
           ensureNotTerminated();
 
-          if (!(ex instanceof _util.XRefParseException)) {
+          if (!(ex instanceof _core_utils.XRefParseException)) {
             onFailure(ex);
             return;
           }
@@ -526,151 +339,133 @@ var WorkerMessageHandler = {
 
       ensureNotTerminated();
       var evaluatorOptions = {
-        forceDataSchema: data.disableCreateObjectURL,
         maxImageSize: data.maxImageSize,
         disableFontFace: data.disableFontFace,
-        nativeImageDecoderSupport: data.nativeImageDecoderSupport,
         ignoreErrors: data.ignoreErrors,
-        isEvalSupported: data.isEvalSupported
+        isEvalSupported: data.isEvalSupported,
+        fontExtraProperties: data.fontExtraProperties
       };
       getPdfManager(data, evaluatorOptions).then(function (newPdfManager) {
         if (terminated) {
-          newPdfManager.terminate();
-          throw new Error('Worker was terminated');
+          newPdfManager.terminate(new _util.AbortException("Worker was terminated."));
+          throw new Error("Worker was terminated");
         }
 
         pdfManager = newPdfManager;
         pdfManager.onLoadedStream().then(function (stream) {
-          handler.send('DataLoaded', {
+          handler.send("DataLoaded", {
             length: stream.bytes.byteLength
           });
         });
       }).then(pdfManagerReady, onFailure);
     }
 
-    handler.on('GetPage', function wphSetupGetPage(data) {
+    handler.on("GetPage", function wphSetupGetPage(data) {
       return pdfManager.getPage(data.pageIndex).then(function (page) {
-        return Promise.all([pdfManager.ensure(page, 'rotate'), pdfManager.ensure(page, 'ref'), pdfManager.ensure(page, 'userUnit'), pdfManager.ensure(page, 'view')]).then(function (_ref3) {
-          var _ref4 = _slicedToArray(_ref3, 4),
-              rotate = _ref4[0],
-              ref = _ref4[1],
-              userUnit = _ref4[2],
-              view = _ref4[3];
-
+        return Promise.all([pdfManager.ensure(page, "rotate"), pdfManager.ensure(page, "ref"), pdfManager.ensure(page, "userUnit"), pdfManager.ensure(page, "view")]).then(function ([rotate, ref, userUnit, view]) {
           return {
-            rotate: rotate,
-            ref: ref,
-            userUnit: userUnit,
-            view: view
+            rotate,
+            ref,
+            userUnit,
+            view
           };
         });
       });
     });
-    handler.on('GetPageIndex', function wphSetupGetPageIndex(data) {
-      var ref = new _primitives.Ref(data.ref.num, data.ref.gen);
+    handler.on("GetPageIndex", function wphSetupGetPageIndex(data) {
+      var ref = _primitives.Ref.get(data.ref.num, data.ref.gen);
+
       var catalog = pdfManager.pdfDocument.catalog;
       return catalog.getPageIndex(ref);
     });
-    handler.on('GetDestinations', function wphSetupGetDestinations(data) {
-      return pdfManager.ensureCatalog('destinations');
+    handler.on("GetDestinations", function wphSetupGetDestinations(data) {
+      return pdfManager.ensureCatalog("destinations");
     });
-    handler.on('GetDestination', function wphSetupGetDestination(data) {
-      return pdfManager.ensureCatalog('getDestination', [data.id]);
+    handler.on("GetDestination", function wphSetupGetDestination(data) {
+      return pdfManager.ensureCatalog("getDestination", [data.id]);
     });
-    handler.on('GetPageLabels', function wphSetupGetPageLabels(data) {
-      return pdfManager.ensureCatalog('pageLabels');
+    handler.on("GetPageLabels", function wphSetupGetPageLabels(data) {
+      return pdfManager.ensureCatalog("pageLabels");
     });
-    handler.on('GetPageMode', function wphSetupGetPageMode(data) {
-      return pdfManager.ensureCatalog('pageMode');
+    handler.on("GetPageLayout", function wphSetupGetPageLayout(data) {
+      return pdfManager.ensureCatalog("pageLayout");
     });
-    handler.on('getOpenActionDestination', function (data) {
-      return pdfManager.ensureCatalog('openActionDestination');
+    handler.on("GetPageMode", function wphSetupGetPageMode(data) {
+      return pdfManager.ensureCatalog("pageMode");
     });
-    handler.on('GetAttachments', function wphSetupGetAttachments(data) {
-      return pdfManager.ensureCatalog('attachments');
+    handler.on("GetViewerPreferences", function (data) {
+      return pdfManager.ensureCatalog("viewerPreferences");
     });
-    handler.on('GetJavaScript', function wphSetupGetJavaScript(data) {
-      return pdfManager.ensureCatalog('javaScript');
+    handler.on("GetOpenAction", function (data) {
+      return pdfManager.ensureCatalog("openAction");
     });
-    handler.on('GetOutline', function wphSetupGetOutline(data) {
-      return pdfManager.ensureCatalog('documentOutline');
+    handler.on("GetAttachments", function wphSetupGetAttachments(data) {
+      return pdfManager.ensureCatalog("attachments");
     });
-    handler.on('GetPermissions', function (data) {
-      return pdfManager.ensureCatalog('permissions');
+    handler.on("GetJavaScript", function wphSetupGetJavaScript(data) {
+      return pdfManager.ensureCatalog("javaScript");
     });
-    handler.on('GetMetadata', function wphSetupGetMetadata(data) {
-      return Promise.all([pdfManager.ensureDoc('documentInfo'), pdfManager.ensureCatalog('metadata')]);
+    handler.on("GetOutline", function wphSetupGetOutline(data) {
+      return pdfManager.ensureCatalog("documentOutline");
     });
-    handler.on('GetData', function wphSetupGetData(data) {
+    handler.on("GetPermissions", function (data) {
+      return pdfManager.ensureCatalog("permissions");
+    });
+    handler.on("GetMetadata", function wphSetupGetMetadata(data) {
+      return Promise.all([pdfManager.ensureDoc("documentInfo"), pdfManager.ensureCatalog("metadata")]);
+    });
+    handler.on("GetData", function wphSetupGetData(data) {
       pdfManager.requestLoadedStream();
       return pdfManager.onLoadedStream().then(function (stream) {
         return stream.bytes;
       });
     });
-    handler.on('GetStats', function wphSetupGetStats(data) {
+    handler.on("GetStats", function wphSetupGetStats(data) {
       return pdfManager.pdfDocument.xref.stats;
     });
-    handler.on('GetAnnotations', function (_ref5) {
-      var pageIndex = _ref5.pageIndex,
-          intent = _ref5.intent;
+    handler.on("GetAnnotations", function ({
+      pageIndex,
+      intent
+    }) {
       return pdfManager.getPage(pageIndex).then(function (page) {
         return page.getAnnotationsData(intent);
       });
     });
-    handler.on('RenderPageRequest', function wphSetupRenderPage(data) {
+    handler.on("GetOperatorList", function wphSetupRenderPage(data, sink) {
       var pageIndex = data.pageIndex;
       pdfManager.getPage(pageIndex).then(function (page) {
-        var task = new WorkerTask('RenderPageRequest: page ' + pageIndex);
+        var task = new WorkerTask(`GetOperatorList: page ${pageIndex}`);
         startWorkerTask(task);
-        var pageNum = pageIndex + 1;
-        var start = Date.now();
+        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
         page.getOperatorList({
-          handler: handler,
-          task: task,
+          handler,
+          sink,
+          task,
           intent: data.intent,
           renderInteractiveForms: data.renderInteractiveForms
-        }).then(function (operatorList) {
+        }).then(function (operatorListInfo) {
           finishWorkerTask(task);
-          (0, _util.info)('page=' + pageNum + ' - getOperatorList: time=' + (Date.now() - start) + 'ms, len=' + operatorList.totalLength);
-        }, function (e) {
+
+          if (start) {
+            (0, _util.info)(`page=${pageIndex + 1} - getOperatorList: time=` + `${Date.now() - start}ms, len=${operatorListInfo.length}`);
+          }
+
+          sink.close();
+        }, function (reason) {
           finishWorkerTask(task);
 
           if (task.terminated) {
             return;
           }
 
-          handler.send('UnsupportedFeature', {
-            featureId: _util.UNSUPPORTED_FEATURES.unknown
-          });
-          var minimumStackMessage = 'worker.js: while trying to getPage() and getOperatorList()';
-          var wrappedException;
-
-          if (typeof e === 'string') {
-            wrappedException = {
-              message: e,
-              stack: minimumStackMessage
-            };
-          } else if (_typeof(e) === 'object') {
-            wrappedException = {
-              message: e.message || e.toString(),
-              stack: e.stack || minimumStackMessage
-            };
-          } else {
-            wrappedException = {
-              message: 'Unknown exception type: ' + _typeof(e),
-              stack: minimumStackMessage
-            };
-          }
-
-          handler.send('PageError', {
-            pageNum: pageNum,
-            error: wrappedException,
-            intent: data.intent
+          handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.errorOperatorList
           });
+          sink.error(reason);
         });
       });
     }, this);
-    handler.on('GetTextContent', function wphExtractText(data, sink) {
+    handler.on("GetTextContent", function wphExtractText(data, sink) {
       var pageIndex = data.pageIndex;
 
       sink.onPull = function (desiredSize) {};
@@ -678,19 +473,22 @@ var WorkerMessageHandler = {
       sink.onCancel = function (reason) {};
 
       pdfManager.getPage(pageIndex).then(function (page) {
-        var task = new WorkerTask('GetTextContent: page ' + pageIndex);
+        var task = new WorkerTask("GetTextContent: page " + pageIndex);
         startWorkerTask(task);
-        var pageNum = pageIndex + 1;
-        var start = Date.now();
+        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
         page.extractTextContent({
-          handler: handler,
-          task: task,
-          sink: sink,
+          handler,
+          task,
+          sink,
           normalizeWhitespace: data.normalizeWhitespace,
           combineTextItems: data.combineTextItems
         }).then(function () {
           finishWorkerTask(task);
-          (0, _util.info)('text indexing: page=' + pageNum + ' - time=' + (Date.now() - start) + 'ms');
+
+          if (start) {
+            (0, _util.info)(`page=${pageIndex + 1} - getTextContent: time=` + `${Date.now() - start}ms`);
+          }
+
           sink.close();
         }, function (reason) {
           finishWorkerTask(task);
@@ -700,29 +498,32 @@ var WorkerMessageHandler = {
           }
 
           sink.error(reason);
-          throw reason;
         });
       });
     });
-    handler.on('FontFallback', function (data) {
+    handler.on("FontFallback", function (data) {
       return pdfManager.fontFallback(data.id, handler);
     });
-    handler.on('Cleanup', function wphCleanup(data) {
-      return pdfManager.cleanup();
+    handler.on("Cleanup", function wphCleanup(data) {
+      return pdfManager.cleanup(true);
     });
-    handler.on('Terminate', function wphTerminate(data) {
+    handler.on("Terminate", function wphTerminate(data) {
       terminated = true;
+      const waitOn = [];
 
       if (pdfManager) {
-        pdfManager.terminate();
+        pdfManager.terminate(new _util.AbortException("Worker was terminated."));
+        const cleanupPromise = pdfManager.cleanup();
+        waitOn.push(cleanupPromise);
         pdfManager = null;
+      } else {
+        (0, _primitives.clearPrimitiveCaches)();
       }
 
       if (cancelXHRs) {
-        cancelXHRs();
+        cancelXHRs(new _util.AbortException("Worker was terminated."));
       }
 
-      var waitOn = [];
       WorkerTasks.forEach(function (task) {
         waitOn.push(task.finished);
         task.terminate();
@@ -732,24 +533,26 @@ var WorkerMessageHandler = {
         handler = null;
       });
     });
-    handler.on('Ready', function wphReady(data) {
+    handler.on("Ready", function wphReady(data) {
       setupDoc(docParams);
       docParams = null;
     });
     return workerHandlerName;
   },
-  initializeFromPort: function initializeFromPort(port) {
-    var handler = new _message_handler.MessageHandler('worker', 'main', port);
+
+  initializeFromPort(port) {
+    var handler = new _message_handler.MessageHandler("worker", "main", port);
     WorkerMessageHandler.setup(handler, port);
-    handler.send('ready', null);
+    handler.send("ready", null);
   }
+
 };
 exports.WorkerMessageHandler = WorkerMessageHandler;
 
 function isMessagePort(maybePort) {
-  return typeof maybePort.postMessage === 'function' && 'onmessage' in maybePort;
+  return typeof maybePort.postMessage === "function" && "onmessage" in maybePort;
 }
 
-if (typeof window === 'undefined' && !(0, _is_node.default)() && typeof self !== 'undefined' && isMessagePort(self)) {
+if (typeof window === "undefined" && !_is_node.isNodeJS && typeof self !== "undefined" && isMessagePort(self)) {
   WorkerMessageHandler.initializeFromPort(self);
 }