Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

260 files changed, 80823 insertions, 0 deletions

diff --git a/toolkit/components/pdfjs/LICENSE b/toolkit/components/pdfjs/LICENSE
new file mode 100644
index 0000000000..f433b1a53f
--- /dev/null
+++ b/toolkit/components/pdfjs/LICENSE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/toolkit/components/pdfjs/README.mozilla b/toolkit/components/pdfjs/README.mozilla
new file mode 100644
index 0000000000..e53f9ee8fc
--- /dev/null
+++ b/toolkit/components/pdfjs/README.mozilla
@@ -0,0 +1,5 @@
+This is the PDF.js project output, https://github.com/mozilla/pdf.js
+
+Current extension version is: 2.7.510
+
+Taken from upstream commit: 631bada0d
diff --git a/toolkit/components/pdfjs/chrome.manifest b/toolkit/components/pdfjs/chrome.manifest
new file mode 100644
index 0000000000..1aef83abc4
--- /dev/null
+++ b/toolkit/components/pdfjs/chrome.manifest
@@ -0,0 +1 @@
+resource pdf.js content/
diff --git a/toolkit/components/pdfjs/components.conf b/toolkit/components/pdfjs/components.conf
new file mode 100644
index 0000000000..6d0f6a150f
--- /dev/null
+++ b/toolkit/components/pdfjs/components.conf
@@ -0,0 +1,19 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+Classes = [
+    {
+        'cid': '{d0c5195d-e798-49d4-b1d3-9324328b2291}',
+        'contract_ids': [
+            '@mozilla.org/streamconv;1?from=application/pdf&to=*/*',
+            '@mozilla.org/streamconv;1?from=application/pdf&to=text/html',
+            '@mozilla.org/streamconv;1?from=application/octet-stream&to=*/*',
+            '@mozilla.org/streamconv;1?from=application/octet-stream&to=text/html',
+        ],
+        'jsm': 'resource://gre/modules/pdfjs.js',
+        'constructor': 'StreamConverterFactory',
+    },
+]
diff --git a/toolkit/components/pdfjs/content/PdfJs.jsm b/toolkit/components/pdfjs/content/PdfJs.jsm
new file mode 100644
index 0000000000..3413a79ae2
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfJs.jsm
@@ -0,0 +1,268 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["PdfJs"];
+
+const PREF_PREFIX = "pdfjs";
+const PREF_DISABLED = PREF_PREFIX + ".disabled";
+const PREF_MIGRATION_VERSION = PREF_PREFIX + ".migrationVersion";
+const PREF_PREVIOUS_ACTION = PREF_PREFIX + ".previousHandler.preferredAction";
+const PREF_PREVIOUS_ASK =
+  PREF_PREFIX + ".previousHandler.alwaysAskBeforeHandling";
+const PREF_ISDEFAULT_CACHE_STATE = PREF_PREFIX + ".enabledCache.state";
+const TOPIC_PDFJS_HANDLER_CHANGED = "pdfjs:handlerChanged";
+const PDF_CONTENT_TYPE = "application/pdf";
+
+const { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(
+  Svc,
+  "mime",
+  "@mozilla.org/mime;1",
+  "nsIMIMEService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  Svc,
+  "handlerService",
+  "@mozilla.org/uriloader/handler-service;1",
+  "nsIHandlerService"
+);
+ChromeUtils.defineModuleGetter(
+  this,
+  "PdfJsDefaultPreferences",
+  "resource://pdf.js/PdfJsDefaultPreferences.jsm"
+);
+
+function initializeDefaultPreferences() {
+  var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + ".");
+  var defaultValue;
+  for (var key in PdfJsDefaultPreferences) {
+    // Skip prefs that are already defined, so we can enable/disable things
+    // in all.js.
+    let prefType = defaultBranch.getPrefType(key);
+    if (prefType !== Ci.nsIPrefBranch.PREF_INVALID) {
+      continue;
+    }
+    defaultValue = PdfJsDefaultPreferences[key];
+    switch (typeof defaultValue) {
+      case "boolean":
+        defaultBranch.setBoolPref(key, defaultValue);
+        break;
+      case "number":
+        defaultBranch.setIntPref(key, defaultValue);
+        break;
+      case "string":
+        defaultBranch.setCharPref(key, defaultValue);
+        break;
+    }
+  }
+}
+
+// We're supposed to get this type of thing from the OS, and generally we do.
+// But doing so is expensive, so on startup paths we can use this to make the
+// handler service get and store the Right Thing (it just goes into a JSON
+// file) and avoid the performance issues.
+const gPdfFakeHandlerInfo = {
+  QueryInterface: ChromeUtils.generateQI(["nsIMIMEInfo"]),
+  getFileExtensions() {
+    return ["pdf"];
+  },
+  possibleApplicationHandlers: Cc["@mozilla.org/array;1"].createInstance(
+    Ci.nsIMutableArray
+  ),
+  extensionExists(ext) {
+    return ext == "pdf";
+  },
+  alwaysAskBeforeHandling: false,
+  preferredAction: Ci.nsIHandlerInfo.handleInternally,
+  type: PDF_CONTENT_TYPE,
+};
+
+var PdfJs = {
+  QueryInterface: ChromeUtils.generateQI(["nsIObserver"]),
+  _initialized: false,
+  _cachedIsDefault: true,
+
+  init: function init(isNewProfile) {
+    if (
+      Services.appinfo.processType !== Services.appinfo.PROCESS_TYPE_DEFAULT
+    ) {
+      throw new Error(
+        "PdfJs.init should only get called in the parent process."
+      );
+    }
+    this.initPrefs();
+    this.checkIsDefault(isNewProfile);
+  },
+
+  initPrefs: function initPrefs() {
+    if (this._initialized) {
+      return;
+    }
+    this._initialized = true;
+
+    if (this._prefDisabled) {
+      this._unbecomeHandler();
+    } else {
+      this._migrate();
+    }
+
+    // Listen for when a different pdf handler is chosen.
+    Services.obs.addObserver(this, TOPIC_PDFJS_HANDLER_CHANGED);
+
+    initializeDefaultPreferences();
+  },
+
+  uninit: function uninit() {
+    if (this._initialized) {
+      Services.obs.removeObserver(this, TOPIC_PDFJS_HANDLER_CHANGED);
+      this._initialized = false;
+    }
+  },
+
+  _migrate: function migrate() {
+    const VERSION = 2;
+    var currentVersion = Services.prefs.getIntPref(PREF_MIGRATION_VERSION, 0);
+    if (currentVersion >= VERSION) {
+      return;
+    }
+    // Make pdf.js the default pdf viewer on the first migration.
+    if (currentVersion < 1) {
+      this._becomeHandler();
+    }
+    if (currentVersion < 2) {
+      // cleaning up of unused database preference (see #3994)
+      Services.prefs.clearUserPref(PREF_PREFIX + ".database");
+    }
+    Services.prefs.setIntPref(PREF_MIGRATION_VERSION, VERSION);
+  },
+
+  _becomeHandler: function _becomeHandler() {
+    // Normally, this happens in the first run at some point, where the
+    // handler service doesn't have any info on user preferences yet.
+    // Don't bother storing old defaults in this case, as they're
+    // meaningless anyway.
+    if (!Svc.handlerService.exists(gPdfFakeHandlerInfo)) {
+      // Store the requisite info into the DB, and nothing else:
+      Svc.handlerService.store(gPdfFakeHandlerInfo);
+    } else {
+      let handlerInfo = Svc.mime.getFromTypeAndExtension(
+        PDF_CONTENT_TYPE,
+        "pdf"
+      );
+      let prefs = Services.prefs;
+      if (
+        handlerInfo.preferredAction !== Ci.nsIHandlerInfo.handleInternally &&
+        handlerInfo.alwaysAskBeforeHandling !== false
+      ) {
+        // Store the previous settings of preferredAction and
+        // alwaysAskBeforeHandling in case we need to revert them in a hotfix that
+        // would turn pdf.js off.
+        prefs.setIntPref(PREF_PREVIOUS_ACTION, handlerInfo.preferredAction);
+        prefs.setBoolPref(
+          PREF_PREVIOUS_ASK,
+          handlerInfo.alwaysAskBeforeHandling
+        );
+      }
+
+      // Change and save mime handler settings.
+      handlerInfo.alwaysAskBeforeHandling = false;
+      handlerInfo.preferredAction = Ci.nsIHandlerInfo.handleInternally;
+      Svc.handlerService.store(handlerInfo);
+    }
+  },
+
+  _unbecomeHandler: function _unbecomeHandler() {
+    let handlerInfo = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, "pdf");
+    if (handlerInfo.preferredAction === Ci.nsIHandlerInfo.handleInternally) {
+      // If PDFJS is disabled, but we're still marked to handleInternally,
+      // either put it back to what it was, or remove it.
+      if (Services.prefs.prefHasUserValue(PREF_PREVIOUS_ACTION)) {
+        handlerInfo.preferredAction = Services.prefs.getIntPref(
+          PREF_PREVIOUS_ACTION
+        );
+        handlerInfo.alwaysAskBeforeHandling = Services.prefs.getBoolPref(
+          PREF_PREVIOUS_ASK
+        );
+        Svc.handlerService.store(handlerInfo);
+      } else {
+        Svc.handlerService.remove(handlerInfo);
+        // Clear migration pref so the handler comes back if reenabled
+        Services.prefs.clearIntPref(PREF_MIGRATION_VERSION);
+      }
+    }
+  },
+
+  /**
+   * @param isNewProfile used to decide whether we need to check the
+   *                     handler service to see if the user configured
+   *                     pdfs differently. If we're on a new profile,
+   *                     there's no need to check.
+   */
+  _isDefault(isNewProfile) {
+    let { processType, PROCESS_TYPE_DEFAULT } = Services.appinfo;
+    if (processType !== PROCESS_TYPE_DEFAULT) {
+      throw new Error(
+        "isDefault should only get called in the parent process."
+      );
+    }
+
+    if (this._prefDisabled) {
+      return false;
+    }
+
+    // Don't bother with the handler service on a new profile:
+    if (isNewProfile) {
+      return true;
+    }
+    // Check if the 'application/pdf' preview handler is configured properly.
+    let handlerInfo = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, "pdf");
+    return (
+      !handlerInfo.alwaysAskBeforeHandling &&
+      handlerInfo.preferredAction == Ci.nsIHandlerInfo.handleInternally
+    );
+  },
+
+  checkIsDefault(isNewProfile) {
+    this._cachedIsDefault = this._isDefault(isNewProfile);
+    Services.prefs.setBoolPref(
+      PREF_ISDEFAULT_CACHE_STATE,
+      this._cachedIsDefault
+    );
+  },
+
+  cachedIsDefault() {
+    return this._cachedIsDefault;
+  },
+
+  // nsIObserver
+  observe(aSubject, aTopic, aData) {
+    this.checkIsDefault();
+  },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  PdfJs,
+  "_prefDisabled",
+  PREF_DISABLED,
+  false,
+  () => PdfJs.checkIsDefault()
+);
diff --git a/toolkit/components/pdfjs/content/PdfJsDefaultPreferences.jsm b/toolkit/components/pdfjs/content/PdfJsDefaultPreferences.jsm
new file mode 100644
index 0000000000..ae9e9edda5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfJsDefaultPreferences.jsm
@@ -0,0 +1,49 @@
+/* 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* eslint-disable */
+
+//
+// THIS FILE IS GENERATED AUTOMATICALLY, DO NOT EDIT MANUALLY!
+//
+
+"use strict";
+var EXPORTED_SYMBOLS = ["PdfJsDefaultPreferences"];
+var PdfJsDefaultPreferences = Object.freeze({
+ "cursorToolOnLoad": 0,
+ "defaultZoomValue": "",
+ "disablePageLabels": false,
+ "enablePermissions": false,
+ "enablePrintAutoRotate": false,
+ "enableScripting": false,
+ "enableWebGL": false,
+ "externalLinkTarget": 0,
+ "historyUpdateUrl": false,
+ "ignoreDestinationZoom": false,
+ "pdfBugEnabled": false,
+ "renderer": "canvas",
+ "renderInteractiveForms": true,
+ "sidebarViewOnLoad": -1,
+ "scrollModeOnLoad": -1,
+ "spreadModeOnLoad": -1,
+ "textLayerMode": 1,
+ "useOnlyCssZoom": false,
+ "viewerCssTheme": 0,
+ "viewOnLoad": 0,
+ "disableAutoFetch": false,
+ "disableFontFace": false,
+ "disableRange": false,
+ "disableStream": false
+});
diff --git a/toolkit/components/pdfjs/content/PdfJsNetwork.jsm b/toolkit/components/pdfjs/content/PdfJsNetwork.jsm
new file mode 100644
index 0000000000..2f0906fe75
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfJsNetwork.jsm
@@ -0,0 +1,226 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var EXPORTED_SYMBOLS = ["NetworkManager"];
+
+// eslint-disable-next-line no-unused-vars
+function log(aMsg) {
+  var msg = "PdfJsNetwork.jsm: " + (aMsg.join ? aMsg.join("") : aMsg);
+  Services.console.logStringMessage(msg);
+}
+
+var NetworkManager = (function NetworkManagerClosure() {
+  const OK_RESPONSE = 200;
+  const PARTIAL_CONTENT_RESPONSE = 206;
+
+  function getArrayBuffer(xhr) {
+    var data = xhr.response;
+    if (typeof data !== "string") {
+      return data;
+    }
+    var length = data.length;
+    var array = new Uint8Array(length);
+    for (var i = 0; i < length; i++) {
+      array[i] = data.charCodeAt(i) & 0xff;
+    }
+    return array.buffer;
+  }
+
+  class NetworkManagerClass {
+    constructor(url, args) {
+      this.url = url;
+      args = args || {};
+      this.isHttp = /^https?:/i.test(url);
+      this.httpHeaders = (this.isHttp && args.httpHeaders) || {};
+      this.withCredentials = args.withCredentials || false;
+      this.getXhr =
+        args.getXhr ||
+        function NetworkManager_getXhr() {
+          return new XMLHttpRequest();
+        };
+
+      this.currXhrId = 0;
+      this.pendingRequests = Object.create(null);
+    }
+
+    requestRange(begin, end, listeners) {
+      var args = {
+        begin,
+        end,
+      };
+      for (var prop in listeners) {
+        args[prop] = listeners[prop];
+      }
+      return this.request(args);
+    }
+
+    requestFull(listeners) {
+      return this.request(listeners);
+    }
+
+    request(args) {
+      var xhr = this.getXhr();
+      var xhrId = this.currXhrId++;
+      var pendingRequest = (this.pendingRequests[xhrId] = {
+        xhr,
+      });
+
+      xhr.open("GET", this.url);
+      xhr.withCredentials = this.withCredentials;
+      for (var property in this.httpHeaders) {
+        var value = this.httpHeaders[property];
+        if (typeof value === "undefined") {
+          continue;
+        }
+        xhr.setRequestHeader(property, value);
+      }
+      if (this.isHttp && "begin" in args && "end" in args) {
+        var rangeStr = args.begin + "-" + (args.end - 1);
+        xhr.setRequestHeader("Range", "bytes=" + rangeStr);
+        pendingRequest.expectedStatus = 206;
+        xhr.channel.QueryInterface(Ci.nsIHttpChannel).redirectionLimit = 0;
+      } else {
+        pendingRequest.expectedStatus = 200;
+      }
+
+      xhr.responseType = "arraybuffer";
+
+      if (args.onError) {
+        xhr.onerror = function(evt) {
+          args.onError(xhr.status);
+        };
+      }
+      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
+      xhr.onprogress = this.onProgress.bind(this, xhrId);
+
+      pendingRequest.onHeadersReceived = args.onHeadersReceived;
+      pendingRequest.onDone = args.onDone;
+      pendingRequest.onError = args.onError;
+      pendingRequest.onProgress = args.onProgress;
+
+      xhr.send(null);
+
+      return xhrId;
+    }
+
+    onProgress(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      var onProgress = pendingRequest.onProgress;
+      if (onProgress) {
+        onProgress(evt);
+      }
+    }
+
+    onStateChange(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      var xhr = pendingRequest.xhr;
+      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
+        pendingRequest.onHeadersReceived();
+        delete pendingRequest.onHeadersReceived;
+      }
+
+      if (xhr.readyState !== 4) {
+        return;
+      }
+
+      if (!(xhrId in this.pendingRequests)) {
+        // The XHR request might have been aborted in onHeadersReceived()
+        // callback, in which case we should abort request
+        return;
+      }
+
+      delete this.pendingRequests[xhrId];
+
+      // success status == 0 can be on ftp, file and other protocols
+      if (xhr.status === 0 && this.isHttp) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+      var xhrStatus = xhr.status || OK_RESPONSE;
+
+      // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2:
+      // "A server MAY ignore the Range header". This means it's possible to
+      // get a 200 rather than a 206 response from a range request.
+      var ok_response_on_range_request =
+        xhrStatus === OK_RESPONSE &&
+        pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+
+      if (
+        !ok_response_on_range_request &&
+        xhrStatus !== pendingRequest.expectedStatus
+      ) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+
+      var chunk = getArrayBuffer(xhr);
+      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
+        var rangeHeader = xhr.getResponseHeader("Content-Range");
+        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
+        var begin = parseInt(matches[1], 10);
+        pendingRequest.onDone({
+          begin,
+          chunk,
+        });
+      } else if (chunk) {
+        pendingRequest.onDone({
+          begin: 0,
+          chunk,
+        });
+      } else if (pendingRequest.onError) {
+        pendingRequest.onError(xhr.status);
+      }
+    }
+
+    hasPendingRequests() {
+      for (var xhrId in this.pendingRequests) {
+        return true;
+      }
+      return false;
+    }
+
+    abortAllRequests() {
+      for (var xhrId in this.pendingRequests) {
+        this.abortRequest(xhrId | 0);
+      }
+    }
+
+    abortRequest(xhrId) {
+      var xhr = this.pendingRequests[xhrId].xhr;
+      delete this.pendingRequests[xhrId];
+      xhr.abort();
+    }
+  }
+
+  return NetworkManagerClass;
+})();
diff --git a/toolkit/components/pdfjs/content/PdfJsTelemetry.jsm b/toolkit/components/pdfjs/content/PdfJsTelemetry.jsm
new file mode 100644
index 0000000000..cb2cea7de4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfJsTelemetry.jsm
@@ -0,0 +1,91 @@
+/* Copyright 2013 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint max-len: ["error", 100] */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["PdfJsTelemetry"];
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var PdfJsTelemetry = {
+  onViewerIsUsed() {
+    Services.telemetry.scalarAdd("pdf.viewer.used", 1);
+  },
+  onFallbackShown(featureId) {
+    Services.telemetry.scalarAdd("pdf.viewer.fallback_shown", 1);
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_FALLBACK_REASON"
+    );
+    histogram.add(featureId ?? "unknown");
+  },
+  onFallbackError(featureId) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_FALLBACK_ERROR"
+    );
+    histogram.add(featureId ?? "unknown");
+  },
+  onDocumentSize(size) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_DOCUMENT_SIZE_KB"
+    );
+    histogram.add(size / 1024);
+  },
+  onDocumentVersion(versionId) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_DOCUMENT_VERSION_2"
+    );
+    histogram.add(versionId);
+  },
+  onDocumentGenerator(generatorId) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_DOCUMENT_GENERATOR_2"
+    );
+    histogram.add(generatorId);
+  },
+  onEmbed(isObject) {
+    let histogram = Services.telemetry.getHistogramById("PDF_VIEWER_EMBED_2");
+    histogram.add(isObject ? "object_embed" : "iframe");
+  },
+  onFontType(fontTypeId) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_FONT_TYPES_2"
+    );
+    histogram.add(fontTypeId);
+  },
+  onForm(formType) {
+    let histogram = Services.telemetry.getHistogramById("PDF_VIEWER_FORM_2");
+    histogram.add(formType);
+  },
+  onPrint() {
+    Services.telemetry.scalarAdd("pdf.viewer.print", 1);
+  },
+  onStreamType(streamTypeId) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_STREAM_TYPES_2"
+    );
+    histogram.add(streamTypeId);
+  },
+  onTimeToView(ms) {
+    let histogram = Services.telemetry.getHistogramById(
+      "PDF_VIEWER_TIME_TO_VIEW_MS"
+    );
+    histogram.add(ms);
+  },
+  onTagged(tagged) {
+    let histogram = Services.telemetry.getHistogramById("PDF_VIEWER_TAGGED");
+    histogram.add(tagged);
+  },
+};
diff --git a/toolkit/components/pdfjs/content/PdfStreamConverter.jsm b/toolkit/components/pdfjs/content/PdfStreamConverter.jsm
new file mode 100644
index 0000000000..f30fdd334e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfStreamConverter.jsm
@@ -0,0 +1,1306 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["PdfStreamConverter"];
+
+const PDFJS_EVENT_ID = "pdf.js.message";
+const PREF_PREFIX = "pdfjs";
+const PDF_VIEWER_ORIGIN = "resource://pdf.js";
+const PDF_VIEWER_WEB_PAGE = "resource://pdf.js/web/viewer.html";
+const MAX_NUMBER_OF_PREFS = 50;
+const MAX_STRING_PREF_LENGTH = 128;
+const PDF_CONTENT_TYPE = "application/pdf";
+
+const { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { AppConstants } = ChromeUtils.import(
+  "resource://gre/modules/AppConstants.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "AsyncPrefs",
+  "resource://gre/modules/AsyncPrefs.jsm"
+);
+ChromeUtils.defineModuleGetter(
+  this,
+  "NetUtil",
+  "resource://gre/modules/NetUtil.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "NetworkManager",
+  "resource://pdf.js/PdfJsNetwork.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "PrivateBrowsingUtils",
+  "resource://gre/modules/PrivateBrowsingUtils.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "PdfJsTelemetry",
+  "resource://pdf.js/PdfJsTelemetry.jsm"
+);
+
+ChromeUtils.defineModuleGetter(this, "PdfJs", "resource://pdf.js/PdfJs.jsm");
+
+XPCOMUtils.defineLazyGlobalGetters(this, ["XMLHttpRequest"]);
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(
+  Svc,
+  "mime",
+  "@mozilla.org/mime;1",
+  "nsIMIMEService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  Svc,
+  "handlers",
+  "@mozilla.org/uriloader/handler-service;1",
+  "nsIHandlerService"
+);
+
+XPCOMUtils.defineLazyGetter(this, "gOurBinary", () => {
+  let file = Services.dirsvc.get("XREExeF", Ci.nsIFile);
+  // Make sure to get the .app on macOS
+  if (AppConstants.platform == "macosx") {
+    while (file) {
+      if (/\.app\/?$/i.test(file.leafName)) {
+        break;
+      }
+      file = file.parent;
+    }
+  }
+  return file;
+});
+
+function getBoolPref(pref, def) {
+  try {
+    return Services.prefs.getBoolPref(pref);
+  } catch (ex) {
+    return def;
+  }
+}
+
+function getIntPref(pref, def) {
+  try {
+    return Services.prefs.getIntPref(pref);
+  } catch (ex) {
+    return def;
+  }
+}
+
+function getStringPref(pref, def) {
+  try {
+    return Services.prefs.getStringPref(pref);
+  } catch (ex) {
+    return def;
+  }
+}
+
+function log(aMsg) {
+  if (!getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false)) {
+    return;
+  }
+  var msg = "PdfStreamConverter.js: " + (aMsg.join ? aMsg.join("") : aMsg);
+  Services.console.logStringMessage(msg);
+  dump(msg + "\n");
+}
+
+function getDOMWindow(aChannel, aPrincipal) {
+  var requestor = aChannel.notificationCallbacks
+    ? aChannel.notificationCallbacks
+    : aChannel.loadGroup.notificationCallbacks;
+  var win = requestor.getInterface(Ci.nsIDOMWindow);
+  // Ensure the window wasn't navigated to something that is not PDF.js.
+  if (!win.document.nodePrincipal.equals(aPrincipal)) {
+    return null;
+  }
+  return win;
+}
+
+function getActor(window) {
+  try {
+    return window.windowGlobalChild.getActor("Pdfjs");
+  } catch (ex) {
+    return null;
+  }
+}
+
+function getLocalizedStrings(path) {
+  var stringBundle = Services.strings.createBundle(
+    "chrome://pdf.js/locale/" + path
+  );
+
+  var map = {};
+  for (let string of stringBundle.getSimpleEnumeration()) {
+    var key = string.key,
+      property = "textContent";
+    var i = key.lastIndexOf(".");
+    if (i >= 0) {
+      property = key.substring(i + 1);
+      key = key.substring(0, i);
+    }
+    if (!(key in map)) {
+      map[key] = {};
+    }
+    map[key][property] = string.value;
+  }
+  return map;
+}
+function getLocalizedString(strings, id, property) {
+  property = property || "textContent";
+  if (id in strings) {
+    return strings[id][property];
+  }
+  return id;
+}
+
+function isValidMatchesCount(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const { current, total } = data;
+  if (
+    typeof total !== "number" ||
+    total < 0 ||
+    typeof current !== "number" ||
+    current < 0 ||
+    current > total
+  ) {
+    return false;
+  }
+  return true;
+}
+
+// PDF data storage
+function PdfDataListener(length) {
+  this.length = length; // less than 0, if length is unknown
+  this.buffers = [];
+  this.loaded = 0;
+}
+
+PdfDataListener.prototype = {
+  append: function PdfDataListener_append(chunk) {
+    // In most of the cases we will pass data as we receive it, but at the
+    // beginning of the loading we may accumulate some data.
+    this.buffers.push(chunk);
+    this.loaded += chunk.length;
+    if (this.length >= 0 && this.length < this.loaded) {
+      this.length = -1; // reset the length, server is giving incorrect one
+    }
+    this.onprogress(this.loaded, this.length >= 0 ? this.length : void 0);
+  },
+  readData: function PdfDataListener_readData() {
+    if (this.buffers.length === 0) {
+      return null;
+    }
+    if (this.buffers.length === 1) {
+      return this.buffers.pop();
+    }
+    // There are multiple buffers that need to be combined into a single
+    // buffer.
+    let combinedLength = 0;
+    for (let buffer of this.buffers) {
+      combinedLength += buffer.length;
+    }
+    let combinedArray = new Uint8Array(combinedLength);
+    let writeOffset = 0;
+    while (this.buffers.length) {
+      let buffer = this.buffers.shift();
+      combinedArray.set(buffer, writeOffset);
+      writeOffset += buffer.length;
+    }
+    return combinedArray;
+  },
+  get isDone() {
+    return !!this.isDataReady;
+  },
+  finish: function PdfDataListener_finish() {
+    this.isDataReady = true;
+    if (this.oncompleteCallback) {
+      this.oncompleteCallback(this.readData());
+    }
+  },
+  error: function PdfDataListener_error(errorCode) {
+    this.errorCode = errorCode;
+    if (this.oncompleteCallback) {
+      this.oncompleteCallback(null, errorCode);
+    }
+  },
+  onprogress() {},
+  get oncomplete() {
+    return this.oncompleteCallback;
+  },
+  set oncomplete(value) {
+    this.oncompleteCallback = value;
+    if (this.isDataReady) {
+      value(this.readData());
+    }
+    if (this.errorCode) {
+      value(null, this.errorCode);
+    }
+  },
+};
+
+/**
+ * All the privileged actions.
+ */
+class ChromeActions {
+  constructor(domWindow, contentDispositionFilename) {
+    this.domWindow = domWindow;
+    this.contentDispositionFilename = contentDispositionFilename;
+    this.telemetryState = {
+      documentInfo: false,
+      firstPageInfo: false,
+      streamTypesUsed: {},
+      fontTypesUsed: {},
+      fallbackErrorsReported: {},
+    };
+  }
+
+  isInPrivateBrowsing() {
+    return PrivateBrowsingUtils.isContentWindowPrivate(this.domWindow);
+  }
+
+  getWindowOriginAttributes() {
+    try {
+      return this.domWindow.document.nodePrincipal.originAttributes;
+    } catch (err) {
+      return {};
+    }
+  }
+
+  download(data, sendResponse) {
+    var self = this;
+    var originalUrl = data.originalUrl;
+    var blobUrl = data.blobUrl || originalUrl;
+    // The data may not be downloaded so we need just retry getting the pdf with
+    // the original url.
+    var originalUri = NetUtil.newURI(originalUrl);
+    var filename = data.filename;
+    if (
+      typeof filename !== "string" ||
+      (!/\.pdf$/i.test(filename) && !data.isAttachment)
+    ) {
+      filename = "document.pdf";
+    }
+    var blobUri = NetUtil.newURI(blobUrl);
+
+    // If the download was triggered from the ctrl/cmd+s or "Save Page As"
+    // launch the "Save As" dialog.
+    if (data.sourceEventType == "save") {
+      let actor = getActor(this.domWindow);
+      actor.sendAsyncMessage("PDFJS:Parent:saveURL", {
+        blobUrl,
+        filename,
+      });
+      return;
+    }
+
+    // The download is from the fallback bar or the download button, so trigger
+    // the open dialog to make it easier for users to save in the downloads
+    // folder or launch a different PDF viewer.
+    var extHelperAppSvc = Cc[
+      "@mozilla.org/uriloader/external-helper-app-service;1"
+    ].getService(Ci.nsIExternalHelperAppService);
+
+    var docIsPrivate = this.isInPrivateBrowsing();
+    var netChannel = NetUtil.newChannel({
+      uri: blobUri,
+      loadUsingSystemPrincipal: true,
+    });
+    if (
+      "nsIPrivateBrowsingChannel" in Ci &&
+      netChannel instanceof Ci.nsIPrivateBrowsingChannel
+    ) {
+      netChannel.setPrivate(docIsPrivate);
+    }
+    NetUtil.asyncFetch(netChannel, function(aInputStream, aResult) {
+      if (!Components.isSuccessCode(aResult)) {
+        if (sendResponse) {
+          sendResponse(true);
+        }
+        return;
+      }
+      // Create a nsIInputStreamChannel so we can set the url on the channel
+      // so the filename will be correct.
+      var channel = Cc[
+        "@mozilla.org/network/input-stream-channel;1"
+      ].createInstance(Ci.nsIInputStreamChannel);
+      channel.QueryInterface(Ci.nsIChannel);
+      try {
+        // contentDisposition/contentDispositionFilename is readonly before FF18
+        channel.contentDisposition = Ci.nsIChannel.DISPOSITION_ATTACHMENT;
+        if (self.contentDispositionFilename && !data.isAttachment) {
+          channel.contentDispositionFilename = self.contentDispositionFilename;
+        } else {
+          channel.contentDispositionFilename = filename;
+        }
+      } catch (e) {}
+      channel.setURI(originalUri);
+      channel.loadInfo = netChannel.loadInfo;
+      channel.contentStream = aInputStream;
+      if (
+        "nsIPrivateBrowsingChannel" in Ci &&
+        channel instanceof Ci.nsIPrivateBrowsingChannel
+      ) {
+        channel.setPrivate(docIsPrivate);
+      }
+
+      var listener = {
+        extListener: null,
+        onStartRequest(aRequest) {
+          var loadContext = self.domWindow.docShell.QueryInterface(
+            Ci.nsILoadContext
+          );
+          this.extListener = extHelperAppSvc.doContent(
+            data.isAttachment ? "application/octet-stream" : PDF_CONTENT_TYPE,
+            aRequest,
+            loadContext,
+            false
+          );
+          this.extListener.onStartRequest(aRequest);
+        },
+        onStopRequest(aRequest, aStatusCode) {
+          if (this.extListener) {
+            this.extListener.onStopRequest(aRequest, aStatusCode);
+          }
+          // Notify the content code we're done downloading.
+          if (sendResponse) {
+            sendResponse(false);
+          }
+        },
+        onDataAvailable(aRequest, aDataInputStream, aOffset, aCount) {
+          this.extListener.onDataAvailable(
+            aRequest,
+            aDataInputStream,
+            aOffset,
+            aCount
+          );
+        },
+      };
+
+      channel.asyncOpen(listener);
+    });
+  }
+
+  getLocale() {
+    return Services.locale.requestedLocale || "en-US";
+  }
+
+  getStrings(data) {
+    try {
+      // Lazy initialization of localizedStrings
+      if (!("localizedStrings" in this)) {
+        this.localizedStrings = getLocalizedStrings("viewer.properties");
+      }
+      var result = this.localizedStrings[data];
+      return JSON.stringify(result || null);
+    } catch (e) {
+      log("Unable to retrieve localized strings: " + e);
+      return "null";
+    }
+  }
+
+  supportsIntegratedFind() {
+    // Integrated find is only supported when we're not in a frame
+    return this.domWindow.windowGlobalChild.browsingContext.parent === null;
+  }
+
+  supportsDocumentFonts() {
+    var prefBrowser = getIntPref("browser.display.use_document_fonts", 1);
+    var prefGfx = getBoolPref("gfx.downloadable_fonts.enabled", true);
+    return !!prefBrowser && prefGfx;
+  }
+
+  supportedMouseWheelZoomModifierKeys() {
+    return {
+      ctrlKey: getIntPref("mousewheel.with_control.action", 3) === 3,
+      metaKey: getIntPref("mousewheel.with_meta.action", 1) === 3,
+    };
+  }
+
+  isInAutomation() {
+    return Cu.isInAutomation;
+  }
+
+  reportTelemetry(data) {
+    var probeInfo = JSON.parse(data);
+    switch (probeInfo.type) {
+      case "documentInfo":
+        if (!this.telemetryState.documentInfo) {
+          PdfJsTelemetry.onDocumentVersion(probeInfo.version);
+          PdfJsTelemetry.onDocumentGenerator(probeInfo.generator);
+          if (probeInfo.formType) {
+            PdfJsTelemetry.onForm(probeInfo.formType);
+          }
+          this.telemetryState.documentInfo = true;
+        }
+        break;
+      case "pageInfo":
+        if (!this.telemetryState.firstPageInfo) {
+          PdfJsTelemetry.onTimeToView(probeInfo.timestamp);
+          this.telemetryState.firstPageInfo = true;
+        }
+        break;
+      case "documentStats":
+        // documentStats can be called several times for one documents.
+        // if stream/font types are reported, trying not to submit the same
+        // enumeration value multiple times.
+        var documentStats = probeInfo.stats;
+        if (!documentStats || typeof documentStats !== "object") {
+          break;
+        }
+        var i,
+          streamTypes = documentStats.streamTypes,
+          key;
+        var STREAM_TYPE_ID_LIMIT = 20;
+        i = 0;
+        for (key in streamTypes) {
+          if (++i > STREAM_TYPE_ID_LIMIT) {
+            break;
+          }
+          if (!this.telemetryState.streamTypesUsed[key]) {
+            PdfJsTelemetry.onStreamType(key);
+            this.telemetryState.streamTypesUsed[key] = true;
+          }
+        }
+        var fontTypes = documentStats.fontTypes;
+        var FONT_TYPE_ID_LIMIT = 20;
+        i = 0;
+        for (key in fontTypes) {
+          if (++i > FONT_TYPE_ID_LIMIT) {
+            break;
+          }
+          if (!this.telemetryState.fontTypesUsed[key]) {
+            PdfJsTelemetry.onFontType(key);
+            this.telemetryState.fontTypesUsed[key] = true;
+          }
+        }
+        break;
+      case "print":
+        PdfJsTelemetry.onPrint();
+        break;
+      case "unsupportedFeature":
+        if (!this.telemetryState.fallbackErrorsReported[probeInfo.featureId]) {
+          PdfJsTelemetry.onFallbackError(probeInfo.featureId);
+          this.telemetryState.fallbackErrorsReported[
+            probeInfo.featureId
+          ] = true;
+        }
+        break;
+      case "tagged":
+        PdfJsTelemetry.onTagged(probeInfo.tagged);
+        break;
+    }
+  }
+
+  /**
+   * @param {Object} args - Object with `featureId` and `url` properties.
+   * @param {function} sendResponse - Callback function.
+   */
+  fallback(args, sendResponse) {
+    var featureId = args.featureId;
+
+    var domWindow = this.domWindow;
+    var strings = getLocalizedStrings("chrome.properties");
+    var message;
+    if (featureId === "forms") {
+      message = getLocalizedString(strings, "unsupported_feature_forms");
+    } else {
+      message = getLocalizedString(strings, "unsupported_feature");
+    }
+    PdfJsTelemetry.onFallbackShown(featureId);
+
+    // Request the display of a notification warning in the associated window
+    // when the renderer isn't sure a pdf displayed correctly.
+    let actor = getActor(domWindow);
+    if (actor) {
+      actor.sendAsyncMessage("PDFJS:Parent:displayWarning", {
+        message,
+        label: getLocalizedString(strings, "open_with_different_viewer"),
+        accessKey: getLocalizedString(
+          strings,
+          "open_with_different_viewer",
+          "accessKey"
+        ),
+      });
+
+      actor.fallbackCallback = sendResponse;
+    }
+  }
+
+  updateFindControlState(data) {
+    if (!this.supportsIntegratedFind()) {
+      return;
+    }
+    // Verify what we're sending to the findbar.
+    var result = data.result;
+    var findPrevious = data.findPrevious;
+    var findPreviousType = typeof findPrevious;
+    if (
+      typeof result !== "number" ||
+      result < 0 ||
+      result > 3 ||
+      (findPreviousType !== "undefined" && findPreviousType !== "boolean")
+    ) {
+      return;
+    }
+    // Allow the `matchesCount` property to be optional, and ensure that
+    // it's valid before including it in the data sent to the findbar.
+    let matchesCount = null;
+    if (isValidMatchesCount(data.matchesCount)) {
+      matchesCount = data.matchesCount;
+    }
+    // Same for the `rawQuery` property.
+    let rawQuery = null;
+    if (typeof data.rawQuery === "string") {
+      rawQuery = data.rawQuery;
+    }
+
+    let actor = getActor(this.domWindow);
+    actor?.sendAsyncMessage("PDFJS:Parent:updateControlState", {
+      result,
+      findPrevious,
+      matchesCount,
+      rawQuery,
+    });
+  }
+
+  updateFindMatchesCount(data) {
+    if (!this.supportsIntegratedFind()) {
+      return;
+    }
+    // Verify what we're sending to the findbar.
+    if (!isValidMatchesCount(data)) {
+      return;
+    }
+
+    let actor = getActor(this.domWindow);
+    actor?.sendAsyncMessage("PDFJS:Parent:updateMatchesCount", data);
+  }
+
+  setPreferences(prefs, sendResponse) {
+    var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + ".");
+    var numberOfPrefs = 0;
+    var prefValue, prefName;
+    for (var key in prefs) {
+      if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+        log(
+          "setPreferences - Exceeded the maximum number of preferences " +
+            "that is allowed to be set at once."
+        );
+        break;
+      } else if (!defaultBranch.getPrefType(key)) {
+        continue;
+      }
+      prefValue = prefs[key];
+      prefName = PREF_PREFIX + "." + key;
+      switch (typeof prefValue) {
+        case "boolean":
+          AsyncPrefs.set(prefName, prefValue);
+          break;
+        case "number":
+          AsyncPrefs.set(prefName, prefValue);
+          break;
+        case "string":
+          if (prefValue.length > MAX_STRING_PREF_LENGTH) {
+            log(
+              "setPreferences - Exceeded the maximum allowed length " +
+                "for a string preference."
+            );
+          } else {
+            AsyncPrefs.set(prefName, prefValue);
+          }
+          break;
+      }
+    }
+    if (sendResponse) {
+      sendResponse(true);
+    }
+  }
+
+  getPreferences(prefs, sendResponse) {
+    var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + ".");
+    var currentPrefs = {},
+      numberOfPrefs = 0;
+    var prefValue, prefName;
+    for (var key in prefs) {
+      if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+        log(
+          "getPreferences - Exceeded the maximum number of preferences " +
+            "that is allowed to be fetched at once."
+        );
+        break;
+      } else if (!defaultBranch.getPrefType(key)) {
+        continue;
+      }
+      prefValue = prefs[key];
+      prefName = PREF_PREFIX + "." + key;
+      switch (typeof prefValue) {
+        case "boolean":
+          currentPrefs[key] = getBoolPref(prefName, prefValue);
+          break;
+        case "number":
+          currentPrefs[key] = getIntPref(prefName, prefValue);
+          break;
+        case "string":
+          currentPrefs[key] = getStringPref(prefName, prefValue);
+          break;
+      }
+    }
+    let result = JSON.stringify(currentPrefs);
+    if (sendResponse) {
+      sendResponse(result);
+    }
+    return result;
+  }
+}
+
+/**
+ * This is for range requests.
+ */
+class RangedChromeActions extends ChromeActions {
+  constructor(
+    domWindow,
+    contentDispositionFilename,
+    originalRequest,
+    rangeEnabled,
+    streamingEnabled,
+    dataListener
+  ) {
+    super(domWindow, contentDispositionFilename);
+    this.dataListener = dataListener;
+    this.originalRequest = originalRequest;
+    this.rangeEnabled = rangeEnabled;
+    this.streamingEnabled = streamingEnabled;
+
+    this.pdfUrl = originalRequest.URI.spec;
+    this.contentLength = originalRequest.contentLength;
+
+    // Pass all the headers from the original request through
+    var httpHeaderVisitor = {
+      headers: {},
+      visitHeader(aHeader, aValue) {
+        if (aHeader === "Range") {
+          // When loading the PDF from cache, firefox seems to set the Range
+          // request header to fetch only the unfetched portions of the file
+          // (e.g. 'Range: bytes=1024-'). However, we want to set this header
+          // manually to fetch the PDF in chunks.
+          return;
+        }
+        this.headers[aHeader] = aValue;
+      },
+    };
+    if (originalRequest.visitRequestHeaders) {
+      originalRequest.visitRequestHeaders(httpHeaderVisitor);
+    }
+
+    var self = this;
+    var xhr_onreadystatechange = function xhr_onreadystatechange() {
+      if (this.readyState === 1) {
+        // LOADING
+        var netChannel = this.channel;
+        // override this XMLHttpRequest's OriginAttributes with our cached parent window's
+        // OriginAttributes, as we are currently running under the SystemPrincipal
+        this.setOriginAttributes(self.getWindowOriginAttributes());
+        if (
+          "nsIPrivateBrowsingChannel" in Ci &&
+          netChannel instanceof Ci.nsIPrivateBrowsingChannel
+        ) {
+          var docIsPrivate = self.isInPrivateBrowsing();
+          netChannel.setPrivate(docIsPrivate);
+        }
+      }
+    };
+    var getXhr = function getXhr() {
+      var xhr = new XMLHttpRequest();
+      xhr.addEventListener("readystatechange", xhr_onreadystatechange);
+      return xhr;
+    };
+
+    this.networkManager = new NetworkManager(this.pdfUrl, {
+      httpHeaders: httpHeaderVisitor.headers,
+      getXhr,
+    });
+
+    // If we are in range request mode, this means we manually issued xhr
+    // requests, which we need to abort when we leave the page
+    domWindow.addEventListener("unload", function unload(e) {
+      domWindow.removeEventListener(e.type, unload);
+      self.abortLoading();
+    });
+  }
+
+  initPassiveLoading() {
+    let data, done;
+    if (!this.streamingEnabled) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+      data = this.dataListener.readData();
+      done = this.dataListener.isDone;
+      this.dataListener = null;
+    } else {
+      data = this.dataListener.readData();
+      done = this.dataListener.isDone;
+
+      this.dataListener.onprogress = (loaded, total) => {
+        this.domWindow.postMessage(
+          {
+            pdfjsLoadAction: "progressiveRead",
+            loaded,
+            total,
+            chunk: this.dataListener.readData(),
+          },
+          PDF_VIEWER_ORIGIN
+        );
+      };
+      this.dataListener.oncomplete = () => {
+        if (!done && this.dataListener.isDone) {
+          this.domWindow.postMessage(
+            {
+              pdfjsLoadAction: "progressiveDone",
+            },
+            PDF_VIEWER_ORIGIN
+          );
+        }
+        this.dataListener = null;
+      };
+    }
+
+    this.domWindow.postMessage(
+      {
+        pdfjsLoadAction: "supportsRangedLoading",
+        rangeEnabled: this.rangeEnabled,
+        streamingEnabled: this.streamingEnabled,
+        pdfUrl: this.pdfUrl,
+        length: this.contentLength,
+        data,
+        done,
+      },
+      PDF_VIEWER_ORIGIN
+    );
+
+    return true;
+  }
+
+  requestDataRange(args) {
+    if (!this.rangeEnabled) {
+      return;
+    }
+
+    var begin = args.begin;
+    var end = args.end;
+    var domWindow = this.domWindow;
+    // TODO(mack): Support error handler. We're not currently not handling
+    // errors from chrome code for non-range requests, so this doesn't
+    // seem high-pri
+    this.networkManager.requestRange(begin, end, {
+      onDone: function RangedChromeActions_onDone(aArgs) {
+        domWindow.postMessage(
+          {
+            pdfjsLoadAction: "range",
+            begin: aArgs.begin,
+            chunk: aArgs.chunk,
+          },
+          PDF_VIEWER_ORIGIN
+        );
+      },
+      onProgress: function RangedChromeActions_onProgress(evt) {
+        domWindow.postMessage(
+          {
+            pdfjsLoadAction: "rangeProgress",
+            loaded: evt.loaded,
+          },
+          PDF_VIEWER_ORIGIN
+        );
+      },
+    });
+  }
+
+  abortLoading() {
+    this.networkManager.abortAllRequests();
+    if (this.originalRequest) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+    }
+    this.dataListener = null;
+  }
+}
+
+/**
+ * This is for a single network stream.
+ */
+class StandardChromeActions extends ChromeActions {
+  constructor(
+    domWindow,
+    contentDispositionFilename,
+    originalRequest,
+    dataListener
+  ) {
+    super(domWindow, contentDispositionFilename);
+    this.originalRequest = originalRequest;
+    this.dataListener = dataListener;
+  }
+
+  initPassiveLoading() {
+    if (!this.dataListener) {
+      return false;
+    }
+
+    this.dataListener.onprogress = (loaded, total) => {
+      this.domWindow.postMessage(
+        {
+          pdfjsLoadAction: "progress",
+          loaded,
+          total,
+        },
+        PDF_VIEWER_ORIGIN
+      );
+    };
+
+    this.dataListener.oncomplete = (data, errorCode) => {
+      this.domWindow.postMessage(
+        {
+          pdfjsLoadAction: "complete",
+          data,
+          errorCode,
+        },
+        PDF_VIEWER_ORIGIN
+      );
+
+      this.dataListener = null;
+      this.originalRequest = null;
+    };
+
+    return true;
+  }
+
+  abortLoading() {
+    if (this.originalRequest) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+    }
+    this.dataListener = null;
+  }
+}
+
+/**
+ * Event listener to trigger chrome privileged code.
+ */
+class RequestListener {
+  constructor(actions) {
+    this.actions = actions;
+  }
+
+  // Receive an event and synchronously or asynchronously responds.
+  receive(event) {
+    var message = event.target;
+    var doc = message.ownerDocument;
+    var action = event.detail.action;
+    var data = event.detail.data;
+    var sync = event.detail.sync;
+    var actions = this.actions;
+    if (!(action in actions)) {
+      log("Unknown action: " + action);
+      return;
+    }
+    var response;
+    if (sync) {
+      response = actions[action].call(this.actions, data);
+      event.detail.response = Cu.cloneInto(response, doc.defaultView);
+    } else {
+      if (!event.detail.responseExpected) {
+        doc.documentElement.removeChild(message);
+        response = null;
+      } else {
+        response = function sendResponse(aResponse) {
+          try {
+            var listener = doc.createEvent("CustomEvent");
+            let detail = Cu.cloneInto({ response: aResponse }, doc.defaultView);
+            listener.initCustomEvent("pdf.js.response", true, false, detail);
+            return message.dispatchEvent(listener);
+          } catch (e) {
+            // doc is no longer accessible because the requestor is already
+            // gone. unloaded content cannot receive the response anyway.
+            return false;
+          }
+        };
+      }
+      actions[action].call(this.actions, data, response);
+    }
+  }
+}
+
+function PdfStreamConverter() {}
+
+PdfStreamConverter.prototype = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIStreamConverter",
+    "nsIStreamListener",
+    "nsIRequestObserver",
+  ]),
+
+  /*
+   * This component works as such:
+   * 1. asyncConvertData stores the listener
+   * 2. onStartRequest creates a new channel, streams the viewer
+   * 3. If range requests are supported:
+   *      3.1. Leave the request open until the viewer is ready to switch to
+   *           range requests.
+   *
+   *    If range rquests are not supported:
+   *      3.1. Read the stream as it's loaded in onDataAvailable to send
+   *           to the viewer
+   *
+   * The convert function just returns the stream, it's just the synchronous
+   * version of asyncConvertData.
+   */
+
+  // nsIStreamConverter::convert
+  convert(aFromStream, aFromType, aToType, aCtxt) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+
+  // nsIStreamConverter::asyncConvertData
+  asyncConvertData(aFromType, aToType, aListener, aCtxt) {
+    if (aCtxt && aCtxt instanceof Ci.nsIChannel) {
+      aCtxt.QueryInterface(Ci.nsIChannel);
+    }
+    // We need to check if we're supposed to convert here, because not all
+    // asyncConvertData consumers will call getConvertedType first:
+    this.getConvertedType(aFromType, aCtxt);
+
+    // Store the listener passed to us
+    this.listener = aListener;
+  },
+
+  _usableHandler(handlerInfo) {
+    let { preferredApplicationHandler } = handlerInfo;
+    if (
+      !preferredApplicationHandler ||
+      !(preferredApplicationHandler instanceof Ci.nsILocalHandlerApp)
+    ) {
+      return false;
+    }
+    preferredApplicationHandler.QueryInterface(Ci.nsILocalHandlerApp);
+    // We have an app, grab the executable
+    let { executable } = preferredApplicationHandler;
+    if (!executable) {
+      return false;
+    }
+    return !executable.equals(gOurBinary);
+  },
+
+  /*
+   * Check if the user wants to use PDF.js. Returns true if PDF.js should
+   * handle PDFs, and false if not. Will always return true on non-parent
+   * processes.
+   *
+   * If the user has selected to open PDFs with a helper app, and we are that
+   * helper app, or if the user has selected the OS default, and we are that
+   * OS default, reset the preference back to pdf.js .
+   *
+   */
+  _validateAndMaybeUpdatePDFPrefs() {
+    let { processType, PROCESS_TYPE_DEFAULT } = Services.appinfo;
+    // If we're not in the parent, or are the default, then just say yes.
+    if (processType != PROCESS_TYPE_DEFAULT || PdfJs.cachedIsDefault()) {
+      return true;
+    }
+
+    // OK, PDF.js might not be the default. Find out if we've misled the user
+    // into making Firefox an external handler or if we're the OS default and
+    // Firefox is set to use the OS default:
+    let mime = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, "pdf");
+    // The above might throw errors. We're deliberately letting those bubble
+    // back up, where they'll tell the stream converter not to use us.
+
+    if (!mime) {
+      // This shouldn't happen, but we can't fix what isn't there. Assume
+      // we're OK to handle with PDF.js
+      return true;
+    }
+
+    const { saveToDisk, useHelperApp, useSystemDefault } = Ci.nsIHandlerInfo;
+    let { preferredAction, alwaysAskBeforeHandling } = mime;
+    // If the user has indicated they want to be asked or want to save to
+    // disk, we shouldn't render inline immediately:
+    if (alwaysAskBeforeHandling || preferredAction == saveToDisk) {
+      return false;
+    }
+    // If we have usable helper app info, don't use PDF.js
+    if (preferredAction == useHelperApp && this._usableHandler(mime)) {
+      return false;
+    }
+    // If we want the OS default and that's not Firefox, don't use PDF.js
+    if (preferredAction == useSystemDefault && !mime.isCurrentAppOSDefault()) {
+      return false;
+    }
+    // Log that we're doing this to help debug issues if people end up being
+    // surprised by this behaviour.
+    Cu.reportError("Found unusable PDF preferences. Fixing back to PDF.js");
+
+    mime.preferredAction = Ci.nsIHandlerInfo.handleInternally;
+    mime.alwaysAskBeforeHandling = false;
+    Svc.handlers.store(mime);
+    return true;
+  },
+
+  getConvertedType(aFromType, aChannel) {
+    const HTML = "text/html";
+    let channelURI = aChannel?.URI;
+    // We can be invoked for application/octet-stream; check if we want the
+    // channel first:
+    if (aFromType != "application/pdf") {
+      let ext = channelURI?.QueryInterface(Ci.nsIURL).fileExtension;
+      let isPDF = ext.toLowerCase() == "pdf";
+      let browsingContext = aChannel?.loadInfo.targetBrowsingContext;
+      let toplevelOctetStream =
+        aFromType == "application/octet-stream" &&
+        browsingContext &&
+        !browsingContext.parent;
+      if (
+        !isPDF ||
+        !toplevelOctetStream ||
+        !getBoolPref(PREF_PREFIX + ".handleOctetStream", false)
+      ) {
+        throw new Components.Exception(
+          "Ignore PDF.js for this download.",
+          Cr.NS_ERROR_FAILURE
+        );
+      }
+      // fall through, this appears to be a pdf.
+    }
+
+    if (this._validateAndMaybeUpdatePDFPrefs()) {
+      return HTML;
+    }
+    // Hm, so normally, no pdfjs. However... if this is a file: channel loaded
+    // with system principal, load it anyway:
+    if (channelURI?.schemeIs("file")) {
+      let triggeringPrincipal = aChannel.loadInfo?.triggeringPrincipal;
+      if (triggeringPrincipal?.isSystemPrincipal) {
+        return HTML;
+      }
+    }
+
+    throw new Components.Exception("Can't use PDF.js", Cr.NS_ERROR_FAILURE);
+  },
+
+  // nsIStreamListener::onDataAvailable
+  onDataAvailable(aRequest, aInputStream, aOffset, aCount) {
+    if (!this.dataListener) {
+      return;
+    }
+
+    var binaryStream = this.binaryStream;
+    binaryStream.setInputStream(aInputStream);
+    let chunk = new ArrayBuffer(aCount);
+    binaryStream.readArrayBuffer(aCount, chunk);
+    this.dataListener.append(new Uint8Array(chunk));
+  },
+
+  // nsIRequestObserver::onStartRequest
+  onStartRequest(aRequest) {
+    // Setup the request so we can use it below.
+    var isHttpRequest = false;
+    try {
+      aRequest.QueryInterface(Ci.nsIHttpChannel);
+      isHttpRequest = true;
+    } catch (e) {}
+
+    var rangeRequest = false;
+    var streamRequest = false;
+    if (isHttpRequest) {
+      var contentEncoding = "identity";
+      try {
+        contentEncoding = aRequest.getResponseHeader("Content-Encoding");
+      } catch (e) {}
+
+      var acceptRanges;
+      try {
+        acceptRanges = aRequest.getResponseHeader("Accept-Ranges");
+      } catch (e) {}
+
+      var hash = aRequest.URI.ref;
+      var isPDFBugEnabled = getBoolPref(PREF_PREFIX + ".pdfBugEnabled", false);
+      rangeRequest =
+        contentEncoding === "identity" &&
+        acceptRanges === "bytes" &&
+        aRequest.contentLength >= 0 &&
+        !getBoolPref(PREF_PREFIX + ".disableRange", false) &&
+        (!isPDFBugEnabled || !hash.toLowerCase().includes("disablerange=true"));
+      streamRequest =
+        contentEncoding === "identity" &&
+        aRequest.contentLength >= 0 &&
+        !getBoolPref(PREF_PREFIX + ".disableStream", false) &&
+        (!isPDFBugEnabled ||
+          !hash.toLowerCase().includes("disablestream=true"));
+    }
+
+    aRequest.QueryInterface(Ci.nsIChannel);
+
+    aRequest.QueryInterface(Ci.nsIWritablePropertyBag);
+
+    var contentDispositionFilename;
+    try {
+      contentDispositionFilename = aRequest.contentDispositionFilename;
+    } catch (e) {}
+
+    // Change the content type so we don't get stuck in a loop.
+    aRequest.setProperty("contentType", aRequest.contentType);
+    aRequest.contentType = "text/html";
+    if (isHttpRequest) {
+      // We trust PDF viewer, using no CSP
+      aRequest.setResponseHeader("Content-Security-Policy", "", false);
+      aRequest.setResponseHeader(
+        "Content-Security-Policy-Report-Only",
+        "",
+        false
+      );
+      // The viewer does not need to handle HTTP Refresh header.
+      aRequest.setResponseHeader("Refresh", "", false);
+    }
+
+    PdfJsTelemetry.onViewerIsUsed();
+    PdfJsTelemetry.onDocumentSize(aRequest.contentLength);
+
+    // Creating storage for PDF data
+    var contentLength = aRequest.contentLength;
+    this.dataListener = new PdfDataListener(contentLength);
+    this.binaryStream = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
+      Ci.nsIBinaryInputStream
+    );
+
+    // Create a new channel that is viewer loaded as a resource.
+    var channel = NetUtil.newChannel({
+      uri: PDF_VIEWER_WEB_PAGE,
+      loadUsingSystemPrincipal: true,
+    });
+
+    var listener = this.listener;
+    var dataListener = this.dataListener;
+    // Proxy all the request observer calls, when it gets to onStopRequest
+    // we can get the dom window.  We also intentionally pass on the original
+    // request(aRequest) below so we don't overwrite the original channel and
+    // trigger an assertion.
+    var proxy = {
+      onStartRequest(request) {
+        listener.onStartRequest(aRequest);
+      },
+      onDataAvailable(request, inputStream, offset, count) {
+        listener.onDataAvailable(aRequest, inputStream, offset, count);
+      },
+      onStopRequest(request, statusCode) {
+        var domWindow = getDOMWindow(channel, resourcePrincipal);
+        if (!Components.isSuccessCode(statusCode) || !domWindow) {
+          // The request may have been aborted and the document may have been
+          // replaced with something that is not PDF.js, abort attaching.
+          listener.onStopRequest(aRequest, statusCode);
+          return;
+        }
+        var actions;
+        if (rangeRequest || streamRequest) {
+          actions = new RangedChromeActions(
+            domWindow,
+            contentDispositionFilename,
+            aRequest,
+            rangeRequest,
+            streamRequest,
+            dataListener
+          );
+        } else {
+          actions = new StandardChromeActions(
+            domWindow,
+            contentDispositionFilename,
+            aRequest,
+            dataListener
+          );
+        }
+        var requestListener = new RequestListener(actions);
+        domWindow.document.addEventListener(
+          PDFJS_EVENT_ID,
+          function(event) {
+            requestListener.receive(event);
+          },
+          false,
+          true
+        );
+
+        let actor = getActor(domWindow);
+        actor?.init(actions.supportsIntegratedFind());
+
+        listener.onStopRequest(aRequest, statusCode);
+
+        if (domWindow.windowGlobalChild.browsingContext.parent) {
+          // This will need to be changed when fission supports object/embed (bug 1614524)
+          var isObjectEmbed = domWindow.frameElement
+            ? domWindow.frameElement.tagName == "OBJECT" ||
+              domWindow.frameElement.tagName == "EMBED"
+            : false;
+          PdfJsTelemetry.onEmbed(isObjectEmbed);
+        }
+      },
+    };
+
+    // Keep the URL the same so the browser sees it as the same.
+    channel.originalURI = aRequest.URI;
+    channel.loadGroup = aRequest.loadGroup;
+    channel.loadInfo.originAttributes = aRequest.loadInfo.originAttributes;
+
+    // We can use the resource principal when data is fetched by the chrome,
+    // e.g. useful for NoScript. Make make sure we reuse the origin attributes
+    // from the request channel to keep isolation consistent.
+    var uri = NetUtil.newURI(PDF_VIEWER_WEB_PAGE);
+    var resourcePrincipal = Services.scriptSecurityManager.createContentPrincipal(
+      uri,
+      aRequest.loadInfo.originAttributes
+    );
+    // Remember the principal we would have had before we mess with it.
+    let originalPrincipal = Services.scriptSecurityManager.getChannelResultPrincipal(
+      aRequest
+    );
+    aRequest.owner = resourcePrincipal;
+    aRequest.setProperty("noPDFJSPrincipal", originalPrincipal);
+
+    channel.asyncOpen(proxy);
+  },
+
+  // nsIRequestObserver::onStopRequest
+  onStopRequest(aRequest, aStatusCode) {
+    if (!this.dataListener) {
+      // Do nothing
+      return;
+    }
+
+    if (Components.isSuccessCode(aStatusCode)) {
+      this.dataListener.finish();
+    } else {
+      this.dataListener.error(aStatusCode);
+    }
+    delete this.dataListener;
+    delete this.binaryStream;
+  },
+};
diff --git a/toolkit/components/pdfjs/content/PdfjsChild.jsm b/toolkit/components/pdfjs/content/PdfjsChild.jsm
new file mode 100644
index 0000000000..a6f9469057
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfjsChild.jsm
@@ -0,0 +1,58 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["PdfjsChild"];
+
+class PdfjsChild extends JSWindowActorChild {
+  init(supportsFind) {
+    if (supportsFind) {
+      this.sendAsyncMessage("PDFJS:Parent:addEventListener");
+    }
+  }
+
+  dispatchEvent(type, detail) {
+    const contentWindow = this.contentWindow;
+    const forward = contentWindow.document.createEvent("CustomEvent");
+    forward.initCustomEvent(type, true, true, detail);
+    contentWindow.dispatchEvent(forward);
+  }
+
+  receiveMessage(msg) {
+    switch (msg.name) {
+      case "PDFJS:Child:handleEvent": {
+        let detail = Cu.cloneInto(msg.data.detail, this.contentWindow);
+        this.dispatchEvent(msg.data.type, detail);
+        break;
+      }
+
+      case "PDFJS:ZoomIn":
+      case "PDFJS:ZoomOut":
+      case "PDFJS:ZoomReset":
+      case "PDFJS:Save": {
+        const type = msg.name.split("PDFJS:")[1].toLowerCase();
+        this.dispatchEvent(type, null);
+        break;
+      }
+
+      case "PDFJS:Child:fallbackDownload":
+        if (this.fallbackCallback) {
+          this.fallbackCallback(msg.data.download);
+        }
+        break;
+    }
+  }
+}
diff --git a/toolkit/components/pdfjs/content/PdfjsParent.jsm b/toolkit/components/pdfjs/content/PdfjsParent.jsm
new file mode 100644
index 0000000000..6da6a50e4d
--- /dev/null
+++ b/toolkit/components/pdfjs/content/PdfjsParent.jsm
@@ -0,0 +1,318 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["PdfjsParent"];
+
+const { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "SetClipboardSearchString",
+  "resource://gre/modules/Finder.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "PrivateBrowsingUtils",
+  "resource://gre/modules/PrivateBrowsingUtils.jsm"
+);
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(
+  Svc,
+  "mime",
+  "@mozilla.org/mime;1",
+  "nsIMIMEService"
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "matchesCountLimit",
+  "accessibility.typeaheadfind.matchesCountLimit"
+);
+
+let gFindTypes = [
+  "find",
+  "findagain",
+  "findhighlightallchange",
+  "findcasesensitivitychange",
+  "findbarclose",
+];
+
+class PdfjsParent extends JSWindowActorParent {
+  constructor() {
+    super();
+    this._boundToFindbar = null;
+    this._findFailedString = null;
+  }
+
+  didDestroy() {
+    if (this._boundToFindbar) {
+      this._removeEventListener();
+    }
+  }
+
+  receiveMessage(aMsg) {
+    switch (aMsg.name) {
+      case "PDFJS:Parent:displayWarning":
+        this._displayWarning(aMsg);
+        break;
+
+      case "PDFJS:Parent:updateControlState":
+        return this._updateControlState(aMsg);
+      case "PDFJS:Parent:updateMatchesCount":
+        return this._updateMatchesCount(aMsg);
+      case "PDFJS:Parent:addEventListener":
+        return this._addEventListener();
+      case "PDFJS:Parent:saveURL":
+        return this._saveURL(aMsg);
+    }
+    return undefined;
+  }
+
+  /*
+   * Internal
+   */
+
+  get browser() {
+    return this.browsingContext.top.embedderElement;
+  }
+
+  _saveURL(aMsg) {
+    const data = aMsg.data;
+    this.browser.ownerGlobal.saveURL(
+      data.blobUrl /* aURL */,
+      data.filename /* aFileName */,
+      null /* aFilePickerTitleKey */,
+      true /* aShouldBypassCache */,
+      false /* aSkipPrompt */,
+      null /* aReferrerInfo */,
+      null /* aCookieJarSettings*/,
+      null /* aSourceDocument */,
+      PrivateBrowsingUtils.isBrowserPrivate(
+        this.browser
+      ) /* aIsContentWindowPrivate */,
+      Services.scriptSecurityManager.getSystemPrincipal() /* aPrincipal */
+    );
+  }
+
+  _updateControlState(aMsg) {
+    let data = aMsg.data;
+    let browser = this.browser;
+    let tabbrowser = browser.getTabBrowser();
+    let tab = tabbrowser.getTabForBrowser(browser);
+    tabbrowser.getFindBar(tab).then(fb => {
+      if (!fb) {
+        // The tab or window closed.
+        return;
+      }
+      fb.updateControlState(data.result, data.findPrevious);
+
+      if (
+        data.result === Ci.nsITypeAheadFind.FIND_FOUND ||
+        data.result === Ci.nsITypeAheadFind.FIND_WRAPPED ||
+        (data.result === Ci.nsITypeAheadFind.FIND_PENDING &&
+          !this._findFailedString)
+      ) {
+        this._findFailedString = null;
+        SetClipboardSearchString(data.rawQuery);
+      } else if (!this._findFailedString) {
+        this._findFailedString = data.rawQuery;
+        SetClipboardSearchString(data.rawQuery);
+      }
+
+      const matchesCount = this._requestMatchesCount(data.matchesCount);
+      fb.onMatchesCountResult(matchesCount);
+    });
+  }
+
+  _updateMatchesCount(aMsg) {
+    let data = aMsg.data;
+    let browser = this.browser;
+    let tabbrowser = browser.getTabBrowser();
+    let tab = tabbrowser.getTabForBrowser(browser);
+    tabbrowser.getFindBar(tab).then(fb => {
+      if (!fb) {
+        // The tab or window closed.
+        return;
+      }
+      const matchesCount = this._requestMatchesCount(data);
+      fb.onMatchesCountResult(matchesCount);
+    });
+  }
+
+  _requestMatchesCount(data) {
+    if (!data) {
+      return { current: 0, total: 0 };
+    }
+    let result = {
+      current: data.current,
+      total: data.total,
+      limit: typeof matchesCountLimit === "number" ? matchesCountLimit : 0,
+    };
+    if (result.total > result.limit) {
+      result.total = -1;
+    }
+    return result;
+  }
+
+  handleEvent(aEvent) {
+    const type = aEvent.type;
+    // Handle the tab find initialized event specially:
+    if (type == "TabFindInitialized") {
+      let browser = aEvent.target.linkedBrowser;
+      this._hookupEventListeners(browser);
+      aEvent.target.removeEventListener(type, this);
+      return;
+    }
+
+    // To avoid forwarding the message as a CPOW, create a structured cloneable
+    // version of the event for both performance, and ease of usage, reasons.
+    let detail = null;
+    if (type !== "findbarclose") {
+      detail = {
+        query: aEvent.detail.query,
+        caseSensitive: aEvent.detail.caseSensitive,
+        entireWord: aEvent.detail.entireWord,
+        highlightAll: aEvent.detail.highlightAll,
+        findPrevious: aEvent.detail.findPrevious,
+      };
+    }
+
+    let browser = aEvent.currentTarget.browser;
+    if (!this._boundToFindbar) {
+      throw new Error(
+        "FindEventManager was not bound for the current browser."
+      );
+    }
+    browser.sendMessageToActor(
+      "PDFJS:Child:handleEvent",
+      { type, detail },
+      "Pdfjs"
+    );
+    aEvent.preventDefault();
+  }
+
+  _addEventListener() {
+    let browser = this.browser;
+    if (this._boundToFindbar) {
+      throw new Error(
+        "FindEventManager was bound 2nd time without unbinding it first."
+      );
+    }
+
+    this._hookupEventListeners(browser);
+  }
+
+  /**
+   * Either hook up all the find event listeners if a findbar exists,
+   * or listen for a find bar being created and hook up event listeners
+   * when it does get created.
+   */
+  _hookupEventListeners(aBrowser) {
+    let tabbrowser = aBrowser.getTabBrowser();
+    let tab = tabbrowser.getTabForBrowser(aBrowser);
+    let findbar = tabbrowser.getCachedFindBar(tab);
+    if (findbar) {
+      // And we need to start listening to find events.
+      for (var i = 0; i < gFindTypes.length; i++) {
+        var type = gFindTypes[i];
+        findbar.addEventListener(type, this, true);
+      }
+      this._boundToFindbar = findbar;
+    } else {
+      tab.addEventListener("TabFindInitialized", this);
+    }
+    return !!findbar;
+  }
+
+  _removeEventListener() {
+    // make sure the listener has been removed.
+    let findbar = this._boundToFindbar;
+    if (findbar) {
+      // No reason to listen to find events any longer.
+      for (var i = 0; i < gFindTypes.length; i++) {
+        var type = gFindTypes[i];
+        findbar.removeEventListener(type, this, true);
+      }
+    }
+
+    this._boundToFindbar = null;
+  }
+
+  /*
+   * Display a notification warning when the renderer isn't sure
+   * a pdf displayed correctly.
+   */
+  _displayWarning(aMsg) {
+    let data = aMsg.data;
+    let browser = this.browser;
+
+    let tabbrowser = browser.getTabBrowser();
+    let notificationBox = tabbrowser.getNotificationBox(browser);
+
+    // Flag so we don't send the message twice, since if the user clicks
+    // "open with different viewer" both the button callback and
+    // eventCallback will be called.
+    let messageSent = false;
+    let sendMessage = download => {
+      // Don't send a response again if we already responded when the button was
+      // clicked.
+      if (messageSent) {
+        return;
+      }
+      try {
+        this.sendAsyncMessage("PDFJS:Child:fallbackDownload", { download });
+        messageSent = true;
+      } catch (ex) {
+        // Ignore any exception if it is related to the child
+        // getting destroyed before the message can be sent.
+        if (!/JSWindowActorParent cannot send at the moment/.test(ex.message)) {
+          throw ex;
+        }
+      }
+    };
+    let buttons = [
+      {
+        label: data.label,
+        accessKey: data.accessKey,
+        callback() {
+          sendMessage(true);
+        },
+      },
+    ];
+    notificationBox.appendNotification(
+      data.message,
+      "pdfjs-fallback",
+      null,
+      notificationBox.PRIORITY_INFO_MEDIUM,
+      buttons,
+      function eventsCallback(eventType) {
+        // Currently there is only one event "removed" but if there are any other
+        // added in the future we still only care about removed at the moment.
+        if (eventType !== "removed") {
+          return;
+        }
+        sendMessage(false);
+      }
+    );
+  }
+}
diff --git a/toolkit/components/pdfjs/content/build/pdf.js b/toolkit/components/pdfjs/content/build/pdf.js
new file mode 100644
index 0000000000..ca2d2cafd3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/build/pdf.js
@@ -0,0 +1,11686 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("pdfjs-dist/build/pdf", [], factory);
+	else if(typeof exports === 'object')
+		exports["pdfjs-dist/build/pdf"] = factory();
+	else
+		root["pdfjs-dist/build/pdf"] = root.pdfjsLib = factory();
+})(this, function() {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "addLinkAttributes", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.addLinkAttributes;
+  }
+}));
+Object.defineProperty(exports, "getFilenameFromUrl", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.getFilenameFromUrl;
+  }
+}));
+Object.defineProperty(exports, "LinkTarget", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.LinkTarget;
+  }
+}));
+Object.defineProperty(exports, "loadScript", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.loadScript;
+  }
+}));
+Object.defineProperty(exports, "PDFDateString", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.PDFDateString;
+  }
+}));
+Object.defineProperty(exports, "RenderingCancelledException", ({
+  enumerable: true,
+  get: function () {
+    return _display_utils.RenderingCancelledException;
+  }
+}));
+Object.defineProperty(exports, "build", ({
+  enumerable: true,
+  get: function () {
+    return _api.build;
+  }
+}));
+Object.defineProperty(exports, "getDocument", ({
+  enumerable: true,
+  get: function () {
+    return _api.getDocument;
+  }
+}));
+Object.defineProperty(exports, "LoopbackPort", ({
+  enumerable: true,
+  get: function () {
+    return _api.LoopbackPort;
+  }
+}));
+Object.defineProperty(exports, "PDFDataRangeTransport", ({
+  enumerable: true,
+  get: function () {
+    return _api.PDFDataRangeTransport;
+  }
+}));
+Object.defineProperty(exports, "PDFWorker", ({
+  enumerable: true,
+  get: function () {
+    return _api.PDFWorker;
+  }
+}));
+Object.defineProperty(exports, "version", ({
+  enumerable: true,
+  get: function () {
+    return _api.version;
+  }
+}));
+Object.defineProperty(exports, "CMapCompressionType", ({
+  enumerable: true,
+  get: function () {
+    return _util.CMapCompressionType;
+  }
+}));
+Object.defineProperty(exports, "createObjectURL", ({
+  enumerable: true,
+  get: function () {
+    return _util.createObjectURL;
+  }
+}));
+Object.defineProperty(exports, "createPromiseCapability", ({
+  enumerable: true,
+  get: function () {
+    return _util.createPromiseCapability;
+  }
+}));
+Object.defineProperty(exports, "createValidAbsoluteUrl", ({
+  enumerable: true,
+  get: function () {
+    return _util.createValidAbsoluteUrl;
+  }
+}));
+Object.defineProperty(exports, "InvalidPDFException", ({
+  enumerable: true,
+  get: function () {
+    return _util.InvalidPDFException;
+  }
+}));
+Object.defineProperty(exports, "MissingPDFException", ({
+  enumerable: true,
+  get: function () {
+    return _util.MissingPDFException;
+  }
+}));
+Object.defineProperty(exports, "OPS", ({
+  enumerable: true,
+  get: function () {
+    return _util.OPS;
+  }
+}));
+Object.defineProperty(exports, "PasswordResponses", ({
+  enumerable: true,
+  get: function () {
+    return _util.PasswordResponses;
+  }
+}));
+Object.defineProperty(exports, "PermissionFlag", ({
+  enumerable: true,
+  get: function () {
+    return _util.PermissionFlag;
+  }
+}));
+Object.defineProperty(exports, "removeNullCharacters", ({
+  enumerable: true,
+  get: function () {
+    return _util.removeNullCharacters;
+  }
+}));
+Object.defineProperty(exports, "shadow", ({
+  enumerable: true,
+  get: function () {
+    return _util.shadow;
+  }
+}));
+Object.defineProperty(exports, "UnexpectedResponseException", ({
+  enumerable: true,
+  get: function () {
+    return _util.UnexpectedResponseException;
+  }
+}));
+Object.defineProperty(exports, "UNSUPPORTED_FEATURES", ({
+  enumerable: true,
+  get: function () {
+    return _util.UNSUPPORTED_FEATURES;
+  }
+}));
+Object.defineProperty(exports, "Util", ({
+  enumerable: true,
+  get: function () {
+    return _util.Util;
+  }
+}));
+Object.defineProperty(exports, "VerbosityLevel", ({
+  enumerable: true,
+  get: function () {
+    return _util.VerbosityLevel;
+  }
+}));
+Object.defineProperty(exports, "AnnotationLayer", ({
+  enumerable: true,
+  get: function () {
+    return _annotation_layer.AnnotationLayer;
+  }
+}));
+Object.defineProperty(exports, "apiCompatibilityParams", ({
+  enumerable: true,
+  get: function () {
+    return _api_compatibility.apiCompatibilityParams;
+  }
+}));
+Object.defineProperty(exports, "GlobalWorkerOptions", ({
+  enumerable: true,
+  get: function () {
+    return _worker_options.GlobalWorkerOptions;
+  }
+}));
+Object.defineProperty(exports, "renderTextLayer", ({
+  enumerable: true,
+  get: function () {
+    return _text_layer.renderTextLayer;
+  }
+}));
+Object.defineProperty(exports, "SVGGraphics", ({
+  enumerable: true,
+  get: function () {
+    return _svg.SVGGraphics;
+  }
+}));
+
+var _display_utils = __w_pdfjs_require__(1);
+
+var _api = __w_pdfjs_require__(5);
+
+var _util = __w_pdfjs_require__(2);
+
+var _annotation_layer = __w_pdfjs_require__(19);
+
+var _api_compatibility = __w_pdfjs_require__(9);
+
+var _worker_options = __w_pdfjs_require__(12);
+
+var _text_layer = __w_pdfjs_require__(21);
+
+var _svg = __w_pdfjs_require__(22);
+
+const pdfjsVersion = '2.7.510';
+const pdfjsBuild = '631bada0d';
+;
+
+/***/ }),
+/* 1 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.addLinkAttributes = addLinkAttributes;
+exports.deprecated = deprecated;
+exports.getFilenameFromUrl = getFilenameFromUrl;
+exports.isFetchSupported = isFetchSupported;
+exports.isValidFetchUrl = isValidFetchUrl;
+exports.loadScript = loadScript;
+exports.StatTimer = exports.RenderingCancelledException = exports.PDFDateString = exports.PageViewport = exports.LinkTarget = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.BaseCMapReaderFactory = exports.BaseCanvasFactory = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
+exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+class BaseCanvasFactory {
+  constructor() {
+    if (this.constructor === BaseCanvasFactory) {
+      (0, _util.unreachable)("Cannot initialize BaseCanvasFactory.");
+    }
+  }
+
+  create(width, height) {
+    (0, _util.unreachable)("Abstract method `create` called.");
+  }
+
+  reset(canvasAndContext, width, height) {
+    if (!canvasAndContext.canvas) {
+      throw new Error("Canvas is not specified");
+    }
+
+    if (width <= 0 || height <= 0) {
+      throw new Error("Invalid canvas size");
+    }
+
+    canvasAndContext.canvas.width = width;
+    canvasAndContext.canvas.height = height;
+  }
+
+  destroy(canvasAndContext) {
+    if (!canvasAndContext.canvas) {
+      throw new Error("Canvas is not specified");
+    }
+
+    canvasAndContext.canvas.width = 0;
+    canvasAndContext.canvas.height = 0;
+    canvasAndContext.canvas = null;
+    canvasAndContext.context = null;
+  }
+
+}
+
+exports.BaseCanvasFactory = BaseCanvasFactory;
+
+class DOMCanvasFactory extends BaseCanvasFactory {
+  constructor({
+    ownerDocument = globalThis.document
+  } = {}) {
+    super();
+    this._document = ownerDocument;
+  }
+
+  create(width, height) {
+    if (width <= 0 || height <= 0) {
+      throw new Error("Invalid canvas size");
+    }
+
+    const canvas = this._document.createElement("canvas");
+
+    const context = canvas.getContext("2d");
+    canvas.width = width;
+    canvas.height = height;
+    return {
+      canvas,
+      context
+    };
+  }
+
+}
+
+exports.DOMCanvasFactory = DOMCanvasFactory;
+
+class BaseCMapReaderFactory {
+  constructor({
+    baseUrl = null,
+    isCompressed = false
+  }) {
+    if (this.constructor === BaseCMapReaderFactory) {
+      (0, _util.unreachable)("Cannot initialize BaseCMapReaderFactory.");
+    }
+
+    this.baseUrl = baseUrl;
+    this.isCompressed = isCompressed;
+  }
+
+  async fetch({
+    name
+  }) {
+    if (!this.baseUrl) {
+      throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
+    }
+
+    if (!name) {
+      throw new Error("CMap name must be specified.");
+    }
+
+    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
+    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
+    return this._fetchData(url, compressionType).catch(reason => {
+      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}CMap at: ${url}`);
+    });
+  }
+
+  _fetchData(url, compressionType) {
+    (0, _util.unreachable)("Abstract method `_fetchData` called.");
+  }
+
+}
+
+exports.BaseCMapReaderFactory = BaseCMapReaderFactory;
+
+class DOMCMapReaderFactory extends BaseCMapReaderFactory {
+  _fetchData(url, compressionType) {
+    return fetch(url).then(async response => {
+      if (!response.ok) {
+        throw new Error(response.statusText);
+      }
+
+      let cMapData;
+
+      if (this.isCompressed) {
+        cMapData = new Uint8Array(await response.arrayBuffer());
+      } else {
+        cMapData = (0, _util.stringToBytes)(await response.text());
+      }
+
+      return {
+        cMapData,
+        compressionType
+      };
+    });
+  }
+
+}
+
+exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
+
+class DOMSVGFactory {
+  create(width, height) {
+    (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
+    const svg = document.createElementNS(SVG_NS, "svg:svg");
+    svg.setAttribute("version", "1.1");
+    svg.setAttribute("width", width + "px");
+    svg.setAttribute("height", height + "px");
+    svg.setAttribute("preserveAspectRatio", "none");
+    svg.setAttribute("viewBox", "0 0 " + width + " " + height);
+    return svg;
+  }
+
+  createElement(type) {
+    (0, _util.assert)(typeof type === "string", "Invalid SVG element type");
+    return document.createElementNS(SVG_NS, type);
+  }
+
+}
+
+exports.DOMSVGFactory = DOMSVGFactory;
+
+class PageViewport {
+  constructor({
+    viewBox,
+    scale,
+    rotation,
+    offsetX = 0,
+    offsetY = 0,
+    dontFlip = false
+  }) {
+    this.viewBox = viewBox;
+    this.scale = scale;
+    this.rotation = rotation;
+    this.offsetX = offsetX;
+    this.offsetY = offsetY;
+    const centerX = (viewBox[2] + viewBox[0]) / 2;
+    const centerY = (viewBox[3] + viewBox[1]) / 2;
+    let rotateA, rotateB, rotateC, rotateD;
+    rotation = rotation % 360;
+    rotation = rotation < 0 ? rotation + 360 : rotation;
+
+    switch (rotation) {
+      case 180:
+        rotateA = -1;
+        rotateB = 0;
+        rotateC = 0;
+        rotateD = 1;
+        break;
+
+      case 90:
+        rotateA = 0;
+        rotateB = 1;
+        rotateC = 1;
+        rotateD = 0;
+        break;
+
+      case 270:
+        rotateA = 0;
+        rotateB = -1;
+        rotateC = -1;
+        rotateD = 0;
+        break;
+
+      case 0:
+        rotateA = 1;
+        rotateB = 0;
+        rotateC = 0;
+        rotateD = -1;
+        break;
+
+      default:
+        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
+    }
+
+    if (dontFlip) {
+      rotateC = -rotateC;
+      rotateD = -rotateD;
+    }
+
+    let offsetCanvasX, offsetCanvasY;
+    let width, height;
+
+    if (rotateA === 0) {
+      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
+      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
+      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
+      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
+    } else {
+      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
+      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
+      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
+      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
+    }
+
+    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
+    this.width = width;
+    this.height = height;
+  }
+
+  clone({
+    scale = this.scale,
+    rotation = this.rotation,
+    offsetX = this.offsetX,
+    offsetY = this.offsetY,
+    dontFlip = false
+  } = {}) {
+    return new PageViewport({
+      viewBox: this.viewBox.slice(),
+      scale,
+      rotation,
+      offsetX,
+      offsetY,
+      dontFlip
+    });
+  }
+
+  convertToViewportPoint(x, y) {
+    return _util.Util.applyTransform([x, y], this.transform);
+  }
+
+  convertToViewportRectangle(rect) {
+    const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
+
+    const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
+
+    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
+  }
+
+  convertToPdfPoint(x, y) {
+    return _util.Util.applyInverseTransform([x, y], this.transform);
+  }
+
+}
+
+exports.PageViewport = PageViewport;
+
+class RenderingCancelledException extends _util.BaseException {
+  constructor(msg, type) {
+    super(msg);
+    this.type = type;
+  }
+
+}
+
+exports.RenderingCancelledException = RenderingCancelledException;
+const LinkTarget = {
+  NONE: 0,
+  SELF: 1,
+  BLANK: 2,
+  PARENT: 3,
+  TOP: 4
+};
+exports.LinkTarget = LinkTarget;
+
+function addLinkAttributes(link, {
+  url,
+  target,
+  rel,
+  enabled = true
+} = {}) {
+  (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
+  const urlNullRemoved = (0, _util.removeNullCharacters)(url);
+
+  if (enabled) {
+    link.href = link.title = urlNullRemoved;
+  } else {
+    link.href = "";
+    link.title = `Disabled: ${urlNullRemoved}`;
+
+    link.onclick = () => {
+      return false;
+    };
+  }
+
+  let targetStr = "";
+
+  switch (target) {
+    case LinkTarget.NONE:
+      break;
+
+    case LinkTarget.SELF:
+      targetStr = "_self";
+      break;
+
+    case LinkTarget.BLANK:
+      targetStr = "_blank";
+      break;
+
+    case LinkTarget.PARENT:
+      targetStr = "_parent";
+      break;
+
+    case LinkTarget.TOP:
+      targetStr = "_top";
+      break;
+  }
+
+  link.target = targetStr;
+  link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
+}
+
+function getFilenameFromUrl(url) {
+  const anchor = url.indexOf("#");
+  const query = url.indexOf("?");
+  const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
+  return url.substring(url.lastIndexOf("/", end) + 1, end);
+}
+
+class StatTimer {
+  constructor() {
+    this.started = Object.create(null);
+    this.times = [];
+  }
+
+  time(name) {
+    if (name in this.started) {
+      (0, _util.warn)(`Timer is already running for ${name}`);
+    }
+
+    this.started[name] = Date.now();
+  }
+
+  timeEnd(name) {
+    if (!(name in this.started)) {
+      (0, _util.warn)(`Timer has not been started for ${name}`);
+    }
+
+    this.times.push({
+      name,
+      start: this.started[name],
+      end: Date.now()
+    });
+    delete this.started[name];
+  }
+
+  toString() {
+    const outBuf = [];
+    let longest = 0;
+
+    for (const time of this.times) {
+      const name = time.name;
+
+      if (name.length > longest) {
+        longest = name.length;
+      }
+    }
+
+    for (const time of this.times) {
+      const duration = time.end - time.start;
+      outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`);
+    }
+
+    return outBuf.join("");
+  }
+
+}
+
+exports.StatTimer = StatTimer;
+
+function isFetchSupported() {
+  return typeof fetch !== "undefined" && typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream !== "undefined";
+}
+
+function isValidFetchUrl(url, baseUrl) {
+  try {
+    const {
+      protocol
+    } = baseUrl ? new URL(url, baseUrl) : new URL(url);
+    return protocol === "http:" || protocol === "https:";
+  } catch (ex) {
+    return false;
+  }
+}
+
+function loadScript(src, removeScriptElement = false) {
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = src;
+
+    script.onload = function (evt) {
+      if (removeScriptElement) {
+        script.remove();
+      }
+
+      resolve(evt);
+    };
+
+    script.onerror = function () {
+      reject(new Error(`Cannot load script at: ${script.src}`));
+    };
+
+    (document.head || document.documentElement).appendChild(script);
+  });
+}
+
+function deprecated(details) {
+  console.log("Deprecated API usage: " + details);
+}
+
+let pdfDateStringRegex;
+
+class PDFDateString {
+  static toDateObject(input) {
+    if (!input || !(0, _util.isString)(input)) {
+      return null;
+    }
+
+    if (!pdfDateStringRegex) {
+      pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
+    }
+
+    const matches = pdfDateStringRegex.exec(input);
+
+    if (!matches) {
+      return null;
+    }
+
+    const year = parseInt(matches[1], 10);
+    let month = parseInt(matches[2], 10);
+    month = month >= 1 && month <= 12 ? month - 1 : 0;
+    let day = parseInt(matches[3], 10);
+    day = day >= 1 && day <= 31 ? day : 1;
+    let hour = parseInt(matches[4], 10);
+    hour = hour >= 0 && hour <= 23 ? hour : 0;
+    let minute = parseInt(matches[5], 10);
+    minute = minute >= 0 && minute <= 59 ? minute : 0;
+    let second = parseInt(matches[6], 10);
+    second = second >= 0 && second <= 59 ? second : 0;
+    const universalTimeRelation = matches[7] || "Z";
+    let offsetHour = parseInt(matches[8], 10);
+    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
+    let offsetMinute = parseInt(matches[9], 10) || 0;
+    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
+
+    if (universalTimeRelation === "-") {
+      hour += offsetHour;
+      minute += offsetMinute;
+    } else if (universalTimeRelation === "+") {
+      hour -= offsetHour;
+      minute -= offsetMinute;
+    }
+
+    return new Date(Date.UTC(year, month, day, hour, minute, second));
+  }
+
+}
+
+exports.PDFDateString = PDFDateString;
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.arrayByteLength = arrayByteLength;
+exports.arraysToBytes = arraysToBytes;
+exports.assert = assert;
+exports.bytesToString = bytesToString;
+exports.createPromiseCapability = createPromiseCapability;
+exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
+exports.encodeToXmlString = encodeToXmlString;
+exports.escapeString = escapeString;
+exports.getModificationDate = getModificationDate;
+exports.getVerbosityLevel = getVerbosityLevel;
+exports.info = info;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isArrayEqual = isArrayEqual;
+exports.isAscii = isAscii;
+exports.isBool = isBool;
+exports.isNum = isNum;
+exports.isSameOrigin = isSameOrigin;
+exports.isString = isString;
+exports.objectFromEntries = objectFromEntries;
+exports.objectSize = objectSize;
+exports.removeNullCharacters = removeNullCharacters;
+exports.setVerbosityLevel = setVerbosityLevel;
+exports.shadow = shadow;
+exports.string32 = string32;
+exports.stringToBytes = stringToBytes;
+exports.stringToPDFString = stringToPDFString;
+exports.stringToUTF16BEString = stringToUTF16BEString;
+exports.stringToUTF8String = stringToUTF8String;
+exports.unreachable = unreachable;
+exports.utf8StringToString = utf8StringToString;
+exports.warn = warn;
+exports.VerbosityLevel = exports.Util = exports.UNSUPPORTED_FEATURES = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.IsLittleEndianCached = exports.IsEvalSupportedCached = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.createObjectURL = exports.CMapCompressionType = exports.BaseException = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
+
+__w_pdfjs_require__(3);
+
+const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
+const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
+exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
+const PermissionFlag = {
+  PRINT: 0x04,
+  MODIFY_CONTENTS: 0x08,
+  COPY: 0x10,
+  MODIFY_ANNOTATIONS: 0x20,
+  FILL_INTERACTIVE_FORMS: 0x100,
+  COPY_FOR_ACCESSIBILITY: 0x200,
+  ASSEMBLE: 0x400,
+  PRINT_HIGH_QUALITY: 0x800
+};
+exports.PermissionFlag = PermissionFlag;
+const TextRenderingMode = {
+  FILL: 0,
+  STROKE: 1,
+  FILL_STROKE: 2,
+  INVISIBLE: 3,
+  FILL_ADD_TO_PATH: 4,
+  STROKE_ADD_TO_PATH: 5,
+  FILL_STROKE_ADD_TO_PATH: 6,
+  ADD_TO_PATH: 7,
+  FILL_STROKE_MASK: 3,
+  ADD_TO_PATH_FLAG: 4
+};
+exports.TextRenderingMode = TextRenderingMode;
+const ImageKind = {
+  GRAYSCALE_1BPP: 1,
+  RGB_24BPP: 2,
+  RGBA_32BPP: 3
+};
+exports.ImageKind = ImageKind;
+const AnnotationType = {
+  TEXT: 1,
+  LINK: 2,
+  FREETEXT: 3,
+  LINE: 4,
+  SQUARE: 5,
+  CIRCLE: 6,
+  POLYGON: 7,
+  POLYLINE: 8,
+  HIGHLIGHT: 9,
+  UNDERLINE: 10,
+  SQUIGGLY: 11,
+  STRIKEOUT: 12,
+  STAMP: 13,
+  CARET: 14,
+  INK: 15,
+  POPUP: 16,
+  FILEATTACHMENT: 17,
+  SOUND: 18,
+  MOVIE: 19,
+  WIDGET: 20,
+  SCREEN: 21,
+  PRINTERMARK: 22,
+  TRAPNET: 23,
+  WATERMARK: 24,
+  THREED: 25,
+  REDACT: 26
+};
+exports.AnnotationType = AnnotationType;
+const AnnotationStateModelType = {
+  MARKED: "Marked",
+  REVIEW: "Review"
+};
+exports.AnnotationStateModelType = AnnotationStateModelType;
+const AnnotationMarkedState = {
+  MARKED: "Marked",
+  UNMARKED: "Unmarked"
+};
+exports.AnnotationMarkedState = AnnotationMarkedState;
+const AnnotationReviewState = {
+  ACCEPTED: "Accepted",
+  REJECTED: "Rejected",
+  CANCELLED: "Cancelled",
+  COMPLETED: "Completed",
+  NONE: "None"
+};
+exports.AnnotationReviewState = AnnotationReviewState;
+const AnnotationReplyType = {
+  GROUP: "Group",
+  REPLY: "R"
+};
+exports.AnnotationReplyType = AnnotationReplyType;
+const AnnotationFlag = {
+  INVISIBLE: 0x01,
+  HIDDEN: 0x02,
+  PRINT: 0x04,
+  NOZOOM: 0x08,
+  NOROTATE: 0x10,
+  NOVIEW: 0x20,
+  READONLY: 0x40,
+  LOCKED: 0x80,
+  TOGGLENOVIEW: 0x100,
+  LOCKEDCONTENTS: 0x200
+};
+exports.AnnotationFlag = AnnotationFlag;
+const AnnotationFieldFlag = {
+  READONLY: 0x0000001,
+  REQUIRED: 0x0000002,
+  NOEXPORT: 0x0000004,
+  MULTILINE: 0x0001000,
+  PASSWORD: 0x0002000,
+  NOTOGGLETOOFF: 0x0004000,
+  RADIO: 0x0008000,
+  PUSHBUTTON: 0x0010000,
+  COMBO: 0x0020000,
+  EDIT: 0x0040000,
+  SORT: 0x0080000,
+  FILESELECT: 0x0100000,
+  MULTISELECT: 0x0200000,
+  DONOTSPELLCHECK: 0x0400000,
+  DONOTSCROLL: 0x0800000,
+  COMB: 0x1000000,
+  RICHTEXT: 0x2000000,
+  RADIOSINUNISON: 0x2000000,
+  COMMITONSELCHANGE: 0x4000000
+};
+exports.AnnotationFieldFlag = AnnotationFieldFlag;
+const AnnotationBorderStyleType = {
+  SOLID: 1,
+  DASHED: 2,
+  BEVELED: 3,
+  INSET: 4,
+  UNDERLINE: 5
+};
+exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
+const AnnotationActionEventType = {
+  E: "MouseEnter",
+  X: "MouseExit",
+  D: "MouseDown",
+  U: "MouseUp",
+  Fo: "Focus",
+  Bl: "Blur",
+  PO: "PageOpen",
+  PC: "PageClose",
+  PV: "PageVisible",
+  PI: "PageInvisible",
+  K: "Keystroke",
+  F: "Format",
+  V: "Validate",
+  C: "Calculate"
+};
+exports.AnnotationActionEventType = AnnotationActionEventType;
+const DocumentActionEventType = {
+  WC: "WillClose",
+  WS: "WillSave",
+  DS: "DidSave",
+  WP: "WillPrint",
+  DP: "DidPrint"
+};
+exports.DocumentActionEventType = DocumentActionEventType;
+const PageActionEventType = {
+  O: "PageOpen",
+  C: "PageClose"
+};
+exports.PageActionEventType = PageActionEventType;
+const StreamType = {
+  UNKNOWN: "UNKNOWN",
+  FLATE: "FLATE",
+  LZW: "LZW",
+  DCT: "DCT",
+  JPX: "JPX",
+  JBIG: "JBIG",
+  A85: "A85",
+  AHX: "AHX",
+  CCF: "CCF",
+  RLX: "RLX"
+};
+exports.StreamType = StreamType;
+const FontType = {
+  UNKNOWN: "UNKNOWN",
+  TYPE1: "TYPE1",
+  TYPE1C: "TYPE1C",
+  CIDFONTTYPE0: "CIDFONTTYPE0",
+  CIDFONTTYPE0C: "CIDFONTTYPE0C",
+  TRUETYPE: "TRUETYPE",
+  CIDFONTTYPE2: "CIDFONTTYPE2",
+  TYPE3: "TYPE3",
+  OPENTYPE: "OPENTYPE",
+  TYPE0: "TYPE0",
+  MMTYPE1: "MMTYPE1"
+};
+exports.FontType = FontType;
+const VerbosityLevel = {
+  ERRORS: 0,
+  WARNINGS: 1,
+  INFOS: 5
+};
+exports.VerbosityLevel = VerbosityLevel;
+const CMapCompressionType = {
+  NONE: 0,
+  BINARY: 1,
+  STREAM: 2
+};
+exports.CMapCompressionType = CMapCompressionType;
+const OPS = {
+  dependency: 1,
+  setLineWidth: 2,
+  setLineCap: 3,
+  setLineJoin: 4,
+  setMiterLimit: 5,
+  setDash: 6,
+  setRenderingIntent: 7,
+  setFlatness: 8,
+  setGState: 9,
+  save: 10,
+  restore: 11,
+  transform: 12,
+  moveTo: 13,
+  lineTo: 14,
+  curveTo: 15,
+  curveTo2: 16,
+  curveTo3: 17,
+  closePath: 18,
+  rectangle: 19,
+  stroke: 20,
+  closeStroke: 21,
+  fill: 22,
+  eoFill: 23,
+  fillStroke: 24,
+  eoFillStroke: 25,
+  closeFillStroke: 26,
+  closeEOFillStroke: 27,
+  endPath: 28,
+  clip: 29,
+  eoClip: 30,
+  beginText: 31,
+  endText: 32,
+  setCharSpacing: 33,
+  setWordSpacing: 34,
+  setHScale: 35,
+  setLeading: 36,
+  setFont: 37,
+  setTextRenderingMode: 38,
+  setTextRise: 39,
+  moveText: 40,
+  setLeadingMoveText: 41,
+  setTextMatrix: 42,
+  nextLine: 43,
+  showText: 44,
+  showSpacedText: 45,
+  nextLineShowText: 46,
+  nextLineSetSpacingShowText: 47,
+  setCharWidth: 48,
+  setCharWidthAndBounds: 49,
+  setStrokeColorSpace: 50,
+  setFillColorSpace: 51,
+  setStrokeColor: 52,
+  setStrokeColorN: 53,
+  setFillColor: 54,
+  setFillColorN: 55,
+  setStrokeGray: 56,
+  setFillGray: 57,
+  setStrokeRGBColor: 58,
+  setFillRGBColor: 59,
+  setStrokeCMYKColor: 60,
+  setFillCMYKColor: 61,
+  shadingFill: 62,
+  beginInlineImage: 63,
+  beginImageData: 64,
+  endInlineImage: 65,
+  paintXObject: 66,
+  markPoint: 67,
+  markPointProps: 68,
+  beginMarkedContent: 69,
+  beginMarkedContentProps: 70,
+  endMarkedContent: 71,
+  beginCompat: 72,
+  endCompat: 73,
+  paintFormXObjectBegin: 74,
+  paintFormXObjectEnd: 75,
+  beginGroup: 76,
+  endGroup: 77,
+  beginAnnotations: 78,
+  endAnnotations: 79,
+  beginAnnotation: 80,
+  endAnnotation: 81,
+  paintJpegXObject: 82,
+  paintImageMaskXObject: 83,
+  paintImageMaskXObjectGroup: 84,
+  paintImageXObject: 85,
+  paintInlineImageXObject: 86,
+  paintInlineImageXObjectGroup: 87,
+  paintImageXObjectRepeat: 88,
+  paintImageMaskXObjectRepeat: 89,
+  paintSolidColorImageMask: 90,
+  constructPath: 91
+};
+exports.OPS = OPS;
+const UNSUPPORTED_FEATURES = {
+  unknown: "unknown",
+  forms: "forms",
+  javaScript: "javaScript",
+  smask: "smask",
+  shadingPattern: "shadingPattern",
+  font: "font",
+  errorTilingPattern: "errorTilingPattern",
+  errorExtGState: "errorExtGState",
+  errorXObject: "errorXObject",
+  errorFontLoadType3: "errorFontLoadType3",
+  errorFontState: "errorFontState",
+  errorFontMissing: "errorFontMissing",
+  errorFontTranslate: "errorFontTranslate",
+  errorColorSpace: "errorColorSpace",
+  errorOperatorList: "errorOperatorList",
+  errorFontToUnicode: "errorFontToUnicode",
+  errorFontLoadNative: "errorFontLoadNative",
+  errorFontGetPath: "errorFontGetPath",
+  errorMarkedContent: "errorMarkedContent"
+};
+exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
+const PasswordResponses = {
+  NEED_PASSWORD: 1,
+  INCORRECT_PASSWORD: 2
+};
+exports.PasswordResponses = PasswordResponses;
+let verbosity = VerbosityLevel.WARNINGS;
+
+function setVerbosityLevel(level) {
+  if (Number.isInteger(level)) {
+    verbosity = level;
+  }
+}
+
+function getVerbosityLevel() {
+  return verbosity;
+}
+
+function info(msg) {
+  if (verbosity >= VerbosityLevel.INFOS) {
+    console.log(`Info: ${msg}`);
+  }
+}
+
+function warn(msg) {
+  if (verbosity >= VerbosityLevel.WARNINGS) {
+    console.log(`Warning: ${msg}`);
+  }
+}
+
+function unreachable(msg) {
+  throw new Error(msg);
+}
+
+function assert(cond, msg) {
+  if (!cond) {
+    unreachable(msg);
+  }
+}
+
+function isSameOrigin(baseUrl, otherUrl) {
+  let base;
+
+  try {
+    base = new URL(baseUrl);
+
+    if (!base.origin || base.origin === "null") {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+
+  const other = new URL(otherUrl, base);
+  return base.origin === other.origin;
+}
+
+function _isValidProtocol(url) {
+  if (!url) {
+    return false;
+  }
+
+  switch (url.protocol) {
+    case "http:":
+    case "https:":
+    case "ftp:":
+    case "mailto:":
+    case "tel:":
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+function createValidAbsoluteUrl(url, baseUrl) {
+  if (!url) {
+    return null;
+  }
+
+  try {
+    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+
+    if (_isValidProtocol(absoluteUrl)) {
+      return absoluteUrl;
+    }
+  } catch (ex) {}
+
+  return null;
+}
+
+function shadow(obj, prop, value) {
+  Object.defineProperty(obj, prop, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: false
+  });
+  return value;
+}
+
+const BaseException = function BaseExceptionClosure() {
+  function BaseException(message) {
+    if (this.constructor === BaseException) {
+      unreachable("Cannot initialize BaseException.");
+    }
+
+    this.message = message;
+    this.name = this.constructor.name;
+  }
+
+  BaseException.prototype = new Error();
+  BaseException.constructor = BaseException;
+  return BaseException;
+}();
+
+exports.BaseException = BaseException;
+
+class PasswordException extends BaseException {
+  constructor(msg, code) {
+    super(msg);
+    this.code = code;
+  }
+
+}
+
+exports.PasswordException = PasswordException;
+
+class UnknownErrorException extends BaseException {
+  constructor(msg, details) {
+    super(msg);
+    this.details = details;
+  }
+
+}
+
+exports.UnknownErrorException = UnknownErrorException;
+
+class InvalidPDFException extends BaseException {}
+
+exports.InvalidPDFException = InvalidPDFException;
+
+class MissingPDFException extends BaseException {}
+
+exports.MissingPDFException = MissingPDFException;
+
+class UnexpectedResponseException extends BaseException {
+  constructor(msg, status) {
+    super(msg);
+    this.status = status;
+  }
+
+}
+
+exports.UnexpectedResponseException = UnexpectedResponseException;
+
+class FormatError extends BaseException {}
+
+exports.FormatError = FormatError;
+
+class AbortException extends BaseException {}
+
+exports.AbortException = AbortException;
+const NullCharactersRegExp = /\x00/g;
+
+function removeNullCharacters(str) {
+  if (typeof str !== "string") {
+    warn("The argument for removeNullCharacters must be a string.");
+    return str;
+  }
+
+  return str.replace(NullCharactersRegExp, "");
+}
+
+function bytesToString(bytes) {
+  assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
+  const length = bytes.length;
+  const MAX_ARGUMENT_COUNT = 8192;
+
+  if (length < MAX_ARGUMENT_COUNT) {
+    return String.fromCharCode.apply(null, bytes);
+  }
+
+  const strBuf = [];
+
+  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+    const chunk = bytes.subarray(i, chunkEnd);
+    strBuf.push(String.fromCharCode.apply(null, chunk));
+  }
+
+  return strBuf.join("");
+}
+
+function stringToBytes(str) {
+  assert(typeof str === "string", "Invalid argument for stringToBytes");
+  const length = str.length;
+  const bytes = new Uint8Array(length);
+
+  for (let i = 0; i < length; ++i) {
+    bytes[i] = str.charCodeAt(i) & 0xff;
+  }
+
+  return bytes;
+}
+
+function arrayByteLength(arr) {
+  if (arr.length !== undefined) {
+    return arr.length;
+  }
+
+  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
+  return arr.byteLength;
+}
+
+function arraysToBytes(arr) {
+  const length = arr.length;
+
+  if (length === 1 && arr[0] instanceof Uint8Array) {
+    return arr[0];
+  }
+
+  let resultLength = 0;
+
+  for (let i = 0; i < length; i++) {
+    resultLength += arrayByteLength(arr[i]);
+  }
+
+  let pos = 0;
+  const data = new Uint8Array(resultLength);
+
+  for (let i = 0; i < length; i++) {
+    let item = arr[i];
+
+    if (!(item instanceof Uint8Array)) {
+      if (typeof item === "string") {
+        item = stringToBytes(item);
+      } else {
+        item = new Uint8Array(item);
+      }
+    }
+
+    const itemLength = item.byteLength;
+    data.set(item, pos);
+    pos += itemLength;
+  }
+
+  return data;
+}
+
+function string32(value) {
+  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
+}
+
+function objectSize(obj) {
+  return Object.keys(obj).length;
+}
+
+function objectFromEntries(iterable) {
+  return Object.assign(Object.create(null), Object.fromEntries(iterable));
+}
+
+function isLittleEndian() {
+  const buffer8 = new Uint8Array(4);
+  buffer8[0] = 1;
+  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
+  return view32[0] === 1;
+}
+
+const IsLittleEndianCached = {
+  get value() {
+    return shadow(this, "value", isLittleEndian());
+  }
+
+};
+exports.IsLittleEndianCached = IsLittleEndianCached;
+
+function isEvalSupported() {
+  try {
+    new Function("");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const IsEvalSupportedCached = {
+  get value() {
+    return shadow(this, "value", isEvalSupported());
+  }
+
+};
+exports.IsEvalSupportedCached = IsEvalSupportedCached;
+const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
+
+class Util {
+  static makeHexColor(r, g, b) {
+    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
+  }
+
+  static transform(m1, m2) {
+    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
+  }
+
+  static applyTransform(p, m) {
+    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
+    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
+    return [xt, yt];
+  }
+
+  static applyInverseTransform(p, m) {
+    const d = m[0] * m[3] - m[1] * m[2];
+    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
+    return [xt, yt];
+  }
+
+  static getAxialAlignedBoundingBox(r, m) {
+    const p1 = Util.applyTransform(r, m);
+    const p2 = Util.applyTransform(r.slice(2, 4), m);
+    const p3 = Util.applyTransform([r[0], r[3]], m);
+    const p4 = Util.applyTransform([r[2], r[1]], m);
+    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
+  }
+
+  static inverseTransform(m) {
+    const d = m[0] * m[3] - m[1] * m[2];
+    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
+  }
+
+  static apply3dTransform(m, v) {
+    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
+  }
+
+  static singularValueDecompose2dScale(m) {
+    const transpose = [m[0], m[2], m[1], m[3]];
+    const a = m[0] * transpose[0] + m[1] * transpose[2];
+    const b = m[0] * transpose[1] + m[1] * transpose[3];
+    const c = m[2] * transpose[0] + m[3] * transpose[2];
+    const d = m[2] * transpose[1] + m[3] * transpose[3];
+    const first = (a + d) / 2;
+    const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
+    const sx = first + second || 1;
+    const sy = first - second || 1;
+    return [Math.sqrt(sx), Math.sqrt(sy)];
+  }
+
+  static normalizeRect(rect) {
+    const r = rect.slice(0);
+
+    if (rect[0] > rect[2]) {
+      r[0] = rect[2];
+      r[2] = rect[0];
+    }
+
+    if (rect[1] > rect[3]) {
+      r[1] = rect[3];
+      r[3] = rect[1];
+    }
+
+    return r;
+  }
+
+  static intersect(rect1, rect2) {
+    function compare(a, b) {
+      return a - b;
+    }
+
+    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);
+    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
+    const result = [];
+    rect1 = Util.normalizeRect(rect1);
+    rect2 = Util.normalizeRect(rect2);
+
+    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
+      result[0] = orderedX[1];
+      result[2] = orderedX[2];
+    } else {
+      return null;
+    }
+
+    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
+      result[1] = orderedY[1];
+      result[3] = orderedY[2];
+    } else {
+      return null;
+    }
+
+    return result;
+  }
+
+}
+
+exports.Util = Util;
+const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
+
+function stringToPDFString(str) {
+  const length = str.length,
+        strBuf = [];
+
+  if (str[0] === "\xFE" && str[1] === "\xFF") {
+    for (let i = 2; i < length; i += 2) {
+      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
+    }
+  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
+    for (let i = 2; i < length; i += 2) {
+      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
+    }
+  } else {
+    for (let i = 0; i < length; ++i) {
+      const code = PDFStringTranslateTable[str.charCodeAt(i)];
+      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
+    }
+  }
+
+  return strBuf.join("");
+}
+
+function escapeString(str) {
+  return str.replace(/([()\\\n\r])/g, match => {
+    if (match === "\n") {
+      return "\\n";
+    } else if (match === "\r") {
+      return "\\r";
+    }
+
+    return `\\${match}`;
+  });
+}
+
+function isAscii(str) {
+  return /^[\x00-\x7F]*$/.test(str);
+}
+
+function stringToUTF16BEString(str) {
+  const buf = ["\xFE\xFF"];
+
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.charCodeAt(i);
+    buf.push(String.fromCharCode(char >> 8 & 0xff));
+    buf.push(String.fromCharCode(char & 0xff));
+  }
+
+  return buf.join("");
+}
+
+function stringToUTF8String(str) {
+  return decodeURIComponent(escape(str));
+}
+
+function utf8StringToString(str) {
+  return unescape(encodeURIComponent(str));
+}
+
+function isBool(v) {
+  return typeof v === "boolean";
+}
+
+function isNum(v) {
+  return typeof v === "number";
+}
+
+function isString(v) {
+  return typeof v === "string";
+}
+
+function isArrayBuffer(v) {
+  return typeof v === "object" && v !== null && v.byteLength !== undefined;
+}
+
+function isArrayEqual(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+
+  return arr1.every(function (element, index) {
+    return element === arr2[index];
+  });
+}
+
+function getModificationDate(date = new Date()) {
+  const buffer = [date.getUTCFullYear().toString(), (date.getUTCMonth() + 1).toString().padStart(2, "0"), date.getUTCDate().toString().padStart(2, "0"), date.getUTCHours().toString().padStart(2, "0"), date.getUTCMinutes().toString().padStart(2, "0"), date.getUTCSeconds().toString().padStart(2, "0")];
+  return buffer.join("");
+}
+
+function createPromiseCapability() {
+  const capability = Object.create(null);
+  let isSettled = false;
+  Object.defineProperty(capability, "settled", {
+    get() {
+      return isSettled;
+    }
+
+  });
+  capability.promise = new Promise(function (resolve, reject) {
+    capability.resolve = function (data) {
+      isSettled = true;
+      resolve(data);
+    };
+
+    capability.reject = function (reason) {
+      isSettled = true;
+      reject(reason);
+    };
+  });
+  return capability;
+}
+
+const createObjectURL = function createObjectURLClosure() {
+  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  return function createObjectURL(data, contentType, forceDataSchema = false) {
+    if (!forceDataSchema && URL.createObjectURL) {
+      const blob = new Blob([data], {
+        type: contentType
+      });
+      return URL.createObjectURL(blob);
+    }
+
+    let buffer = `data:${contentType};base64,`;
+
+    for (let i = 0, ii = data.length; i < ii; i += 3) {
+      const b1 = data[i] & 0xff;
+      const b2 = data[i + 1] & 0xff;
+      const b3 = data[i + 2] & 0xff;
+      const d1 = b1 >> 2,
+            d2 = (b1 & 3) << 4 | b2 >> 4;
+      const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
+      const d4 = i + 2 < ii ? b3 & 0x3f : 64;
+      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
+    }
+
+    return buffer;
+  };
+}();
+
+exports.createObjectURL = createObjectURL;
+const XMLEntities = {
+  0x3c: "&lt;",
+  0x3e: "&gt;",
+  0x26: "&amp;",
+  0x22: "&quot;",
+  0x27: "&apos;"
+};
+
+function encodeToXmlString(str) {
+  const buffer = [];
+  let start = 0;
+
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.codePointAt(i);
+
+    if (0x20 <= char && char <= 0x7e) {
+      const entity = XMLEntities[char];
+
+      if (entity) {
+        if (start < i) {
+          buffer.push(str.substring(start, i));
+        }
+
+        buffer.push(entity);
+        start = i + 1;
+      }
+    } else {
+      if (start < i) {
+        buffer.push(str.substring(start, i));
+      }
+
+      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
+
+      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
+        i++;
+      }
+
+      start = i + 1;
+    }
+  }
+
+  if (buffer.length === 0) {
+    return str;
+  }
+
+  if (start < str.length) {
+    buffer.push(str.substring(start, str.length));
+  }
+
+  return buffer.join("");
+}
+
+/***/ }),
+/* 3 */
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
+
+
+
+var _is_node = __w_pdfjs_require__(4);
+
+;
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.isNodeJS = void 0;
+const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
+exports.isNodeJS = isNodeJS;
+
+/***/ }),
+/* 5 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getDocument = getDocument;
+exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
+exports.version = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultCMapReaderFactory = exports.DefaultCanvasFactory = exports.build = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _display_utils = __w_pdfjs_require__(1);
+
+var _font_loader = __w_pdfjs_require__(6);
+
+var _node_utils = __w_pdfjs_require__(7);
+
+var _annotation_storage = __w_pdfjs_require__(8);
+
+var _api_compatibility = __w_pdfjs_require__(9);
+
+var _canvas = __w_pdfjs_require__(10);
+
+var _worker_options = __w_pdfjs_require__(12);
+
+var _is_node = __w_pdfjs_require__(4);
+
+var _message_handler = __w_pdfjs_require__(13);
+
+var _metadata = __w_pdfjs_require__(14);
+
+var _optional_content_config = __w_pdfjs_require__(16);
+
+var _transport_stream = __w_pdfjs_require__(17);
+
+var _webgl = __w_pdfjs_require__(18);
+
+const DEFAULT_RANGE_CHUNK_SIZE = 65536;
+const RENDERING_CANCELLED_TIMEOUT = 100;
+const DefaultCanvasFactory = _display_utils.DOMCanvasFactory;
+exports.DefaultCanvasFactory = DefaultCanvasFactory;
+const DefaultCMapReaderFactory = _display_utils.DOMCMapReaderFactory;
+exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory;
+let createPDFNetworkStream;
+
+function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
+  createPDFNetworkStream = pdfNetworkStreamFactory;
+}
+
+function getDocument(src) {
+  const task = new PDFDocumentLoadingTask();
+  let source;
+
+  if (typeof src === "string") {
+    source = {
+      url: src
+    };
+  } else if ((0, _util.isArrayBuffer)(src)) {
+    source = {
+      data: src
+    };
+  } else if (src instanceof PDFDataRangeTransport) {
+    source = {
+      range: src
+    };
+  } else {
+    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;
+  }
+
+  const params = Object.create(null);
+  let rangeTransport = null,
+      worker = null;
+
+  for (const key in source) {
+    if (key === "url" && typeof window !== "undefined") {
+      params[key] = new URL(source[key], window.location).href;
+      continue;
+    } else if (key === "range") {
+      rangeTransport = source[key];
+      continue;
+    } else if (key === "worker") {
+      worker = source[key];
+      continue;
+    } else if (key === "data" && !(source[key] instanceof Uint8Array)) {
+      const pdfBytes = source[key];
+
+      if (typeof pdfBytes === "string") {
+        params[key] = (0, _util.stringToBytes)(pdfBytes);
+      } 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;
+    }
+
+    params[key] = source[key];
+  }
+
+  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
+  params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory;
+  params.ignoreErrors = params.stopAtErrors !== true;
+  params.fontExtraProperties = params.fontExtraProperties === true;
+  params.pdfBug = params.pdfBug === true;
+
+  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.ownerDocument === "undefined") {
+    params.ownerDocument = globalThis.document;
+  }
+
+  if (typeof params.disableRange !== "boolean") {
+    params.disableRange = false;
+  }
+
+  if (typeof params.disableStream !== "boolean") {
+    params.disableStream = false;
+  }
+
+  if (typeof params.disableAutoFetch !== "boolean") {
+    params.disableAutoFetch = false;
+  }
+
+  (0, _util.setVerbosityLevel)(params.verbosity);
+
+  if (!worker) {
+    const workerParams = {
+      verbosity: params.verbosity,
+      port: _worker_options.GlobalWorkerOptions.workerPort
+    };
+    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
+    task._worker = worker;
+  }
+
+  const docId = task.docId;
+  worker.promise.then(function () {
+    if (task.destroyed) {
+      throw new Error("Loading aborted");
+    }
+
+    const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
+
+    const networkStreamPromise = new Promise(function (resolve) {
+      let networkStream;
+
+      if (rangeTransport) {
+        networkStream = new _transport_stream.PDFDataTransportStream({
+          length: params.length,
+          initialData: params.initialData,
+          progressiveDone: params.progressiveDone,
+          disableRange: params.disableRange,
+          disableStream: params.disableStream
+        }, rangeTransport);
+      } else if (!params.data) {
+        networkStream = createPDFNetworkStream({
+          url: params.url,
+          length: params.length,
+          httpHeaders: params.httpHeaders,
+          withCredentials: params.withCredentials,
+          rangeChunkSize: params.rangeChunkSize,
+          disableRange: params.disableRange,
+          disableStream: params.disableStream
+        });
+      }
+
+      resolve(networkStream);
+    });
+    return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
+      if (task.destroyed) {
+        throw new Error("Loading aborted");
+      }
+
+      const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
+      messageHandler.postMessageTransfers = worker.postMessageTransfers;
+      const transport = new WorkerTransport(messageHandler, task, networkStream, params);
+      task._transport = transport;
+      messageHandler.send("Ready", null);
+    });
+  }).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,
+    apiVersion: '2.7.510',
+    source: {
+      data: source.data,
+      url: source.url,
+      password: source.password,
+      disableAutoFetch: source.disableAutoFetch,
+      rangeChunkSize: source.rangeChunkSize,
+      length: source.length
+    },
+    maxImageSize: source.maxImageSize,
+    disableFontFace: source.disableFontFace,
+    postMessageTransfers: worker.postMessageTransfers,
+    docBaseUrl: source.docBaseUrl,
+    ignoreErrors: source.ignoreErrors,
+    isEvalSupported: source.isEvalSupported,
+    fontExtraProperties: source.fontExtraProperties
+  }).then(function (workerId) {
+    if (worker.destroyed) {
+      throw new Error("Worker was destroyed");
+    }
+
+    return workerId;
+  });
+}
+
+const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
+  let nextDocumentId = 0;
+
+  class PDFDocumentLoadingTask {
+    constructor() {
+      this._capability = (0, _util.createPromiseCapability)();
+      this._transport = null;
+      this._worker = null;
+      this.docId = "d" + nextDocumentId++;
+      this.destroyed = false;
+      this.onPassword = null;
+      this.onProgress = null;
+      this.onUnsupportedFeature = null;
+    }
+
+    get promise() {
+      return this._capability.promise;
+    }
+
+    destroy() {
+      this.destroyed = true;
+      const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
+      return transportDestroyed.then(() => {
+        this._transport = null;
+
+        if (this._worker) {
+          this._worker.destroy();
+
+          this._worker = null;
+        }
+      });
+    }
+
+  }
+
+  return PDFDocumentLoadingTask;
+}();
+
+class PDFDataRangeTransport {
+  constructor(length, initialData, progressiveDone = false) {
+    this.length = length;
+    this.initialData = initialData;
+    this.progressiveDone = progressiveDone;
+    this._rangeListeners = [];
+    this._progressListeners = [];
+    this._progressiveReadListeners = [];
+    this._progressiveDoneListeners = [];
+    this._readyCapability = (0, _util.createPromiseCapability)();
+  }
+
+  addRangeListener(listener) {
+    this._rangeListeners.push(listener);
+  }
+
+  addProgressListener(listener) {
+    this._progressListeners.push(listener);
+  }
+
+  addProgressiveReadListener(listener) {
+    this._progressiveReadListeners.push(listener);
+  }
+
+  addProgressiveDoneListener(listener) {
+    this._progressiveDoneListeners.push(listener);
+  }
+
+  onDataRange(begin, chunk) {
+    for (const listener of this._rangeListeners) {
+      listener(begin, chunk);
+    }
+  }
+
+  onDataProgress(loaded, total) {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressListeners) {
+        listener(loaded, total);
+      }
+    });
+  }
+
+  onDataProgressiveRead(chunk) {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressiveReadListeners) {
+        listener(chunk);
+      }
+    });
+  }
+
+  onDataProgressiveDone() {
+    this._readyCapability.promise.then(() => {
+      for (const listener of this._progressiveDoneListeners) {
+        listener();
+      }
+    });
+  }
+
+  transportReady() {
+    this._readyCapability.resolve();
+  }
+
+  requestDataRange(begin, end) {
+    (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
+  }
+
+  abort() {}
+
+}
+
+exports.PDFDataRangeTransport = PDFDataRangeTransport;
+
+class PDFDocumentProxy {
+  constructor(pdfInfo, transport) {
+    this._pdfInfo = pdfInfo;
+    this._transport = transport;
+  }
+
+  get annotationStorage() {
+    return (0, _util.shadow)(this, "annotationStorage", new _annotation_storage.AnnotationStorage());
+  }
+
+  get numPages() {
+    return this._pdfInfo.numPages;
+  }
+
+  get fingerprint() {
+    return this._pdfInfo.fingerprint;
+  }
+
+  getPage(pageNumber) {
+    return this._transport.getPage(pageNumber);
+  }
+
+  getPageIndex(ref) {
+    return this._transport.getPageIndex(ref);
+  }
+
+  getDestinations() {
+    return this._transport.getDestinations();
+  }
+
+  getDestination(id) {
+    return this._transport.getDestination(id);
+  }
+
+  getPageLabels() {
+    return this._transport.getPageLabels();
+  }
+
+  getPageLayout() {
+    return this._transport.getPageLayout();
+  }
+
+  getPageMode() {
+    return this._transport.getPageMode();
+  }
+
+  getViewerPreferences() {
+    return this._transport.getViewerPreferences();
+  }
+
+  getOpenAction() {
+    return this._transport.getOpenAction();
+  }
+
+  getAttachments() {
+    return this._transport.getAttachments();
+  }
+
+  getJavaScript() {
+    return this._transport.getJavaScript();
+  }
+
+  getJSActions() {
+    return this._transport.getDocJSActions();
+  }
+
+  getOutline() {
+    return this._transport.getOutline();
+  }
+
+  getOptionalContentConfig() {
+    return this._transport.getOptionalContentConfig();
+  }
+
+  getPermissions() {
+    return this._transport.getPermissions();
+  }
+
+  getMetadata() {
+    return this._transport.getMetadata();
+  }
+
+  getMarkInfo() {
+    return this._transport.getMarkInfo();
+  }
+
+  getData() {
+    return this._transport.getData();
+  }
+
+  getDownloadInfo() {
+    return this._transport.downloadInfoCapability.promise;
+  }
+
+  getStats() {
+    return this._transport.getStats();
+  }
+
+  cleanup() {
+    return this._transport.startCleanup();
+  }
+
+  destroy() {
+    return this.loadingTask.destroy();
+  }
+
+  get loadingParams() {
+    return this._transport.loadingParams;
+  }
+
+  get loadingTask() {
+    return this._transport.loadingTask;
+  }
+
+  saveDocument(annotationStorage) {
+    return this._transport.saveDocument(annotationStorage);
+  }
+
+  getFieldObjects() {
+    return this._transport.getFieldObjects();
+  }
+
+  hasJSActions() {
+    return this._transport.hasJSActions();
+  }
+
+  getCalculationOrderIds() {
+    return this._transport.getCalculationOrderIds();
+  }
+
+}
+
+exports.PDFDocumentProxy = PDFDocumentProxy;
+
+class PDFPageProxy {
+  constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {
+    this._pageIndex = pageIndex;
+    this._pageInfo = pageInfo;
+    this._ownerDocument = ownerDocument;
+    this._transport = transport;
+    this._stats = pdfBug ? new _display_utils.StatTimer() : null;
+    this._pdfBug = pdfBug;
+    this.commonObjs = transport.commonObjs;
+    this.objs = new PDFObjects();
+    this.cleanupAfterRender = false;
+    this.pendingCleanup = false;
+    this._intentStates = new Map();
+    this.destroyed = false;
+  }
+
+  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({
+    scale,
+    rotation = this.rotate,
+    offsetX = 0,
+    offsetY = 0,
+    dontFlip = false
+  } = {}) {
+    return new _display_utils.PageViewport({
+      viewBox: this.view,
+      scale,
+      rotation,
+      offsetX,
+      offsetY,
+      dontFlip
+    });
+  }
+
+  getAnnotations({
+    intent = null
+  } = {}) {
+    if (!this.annotationsPromise || this.annotationsIntent !== intent) {
+      this.annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
+      this.annotationsIntent = intent;
+    }
+
+    return this.annotationsPromise;
+  }
+
+  getJSActions() {
+    if (!this._jsActionsPromise) {
+      this._jsActionsPromise = this._transport.getPageJSActions(this._pageIndex);
+    }
+
+    return this._jsActionsPromise;
+  }
+
+  render({
+    canvasContext,
+    viewport,
+    intent = "display",
+    enableWebGL = false,
+    renderInteractiveForms = false,
+    transform = null,
+    imageLayer = null,
+    canvasFactory = null,
+    background = null,
+    annotationStorage = null,
+    optionalContentConfigPromise = null
+  }) {
+    if (this._stats) {
+      this._stats.time("Overall");
+    }
+
+    const renderingIntent = intent === "print" ? "print" : "display";
+    this.pendingCleanup = false;
+
+    if (!optionalContentConfigPromise) {
+      optionalContentConfigPromise = this._transport.getOptionalContentConfig();
+    }
+
+    let intentState = this._intentStates.get(renderingIntent);
+
+    if (!intentState) {
+      intentState = Object.create(null);
+
+      this._intentStates.set(renderingIntent, intentState);
+    }
+
+    if (intentState.streamReaderCancelTimeout) {
+      clearTimeout(intentState.streamReaderCancelTimeout);
+      intentState.streamReaderCancelTimeout = null;
+    }
+
+    const canvasFactoryInstance = canvasFactory || new DefaultCanvasFactory({
+      ownerDocument: this._ownerDocument
+    });
+    const webGLContext = new _webgl.WebGLContext({
+      enable: enableWebGL
+    });
+
+    if (!intentState.displayReadyCapability) {
+      intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
+      intentState.operatorList = {
+        fnArray: [],
+        argsArray: [],
+        lastChunk: false
+      };
+
+      if (this._stats) {
+        this._stats.time("Page Request");
+      }
+
+      this._pumpOperatorList({
+        pageIndex: this._pageIndex,
+        intent: renderingIntent,
+        renderInteractiveForms: renderInteractiveForms === true,
+        annotationStorage: annotationStorage?.getAll() || null
+      });
+    }
+
+    const complete = error => {
+      const i = intentState.renderTasks.indexOf(internalRenderTask);
+
+      if (i >= 0) {
+        intentState.renderTasks.splice(i, 1);
+      }
+
+      if (this.cleanupAfterRender || renderingIntent === "print") {
+        this.pendingCleanup = true;
+      }
+
+      this._tryCleanup();
+
+      if (error) {
+        internalRenderTask.capability.reject(error);
+
+        this._abortOperatorList({
+          intentState,
+          reason: error
+        });
+      } else {
+        internalRenderTask.capability.resolve();
+      }
+
+      if (this._stats) {
+        this._stats.timeEnd("Rendering");
+
+        this._stats.timeEnd("Overall");
+      }
+    };
+
+    const internalRenderTask = new InternalRenderTask({
+      callback: complete,
+      params: {
+        canvasContext,
+        viewport,
+        transform,
+        imageLayer,
+        background
+      },
+      objs: this.objs,
+      commonObjs: this.commonObjs,
+      operatorList: intentState.operatorList,
+      pageIndex: this._pageIndex,
+      canvasFactory: canvasFactoryInstance,
+      webGLContext,
+      useRequestAnimationFrame: renderingIntent !== "print",
+      pdfBug: this._pdfBug
+    });
+
+    if (!intentState.renderTasks) {
+      intentState.renderTasks = [];
+    }
+
+    intentState.renderTasks.push(internalRenderTask);
+    const renderTask = internalRenderTask.task;
+    Promise.all([intentState.displayReadyCapability.promise, optionalContentConfigPromise]).then(([transparency, optionalContentConfig]) => {
+      if (this.pendingCleanup) {
+        complete();
+        return;
+      }
+
+      if (this._stats) {
+        this._stats.time("Rendering");
+      }
+
+      internalRenderTask.initializeGraphics({
+        transparency,
+        optionalContentConfig
+      });
+      internalRenderTask.operatorListChanged();
+    }).catch(complete);
+    return renderTask;
+  }
+
+  getOperatorList() {
+    function operatorListChanged() {
+      if (intentState.operatorList.lastChunk) {
+        intentState.opListReadCapability.resolve(intentState.operatorList);
+        const i = intentState.renderTasks.indexOf(opListTask);
+
+        if (i >= 0) {
+          intentState.renderTasks.splice(i, 1);
+        }
+      }
+    }
+
+    const renderingIntent = "oplist";
+
+    let intentState = this._intentStates.get(renderingIntent);
+
+    if (!intentState) {
+      intentState = Object.create(null);
+
+      this._intentStates.set(renderingIntent, intentState);
+    }
+
+    let opListTask;
+
+    if (!intentState.opListReadCapability) {
+      opListTask = Object.create(null);
+      opListTask.operatorListChanged = operatorListChanged;
+      intentState.opListReadCapability = (0, _util.createPromiseCapability)();
+      intentState.renderTasks = [];
+      intentState.renderTasks.push(opListTask);
+      intentState.operatorList = {
+        fnArray: [],
+        argsArray: [],
+        lastChunk: false
+      };
+
+      if (this._stats) {
+        this._stats.time("Page Request");
+      }
+
+      this._pumpOperatorList({
+        pageIndex: this._pageIndex,
+        intent: renderingIntent
+      });
+    }
+
+    return intentState.opListReadCapability.promise;
+  }
+
+  streamTextContent({
+    normalizeWhitespace = false,
+    disableCombineTextItems = false
+  } = {}) {
+    const TEXT_CONTENT_CHUNK_SIZE = 100;
+    return this._transport.messageHandler.sendWithStream("GetTextContent", {
+      pageIndex: this._pageIndex,
+      normalizeWhitespace: normalizeWhitespace === true,
+      combineTextItems: disableCombineTextItems !== true
+    }, {
+      highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
+
+      size(textContent) {
+        return textContent.items.length;
+      }
+
+    });
+  }
+
+  getTextContent(params = {}) {
+    const readableStream = this.streamTextContent(params);
+    return new Promise(function (resolve, reject) {
+      function pump() {
+        reader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            resolve(textContent);
+            return;
+          }
+
+          Object.assign(textContent.styles, value.styles);
+          textContent.items.push(...value.items);
+          pump();
+        }, reject);
+      }
+
+      const reader = readableStream.getReader();
+      const textContent = {
+        items: [],
+        styles: Object.create(null)
+      };
+      pump();
+    });
+  }
+
+  _destroy() {
+    this.destroyed = true;
+    this._transport.pageCache[this._pageIndex] = null;
+    const waitOn = [];
+
+    for (const [intent, intentState] of this._intentStates) {
+      this._abortOperatorList({
+        intentState,
+        reason: new Error("Page was destroyed."),
+        force: true
+      });
+
+      if (intent === "oplist") {
+        continue;
+      }
+
+      for (const internalRenderTask of intentState.renderTasks) {
+        waitOn.push(internalRenderTask.completed);
+        internalRenderTask.cancel();
+      }
+    }
+
+    this.objs.clear();
+    this.annotationsPromise = null;
+    this._jsActionsPromise = null;
+    this.pendingCleanup = false;
+    return Promise.all(waitOn);
+  }
+
+  cleanup(resetStats = false) {
+    this.pendingCleanup = true;
+    return this._tryCleanup(resetStats);
+  }
+
+  _tryCleanup(resetStats = false) {
+    if (!this.pendingCleanup) {
+      return false;
+    }
+
+    for (const {
+      renderTasks,
+      operatorList
+    } of this._intentStates.values()) {
+      if (renderTasks.length !== 0 || !operatorList.lastChunk) {
+        return false;
+      }
+    }
+
+    this._intentStates.clear();
+
+    this.objs.clear();
+    this.annotationsPromise = null;
+    this._jsActionsPromise = null;
+
+    if (resetStats && this._stats) {
+      this._stats = new _display_utils.StatTimer();
+    }
+
+    this.pendingCleanup = false;
+    return true;
+  }
+
+  _startRenderPage(transparency, intent) {
+    const intentState = this._intentStates.get(intent);
+
+    if (!intentState) {
+      return;
+    }
+
+    if (this._stats) {
+      this._stats.timeEnd("Page Request");
+    }
+
+    if (intentState.displayReadyCapability) {
+      intentState.displayReadyCapability.resolve(transparency);
+    }
+  }
+
+  _renderPageChunk(operatorListChunk, intentState) {
+    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
+      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
+      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
+    }
+
+    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
+
+    for (let i = 0; i < intentState.renderTasks.length; i++) {
+      intentState.renderTasks[i].operatorListChanged();
+    }
+
+    if (operatorListChunk.lastChunk) {
+      this._tryCleanup();
+    }
+  }
+
+  _pumpOperatorList(args) {
+    (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
+
+    const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
+
+    const reader = readableStream.getReader();
+
+    const intentState = this._intentStates.get(args.intent);
+
+    intentState.streamReader = reader;
+
+    const pump = () => {
+      reader.read().then(({
+        value,
+        done
+      }) => {
+        if (done) {
+          intentState.streamReader = null;
+          return;
+        }
+
+        if (this._transport.destroyed) {
+          return;
+        }
+
+        this._renderPageChunk(value, intentState);
+
+        pump();
+      }, reason => {
+        intentState.streamReader = null;
+
+        if (this._transport.destroyed) {
+          return;
+        }
+
+        if (intentState.operatorList) {
+          intentState.operatorList.lastChunk = true;
+
+          for (let i = 0; i < intentState.renderTasks.length; i++) {
+            intentState.renderTasks[i].operatorListChanged();
+          }
+
+          this._tryCleanup();
+        }
+
+        if (intentState.displayReadyCapability) {
+          intentState.displayReadyCapability.reject(reason);
+        } else if (intentState.opListReadCapability) {
+          intentState.opListReadCapability.reject(reason);
+        } else {
+          throw reason;
+        }
+      });
+    };
+
+    pump();
+  }
+
+  _abortOperatorList({
+    intentState,
+    reason,
+    force = false
+  }) {
+    (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
+
+    if (!intentState.streamReader) {
+      return;
+    }
+
+    if (!force) {
+      if (intentState.renderTasks.length !== 0) {
+        return;
+      }
+
+      if (reason instanceof _display_utils.RenderingCancelledException) {
+        intentState.streamReaderCancelTimeout = setTimeout(() => {
+          this._abortOperatorList({
+            intentState,
+            reason,
+            force: true
+          });
+
+          intentState.streamReaderCancelTimeout = null;
+        }, RENDERING_CANCELLED_TIMEOUT);
+        return;
+      }
+    }
+
+    intentState.streamReader.cancel(new _util.AbortException(reason?.message));
+    intentState.streamReader = null;
+
+    if (this._transport.destroyed) {
+      return;
+    }
+
+    for (const [intent, curIntentState] of this._intentStates) {
+      if (curIntentState === intentState) {
+        this._intentStates.delete(intent);
+
+        break;
+      }
+    }
+
+    this.cleanup();
+  }
+
+  get stats() {
+    return this._stats;
+  }
+
+}
+
+exports.PDFPageProxy = PDFPageProxy;
+
+class LoopbackPort {
+  constructor(defer = true) {
+    this._listeners = [];
+    this._defer = defer;
+    this._deferred = Promise.resolve(undefined);
+  }
+
+  postMessage(obj, transfers) {
+    function cloneValue(value) {
+      if (typeof value !== "object" || value === null) {
+        return value;
+      }
+
+      if (cloned.has(value)) {
+        return cloned.get(value);
+      }
+
+      let buffer, result;
+
+      if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
+        if (transfers?.includes(buffer)) {
+          result = new value.constructor(buffer, value.byteOffset, value.byteLength);
+        } else {
+          result = new value.constructor(value);
+        }
+
+        cloned.set(value, result);
+        return result;
+      }
+
+      result = Array.isArray(value) ? [] : {};
+      cloned.set(value, result);
+
+      for (const i in value) {
+        let desc,
+            p = value;
+
+        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
+          p = Object.getPrototypeOf(p);
+        }
+
+        if (typeof desc.value === "undefined") {
+          continue;
+        }
+
+        if (typeof desc.value === "function") {
+          if (value.hasOwnProperty && value.hasOwnProperty(i)) {
+            throw new Error(`LoopbackPort.postMessage - cannot clone: ${value[i]}`);
+          }
+
+          continue;
+        }
+
+        result[i] = cloneValue(desc.value);
+      }
+
+      return result;
+    }
+
+    if (!this._defer) {
+      this._listeners.forEach(listener => {
+        listener.call(this, {
+          data: obj
+        });
+      });
+
+      return;
+    }
+
+    const cloned = new WeakMap();
+    const e = {
+      data: cloneValue(obj)
+    };
+
+    this._deferred.then(() => {
+      this._listeners.forEach(listener => {
+        listener.call(this, e);
+      });
+    });
+  }
+
+  addEventListener(name, listener) {
+    this._listeners.push(listener);
+  }
+
+  removeEventListener(name, listener) {
+    const i = this._listeners.indexOf(listener);
+
+    this._listeners.splice(i, 1);
+  }
+
+  terminate() {
+    this._listeners.length = 0;
+  }
+
+}
+
+exports.LoopbackPort = LoopbackPort;
+
+const PDFWorker = function PDFWorkerClosure() {
+  const pdfWorkerPorts = new WeakMap();
+  let isWorkerDisabled = false;
+  let fallbackWorkerSrc;
+  let nextFakeWorkerId = 0;
+  let fakeWorkerCapability;
+
+  function getWorkerSrc() {
+    if (_worker_options.GlobalWorkerOptions.workerSrc) {
+      return _worker_options.GlobalWorkerOptions.workerSrc;
+    }
+
+    if (typeof fallbackWorkerSrc !== "undefined") {
+      if (!_is_node.isNodeJS) {
+        (0, _display_utils.deprecated)('No "GlobalWorkerOptions.workerSrc" specified.');
+      }
+
+      return fallbackWorkerSrc;
+    }
+
+    throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
+  }
+
+  function getMainThreadWorkerMessageHandler() {
+    let mainWorkerMessageHandler;
+
+    try {
+      mainWorkerMessageHandler = globalThis.pdfjsWorker?.WorkerMessageHandler;
+    } catch (ex) {}
+
+    return mainWorkerMessageHandler || null;
+  }
+
+  function setupFakeWorkerGlobal() {
+    if (fakeWorkerCapability) {
+      return fakeWorkerCapability.promise;
+    }
+
+    fakeWorkerCapability = (0, _util.createPromiseCapability)();
+
+    const loader = async function () {
+      const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
+
+      if (mainWorkerMessageHandler) {
+        return mainWorkerMessageHandler;
+      }
+
+      await (0, _display_utils.loadScript)(getWorkerSrc());
+      return window.pdfjsWorker.WorkerMessageHandler;
+    };
+
+    loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);
+    return fakeWorkerCapability.promise;
+  }
+
+  function createCDNWrapper(url) {
+    const wrapper = "importScripts('" + url + "');";
+    return URL.createObjectURL(new Blob([wrapper]));
+  }
+
+  class PDFWorker {
+    constructor({
+      name = null,
+      port = null,
+      verbosity = (0, _util.getVerbosityLevel)()
+    } = {}) {
+      if (port && pdfWorkerPorts.has(port)) {
+        throw new Error("Cannot use more than one PDFWorker per port");
+      }
+
+      this.name = name;
+      this.destroyed = false;
+      this.postMessageTransfers = true;
+      this.verbosity = verbosity;
+      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();
+    }
+
+    get promise() {
+      return this._readyCapability.promise;
+    }
+
+    get port() {
+      return this._port;
+    }
+
+    get messageHandler() {
+      return this._messageHandler;
+    }
+
+    _initializeFromPort(port) {
+      this._port = port;
+      this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
+
+      this._messageHandler.on("ready", function () {});
+
+      this._readyCapability.resolve();
+    }
+
+    _initialize() {
+      if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
+        let workerSrc = getWorkerSrc();
+
+        try {
+          const worker = new Worker(workerSrc);
+          const messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
+
+          const terminateEarly = () => {
+            worker.removeEventListener("error", onWorkerError);
+            messageHandler.destroy();
+            worker.terminate();
+
+            if (this.destroyed) {
+              this._readyCapability.reject(new Error("Worker was destroyed"));
+            } else {
+              this._setupFakeWorker();
+            }
+          };
+
+          const onWorkerError = () => {
+            if (!this._webWorker) {
+              terminateEarly();
+            }
+          };
+
+          worker.addEventListener("error", onWorkerError);
+          messageHandler.on("test", data => {
+            worker.removeEventListener("error", onWorkerError);
+
+            if (this.destroyed) {
+              terminateEarly();
+              return;
+            }
+
+            if (data) {
+              this._messageHandler = messageHandler;
+              this._port = worker;
+              this._webWorker = worker;
+
+              if (!data.supportTransfers) {
+                this.postMessageTransfers = false;
+              }
+
+              this._readyCapability.resolve();
+
+              messageHandler.send("configure", {
+                verbosity: this.verbosity
+              });
+            } else {
+              this._setupFakeWorker();
+
+              messageHandler.destroy();
+              worker.terminate();
+            }
+          });
+          messageHandler.on("ready", data => {
+            worker.removeEventListener("error", onWorkerError);
+
+            if (this.destroyed) {
+              terminateEarly();
+              return;
+            }
+
+            try {
+              sendTest();
+            } catch (e) {
+              this._setupFakeWorker();
+            }
+          });
+
+          const sendTest = () => {
+            const testObj = new Uint8Array([this.postMessageTransfers ? 255 : 0]);
+
+            try {
+              messageHandler.send("test", testObj, [testObj.buffer]);
+            } catch (ex) {
+              (0, _util.warn)("Cannot use postMessage transfers.");
+              testObj[0] = 0;
+              messageHandler.send("test", testObj);
+            }
+          };
+
+          sendTest();
+          return;
+        } catch (e) {
+          (0, _util.info)("The worker has been disabled.");
+        }
+      }
+
+      this._setupFakeWorker();
+    }
+
+    _setupFakeWorker() {
+      if (!isWorkerDisabled) {
+        (0, _util.warn)("Setting up fake worker.");
+        isWorkerDisabled = true;
+      }
+
+      setupFakeWorkerGlobal().then(WorkerMessageHandler => {
+        if (this.destroyed) {
+          this._readyCapability.reject(new Error("Worker was destroyed"));
+
+          return;
+        }
+
+        const port = new LoopbackPort();
+        this._port = port;
+        const id = "fake" + nextFakeWorkerId++;
+        const workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
+        WorkerMessageHandler.setup(workerHandler, port);
+        const messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
+        this._messageHandler = messageHandler;
+
+        this._readyCapability.resolve();
+
+        messageHandler.send("configure", {
+          verbosity: this.verbosity
+        });
+      }).catch(reason => {
+        this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`));
+      });
+    }
+
+    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;
+      }
+    }
+
+    static fromPort(params) {
+      if (!params || !params.port) {
+        throw new Error("PDFWorker.fromPort - invalid method signature.");
+      }
+
+      if (pdfWorkerPorts.has(params.port)) {
+        return pdfWorkerPorts.get(params.port);
+      }
+
+      return new PDFWorker(params);
+    }
+
+    static getWorkerSrc() {
+      return getWorkerSrc();
+    }
+
+  }
+
+  return PDFWorker;
+}();
+
+exports.PDFWorker = PDFWorker;
+
+class WorkerTransport {
+  constructor(messageHandler, loadingTask, networkStream, params) {
+    this.messageHandler = messageHandler;
+    this.loadingTask = loadingTask;
+    this.commonObjs = new PDFObjects();
+    this.fontLoader = new _font_loader.FontLoader({
+      docId: loadingTask.docId,
+      onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
+      ownerDocument: params.ownerDocument
+    });
+    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();
+  }
+
+  get loadingTaskSettled() {
+    return this.loadingTask._capability.settled;
+  }
+
+  destroy() {
+    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"));
+    }
+
+    const waitOn = [];
+    this.pageCache.forEach(function (page) {
+      if (page) {
+        waitOn.push(page._destroy());
+      }
+    });
+    this.pageCache.length = 0;
+    this.pagePromises.length = 0;
+    const terminated = this.messageHandler.sendWithPromise("Terminate", null);
+    waitOn.push(terminated);
+
+    if (this.loadingTaskSettled) {
+      const annotationStorageResetModified = this.loadingTask.promise.then(pdfDocument => {
+        if (pdfDocument.hasOwnProperty("annotationStorage")) {
+          pdfDocument.annotationStorage.resetModified();
+        }
+      }).catch(() => {});
+      waitOn.push(annotationStorageResetModified);
+    }
+
+    Promise.all(waitOn).then(() => {
+      this.commonObjs.clear();
+      this.fontLoader.clear();
+      this._hasJSActionsPromise = null;
+
+      if (this._networkStream) {
+        this._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
+      }
+
+      if (this.messageHandler) {
+        this.messageHandler.destroy();
+        this.messageHandler = null;
+      }
+
+      this.destroyCapability.resolve();
+    }, this.destroyCapability.reject);
+    return this.destroyCapability.promise;
+  }
+
+  setupMessageHandler() {
+    const {
+      messageHandler,
+      loadingTask
+    } = this;
+    messageHandler.on("GetReader", (data, sink) => {
+      (0, _util.assert)(this._networkStream, "GetReader - no `IPDFStream` instance available.");
+      this._fullReader = this._networkStream.getFullReader();
+
+      this._fullReader.onProgress = evt => {
+        this._lastProgress = {
+          loaded: evt.loaded,
+          total: evt.total
+        };
+      };
+
+      sink.onPull = () => {
+        this._fullReader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            sink.close();
+            return;
+          }
+
+          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
+          sink.enqueue(new Uint8Array(value), 1, [value]);
+        }).catch(reason => {
+          sink.error(reason);
+        });
+      };
+
+      sink.onCancel = reason => {
+        this._fullReader.cancel(reason);
+
+        sink.ready.catch(readyReason => {
+          if (this.destroyed) {
+            return;
+          }
+
+          throw readyReason;
+        });
+      };
+    });
+    messageHandler.on("ReaderHeadersReady", data => {
+      const headersCapability = (0, _util.createPromiseCapability)();
+      const fullReader = this._fullReader;
+      fullReader.headersReady.then(() => {
+        if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
+          if (this._lastProgress && loadingTask.onProgress) {
+            loadingTask.onProgress(this._lastProgress);
+          }
+
+          fullReader.onProgress = evt => {
+            if (loadingTask.onProgress) {
+              loadingTask.onProgress({
+                loaded: evt.loaded,
+                total: evt.total
+              });
+            }
+          };
+        }
+
+        headersCapability.resolve({
+          isStreamingSupported: fullReader.isStreamingSupported,
+          isRangeSupported: fullReader.isRangeSupported,
+          contentLength: fullReader.contentLength
+        });
+      }, headersCapability.reject);
+      return headersCapability.promise;
+    });
+    messageHandler.on("GetRangeReader", (data, sink) => {
+      (0, _util.assert)(this._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
+
+      const rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
+
+      if (!rangeReader) {
+        sink.close();
+        return;
+      }
+
+      sink.onPull = () => {
+        rangeReader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            sink.close();
+            return;
+          }
+
+          (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
+          sink.enqueue(new Uint8Array(value), 1, [value]);
+        }).catch(reason => {
+          sink.error(reason);
+        });
+      };
+
+      sink.onCancel = reason => {
+        rangeReader.cancel(reason);
+        sink.ready.catch(readyReason => {
+          if (this.destroyed) {
+            return;
+          }
+
+          throw readyReason;
+        });
+      };
+    });
+    messageHandler.on("GetDoc", ({
+      pdfInfo
+    }) => {
+      this._numPages = pdfInfo.numPages;
+
+      loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));
+    });
+    messageHandler.on("DocException", function (ex) {
+      let reason;
+
+      switch (ex.name) {
+        case "PasswordException":
+          reason = new _util.PasswordException(ex.message, ex.code);
+          break;
+
+        case "InvalidPDFException":
+          reason = new _util.InvalidPDFException(ex.message);
+          break;
+
+        case "MissingPDFException":
+          reason = new _util.MissingPDFException(ex.message);
+          break;
+
+        case "UnexpectedResponseException":
+          reason = new _util.UnexpectedResponseException(ex.message, ex.status);
+          break;
+
+        case "UnknownErrorException":
+          reason = new _util.UnknownErrorException(ex.message, ex.details);
+          break;
+      }
+
+      if (!(reason instanceof Error)) {
+        const msg = "DocException - expected a valid Error.";
+        (0, _util.warn)(msg);
+      }
+
+      loadingTask._capability.reject(reason);
+    });
+    messageHandler.on("PasswordRequest", exception => {
+      this._passwordCapability = (0, _util.createPromiseCapability)();
+
+      if (loadingTask.onPassword) {
+        const updatePassword = password => {
+          this._passwordCapability.resolve({
+            password
+          });
+        };
+
+        try {
+          loadingTask.onPassword(updatePassword, exception.code);
+        } catch (ex) {
+          this._passwordCapability.reject(ex);
+        }
+      } else {
+        this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
+      }
+
+      return this._passwordCapability.promise;
+    });
+    messageHandler.on("DataLoaded", data => {
+      if (loadingTask.onProgress) {
+        loadingTask.onProgress({
+          loaded: data.length,
+          total: data.length
+        });
+      }
+
+      this.downloadInfoCapability.resolve(data);
+    });
+    messageHandler.on("StartRenderPage", data => {
+      if (this.destroyed) {
+        return;
+      }
+
+      const page = this.pageCache[data.pageIndex];
+
+      page._startRenderPage(data.transparency, data.intent);
+    });
+    messageHandler.on("commonobj", data => {
+      if (this.destroyed) {
+        return;
+      }
+
+      const [id, type, exportedData] = data;
+
+      if (this.commonObjs.has(id)) {
+        return;
+      }
+
+      switch (type) {
+        case "Font":
+          const params = this._params;
+
+          if ("error" in exportedData) {
+            const exportedError = exportedData.error;
+            (0, _util.warn)(`Error during font loading: ${exportedError}`);
+            this.commonObjs.resolve(id, exportedError);
+            break;
+          }
+
+          let fontRegistry = null;
+
+          if (params.pdfBug && globalThis.FontInspector?.enabled) {
+            fontRegistry = {
+              registerFont(font, url) {
+                globalThis.FontInspector.fontAdded(font, url);
+              }
+
+            };
+          }
+
+          const font = new _font_loader.FontFaceObject(exportedData, {
+            isEvalSupported: params.isEvalSupported,
+            disableFontFace: params.disableFontFace,
+            ignoreErrors: params.ignoreErrors,
+            onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
+            fontRegistry
+          });
+          this.fontLoader.bind(font).catch(reason => {
+            return messageHandler.sendWithPromise("FontFallback", {
+              id
+            });
+          }).finally(() => {
+            if (!params.fontExtraProperties && font.data) {
+              font.data = null;
+            }
+
+            this.commonObjs.resolve(id, font);
+          });
+          break;
+
+        case "FontPath":
+        case "Image":
+          this.commonObjs.resolve(id, exportedData);
+          break;
+
+        default:
+          throw new Error(`Got unknown common object type ${type}`);
+      }
+    });
+    messageHandler.on("obj", data => {
+      if (this.destroyed) {
+        return undefined;
+      }
+
+      const [id, pageIndex, type, imageData] = data;
+      const pageProxy = this.pageCache[pageIndex];
+
+      if (pageProxy.objs.has(id)) {
+        return undefined;
+      }
+
+      switch (type) {
+        case "Image":
+          pageProxy.objs.resolve(id, imageData);
+          const MAX_IMAGE_SIZE_TO_STORE = 8000000;
+
+          if (imageData?.data?.length > MAX_IMAGE_SIZE_TO_STORE) {
+            pageProxy.cleanupAfterRender = true;
+          }
+
+          break;
+
+        default:
+          throw new Error(`Got unknown object type ${type}`);
+      }
+
+      return undefined;
+    });
+    messageHandler.on("DocProgress", data => {
+      if (this.destroyed) {
+        return;
+      }
+
+      if (loadingTask.onProgress) {
+        loadingTask.onProgress({
+          loaded: data.loaded,
+          total: data.total
+        });
+      }
+    });
+    messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
+    messageHandler.on("FetchBuiltInCMap", (data, sink) => {
+      if (this.destroyed) {
+        sink.error(new Error("Worker was destroyed"));
+        return;
+      }
+
+      let fetched = false;
+
+      sink.onPull = () => {
+        if (fetched) {
+          sink.close();
+          return;
+        }
+
+        fetched = true;
+        this.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
+          sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
+        }).catch(function (reason) {
+          sink.error(reason);
+        });
+      };
+    });
+  }
+
+  _onUnsupportedFeature({
+    featureId
+  }) {
+    if (this.destroyed) {
+      return;
+    }
+
+    if (this.loadingTask.onUnsupportedFeature) {
+      this.loadingTask.onUnsupportedFeature(featureId);
+    }
+  }
+
+  getData() {
+    return this.messageHandler.sendWithPromise("GetData", null);
+  }
+
+  getPage(pageNumber) {
+    if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
+      return Promise.reject(new Error("Invalid page request"));
+    }
+
+    const pageIndex = pageNumber - 1;
+
+    if (pageIndex in this.pagePromises) {
+      return this.pagePromises[pageIndex];
+    }
+
+    const promise = this.messageHandler.sendWithPromise("GetPage", {
+      pageIndex
+    }).then(pageInfo => {
+      if (this.destroyed) {
+        throw new Error("Transport destroyed");
+      }
+
+      const page = new PDFPageProxy(pageIndex, pageInfo, this, this._params.ownerDocument, this._params.pdfBug);
+      this.pageCache[pageIndex] = page;
+      return page;
+    });
+    this.pagePromises[pageIndex] = promise;
+    return promise;
+  }
+
+  getPageIndex(ref) {
+    return this.messageHandler.sendWithPromise("GetPageIndex", {
+      ref
+    }).catch(function (reason) {
+      return Promise.reject(new Error(reason));
+    });
+  }
+
+  getAnnotations(pageIndex, intent) {
+    return this.messageHandler.sendWithPromise("GetAnnotations", {
+      pageIndex,
+      intent
+    });
+  }
+
+  saveDocument(annotationStorage) {
+    return this.messageHandler.sendWithPromise("SaveDocument", {
+      numPages: this._numPages,
+      annotationStorage: annotationStorage?.getAll() || null,
+      filename: this._fullReader ? this._fullReader.filename : null
+    }).finally(() => {
+      if (annotationStorage) {
+        annotationStorage.resetModified();
+      }
+    });
+  }
+
+  getFieldObjects() {
+    return this.messageHandler.sendWithPromise("GetFieldObjects", null);
+  }
+
+  hasJSActions() {
+    return this._hasJSActionsPromise || (this._hasJSActionsPromise = this.messageHandler.sendWithPromise("HasJSActions", null));
+  }
+
+  getCalculationOrderIds() {
+    return this.messageHandler.sendWithPromise("GetCalculationOrderIds", null);
+  }
+
+  getDestinations() {
+    return this.messageHandler.sendWithPromise("GetDestinations", null);
+  }
+
+  getDestination(id) {
+    if (typeof id !== "string") {
+      return Promise.reject(new Error("Invalid destination request."));
+    }
+
+    return this.messageHandler.sendWithPromise("GetDestination", {
+      id
+    });
+  }
+
+  getPageLabels() {
+    return this.messageHandler.sendWithPromise("GetPageLabels", null);
+  }
+
+  getPageLayout() {
+    return this.messageHandler.sendWithPromise("GetPageLayout", null);
+  }
+
+  getPageMode() {
+    return this.messageHandler.sendWithPromise("GetPageMode", null);
+  }
+
+  getViewerPreferences() {
+    return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
+  }
+
+  getOpenAction() {
+    return this.messageHandler.sendWithPromise("GetOpenAction", null);
+  }
+
+  getAttachments() {
+    return this.messageHandler.sendWithPromise("GetAttachments", null);
+  }
+
+  getJavaScript() {
+    return this.messageHandler.sendWithPromise("GetJavaScript", null);
+  }
+
+  getDocJSActions() {
+    return this.messageHandler.sendWithPromise("GetDocJSActions", null);
+  }
+
+  getPageJSActions(pageIndex) {
+    return this.messageHandler.sendWithPromise("GetPageJSActions", {
+      pageIndex
+    });
+  }
+
+  getOutline() {
+    return this.messageHandler.sendWithPromise("GetOutline", null);
+  }
+
+  getOptionalContentConfig() {
+    return this.messageHandler.sendWithPromise("GetOptionalContentConfig", null).then(results => {
+      return new _optional_content_config.OptionalContentConfig(results);
+    });
+  }
+
+  getPermissions() {
+    return this.messageHandler.sendWithPromise("GetPermissions", null);
+  }
+
+  getMetadata() {
+    return this.messageHandler.sendWithPromise("GetMetadata", null).then(results => {
+      return {
+        info: results[0],
+        metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
+        contentDispositionFilename: this._fullReader?.filename ?? null,
+        contentLength: this._fullReader?.contentLength ?? null
+      };
+    });
+  }
+
+  getMarkInfo() {
+    return this.messageHandler.sendWithPromise("GetMarkInfo", null);
+  }
+
+  getStats() {
+    return this.messageHandler.sendWithPromise("GetStats", null);
+  }
+
+  startCleanup() {
+    return this.messageHandler.sendWithPromise("Cleanup", null).then(() => {
+      for (let i = 0, ii = this.pageCache.length; i < ii; i++) {
+        const page = this.pageCache[i];
+
+        if (page) {
+          const cleanupSuccessful = page.cleanup();
+
+          if (!cleanupSuccessful) {
+            throw new Error(`startCleanup: Page ${i + 1} is currently rendering.`);
+          }
+        }
+      }
+
+      this.commonObjs.clear();
+      this.fontLoader.clear();
+      this._hasJSActionsPromise = null;
+    });
+  }
+
+  get loadingParams() {
+    const params = this._params;
+    return (0, _util.shadow)(this, "loadingParams", {
+      disableAutoFetch: params.disableAutoFetch,
+      disableFontFace: params.disableFontFace
+    });
+  }
+
+}
+
+class PDFObjects {
+  constructor() {
+    this._objs = Object.create(null);
+  }
+
+  _ensureObj(objId) {
+    if (this._objs[objId]) {
+      return this._objs[objId];
+    }
+
+    return this._objs[objId] = {
+      capability: (0, _util.createPromiseCapability)(),
+      data: null,
+      resolved: false
+    };
+  }
+
+  get(objId, callback = null) {
+    if (callback) {
+      this._ensureObj(objId).capability.promise.then(callback);
+
+      return null;
+    }
+
+    const obj = this._objs[objId];
+
+    if (!obj || !obj.resolved) {
+      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
+    }
+
+    return obj.data;
+  }
+
+  has(objId) {
+    const obj = this._objs[objId];
+    return obj ? obj.resolved : false;
+  }
+
+  resolve(objId, data) {
+    const obj = this._ensureObj(objId);
+
+    obj.resolved = true;
+    obj.data = data;
+    obj.capability.resolve(data);
+  }
+
+  clear() {
+    this._objs = Object.create(null);
+  }
+
+}
+
+class RenderTask {
+  constructor(internalRenderTask) {
+    this._internalRenderTask = internalRenderTask;
+    this.onContinue = null;
+  }
+
+  get promise() {
+    return this._internalRenderTask.capability.promise;
+  }
+
+  cancel() {
+    this._internalRenderTask.cancel();
+  }
+
+}
+
+const InternalRenderTask = function InternalRenderTaskClosure() {
+  const canvasInRendering = new WeakSet();
+
+  class InternalRenderTask {
+    constructor({
+      callback,
+      params,
+      objs,
+      commonObjs,
+      operatorList,
+      pageIndex,
+      canvasFactory,
+      webGLContext,
+      useRequestAnimationFrame = false,
+      pdfBug = false
+    }) {
+      this.callback = callback;
+      this.params = params;
+      this.objs = objs;
+      this.commonObjs = commonObjs;
+      this.operatorListIdx = null;
+      this.operatorList = operatorList;
+      this._pageIndex = pageIndex;
+      this.canvasFactory = canvasFactory;
+      this.webGLContext = webGLContext;
+      this._pdfBug = pdfBug;
+      this.running = false;
+      this.graphicsReadyCallback = null;
+      this.graphicsReady = false;
+      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== "undefined";
+      this.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;
+    }
+
+    get completed() {
+      return this.capability.promise.catch(function () {});
+    }
+
+    initializeGraphics({
+      transparency = false,
+      optionalContentConfig
+    }) {
+      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 && globalThis.StepperManager?.enabled) {
+        this.stepper = globalThis.StepperManager.create(this._pageIndex);
+        this.stepper.init(this.operatorList);
+        this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
+      }
+
+      const {
+        canvasContext,
+        viewport,
+        transform,
+        imageLayer,
+        background
+      } = this.params;
+      this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer, optionalContentConfig);
+      this.gfx.beginDrawing({
+        transform,
+        viewport,
+        transparency,
+        background
+      });
+      this.operatorListIdx = 0;
+      this.graphicsReady = true;
+
+      if (this.graphicsReadyCallback) {
+        this.graphicsReadyCallback();
+      }
+    }
+
+    cancel(error = null) {
+      this.running = false;
+      this.cancelled = true;
+
+      if (this.gfx) {
+        this.gfx.endDrawing();
+      }
+
+      if (this._canvas) {
+        canvasInRendering.delete(this._canvas);
+      }
+
+      this.callback(error || new _display_utils.RenderingCancelledException(`Rendering cancelled, page ${this._pageIndex + 1}`, "canvas"));
+    }
+
+    operatorListChanged() {
+      if (!this.graphicsReady) {
+        if (!this.graphicsReadyCallback) {
+          this.graphicsReadyCallback = this._continueBound;
+        }
+
+        return;
+      }
+
+      if (this.stepper) {
+        this.stepper.updateOperatorList(this.operatorList);
+      }
+
+      if (this.running) {
+        return;
+      }
+
+      this._continue();
+    }
+
+    _continue() {
+      this.running = true;
+
+      if (this.cancelled) {
+        return;
+      }
+
+      if (this.task.onContinue) {
+        this.task.onContinue(this._scheduleNextBound);
+      } else {
+        this._scheduleNext();
+      }
+    }
+
+    _scheduleNext() {
+      if (this._useRequestAnimationFrame) {
+        window.requestAnimationFrame(() => {
+          this._nextBound().catch(this.cancel.bind(this));
+        });
+      } else {
+        Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));
+      }
+    }
+
+    async _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) {
+        this.running = false;
+
+        if (this.operatorList.lastChunk) {
+          this.gfx.endDrawing();
+
+          if (this._canvas) {
+            canvasInRendering.delete(this._canvas);
+          }
+
+          this.callback();
+        }
+      }
+    }
+
+  }
+
+  return InternalRenderTask;
+}();
+
+const version = '2.7.510';
+exports.version = version;
+const build = '631bada0d';
+exports.build = build;
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.FontLoader = exports.FontFaceObject = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class BaseFontLoader {
+  constructor({
+    docId,
+    onUnsupportedFeature,
+    ownerDocument = globalThis.document
+  }) {
+    if (this.constructor === BaseFontLoader) {
+      (0, _util.unreachable)("Cannot initialize BaseFontLoader.");
+    }
+
+    this.docId = docId;
+    this._onUnsupportedFeature = onUnsupportedFeature;
+    this._document = ownerDocument;
+    this.nativeFontFaces = [];
+    this.styleElement = null;
+  }
+
+  addNativeFontFace(nativeFontFace) {
+    this.nativeFontFaces.push(nativeFontFace);
+
+    this._document.fonts.add(nativeFontFace);
+  }
+
+  insertRule(rule) {
+    let styleElement = this.styleElement;
+
+    if (!styleElement) {
+      styleElement = this.styleElement = this._document.createElement("style");
+      styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;
+
+      this._document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement);
+    }
+
+    const styleSheet = styleElement.sheet;
+    styleSheet.insertRule(rule, styleSheet.cssRules.length);
+  }
+
+  clear() {
+    this.nativeFontFaces.forEach(nativeFontFace => {
+      this._document.fonts.delete(nativeFontFace);
+    });
+    this.nativeFontFaces.length = 0;
+
+    if (this.styleElement) {
+      this.styleElement.remove();
+      this.styleElement = null;
+    }
+  }
+
+  async bind(font) {
+    if (font.attached || font.missingFile) {
+      return;
+    }
+
+    font.attached = true;
+
+    if (this.isFontLoadingAPISupported) {
+      const nativeFontFace = font.createNativeFontFace();
+
+      if (nativeFontFace) {
+        this.addNativeFontFace(nativeFontFace);
+
+        try {
+          await nativeFontFace.loaded;
+        } catch (ex) {
+          this._onUnsupportedFeature({
+            featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative
+          });
+
+          (0, _util.warn)(`Failed to load font '${nativeFontFace.family}': '${ex}'.`);
+          font.disableFontFace = true;
+          throw ex;
+        }
+      }
+
+      return;
+    }
+
+    const rule = font.createFontFaceRule();
+
+    if (rule) {
+      this.insertRule(rule);
+
+      if (this.isSyncFontLoadingSupported) {
+        return;
+      }
+
+      await new Promise(resolve => {
+        const request = this._queueLoadingCallback(resolve);
+
+        this._prepareFontLoadEvent([rule], [font], request);
+      });
+    }
+  }
+
+  _queueLoadingCallback(callback) {
+    (0, _util.unreachable)("Abstract method `_queueLoadingCallback`.");
+  }
+
+  get isFontLoadingAPISupported() {
+    return (0, _util.shadow)(this, "isFontLoadingAPISupported", !!this._document?.fonts);
+  }
+
+  get isSyncFontLoadingSupported() {
+    (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`.");
+  }
+
+  get _loadTestFont() {
+    (0, _util.unreachable)("Abstract method `_loadTestFont`.");
+  }
+
+  _prepareFontLoadEvent(rules, fontsToLoad, request) {
+    (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`.");
+  }
+
+}
+
+let FontLoader;
+exports.FontLoader = FontLoader;
+{
+  exports.FontLoader = FontLoader = class MozcentralFontLoader extends BaseFontLoader {
+    get isSyncFontLoadingSupported() {
+      return (0, _util.shadow)(this, "isSyncFontLoadingSupported", true);
+    }
+
+  };
+}
+
+class FontFaceObject {
+  constructor(translatedData, {
+    isEvalSupported = true,
+    disableFontFace = false,
+    ignoreErrors = false,
+    onUnsupportedFeature = null,
+    fontRegistry = null
+  }) {
+    this.compiledGlyphs = Object.create(null);
+
+    for (const i in translatedData) {
+      this[i] = translatedData[i];
+    }
+
+    this.isEvalSupported = isEvalSupported !== false;
+    this.disableFontFace = disableFontFace === true;
+    this.ignoreErrors = ignoreErrors === true;
+    this._onUnsupportedFeature = onUnsupportedFeature;
+    this.fontRegistry = fontRegistry;
+  }
+
+  createNativeFontFace() {
+    if (!this.data || this.disableFontFace) {
+      return null;
+    }
+
+    const nativeFontFace = new FontFace(this.loadedName, this.data, {});
+
+    if (this.fontRegistry) {
+      this.fontRegistry.registerFont(this);
+    }
+
+    return nativeFontFace;
+  }
+
+  createFontFaceRule() {
+    if (!this.data || this.disableFontFace) {
+      return null;
+    }
+
+    const data = (0, _util.bytesToString)(new Uint8Array(this.data));
+    const url = `url(data:${this.mimetype};base64,${btoa(data)});`;
+    const rule = `@font-face {font-family:"${this.loadedName}";src:${url}}`;
+
+    if (this.fontRegistry) {
+      this.fontRegistry.registerFont(this, url);
+    }
+
+    return rule;
+  }
+
+  getPathGenerator(objs, character) {
+    if (this.compiledGlyphs[character] !== undefined) {
+      return this.compiledGlyphs[character];
+    }
+
+    let cmds, current;
+
+    try {
+      cmds = objs.get(this.loadedName + "_path_" + character);
+    } catch (ex) {
+      if (!this.ignoreErrors) {
+        throw ex;
+      }
+
+      if (this._onUnsupportedFeature) {
+        this._onUnsupportedFeature({
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath
+        });
+      }
+
+      (0, _util.warn)(`getPathGenerator - ignoring character: "${ex}".`);
+      return this.compiledGlyphs[character] = function (c, size) {};
+    }
+
+    if (this.isEvalSupported && _util.IsEvalSupportedCached.value) {
+      let args,
+          js = "";
+
+      for (let i = 0, ii = cmds.length; i < ii; i++) {
+        current = cmds[i];
+
+        if (current.args !== undefined) {
+          args = current.args.join(",");
+        } else {
+          args = "";
+        }
+
+        js += "c." + current.cmd + "(" + args + ");\n";
+      }
+
+      return this.compiledGlyphs[character] = new Function("c", "size", js);
+    }
+
+    return this.compiledGlyphs[character] = function (c, size) {
+      for (let i = 0, ii = cmds.length; i < ii; i++) {
+        current = cmds[i];
+
+        if (current.cmd === "scale") {
+          current.args = [size, -size];
+        }
+
+        c[current.cmd].apply(c, current.args);
+      }
+    };
+  }
+
+}
+
+exports.FontFaceObject = FontFaceObject;
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = void 0;
+
+var _display_utils = __w_pdfjs_require__(1);
+
+var _is_node = __w_pdfjs_require__(4);
+
+var _util = __w_pdfjs_require__(2);
+
+let NodeCanvasFactory = class {
+  constructor() {
+    (0, _util.unreachable)("Not implemented: NodeCanvasFactory");
+  }
+
+};
+exports.NodeCanvasFactory = NodeCanvasFactory;
+let NodeCMapReaderFactory = class {
+  constructor() {
+    (0, _util.unreachable)("Not implemented: NodeCMapReaderFactory");
+  }
+
+};
+exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
+;
+
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.AnnotationStorage = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class AnnotationStorage {
+  constructor() {
+    this._storage = new Map();
+    this._modified = false;
+    this.onSetModified = null;
+    this.onResetModified = null;
+  }
+
+  getOrCreateValue(key, defaultValue) {
+    if (this._storage.has(key)) {
+      return this._storage.get(key);
+    }
+
+    this._storage.set(key, defaultValue);
+
+    return defaultValue;
+  }
+
+  setValue(key, value) {
+    const obj = this._storage.get(key);
+
+    let modified = false;
+
+    if (obj !== undefined) {
+      for (const [entry, val] of Object.entries(value)) {
+        if (obj[entry] !== val) {
+          modified = true;
+          obj[entry] = val;
+        }
+      }
+    } else {
+      this._storage.set(key, value);
+
+      modified = true;
+    }
+
+    if (modified) {
+      this._setModified();
+    }
+  }
+
+  getAll() {
+    if (this._storage.size === 0) {
+      return null;
+    }
+
+    return (0, _util.objectFromEntries)(this._storage);
+  }
+
+  get size() {
+    return this._storage.size;
+  }
+
+  _setModified() {
+    if (!this._modified) {
+      this._modified = true;
+
+      if (typeof this.onSetModified === "function") {
+        this.onSetModified();
+      }
+    }
+  }
+
+  resetModified() {
+    if (this._modified) {
+      this._modified = false;
+
+      if (typeof this.onResetModified === "function") {
+        this.onResetModified();
+      }
+    }
+  }
+
+}
+
+exports.AnnotationStorage = AnnotationStorage;
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.apiCompatibilityParams = void 0;
+
+var _is_node = __w_pdfjs_require__(4);
+
+const compatibilityParams = Object.create(null);
+;
+const apiCompatibilityParams = Object.freeze(compatibilityParams);
+exports.apiCompatibilityParams = apiCompatibilityParams;
+
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.CanvasGraphics = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _pattern_helper = __w_pdfjs_require__(11);
+
+const MIN_FONT_SIZE = 16;
+const MAX_FONT_SIZE = 100;
+const MAX_GROUP_SIZE = 4096;
+const MIN_WIDTH_FACTOR = 0.65;
+const COMPILE_TYPE3_GLYPHS = true;
+const MAX_SIZE_TO_COMPILE = 1000;
+const FULL_CHUNK_HEIGHT = 16;
+
+function addContextCurrentTransform(ctx) {
+  if (!ctx.mozCurrentTransform) {
+    ctx._originalSave = ctx.save;
+    ctx._originalRestore = ctx.restore;
+    ctx._originalRotate = ctx.rotate;
+    ctx._originalScale = ctx.scale;
+    ctx._originalTranslate = ctx.translate;
+    ctx._originalTransform = ctx.transform;
+    ctx._originalSetTransform = ctx.setTransform;
+    ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];
+    ctx._transformStack = [];
+    Object.defineProperty(ctx, "mozCurrentTransform", {
+      get: function getCurrentTransform() {
+        return this._transformMatrix;
+      }
+    });
+    Object.defineProperty(ctx, "mozCurrentTransformInverse", {
+      get: function getCurrentTransformInverse() {
+        const m = this._transformMatrix;
+        const a = m[0],
+              b = m[1],
+              c = m[2],
+              d = m[3],
+              e = m[4],
+              f = m[5];
+        const ad_bc = a * d - b * c;
+        const bc_ad = b * c - a * d;
+        return [d / ad_bc, b / bc_ad, c / bc_ad, a / ad_bc, (d * e - c * f) / bc_ad, (b * e - a * f) / ad_bc];
+      }
+    });
+
+    ctx.save = function ctxSave() {
+      const old = this._transformMatrix;
+
+      this._transformStack.push(old);
+
+      this._transformMatrix = old.slice(0, 6);
+
+      this._originalSave();
+    };
+
+    ctx.restore = function ctxRestore() {
+      const prev = this._transformStack.pop();
+
+      if (prev) {
+        this._transformMatrix = prev;
+
+        this._originalRestore();
+      }
+    };
+
+    ctx.translate = function ctxTranslate(x, y) {
+      const m = this._transformMatrix;
+      m[4] = m[0] * x + m[2] * y + m[4];
+      m[5] = m[1] * x + m[3] * y + m[5];
+
+      this._originalTranslate(x, y);
+    };
+
+    ctx.scale = function ctxScale(x, y) {
+      const m = this._transformMatrix;
+      m[0] = m[0] * x;
+      m[1] = m[1] * x;
+      m[2] = m[2] * y;
+      m[3] = m[3] * y;
+
+      this._originalScale(x, y);
+    };
+
+    ctx.transform = function ctxTransform(a, b, c, d, e, f) {
+      const m = this._transformMatrix;
+      this._transformMatrix = [m[0] * a + m[2] * b, m[1] * a + m[3] * b, m[0] * c + m[2] * d, m[1] * c + m[3] * d, m[0] * e + m[2] * f + m[4], m[1] * e + m[3] * f + m[5]];
+
+      ctx._originalTransform(a, b, c, d, e, f);
+    };
+
+    ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
+      this._transformMatrix = [a, b, c, d, e, f];
+
+      ctx._originalSetTransform(a, b, c, d, e, f);
+    };
+
+    ctx.rotate = function ctxRotate(angle) {
+      const cosValue = Math.cos(angle);
+      const sinValue = Math.sin(angle);
+      const m = this._transformMatrix;
+      this._transformMatrix = [m[0] * cosValue + m[2] * sinValue, m[1] * cosValue + m[3] * sinValue, m[0] * -sinValue + m[2] * cosValue, m[1] * -sinValue + m[3] * cosValue, m[4], m[5]];
+
+      this._originalRotate(angle);
+    };
+  }
+}
+
+const CachedCanvases = function CachedCanvasesClosure() {
+  function CachedCanvases(canvasFactory) {
+    this.canvasFactory = canvasFactory;
+    this.cache = Object.create(null);
+  }
+
+  CachedCanvases.prototype = {
+    getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
+      let canvasEntry;
+
+      if (this.cache[id] !== undefined) {
+        canvasEntry = this.cache[id];
+        this.canvasFactory.reset(canvasEntry, width, height);
+        canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);
+      } else {
+        canvasEntry = this.canvasFactory.create(width, height);
+        this.cache[id] = canvasEntry;
+      }
+
+      if (trackTransform) {
+        addContextCurrentTransform(canvasEntry.context);
+      }
+
+      return canvasEntry;
+    },
+
+    clear() {
+      for (const id in this.cache) {
+        const canvasEntry = this.cache[id];
+        this.canvasFactory.destroy(canvasEntry);
+        delete this.cache[id];
+      }
+    }
+
+  };
+  return CachedCanvases;
+}();
+
+function compileType3Glyph(imgData) {
+  const POINT_TO_PROCESS_LIMIT = 1000;
+  const width = imgData.width,
+        height = imgData.height,
+        width1 = width + 1;
+  let i, ii, j, j0;
+  const points = new Uint8Array(width1 * (height + 1));
+  const POINT_TYPES = new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);
+  const lineSize = width + 7 & ~7,
+        data0 = imgData.data;
+  const data = new Uint8Array(lineSize * height);
+  let pos = 0;
+
+  for (i = 0, ii = data0.length; i < ii; i++) {
+    const elem = data0[i];
+    let mask = 128;
+
+    while (mask > 0) {
+      data[pos++] = elem & mask ? 0 : 255;
+      mask >>= 1;
+    }
+  }
+
+  let count = 0;
+  pos = 0;
+
+  if (data[pos] !== 0) {
+    points[0] = 1;
+    ++count;
+  }
+
+  for (j = 1; j < width; j++) {
+    if (data[pos] !== data[pos + 1]) {
+      points[j] = data[pos] ? 2 : 1;
+      ++count;
+    }
+
+    pos++;
+  }
+
+  if (data[pos] !== 0) {
+    points[j] = 2;
+    ++count;
+  }
+
+  for (i = 1; i < height; i++) {
+    pos = i * lineSize;
+    j0 = i * width1;
+
+    if (data[pos - lineSize] !== data[pos]) {
+      points[j0] = data[pos] ? 1 : 8;
+      ++count;
+    }
+
+    let sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
+
+    for (j = 1; j < width; j++) {
+      sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
+
+      if (POINT_TYPES[sum]) {
+        points[j0 + j] = POINT_TYPES[sum];
+        ++count;
+      }
+
+      pos++;
+    }
+
+    if (data[pos - lineSize] !== data[pos]) {
+      points[j0 + j] = data[pos] ? 2 : 4;
+      ++count;
+    }
+
+    if (count > POINT_TO_PROCESS_LIMIT) {
+      return null;
+    }
+  }
+
+  pos = lineSize * (height - 1);
+  j0 = i * width1;
+
+  if (data[pos] !== 0) {
+    points[j0] = 8;
+    ++count;
+  }
+
+  for (j = 1; j < width; j++) {
+    if (data[pos] !== data[pos + 1]) {
+      points[j0 + j] = data[pos] ? 4 : 8;
+      ++count;
+    }
+
+    pos++;
+  }
+
+  if (data[pos] !== 0) {
+    points[j0 + j] = 4;
+    ++count;
+  }
+
+  if (count > POINT_TO_PROCESS_LIMIT) {
+    return null;
+  }
+
+  const steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
+  const outlines = [];
+
+  for (i = 0; count && i <= height; i++) {
+    let p = i * width1;
+    const end = p + width;
+
+    while (p < end && !points[p]) {
+      p++;
+    }
+
+    if (p === end) {
+      continue;
+    }
+
+    const coords = [p % width1, i];
+    const p0 = p;
+    let type = points[p];
+
+    do {
+      const step = steps[type];
+
+      do {
+        p += step;
+      } while (!points[p]);
+
+      const pp = points[p];
+
+      if (pp !== 5 && pp !== 10) {
+        type = pp;
+        points[p] = 0;
+      } else {
+        type = pp & 0x33 * type >> 4;
+        points[p] &= type >> 2 | type << 2;
+      }
+
+      coords.push(p % width1);
+      coords.push(p / width1 | 0);
+
+      if (!points[p]) {
+        --count;
+      }
+    } while (p0 !== p);
+
+    outlines.push(coords);
+    --i;
+  }
+
+  const drawOutline = function (c) {
+    c.save();
+    c.scale(1 / width, -1 / height);
+    c.translate(0, -height);
+    c.beginPath();
+
+    for (let k = 0, kk = outlines.length; k < kk; k++) {
+      const o = outlines[k];
+      c.moveTo(o[0], o[1]);
+
+      for (let l = 2, ll = o.length; l < ll; l += 2) {
+        c.lineTo(o[l], o[l + 1]);
+      }
+    }
+
+    c.fill();
+    c.beginPath();
+    c.restore();
+  };
+
+  return drawOutline;
+}
+
+const CanvasExtraState = function CanvasExtraStateClosure() {
+  function CanvasExtraState() {
+    this.alphaIsShape = false;
+    this.fontSize = 0;
+    this.fontSizeScale = 1;
+    this.textMatrix = _util.IDENTITY_MATRIX;
+    this.textMatrixScale = 1;
+    this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
+    this.leading = 0;
+    this.x = 0;
+    this.y = 0;
+    this.lineX = 0;
+    this.lineY = 0;
+    this.charSpacing = 0;
+    this.wordSpacing = 0;
+    this.textHScale = 1;
+    this.textRenderingMode = _util.TextRenderingMode.FILL;
+    this.textRise = 0;
+    this.fillColor = "#000000";
+    this.strokeColor = "#000000";
+    this.patternFill = false;
+    this.fillAlpha = 1;
+    this.strokeAlpha = 1;
+    this.lineWidth = 1;
+    this.activeSMask = null;
+    this.resumeSMaskCtx = null;
+    this.transferMaps = null;
+  }
+
+  CanvasExtraState.prototype = {
+    clone: function CanvasExtraState_clone() {
+      return Object.create(this);
+    },
+    setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {
+      this.x = x;
+      this.y = y;
+    }
+  };
+  return CanvasExtraState;
+}();
+
+const CanvasGraphics = function CanvasGraphicsClosure() {
+  const EXECUTION_TIME = 15;
+  const EXECUTION_STEPS = 10;
+
+  function CanvasGraphics(canvasCtx, commonObjs, objs, canvasFactory, webGLContext, imageLayer, optionalContentConfig) {
+    this.ctx = canvasCtx;
+    this.current = new CanvasExtraState();
+    this.stateStack = [];
+    this.pendingClip = null;
+    this.pendingEOFill = false;
+    this.res = null;
+    this.xobjs = null;
+    this.commonObjs = commonObjs;
+    this.objs = objs;
+    this.canvasFactory = canvasFactory;
+    this.webGLContext = webGLContext;
+    this.imageLayer = imageLayer;
+    this.groupStack = [];
+    this.processingType3 = null;
+    this.baseTransform = null;
+    this.baseTransformStack = [];
+    this.groupLevel = 0;
+    this.smaskStack = [];
+    this.smaskCounter = 0;
+    this.tempSMask = null;
+    this.contentVisible = true;
+    this.markedContentStack = [];
+    this.optionalContentConfig = optionalContentConfig;
+    this.cachedCanvases = new CachedCanvases(this.canvasFactory);
+
+    if (canvasCtx) {
+      addContextCurrentTransform(canvasCtx);
+    }
+
+    this._cachedGetSinglePixelWidth = null;
+  }
+
+  function putBinaryImageData(ctx, imgData, transferMaps = null) {
+    if (typeof ImageData !== "undefined" && imgData instanceof ImageData) {
+      ctx.putImageData(imgData, 0, 0);
+      return;
+    }
+
+    const height = imgData.height,
+          width = imgData.width;
+    const partialChunkHeight = height % FULL_CHUNK_HEIGHT;
+    const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
+    const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
+    const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+    let srcPos = 0,
+        destPos;
+    const src = imgData.data;
+    const dest = chunkImgData.data;
+    let i, j, thisChunkHeight, elemsInThisChunk;
+    let transferMapRed, transferMapGreen, transferMapBlue, transferMapGray;
+
+    if (transferMaps) {
+      switch (transferMaps.length) {
+        case 1:
+          transferMapRed = transferMaps[0];
+          transferMapGreen = transferMaps[0];
+          transferMapBlue = transferMaps[0];
+          transferMapGray = transferMaps[0];
+          break;
+
+        case 4:
+          transferMapRed = transferMaps[0];
+          transferMapGreen = transferMaps[1];
+          transferMapBlue = transferMaps[2];
+          transferMapGray = transferMaps[3];
+          break;
+      }
+    }
+
+    if (imgData.kind === _util.ImageKind.GRAYSCALE_1BPP) {
+      const srcLength = src.byteLength;
+      const dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);
+      const dest32DataLength = dest32.length;
+      const fullSrcDiff = width + 7 >> 3;
+      let white = 0xffffffff;
+      let black = _util.IsLittleEndianCached.value ? 0xff000000 : 0x000000ff;
+
+      if (transferMapGray) {
+        if (transferMapGray[0] === 0xff && transferMapGray[0xff] === 0) {
+          [white, black] = [black, white];
+        }
+      }
+
+      for (i = 0; i < totalChunks; i++) {
+        thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
+        destPos = 0;
+
+        for (j = 0; j < thisChunkHeight; j++) {
+          const srcDiff = srcLength - srcPos;
+          let k = 0;
+          const kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;
+          const kEndUnrolled = kEnd & ~7;
+          let mask = 0;
+          let srcByte = 0;
+
+          for (; k < kEndUnrolled; k += 8) {
+            srcByte = src[srcPos++];
+            dest32[destPos++] = srcByte & 128 ? white : black;
+            dest32[destPos++] = srcByte & 64 ? white : black;
+            dest32[destPos++] = srcByte & 32 ? white : black;
+            dest32[destPos++] = srcByte & 16 ? white : black;
+            dest32[destPos++] = srcByte & 8 ? white : black;
+            dest32[destPos++] = srcByte & 4 ? white : black;
+            dest32[destPos++] = srcByte & 2 ? white : black;
+            dest32[destPos++] = srcByte & 1 ? white : black;
+          }
+
+          for (; k < kEnd; k++) {
+            if (mask === 0) {
+              srcByte = src[srcPos++];
+              mask = 128;
+            }
+
+            dest32[destPos++] = srcByte & mask ? white : black;
+            mask >>= 1;
+          }
+        }
+
+        while (destPos < dest32DataLength) {
+          dest32[destPos++] = 0;
+        }
+
+        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+      }
+    } else if (imgData.kind === _util.ImageKind.RGBA_32BPP) {
+      const hasTransferMaps = !!(transferMapRed || transferMapGreen || transferMapBlue);
+      j = 0;
+      elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
+
+      for (i = 0; i < fullChunks; i++) {
+        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
+        srcPos += elemsInThisChunk;
+
+        if (hasTransferMaps) {
+          for (let k = 0; k < elemsInThisChunk; k += 4) {
+            if (transferMapRed) {
+              dest[k + 0] = transferMapRed[dest[k + 0]];
+            }
+
+            if (transferMapGreen) {
+              dest[k + 1] = transferMapGreen[dest[k + 1]];
+            }
+
+            if (transferMapBlue) {
+              dest[k + 2] = transferMapBlue[dest[k + 2]];
+            }
+          }
+        }
+
+        ctx.putImageData(chunkImgData, 0, j);
+        j += FULL_CHUNK_HEIGHT;
+      }
+
+      if (i < totalChunks) {
+        elemsInThisChunk = width * partialChunkHeight * 4;
+        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
+
+        if (hasTransferMaps) {
+          for (let k = 0; k < elemsInThisChunk; k += 4) {
+            if (transferMapRed) {
+              dest[k + 0] = transferMapRed[dest[k + 0]];
+            }
+
+            if (transferMapGreen) {
+              dest[k + 1] = transferMapGreen[dest[k + 1]];
+            }
+
+            if (transferMapBlue) {
+              dest[k + 2] = transferMapBlue[dest[k + 2]];
+            }
+          }
+        }
+
+        ctx.putImageData(chunkImgData, 0, j);
+      }
+    } else if (imgData.kind === _util.ImageKind.RGB_24BPP) {
+      const hasTransferMaps = !!(transferMapRed || transferMapGreen || transferMapBlue);
+      thisChunkHeight = FULL_CHUNK_HEIGHT;
+      elemsInThisChunk = width * thisChunkHeight;
+
+      for (i = 0; i < totalChunks; i++) {
+        if (i >= fullChunks) {
+          thisChunkHeight = partialChunkHeight;
+          elemsInThisChunk = width * thisChunkHeight;
+        }
+
+        destPos = 0;
+
+        for (j = elemsInThisChunk; j--;) {
+          dest[destPos++] = src[srcPos++];
+          dest[destPos++] = src[srcPos++];
+          dest[destPos++] = src[srcPos++];
+          dest[destPos++] = 255;
+        }
+
+        if (hasTransferMaps) {
+          for (let k = 0; k < destPos; k += 4) {
+            if (transferMapRed) {
+              dest[k + 0] = transferMapRed[dest[k + 0]];
+            }
+
+            if (transferMapGreen) {
+              dest[k + 1] = transferMapGreen[dest[k + 1]];
+            }
+
+            if (transferMapBlue) {
+              dest[k + 2] = transferMapBlue[dest[k + 2]];
+            }
+          }
+        }
+
+        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+      }
+    } else {
+      throw new Error(`bad image kind: ${imgData.kind}`);
+    }
+  }
+
+  function putBinaryImageMask(ctx, imgData) {
+    const height = imgData.height,
+          width = imgData.width;
+    const partialChunkHeight = height % FULL_CHUNK_HEIGHT;
+    const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
+    const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
+    const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+    let srcPos = 0;
+    const src = imgData.data;
+    const dest = chunkImgData.data;
+
+    for (let i = 0; i < totalChunks; i++) {
+      const thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
+      let destPos = 3;
+
+      for (let j = 0; j < thisChunkHeight; j++) {
+        let elem,
+            mask = 0;
+
+        for (let k = 0; k < width; k++) {
+          if (!mask) {
+            elem = src[srcPos++];
+            mask = 128;
+          }
+
+          dest[destPos] = elem & mask ? 0 : 255;
+          destPos += 4;
+          mask >>= 1;
+        }
+      }
+
+      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+    }
+  }
+
+  function copyCtxState(sourceCtx, destCtx) {
+    const properties = ["strokeStyle", "fillStyle", "fillRule", "globalAlpha", "lineWidth", "lineCap", "lineJoin", "miterLimit", "globalCompositeOperation", "font"];
+
+    for (let i = 0, ii = properties.length; i < ii; i++) {
+      const property = properties[i];
+
+      if (sourceCtx[property] !== undefined) {
+        destCtx[property] = sourceCtx[property];
+      }
+    }
+
+    if (sourceCtx.setLineDash !== undefined) {
+      destCtx.setLineDash(sourceCtx.getLineDash());
+      destCtx.lineDashOffset = sourceCtx.lineDashOffset;
+    }
+  }
+
+  function resetCtxToDefault(ctx) {
+    ctx.strokeStyle = "#000000";
+    ctx.fillStyle = "#000000";
+    ctx.fillRule = "nonzero";
+    ctx.globalAlpha = 1;
+    ctx.lineWidth = 1;
+    ctx.lineCap = "butt";
+    ctx.lineJoin = "miter";
+    ctx.miterLimit = 10;
+    ctx.globalCompositeOperation = "source-over";
+    ctx.font = "10px sans-serif";
+
+    if (ctx.setLineDash !== undefined) {
+      ctx.setLineDash([]);
+      ctx.lineDashOffset = 0;
+    }
+  }
+
+  function composeSMaskBackdrop(bytes, r0, g0, b0) {
+    const length = bytes.length;
+
+    for (let i = 3; i < length; i += 4) {
+      const alpha = bytes[i];
+
+      if (alpha === 0) {
+        bytes[i - 3] = r0;
+        bytes[i - 2] = g0;
+        bytes[i - 1] = b0;
+      } else if (alpha < 255) {
+        const alpha_ = 255 - alpha;
+        bytes[i - 3] = bytes[i - 3] * alpha + r0 * alpha_ >> 8;
+        bytes[i - 2] = bytes[i - 2] * alpha + g0 * alpha_ >> 8;
+        bytes[i - 1] = bytes[i - 1] * alpha + b0 * alpha_ >> 8;
+      }
+    }
+  }
+
+  function composeSMaskAlpha(maskData, layerData, transferMap) {
+    const length = maskData.length;
+    const scale = 1 / 255;
+
+    for (let i = 3; i < length; i += 4) {
+      const alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
+      layerData[i] = layerData[i] * alpha * scale | 0;
+    }
+  }
+
+  function composeSMaskLuminosity(maskData, layerData, transferMap) {
+    const length = maskData.length;
+
+    for (let i = 3; i < length; i += 4) {
+      const y = maskData[i - 3] * 77 + maskData[i - 2] * 152 + maskData[i - 1] * 28;
+      layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
+    }
+  }
+
+  function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
+    const hasBackdrop = !!backdrop;
+    const r0 = hasBackdrop ? backdrop[0] : 0;
+    const g0 = hasBackdrop ? backdrop[1] : 0;
+    const b0 = hasBackdrop ? backdrop[2] : 0;
+    let composeFn;
+
+    if (subtype === "Luminosity") {
+      composeFn = composeSMaskLuminosity;
+    } else {
+      composeFn = composeSMaskAlpha;
+    }
+
+    const PIXELS_TO_PROCESS = 1048576;
+    const chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
+
+    for (let row = 0; row < height; row += chunkSize) {
+      const chunkHeight = Math.min(chunkSize, height - row);
+      const maskData = maskCtx.getImageData(0, row, width, chunkHeight);
+      const layerData = layerCtx.getImageData(0, row, width, chunkHeight);
+
+      if (hasBackdrop) {
+        composeSMaskBackdrop(maskData.data, r0, g0, b0);
+      }
+
+      composeFn(maskData.data, layerData.data, transferMap);
+      maskCtx.putImageData(layerData, 0, row);
+    }
+  }
+
+  function composeSMask(ctx, smask, layerCtx, webGLContext) {
+    const mask = smask.canvas;
+    const maskCtx = smask.context;
+    ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
+    const backdrop = smask.backdrop || null;
+
+    if (!smask.transferMap && webGLContext.isEnabled) {
+      const composed = webGLContext.composeSMask({
+        layer: layerCtx.canvas,
+        mask,
+        properties: {
+          subtype: smask.subtype,
+          backdrop
+        }
+      });
+      ctx.setTransform(1, 0, 0, 1, 0, 0);
+      ctx.drawImage(composed, smask.offsetX, smask.offsetY);
+      return;
+    }
+
+    genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
+    ctx.drawImage(mask, 0, 0);
+  }
+
+  const LINE_CAP_STYLES = ["butt", "round", "square"];
+  const LINE_JOIN_STYLES = ["miter", "round", "bevel"];
+  const NORMAL_CLIP = {};
+  const EO_CLIP = {};
+  CanvasGraphics.prototype = {
+    beginDrawing({
+      transform,
+      viewport,
+      transparency = false,
+      background = null
+    }) {
+      const width = this.ctx.canvas.width;
+      const height = this.ctx.canvas.height;
+      this.ctx.save();
+      this.ctx.fillStyle = background || "rgb(255, 255, 255)";
+      this.ctx.fillRect(0, 0, width, height);
+      this.ctx.restore();
+
+      if (transparency) {
+        const transparentCanvas = this.cachedCanvases.getCanvas("transparent", width, height, true);
+        this.compositeCtx = this.ctx;
+        this.transparentCanvas = transparentCanvas.canvas;
+        this.ctx = transparentCanvas.context;
+        this.ctx.save();
+        this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
+      }
+
+      this.ctx.save();
+      resetCtxToDefault(this.ctx);
+
+      if (transform) {
+        this.ctx.transform.apply(this.ctx, transform);
+      }
+
+      this.ctx.transform.apply(this.ctx, viewport.transform);
+      this.baseTransform = this.ctx.mozCurrentTransform.slice();
+
+      if (this.imageLayer) {
+        this.imageLayer.beginLayout();
+      }
+    },
+
+    executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
+      const argsArray = operatorList.argsArray;
+      const fnArray = operatorList.fnArray;
+      let i = executionStartIdx || 0;
+      const argsArrayLen = argsArray.length;
+
+      if (argsArrayLen === i) {
+        return i;
+      }
+
+      const chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === "function";
+      const endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
+      let steps = 0;
+      const commonObjs = this.commonObjs;
+      const objs = this.objs;
+      let fnId;
+
+      while (true) {
+        if (stepper !== undefined && i === stepper.nextBreakPoint) {
+          stepper.breakIt(i, continueCallback);
+          return i;
+        }
+
+        fnId = fnArray[i];
+
+        if (fnId !== _util.OPS.dependency) {
+          this[fnId].apply(this, argsArray[i]);
+        } else {
+          for (const depObjId of argsArray[i]) {
+            const objsPool = depObjId.startsWith("g_") ? commonObjs : objs;
+
+            if (!objsPool.has(depObjId)) {
+              objsPool.get(depObjId, continueCallback);
+              return i;
+            }
+          }
+        }
+
+        i++;
+
+        if (i === argsArrayLen) {
+          return i;
+        }
+
+        if (chunkOperations && ++steps > EXECUTION_STEPS) {
+          if (Date.now() > endTime) {
+            continueCallback();
+            return i;
+          }
+
+          steps = 0;
+        }
+      }
+    },
+    endDrawing: function CanvasGraphics_endDrawing() {
+      while (this.stateStack.length || this.current.activeSMask !== null) {
+        this.restore();
+      }
+
+      this.ctx.restore();
+
+      if (this.transparentCanvas) {
+        this.ctx = this.compositeCtx;
+        this.ctx.save();
+        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+        this.ctx.drawImage(this.transparentCanvas, 0, 0);
+        this.ctx.restore();
+        this.transparentCanvas = null;
+      }
+
+      this.cachedCanvases.clear();
+      this.webGLContext.clear();
+
+      if (this.imageLayer) {
+        this.imageLayer.endLayout();
+      }
+    },
+    setLineWidth: function CanvasGraphics_setLineWidth(width) {
+      this.current.lineWidth = width;
+      this.ctx.lineWidth = width;
+    },
+    setLineCap: function CanvasGraphics_setLineCap(style) {
+      this.ctx.lineCap = LINE_CAP_STYLES[style];
+    },
+    setLineJoin: function CanvasGraphics_setLineJoin(style) {
+      this.ctx.lineJoin = LINE_JOIN_STYLES[style];
+    },
+    setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
+      this.ctx.miterLimit = limit;
+    },
+    setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
+      const ctx = this.ctx;
+
+      if (ctx.setLineDash !== undefined) {
+        ctx.setLineDash(dashArray);
+        ctx.lineDashOffset = dashPhase;
+      }
+    },
+
+    setRenderingIntent(intent) {},
+
+    setFlatness(flatness) {},
+
+    setGState: function CanvasGraphics_setGState(states) {
+      for (let i = 0, ii = states.length; i < ii; i++) {
+        const state = states[i];
+        const key = state[0];
+        const value = state[1];
+
+        switch (key) {
+          case "LW":
+            this.setLineWidth(value);
+            break;
+
+          case "LC":
+            this.setLineCap(value);
+            break;
+
+          case "LJ":
+            this.setLineJoin(value);
+            break;
+
+          case "ML":
+            this.setMiterLimit(value);
+            break;
+
+          case "D":
+            this.setDash(value[0], value[1]);
+            break;
+
+          case "RI":
+            this.setRenderingIntent(value);
+            break;
+
+          case "FL":
+            this.setFlatness(value);
+            break;
+
+          case "Font":
+            this.setFont(value[0], value[1]);
+            break;
+
+          case "CA":
+            this.current.strokeAlpha = state[1];
+            break;
+
+          case "ca":
+            this.current.fillAlpha = state[1];
+            this.ctx.globalAlpha = state[1];
+            break;
+
+          case "BM":
+            this.ctx.globalCompositeOperation = value;
+            break;
+
+          case "SMask":
+            if (this.current.activeSMask) {
+              if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
+                this.suspendSMaskGroup();
+              } else {
+                this.endSMaskGroup();
+              }
+            }
+
+            this.current.activeSMask = value ? this.tempSMask : null;
+
+            if (this.current.activeSMask) {
+              this.beginSMaskGroup();
+            }
+
+            this.tempSMask = null;
+            break;
+
+          case "TR":
+            this.current.transferMaps = value;
+        }
+      }
+    },
+    beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
+      const activeSMask = this.current.activeSMask;
+      const drawnWidth = activeSMask.canvas.width;
+      const drawnHeight = activeSMask.canvas.height;
+      const cacheId = "smaskGroupAt" + this.groupLevel;
+      const scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
+      const currentCtx = this.ctx;
+      const currentTransform = currentCtx.mozCurrentTransform;
+      this.ctx.save();
+      const groupCtx = scratchCanvas.context;
+      groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);
+      groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);
+      groupCtx.transform.apply(groupCtx, currentTransform);
+      activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;
+      copyCtxState(currentCtx, groupCtx);
+      this.ctx = groupCtx;
+      this.setGState([["BM", "source-over"], ["ca", 1], ["CA", 1]]);
+      this.groupStack.push(currentCtx);
+      this.groupLevel++;
+    },
+    suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {
+      const groupCtx = this.ctx;
+      this.groupLevel--;
+      this.ctx = this.groupStack.pop();
+      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
+      this.ctx.restore();
+      this.ctx.save();
+      copyCtxState(groupCtx, this.ctx);
+      this.current.resumeSMaskCtx = groupCtx;
+
+      const deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
+      this.ctx.transform.apply(this.ctx, deltaTransform);
+      groupCtx.save();
+      groupCtx.setTransform(1, 0, 0, 1, 0, 0);
+      groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
+      groupCtx.restore();
+    },
+    resumeSMaskGroup: function CanvasGraphics_resumeSMaskGroup() {
+      const groupCtx = this.current.resumeSMaskCtx;
+      const currentCtx = this.ctx;
+      this.ctx = groupCtx;
+      this.groupStack.push(currentCtx);
+      this.groupLevel++;
+    },
+    endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
+      const groupCtx = this.ctx;
+      this.groupLevel--;
+      this.ctx = this.groupStack.pop();
+      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
+      this.ctx.restore();
+      copyCtxState(groupCtx, this.ctx);
+
+      const deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
+      this.ctx.transform.apply(this.ctx, deltaTransform);
+    },
+    save: function CanvasGraphics_save() {
+      this.ctx.save();
+      const old = this.current;
+      this.stateStack.push(old);
+      this.current = old.clone();
+      this.current.resumeSMaskCtx = null;
+    },
+    restore: function CanvasGraphics_restore() {
+      if (this.current.resumeSMaskCtx) {
+        this.resumeSMaskGroup();
+      }
+
+      if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
+        this.endSMaskGroup();
+      }
+
+      if (this.stateStack.length !== 0) {
+        this.current = this.stateStack.pop();
+        this.ctx.restore();
+        this.pendingClip = null;
+        this._cachedGetSinglePixelWidth = null;
+      } else {
+        this.current.activeSMask = null;
+      }
+    },
+    transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
+      this.ctx.transform(a, b, c, d, e, f);
+      this._cachedGetSinglePixelWidth = null;
+    },
+    constructPath: function CanvasGraphics_constructPath(ops, args) {
+      const ctx = this.ctx;
+      const current = this.current;
+      let x = current.x,
+          y = current.y;
+
+      for (let i = 0, j = 0, ii = ops.length; i < ii; i++) {
+        switch (ops[i] | 0) {
+          case _util.OPS.rectangle:
+            x = args[j++];
+            y = args[j++];
+            let width = args[j++];
+            let height = args[j++];
+
+            if (width === 0 && ctx.lineWidth < this.getSinglePixelWidth()) {
+              width = this.getSinglePixelWidth();
+            }
+
+            if (height === 0 && ctx.lineWidth < this.getSinglePixelWidth()) {
+              height = this.getSinglePixelWidth();
+            }
+
+            const xw = x + width;
+            const yh = y + height;
+            ctx.moveTo(x, y);
+            ctx.lineTo(xw, y);
+            ctx.lineTo(xw, yh);
+            ctx.lineTo(x, yh);
+            ctx.lineTo(x, y);
+            ctx.closePath();
+            break;
+
+          case _util.OPS.moveTo:
+            x = args[j++];
+            y = args[j++];
+            ctx.moveTo(x, y);
+            break;
+
+          case _util.OPS.lineTo:
+            x = args[j++];
+            y = args[j++];
+            ctx.lineTo(x, y);
+            break;
+
+          case _util.OPS.curveTo:
+            x = args[j + 4];
+            y = args[j + 5];
+            ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
+            j += 6;
+            break;
+
+          case _util.OPS.curveTo2:
+            ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j + 3]);
+            x = args[j + 2];
+            y = args[j + 3];
+            j += 4;
+            break;
+
+          case _util.OPS.curveTo3:
+            x = args[j + 2];
+            y = args[j + 3];
+            ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
+            j += 4;
+            break;
+
+          case _util.OPS.closePath:
+            ctx.closePath();
+            break;
+        }
+      }
+
+      current.setCurrentPoint(x, y);
+    },
+    closePath: function CanvasGraphics_closePath() {
+      this.ctx.closePath();
+    },
+    stroke: function CanvasGraphics_stroke(consumePath) {
+      consumePath = typeof consumePath !== "undefined" ? consumePath : true;
+      const ctx = this.ctx;
+      const strokeColor = this.current.strokeColor;
+      ctx.globalAlpha = this.current.strokeAlpha;
+
+      if (this.contentVisible) {
+        if (typeof strokeColor === "object" && strokeColor?.getPattern) {
+          ctx.save();
+          const transform = ctx.mozCurrentTransform;
+
+          const scale = _util.Util.singularValueDecompose2dScale(transform)[0];
+
+          ctx.strokeStyle = strokeColor.getPattern(ctx, this);
+          ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth * scale);
+          ctx.stroke();
+          ctx.restore();
+        } else {
+          ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
+          ctx.stroke();
+        }
+      }
+
+      if (consumePath) {
+        this.consumePath();
+      }
+
+      ctx.globalAlpha = this.current.fillAlpha;
+    },
+    closeStroke: function CanvasGraphics_closeStroke() {
+      this.closePath();
+      this.stroke();
+    },
+    fill: function CanvasGraphics_fill(consumePath) {
+      consumePath = typeof consumePath !== "undefined" ? consumePath : true;
+      const ctx = this.ctx;
+      const fillColor = this.current.fillColor;
+      const isPatternFill = this.current.patternFill;
+      let needRestore = false;
+
+      if (isPatternFill) {
+        ctx.save();
+
+        if (this.baseTransform) {
+          ctx.setTransform.apply(ctx, this.baseTransform);
+        }
+
+        ctx.fillStyle = fillColor.getPattern(ctx, this);
+        needRestore = true;
+      }
+
+      if (this.contentVisible) {
+        if (this.pendingEOFill) {
+          ctx.fill("evenodd");
+          this.pendingEOFill = false;
+        } else {
+          ctx.fill();
+        }
+      }
+
+      if (needRestore) {
+        ctx.restore();
+      }
+
+      if (consumePath) {
+        this.consumePath();
+      }
+    },
+    eoFill: function CanvasGraphics_eoFill() {
+      this.pendingEOFill = true;
+      this.fill();
+    },
+    fillStroke: function CanvasGraphics_fillStroke() {
+      this.fill(false);
+      this.stroke(false);
+      this.consumePath();
+    },
+    eoFillStroke: function CanvasGraphics_eoFillStroke() {
+      this.pendingEOFill = true;
+      this.fillStroke();
+    },
+    closeFillStroke: function CanvasGraphics_closeFillStroke() {
+      this.closePath();
+      this.fillStroke();
+    },
+    closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {
+      this.pendingEOFill = true;
+      this.closePath();
+      this.fillStroke();
+    },
+    endPath: function CanvasGraphics_endPath() {
+      this.consumePath();
+    },
+    clip: function CanvasGraphics_clip() {
+      this.pendingClip = NORMAL_CLIP;
+    },
+    eoClip: function CanvasGraphics_eoClip() {
+      this.pendingClip = EO_CLIP;
+    },
+    beginText: function CanvasGraphics_beginText() {
+      this.current.textMatrix = _util.IDENTITY_MATRIX;
+      this.current.textMatrixScale = 1;
+      this.current.x = this.current.lineX = 0;
+      this.current.y = this.current.lineY = 0;
+    },
+    endText: function CanvasGraphics_endText() {
+      const paths = this.pendingTextPaths;
+      const ctx = this.ctx;
+
+      if (paths === undefined) {
+        ctx.beginPath();
+        return;
+      }
+
+      ctx.save();
+      ctx.beginPath();
+
+      for (let i = 0; i < paths.length; i++) {
+        const path = paths[i];
+        ctx.setTransform.apply(ctx, path.transform);
+        ctx.translate(path.x, path.y);
+        path.addToPath(ctx, path.fontSize);
+      }
+
+      ctx.restore();
+      ctx.clip();
+      ctx.beginPath();
+      delete this.pendingTextPaths;
+    },
+    setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
+      this.current.charSpacing = spacing;
+    },
+    setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {
+      this.current.wordSpacing = spacing;
+    },
+    setHScale: function CanvasGraphics_setHScale(scale) {
+      this.current.textHScale = scale / 100;
+    },
+    setLeading: function CanvasGraphics_setLeading(leading) {
+      this.current.leading = -leading;
+    },
+    setFont: function CanvasGraphics_setFont(fontRefName, size) {
+      const fontObj = this.commonObjs.get(fontRefName);
+      const current = this.current;
+
+      if (!fontObj) {
+        throw new Error(`Can't find font for ${fontRefName}`);
+      }
+
+      current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
+
+      if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
+        (0, _util.warn)("Invalid font matrix for font " + fontRefName);
+      }
+
+      if (size < 0) {
+        size = -size;
+        current.fontDirection = -1;
+      } else {
+        current.fontDirection = 1;
+      }
+
+      this.current.font = fontObj;
+      this.current.fontSize = size;
+
+      if (fontObj.isType3Font) {
+        return;
+      }
+
+      const name = fontObj.loadedName || "sans-serif";
+      let bold = "normal";
+
+      if (fontObj.black) {
+        bold = "900";
+      } else if (fontObj.bold) {
+        bold = "bold";
+      }
+
+      const italic = fontObj.italic ? "italic" : "normal";
+      const typeface = `"${name}", ${fontObj.fallbackName}`;
+      let browserFontSize = size;
+
+      if (size < MIN_FONT_SIZE) {
+        browserFontSize = MIN_FONT_SIZE;
+      } else if (size > MAX_FONT_SIZE) {
+        browserFontSize = MAX_FONT_SIZE;
+      }
+
+      this.current.fontSizeScale = size / browserFontSize;
+      this.ctx.font = `${italic} ${bold} ${browserFontSize}px ${typeface}`;
+    },
+    setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
+      this.current.textRenderingMode = mode;
+    },
+    setTextRise: function CanvasGraphics_setTextRise(rise) {
+      this.current.textRise = rise;
+    },
+    moveText: function CanvasGraphics_moveText(x, y) {
+      this.current.x = this.current.lineX += x;
+      this.current.y = this.current.lineY += y;
+    },
+    setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {
+      this.setLeading(-y);
+      this.moveText(x, y);
+    },
+    setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {
+      this.current.textMatrix = [a, b, c, d, e, f];
+      this.current.textMatrixScale = Math.sqrt(a * a + b * b);
+      this.current.x = this.current.lineX = 0;
+      this.current.y = this.current.lineY = 0;
+    },
+    nextLine: function CanvasGraphics_nextLine() {
+      this.moveText(0, this.current.leading);
+    },
+
+    paintChar(character, x, y, patternTransform) {
+      const ctx = this.ctx;
+      const current = this.current;
+      const font = current.font;
+      const textRenderingMode = current.textRenderingMode;
+      const fontSize = current.fontSize / current.fontSizeScale;
+      const fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+      const isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
+      const patternFill = current.patternFill && !font.missingFile;
+      let addToPath;
+
+      if (font.disableFontFace || isAddToPathSet || patternFill) {
+        addToPath = font.getPathGenerator(this.commonObjs, character);
+      }
+
+      if (font.disableFontFace || patternFill) {
+        ctx.save();
+        ctx.translate(x, y);
+        ctx.beginPath();
+        addToPath(ctx, fontSize);
+
+        if (patternTransform) {
+          ctx.setTransform.apply(ctx, patternTransform);
+        }
+
+        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          ctx.fill();
+        }
+
+        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          ctx.stroke();
+        }
+
+        ctx.restore();
+      } else {
+        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          ctx.fillText(character, x, y);
+        }
+
+        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          ctx.strokeText(character, x, y);
+        }
+      }
+
+      if (isAddToPathSet) {
+        const paths = this.pendingTextPaths || (this.pendingTextPaths = []);
+        paths.push({
+          transform: ctx.mozCurrentTransform,
+          x,
+          y,
+          fontSize,
+          addToPath
+        });
+      }
+    },
+
+    get isFontSubpixelAAEnabled() {
+      const {
+        context: ctx
+      } = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10);
+      ctx.scale(1.5, 1);
+      ctx.fillText("I", 0, 10);
+      const data = ctx.getImageData(0, 0, 10, 10).data;
+      let enabled = false;
+
+      for (let i = 3; i < data.length; i += 4) {
+        if (data[i] > 0 && data[i] < 255) {
+          enabled = true;
+          break;
+        }
+      }
+
+      return (0, _util.shadow)(this, "isFontSubpixelAAEnabled", enabled);
+    },
+
+    showText: function CanvasGraphics_showText(glyphs) {
+      const current = this.current;
+      const font = current.font;
+
+      if (font.isType3Font) {
+        return this.showType3Text(glyphs);
+      }
+
+      const fontSize = current.fontSize;
+
+      if (fontSize === 0) {
+        return undefined;
+      }
+
+      const ctx = this.ctx;
+      const fontSizeScale = current.fontSizeScale;
+      const charSpacing = current.charSpacing;
+      const wordSpacing = current.wordSpacing;
+      const fontDirection = current.fontDirection;
+      const textHScale = current.textHScale * fontDirection;
+      const glyphsLength = glyphs.length;
+      const vertical = font.vertical;
+      const spacingDir = vertical ? 1 : -1;
+      const defaultVMetrics = font.defaultVMetrics;
+      const widthAdvanceScale = fontSize * current.fontMatrix[0];
+      const simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
+      ctx.save();
+      let patternTransform;
+
+      if (current.patternFill) {
+        ctx.save();
+        const pattern = current.fillColor.getPattern(ctx, this);
+        patternTransform = ctx.mozCurrentTransform;
+        ctx.restore();
+        ctx.fillStyle = pattern;
+      }
+
+      ctx.transform.apply(ctx, current.textMatrix);
+      ctx.translate(current.x, current.y + current.textRise);
+
+      if (fontDirection > 0) {
+        ctx.scale(textHScale, -1);
+      } else {
+        ctx.scale(textHScale, 1);
+      }
+
+      let lineWidth = current.lineWidth;
+      const scale = current.textMatrixScale;
+
+      if (scale === 0 || lineWidth === 0) {
+        const fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+
+        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          this._cachedGetSinglePixelWidth = null;
+          lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
+        }
+      } else {
+        lineWidth /= scale;
+      }
+
+      if (fontSizeScale !== 1.0) {
+        ctx.scale(fontSizeScale, fontSizeScale);
+        lineWidth /= fontSizeScale;
+      }
+
+      ctx.lineWidth = lineWidth;
+      let x = 0,
+          i;
+
+      for (i = 0; i < glyphsLength; ++i) {
+        const glyph = glyphs[i];
+
+        if ((0, _util.isNum)(glyph)) {
+          x += spacingDir * glyph * fontSize / 1000;
+          continue;
+        }
+
+        let restoreNeeded = false;
+        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
+        const character = glyph.fontChar;
+        const accent = glyph.accent;
+        let scaledX, scaledY;
+        let width = glyph.width;
+
+        if (vertical) {
+          const vmetric = glyph.vmetric || defaultVMetrics;
+          const vx = -(glyph.vmetric ? vmetric[1] : width * 0.5) * widthAdvanceScale;
+          const vy = vmetric[2] * widthAdvanceScale;
+          width = vmetric ? -vmetric[0] : width;
+          scaledX = vx / fontSizeScale;
+          scaledY = (x + vy) / fontSizeScale;
+        } else {
+          scaledX = x / fontSizeScale;
+          scaledY = 0;
+        }
+
+        if (font.remeasure && width > 0) {
+          const measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
+
+          if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
+            const characterScaleX = width / measuredWidth;
+            restoreNeeded = true;
+            ctx.save();
+            ctx.scale(characterScaleX, 1);
+            scaledX /= characterScaleX;
+          } else if (width !== measuredWidth) {
+            scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
+          }
+        }
+
+        if (this.contentVisible && (glyph.isInFont || font.missingFile)) {
+          if (simpleFillText && !accent) {
+            ctx.fillText(character, scaledX, scaledY);
+          } else {
+            this.paintChar(character, scaledX, scaledY, patternTransform);
+
+            if (accent) {
+              const scaledAccentX = scaledX + fontSize * accent.offset.x / fontSizeScale;
+              const scaledAccentY = scaledY - fontSize * accent.offset.y / fontSizeScale;
+              this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY, patternTransform);
+            }
+          }
+        }
+
+        let charWidth;
+
+        if (vertical) {
+          charWidth = width * widthAdvanceScale - spacing * fontDirection;
+        } else {
+          charWidth = width * widthAdvanceScale + spacing * fontDirection;
+        }
+
+        x += charWidth;
+
+        if (restoreNeeded) {
+          ctx.restore();
+        }
+      }
+
+      if (vertical) {
+        current.y -= x;
+      } else {
+        current.x += x * textHScale;
+      }
+
+      ctx.restore();
+    },
+    showType3Text: function CanvasGraphics_showType3Text(glyphs) {
+      const ctx = this.ctx;
+      const current = this.current;
+      const font = current.font;
+      const fontSize = current.fontSize;
+      const fontDirection = current.fontDirection;
+      const spacingDir = font.vertical ? 1 : -1;
+      const charSpacing = current.charSpacing;
+      const wordSpacing = current.wordSpacing;
+      const textHScale = current.textHScale * fontDirection;
+      const fontMatrix = current.fontMatrix || _util.FONT_IDENTITY_MATRIX;
+      const glyphsLength = glyphs.length;
+      const isTextInvisible = current.textRenderingMode === _util.TextRenderingMode.INVISIBLE;
+      let i, glyph, width, spacingLength;
+
+      if (isTextInvisible || fontSize === 0) {
+        return;
+      }
+
+      this._cachedGetSinglePixelWidth = null;
+      ctx.save();
+      ctx.transform.apply(ctx, current.textMatrix);
+      ctx.translate(current.x, current.y);
+      ctx.scale(textHScale, fontDirection);
+
+      for (i = 0; i < glyphsLength; ++i) {
+        glyph = glyphs[i];
+
+        if ((0, _util.isNum)(glyph)) {
+          spacingLength = spacingDir * glyph * fontSize / 1000;
+          this.ctx.translate(spacingLength, 0);
+          current.x += spacingLength * textHScale;
+          continue;
+        }
+
+        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
+        const operatorList = font.charProcOperatorList[glyph.operatorListId];
+
+        if (!operatorList) {
+          (0, _util.warn)(`Type3 character "${glyph.operatorListId}" is not available.`);
+          continue;
+        }
+
+        if (this.contentVisible) {
+          this.processingType3 = glyph;
+          this.save();
+          ctx.scale(fontSize, fontSize);
+          ctx.transform.apply(ctx, fontMatrix);
+          this.executeOperatorList(operatorList);
+          this.restore();
+        }
+
+        const transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
+
+        width = transformed[0] * fontSize + spacing;
+        ctx.translate(width, 0);
+        current.x += width * textHScale;
+      }
+
+      ctx.restore();
+      this.processingType3 = null;
+    },
+    setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {},
+    setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
+      this.ctx.rect(llx, lly, urx - llx, ury - lly);
+      this.clip();
+      this.endPath();
+    },
+    getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
+      let pattern;
+
+      if (IR[0] === "TilingPattern") {
+        const color = IR[1];
+        const baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
+        const canvasGraphicsFactory = {
+          createCanvasGraphics: ctx => {
+            return new CanvasGraphics(ctx, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext);
+          }
+        };
+        pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
+      } else {
+        pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
+      }
+
+      return pattern;
+    },
+    setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
+      this.current.strokeColor = this.getColorN_Pattern(arguments);
+    },
+    setFillColorN: function CanvasGraphics_setFillColorN() {
+      this.current.fillColor = this.getColorN_Pattern(arguments);
+      this.current.patternFill = true;
+    },
+    setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
+      const color = _util.Util.makeHexColor(r, g, b);
+
+      this.ctx.strokeStyle = color;
+      this.current.strokeColor = color;
+    },
+    setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
+      const color = _util.Util.makeHexColor(r, g, b);
+
+      this.ctx.fillStyle = color;
+      this.current.fillColor = color;
+      this.current.patternFill = false;
+    },
+    shadingFill: function CanvasGraphics_shadingFill(patternIR) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const ctx = this.ctx;
+      this.save();
+      const pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
+      ctx.fillStyle = pattern.getPattern(ctx, this, true);
+      const inv = ctx.mozCurrentTransformInverse;
+
+      if (inv) {
+        const canvas = ctx.canvas;
+        const width = canvas.width;
+        const height = canvas.height;
+
+        const bl = _util.Util.applyTransform([0, 0], inv);
+
+        const br = _util.Util.applyTransform([0, height], inv);
+
+        const ul = _util.Util.applyTransform([width, 0], inv);
+
+        const ur = _util.Util.applyTransform([width, height], inv);
+
+        const x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
+        const y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
+        const x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
+        const y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
+        this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
+      } else {
+        this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
+      }
+
+      this.restore();
+    },
+    beginInlineImage: function CanvasGraphics_beginInlineImage() {
+      (0, _util.unreachable)("Should not call beginInlineImage");
+    },
+    beginImageData: function CanvasGraphics_beginImageData() {
+      (0, _util.unreachable)("Should not call beginImageData");
+    },
+    paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      this.save();
+      this.baseTransformStack.push(this.baseTransform);
+
+      if (Array.isArray(matrix) && matrix.length === 6) {
+        this.transform.apply(this, matrix);
+      }
+
+      this.baseTransform = this.ctx.mozCurrentTransform;
+
+      if (bbox) {
+        const width = bbox[2] - bbox[0];
+        const height = bbox[3] - bbox[1];
+        this.ctx.rect(bbox[0], bbox[1], width, height);
+        this.clip();
+        this.endPath();
+      }
+    },
+    paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      this.restore();
+      this.baseTransform = this.baseTransformStack.pop();
+    },
+    beginGroup: function CanvasGraphics_beginGroup(group) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      this.save();
+      const currentCtx = this.ctx;
+
+      if (!group.isolated) {
+        (0, _util.info)("TODO: Support non-isolated groups.");
+      }
+
+      if (group.knockout) {
+        (0, _util.warn)("Knockout groups not supported.");
+      }
+
+      const currentTransform = currentCtx.mozCurrentTransform;
+
+      if (group.matrix) {
+        currentCtx.transform.apply(currentCtx, group.matrix);
+      }
+
+      if (!group.bbox) {
+        throw new Error("Bounding box is required.");
+      }
+
+      let bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
+
+      const canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
+      bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
+      const offsetX = Math.floor(bounds[0]);
+      const offsetY = Math.floor(bounds[1]);
+      let drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
+      let drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
+      let scaleX = 1,
+          scaleY = 1;
+
+      if (drawnWidth > MAX_GROUP_SIZE) {
+        scaleX = drawnWidth / MAX_GROUP_SIZE;
+        drawnWidth = MAX_GROUP_SIZE;
+      }
+
+      if (drawnHeight > MAX_GROUP_SIZE) {
+        scaleY = drawnHeight / MAX_GROUP_SIZE;
+        drawnHeight = MAX_GROUP_SIZE;
+      }
+
+      let cacheId = "groupAt" + this.groupLevel;
+
+      if (group.smask) {
+        cacheId += "_smask_" + this.smaskCounter++ % 2;
+      }
+
+      const scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
+      const groupCtx = scratchCanvas.context;
+      groupCtx.scale(1 / scaleX, 1 / scaleY);
+      groupCtx.translate(-offsetX, -offsetY);
+      groupCtx.transform.apply(groupCtx, currentTransform);
+
+      if (group.smask) {
+        this.smaskStack.push({
+          canvas: scratchCanvas.canvas,
+          context: groupCtx,
+          offsetX,
+          offsetY,
+          scaleX,
+          scaleY,
+          subtype: group.smask.subtype,
+          backdrop: group.smask.backdrop,
+          transferMap: group.smask.transferMap || null,
+          startTransformInverse: null
+        });
+      } else {
+        currentCtx.setTransform(1, 0, 0, 1, 0, 0);
+        currentCtx.translate(offsetX, offsetY);
+        currentCtx.scale(scaleX, scaleY);
+      }
+
+      copyCtxState(currentCtx, groupCtx);
+      this.ctx = groupCtx;
+      this.setGState([["BM", "source-over"], ["ca", 1], ["CA", 1]]);
+      this.groupStack.push(currentCtx);
+      this.groupLevel++;
+      this.current.activeSMask = null;
+    },
+    endGroup: function CanvasGraphics_endGroup(group) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      this.groupLevel--;
+      const groupCtx = this.ctx;
+      this.ctx = this.groupStack.pop();
+
+      if (this.ctx.imageSmoothingEnabled !== undefined) {
+        this.ctx.imageSmoothingEnabled = false;
+      } else {
+        this.ctx.mozImageSmoothingEnabled = false;
+      }
+
+      if (group.smask) {
+        this.tempSMask = this.smaskStack.pop();
+      } else {
+        this.ctx.drawImage(groupCtx.canvas, 0, 0);
+      }
+
+      this.restore();
+    },
+    beginAnnotations: function CanvasGraphics_beginAnnotations() {
+      this.save();
+
+      if (this.baseTransform) {
+        this.ctx.setTransform.apply(this.ctx, this.baseTransform);
+      }
+    },
+    endAnnotations: function CanvasGraphics_endAnnotations() {
+      this.restore();
+    },
+    beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform, matrix) {
+      this.save();
+      resetCtxToDefault(this.ctx);
+      this.current = new CanvasExtraState();
+
+      if (Array.isArray(rect) && rect.length === 4) {
+        const width = rect[2] - rect[0];
+        const height = rect[3] - rect[1];
+        this.ctx.rect(rect[0], rect[1], width, height);
+        this.clip();
+        this.endPath();
+      }
+
+      this.transform.apply(this, transform);
+      this.transform.apply(this, matrix);
+    },
+    endAnnotation: function CanvasGraphics_endAnnotation() {
+      this.restore();
+    },
+    paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const ctx = this.ctx;
+      const width = img.width,
+            height = img.height;
+      const fillColor = this.current.fillColor;
+      const isPatternFill = this.current.patternFill;
+      const glyph = this.processingType3;
+
+      if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
+        if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
+          glyph.compiled = compileType3Glyph({
+            data: img.data,
+            width,
+            height
+          });
+        } else {
+          glyph.compiled = null;
+        }
+      }
+
+      if (glyph?.compiled) {
+        glyph.compiled(ctx);
+        return;
+      }
+
+      const maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
+      const maskCtx = maskCanvas.context;
+      maskCtx.save();
+      putBinaryImageMask(maskCtx, img);
+      maskCtx.globalCompositeOperation = "source-in";
+      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+      maskCtx.fillRect(0, 0, width, height);
+      maskCtx.restore();
+      this.paintInlineImageXObject(maskCanvas.canvas);
+    },
+
+    paintImageMaskXObjectRepeat(imgData, scaleX, skewX = 0, skewY = 0, scaleY, positions) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const width = imgData.width;
+      const height = imgData.height;
+      const fillColor = this.current.fillColor;
+      const isPatternFill = this.current.patternFill;
+      const maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
+      const maskCtx = maskCanvas.context;
+      maskCtx.save();
+      putBinaryImageMask(maskCtx, imgData);
+      maskCtx.globalCompositeOperation = "source-in";
+      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+      maskCtx.fillRect(0, 0, width, height);
+      maskCtx.restore();
+      const ctx = this.ctx;
+
+      for (let i = 0, ii = positions.length; i < ii; i += 2) {
+        ctx.save();
+        ctx.transform(scaleX, skewX, skewY, scaleY, positions[i], positions[i + 1]);
+        ctx.scale(1, -1);
+        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
+        ctx.restore();
+      }
+    },
+
+    paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(images) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const ctx = this.ctx;
+      const fillColor = this.current.fillColor;
+      const isPatternFill = this.current.patternFill;
+
+      for (let i = 0, ii = images.length; i < ii; i++) {
+        const image = images[i];
+        const width = image.width,
+              height = image.height;
+        const maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
+        const maskCtx = maskCanvas.context;
+        maskCtx.save();
+        putBinaryImageMask(maskCtx, image);
+        maskCtx.globalCompositeOperation = "source-in";
+        maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+        maskCtx.fillRect(0, 0, width, height);
+        maskCtx.restore();
+        ctx.save();
+        ctx.transform.apply(ctx, image.transform);
+        ctx.scale(1, -1);
+        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
+        ctx.restore();
+      }
+    },
+    paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
+
+      if (!imgData) {
+        (0, _util.warn)("Dependent image isn't ready yet");
+        return;
+      }
+
+      this.paintInlineImageXObject(imgData);
+    },
+    paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
+
+      if (!imgData) {
+        (0, _util.warn)("Dependent image isn't ready yet");
+        return;
+      }
+
+      const width = imgData.width;
+      const height = imgData.height;
+      const map = [];
+
+      for (let i = 0, ii = positions.length; i < ii; i += 2) {
+        map.push({
+          transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
+          x: 0,
+          y: 0,
+          w: width,
+          h: height
+        });
+      }
+
+      this.paintInlineImageXObjectGroup(imgData, map);
+    },
+    paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const width = imgData.width;
+      const height = imgData.height;
+      const ctx = this.ctx;
+      this.save();
+      ctx.scale(1 / width, -1 / height);
+      const currentTransform = ctx.mozCurrentTransformInverse;
+      const a = currentTransform[0],
+            b = currentTransform[1];
+      let widthScale = Math.max(Math.sqrt(a * a + b * b), 1);
+      const c = currentTransform[2],
+            d = currentTransform[3];
+      let heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
+      let imgToPaint, tmpCanvas, tmpCtx;
+
+      if (typeof HTMLElement === "function" && imgData instanceof HTMLElement || !imgData.data) {
+        imgToPaint = imgData;
+      } else {
+        tmpCanvas = this.cachedCanvases.getCanvas("inlineImage", width, height);
+        tmpCtx = tmpCanvas.context;
+        putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);
+        imgToPaint = tmpCanvas.canvas;
+      }
+
+      let paintWidth = width,
+          paintHeight = height;
+      let tmpCanvasId = "prescale1";
+
+      while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
+        let newWidth = paintWidth,
+            newHeight = paintHeight;
+
+        if (widthScale > 2 && paintWidth > 1) {
+          newWidth = Math.ceil(paintWidth / 2);
+          widthScale /= paintWidth / newWidth;
+        }
+
+        if (heightScale > 2 && paintHeight > 1) {
+          newHeight = Math.ceil(paintHeight / 2);
+          heightScale /= paintHeight / newHeight;
+        }
+
+        tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
+        tmpCtx = tmpCanvas.context;
+        tmpCtx.clearRect(0, 0, newWidth, newHeight);
+        tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth, newHeight);
+        imgToPaint = tmpCanvas.canvas;
+        paintWidth = newWidth;
+        paintHeight = newHeight;
+        tmpCanvasId = tmpCanvasId === "prescale1" ? "prescale2" : "prescale1";
+      }
+
+      ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
+
+      if (this.imageLayer) {
+        const position = this.getCanvasPosition(0, -height);
+        this.imageLayer.appendImage({
+          imgData,
+          left: position[0],
+          top: position[1],
+          width: width / currentTransform[0],
+          height: height / currentTransform[3]
+        });
+      }
+
+      this.restore();
+    },
+    paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      const ctx = this.ctx;
+      const w = imgData.width;
+      const h = imgData.height;
+      const tmpCanvas = this.cachedCanvases.getCanvas("inlineImage", w, h);
+      const tmpCtx = tmpCanvas.context;
+      putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);
+
+      for (let i = 0, ii = map.length; i < ii; i++) {
+        const entry = map[i];
+        ctx.save();
+        ctx.transform.apply(ctx, entry.transform);
+        ctx.scale(1, -1);
+        ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
+
+        if (this.imageLayer) {
+          const position = this.getCanvasPosition(entry.x, entry.y);
+          this.imageLayer.appendImage({
+            imgData,
+            left: position[0],
+            top: position[1],
+            width: w,
+            height: h
+          });
+        }
+
+        ctx.restore();
+      }
+    },
+    paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
+      if (!this.contentVisible) {
+        return;
+      }
+
+      this.ctx.fillRect(0, 0, 1, 1);
+    },
+    markPoint: function CanvasGraphics_markPoint(tag) {},
+    markPointProps: function CanvasGraphics_markPointProps(tag, properties) {},
+    beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {
+      this.markedContentStack.push({
+        visible: true
+      });
+    },
+    beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag, properties) {
+      if (tag === "OC") {
+        this.markedContentStack.push({
+          visible: this.optionalContentConfig.isVisible(properties)
+        });
+      } else {
+        this.markedContentStack.push({
+          visible: true
+        });
+      }
+
+      this.contentVisible = this.isContentVisible();
+    },
+    endMarkedContent: function CanvasGraphics_endMarkedContent() {
+      this.markedContentStack.pop();
+      this.contentVisible = this.isContentVisible();
+    },
+    beginCompat: function CanvasGraphics_beginCompat() {},
+    endCompat: function CanvasGraphics_endCompat() {},
+    consumePath: function CanvasGraphics_consumePath() {
+      const ctx = this.ctx;
+
+      if (this.pendingClip) {
+        if (this.pendingClip === EO_CLIP) {
+          ctx.clip("evenodd");
+        } else {
+          ctx.clip();
+        }
+
+        this.pendingClip = null;
+      }
+
+      ctx.beginPath();
+    },
+
+    getSinglePixelWidth(scale) {
+      if (this._cachedGetSinglePixelWidth === null) {
+        const inverse = this.ctx.mozCurrentTransformInverse;
+        this._cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
+      }
+
+      return this._cachedGetSinglePixelWidth;
+    },
+
+    getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
+      const transform = this.ctx.mozCurrentTransform;
+      return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]];
+    },
+    isContentVisible: function CanvasGraphics_isContentVisible() {
+      for (let i = this.markedContentStack.length - 1; i >= 0; i--) {
+        if (!this.markedContentStack[i].visible) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  };
+
+  for (const op in _util.OPS) {
+    CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
+  }
+
+  return CanvasGraphics;
+}();
+
+exports.CanvasGraphics = CanvasGraphics;
+
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getShadingPatternFromIR = getShadingPatternFromIR;
+exports.TilingPattern = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const ShadingIRs = {};
+
+function applyBoundingBox(ctx, bbox) {
+  if (!bbox || typeof Path2D === "undefined") {
+    return;
+  }
+
+  const width = bbox[2] - bbox[0];
+  const height = bbox[3] - bbox[1];
+  const region = new Path2D();
+  region.rect(bbox[0], bbox[1], width, height);
+  ctx.clip(region);
+}
+
+ShadingIRs.RadialAxial = {
+  fromIR: function RadialAxial_fromIR(raw) {
+    const type = raw[1];
+    const bbox = raw[2];
+    const colorStops = raw[3];
+    const p0 = raw[4];
+    const p1 = raw[5];
+    const r0 = raw[6];
+    const r1 = raw[7];
+    return {
+      getPattern: function RadialAxial_getPattern(ctx) {
+        applyBoundingBox(ctx, bbox);
+        let grad;
+
+        if (type === "axial") {
+          grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
+        } else if (type === "radial") {
+          grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
+        }
+
+        for (let i = 0, ii = colorStops.length; i < ii; ++i) {
+          const c = colorStops[i];
+          grad.addColorStop(c[0], c[1]);
+        }
+
+        return grad;
+      }
+    };
+  }
+};
+
+const createMeshCanvas = function createMeshCanvasClosure() {
+  function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
+    const coords = context.coords,
+          colors = context.colors;
+    const bytes = data.data,
+          rowSize = data.width * 4;
+    let tmp;
+
+    if (coords[p1 + 1] > coords[p2 + 1]) {
+      tmp = p1;
+      p1 = p2;
+      p2 = tmp;
+      tmp = c1;
+      c1 = c2;
+      c2 = tmp;
+    }
+
+    if (coords[p2 + 1] > coords[p3 + 1]) {
+      tmp = p2;
+      p2 = p3;
+      p3 = tmp;
+      tmp = c2;
+      c2 = c3;
+      c3 = tmp;
+    }
+
+    if (coords[p1 + 1] > coords[p2 + 1]) {
+      tmp = p1;
+      p1 = p2;
+      p2 = tmp;
+      tmp = c1;
+      c1 = c2;
+      c2 = tmp;
+    }
+
+    const x1 = (coords[p1] + context.offsetX) * context.scaleX;
+    const y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
+    const x2 = (coords[p2] + context.offsetX) * context.scaleX;
+    const y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
+    const x3 = (coords[p3] + context.offsetX) * context.scaleX;
+    const y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
+
+    if (y1 >= y3) {
+      return;
+    }
+
+    const c1r = colors[c1],
+          c1g = colors[c1 + 1],
+          c1b = colors[c1 + 2];
+    const c2r = colors[c2],
+          c2g = colors[c2 + 1],
+          c2b = colors[c2 + 2];
+    const c3r = colors[c3],
+          c3g = colors[c3 + 1],
+          c3b = colors[c3 + 2];
+    const minY = Math.round(y1),
+          maxY = Math.round(y3);
+    let xa, car, cag, cab;
+    let xb, cbr, cbg, cbb;
+
+    for (let y = minY; y <= maxY; y++) {
+      if (y < y2) {
+        let k;
+
+        if (y < y1) {
+          k = 0;
+        } else if (y1 === y2) {
+          k = 1;
+        } else {
+          k = (y1 - y) / (y1 - y2);
+        }
+
+        xa = x1 - (x1 - x2) * k;
+        car = c1r - (c1r - c2r) * k;
+        cag = c1g - (c1g - c2g) * k;
+        cab = c1b - (c1b - c2b) * k;
+      } else {
+        let k;
+
+        if (y > y3) {
+          k = 1;
+        } else if (y2 === y3) {
+          k = 0;
+        } else {
+          k = (y2 - y) / (y2 - y3);
+        }
+
+        xa = x2 - (x2 - x3) * k;
+        car = c2r - (c2r - c3r) * k;
+        cag = c2g - (c2g - c3g) * k;
+        cab = c2b - (c2b - c3b) * k;
+      }
+
+      let k;
+
+      if (y < y1) {
+        k = 0;
+      } else if (y > y3) {
+        k = 1;
+      } else {
+        k = (y1 - y) / (y1 - y3);
+      }
+
+      xb = x1 - (x1 - x3) * k;
+      cbr = c1r - (c1r - c3r) * k;
+      cbg = c1g - (c1g - c3g) * k;
+      cbb = c1b - (c1b - c3b) * k;
+      const x1_ = Math.round(Math.min(xa, xb));
+      const x2_ = Math.round(Math.max(xa, xb));
+      let j = rowSize * y + x1_ * 4;
+
+      for (let x = x1_; x <= x2_; x++) {
+        k = (xa - x) / (xa - xb);
+
+        if (k < 0) {
+          k = 0;
+        } else if (k > 1) {
+          k = 1;
+        }
+
+        bytes[j++] = car - (car - cbr) * k | 0;
+        bytes[j++] = cag - (cag - cbg) * k | 0;
+        bytes[j++] = cab - (cab - cbb) * k | 0;
+        bytes[j++] = 255;
+      }
+    }
+  }
+
+  function drawFigure(data, figure, context) {
+    const ps = figure.coords;
+    const cs = figure.colors;
+    let i, ii;
+
+    switch (figure.type) {
+      case "lattice":
+        const verticesPerRow = figure.verticesPerRow;
+        const rows = Math.floor(ps.length / verticesPerRow) - 1;
+        const cols = verticesPerRow - 1;
+
+        for (i = 0; i < rows; i++) {
+          let q = i * verticesPerRow;
+
+          for (let j = 0; j < cols; j++, q++) {
+            drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
+            drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
+          }
+        }
+
+        break;
+
+      case "triangles":
+        for (i = 0, ii = ps.length; i < ii; i += 3) {
+          drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
+        }
+
+        break;
+
+      default:
+        throw new Error("illegal figure");
+    }
+  }
+
+  function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases, webGLContext) {
+    const EXPECTED_SCALE = 1.1;
+    const MAX_PATTERN_SIZE = 3000;
+    const BORDER_SIZE = 2;
+    const offsetX = Math.floor(bounds[0]);
+    const offsetY = Math.floor(bounds[1]);
+    const boundsWidth = Math.ceil(bounds[2]) - offsetX;
+    const boundsHeight = Math.ceil(bounds[3]) - offsetY;
+    const width = Math.min(Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
+    const height = Math.min(Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
+    const scaleX = boundsWidth / width;
+    const scaleY = boundsHeight / height;
+    const context = {
+      coords,
+      colors,
+      offsetX: -offsetX,
+      offsetY: -offsetY,
+      scaleX: 1 / scaleX,
+      scaleY: 1 / scaleY
+    };
+    const paddedWidth = width + BORDER_SIZE * 2;
+    const paddedHeight = height + BORDER_SIZE * 2;
+    let canvas, tmpCanvas, i, ii;
+
+    if (webGLContext.isEnabled) {
+      canvas = webGLContext.drawFigures({
+        width,
+        height,
+        backgroundColor,
+        figures,
+        context
+      });
+      tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false);
+      tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
+      canvas = tmpCanvas.canvas;
+    } else {
+      tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false);
+      const tmpCtx = tmpCanvas.context;
+      const data = tmpCtx.createImageData(width, height);
+
+      if (backgroundColor) {
+        const bytes = data.data;
+
+        for (i = 0, ii = bytes.length; i < ii; i += 4) {
+          bytes[i] = backgroundColor[0];
+          bytes[i + 1] = backgroundColor[1];
+          bytes[i + 2] = backgroundColor[2];
+          bytes[i + 3] = 255;
+        }
+      }
+
+      for (i = 0; i < figures.length; i++) {
+        drawFigure(data, figures[i], context);
+      }
+
+      tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
+      canvas = tmpCanvas.canvas;
+    }
+
+    return {
+      canvas,
+      offsetX: offsetX - BORDER_SIZE * scaleX,
+      offsetY: offsetY - BORDER_SIZE * scaleY,
+      scaleX,
+      scaleY
+    };
+  }
+
+  return createMeshCanvas;
+}();
+
+ShadingIRs.Mesh = {
+  fromIR: function Mesh_fromIR(raw) {
+    const coords = raw[2];
+    const colors = raw[3];
+    const figures = raw[4];
+    const bounds = raw[5];
+    const matrix = raw[6];
+    const bbox = raw[7];
+    const background = raw[8];
+    return {
+      getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
+        applyBoundingBox(ctx, bbox);
+        let scale;
+
+        if (shadingFill) {
+          scale = _util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
+        } else {
+          scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
+
+          if (matrix) {
+            const matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
+
+            scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
+          }
+        }
+
+        const temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases, owner.webGLContext);
+
+        if (!shadingFill) {
+          ctx.setTransform.apply(ctx, owner.baseTransform);
+
+          if (matrix) {
+            ctx.transform.apply(ctx, matrix);
+          }
+        }
+
+        ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
+        ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
+        return ctx.createPattern(temporaryPatternCanvas.canvas, "no-repeat");
+      }
+    };
+  }
+};
+ShadingIRs.Dummy = {
+  fromIR: function Dummy_fromIR() {
+    return {
+      getPattern: function Dummy_fromIR_getPattern() {
+        return "hotpink";
+      }
+    };
+  }
+};
+
+function getShadingPatternFromIR(raw) {
+  const shadingIR = ShadingIRs[raw[0]];
+
+  if (!shadingIR) {
+    throw new Error(`Unknown IR type: ${raw[0]}`);
+  }
+
+  return shadingIR.fromIR(raw);
+}
+
+const TilingPattern = function TilingPatternClosure() {
+  const PaintType = {
+    COLORED: 1,
+    UNCOLORED: 2
+  };
+  const MAX_PATTERN_SIZE = 3000;
+
+  function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
+    this.operatorList = IR[2];
+    this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
+    this.bbox = IR[4];
+    this.xstep = IR[5];
+    this.ystep = IR[6];
+    this.paintType = IR[7];
+    this.tilingType = IR[8];
+    this.color = color;
+    this.canvasGraphicsFactory = canvasGraphicsFactory;
+    this.baseTransform = baseTransform;
+    this.ctx = ctx;
+  }
+
+  TilingPattern.prototype = {
+    createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
+      const operatorList = this.operatorList;
+      const bbox = this.bbox;
+      const xstep = this.xstep;
+      const ystep = this.ystep;
+      const paintType = this.paintType;
+      const tilingType = this.tilingType;
+      const color = this.color;
+      const canvasGraphicsFactory = this.canvasGraphicsFactory;
+      (0, _util.info)("TilingType: " + tilingType);
+      const x0 = bbox[0],
+            y0 = bbox[1],
+            x1 = bbox[2],
+            y1 = bbox[3];
+
+      const matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
+
+      const curMatrixScale = _util.Util.singularValueDecompose2dScale(this.baseTransform);
+
+      const combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] * curMatrixScale[1]];
+      const dimx = this.getSizeAndScale(xstep, this.ctx.canvas.width, combinedScale[0]);
+      const dimy = this.getSizeAndScale(ystep, this.ctx.canvas.height, combinedScale[1]);
+      const tmpCanvas = owner.cachedCanvases.getCanvas("pattern", dimx.size, dimy.size, true);
+      const tmpCtx = tmpCanvas.context;
+      const graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
+      graphics.groupLevel = owner.groupLevel;
+      this.setFillAndStrokeStyleToContext(graphics, paintType, color);
+      graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);
+      graphics.transform(1, 0, 0, 1, -x0, -y0);
+      this.clipBbox(graphics, bbox, x0, y0, x1, y1);
+      graphics.executeOperatorList(operatorList);
+      this.ctx.transform(1, 0, 0, 1, x0, y0);
+      this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);
+      return tmpCanvas.canvas;
+    },
+    getSizeAndScale: function TilingPattern_getSizeAndScale(step, realOutputSize, scale) {
+      step = Math.abs(step);
+      const maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
+      let size = Math.ceil(step * scale);
+
+      if (size >= maxSize) {
+        size = maxSize;
+      } else {
+        scale = size / step;
+      }
+
+      return {
+        scale,
+        size
+      };
+    },
+    clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
+      if (Array.isArray(bbox) && bbox.length === 4) {
+        const bboxWidth = x1 - x0;
+        const bboxHeight = y1 - y0;
+        graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
+        graphics.clip();
+        graphics.endPath();
+      }
+    },
+    setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
+      const context = graphics.ctx,
+            current = graphics.current;
+
+      switch (paintType) {
+        case PaintType.COLORED:
+          const ctx = this.ctx;
+          context.fillStyle = ctx.fillStyle;
+          context.strokeStyle = ctx.strokeStyle;
+          current.fillColor = ctx.fillStyle;
+          current.strokeColor = ctx.strokeStyle;
+          break;
+
+        case PaintType.UNCOLORED:
+          const cssColor = _util.Util.makeHexColor(color[0], color[1], color[2]);
+
+          context.fillStyle = cssColor;
+          context.strokeStyle = cssColor;
+          current.fillColor = cssColor;
+          current.strokeColor = cssColor;
+          break;
+
+        default:
+          throw new _util.FormatError(`Unsupported paint type: ${paintType}`);
+      }
+    },
+    getPattern: function TilingPattern_getPattern(ctx, owner) {
+      ctx = this.ctx;
+      ctx.setTransform.apply(ctx, this.baseTransform);
+      ctx.transform.apply(ctx, this.matrix);
+      const temporaryPatternCanvas = this.createPatternCanvas(owner);
+      return ctx.createPattern(temporaryPatternCanvas, "repeat");
+    }
+  };
+  return TilingPattern;
+}();
+
+exports.TilingPattern = TilingPattern;
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.GlobalWorkerOptions = void 0;
+const GlobalWorkerOptions = Object.create(null);
+exports.GlobalWorkerOptions = GlobalWorkerOptions;
+GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort;
+GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? "" : GlobalWorkerOptions.workerSrc;
+
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.MessageHandler = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const CallbackKind = {
+  UNKNOWN: 0,
+  DATA: 1,
+  ERROR: 2
+};
+const StreamKind = {
+  UNKNOWN: 0,
+  CANCEL: 1,
+  CANCEL_COMPLETE: 2,
+  CLOSE: 3,
+  ENQUEUE: 4,
+  ERROR: 5,
+  PULL: 6,
+  PULL_COMPLETE: 7,
+  START_COMPLETE: 8
+};
+
+function wrapReason(reason) {
+  if (typeof reason !== "object" || reason === null) {
+    return reason;
+  }
+
+  switch (reason.name) {
+    case "AbortException":
+      return new _util.AbortException(reason.message);
+
+    case "MissingPDFException":
+      return new _util.MissingPDFException(reason.message);
+
+    case "UnexpectedResponseException":
+      return new _util.UnexpectedResponseException(reason.message, reason.status);
+
+    case "UnknownErrorException":
+      return new _util.UnknownErrorException(reason.message, reason.details);
+
+    default:
+      return new _util.UnknownErrorException(reason.message, reason.toString());
+  }
+}
+
+class MessageHandler {
+  constructor(sourceName, targetName, comObj) {
+    this.sourceName = sourceName;
+    this.targetName = targetName;
+    this.comObj = comObj;
+    this.callbackId = 1;
+    this.streamId = 1;
+    this.postMessageTransfers = true;
+    this.streamSinks = Object.create(null);
+    this.streamControllers = Object.create(null);
+    this.callbackCapabilities = Object.create(null);
+    this.actionHandler = Object.create(null);
+
+    this._onComObjOnMessage = event => {
+      const data = event.data;
+
+      if (data.targetName !== this.sourceName) {
+        return;
+      }
+
+      if (data.stream) {
+        this._processStreamMessage(data);
+
+        return;
+      }
+
+      if (data.callback) {
+        const callbackId = data.callbackId;
+        const capability = this.callbackCapabilities[callbackId];
+
+        if (!capability) {
+          throw new Error(`Cannot resolve callback ${callbackId}`);
+        }
+
+        delete this.callbackCapabilities[callbackId];
+
+        if (data.callback === CallbackKind.DATA) {
+          capability.resolve(data.data);
+        } else if (data.callback === CallbackKind.ERROR) {
+          capability.reject(wrapReason(data.reason));
+        } else {
+          throw new Error("Unexpected callback case");
+        }
+
+        return;
+      }
+
+      const action = this.actionHandler[data.action];
+
+      if (!action) {
+        throw new Error(`Unknown action from worker: ${data.action}`);
+      }
+
+      if (data.callbackId) {
+        const cbSourceName = this.sourceName;
+        const cbTargetName = data.sourceName;
+        new Promise(function (resolve) {
+          resolve(action(data.data));
+        }).then(function (result) {
+          comObj.postMessage({
+            sourceName: cbSourceName,
+            targetName: cbTargetName,
+            callback: CallbackKind.DATA,
+            callbackId: data.callbackId,
+            data: result
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName: cbSourceName,
+            targetName: cbTargetName,
+            callback: CallbackKind.ERROR,
+            callbackId: data.callbackId,
+            reason: wrapReason(reason)
+          });
+        });
+        return;
+      }
+
+      if (data.streamId) {
+        this._createStreamSink(data);
+
+        return;
+      }
+
+      action(data.data);
+    };
+
+    comObj.addEventListener("message", this._onComObjOnMessage);
+  }
+
+  on(actionName, handler) {
+    const ah = this.actionHandler;
+
+    if (ah[actionName]) {
+      throw new Error(`There is already an actionName called "${actionName}"`);
+    }
+
+    ah[actionName] = handler;
+  }
+
+  send(actionName, data, transfers) {
+    this._postMessage({
+      sourceName: this.sourceName,
+      targetName: this.targetName,
+      action: actionName,
+      data
+    }, transfers);
+  }
+
+  sendWithPromise(actionName, data, transfers) {
+    const callbackId = this.callbackId++;
+    const capability = (0, _util.createPromiseCapability)();
+    this.callbackCapabilities[callbackId] = capability;
+
+    try {
+      this._postMessage({
+        sourceName: this.sourceName,
+        targetName: this.targetName,
+        action: actionName,
+        callbackId,
+        data
+      }, transfers);
+    } catch (ex) {
+      capability.reject(ex);
+    }
+
+    return capability.promise;
+  }
+
+  sendWithStream(actionName, data, queueingStrategy, transfers) {
+    const streamId = this.streamId++;
+    const sourceName = this.sourceName;
+    const targetName = this.targetName;
+    const comObj = this.comObj;
+    return new ReadableStream({
+      start: controller => {
+        const startCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId] = {
+          controller,
+          startCall: startCapability,
+          pullCall: null,
+          cancelCall: null,
+          isClosed: false
+        };
+
+        this._postMessage({
+          sourceName,
+          targetName,
+          action: actionName,
+          streamId,
+          data,
+          desiredSize: controller.desiredSize
+        }, transfers);
+
+        return startCapability.promise;
+      },
+      pull: controller => {
+        const pullCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].pullCall = pullCapability;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.PULL,
+          streamId,
+          desiredSize: controller.desiredSize
+        });
+        return pullCapability.promise;
+      },
+      cancel: reason => {
+        (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason");
+        const cancelCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].cancelCall = cancelCapability;
+        this.streamControllers[streamId].isClosed = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.CANCEL,
+          streamId,
+          reason: wrapReason(reason)
+        });
+        return cancelCapability.promise;
+      }
+    }, queueingStrategy);
+  }
+
+  _createStreamSink(data) {
+    const self = this;
+    const action = this.actionHandler[data.action];
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
+    const streamSink = {
+      enqueue(chunk, size = 1, transfers) {
+        if (this.isCancelled) {
+          return;
+        }
+
+        const lastDesiredSize = this.desiredSize;
+        this.desiredSize -= size;
+
+        if (lastDesiredSize > 0 && this.desiredSize <= 0) {
+          this.sinkCapability = (0, _util.createPromiseCapability)();
+          this.ready = this.sinkCapability.promise;
+        }
+
+        self._postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.ENQUEUE,
+          streamId,
+          chunk
+        }, transfers);
+      },
+
+      close() {
+        if (this.isCancelled) {
+          return;
+        }
+
+        this.isCancelled = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.CLOSE,
+          streamId
+        });
+        delete self.streamSinks[streamId];
+      },
+
+      error(reason) {
+        (0, _util.assert)(reason instanceof Error, "error must have a valid reason");
+
+        if (this.isCancelled) {
+          return;
+        }
+
+        this.isCancelled = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.ERROR,
+          streamId,
+          reason: wrapReason(reason)
+        });
+      },
+
+      sinkCapability: (0, _util.createPromiseCapability)(),
+      onPull: null,
+      onCancel: null,
+      isCancelled: false,
+      desiredSize: data.desiredSize,
+      ready: null
+    };
+    streamSink.sinkCapability.resolve();
+    streamSink.ready = streamSink.sinkCapability.promise;
+    this.streamSinks[streamId] = streamSink;
+    new Promise(function (resolve) {
+      resolve(action(data.data, streamSink));
+    }).then(function () {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        success: true
+      });
+    }, function (reason) {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        reason: wrapReason(reason)
+      });
+    });
+  }
+
+  _processStreamMessage(data) {
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
+
+    switch (data.stream) {
+      case StreamKind.START_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].startCall.resolve();
+        } else {
+          this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
+        }
+
+        break;
+
+      case StreamKind.PULL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].pullCall.resolve();
+        } else {
+          this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
+        }
+
+        break;
+
+      case StreamKind.PULL:
+        if (!this.streamSinks[streamId]) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            success: true
+          });
+          break;
+        }
+
+        if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
+          this.streamSinks[streamId].sinkCapability.resolve();
+        }
+
+        this.streamSinks[streamId].desiredSize = data.desiredSize;
+        const {
+          onPull
+        } = this.streamSinks[data.streamId];
+        new Promise(function (resolve) {
+          resolve(onPull && onPull());
+        }).then(function () {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            success: true
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        });
+        break;
+
+      case StreamKind.ENQUEUE:
+        (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
+
+        if (this.streamControllers[streamId].isClosed) {
+          break;
+        }
+
+        this.streamControllers[streamId].controller.enqueue(data.chunk);
+        break;
+
+      case StreamKind.CLOSE:
+        (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
+
+        if (this.streamControllers[streamId].isClosed) {
+          break;
+        }
+
+        this.streamControllers[streamId].isClosed = true;
+        this.streamControllers[streamId].controller.close();
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.ERROR:
+        (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
+        this.streamControllers[streamId].controller.error(wrapReason(data.reason));
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.CANCEL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].cancelCall.resolve();
+        } else {
+          this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
+        }
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.CANCEL:
+        if (!this.streamSinks[streamId]) {
+          break;
+        }
+
+        const {
+          onCancel
+        } = this.streamSinks[data.streamId];
+        new Promise(function (resolve) {
+          resolve(onCancel && onCancel(wrapReason(data.reason)));
+        }).then(function () {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            success: true
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        });
+        this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
+        this.streamSinks[streamId].isCancelled = true;
+        delete this.streamSinks[streamId];
+        break;
+
+      default:
+        throw new Error("Unexpected stream case");
+    }
+  }
+
+  async _deleteStreamController(streamId) {
+    await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
+      return capability && capability.promise;
+    }));
+    delete this.streamControllers[streamId];
+  }
+
+  _postMessage(message, transfers) {
+    if (transfers && this.postMessageTransfers) {
+      this.comObj.postMessage(message, transfers);
+    } else {
+      this.comObj.postMessage(message);
+    }
+  }
+
+  destroy() {
+    this.comObj.removeEventListener("message", this._onComObjOnMessage);
+  }
+
+}
+
+exports.MessageHandler = MessageHandler;
+
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Metadata = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _xml_parser = __w_pdfjs_require__(15);
+
+class Metadata {
+  constructor(data) {
+    (0, _util.assert)(typeof data === "string", "Metadata: input is not a string");
+    data = this._repair(data);
+    const parser = new _xml_parser.SimpleXMLParser();
+    const xmlDocument = parser.parseFromString(data);
+    this._metadataMap = new Map();
+
+    if (xmlDocument) {
+      this._parse(xmlDocument);
+    }
+  }
+
+  _repair(data) {
+    return data.replace(/^[^<]+/, "").replace(/>\\376\\377([^<]+)/g, function (all, codes) {
+      const bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
+        return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
+      }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
+        switch (name) {
+          case "amp":
+            return "&";
+
+          case "apos":
+            return "'";
+
+          case "gt":
+            return ">";
+
+          case "lt":
+            return "<";
+
+          case "quot":
+            return '"';
+        }
+
+        throw new Error(`_repair: ${name} isn't defined.`);
+      });
+      let chars = "";
+
+      for (let i = 0, ii = bytes.length; i < ii; i += 2) {
+        const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
+
+        if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) {
+          chars += String.fromCharCode(code);
+        } else {
+          chars += "&#x" + (0x10000 + code).toString(16).substring(1) + ";";
+        }
+      }
+
+      return ">" + chars;
+    });
+  }
+
+  _parse(xmlDocument) {
+    let rdf = xmlDocument.documentElement;
+
+    if (rdf.nodeName.toLowerCase() !== "rdf:rdf") {
+      rdf = rdf.firstChild;
+
+      while (rdf && rdf.nodeName.toLowerCase() !== "rdf:rdf") {
+        rdf = rdf.nextSibling;
+      }
+    }
+
+    const nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
+
+    if (!rdf || nodeName !== "rdf:rdf" || !rdf.hasChildNodes()) {
+      return;
+    }
+
+    const children = rdf.childNodes;
+
+    for (let i = 0, ii = children.length; i < ii; i++) {
+      const desc = children[i];
+
+      if (desc.nodeName.toLowerCase() !== "rdf:description") {
+        continue;
+      }
+
+      for (let j = 0, jj = desc.childNodes.length; j < jj; j++) {
+        if (desc.childNodes[j].nodeName.toLowerCase() !== "#text") {
+          const entry = desc.childNodes[j];
+          const name = entry.nodeName.toLowerCase();
+
+          this._metadataMap.set(name, entry.textContent.trim());
+        }
+      }
+    }
+  }
+
+  get(name) {
+    return this._metadataMap.has(name) ? this._metadataMap.get(name) : null;
+  }
+
+  getAll() {
+    return (0, _util.objectFromEntries)(this._metadataMap);
+  }
+
+  has(name) {
+    return this._metadataMap.has(name);
+  }
+
+}
+
+exports.Metadata = Metadata;
+
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SimpleXMLParser = exports.SimpleDOMNode = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const XMLParserErrorCode = {
+  NoError: 0,
+  EndOfDocument: -1,
+  UnterminatedCdat: -2,
+  UnterminatedXmlDeclaration: -3,
+  UnterminatedDoctypeDeclaration: -4,
+  UnterminatedComment: -5,
+  MalformedElement: -6,
+  OutOfMemory: -7,
+  UnterminatedAttributeValue: -8,
+  UnterminatedElement: -9,
+  ElementNeverBegun: -10
+};
+
+function isWhitespace(s, index) {
+  const ch = s[index];
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "\t";
+}
+
+function isWhitespaceString(s) {
+  for (let i = 0, ii = s.length; i < ii; i++) {
+    if (!isWhitespace(s, i)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+class XMLParserBase {
+  _resolveEntities(s) {
+    return s.replace(/&([^;]+);/g, (all, entity) => {
+      if (entity.substring(0, 2) === "#x") {
+        return String.fromCodePoint(parseInt(entity.substring(2), 16));
+      } else if (entity.substring(0, 1) === "#") {
+        return String.fromCodePoint(parseInt(entity.substring(1), 10));
+      }
+
+      switch (entity) {
+        case "lt":
+          return "<";
+
+        case "gt":
+          return ">";
+
+        case "amp":
+          return "&";
+
+        case "quot":
+          return '"';
+      }
+
+      return this.onResolveEntity(entity);
+    });
+  }
+
+  _parseContent(s, start) {
+    const attributes = [];
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
+        ++pos;
+      }
+    }
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+
+    while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") {
+      skipWs();
+      let attrName = "",
+          attrValue = "";
+
+      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
+        attrName += s[pos];
+        ++pos;
+      }
+
+      skipWs();
+
+      if (s[pos] !== "=") {
+        return null;
+      }
+
+      ++pos;
+      skipWs();
+      const attrEndChar = s[pos];
+
+      if (attrEndChar !== '"' && attrEndChar !== "'") {
+        return null;
+      }
+
+      const attrEndIndex = s.indexOf(attrEndChar, ++pos);
+
+      if (attrEndIndex < 0) {
+        return null;
+      }
+
+      attrValue = s.substring(pos, attrEndIndex);
+      attributes.push({
+        name: attrName,
+        value: this._resolveEntities(attrValue)
+      });
+      pos = attrEndIndex + 1;
+      skipWs();
+    }
+
+    return {
+      name,
+      attributes,
+      parsed: pos - start
+    };
+  }
+
+  _parseProcessingInstruction(s, start) {
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
+        ++pos;
+      }
+    }
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+    const attrStart = pos;
+
+    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
+      ++pos;
+    }
+
+    const value = s.substring(attrStart, pos);
+    return {
+      name,
+      value,
+      parsed: pos - start
+    };
+  }
+
+  parseXml(s) {
+    let i = 0;
+
+    while (i < s.length) {
+      const ch = s[i];
+      let j = i;
+
+      if (ch === "<") {
+        ++j;
+        const ch2 = s[j];
+        let q;
+
+        switch (ch2) {
+          case "/":
+            ++j;
+            q = s.indexOf(">", j);
+
+            if (q < 0) {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
+
+            this.onEndElement(s.substring(j, q));
+            j = q + 1;
+            break;
+
+          case "?":
+            ++j;
+
+            const pi = this._parseProcessingInstruction(s, j);
+
+            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
+              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
+              return;
+            }
+
+            this.onPi(pi.name, pi.value);
+            j += pi.parsed + 2;
+            break;
+
+          case "!":
+            if (s.substring(j + 1, j + 3) === "--") {
+              q = s.indexOf("-->", j + 3);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedComment);
+                return;
+              }
+
+              this.onComment(s.substring(j + 3, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
+              q = s.indexOf("]]>", j + 8);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedCdat);
+                return;
+              }
+
+              this.onCdata(s.substring(j + 8, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
+              const q2 = s.indexOf("[", j + 8);
+              let complexDoctype = false;
+              q = s.indexOf(">", j + 8);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                return;
+              }
+
+              if (q2 > 0 && q > q2) {
+                q = s.indexOf("]>", j + 8);
+
+                if (q < 0) {
+                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                  return;
+                }
+
+                complexDoctype = true;
+              }
+
+              const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
+              this.onDoctype(doctypeContent);
+              j = q + (complexDoctype ? 2 : 1);
+            } else {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            break;
+
+          default:
+            const content = this._parseContent(s, j);
+
+            if (content === null) {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            let isClosed = false;
+
+            if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") {
+              isClosed = true;
+            } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
+
+            this.onBeginElement(content.name, content.attributes, isClosed);
+            j += content.parsed + (isClosed ? 2 : 1);
+            break;
+        }
+      } else {
+        while (j < s.length && s[j] !== "<") {
+          j++;
+        }
+
+        const text = s.substring(i, j);
+        this.onText(this._resolveEntities(text));
+      }
+
+      i = j;
+    }
+  }
+
+  onResolveEntity(name) {
+    return `&${name};`;
+  }
+
+  onPi(name, value) {}
+
+  onComment(text) {}
+
+  onCdata(text) {}
+
+  onDoctype(doctypeContent) {}
+
+  onText(text) {}
+
+  onBeginElement(name, attributes, isEmpty) {}
+
+  onEndElement(name) {}
+
+  onError(code) {}
+
+}
+
+class SimpleDOMNode {
+  constructor(nodeName, nodeValue) {
+    this.nodeName = nodeName;
+    this.nodeValue = nodeValue;
+    Object.defineProperty(this, "parentNode", {
+      value: null,
+      writable: true
+    });
+  }
+
+  get firstChild() {
+    return this.childNodes && this.childNodes[0];
+  }
+
+  get nextSibling() {
+    const childNodes = this.parentNode.childNodes;
+
+    if (!childNodes) {
+      return undefined;
+    }
+
+    const index = childNodes.indexOf(this);
+
+    if (index === -1) {
+      return undefined;
+    }
+
+    return childNodes[index + 1];
+  }
+
+  get textContent() {
+    if (!this.childNodes) {
+      return this.nodeValue || "";
+    }
+
+    return this.childNodes.map(function (child) {
+      return child.textContent;
+    }).join("");
+  }
+
+  hasChildNodes() {
+    return this.childNodes && this.childNodes.length > 0;
+  }
+
+  searchNode(paths, pos) {
+    if (pos >= paths.length) {
+      return this;
+    }
+
+    const component = paths[pos];
+    const stack = [];
+    let node = this;
+
+    while (true) {
+      if (component.name === node.nodeName) {
+        if (component.pos === 0) {
+          const res = node.searchNode(paths, pos + 1);
+
+          if (res !== null) {
+            return res;
+          }
+        } else if (stack.length === 0) {
+          return null;
+        } else {
+          const [parent] = stack.pop();
+          let siblingPos = 0;
+
+          for (const child of parent.childNodes) {
+            if (component.name === child.nodeName) {
+              if (siblingPos === component.pos) {
+                return child.searchNode(paths, pos + 1);
+              }
+
+              siblingPos++;
+            }
+          }
+
+          return node.searchNode(paths, pos + 1);
+        }
+      }
+
+      if (node.childNodes && node.childNodes.length !== 0) {
+        stack.push([node, 0]);
+        node = node.childNodes[0];
+      } else if (stack.length === 0) {
+        return null;
+      } else {
+        while (stack.length !== 0) {
+          const [parent, currentPos] = stack.pop();
+          const newPos = currentPos + 1;
+
+          if (newPos < parent.childNodes.length) {
+            stack.push([parent, newPos]);
+            node = parent.childNodes[newPos];
+            break;
+          }
+        }
+
+        if (stack.length === 0) {
+          return null;
+        }
+      }
+    }
+  }
+
+  dump(buffer) {
+    if (this.nodeName === "#text") {
+      buffer.push((0, _util.encodeToXmlString)(this.nodeValue));
+      return;
+    }
+
+    buffer.push(`<${this.nodeName}`);
+
+    if (this.attributes) {
+      for (const attribute of this.attributes) {
+        buffer.push(` ${attribute.name}="${(0, _util.encodeToXmlString)(attribute.value)}"`);
+      }
+    }
+
+    if (this.hasChildNodes()) {
+      buffer.push(">");
+
+      for (const child of this.childNodes) {
+        child.dump(buffer);
+      }
+
+      buffer.push(`</${this.nodeName}>`);
+    } else if (this.nodeValue) {
+      buffer.push(`>${(0, _util.encodeToXmlString)(this.nodeValue)}</${this.nodeName}>`);
+    } else {
+      buffer.push("/>");
+    }
+  }
+
+}
+
+exports.SimpleDOMNode = SimpleDOMNode;
+
+class SimpleXMLParser extends XMLParserBase {
+  constructor(hasAttributes = false) {
+    super();
+    this._currentFragment = null;
+    this._stack = null;
+    this._errorCode = XMLParserErrorCode.NoError;
+    this._hasAttributes = hasAttributes;
+  }
+
+  parseFromString(data) {
+    this._currentFragment = [];
+    this._stack = [];
+    this._errorCode = XMLParserErrorCode.NoError;
+    this.parseXml(data);
+
+    if (this._errorCode !== XMLParserErrorCode.NoError) {
+      return undefined;
+    }
+
+    const [documentElement] = this._currentFragment;
+
+    if (!documentElement) {
+      return undefined;
+    }
+
+    return {
+      documentElement
+    };
+  }
+
+  onResolveEntity(name) {
+    switch (name) {
+      case "apos":
+        return "'";
+    }
+
+    return super.onResolveEntity(name);
+  }
+
+  onText(text) {
+    if (isWhitespaceString(text)) {
+      return;
+    }
+
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onCdata(text) {
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onBeginElement(name, attributes, isEmpty) {
+    const node = new SimpleDOMNode(name);
+    node.childNodes = [];
+
+    if (this._hasAttributes) {
+      node.attributes = attributes;
+    }
+
+    this._currentFragment.push(node);
+
+    if (isEmpty) {
+      return;
+    }
+
+    this._stack.push(this._currentFragment);
+
+    this._currentFragment = node.childNodes;
+  }
+
+  onEndElement(name) {
+    this._currentFragment = this._stack.pop() || [];
+    const lastElement = this._currentFragment[this._currentFragment.length - 1];
+
+    if (!lastElement) {
+      return;
+    }
+
+    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
+      lastElement.childNodes[i].parentNode = lastElement;
+    }
+  }
+
+  onError(code) {
+    this._errorCode = code;
+  }
+
+}
+
+exports.SimpleXMLParser = SimpleXMLParser;
+
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.OptionalContentConfig = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class OptionalContentGroup {
+  constructor(name, intent) {
+    this.visible = true;
+    this.name = name;
+    this.intent = intent;
+  }
+
+}
+
+class OptionalContentConfig {
+  constructor(data) {
+    this.name = null;
+    this.creator = null;
+    this._order = null;
+    this._groups = new Map();
+
+    if (data === null) {
+      return;
+    }
+
+    this.name = data.name;
+    this.creator = data.creator;
+    this._order = data.order;
+
+    for (const group of data.groups) {
+      this._groups.set(group.id, new OptionalContentGroup(group.name, group.intent));
+    }
+
+    if (data.baseState === "OFF") {
+      for (const group of this._groups) {
+        group.visible = false;
+      }
+    }
+
+    for (const on of data.on) {
+      this._groups.get(on).visible = true;
+    }
+
+    for (const off of data.off) {
+      this._groups.get(off).visible = false;
+    }
+  }
+
+  isVisible(group) {
+    if (group.type === "OCG") {
+      if (!this._groups.has(group.id)) {
+        (0, _util.warn)(`Optional content group not found: ${group.id}`);
+        return true;
+      }
+
+      return this._groups.get(group.id).visible;
+    } else if (group.type === "OCMD") {
+      if (group.expression) {
+        (0, _util.warn)("Visibility expression not supported yet.");
+      }
+
+      if (!group.policy || group.policy === "AnyOn") {
+        for (const id of group.ids) {
+          if (!this._groups.has(id)) {
+            (0, _util.warn)(`Optional content group not found: ${id}`);
+            return true;
+          }
+
+          if (this._groups.get(id).visible) {
+            return true;
+          }
+        }
+
+        return false;
+      } else if (group.policy === "AllOn") {
+        for (const id of group.ids) {
+          if (!this._groups.has(id)) {
+            (0, _util.warn)(`Optional content group not found: ${id}`);
+            return true;
+          }
+
+          if (!this._groups.get(id).visible) {
+            return false;
+          }
+        }
+
+        return true;
+      } else if (group.policy === "AnyOff") {
+        for (const id of group.ids) {
+          if (!this._groups.has(id)) {
+            (0, _util.warn)(`Optional content group not found: ${id}`);
+            return true;
+          }
+
+          if (!this._groups.get(id).visible) {
+            return true;
+          }
+        }
+
+        return false;
+      } else if (group.policy === "AllOff") {
+        for (const id of group.ids) {
+          if (!this._groups.has(id)) {
+            (0, _util.warn)(`Optional content group not found: ${id}`);
+            return true;
+          }
+
+          if (this._groups.get(id).visible) {
+            return false;
+          }
+        }
+
+        return true;
+      }
+
+      (0, _util.warn)(`Unknown optional content policy ${group.policy}.`);
+      return true;
+    }
+
+    (0, _util.warn)(`Unknown group type ${group.type}.`);
+    return true;
+  }
+
+  setVisibility(id, visible = true) {
+    if (!this._groups.has(id)) {
+      (0, _util.warn)(`Optional content group not found: ${id}`);
+      return;
+    }
+
+    this._groups.get(id).visible = !!visible;
+  }
+
+  getOrder() {
+    if (!this._groups.size) {
+      return null;
+    }
+
+    if (this._order) {
+      return this._order.slice();
+    }
+
+    return Array.from(this._groups.keys());
+  }
+
+  getGroups() {
+    if (!this._groups.size) {
+      return null;
+    }
+
+    return (0, _util.objectFromEntries)(this._groups);
+  }
+
+  getGroup(id) {
+    return this._groups.get(id) || null;
+  }
+
+}
+
+exports.OptionalContentConfig = OptionalContentConfig;
+
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFDataTransportStream = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class PDFDataTransportStream {
+  constructor(params, pdfDataRangeTransport) {
+    (0, _util.assert)(pdfDataRangeTransport, 'PDFDataTransportStream - missing required "pdfDataRangeTransport" argument.');
+    this._queuedChunks = [];
+    this._progressiveDone = params.progressiveDone || false;
+    const initialData = params.initialData;
+
+    if (initialData?.length > 0) {
+      const buffer = new Uint8Array(initialData).buffer;
+
+      this._queuedChunks.push(buffer);
+    }
+
+    this._pdfDataRangeTransport = pdfDataRangeTransport;
+    this._isStreamingSupported = !params.disableStream;
+    this._isRangeSupported = !params.disableRange;
+    this._contentLength = params.length;
+    this._fullRequestReader = null;
+    this._rangeReaders = [];
+
+    this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {
+      this._onReceiveData({
+        begin,
+        chunk
+      });
+    });
+
+    this._pdfDataRangeTransport.addProgressListener((loaded, total) => {
+      this._onProgress({
+        loaded,
+        total
+      });
+    });
+
+    this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {
+      this._onReceiveData({
+        chunk
+      });
+    });
+
+    this._pdfDataRangeTransport.addProgressiveDoneListener(() => {
+      this._onProgressiveDone();
+    });
+
+    this._pdfDataRangeTransport.transportReady();
+  }
+
+  _onReceiveData(args) {
+    const buffer = new Uint8Array(args.chunk).buffer;
+
+    if (args.begin === undefined) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader._enqueue(buffer);
+      } else {
+        this._queuedChunks.push(buffer);
+      }
+    } else {
+      const found = this._rangeReaders.some(function (rangeReader) {
+        if (rangeReader._begin !== args.begin) {
+          return false;
+        }
+
+        rangeReader._enqueue(buffer);
+
+        return true;
+      });
+
+      (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.");
+    }
+  }
+
+  get _progressiveDataLength() {
+    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
+  }
+
+  _onProgress(evt) {
+    if (evt.total === undefined) {
+      const firstReader = this._rangeReaders[0];
+
+      if (firstReader?.onProgress) {
+        firstReader.onProgress({
+          loaded: evt.loaded
+        });
+      }
+    } else {
+      const fullReader = this._fullRequestReader;
+
+      if (fullReader?.onProgress) {
+        fullReader.onProgress({
+          loaded: evt.loaded,
+          total: evt.total
+        });
+      }
+    }
+  }
+
+  _onProgressiveDone() {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.progressiveDone();
+    }
+
+    this._progressiveDone = true;
+  }
+
+  _removeRangeReader(reader) {
+    const i = this._rangeReaders.indexOf(reader);
+
+    if (i >= 0) {
+      this._rangeReaders.splice(i, 1);
+    }
+  }
+
+  getFullReader() {
+    (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once.");
+    const queuedChunks = this._queuedChunks;
+    this._queuedChunks = null;
+    return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone);
+  }
+
+  getRangeReader(begin, end) {
+    if (end <= this._progressiveDataLength) {
+      return null;
+    }
+
+    const reader = new PDFDataTransportStreamRangeReader(this, begin, end);
+
+    this._pdfDataRangeTransport.requestDataRange(begin, end);
+
+    this._rangeReaders.push(reader);
+
+    return reader;
+  }
+
+  cancelAllRequests(reason) {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.cancel(reason);
+    }
+
+    const readers = this._rangeReaders.slice(0);
+
+    readers.forEach(function (rangeReader) {
+      rangeReader.cancel(reason);
+    });
+
+    this._pdfDataRangeTransport.abort();
+  }
+
+}
+
+exports.PDFDataTransportStream = PDFDataTransportStream;
+
+class PDFDataTransportStreamReader {
+  constructor(stream, queuedChunks, progressiveDone = false) {
+    this._stream = stream;
+    this._done = progressiveDone || false;
+    this._filename = null;
+    this._queuedChunks = queuedChunks || [];
+    this._loaded = 0;
+
+    for (const chunk of this._queuedChunks) {
+      this._loaded += chunk.byteLength;
+    }
+
+    this._requests = [];
+    this._headersReady = Promise.resolve();
+    stream._fullRequestReader = this;
+    this.onProgress = null;
+  }
+
+  _enqueue(chunk) {
+    if (this._done) {
+      return;
+    }
+
+    if (this._requests.length > 0) {
+      const requestCapability = this._requests.shift();
+
+      requestCapability.resolve({
+        value: chunk,
+        done: false
+      });
+    } else {
+      this._queuedChunks.push(chunk);
+    }
+
+    this._loaded += chunk.byteLength;
+  }
+
+  get headersReady() {
+    return this._headersReady;
+  }
+
+  get filename() {
+    return this._filename;
+  }
+
+  get isRangeSupported() {
+    return this._stream._isRangeSupported;
+  }
+
+  get isStreamingSupported() {
+    return this._stream._isStreamingSupported;
+  }
+
+  get contentLength() {
+    return this._stream._contentLength;
+  }
+
+  async read() {
+    if (this._queuedChunks.length > 0) {
+      const chunk = this._queuedChunks.shift();
+
+      return {
+        value: chunk,
+        done: false
+      };
+    }
+
+    if (this._done) {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
+
+    const requestCapability = (0, _util.createPromiseCapability)();
+
+    this._requests.push(requestCapability);
+
+    return requestCapability.promise;
+  }
+
+  cancel(reason) {
+    this._done = true;
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+  }
+
+  progressiveDone() {
+    if (this._done) {
+      return;
+    }
+
+    this._done = true;
+  }
+
+}
+
+class PDFDataTransportStreamRangeReader {
+  constructor(stream, begin, end) {
+    this._stream = stream;
+    this._begin = begin;
+    this._end = end;
+    this._queuedChunk = null;
+    this._requests = [];
+    this._done = false;
+    this.onProgress = null;
+  }
+
+  _enqueue(chunk) {
+    if (this._done) {
+      return;
+    }
+
+    if (this._requests.length === 0) {
+      this._queuedChunk = chunk;
+    } else {
+      const requestsCapability = this._requests.shift();
+
+      requestsCapability.resolve({
+        value: chunk,
+        done: false
+      });
+
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({
+          value: undefined,
+          done: true
+        });
+      });
+
+      this._requests = [];
+    }
+
+    this._done = true;
+
+    this._stream._removeRangeReader(this);
+  }
+
+  get isStreamingSupported() {
+    return false;
+  }
+
+  async read() {
+    if (this._queuedChunk) {
+      const chunk = this._queuedChunk;
+      this._queuedChunk = null;
+      return {
+        value: chunk,
+        done: false
+      };
+    }
+
+    if (this._done) {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
+
+    const requestCapability = (0, _util.createPromiseCapability)();
+
+    this._requests.push(requestCapability);
+
+    return requestCapability.promise;
+  }
+
+  cancel(reason) {
+    this._done = true;
+
+    this._requests.forEach(function (requestCapability) {
+      requestCapability.resolve({
+        value: undefined,
+        done: true
+      });
+    });
+
+    this._requests = [];
+
+    this._stream._removeRangeReader(this);
+  }
+
+}
+
+/***/ }),
+/* 18 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.WebGLContext = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class WebGLContext {
+  constructor({
+    enable = false
+  }) {
+    this._enabled = enable === true;
+  }
+
+  get isEnabled() {
+    let enabled = this._enabled;
+
+    if (enabled) {
+      enabled = WebGLUtils.tryInitGL();
+    }
+
+    return (0, _util.shadow)(this, "isEnabled", enabled);
+  }
+
+  composeSMask({
+    layer,
+    mask,
+    properties
+  }) {
+    return WebGLUtils.composeSMask(layer, mask, properties);
+  }
+
+  drawFigures({
+    width,
+    height,
+    backgroundColor,
+    figures,
+    context
+  }) {
+    return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
+  }
+
+  clear() {
+    WebGLUtils.cleanup();
+  }
+
+}
+
+exports.WebGLContext = WebGLContext;
+
+const WebGLUtils = function WebGLUtilsClosure() {
+  function loadShader(gl, code, shaderType) {
+    const shader = gl.createShader(shaderType);
+    gl.shaderSource(shader, code);
+    gl.compileShader(shader);
+    const compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+
+    if (!compiled) {
+      const errorMsg = gl.getShaderInfoLog(shader);
+      throw new Error("Error during shader compilation: " + errorMsg);
+    }
+
+    return shader;
+  }
+
+  function createVertexShader(gl, code) {
+    return loadShader(gl, code, gl.VERTEX_SHADER);
+  }
+
+  function createFragmentShader(gl, code) {
+    return loadShader(gl, code, gl.FRAGMENT_SHADER);
+  }
+
+  function createProgram(gl, shaders) {
+    const program = gl.createProgram();
+
+    for (let i = 0, ii = shaders.length; i < ii; ++i) {
+      gl.attachShader(program, shaders[i]);
+    }
+
+    gl.linkProgram(program);
+    const linked = gl.getProgramParameter(program, gl.LINK_STATUS);
+
+    if (!linked) {
+      const errorMsg = gl.getProgramInfoLog(program);
+      throw new Error("Error during program linking: " + errorMsg);
+    }
+
+    return program;
+  }
+
+  function createTexture(gl, image, textureId) {
+    gl.activeTexture(textureId);
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+    return texture;
+  }
+
+  let currentGL, currentCanvas;
+
+  function generateGL() {
+    if (currentGL) {
+      return;
+    }
+
+    currentCanvas = document.createElement("canvas");
+    currentGL = currentCanvas.getContext("webgl", {
+      premultipliedalpha: false
+    });
+  }
+
+  const smaskVertexShaderCode = "\
+  attribute vec2 a_position;                                    \
+  attribute vec2 a_texCoord;                                    \
+                                                                \
+  uniform vec2 u_resolution;                                    \
+                                                                \
+  varying vec2 v_texCoord;                                      \
+                                                                \
+  void main() {                                                 \
+    vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0;   \
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
+                                                                \
+    v_texCoord = a_texCoord;                                    \
+  }                                                             ";
+  const smaskFragmentShaderCode = "\
+  precision mediump float;                                      \
+                                                                \
+  uniform vec4 u_backdrop;                                      \
+  uniform int u_subtype;                                        \
+  uniform sampler2D u_image;                                    \
+  uniform sampler2D u_mask;                                     \
+                                                                \
+  varying vec2 v_texCoord;                                      \
+                                                                \
+  void main() {                                                 \
+    vec4 imageColor = texture2D(u_image, v_texCoord);           \
+    vec4 maskColor = texture2D(u_mask, v_texCoord);             \
+    if (u_backdrop.a > 0.0) {                                   \
+      maskColor.rgb = maskColor.rgb * maskColor.a +             \
+                      u_backdrop.rgb * (1.0 - maskColor.a);     \
+    }                                                           \
+    float lum;                                                  \
+    if (u_subtype == 0) {                                       \
+      lum = maskColor.a;                                        \
+    } else {                                                    \
+      lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \
+            maskColor.b * 0.11;                                 \
+    }                                                           \
+    imageColor.a *= lum;                                        \
+    imageColor.rgb *= imageColor.a;                             \
+    gl_FragColor = imageColor;                                  \
+  }                                                             ";
+  let smaskCache = null;
+
+  function initSmaskGL() {
+    generateGL();
+    const canvas = currentCanvas;
+    currentCanvas = null;
+    const gl = currentGL;
+    currentGL = null;
+    const vertexShader = createVertexShader(gl, smaskVertexShaderCode);
+    const fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);
+    const program = createProgram(gl, [vertexShader, fragmentShader]);
+    gl.useProgram(program);
+    const cache = {};
+    cache.gl = gl;
+    cache.canvas = canvas;
+    cache.resolutionLocation = gl.getUniformLocation(program, "u_resolution");
+    cache.positionLocation = gl.getAttribLocation(program, "a_position");
+    cache.backdropLocation = gl.getUniformLocation(program, "u_backdrop");
+    cache.subtypeLocation = gl.getUniformLocation(program, "u_subtype");
+    const texCoordLocation = gl.getAttribLocation(program, "a_texCoord");
+    const texLayerLocation = gl.getUniformLocation(program, "u_image");
+    const texMaskLocation = gl.getUniformLocation(program, "u_mask");
+    const texCoordBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0]), gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(texCoordLocation);
+    gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
+    gl.uniform1i(texLayerLocation, 0);
+    gl.uniform1i(texMaskLocation, 1);
+    smaskCache = cache;
+  }
+
+  function composeSMask(layer, mask, properties) {
+    const width = layer.width,
+          height = layer.height;
+
+    if (!smaskCache) {
+      initSmaskGL();
+    }
+
+    const cache = smaskCache,
+          canvas = cache.canvas,
+          gl = cache.gl;
+    canvas.width = width;
+    canvas.height = height;
+    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    gl.uniform2f(cache.resolutionLocation, width, height);
+
+    if (properties.backdrop) {
+      gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], properties.backdrop[1], properties.backdrop[2], 1);
+    } else {
+      gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);
+    }
+
+    gl.uniform1i(cache.subtypeLocation, properties.subtype === "Luminosity" ? 1 : 0);
+    const texture = createTexture(gl, layer, gl.TEXTURE0);
+    const maskTexture = createTexture(gl, mask, gl.TEXTURE1);
+    const buffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, width, 0, 0, height, 0, height, width, 0, width, height]), gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(cache.positionLocation);
+    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
+    gl.clearColor(0, 0, 0, 0);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+    gl.flush();
+    gl.deleteTexture(texture);
+    gl.deleteTexture(maskTexture);
+    gl.deleteBuffer(buffer);
+    return canvas;
+  }
+
+  const figuresVertexShaderCode = "\
+  attribute vec2 a_position;                                    \
+  attribute vec3 a_color;                                       \
+                                                                \
+  uniform vec2 u_resolution;                                    \
+  uniform vec2 u_scale;                                         \
+  uniform vec2 u_offset;                                        \
+                                                                \
+  varying vec4 v_color;                                         \
+                                                                \
+  void main() {                                                 \
+    vec2 position = (a_position + u_offset) * u_scale;          \
+    vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0;     \
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
+                                                                \
+    v_color = vec4(a_color / 255.0, 1.0);                       \
+  }                                                             ";
+  const figuresFragmentShaderCode = "\
+  precision mediump float;                                      \
+                                                                \
+  varying vec4 v_color;                                         \
+                                                                \
+  void main() {                                                 \
+    gl_FragColor = v_color;                                     \
+  }                                                             ";
+  let figuresCache = null;
+
+  function initFiguresGL() {
+    generateGL();
+    const canvas = currentCanvas;
+    currentCanvas = null;
+    const gl = currentGL;
+    currentGL = null;
+    const vertexShader = createVertexShader(gl, figuresVertexShaderCode);
+    const fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);
+    const program = createProgram(gl, [vertexShader, fragmentShader]);
+    gl.useProgram(program);
+    const cache = {};
+    cache.gl = gl;
+    cache.canvas = canvas;
+    cache.resolutionLocation = gl.getUniformLocation(program, "u_resolution");
+    cache.scaleLocation = gl.getUniformLocation(program, "u_scale");
+    cache.offsetLocation = gl.getUniformLocation(program, "u_offset");
+    cache.positionLocation = gl.getAttribLocation(program, "a_position");
+    cache.colorLocation = gl.getAttribLocation(program, "a_color");
+    figuresCache = cache;
+  }
+
+  function drawFigures(width, height, backgroundColor, figures, context) {
+    if (!figuresCache) {
+      initFiguresGL();
+    }
+
+    const cache = figuresCache,
+          canvas = cache.canvas,
+          gl = cache.gl;
+    canvas.width = width;
+    canvas.height = height;
+    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    gl.uniform2f(cache.resolutionLocation, width, height);
+    let count = 0;
+
+    for (let i = 0, ii = figures.length; i < ii; i++) {
+      switch (figures[i].type) {
+        case "lattice":
+          const rows = figures[i].coords.length / figures[i].verticesPerRow | 0;
+          count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;
+          break;
+
+        case "triangles":
+          count += figures[i].coords.length;
+          break;
+      }
+    }
+
+    const coords = new Float32Array(count * 2);
+    const colors = new Uint8Array(count * 3);
+    const coordsMap = context.coords,
+          colorsMap = context.colors;
+    let pIndex = 0,
+        cIndex = 0;
+
+    for (let i = 0, ii = figures.length; i < ii; i++) {
+      const figure = figures[i],
+            ps = figure.coords,
+            cs = figure.colors;
+
+      switch (figure.type) {
+        case "lattice":
+          const cols = figure.verticesPerRow;
+          const rows = ps.length / cols | 0;
+
+          for (let row = 1; row < rows; row++) {
+            let offset = row * cols + 1;
+
+            for (let col = 1; col < cols; col++, offset++) {
+              coords[pIndex] = coordsMap[ps[offset - cols - 1]];
+              coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];
+              coords[pIndex + 2] = coordsMap[ps[offset - cols]];
+              coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];
+              coords[pIndex + 4] = coordsMap[ps[offset - 1]];
+              coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];
+              colors[cIndex] = colorsMap[cs[offset - cols - 1]];
+              colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];
+              colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];
+              colors[cIndex + 3] = colorsMap[cs[offset - cols]];
+              colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];
+              colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];
+              colors[cIndex + 6] = colorsMap[cs[offset - 1]];
+              colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];
+              colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];
+              coords[pIndex + 6] = coords[pIndex + 2];
+              coords[pIndex + 7] = coords[pIndex + 3];
+              coords[pIndex + 8] = coords[pIndex + 4];
+              coords[pIndex + 9] = coords[pIndex + 5];
+              coords[pIndex + 10] = coordsMap[ps[offset]];
+              coords[pIndex + 11] = coordsMap[ps[offset] + 1];
+              colors[cIndex + 9] = colors[cIndex + 3];
+              colors[cIndex + 10] = colors[cIndex + 4];
+              colors[cIndex + 11] = colors[cIndex + 5];
+              colors[cIndex + 12] = colors[cIndex + 6];
+              colors[cIndex + 13] = colors[cIndex + 7];
+              colors[cIndex + 14] = colors[cIndex + 8];
+              colors[cIndex + 15] = colorsMap[cs[offset]];
+              colors[cIndex + 16] = colorsMap[cs[offset] + 1];
+              colors[cIndex + 17] = colorsMap[cs[offset] + 2];
+              pIndex += 12;
+              cIndex += 18;
+            }
+          }
+
+          break;
+
+        case "triangles":
+          for (let j = 0, jj = ps.length; j < jj; j++) {
+            coords[pIndex] = coordsMap[ps[j]];
+            coords[pIndex + 1] = coordsMap[ps[j] + 1];
+            colors[cIndex] = colorsMap[cs[j]];
+            colors[cIndex + 1] = colorsMap[cs[j] + 1];
+            colors[cIndex + 2] = colorsMap[cs[j] + 2];
+            pIndex += 2;
+            cIndex += 3;
+          }
+
+          break;
+      }
+    }
+
+    if (backgroundColor) {
+      gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, backgroundColor[2] / 255, 1.0);
+    } else {
+      gl.clearColor(0, 0, 0, 0);
+    }
+
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    const coordsBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(cache.positionLocation);
+    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
+    const colorsBuffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(cache.colorLocation);
+    gl.vertexAttribPointer(cache.colorLocation, 3, gl.UNSIGNED_BYTE, false, 0, 0);
+    gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);
+    gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);
+    gl.drawArrays(gl.TRIANGLES, 0, count);
+    gl.flush();
+    gl.deleteBuffer(coordsBuffer);
+    gl.deleteBuffer(colorsBuffer);
+    return canvas;
+  }
+
+  return {
+    tryInitGL() {
+      try {
+        generateGL();
+        return !!currentGL;
+      } catch (ex) {}
+
+      return false;
+    },
+
+    composeSMask,
+    drawFigures,
+
+    cleanup() {
+      if (smaskCache?.canvas) {
+        smaskCache.canvas.width = 0;
+        smaskCache.canvas.height = 0;
+      }
+
+      if (figuresCache?.canvas) {
+        figuresCache.canvas.width = 0;
+        figuresCache.canvas.height = 0;
+      }
+
+      smaskCache = null;
+      figuresCache = null;
+    }
+
+  };
+}();
+
+/***/ }),
+/* 19 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.AnnotationLayer = void 0;
+
+var _display_utils = __w_pdfjs_require__(1);
+
+var _util = __w_pdfjs_require__(2);
+
+var _annotation_storage = __w_pdfjs_require__(8);
+
+var _scripting_utils = __w_pdfjs_require__(20);
+
+class AnnotationElementFactory {
+  static create(parameters) {
+    const subtype = parameters.data.annotationType;
+
+    switch (subtype) {
+      case _util.AnnotationType.LINK:
+        return new LinkAnnotationElement(parameters);
+
+      case _util.AnnotationType.TEXT:
+        return new TextAnnotationElement(parameters);
+
+      case _util.AnnotationType.WIDGET:
+        const fieldType = parameters.data.fieldType;
+
+        switch (fieldType) {
+          case "Tx":
+            return new TextWidgetAnnotationElement(parameters);
+
+          case "Btn":
+            if (parameters.data.radioButton) {
+              return new RadioButtonWidgetAnnotationElement(parameters);
+            } else if (parameters.data.checkBox) {
+              return new CheckboxWidgetAnnotationElement(parameters);
+            }
+
+            return new PushButtonWidgetAnnotationElement(parameters);
+
+          case "Ch":
+            return new ChoiceWidgetAnnotationElement(parameters);
+        }
+
+        return new WidgetAnnotationElement(parameters);
+
+      case _util.AnnotationType.POPUP:
+        return new PopupAnnotationElement(parameters);
+
+      case _util.AnnotationType.FREETEXT:
+        return new FreeTextAnnotationElement(parameters);
+
+      case _util.AnnotationType.LINE:
+        return new LineAnnotationElement(parameters);
+
+      case _util.AnnotationType.SQUARE:
+        return new SquareAnnotationElement(parameters);
+
+      case _util.AnnotationType.CIRCLE:
+        return new CircleAnnotationElement(parameters);
+
+      case _util.AnnotationType.POLYLINE:
+        return new PolylineAnnotationElement(parameters);
+
+      case _util.AnnotationType.CARET:
+        return new CaretAnnotationElement(parameters);
+
+      case _util.AnnotationType.INK:
+        return new InkAnnotationElement(parameters);
+
+      case _util.AnnotationType.POLYGON:
+        return new PolygonAnnotationElement(parameters);
+
+      case _util.AnnotationType.HIGHLIGHT:
+        return new HighlightAnnotationElement(parameters);
+
+      case _util.AnnotationType.UNDERLINE:
+        return new UnderlineAnnotationElement(parameters);
+
+      case _util.AnnotationType.SQUIGGLY:
+        return new SquigglyAnnotationElement(parameters);
+
+      case _util.AnnotationType.STRIKEOUT:
+        return new StrikeOutAnnotationElement(parameters);
+
+      case _util.AnnotationType.STAMP:
+        return new StampAnnotationElement(parameters);
+
+      case _util.AnnotationType.FILEATTACHMENT:
+        return new FileAttachmentAnnotationElement(parameters);
+
+      default:
+        return new AnnotationElement(parameters);
+    }
+  }
+
+}
+
+class AnnotationElement {
+  constructor(parameters, {
+    isRenderable = false,
+    ignoreBorder = false,
+    createQuadrilaterals = false
+  } = {}) {
+    this.isRenderable = isRenderable;
+    this.data = parameters.data;
+    this.layer = parameters.layer;
+    this.page = parameters.page;
+    this.viewport = parameters.viewport;
+    this.linkService = parameters.linkService;
+    this.downloadManager = parameters.downloadManager;
+    this.imageResourcesPath = parameters.imageResourcesPath;
+    this.renderInteractiveForms = parameters.renderInteractiveForms;
+    this.svgFactory = parameters.svgFactory;
+    this.annotationStorage = parameters.annotationStorage;
+    this.enableScripting = parameters.enableScripting;
+    this.hasJSActions = parameters.hasJSActions;
+    this._mouseState = parameters.mouseState;
+
+    if (isRenderable) {
+      this.container = this._createContainer(ignoreBorder);
+    }
+
+    if (createQuadrilaterals) {
+      this.quadrilaterals = this._createQuadrilaterals(ignoreBorder);
+    }
+  }
+
+  _createContainer(ignoreBorder = false) {
+    const data = this.data,
+          page = this.page,
+          viewport = this.viewport;
+    const container = document.createElement("section");
+    let width = data.rect[2] - data.rect[0];
+    let height = data.rect[3] - data.rect[1];
+    container.setAttribute("data-annotation-id", data.id);
+
+    const rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
+
+    container.style.transform = `matrix(${viewport.transform.join(",")})`;
+    container.style.transformOrigin = `${-rect[0]}px ${-rect[1]}px`;
+
+    if (!ignoreBorder && data.borderStyle.width > 0) {
+      container.style.borderWidth = `${data.borderStyle.width}px`;
+
+      if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
+        width = width - 2 * data.borderStyle.width;
+        height = height - 2 * data.borderStyle.width;
+      }
+
+      const horizontalRadius = data.borderStyle.horizontalCornerRadius;
+      const verticalRadius = data.borderStyle.verticalCornerRadius;
+
+      if (horizontalRadius > 0 || verticalRadius > 0) {
+        const radius = `${horizontalRadius}px / ${verticalRadius}px`;
+        container.style.borderRadius = radius;
+      }
+
+      switch (data.borderStyle.style) {
+        case _util.AnnotationBorderStyleType.SOLID:
+          container.style.borderStyle = "solid";
+          break;
+
+        case _util.AnnotationBorderStyleType.DASHED:
+          container.style.borderStyle = "dashed";
+          break;
+
+        case _util.AnnotationBorderStyleType.BEVELED:
+          (0, _util.warn)("Unimplemented border style: beveled");
+          break;
+
+        case _util.AnnotationBorderStyleType.INSET:
+          (0, _util.warn)("Unimplemented border style: inset");
+          break;
+
+        case _util.AnnotationBorderStyleType.UNDERLINE:
+          container.style.borderBottomStyle = "solid";
+          break;
+
+        default:
+          break;
+      }
+
+      if (data.color) {
+        container.style.borderColor = _util.Util.makeHexColor(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
+      } else {
+        container.style.borderWidth = 0;
+      }
+    }
+
+    container.style.left = `${rect[0]}px`;
+    container.style.top = `${rect[1]}px`;
+    container.style.width = `${width}px`;
+    container.style.height = `${height}px`;
+    return container;
+  }
+
+  _createQuadrilaterals(ignoreBorder = false) {
+    if (!this.data.quadPoints) {
+      return null;
+    }
+
+    const quadrilaterals = [];
+    const savedRect = this.data.rect;
+
+    for (const quadPoint of this.data.quadPoints) {
+      this.data.rect = [quadPoint[2].x, quadPoint[2].y, quadPoint[1].x, quadPoint[1].y];
+      quadrilaterals.push(this._createContainer(ignoreBorder));
+    }
+
+    this.data.rect = savedRect;
+    return quadrilaterals;
+  }
+
+  _createPopup(trigger, data) {
+    let container = this.container;
+
+    if (this.quadrilaterals) {
+      trigger = trigger || this.quadrilaterals;
+      container = this.quadrilaterals[0];
+    }
+
+    if (!trigger) {
+      trigger = document.createElement("div");
+      trigger.style.height = container.style.height;
+      trigger.style.width = container.style.width;
+      container.appendChild(trigger);
+    }
+
+    const popupElement = new PopupElement({
+      container,
+      trigger,
+      color: data.color,
+      title: data.title,
+      modificationDate: data.modificationDate,
+      contents: data.contents,
+      hideWrapper: true
+    });
+    const popup = popupElement.render();
+    popup.style.left = container.style.width;
+    container.appendChild(popup);
+  }
+
+  _renderQuadrilaterals(className) {
+    this.quadrilaterals.forEach(quadrilateral => {
+      quadrilateral.className = className;
+    });
+    return this.quadrilaterals;
+  }
+
+  render() {
+    (0, _util.unreachable)("Abstract method `AnnotationElement.render` called");
+  }
+
+}
+
+class LinkAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action || parameters.data.isTooltipOnly || parameters.data.actions && (parameters.data.actions.Action || parameters.data.actions.MouseUp || parameters.data.actions.MouseDown));
+    super(parameters, {
+      isRenderable,
+      createQuadrilaterals: true
+    });
+  }
+
+  render() {
+    const {
+      data,
+      linkService
+    } = this;
+    const link = document.createElement("a");
+
+    if (data.url) {
+      (0, _display_utils.addLinkAttributes)(link, {
+        url: data.url,
+        target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
+        rel: linkService.externalLinkRel,
+        enabled: linkService.externalLinkEnabled
+      });
+    } else if (data.action) {
+      this._bindNamedAction(link, data.action);
+    } else if (data.dest) {
+      this._bindLink(link, data.dest);
+    } else if (data.actions && (data.actions.Action || data.actions.MouseUp || data.actions.MouseDown) && this.enableScripting && this.hasJSActions) {
+      this._bindJSAction(link, data);
+    } else {
+      this._bindLink(link, "");
+    }
+
+    if (this.quadrilaterals) {
+      return this._renderQuadrilaterals("linkAnnotation").map((quadrilateral, index) => {
+        const linkElement = index === 0 ? link : link.cloneNode();
+        quadrilateral.appendChild(linkElement);
+        return quadrilateral;
+      });
+    }
+
+    this.container.className = "linkAnnotation";
+    this.container.appendChild(link);
+    return this.container;
+  }
+
+  _bindLink(link, destination) {
+    link.href = this.linkService.getDestinationHash(destination);
+
+    link.onclick = () => {
+      if (destination) {
+        this.linkService.goToDestination(destination);
+      }
+
+      return false;
+    };
+
+    if (destination || destination === "") {
+      link.className = "internalLink";
+    }
+  }
+
+  _bindNamedAction(link, action) {
+    link.href = this.linkService.getAnchorUrl("");
+
+    link.onclick = () => {
+      this.linkService.executeNamedAction(action);
+      return false;
+    };
+
+    link.className = "internalLink";
+  }
+
+  _bindJSAction(link, data) {
+    link.href = this.linkService.getAnchorUrl("");
+    const map = new Map([["Action", "onclick"], ["MouseUp", "onmouseup"], ["MouseDown", "onmousedown"]]);
+
+    for (const name of Object.keys(data.actions)) {
+      const jsName = map.get(name);
+
+      if (!jsName) {
+        continue;
+      }
+
+      link[jsName] = () => {
+        this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+          source: this,
+          detail: {
+            id: data.id,
+            name
+          }
+        });
+        return false;
+      };
+    }
+
+    link.className = "internalLink";
+  }
+
+}
+
+class TextAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable
+    });
+  }
+
+  render() {
+    this.container.className = "textAnnotation";
+    const image = document.createElement("img");
+    image.style.height = this.container.style.height;
+    image.style.width = this.container.style.width;
+    image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg";
+    image.alt = "[{{type}} Annotation]";
+    image.dataset.l10nId = "text_annotation_type";
+    image.dataset.l10nArgs = JSON.stringify({
+      type: this.data.name
+    });
+
+    if (!this.data.hasPopup) {
+      this._createPopup(image, this.data);
+    }
+
+    this.container.appendChild(image);
+    return this.container;
+  }
+
+}
+
+class WidgetAnnotationElement extends AnnotationElement {
+  render() {
+    if (this.data.alternativeText) {
+      this.container.title = this.data.alternativeText;
+    }
+
+    return this.container;
+  }
+
+  _getKeyModifier(event) {
+    return navigator.platform.includes("Win") && event.ctrlKey || navigator.platform.includes("Mac") && event.metaKey;
+  }
+
+  _setEventListener(element, baseName, eventName, valueGetter) {
+    if (this.data.actions[eventName.replace(" ", "")] === undefined) {
+      return;
+    }
+
+    if (baseName.includes("mouse")) {
+      element.addEventListener(baseName, event => {
+        this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+          source: this,
+          detail: {
+            id: this.data.id,
+            name: eventName,
+            value: valueGetter(event),
+            shift: event.shiftKey,
+            modifier: this._getKeyModifier(event)
+          }
+        });
+      });
+    } else {
+      element.addEventListener(baseName, event => {
+        this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+          source: this,
+          detail: {
+            id: this.data.id,
+            name: eventName,
+            value: event.target.checked
+          }
+        });
+      });
+    }
+  }
+
+  _setEventListeners(element, names, getter) {
+    if (!this.data.actions) {
+      return;
+    }
+
+    for (const [baseName, eventName] of names) {
+      this._setEventListener(element, baseName, eventName, getter);
+    }
+  }
+
+}
+
+class TextWidgetAnnotationElement extends WidgetAnnotationElement {
+  constructor(parameters) {
+    const isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
+    super(parameters, {
+      isRenderable
+    });
+  }
+
+  render() {
+    const TEXT_ALIGNMENT = ["left", "center", "right"];
+    const storage = this.annotationStorage;
+    const id = this.data.id;
+    this.container.className = "textWidgetAnnotation";
+    let element = null;
+
+    if (this.renderInteractiveForms) {
+      const textContent = storage.getOrCreateValue(id, {
+        value: this.data.fieldValue
+      }).value;
+      const elementData = {
+        userValue: null,
+        formattedValue: null,
+        beforeInputSelectionRange: null,
+        beforeInputValue: null
+      };
+
+      if (this.data.multiLine) {
+        element = document.createElement("textarea");
+        element.textContent = textContent;
+      } else {
+        element = document.createElement("input");
+        element.type = "text";
+        element.setAttribute("value", textContent);
+      }
+
+      elementData.userValue = textContent;
+      element.setAttribute("id", id);
+      element.addEventListener("input", function (event) {
+        storage.setValue(id, {
+          value: event.target.value
+        });
+      });
+
+      let blurListener = event => {
+        if (elementData.formattedValue) {
+          event.target.value = elementData.formattedValue;
+        }
+
+        event.target.setSelectionRange(0, 0);
+        elementData.beforeInputSelectionRange = null;
+      };
+
+      if (this.enableScripting && this.hasJSActions) {
+        element.addEventListener("focus", event => {
+          if (elementData.userValue) {
+            event.target.value = elementData.userValue;
+          }
+        });
+        element.addEventListener("updatefromsandbox", function (event) {
+          const {
+            detail
+          } = event;
+          const actions = {
+            value() {
+              elementData.userValue = detail.value || "";
+              storage.setValue(id, {
+                value: elementData.userValue.toString()
+              });
+
+              if (!elementData.formattedValue) {
+                event.target.value = elementData.userValue;
+              }
+            },
+
+            valueAsString() {
+              elementData.formattedValue = detail.valueAsString || "";
+
+              if (event.target !== document.activeElement) {
+                event.target.value = elementData.formattedValue;
+              }
+
+              storage.setValue(id, {
+                formattedValue: elementData.formattedValue
+              });
+            },
+
+            focus() {
+              setTimeout(() => event.target.focus({
+                preventScroll: false
+              }), 0);
+            },
+
+            userName() {
+              event.target.title = detail.userName;
+            },
+
+            hidden() {
+              event.target.style.visibility = detail.hidden ? "hidden" : "visible";
+              storage.setValue(id, {
+                hidden: detail.hidden
+              });
+            },
+
+            editable() {
+              event.target.disabled = !detail.editable;
+            },
+
+            selRange() {
+              const [selStart, selEnd] = detail.selRange;
+
+              if (selStart >= 0 && selEnd < event.target.value.length) {
+                event.target.setSelectionRange(selStart, selEnd);
+              }
+            },
+
+            strokeColor() {
+              const color = detail.strokeColor;
+              event.target.style.color = _scripting_utils.ColorConverters[`${color[0]}_HTML`](color.slice(1));
+            }
+
+          };
+          Object.keys(detail).filter(name => name in actions).forEach(name => actions[name]());
+        });
+
+        if (this.data.actions) {
+          element.addEventListener("keydown", event => {
+            elementData.beforeInputValue = event.target.value;
+            let commitKey = -1;
+
+            if (event.key === "Escape") {
+              commitKey = 0;
+            } else if (event.key === "Enter") {
+              commitKey = 2;
+            } else if (event.key === "Tab") {
+              commitKey = 3;
+            }
+
+            if (commitKey === -1) {
+              return;
+            }
+
+            elementData.userValue = event.target.value;
+            this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+              source: this,
+              detail: {
+                id,
+                name: "Keystroke",
+                value: event.target.value,
+                willCommit: true,
+                commitKey,
+                selStart: event.target.selectionStart,
+                selEnd: event.target.selectionEnd
+              }
+            });
+          });
+          const _blurListener = blurListener;
+          blurListener = null;
+          element.addEventListener("blur", event => {
+            if (this._mouseState.isDown) {
+              elementData.userValue = event.target.value;
+              this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+                source: this,
+                detail: {
+                  id,
+                  name: "Keystroke",
+                  value: event.target.value,
+                  willCommit: true,
+                  commitKey: 1,
+                  selStart: event.target.selectionStart,
+                  selEnd: event.target.selectionEnd
+                }
+              });
+            }
+
+            _blurListener(event);
+          });
+          element.addEventListener("mousedown", event => {
+            elementData.beforeInputValue = event.target.value;
+            elementData.beforeInputSelectionRange = null;
+          });
+          element.addEventListener("keyup", event => {
+            if (event.target.selectionStart === event.target.selectionEnd) {
+              elementData.beforeInputSelectionRange = null;
+            }
+          });
+          element.addEventListener("select", event => {
+            elementData.beforeInputSelectionRange = [event.target.selectionStart, event.target.selectionEnd];
+          });
+
+          if ("Keystroke" in this.data.actions) {
+            element.addEventListener("input", event => {
+              let selStart = -1;
+              let selEnd = -1;
+
+              if (elementData.beforeInputSelectionRange) {
+                [selStart, selEnd] = elementData.beforeInputSelectionRange;
+              }
+
+              this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+                source: this,
+                detail: {
+                  id,
+                  name: "Keystroke",
+                  value: elementData.beforeInputValue,
+                  change: event.data,
+                  willCommit: false,
+                  selStart,
+                  selEnd
+                }
+              });
+            });
+          }
+
+          this._setEventListeners(element, [["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "MouseUp"]], event => event.target.value);
+        }
+      }
+
+      if (blurListener) {
+        element.addEventListener("blur", blurListener);
+      }
+
+      element.disabled = this.data.readOnly;
+      element.name = this.data.fieldName;
+
+      if (this.data.maxLen !== null) {
+        element.maxLength = this.data.maxLen;
+      }
+
+      if (this.data.comb) {
+        const fieldWidth = this.data.rect[2] - this.data.rect[0];
+        const combWidth = fieldWidth / this.data.maxLen;
+        element.classList.add("comb");
+        element.style.letterSpacing = `calc(${combWidth}px - 1ch)`;
+      }
+    } else {
+      element = document.createElement("div");
+      element.textContent = this.data.fieldValue;
+      element.style.verticalAlign = "middle";
+      element.style.display = "table-cell";
+      let font = null;
+
+      if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) {
+        font = this.page.commonObjs.get(this.data.fontRefName);
+      }
+
+      this._setTextStyle(element, font);
+    }
+
+    if (this.data.textAlignment !== null) {
+      element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
+    }
+
+    this.container.appendChild(element);
+    return this.container;
+  }
+
+  _setTextStyle(element, font) {
+    const style = element.style;
+    style.fontSize = `${this.data.fontSize}px`;
+    style.direction = this.data.fontDirection < 0 ? "rtl" : "ltr";
+
+    if (!font) {
+      return;
+    }
+
+    let bold = "normal";
+
+    if (font.black) {
+      bold = "900";
+    } else if (font.bold) {
+      bold = "bold";
+    }
+
+    style.fontWeight = bold;
+    style.fontStyle = font.italic ? "italic" : "normal";
+    const fontFamily = font.loadedName ? `"${font.loadedName}", ` : "";
+    const fallbackName = font.fallbackName || "Helvetica, sans-serif";
+    style.fontFamily = fontFamily + fallbackName;
+  }
+
+}
+
+class CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {
+  constructor(parameters) {
+    super(parameters, {
+      isRenderable: parameters.renderInteractiveForms
+    });
+  }
+
+  render() {
+    const storage = this.annotationStorage;
+    const data = this.data;
+    const id = data.id;
+    const value = storage.getOrCreateValue(id, {
+      value: data.fieldValue && data.fieldValue !== "Off"
+    }).value;
+    this.container.className = "buttonWidgetAnnotation checkBox";
+    const element = document.createElement("input");
+    element.disabled = data.readOnly;
+    element.type = "checkbox";
+    element.name = this.data.fieldName;
+
+    if (value) {
+      element.setAttribute("checked", true);
+    }
+
+    element.setAttribute("id", id);
+    element.addEventListener("change", function (event) {
+      const name = event.target.name;
+
+      for (const checkbox of document.getElementsByName(name)) {
+        if (checkbox !== event.target) {
+          checkbox.checked = false;
+          storage.setValue(checkbox.parentNode.getAttribute("data-annotation-id"), {
+            value: false
+          });
+        }
+      }
+
+      storage.setValue(id, {
+        value: event.target.checked
+      });
+    });
+
+    if (this.enableScripting && this.hasJSActions) {
+      element.addEventListener("updatefromsandbox", event => {
+        const {
+          detail
+        } = event;
+        const actions = {
+          value() {
+            event.target.checked = detail.value !== "Off";
+            storage.setValue(id, {
+              value: event.target.checked
+            });
+          },
+
+          focus() {
+            setTimeout(() => event.target.focus({
+              preventScroll: false
+            }), 0);
+          },
+
+          hidden() {
+            event.target.style.visibility = detail.hidden ? "hidden" : "visible";
+            storage.setValue(id, {
+              hidden: detail.hidden
+            });
+          },
+
+          editable() {
+            event.target.disabled = !detail.editable;
+          }
+
+        };
+        Object.keys(detail).filter(name => name in actions).forEach(name => actions[name]());
+      });
+
+      this._setEventListeners(element, [["change", "Validate"], ["change", "Action"], ["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "MouseUp"]], event => event.target.checked);
+    }
+
+    this.container.appendChild(element);
+    return this.container;
+  }
+
+}
+
+class RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {
+  constructor(parameters) {
+    super(parameters, {
+      isRenderable: parameters.renderInteractiveForms
+    });
+  }
+
+  render() {
+    this.container.className = "buttonWidgetAnnotation radioButton";
+    const storage = this.annotationStorage;
+    const data = this.data;
+    const id = data.id;
+    const value = storage.getOrCreateValue(id, {
+      value: data.fieldValue === data.buttonValue
+    }).value;
+    const element = document.createElement("input");
+    element.disabled = data.readOnly;
+    element.type = "radio";
+    element.name = data.fieldName;
+
+    if (value) {
+      element.setAttribute("checked", true);
+    }
+
+    element.setAttribute("pdfButtonValue", data.buttonValue);
+    element.setAttribute("id", id);
+    element.addEventListener("change", function (event) {
+      const {
+        target
+      } = event;
+
+      for (const radio of document.getElementsByName(target.name)) {
+        if (radio !== target) {
+          storage.setValue(radio.getAttribute("id"), {
+            value: false
+          });
+        }
+      }
+
+      storage.setValue(id, {
+        value: target.checked
+      });
+    });
+
+    if (this.enableScripting && this.hasJSActions) {
+      element.addEventListener("updatefromsandbox", event => {
+        const {
+          detail
+        } = event;
+        const actions = {
+          value() {
+            const fieldValue = detail.value;
+
+            for (const radio of document.getElementsByName(event.target.name)) {
+              const radioId = radio.getAttribute("id");
+
+              if (fieldValue === radio.getAttribute("pdfButtonValue")) {
+                radio.setAttribute("checked", true);
+                storage.setValue(radioId, {
+                  value: true
+                });
+              } else {
+                storage.setValue(radioId, {
+                  value: false
+                });
+              }
+            }
+          },
+
+          focus() {
+            setTimeout(() => event.target.focus({
+              preventScroll: false
+            }), 0);
+          },
+
+          hidden() {
+            event.target.style.visibility = detail.hidden ? "hidden" : "visible";
+            storage.setValue(id, {
+              hidden: detail.hidden
+            });
+          },
+
+          editable() {
+            event.target.disabled = !detail.editable;
+          }
+
+        };
+        Object.keys(detail).filter(name => name in actions).forEach(name => actions[name]());
+      });
+
+      this._setEventListeners(element, [["change", "Validate"], ["change", "Action"], ["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "MouseUp"]], event => event.target.checked);
+    }
+
+    this.container.appendChild(element);
+    return this.container;
+  }
+
+}
+
+class PushButtonWidgetAnnotationElement extends LinkAnnotationElement {
+  render() {
+    const container = super.render();
+    container.className = "buttonWidgetAnnotation pushButton";
+
+    if (this.data.alternativeText) {
+      container.title = this.data.alternativeText;
+    }
+
+    return container;
+  }
+
+}
+
+class ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {
+  constructor(parameters) {
+    super(parameters, {
+      isRenderable: parameters.renderInteractiveForms
+    });
+  }
+
+  render() {
+    this.container.className = "choiceWidgetAnnotation";
+    const storage = this.annotationStorage;
+    const id = this.data.id;
+    storage.getOrCreateValue(id, {
+      value: this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : undefined
+    });
+    const selectElement = document.createElement("select");
+    selectElement.disabled = this.data.readOnly;
+    selectElement.name = this.data.fieldName;
+    selectElement.setAttribute("id", id);
+
+    if (!this.data.combo) {
+      selectElement.size = this.data.options.length;
+
+      if (this.data.multiSelect) {
+        selectElement.multiple = true;
+      }
+    }
+
+    for (const option of this.data.options) {
+      const optionElement = document.createElement("option");
+      optionElement.textContent = option.displayValue;
+      optionElement.value = option.exportValue;
+
+      if (this.data.fieldValue.includes(option.exportValue)) {
+        optionElement.setAttribute("selected", true);
+      }
+
+      selectElement.appendChild(optionElement);
+    }
+
+    function getValue(event) {
+      const options = event.target.options;
+      return options[options.selectedIndex].value;
+    }
+
+    if (this.enableScripting && this.hasJSActions) {
+      selectElement.addEventListener("updatefromsandbox", event => {
+        const {
+          detail
+        } = event;
+        const actions = {
+          value() {
+            const options = event.target.options;
+            const value = detail.value;
+            const i = options.indexOf(value);
+
+            if (i !== -1) {
+              options.selectedIndex = i;
+              storage.setValue(id, {
+                value
+              });
+            }
+          },
+
+          focus() {
+            setTimeout(() => event.target.focus({
+              preventScroll: false
+            }), 0);
+          },
+
+          hidden() {
+            event.target.style.visibility = detail.hidden ? "hidden" : "visible";
+            storage.setValue(id, {
+              hidden: detail.hidden
+            });
+          },
+
+          editable() {
+            event.target.disabled = !detail.editable;
+          }
+
+        };
+        Object.keys(detail).filter(name => name in actions).forEach(name => actions[name]());
+      });
+      selectElement.addEventListener("input", event => {
+        const value = getValue(event);
+        storage.setValue(id, {
+          value
+        });
+        this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
+          source: this,
+          detail: {
+            id,
+            name: "Keystroke",
+            changeEx: value,
+            willCommit: true,
+            commitKey: 1,
+            keyDown: false
+          }
+        });
+      });
+
+      this._setEventListeners(selectElement, [["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "MouseUp"]], event => event.target.checked);
+    } else {
+      selectElement.addEventListener("input", function (event) {
+        storage.setValue(id, {
+          value: getValue(event)
+        });
+      });
+    }
+
+    this.container.appendChild(selectElement);
+    return this.container;
+  }
+
+}
+
+class PopupAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable
+    });
+  }
+
+  render() {
+    const IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"];
+    this.container.className = "popupAnnotation";
+
+    if (IGNORE_TYPES.includes(this.data.parentType)) {
+      return this.container;
+    }
+
+    const selector = `[data-annotation-id="${this.data.parentId}"]`;
+    const parentElements = this.layer.querySelectorAll(selector);
+
+    if (parentElements.length === 0) {
+      return this.container;
+    }
+
+    const popup = new PopupElement({
+      container: this.container,
+      trigger: Array.from(parentElements),
+      color: this.data.color,
+      title: this.data.title,
+      modificationDate: this.data.modificationDate,
+      contents: this.data.contents
+    });
+    const page = this.page;
+
+    const rect = _util.Util.normalizeRect([this.data.parentRect[0], page.view[3] - this.data.parentRect[1] + page.view[1], this.data.parentRect[2], page.view[3] - this.data.parentRect[3] + page.view[1]]);
+
+    const popupLeft = rect[0] + this.data.parentRect[2] - this.data.parentRect[0];
+    const popupTop = rect[1];
+    this.container.style.transformOrigin = `${-popupLeft}px ${-popupTop}px`;
+    this.container.style.left = `${popupLeft}px`;
+    this.container.style.top = `${popupTop}px`;
+    this.container.appendChild(popup.render());
+    return this.container;
+  }
+
+}
+
+class PopupElement {
+  constructor(parameters) {
+    this.container = parameters.container;
+    this.trigger = parameters.trigger;
+    this.color = parameters.color;
+    this.title = parameters.title;
+    this.modificationDate = parameters.modificationDate;
+    this.contents = parameters.contents;
+    this.hideWrapper = parameters.hideWrapper || false;
+    this.pinned = false;
+  }
+
+  render() {
+    const BACKGROUND_ENLIGHT = 0.7;
+    const wrapper = document.createElement("div");
+    wrapper.className = "popupWrapper";
+    this.hideElement = this.hideWrapper ? wrapper : this.container;
+    this.hideElement.setAttribute("hidden", true);
+    const popup = document.createElement("div");
+    popup.className = "popup";
+    const color = this.color;
+
+    if (color) {
+      const r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
+      const g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
+      const b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
+      popup.style.backgroundColor = _util.Util.makeHexColor(r | 0, g | 0, b | 0);
+    }
+
+    const title = document.createElement("h1");
+    title.textContent = this.title;
+    popup.appendChild(title);
+
+    const dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
+
+    if (dateObject) {
+      const modificationDate = document.createElement("span");
+      modificationDate.textContent = "{{date}}, {{time}}";
+      modificationDate.dataset.l10nId = "annotation_date_string";
+      modificationDate.dataset.l10nArgs = JSON.stringify({
+        date: dateObject.toLocaleDateString(),
+        time: dateObject.toLocaleTimeString()
+      });
+      popup.appendChild(modificationDate);
+    }
+
+    const contents = this._formatContents(this.contents);
+
+    popup.appendChild(contents);
+
+    if (!Array.isArray(this.trigger)) {
+      this.trigger = [this.trigger];
+    }
+
+    this.trigger.forEach(element => {
+      element.addEventListener("click", this._toggle.bind(this));
+      element.addEventListener("mouseover", this._show.bind(this, false));
+      element.addEventListener("mouseout", this._hide.bind(this, false));
+    });
+    popup.addEventListener("click", this._hide.bind(this, true));
+    wrapper.appendChild(popup);
+    return wrapper;
+  }
+
+  _formatContents(contents) {
+    const p = document.createElement("p");
+    const lines = contents.split(/(?:\r\n?|\n)/);
+
+    for (let i = 0, ii = lines.length; i < ii; ++i) {
+      const line = lines[i];
+      p.appendChild(document.createTextNode(line));
+
+      if (i < ii - 1) {
+        p.appendChild(document.createElement("br"));
+      }
+    }
+
+    return p;
+  }
+
+  _toggle() {
+    if (this.pinned) {
+      this._hide(true);
+    } else {
+      this._show(true);
+    }
+  }
+
+  _show(pin = false) {
+    if (pin) {
+      this.pinned = true;
+    }
+
+    if (this.hideElement.hasAttribute("hidden")) {
+      this.hideElement.removeAttribute("hidden");
+      this.container.style.zIndex += 1;
+    }
+  }
+
+  _hide(unpin = true) {
+    if (unpin) {
+      this.pinned = false;
+    }
+
+    if (!this.hideElement.hasAttribute("hidden") && !this.pinned) {
+      this.hideElement.setAttribute("hidden", true);
+      this.container.style.zIndex -= 1;
+    }
+  }
+
+}
+
+class FreeTextAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "freeTextAnnotation";
+
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    return this.container;
+  }
+
+}
+
+class LineAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "lineAnnotation";
+    const data = this.data;
+    const width = data.rect[2] - data.rect[0];
+    const height = data.rect[3] - data.rect[1];
+    const svg = this.svgFactory.create(width, height);
+    const line = this.svgFactory.createElement("svg:line");
+    line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]);
+    line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]);
+    line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]);
+    line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]);
+    line.setAttribute("stroke-width", data.borderStyle.width || 1);
+    line.setAttribute("stroke", "transparent");
+    svg.appendChild(line);
+    this.container.append(svg);
+
+    this._createPopup(line, data);
+
+    return this.container;
+  }
+
+}
+
+class SquareAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "squareAnnotation";
+    const data = this.data;
+    const width = data.rect[2] - data.rect[0];
+    const height = data.rect[3] - data.rect[1];
+    const svg = this.svgFactory.create(width, height);
+    const borderWidth = data.borderStyle.width;
+    const square = this.svgFactory.createElement("svg:rect");
+    square.setAttribute("x", borderWidth / 2);
+    square.setAttribute("y", borderWidth / 2);
+    square.setAttribute("width", width - borderWidth);
+    square.setAttribute("height", height - borderWidth);
+    square.setAttribute("stroke-width", borderWidth || 1);
+    square.setAttribute("stroke", "transparent");
+    square.setAttribute("fill", "none");
+    svg.appendChild(square);
+    this.container.append(svg);
+
+    this._createPopup(square, data);
+
+    return this.container;
+  }
+
+}
+
+class CircleAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "circleAnnotation";
+    const data = this.data;
+    const width = data.rect[2] - data.rect[0];
+    const height = data.rect[3] - data.rect[1];
+    const svg = this.svgFactory.create(width, height);
+    const borderWidth = data.borderStyle.width;
+    const circle = this.svgFactory.createElement("svg:ellipse");
+    circle.setAttribute("cx", width / 2);
+    circle.setAttribute("cy", height / 2);
+    circle.setAttribute("rx", width / 2 - borderWidth / 2);
+    circle.setAttribute("ry", height / 2 - borderWidth / 2);
+    circle.setAttribute("stroke-width", borderWidth || 1);
+    circle.setAttribute("stroke", "transparent");
+    circle.setAttribute("fill", "none");
+    svg.appendChild(circle);
+    this.container.append(svg);
+
+    this._createPopup(circle, data);
+
+    return this.container;
+  }
+
+}
+
+class PolylineAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+    this.containerClassName = "polylineAnnotation";
+    this.svgElementName = "svg:polyline";
+  }
+
+  render() {
+    this.container.className = this.containerClassName;
+    const data = this.data;
+    const width = data.rect[2] - data.rect[0];
+    const height = data.rect[3] - data.rect[1];
+    const svg = this.svgFactory.create(width, height);
+    let points = [];
+
+    for (const coordinate of data.vertices) {
+      const x = coordinate.x - data.rect[0];
+      const y = data.rect[3] - coordinate.y;
+      points.push(x + "," + y);
+    }
+
+    points = points.join(" ");
+    const polyline = this.svgFactory.createElement(this.svgElementName);
+    polyline.setAttribute("points", points);
+    polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
+    polyline.setAttribute("stroke", "transparent");
+    polyline.setAttribute("fill", "none");
+    svg.appendChild(polyline);
+    this.container.append(svg);
+
+    this._createPopup(polyline, data);
+
+    return this.container;
+  }
+
+}
+
+class PolygonAnnotationElement extends PolylineAnnotationElement {
+  constructor(parameters) {
+    super(parameters);
+    this.containerClassName = "polygonAnnotation";
+    this.svgElementName = "svg:polygon";
+  }
+
+}
+
+class CaretAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "caretAnnotation";
+
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    return this.container;
+  }
+
+}
+
+class InkAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+    this.containerClassName = "inkAnnotation";
+    this.svgElementName = "svg:polyline";
+  }
+
+  render() {
+    this.container.className = this.containerClassName;
+    const data = this.data;
+    const width = data.rect[2] - data.rect[0];
+    const height = data.rect[3] - data.rect[1];
+    const svg = this.svgFactory.create(width, height);
+
+    for (const inkList of data.inkLists) {
+      let points = [];
+
+      for (const coordinate of inkList) {
+        const x = coordinate.x - data.rect[0];
+        const y = data.rect[3] - coordinate.y;
+        points.push(`${x},${y}`);
+      }
+
+      points = points.join(" ");
+      const polyline = this.svgFactory.createElement(this.svgElementName);
+      polyline.setAttribute("points", points);
+      polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
+      polyline.setAttribute("stroke", "transparent");
+      polyline.setAttribute("fill", "none");
+
+      this._createPopup(polyline, data);
+
+      svg.appendChild(polyline);
+    }
+
+    this.container.append(svg);
+    return this.container;
+  }
+
+}
+
+class HighlightAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true,
+      createQuadrilaterals: true
+    });
+  }
+
+  render() {
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    if (this.quadrilaterals) {
+      return this._renderQuadrilaterals("highlightAnnotation");
+    }
+
+    this.container.className = "highlightAnnotation";
+    return this.container;
+  }
+
+}
+
+class UnderlineAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true,
+      createQuadrilaterals: true
+    });
+  }
+
+  render() {
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    if (this.quadrilaterals) {
+      return this._renderQuadrilaterals("underlineAnnotation");
+    }
+
+    this.container.className = "underlineAnnotation";
+    return this.container;
+  }
+
+}
+
+class SquigglyAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true,
+      createQuadrilaterals: true
+    });
+  }
+
+  render() {
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    if (this.quadrilaterals) {
+      return this._renderQuadrilaterals("squigglyAnnotation");
+    }
+
+    this.container.className = "squigglyAnnotation";
+    return this.container;
+  }
+
+}
+
+class StrikeOutAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true,
+      createQuadrilaterals: true
+    });
+  }
+
+  render() {
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    if (this.quadrilaterals) {
+      return this._renderQuadrilaterals("strikeoutAnnotation");
+    }
+
+    this.container.className = "strikeoutAnnotation";
+    return this.container;
+  }
+
+}
+
+class StampAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    const isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+    super(parameters, {
+      isRenderable,
+      ignoreBorder: true
+    });
+  }
+
+  render() {
+    this.container.className = "stampAnnotation";
+
+    if (!this.data.hasPopup) {
+      this._createPopup(null, this.data);
+    }
+
+    return this.container;
+  }
+
+}
+
+class FileAttachmentAnnotationElement extends AnnotationElement {
+  constructor(parameters) {
+    super(parameters, {
+      isRenderable: true
+    });
+    const {
+      filename,
+      content
+    } = this.data.file;
+    this.filename = (0, _display_utils.getFilenameFromUrl)(filename);
+    this.content = content;
+    this.linkService.eventBus?.dispatch("fileattachmentannotation", {
+      source: this,
+      id: (0, _util.stringToPDFString)(filename),
+      filename,
+      content
+    });
+  }
+
+  render() {
+    this.container.className = "fileAttachmentAnnotation";
+    const trigger = document.createElement("div");
+    trigger.style.height = this.container.style.height;
+    trigger.style.width = this.container.style.width;
+    trigger.addEventListener("dblclick", this._download.bind(this));
+
+    if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
+      this._createPopup(trigger, this.data);
+    }
+
+    this.container.appendChild(trigger);
+    return this.container;
+  }
+
+  _download() {
+    if (!this.downloadManager) {
+      (0, _util.warn)("Download cannot be started due to unavailable download manager");
+      return;
+    }
+
+    this.downloadManager.downloadData(this.content, this.filename, "");
+  }
+
+}
+
+class AnnotationLayer {
+  static render(parameters) {
+    const sortedAnnotations = [],
+          popupAnnotations = [];
+
+    for (const data of parameters.annotations) {
+      if (!data) {
+        continue;
+      }
+
+      if (data.annotationType === _util.AnnotationType.POPUP) {
+        popupAnnotations.push(data);
+        continue;
+      }
+
+      sortedAnnotations.push(data);
+    }
+
+    if (popupAnnotations.length) {
+      sortedAnnotations.push(...popupAnnotations);
+    }
+
+    for (const data of sortedAnnotations) {
+      const element = AnnotationElementFactory.create({
+        data,
+        layer: parameters.div,
+        page: parameters.page,
+        viewport: parameters.viewport,
+        linkService: parameters.linkService,
+        downloadManager: parameters.downloadManager,
+        imageResourcesPath: parameters.imageResourcesPath || "",
+        renderInteractiveForms: typeof parameters.renderInteractiveForms === "boolean" ? parameters.renderInteractiveForms : true,
+        svgFactory: new _display_utils.DOMSVGFactory(),
+        annotationStorage: parameters.annotationStorage || new _annotation_storage.AnnotationStorage(),
+        enableScripting: parameters.enableScripting,
+        hasJSActions: parameters.hasJSActions,
+        mouseState: parameters.mouseState || {
+          isDown: false
+        }
+      });
+
+      if (element.isRenderable) {
+        const rendered = element.render();
+
+        if (data.hidden) {
+          rendered.style.visibility = "hidden";
+        }
+
+        if (Array.isArray(rendered)) {
+          for (const renderedElement of rendered) {
+            parameters.div.appendChild(renderedElement);
+          }
+        } else {
+          if (element instanceof PopupAnnotationElement) {
+            parameters.div.prepend(rendered);
+          } else {
+            parameters.div.appendChild(rendered);
+          }
+        }
+      }
+    }
+  }
+
+  static update(parameters) {
+    const transform = `matrix(${parameters.viewport.transform.join(",")})`;
+
+    for (const data of parameters.annotations) {
+      const elements = parameters.div.querySelectorAll(`[data-annotation-id="${data.id}"]`);
+
+      if (elements) {
+        elements.forEach(element => {
+          element.style.transform = transform;
+        });
+      }
+    }
+
+    parameters.div.removeAttribute("hidden");
+  }
+
+}
+
+exports.AnnotationLayer = AnnotationLayer;
+
+/***/ }),
+/* 20 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ColorConverters = void 0;
+
+function makeColorComp(n) {
+  return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
+}
+
+class ColorConverters {
+  static CMYK_G([c, y, m, k]) {
+    return ["G", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];
+  }
+
+  static G_CMYK([g]) {
+    return ["CMYK", 0, 0, 0, 1 - g];
+  }
+
+  static G_RGB([g]) {
+    return ["RGB", g, g, g];
+  }
+
+  static G_HTML([g]) {
+    const G = makeColorComp(g);
+    return `#${G}${G}${G}`;
+  }
+
+  static RGB_G([r, g, b]) {
+    return ["G", 0.3 * r + 0.59 * g + 0.11 * b];
+  }
+
+  static RGB_HTML([r, g, b]) {
+    const R = makeColorComp(r);
+    const G = makeColorComp(g);
+    const B = makeColorComp(b);
+    return `#${R}${G}${B}`;
+  }
+
+  static T_HTML() {
+    return "#00000000";
+  }
+
+  static CMYK_RGB([c, y, m, k]) {
+    return ["RGB", 1 - Math.min(1, c + k), 1 - Math.min(1, m + k), 1 - Math.min(1, y + k)];
+  }
+
+  static CMYK_HTML(components) {
+    return this.RGB_HTML(this.CMYK_RGB(components));
+  }
+
+  static RGB_CMYK([r, g, b]) {
+    const c = 1 - r;
+    const m = 1 - g;
+    const y = 1 - b;
+    const k = Math.min(c, m, y);
+    return ["CMYK", c, m, y, k];
+  }
+
+}
+
+exports.ColorConverters = ColorConverters;
+
+/***/ }),
+/* 21 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.renderTextLayer = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const renderTextLayer = function renderTextLayerClosure() {
+  const MAX_TEXT_DIVS_TO_RENDER = 100000;
+  const NonWhitespaceRegexp = /\S/;
+
+  function isAllWhitespace(str) {
+    return !NonWhitespaceRegexp.test(str);
+  }
+
+  function appendText(task, geom, styles) {
+    const textDiv = document.createElement("span");
+    const textDivProperties = {
+      angle: 0,
+      canvasWidth: 0,
+      isWhitespace: false,
+      originalTransform: null,
+      paddingBottom: 0,
+      paddingLeft: 0,
+      paddingRight: 0,
+      paddingTop: 0,
+      scale: 1
+    };
+
+    task._textDivs.push(textDiv);
+
+    if (isAllWhitespace(geom.str)) {
+      textDivProperties.isWhitespace = true;
+
+      task._textDivProperties.set(textDiv, textDivProperties);
+
+      return;
+    }
+
+    const tx = _util.Util.transform(task._viewport.transform, geom.transform);
+
+    let angle = Math.atan2(tx[1], tx[0]);
+    const style = styles[geom.fontName];
+
+    if (style.vertical) {
+      angle += Math.PI / 2;
+    }
+
+    const fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);
+    let fontAscent = fontHeight;
+
+    if (style.ascent) {
+      fontAscent = style.ascent * fontAscent;
+    } else if (style.descent) {
+      fontAscent = (1 + style.descent) * fontAscent;
+    }
+
+    let left, top;
+
+    if (angle === 0) {
+      left = tx[4];
+      top = tx[5] - fontAscent;
+    } else {
+      left = tx[4] + fontAscent * Math.sin(angle);
+      top = tx[5] - fontAscent * Math.cos(angle);
+    }
+
+    textDiv.style.left = `${left}px`;
+    textDiv.style.top = `${top}px`;
+    textDiv.style.fontSize = `${fontHeight}px`;
+    textDiv.style.fontFamily = style.fontFamily;
+    textDiv.textContent = geom.str;
+
+    if (task._fontInspectorEnabled) {
+      textDiv.dataset.fontName = geom.fontName;
+    }
+
+    if (angle !== 0) {
+      textDivProperties.angle = angle * (180 / Math.PI);
+    }
+
+    let shouldScaleText = false;
+
+    if (geom.str.length > 1) {
+      shouldScaleText = true;
+    } else if (geom.transform[0] !== geom.transform[3]) {
+      const absScaleX = Math.abs(geom.transform[0]),
+            absScaleY = Math.abs(geom.transform[3]);
+
+      if (absScaleX !== absScaleY && Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5) {
+        shouldScaleText = true;
+      }
+    }
+
+    if (shouldScaleText) {
+      if (style.vertical) {
+        textDivProperties.canvasWidth = geom.height * task._viewport.scale;
+      } else {
+        textDivProperties.canvasWidth = geom.width * task._viewport.scale;
+      }
+    }
+
+    task._textDivProperties.set(textDiv, textDivProperties);
+
+    if (task._textContentStream) {
+      task._layoutText(textDiv);
+    }
+
+    if (task._enhanceTextSelection) {
+      let angleCos = 1,
+          angleSin = 0;
+
+      if (angle !== 0) {
+        angleCos = Math.cos(angle);
+        angleSin = Math.sin(angle);
+      }
+
+      const divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
+      const divHeight = fontHeight;
+      let m, b;
+
+      if (angle !== 0) {
+        m = [angleCos, angleSin, -angleSin, angleCos, left, top];
+        b = _util.Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);
+      } else {
+        b = [left, top, left + divWidth, top + divHeight];
+      }
+
+      task._bounds.push({
+        left: b[0],
+        top: b[1],
+        right: b[2],
+        bottom: b[3],
+        div: textDiv,
+        size: [divWidth, divHeight],
+        m
+      });
+    }
+  }
+
+  function render(task) {
+    if (task._canceled) {
+      return;
+    }
+
+    const textDivs = task._textDivs;
+    const capability = task._capability;
+    const textDivsLength = textDivs.length;
+
+    if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
+      task._renderingDone = true;
+      capability.resolve();
+      return;
+    }
+
+    if (!task._textContentStream) {
+      for (let i = 0; i < textDivsLength; i++) {
+        task._layoutText(textDivs[i]);
+      }
+    }
+
+    task._renderingDone = true;
+    capability.resolve();
+  }
+
+  function findPositiveMin(ts, offset, count) {
+    let result = 0;
+
+    for (let i = 0; i < count; i++) {
+      const t = ts[offset++];
+
+      if (t > 0) {
+        result = result ? Math.min(t, result) : t;
+      }
+    }
+
+    return result;
+  }
+
+  function expand(task) {
+    const bounds = task._bounds;
+    const viewport = task._viewport;
+    const expanded = expandBounds(viewport.width, viewport.height, bounds);
+
+    for (let i = 0; i < expanded.length; i++) {
+      const div = bounds[i].div;
+
+      const divProperties = task._textDivProperties.get(div);
+
+      if (divProperties.angle === 0) {
+        divProperties.paddingLeft = bounds[i].left - expanded[i].left;
+        divProperties.paddingTop = bounds[i].top - expanded[i].top;
+        divProperties.paddingRight = expanded[i].right - bounds[i].right;
+        divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
+
+        task._textDivProperties.set(div, divProperties);
+
+        continue;
+      }
+
+      const e = expanded[i],
+            b = bounds[i];
+      const m = b.m,
+            c = m[0],
+            s = m[1];
+      const points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];
+      const ts = new Float64Array(64);
+      points.forEach(function (p, j) {
+        const t = _util.Util.applyTransform(p, m);
+
+        ts[j + 0] = c && (e.left - t[0]) / c;
+        ts[j + 4] = s && (e.top - t[1]) / s;
+        ts[j + 8] = c && (e.right - t[0]) / c;
+        ts[j + 12] = s && (e.bottom - t[1]) / s;
+        ts[j + 16] = s && (e.left - t[0]) / -s;
+        ts[j + 20] = c && (e.top - t[1]) / c;
+        ts[j + 24] = s && (e.right - t[0]) / -s;
+        ts[j + 28] = c && (e.bottom - t[1]) / c;
+        ts[j + 32] = c && (e.left - t[0]) / -c;
+        ts[j + 36] = s && (e.top - t[1]) / -s;
+        ts[j + 40] = c && (e.right - t[0]) / -c;
+        ts[j + 44] = s && (e.bottom - t[1]) / -s;
+        ts[j + 48] = s && (e.left - t[0]) / s;
+        ts[j + 52] = c && (e.top - t[1]) / -c;
+        ts[j + 56] = s && (e.right - t[0]) / s;
+        ts[j + 60] = c && (e.bottom - t[1]) / -c;
+      });
+      const boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
+      divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
+      divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
+      divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
+      divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
+
+      task._textDivProperties.set(div, divProperties);
+    }
+  }
+
+  function expandBounds(width, height, boxes) {
+    const bounds = boxes.map(function (box, i) {
+      return {
+        x1: box.left,
+        y1: box.top,
+        x2: box.right,
+        y2: box.bottom,
+        index: i,
+        x1New: undefined,
+        x2New: undefined
+      };
+    });
+    expandBoundsLTR(width, bounds);
+    const expanded = new Array(boxes.length);
+    bounds.forEach(function (b) {
+      const i = b.index;
+      expanded[i] = {
+        left: b.x1New,
+        top: 0,
+        right: b.x2New,
+        bottom: 0
+      };
+    });
+    boxes.map(function (box, i) {
+      const e = expanded[i],
+            b = bounds[i];
+      b.x1 = box.top;
+      b.y1 = width - e.right;
+      b.x2 = box.bottom;
+      b.y2 = width - e.left;
+      b.index = i;
+      b.x1New = undefined;
+      b.x2New = undefined;
+    });
+    expandBoundsLTR(height, bounds);
+    bounds.forEach(function (b) {
+      const i = b.index;
+      expanded[i].top = b.x1New;
+      expanded[i].bottom = b.x2New;
+    });
+    return expanded;
+  }
+
+  function expandBoundsLTR(width, bounds) {
+    bounds.sort(function (a, b) {
+      return a.x1 - b.x1 || a.index - b.index;
+    });
+    const fakeBoundary = {
+      x1: -Infinity,
+      y1: -Infinity,
+      x2: 0,
+      y2: Infinity,
+      index: -1,
+      x1New: 0,
+      x2New: 0
+    };
+    const horizon = [{
+      start: -Infinity,
+      end: Infinity,
+      boundary: fakeBoundary
+    }];
+    bounds.forEach(function (boundary) {
+      let i = 0;
+
+      while (i < horizon.length && horizon[i].end <= boundary.y1) {
+        i++;
+      }
+
+      let j = horizon.length - 1;
+
+      while (j >= 0 && horizon[j].start >= boundary.y2) {
+        j--;
+      }
+
+      let horizonPart, affectedBoundary;
+      let q,
+          k,
+          maxXNew = -Infinity;
+
+      for (q = i; q <= j; q++) {
+        horizonPart = horizon[q];
+        affectedBoundary = horizonPart.boundary;
+        let xNew;
+
+        if (affectedBoundary.x2 > boundary.x1) {
+          xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
+        } else if (affectedBoundary.x2New === undefined) {
+          xNew = (affectedBoundary.x2 + boundary.x1) / 2;
+        } else {
+          xNew = affectedBoundary.x2New;
+        }
+
+        if (xNew > maxXNew) {
+          maxXNew = xNew;
+        }
+      }
+
+      boundary.x1New = maxXNew;
+
+      for (q = i; q <= j; q++) {
+        horizonPart = horizon[q];
+        affectedBoundary = horizonPart.boundary;
+
+        if (affectedBoundary.x2New === undefined) {
+          if (affectedBoundary.x2 > boundary.x1) {
+            if (affectedBoundary.index > boundary.index) {
+              affectedBoundary.x2New = affectedBoundary.x2;
+            }
+          } else {
+            affectedBoundary.x2New = maxXNew;
+          }
+        } else if (affectedBoundary.x2New > maxXNew) {
+          affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
+        }
+      }
+
+      const changedHorizon = [];
+      let lastBoundary = null;
+
+      for (q = i; q <= j; q++) {
+        horizonPart = horizon[q];
+        affectedBoundary = horizonPart.boundary;
+        const useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
+
+        if (lastBoundary === useBoundary) {
+          changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
+        } else {
+          changedHorizon.push({
+            start: horizonPart.start,
+            end: horizonPart.end,
+            boundary: useBoundary
+          });
+          lastBoundary = useBoundary;
+        }
+      }
+
+      if (horizon[i].start < boundary.y1) {
+        changedHorizon[0].start = boundary.y1;
+        changedHorizon.unshift({
+          start: horizon[i].start,
+          end: boundary.y1,
+          boundary: horizon[i].boundary
+        });
+      }
+
+      if (boundary.y2 < horizon[j].end) {
+        changedHorizon[changedHorizon.length - 1].end = boundary.y2;
+        changedHorizon.push({
+          start: boundary.y2,
+          end: horizon[j].end,
+          boundary: horizon[j].boundary
+        });
+      }
+
+      for (q = i; q <= j; q++) {
+        horizonPart = horizon[q];
+        affectedBoundary = horizonPart.boundary;
+
+        if (affectedBoundary.x2New !== undefined) {
+          continue;
+        }
+
+        let used = false;
+
+        for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
+          used = horizon[k].boundary === affectedBoundary;
+        }
+
+        for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
+          used = horizon[k].boundary === affectedBoundary;
+        }
+
+        for (k = 0; !used && k < changedHorizon.length; k++) {
+          used = changedHorizon[k].boundary === affectedBoundary;
+        }
+
+        if (!used) {
+          affectedBoundary.x2New = maxXNew;
+        }
+      }
+
+      Array.prototype.splice.apply(horizon, [i, j - i + 1].concat(changedHorizon));
+    });
+    horizon.forEach(function (horizonPart) {
+      const affectedBoundary = horizonPart.boundary;
+
+      if (affectedBoundary.x2New === undefined) {
+        affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
+      }
+    });
+  }
+
+  function TextLayerRenderTask({
+    textContent,
+    textContentStream,
+    container,
+    viewport,
+    textDivs,
+    textContentItemsStr,
+    enhanceTextSelection
+  }) {
+    this._textContent = textContent;
+    this._textContentStream = textContentStream;
+    this._container = container;
+    this._document = container.ownerDocument;
+    this._viewport = viewport;
+    this._textDivs = textDivs || [];
+    this._textContentItemsStr = textContentItemsStr || [];
+    this._enhanceTextSelection = !!enhanceTextSelection;
+    this._fontInspectorEnabled = !!globalThis.FontInspector?.enabled;
+    this._reader = null;
+    this._layoutTextLastFontSize = null;
+    this._layoutTextLastFontFamily = null;
+    this._layoutTextCtx = null;
+    this._textDivProperties = new WeakMap();
+    this._renderingDone = false;
+    this._canceled = false;
+    this._capability = (0, _util.createPromiseCapability)();
+    this._renderTimer = null;
+    this._bounds = [];
+
+    this._capability.promise.finally(() => {
+      if (this._layoutTextCtx) {
+        this._layoutTextCtx.canvas.width = 0;
+        this._layoutTextCtx.canvas.height = 0;
+        this._layoutTextCtx = null;
+      }
+    }).catch(() => {});
+  }
+
+  TextLayerRenderTask.prototype = {
+    get promise() {
+      return this._capability.promise;
+    },
+
+    cancel: function TextLayer_cancel() {
+      this._canceled = true;
+
+      if (this._reader) {
+        this._reader.cancel(new _util.AbortException("TextLayer task cancelled."));
+
+        this._reader = null;
+      }
+
+      if (this._renderTimer !== null) {
+        clearTimeout(this._renderTimer);
+        this._renderTimer = null;
+      }
+
+      this._capability.reject(new Error("TextLayer task cancelled."));
+    },
+
+    _processItems(items, styleCache) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        this._textContentItemsStr.push(items[i].str);
+
+        appendText(this, items[i], styleCache);
+      }
+    },
+
+    _layoutText(textDiv) {
+      const textDivProperties = this._textDivProperties.get(textDiv);
+
+      if (textDivProperties.isWhitespace) {
+        return;
+      }
+
+      let transform = "";
+
+      if (textDivProperties.canvasWidth !== 0) {
+        const {
+          fontSize,
+          fontFamily
+        } = textDiv.style;
+
+        if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
+          this._layoutTextCtx.font = `${fontSize} ${fontFamily}`;
+          this._layoutTextLastFontSize = fontSize;
+          this._layoutTextLastFontFamily = fontFamily;
+        }
+
+        const {
+          width
+        } = this._layoutTextCtx.measureText(textDiv.textContent);
+
+        if (width > 0) {
+          textDivProperties.scale = textDivProperties.canvasWidth / width;
+          transform = `scaleX(${textDivProperties.scale})`;
+        }
+      }
+
+      if (textDivProperties.angle !== 0) {
+        transform = `rotate(${textDivProperties.angle}deg) ${transform}`;
+      }
+
+      if (transform.length > 0) {
+        if (this._enhanceTextSelection) {
+          textDivProperties.originalTransform = transform;
+        }
+
+        textDiv.style.transform = transform;
+      }
+
+      this._textDivProperties.set(textDiv, textDivProperties);
+
+      this._container.appendChild(textDiv);
+    },
+
+    _render: function TextLayer_render(timeout) {
+      const capability = (0, _util.createPromiseCapability)();
+      let styleCache = Object.create(null);
+
+      const canvas = this._document.createElement("canvas");
+
+      canvas.mozOpaque = true;
+      this._layoutTextCtx = canvas.getContext("2d", {
+        alpha: false
+      });
+
+      if (this._textContent) {
+        const textItems = this._textContent.items;
+        const textStyles = this._textContent.styles;
+
+        this._processItems(textItems, textStyles);
+
+        capability.resolve();
+      } else if (this._textContentStream) {
+        const pump = () => {
+          this._reader.read().then(({
+            value,
+            done
+          }) => {
+            if (done) {
+              capability.resolve();
+              return;
+            }
+
+            Object.assign(styleCache, value.styles);
+
+            this._processItems(value.items, styleCache);
+
+            pump();
+          }, capability.reject);
+        };
+
+        this._reader = this._textContentStream.getReader();
+        pump();
+      } else {
+        throw new Error('Neither "textContent" nor "textContentStream"' + " parameters specified.");
+      }
+
+      capability.promise.then(() => {
+        styleCache = null;
+
+        if (!timeout) {
+          render(this);
+        } else {
+          this._renderTimer = setTimeout(() => {
+            render(this);
+            this._renderTimer = null;
+          }, timeout);
+        }
+      }, this._capability.reject);
+    },
+    expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
+      if (!this._enhanceTextSelection || !this._renderingDone) {
+        return;
+      }
+
+      if (this._bounds !== null) {
+        expand(this);
+        this._bounds = null;
+      }
+
+      const transformBuf = [],
+            paddingBuf = [];
+
+      for (let i = 0, ii = this._textDivs.length; i < ii; i++) {
+        const div = this._textDivs[i];
+
+        const divProps = this._textDivProperties.get(div);
+
+        if (divProps.isWhitespace) {
+          continue;
+        }
+
+        if (expandDivs) {
+          transformBuf.length = 0;
+          paddingBuf.length = 0;
+
+          if (divProps.originalTransform) {
+            transformBuf.push(divProps.originalTransform);
+          }
+
+          if (divProps.paddingTop > 0) {
+            paddingBuf.push(`${divProps.paddingTop}px`);
+            transformBuf.push(`translateY(${-divProps.paddingTop}px)`);
+          } else {
+            paddingBuf.push(0);
+          }
+
+          if (divProps.paddingRight > 0) {
+            paddingBuf.push(`${divProps.paddingRight / divProps.scale}px`);
+          } else {
+            paddingBuf.push(0);
+          }
+
+          if (divProps.paddingBottom > 0) {
+            paddingBuf.push(`${divProps.paddingBottom}px`);
+          } else {
+            paddingBuf.push(0);
+          }
+
+          if (divProps.paddingLeft > 0) {
+            paddingBuf.push(`${divProps.paddingLeft / divProps.scale}px`);
+            transformBuf.push(`translateX(${-divProps.paddingLeft / divProps.scale}px)`);
+          } else {
+            paddingBuf.push(0);
+          }
+
+          div.style.padding = paddingBuf.join(" ");
+
+          if (transformBuf.length) {
+            div.style.transform = transformBuf.join(" ");
+          }
+        } else {
+          div.style.padding = null;
+          div.style.transform = divProps.originalTransform;
+        }
+      }
+    }
+  };
+
+  function renderTextLayer(renderParameters) {
+    const task = new TextLayerRenderTask({
+      textContent: renderParameters.textContent,
+      textContentStream: renderParameters.textContentStream,
+      container: renderParameters.container,
+      viewport: renderParameters.viewport,
+      textDivs: renderParameters.textDivs,
+      textContentItemsStr: renderParameters.textContentItemsStr,
+      enhanceTextSelection: renderParameters.enhanceTextSelection
+    });
+
+    task._render(renderParameters.timeout);
+
+    return task;
+  }
+
+  return renderTextLayer;
+}();
+
+exports.renderTextLayer = renderTextLayer;
+
+/***/ }),
+/* 22 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SVGGraphics = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _display_utils = __w_pdfjs_require__(1);
+
+var _is_node = __w_pdfjs_require__(4);
+
+let SVGGraphics = function () {
+  throw new Error("Not implemented: SVGGraphics");
+};
+
+exports.SVGGraphics = SVGGraphics;
+;
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __w_pdfjs_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	// module exports must be returned from runtime so entry inlining is disabled
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	return __w_pdfjs_require__(0);
+/******/ })()
+;
+});
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/build/pdf.sandbox.external.js b/toolkit/components/pdfjs/content/build/pdf.sandbox.external.js
new file mode 100644
index 0000000000..ae00a7ff0a
--- /dev/null
+++ b/toolkit/components/pdfjs/content/build/pdf.sandbox.external.js
@@ -0,0 +1,133 @@
+/* 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class SandboxSupportBase {
+ constructor(win) {
+  this.win = win;
+  this.timeoutIds = new Map();
+  this.commFun = null;
+ }
+ destroy() {
+  this.commFunc = null;
+  this.timeoutIds.forEach(([_, id]) => this.win.clearTimeout(id));
+  this.timeoutIds = null;
+ }
+ exportValueToSandbox(val) {
+  throw new Error("Not implemented");
+ }
+ importValueFromSandbox(val) {
+  throw new Error("Not implemented");
+ }
+ createErrorForSandbox(errorMessage) {
+  throw new Error("Not implemented");
+ }
+ callSandboxFunction(name, args) {
+  try {
+   args = this.exportValueToSandbox(args);
+   this.commFun(name, args);
+  } catch (e) {
+   this.win.console.error(e);
+  }
+ }
+ createSandboxExternals() {
+  const externals = {
+   setTimeout: (callbackId, nMilliseconds) => {
+    if (typeof callbackId !== "number" || typeof nMilliseconds !== "number") {
+     return;
+    }
+    const id = this.win.setTimeout(() => {
+     this.timeoutIds.delete(callbackId);
+     this.callSandboxFunction("timeoutCb", {
+      callbackId,
+      interval: false
+     });
+    }, nMilliseconds);
+    this.timeoutIds.set(callbackId, id);
+   },
+   clearTimeout: id => {
+    this.win.clearTimeout(this.timeoutIds.get(id));
+    this.timeoutIds.delete(id);
+   },
+   setInterval: (callbackId, nMilliseconds) => {
+    if (typeof callbackId !== "number" || typeof nMilliseconds !== "number") {
+     return;
+    }
+    const id = this.win.setInterval(() => {
+     this.callSandboxFunction("timeoutCb", {
+      callbackId,
+      interval: true
+     });
+    }, nMilliseconds);
+    this.timeoutIds.set(callbackId, id);
+   },
+   clearInterval: id => {
+    this.win.clearInterval(this.timeoutIds.get(id));
+    this.timeoutIds.delete(id);
+   },
+   alert: cMsg => {
+    if (typeof cMsg !== "string") {
+     return;
+    }
+    this.win.alert(cMsg);
+   },
+   prompt: (cQuestion, cDefault) => {
+    if (typeof cQuestion !== "string" || typeof cDefault !== "string") {
+     return null;
+    }
+    return this.win.prompt(cQuestion, cDefault);
+   },
+   parseURL: cUrl => {
+    const url = new this.win.URL(cUrl);
+    const props = [
+     "hash",
+     "host",
+     "hostname",
+     "href",
+     "origin",
+     "password",
+     "pathname",
+     "port",
+     "protocol",
+     "search",
+     "searchParams",
+     "username"
+    ];
+    return Object.fromEntries(props.map(name => [
+     name,
+     url[name].toString()
+    ]));
+   },
+   send: data => {
+    if (!data) {
+     return;
+    }
+    const event = new this.win.CustomEvent("updatefromsandbox", { detail: this.importValueFromSandbox(data) });
+    this.win.dispatchEvent(event);
+   }
+  };
+  Object.setPrototypeOf(externals, null);
+  return (name, args) => {
+   try {
+    const result = externals[name](...args);
+    return this.exportValueToSandbox(result);
+   } catch (error) {
+    throw this.createErrorForSandbox(error?.toString() ?? "");
+   }
+  };
+ }
+}
+{
+ var EXPORTED_SYMBOLS = ["SandboxSupportBase"];
+}
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/build/pdf.scripting.js b/toolkit/components/pdfjs/content/build/pdf.scripting.js
new file mode 100644
index 0000000000..ef35c721be
--- /dev/null
+++ b/toolkit/components/pdfjs/content/build/pdf.scripting.js
@@ -0,0 +1,4234 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("pdfjs-dist/build/pdf.scripting", [], factory);
+	else if(typeof exports === 'object')
+		exports["pdfjs-dist/build/pdf.scripting"] = factory();
+	else
+		root.pdfjsScripting = factory();
+})(this, function() {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "initSandbox", ({
+  enumerable: true,
+  get: function () {
+    return _initialization.initSandbox;
+  }
+}));
+
+var _initialization = __w_pdfjs_require__(1);
+
+const pdfjsVersion = '2.7.510';
+const pdfjsBuild = '631bada0d';
+
+/***/ }),
+/* 1 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.initSandbox = initSandbox;
+
+var _constants = __w_pdfjs_require__(2);
+
+var _field = __w_pdfjs_require__(3);
+
+var _aform = __w_pdfjs_require__(8);
+
+var _app = __w_pdfjs_require__(9);
+
+var _color = __w_pdfjs_require__(4);
+
+var _console = __w_pdfjs_require__(13);
+
+var _doc = __w_pdfjs_require__(14);
+
+var _proxy = __w_pdfjs_require__(16);
+
+var _util = __w_pdfjs_require__(17);
+
+function initSandbox(params) {
+  delete globalThis.pdfjsScripting;
+  const externalCall = globalThis.callExternalFunction;
+  delete globalThis.callExternalFunction;
+
+  const globalEval = code => globalThis.eval(code);
+
+  const send = data => externalCall("send", [data]);
+
+  const proxyHandler = new _proxy.ProxyHandler();
+  const {
+    data
+  } = params;
+  const doc = new _doc.Doc({
+    send,
+    globalEval,
+    ...data.docInfo
+  });
+  const _document = {
+    obj: doc,
+    wrapped: new Proxy(doc, proxyHandler)
+  };
+  const app = new _app.App({
+    send,
+    globalEval,
+    externalCall,
+    _document,
+    calculationOrder: data.calculationOrder,
+    proxyHandler,
+    ...data.appInfo
+  });
+  const util = new _util.Util({
+    externalCall
+  });
+  const aform = new _aform.AForm(doc, app, util);
+
+  if (data.objects) {
+    for (const [name, objs] of Object.entries(data.objects)) {
+      const obj = objs[0];
+      obj.send = send;
+      obj.globalEval = globalEval;
+      obj.doc = _document.wrapped;
+      let field;
+
+      if (obj.type === "radiobutton") {
+        const otherButtons = objs.slice(1);
+        field = new _field.RadioButtonField(otherButtons, obj);
+      } else if (obj.type === "checkbox") {
+        const otherButtons = objs.slice(1);
+        field = new _field.CheckboxField(otherButtons, obj);
+      } else {
+        field = new _field.Field(obj);
+      }
+
+      const wrapped = new Proxy(field, proxyHandler);
+
+      doc._addField(name, wrapped);
+
+      const _object = {
+        obj: field,
+        wrapped
+      };
+
+      for (const object of objs) {
+        app._objects[object.id] = _object;
+      }
+    }
+  }
+
+  globalThis.event = null;
+  globalThis.global = Object.create(null);
+  globalThis.app = new Proxy(app, proxyHandler);
+  globalThis.color = new Proxy(new _color.Color(), proxyHandler);
+  globalThis.console = new Proxy(new _console.Console({
+    send
+  }), proxyHandler);
+  globalThis.util = new Proxy(util, proxyHandler);
+  globalThis.border = _constants.Border;
+  globalThis.cursor = _constants.Cursor;
+  globalThis.display = _constants.Display;
+  globalThis.font = _constants.Font;
+  globalThis.highlight = _constants.Highlight;
+  globalThis.position = _constants.Position;
+  globalThis.scaleHow = _constants.ScaleHow;
+  globalThis.scaleWhen = _constants.ScaleWhen;
+  globalThis.style = _constants.Style;
+  globalThis.trans = _constants.Trans;
+  globalThis.zoomtype = _constants.ZoomType;
+
+  for (const name of Object.getOwnPropertyNames(_aform.AForm.prototype)) {
+    if (name !== "constructor" && !name.startsWith("_")) {
+      globalThis[name] = aform[name].bind(aform);
+    }
+  }
+
+  const properties = Object.create(null);
+
+  for (const name of Object.getOwnPropertyNames(_doc.Doc.prototype)) {
+    if (name === "constructor" || name.startsWith("_")) {
+      continue;
+    }
+
+    const descriptor = Object.getOwnPropertyDescriptor(_doc.Doc.prototype, name);
+
+    if (descriptor.get) {
+      properties[name] = {
+        get: descriptor.get.bind(doc),
+        set: descriptor.set.bind(doc)
+      };
+    } else {
+      properties[name] = {
+        value: _doc.Doc.prototype[name].bind(doc)
+      };
+    }
+  }
+
+  Object.defineProperties(globalThis, properties);
+  const functions = {
+    dispatchEvent: app._dispatchEvent.bind(app),
+    timeoutCb: app._evalCallback.bind(app)
+  };
+  return (name, args) => {
+    try {
+      functions[name](args);
+    } catch (error) {
+      const value = `${error.toString()}\n${error.stack}`;
+      send({
+        command: "error",
+        value
+      });
+    }
+  };
+}
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ZoomType = exports.Trans = exports.Style = exports.ScaleWhen = exports.ScaleHow = exports.Position = exports.Highlight = exports.Font = exports.Display = exports.Cursor = exports.Border = void 0;
+const Border = Object.freeze({
+  s: "solid",
+  d: "dashed",
+  b: "beveled",
+  i: "inset",
+  u: "underline"
+});
+exports.Border = Border;
+const Cursor = Object.freeze({
+  visible: 0,
+  hidden: 1,
+  delay: 2
+});
+exports.Cursor = Cursor;
+const Display = Object.freeze({
+  visible: 0,
+  hidden: 1,
+  noPrint: 2,
+  noView: 3
+});
+exports.Display = Display;
+const Font = Object.freeze({
+  Times: "Times-Roman",
+  TimesB: "Times-Bold",
+  TimesI: "Times-Italic",
+  TimesBI: "Times-BoldItalic",
+  Helv: "Helvetica",
+  HelvB: "Helvetica-Bold",
+  HelvI: "Helvetica-Oblique",
+  HelvBI: "Helvetica-BoldOblique",
+  Cour: "Courier",
+  CourB: "Courier-Bold",
+  CourI: "Courier-Oblique",
+  CourBI: "Courier-BoldOblique",
+  Symbol: "Symbol",
+  ZapfD: "ZapfDingbats",
+  KaGo: "HeiseiKakuGo-W5-UniJIS-UCS2-H",
+  KaMi: "HeiseiMin-W3-UniJIS-UCS2-H"
+});
+exports.Font = Font;
+const Highlight = Object.freeze({
+  n: "none",
+  i: "invert",
+  p: "push",
+  o: "outline"
+});
+exports.Highlight = Highlight;
+const Position = Object.freeze({
+  textOnly: 0,
+  iconOnly: 1,
+  iconTextV: 2,
+  textIconV: 3,
+  iconTextH: 4,
+  textIconH: 5,
+  overlay: 6
+});
+exports.Position = Position;
+const ScaleHow = Object.freeze({
+  proportional: 0,
+  anamorphic: 1
+});
+exports.ScaleHow = ScaleHow;
+const ScaleWhen = Object.freeze({
+  always: 0,
+  never: 1,
+  tooBig: 2,
+  tooSmall: 3
+});
+exports.ScaleWhen = ScaleWhen;
+const Style = Object.freeze({
+  ch: "check",
+  cr: "cross",
+  di: "diamond",
+  ci: "circle",
+  st: "star",
+  sq: "square"
+});
+exports.Style = Style;
+const Trans = Object.freeze({
+  blindsH: "BlindsHorizontal",
+  blindsV: "BlindsVertical",
+  boxI: "BoxIn",
+  boxO: "BoxOut",
+  dissolve: "Dissolve",
+  glitterD: "GlitterDown",
+  glitterR: "GlitterRight",
+  glitterRD: "GlitterRightDown",
+  random: "Random",
+  replace: "Replace",
+  splitHI: "SplitHorizontalIn",
+  splitHO: "SplitHorizontalOut",
+  splitVI: "SplitVerticalIn",
+  splitVO: "SplitVerticalOut",
+  wipeD: "WipeDown",
+  wipeL: "WipeLeft",
+  wipeR: "WipeRight",
+  wipeU: "WipeUp"
+});
+exports.Trans = Trans;
+const ZoomType = Object.freeze({
+  none: "NoVary",
+  fitP: "FitPage",
+  fitW: "FitWidth",
+  fitH: "FitHeight",
+  fitV: "FitVisibleWidth",
+  pref: "Preferred",
+  refW: "ReflowWidth"
+});
+exports.ZoomType = ZoomType;
+
+/***/ }),
+/* 3 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.RadioButtonField = exports.Field = exports.CheckboxField = void 0;
+
+var _color = __w_pdfjs_require__(4);
+
+var _common = __w_pdfjs_require__(7);
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class Field extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this.alignment = data.alignment || "left";
+    this.borderStyle = data.borderStyle || "";
+    this.buttonAlignX = data.buttonAlignX || 50;
+    this.buttonAlignY = data.buttonAlignY || 50;
+    this.buttonFitBounds = data.buttonFitBounds;
+    this.buttonPosition = data.buttonPosition;
+    this.buttonScaleHow = data.buttonScaleHow;
+    this.ButtonScaleWhen = data.buttonScaleWhen;
+    this.calcOrderIndex = data.calcOrderIndex;
+    this.charLimit = data.charLimit;
+    this.comb = data.comb;
+    this.commitOnSelChange = data.commitOnSelChange;
+    this.currentValueIndices = data.currentValueIndices;
+    this.defaultStyle = data.defaultStyle;
+    this.defaultValue = data.defaultValue;
+    this.doNotScroll = data.doNotScroll;
+    this.doNotSpellCheck = data.doNotSpellCheck;
+    this.delay = data.delay;
+    this.display = data.display;
+    this.doc = data.doc;
+    this.editable = data.editable;
+    this.exportValues = data.exportValues;
+    this.fileSelect = data.fileSelect;
+    this.hidden = data.hidden;
+    this.highlight = data.highlight;
+    this.lineWidth = data.lineWidth;
+    this.multiline = data.multiline;
+    this.multipleSelection = !!data.multipleSelection;
+    this.name = data.name;
+    this.numItems = data.numItems;
+    this.page = data.page;
+    this.password = data.password;
+    this.print = data.print;
+    this.radiosInUnison = data.radiosInUnison;
+    this.readonly = data.readonly;
+    this.rect = data.rect;
+    this.required = data.required;
+    this.richText = data.richText;
+    this.richValue = data.richValue;
+    this.rotation = data.rotation;
+    this.style = data.style;
+    this.submitName = data.submitName;
+    this.textFont = data.textFont;
+    this.textSize = data.textSize;
+    this.type = data.type;
+    this.userName = data.userName;
+    this._document = data.doc;
+    this._value = data.value || "";
+    this._valueAsString = data.valueAsString;
+    this._actions = (0, _common.createActionsMap)(data.actions);
+    this._fillColor = data.fillColor || ["T"];
+    this._strokeColor = data.strokeColor || ["G", 0];
+    this._textColor = data.textColor || ["G", 0];
+    this._globalEval = data.globalEval;
+  }
+
+  get fillColor() {
+    return this._fillColor;
+  }
+
+  set fillColor(color) {
+    if (_color.Color._isValidColor(color)) {
+      this._fillColor = color;
+    }
+  }
+
+  get strokeColor() {
+    return this._strokeColor;
+  }
+
+  set strokeColor(color) {
+    if (_color.Color._isValidColor(color)) {
+      this._strokeColor = color;
+    }
+  }
+
+  get textColor() {
+    return this._textColor;
+  }
+
+  set textColor(color) {
+    if (_color.Color._isValidColor(color)) {
+      this._textColor = color;
+    }
+  }
+
+  get value() {
+    return this._value;
+  }
+
+  set value(value) {
+    if (!this.multipleSelection) {
+      this._value = value;
+    }
+  }
+
+  get valueAsString() {
+    return this._valueAsString;
+  }
+
+  set valueAsString(val) {
+    this._valueAsString = val ? val.toString() : "";
+  }
+
+  checkThisBox(nWidget, bCheckIt = true) {}
+
+  isBoxChecked(nWidget) {
+    return false;
+  }
+
+  isDefaultChecked(nWidget) {
+    return false;
+  }
+
+  setAction(cTrigger, cScript) {
+    if (typeof cTrigger !== "string" || typeof cScript !== "string") {
+      return;
+    }
+
+    if (!(cTrigger in this._actions)) {
+      this._actions[cTrigger] = [];
+    }
+
+    this._actions[cTrigger].push(cScript);
+  }
+
+  setFocus() {
+    this._send({
+      id: this._id,
+      focus: true
+    });
+  }
+
+  _isButton() {
+    return false;
+  }
+
+  _runActions(event) {
+    const eventName = event.name;
+
+    if (!this._actions.has(eventName)) {
+      return false;
+    }
+
+    const actions = this._actions.get(eventName);
+
+    try {
+      for (const action of actions) {
+        this._globalEval(action);
+      }
+    } catch (error) {
+      event.rc = false;
+      throw error;
+    }
+
+    return true;
+  }
+
+}
+
+exports.Field = Field;
+
+class RadioButtonField extends Field {
+  constructor(otherButtons, data) {
+    super(data);
+    this.exportValues = [this.exportValues];
+    this._radioIds = [this._id];
+    this._radioActions = [this._actions];
+
+    for (const radioData of otherButtons) {
+      this.exportValues.push(radioData.exportValues);
+
+      this._radioIds.push(radioData.id);
+
+      this._radioActions.push((0, _common.createActionsMap)(radioData.actions));
+
+      if (this._value === radioData.exportValues) {
+        this._id = radioData.id;
+      }
+    }
+  }
+
+  get value() {
+    return this._value;
+  }
+
+  set value(value) {
+    const i = this.exportValues.indexOf(value);
+
+    if (0 <= i && i < this._radioIds.length) {
+      this._id = this._radioIds[i];
+      this._value = value;
+    } else if (value === "Off" && this._radioIds.length === 2) {
+      const nextI = (1 + this._radioIds.indexOf(this._id)) % 2;
+      this._id = this._radioIds[nextI];
+      this._value = this.exportValues[nextI];
+    }
+  }
+
+  checkThisBox(nWidget, bCheckIt = true) {
+    if (nWidget < 0 || nWidget >= this._radioIds.length || !bCheckIt) {
+      return;
+    }
+
+    this._id = this._radioIds[nWidget];
+    this._value = this.exportValues[nWidget];
+
+    this._send({
+      id: this._id,
+      value: this._value
+    });
+  }
+
+  isBoxChecked(nWidget) {
+    return nWidget >= 0 && nWidget < this._radioIds.length && this._id === this._radioIds[nWidget];
+  }
+
+  isDefaultChecked(nWidget) {
+    return nWidget >= 0 && nWidget < this.exportValues.length && this.defaultValue === this.exportValues[nWidget];
+  }
+
+  _getExportValue(state) {
+    const i = this._radioIds.indexOf(this._id);
+
+    return this.exportValues[i];
+  }
+
+  _runActions(event) {
+    const i = this._radioIds.indexOf(this._id);
+
+    this._actions = this._radioActions[i];
+    return super._runActions(event);
+  }
+
+  _isButton() {
+    return true;
+  }
+
+}
+
+exports.RadioButtonField = RadioButtonField;
+
+class CheckboxField extends RadioButtonField {
+  get value() {
+    return this._value;
+  }
+
+  set value(value) {
+    if (value === "Off") {
+      this._value = "Off";
+    } else {
+      super.value = value;
+    }
+  }
+
+  _getExportValue(state) {
+    return state ? super._getExportValue(state) : "Off";
+  }
+
+  isBoxChecked(nWidget) {
+    if (this._value === "Off") {
+      return false;
+    }
+
+    return super.isBoxChecked(nWidget);
+  }
+
+  isDefaultChecked(nWidget) {
+    if (this.defaultValue === "Off") {
+      return this._value === "Off";
+    }
+
+    return super.isDefaultChecked(nWidget);
+  }
+
+  checkThisBox(nWidget, bCheckIt = true) {
+    if (nWidget < 0 || nWidget >= this._radioIds.length) {
+      return;
+    }
+
+    this._id = this._radioIds[nWidget];
+    this._value = bCheckIt ? this.exportValues[nWidget] : "Off";
+
+    this._send({
+      id: this._id,
+      value: this._value
+    });
+  }
+
+}
+
+exports.CheckboxField = CheckboxField;
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Color = void 0;
+
+var _scripting_utils = __w_pdfjs_require__(5);
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class Color extends _pdf_object.PDFObject {
+  constructor() {
+    super({});
+    this.transparent = ["T"];
+    this.black = ["G", 0];
+    this.white = ["G", 1];
+    this.red = ["RGB", 1, 0, 0];
+    this.green = ["RGB", 0, 1, 0];
+    this.blue = ["RGB", 0, 0, 1];
+    this.cyan = ["CMYK", 1, 0, 0, 0];
+    this.magenta = ["CMYK", 0, 1, 0, 0];
+    this.yellow = ["CMYK", 0, 0, 1, 0];
+    this.dkGray = ["G", 0.25];
+    this.gray = ["G", 0.5];
+    this.ltGray = ["G", 0.75];
+  }
+
+  static _isValidSpace(cColorSpace) {
+    return typeof cColorSpace === "string" && (cColorSpace === "T" || cColorSpace === "G" || cColorSpace === "RGB" || cColorSpace === "CMYK");
+  }
+
+  static _isValidColor(colorArray) {
+    if (!Array.isArray(colorArray) || colorArray.length === 0) {
+      return false;
+    }
+
+    const space = colorArray[0];
+
+    if (!Color._isValidSpace(space)) {
+      return false;
+    }
+
+    switch (space) {
+      case "T":
+        if (colorArray.length !== 1) {
+          return false;
+        }
+
+        break;
+
+      case "G":
+        if (colorArray.length !== 2) {
+          return false;
+        }
+
+        break;
+
+      case "RGB":
+        if (colorArray.length !== 4) {
+          return false;
+        }
+
+        break;
+
+      case "CMYK":
+        if (colorArray.length !== 5) {
+          return false;
+        }
+
+        break;
+
+      default:
+        return false;
+    }
+
+    return colorArray.slice(1).every(c => typeof c === "number" && c >= 0 && c <= 1);
+  }
+
+  static _getCorrectColor(colorArray) {
+    return Color._isValidColor(colorArray) ? colorArray : ["G", 0];
+  }
+
+  convert(colorArray, cColorSpace) {
+    if (!Color._isValidSpace(cColorSpace)) {
+      return this.black;
+    }
+
+    if (cColorSpace === "T") {
+      return ["T"];
+    }
+
+    colorArray = Color._getCorrectColor(colorArray);
+
+    if (colorArray[0] === cColorSpace) {
+      return colorArray;
+    }
+
+    if (colorArray[0] === "T") {
+      return this.convert(this.black, cColorSpace);
+    }
+
+    return _scripting_utils.ColorConverters[`${colorArray[0]}_${cColorSpace}`](colorArray.slice(1));
+  }
+
+  equal(colorArray1, colorArray2) {
+    colorArray1 = Color._getCorrectColor(colorArray1);
+    colorArray2 = Color._getCorrectColor(colorArray2);
+
+    if (colorArray1[0] === "T" || colorArray2[0] === "T") {
+      return colorArray1[0] === "T" && colorArray2[0] === "T";
+    }
+
+    if (colorArray1[0] !== colorArray2[0]) {
+      colorArray2 = this.convert(colorArray2, colorArray1[0]);
+    }
+
+    return colorArray1.slice(1).every((c, i) => c === colorArray2[i + 1]);
+  }
+
+}
+
+exports.Color = Color;
+
+/***/ }),
+/* 5 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ColorConverters = void 0;
+
+function makeColorComp(n) {
+  return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
+}
+
+class ColorConverters {
+  static CMYK_G([c, y, m, k]) {
+    return ["G", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];
+  }
+
+  static G_CMYK([g]) {
+    return ["CMYK", 0, 0, 0, 1 - g];
+  }
+
+  static G_RGB([g]) {
+    return ["RGB", g, g, g];
+  }
+
+  static G_HTML([g]) {
+    const G = makeColorComp(g);
+    return `#${G}${G}${G}`;
+  }
+
+  static RGB_G([r, g, b]) {
+    return ["G", 0.3 * r + 0.59 * g + 0.11 * b];
+  }
+
+  static RGB_HTML([r, g, b]) {
+    const R = makeColorComp(r);
+    const G = makeColorComp(g);
+    const B = makeColorComp(b);
+    return `#${R}${G}${B}`;
+  }
+
+  static T_HTML() {
+    return "#00000000";
+  }
+
+  static CMYK_RGB([c, y, m, k]) {
+    return ["RGB", 1 - Math.min(1, c + k), 1 - Math.min(1, m + k), 1 - Math.min(1, y + k)];
+  }
+
+  static CMYK_HTML(components) {
+    return this.RGB_HTML(this.CMYK_RGB(components));
+  }
+
+  static RGB_CMYK([r, g, b]) {
+    const c = 1 - r;
+    const m = 1 - g;
+    const y = 1 - b;
+    const k = Math.min(c, m, y);
+    return ["CMYK", c, m, y, k];
+  }
+
+}
+
+exports.ColorConverters = ColorConverters;
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFObject = void 0;
+
+class PDFObject {
+  constructor(data) {
+    this._expandos = Object.create(null);
+    this._send = data.send || null;
+    this._id = data.id || null;
+  }
+
+}
+
+exports.PDFObject = PDFObject;
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.createActionsMap = createActionsMap;
+
+function createActionsMap(actions) {
+  const actionsMap = new Map();
+
+  if (actions) {
+    for (const [eventType, actionsForEvent] of Object.entries(actions)) {
+      actionsMap.set(eventType, actionsForEvent);
+    }
+  }
+
+  return actionsMap;
+}
+
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.AForm = void 0;
+
+class AForm {
+  constructor(document, app, util) {
+    this._document = document;
+    this._app = app;
+    this._util = util;
+    this._dateFormats = ["m/d", "m/d/yy", "mm/dd/yy", "mm/yy", "d-mmm", "d-mmm-yy", "dd-mmm-yy", "yy-mm-dd", "mmm-yy", "mmmm-yy", "mmm d, yyyy", "mmmm d, yyyy", "m/d/yy h:MM tt", "m/d/yy HH:MM"];
+    this._timeFormats = ["HH:MM", "h:MM tt", "HH:MM:ss", "h:MM:ss tt"];
+    this._emailRegex = new RegExp("^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+" + "@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?" + "(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$");
+  }
+
+  _parseDate(cFormat, cDate) {
+    const ddate = Date.parse(cDate);
+
+    if (isNaN(ddate)) {
+      try {
+        return this._util.scand(cFormat, cDate);
+      } catch (error) {
+        return null;
+      }
+    } else {
+      return new Date(ddate);
+    }
+  }
+
+  AFMergeChange(event = globalThis.event) {
+    if (event.willCommit) {
+      return event.value.toString();
+    }
+
+    return this._app._eventDispatcher.mergeChange(event);
+  }
+
+  AFParseDateEx(cString, cOrder) {
+    return this._parseDate(cOrder, cString);
+  }
+
+  AFExtractNums(str) {
+    if (typeof str === "number") {
+      return [str];
+    }
+
+    if (!str || typeof str !== "string") {
+      return null;
+    }
+
+    const first = str.charAt(0);
+
+    if (first === "." || first === ",") {
+      str = `0${str}`;
+    }
+
+    const numbers = str.match(/([0-9]+)/g);
+
+    if (numbers.length === 0) {
+      return null;
+    }
+
+    return numbers;
+  }
+
+  AFMakeNumber(str) {
+    if (typeof str === "number") {
+      return str;
+    }
+
+    if (typeof str !== "string") {
+      return null;
+    }
+
+    str = str.trim().replace(",", ".");
+    const number = parseFloat(str);
+
+    if (isNaN(number) || !isFinite(number)) {
+      return null;
+    }
+
+    return number;
+  }
+
+  AFMakeArrayFromList(string) {
+    if (typeof string === "string") {
+      return string.split(/, ?/g);
+    }
+
+    return string;
+  }
+
+  AFNumber_Format(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend) {
+    const event = globalThis.event;
+
+    if (!event.value) {
+      return;
+    }
+
+    let value = this.AFMakeNumber(event.value);
+
+    if (value === null) {
+      event.value = "";
+      return;
+    }
+
+    const sign = Math.sign(value);
+    const buf = [];
+    let hasParen = false;
+
+    if (sign === -1 && bCurrencyPrepend && negStyle === 0) {
+      buf.push("-");
+    }
+
+    if ((negStyle === 2 || negStyle === 3) && sign === -1) {
+      buf.push("(");
+      hasParen = true;
+    }
+
+    if (bCurrencyPrepend) {
+      buf.push(strCurrency);
+    }
+
+    sepStyle = Math.min(Math.max(0, Math.floor(sepStyle)), 4);
+    buf.push("%,");
+    buf.push(sepStyle);
+    buf.push(".");
+    buf.push(nDec.toString());
+    buf.push("f");
+
+    if (!bCurrencyPrepend) {
+      buf.push(strCurrency);
+    }
+
+    if (hasParen) {
+      buf.push(")");
+    }
+
+    if (negStyle === 1 || negStyle === 3) {
+      event.target.textColor = sign === 1 ? color.black : color.red;
+    }
+
+    if ((negStyle !== 0 || bCurrencyPrepend) && sign === -1) {
+      value = -value;
+    }
+
+    const formatStr = buf.join("");
+    event.value = this._util.printf(formatStr, value);
+  }
+
+  AFNumber_Keystroke(nDec, sepStyle, negStyle, currStyle, strCurrency, bCurrencyPrepend) {
+    const event = globalThis.event;
+    let value = this.AFMergeChange(event);
+
+    if (!value) {
+      return;
+    }
+
+    value = value.trim();
+    let pattern;
+
+    if (sepStyle > 1) {
+      pattern = event.willCommit ? /^[+-]?([0-9]+(,[0-9]*)?|,[0-9]+)$/ : /^[+-]?[0-9]*,?[0-9]*$/;
+    } else {
+      pattern = event.willCommit ? /^[+-]?([0-9]+(\.[0-9]*)?|\.[0-9]+)$/ : /^[+-]?[0-9]*\.?[0-9]*$/;
+    }
+
+    if (!pattern.test(value)) {
+      if (event.willCommit) {
+        if (event.target) {
+          this._app.alert(`Invalid number in [ ${event.target.name} ]`);
+        } else {
+          this._app.alert(`Invalid number`);
+        }
+      }
+
+      event.rc = false;
+    }
+  }
+
+  AFPercent_Format(nDec, sepStyle, percentPrepend = false) {
+    if (typeof nDec !== "number") {
+      return;
+    }
+
+    if (typeof sepStyle !== "number") {
+      return;
+    }
+
+    if (nDec < 0) {
+      throw new Error("Invalid nDec value in AFPercent_Format");
+    }
+
+    const event = globalThis.event;
+
+    if (nDec > 512) {
+      event.value = "%";
+      return;
+    }
+
+    nDec = Math.floor(nDec);
+    sepStyle = Math.min(Math.max(0, Math.floor(sepStyle)), 4);
+    let value = this.AFMakeNumber(event.value);
+
+    if (value === null) {
+      event.value = "%";
+      return;
+    }
+
+    const formatStr = `%,${sepStyle}.${nDec}f`;
+    value = this._util.printf(formatStr, value * 100);
+
+    if (percentPrepend) {
+      event.value = `%${value}`;
+    } else {
+      event.value = `${value}%`;
+    }
+  }
+
+  AFPercent_Keystroke(nDec, sepStyle) {
+    this.AFNumber_Keystroke(nDec, sepStyle, 0, 0, "", true);
+  }
+
+  AFDate_FormatEx(cFormat) {
+    const event = globalThis.event;
+    const value = event.value;
+
+    if (!value) {
+      return;
+    }
+
+    const date = this._parseDate(cFormat, value);
+
+    if (date !== null) {
+      event.value = this._util.printd(cFormat, date);
+    }
+  }
+
+  AFDate_Format(pdf) {
+    if (pdf >= 0 && pdf < this._dateFormats.length) {
+      this.AFDate_FormatEx(this._dateFormats[pdf]);
+    }
+  }
+
+  AFDate_KeystrokeEx(cFormat) {
+    const event = globalThis.event;
+
+    if (!event.willCommit) {
+      return;
+    }
+
+    const value = event.value;
+
+    if (!value) {
+      return;
+    }
+
+    if (this._parseDate(cFormat, value) === null) {
+      this._app.alert("Invalid date");
+
+      event.rc = false;
+    }
+  }
+
+  AFDate_Keystroke(pdf) {
+    if (pdf >= 0 && pdf < this._dateFormats.length) {
+      this.AFDate_KeystrokeEx(this._dateFormats[pdf]);
+    }
+  }
+
+  AFRange_Validate(bGreaterThan, nGreaterThan, bLessThan, nLessThan) {
+    const event = globalThis.event;
+
+    if (!event.value) {
+      return;
+    }
+
+    const value = this.AFMakeNumber(event.value);
+
+    if (value === null) {
+      return;
+    }
+
+    bGreaterThan = !!bGreaterThan;
+    bLessThan = !!bLessThan;
+
+    if (bGreaterThan) {
+      nGreaterThan = this.AFMakeNumber(nGreaterThan);
+
+      if (nGreaterThan === null) {
+        return;
+      }
+    }
+
+    if (bLessThan) {
+      nLessThan = this.AFMakeNumber(nLessThan);
+
+      if (nLessThan === null) {
+        return;
+      }
+    }
+
+    let err = "";
+
+    if (bGreaterThan && bLessThan) {
+      if (value < nGreaterThan || value > nLessThan) {
+        err = `${event.value} is not between ${nGreaterThan} and ${nLessThan}`;
+      }
+    } else if (bGreaterThan) {
+      if (value < nGreaterThan) {
+        err = `${event.value} is not greater or equal than ${nGreaterThan}`;
+      }
+    } else if (value > nLessThan) {
+      err = `${event.value} is not less or equal than ${nLessThan}`;
+    }
+
+    if (err) {
+      this._app.alert(err);
+
+      event.rc = false;
+    }
+  }
+
+  AFSimple(cFunction, nValue1, nValue2) {
+    const value1 = this.AFMakeNumber(nValue1);
+
+    if (value1 === null) {
+      throw new Error("Invalid nValue1 in AFSimple");
+    }
+
+    const value2 = this.AFMakeNumber(nValue2);
+
+    if (value2 === null) {
+      throw new Error("Invalid nValue2 in AFSimple");
+    }
+
+    switch (cFunction) {
+      case "AVG":
+        return (value1 + value2) / 2;
+
+      case "SUM":
+        return value1 + value2;
+
+      case "PRD":
+        return value1 * value2;
+
+      case "MIN":
+        return Math.min(value1, value2);
+
+      case "MAX":
+        return Math.max(value1, value2);
+    }
+
+    throw new Error("Invalid cFunction in AFSimple");
+  }
+
+  AFSimple_Calculate(cFunction, cFields) {
+    const actions = {
+      AVG: args => args.reduce((acc, value) => acc + value, 0) / args.length,
+      SUM: args => args.reduce((acc, value) => acc + value, 0),
+      PRD: args => args.reduce((acc, value) => acc * value, 1),
+      MIN: args => args.reduce((acc, value) => Math.min(acc, value), Number.MAX_VALUE),
+      MAX: args => args.reduce((acc, value) => Math.max(acc, value), Number.MIN_VALUE)
+    };
+
+    if (!(cFunction in actions)) {
+      throw new TypeError("Invalid function in AFSimple_Calculate");
+    }
+
+    const event = globalThis.event;
+    const values = [];
+
+    for (const cField of cFields) {
+      const field = this._document.getField(cField);
+
+      const number = this.AFMakeNumber(field.value);
+
+      if (number !== null) {
+        values.push(number);
+      }
+    }
+
+    if (values.length === 0) {
+      event.value = cFunction === "PRD" ? 1 : 0;
+      return;
+    }
+
+    const res = actions[cFunction](values);
+    event.value = Math.round(1e6 * res) / 1e6;
+  }
+
+  AFSpecial_Format(psf) {
+    const event = globalThis.event;
+
+    if (!event.value) {
+      return;
+    }
+
+    psf = this.AFMakeNumber(psf);
+
+    if (psf === null) {
+      throw new Error("Invalid psf in AFSpecial_Format");
+    }
+
+    let formatStr = "";
+
+    switch (psf) {
+      case 0:
+        formatStr = "99999";
+        break;
+
+      case 1:
+        formatStr = "99999-9999";
+        break;
+
+      case 2:
+        if (this._util.printx("9999999999", event.value).length >= 10) {
+          formatStr = "(999) 999-9999";
+        } else {
+          formatStr = "999-9999";
+        }
+
+        break;
+
+      case 3:
+        formatStr = "999-99-9999";
+        break;
+
+      default:
+        throw new Error("Invalid psf in AFSpecial_Format");
+    }
+
+    event.value = this._util.printx(formatStr, event.value);
+  }
+
+  AFSpecial_KeystrokeEx(cMask) {
+    if (!cMask) {
+      return;
+    }
+
+    const event = globalThis.event;
+    const value = this.AFMergeChange(event);
+    const checkers = new Map([["9", char => char >= "0" && char <= "9"], ["A", char => "a" <= char && char <= "z" || "A" <= char && char <= "Z"], ["O", char => "a" <= char && char <= "z" || "A" <= char && char <= "Z" || "0" <= char && char <= "9"], ["X", char => true]]);
+
+    function _checkValidity(_value, _cMask) {
+      for (let i = 0, ii = value.length; i < ii; i++) {
+        const mask = _cMask.charAt(i);
+
+        const char = _value.charAt(i);
+
+        const checker = checkers.get(mask);
+
+        if (checker) {
+          if (!checker(char)) {
+            return false;
+          }
+        } else if (mask !== char) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    if (!value) {
+      return;
+    }
+
+    if (value.length > cMask.length) {
+      this._app.alert("Value is too long");
+
+      event.rc = false;
+      return;
+    }
+
+    if (event.willCommit) {
+      if (value.length < cMask.length) {
+        this._app.alert("Value is too short");
+
+        event.rc = false;
+        return;
+      }
+
+      if (!_checkValidity(value, cMask)) {
+        this._app.alert("Value doesn't fit the specified format");
+
+        event.rc = false;
+        return;
+      }
+
+      return;
+    }
+
+    if (value.length < cMask.length) {
+      cMask = cMask.substring(0, value.length);
+    }
+
+    if (!_checkValidity(value, cMask)) {
+      event.rc = false;
+    }
+  }
+
+  AFSpecial_Keystroke(psf) {
+    const event = globalThis.event;
+
+    if (!event.value) {
+      return;
+    }
+
+    psf = this.AFMakeNumber(psf);
+
+    if (psf === null) {
+      throw new Error("Invalid psf in AFSpecial_Keystroke");
+    }
+
+    let formatStr;
+
+    switch (psf) {
+      case 0:
+        formatStr = "99999";
+        break;
+
+      case 1:
+        formatStr = "99999-9999";
+        break;
+
+      case 2:
+        const finalLen = event.value.length + event.change.length + event.selStart - event.selEnd;
+
+        if (finalLen >= 8) {
+          formatStr = "(999) 999-9999";
+        } else {
+          formatStr = "999-9999";
+        }
+
+        break;
+
+      case 3:
+        formatStr = "999-99-9999";
+        break;
+
+      default:
+        throw new Error("Invalid psf in AFSpecial_Keystroke");
+    }
+
+    this.AFSpecial_KeystrokeEx(formatStr);
+  }
+
+  AFTime_FormatEx(cFormat) {
+    this.AFDate_FormatEx(cFormat);
+  }
+
+  AFTime_Format(pdf) {
+    if (pdf >= 0 && pdf < this._timeFormats.length) {
+      this.AFDate_FormatEx(this._timeFormats[pdf]);
+    }
+  }
+
+  AFTime_KeystrokeEx(cFormat) {
+    this.AFDate_KeystrokeEx(cFormat);
+  }
+
+  AFTime_Keystroke(pdf) {
+    if (pdf >= 0 && pdf < this._timeFormats.length) {
+      this.AFDate_KeystrokeEx(this._timeFormats[pdf]);
+    }
+  }
+
+  eMailValidate(str) {
+    return this._emailRegex.test(str);
+  }
+
+}
+
+exports.AForm = AForm;
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.App = void 0;
+
+var _color = __w_pdfjs_require__(4);
+
+var _event = __w_pdfjs_require__(10);
+
+var _fullscreen = __w_pdfjs_require__(11);
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+var _thermometer = __w_pdfjs_require__(12);
+
+const VIEWER_TYPE = "PDF.js";
+const VIEWER_VARIATION = "Full";
+const VIEWER_VERSION = "10.0";
+const FORMS_VERSION = undefined;
+
+class App extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this.calculate = true;
+    this._constants = null;
+    this._focusRect = true;
+    this._fs = null;
+    this._language = App._getLanguage(data.language);
+    this._openInPlace = false;
+    this._platform = App._getPlatform(data.platform);
+    this._runtimeHighlight = false;
+    this._runtimeHighlightColor = ["T"];
+    this._thermometer = null;
+    this._toolbar = false;
+    this._document = data._document;
+    this._proxyHandler = data.proxyHandler;
+    this._objects = Object.create(null);
+    this._eventDispatcher = new _event.EventDispatcher(this._document, data.calculationOrder, this._objects);
+    this._timeoutIds = new WeakMap();
+
+    if (typeof FinalizationRegistry !== "undefined") {
+      this._timeoutIdsRegistry = new FinalizationRegistry(this._cleanTimeout.bind(this));
+    } else {
+      this._timeoutIdsRegistry = null;
+    }
+
+    this._timeoutCallbackIds = new Map();
+    this._timeoutCallbackId = 0;
+    this._globalEval = data.globalEval;
+    this._externalCall = data.externalCall;
+  }
+
+  _dispatchEvent(pdfEvent) {
+    this._eventDispatcher.dispatch(pdfEvent);
+  }
+
+  _registerTimeoutCallback(cExpr) {
+    const id = this._timeoutCallbackId++;
+
+    this._timeoutCallbackIds.set(id, cExpr);
+
+    return id;
+  }
+
+  _unregisterTimeoutCallback(id) {
+    this._timeoutCallbackIds.delete(id);
+  }
+
+  _evalCallback({
+    callbackId,
+    interval
+  }) {
+    const expr = this._timeoutCallbackIds.get(callbackId);
+
+    if (!interval) {
+      this._unregisterTimeoutCallback(callbackId);
+    }
+
+    if (expr) {
+      this._globalEval(expr);
+    }
+  }
+
+  _registerTimeout(callbackId, interval) {
+    const timeout = Object.create(null);
+    const id = {
+      callbackId,
+      interval
+    };
+
+    this._timeoutIds.set(timeout, id);
+
+    if (this._timeoutIdsRegistry) {
+      this._timeoutIdsRegistry.register(timeout, id);
+    }
+
+    return timeout;
+  }
+
+  _unregisterTimeout(timeout) {
+    if (this._timeoutIdsRegistry) {
+      this._timeoutIdsRegistry.unregister(timeout);
+    }
+
+    const data = this._timeoutIds.get(timeout);
+
+    if (!data) {
+      return;
+    }
+
+    this._timeoutIds.delete(timeout);
+
+    this._cleanTimeout(data);
+  }
+
+  _cleanTimeout({
+    callbackId,
+    interval
+  }) {
+    this._unregisterTimeoutCallback(callbackId);
+
+    if (interval) {
+      this._externalCall("clearInterval", [callbackId]);
+    } else {
+      this._externalCall("clearTimeout", [callbackId]);
+    }
+  }
+
+  static _getPlatform(platform) {
+    if (typeof platform === "string") {
+      platform = platform.toLowerCase();
+
+      if (platform.includes("win")) {
+        return "WIN";
+      } else if (platform.includes("mac")) {
+        return "MAC";
+      }
+    }
+
+    return "UNIX";
+  }
+
+  static _getLanguage(language) {
+    const [main, sub] = language.toLowerCase().split(/[-_]/);
+
+    switch (main) {
+      case "zh":
+        if (sub === "cn" || sub === "sg") {
+          return "CHS";
+        }
+
+        return "CHT";
+
+      case "da":
+        return "DAN";
+
+      case "de":
+        return "DEU";
+
+      case "es":
+        return "ESP";
+
+      case "fr":
+        return "FRA";
+
+      case "it":
+        return "ITA";
+
+      case "ko":
+        return "KOR";
+
+      case "ja":
+        return "JPN";
+
+      case "nl":
+        return "NLD";
+
+      case "no":
+        return "NOR";
+
+      case "pt":
+        if (sub === "br") {
+          return "PTB";
+        }
+
+        return "ENU";
+
+      case "fi":
+        return "SUO";
+
+      case "SV":
+        return "SVE";
+
+      default:
+        return "ENU";
+    }
+  }
+
+  get activeDocs() {
+    return [this._document.wrapped];
+  }
+
+  set activeDocs(_) {
+    throw new Error("app.activeDocs is read-only");
+  }
+
+  get constants() {
+    if (!this._constants) {
+      this._constants = Object.freeze({
+        align: Object.freeze({
+          left: 0,
+          center: 1,
+          right: 2,
+          top: 3,
+          bottom: 4
+        })
+      });
+    }
+
+    return this._constants;
+  }
+
+  set constants(_) {
+    throw new Error("app.constants is read-only");
+  }
+
+  get focusRect() {
+    return this._focusRect;
+  }
+
+  set focusRect(val) {
+    this._focusRect = val;
+  }
+
+  get formsVersion() {
+    return FORMS_VERSION;
+  }
+
+  set formsVersion(_) {
+    throw new Error("app.formsVersion is read-only");
+  }
+
+  get fromPDFConverters() {
+    return [];
+  }
+
+  set fromPDFConverters(_) {
+    throw new Error("app.fromPDFConverters is read-only");
+  }
+
+  get fs() {
+    if (this._fs === null) {
+      this._fs = new Proxy(new _fullscreen.FullScreen({
+        send: this._send
+      }), this._proxyHandler);
+    }
+
+    return this._fs;
+  }
+
+  set fs(_) {
+    throw new Error("app.fs is read-only");
+  }
+
+  get language() {
+    return this._language;
+  }
+
+  set language(_) {
+    throw new Error("app.language is read-only");
+  }
+
+  get media() {
+    return undefined;
+  }
+
+  set media(_) {
+    throw new Error("app.media is read-only");
+  }
+
+  get monitors() {
+    return [];
+  }
+
+  set monitors(_) {
+    throw new Error("app.monitors is read-only");
+  }
+
+  get numPlugins() {
+    return 0;
+  }
+
+  set numPlugins(_) {
+    throw new Error("app.numPlugins is read-only");
+  }
+
+  get openInPlace() {
+    return this._openInPlace;
+  }
+
+  set openInPlace(val) {
+    this._openInPlace = val;
+  }
+
+  get platform() {
+    return this._platform;
+  }
+
+  set platform(_) {
+    throw new Error("app.platform is read-only");
+  }
+
+  get plugins() {
+    return [];
+  }
+
+  set plugins(_) {
+    throw new Error("app.plugins is read-only");
+  }
+
+  get printColorProfiles() {
+    return [];
+  }
+
+  set printColorProfiles(_) {
+    throw new Error("app.printColorProfiles is read-only");
+  }
+
+  get printerNames() {
+    return [];
+  }
+
+  set printerNames(_) {
+    throw new Error("app.printerNames is read-only");
+  }
+
+  get runtimeHighlight() {
+    return this._runtimeHighlight;
+  }
+
+  set runtimeHighlight(val) {
+    this._runtimeHighlight = val;
+  }
+
+  get runtimeHighlightColor() {
+    return this._runtimeHighlightColor;
+  }
+
+  set runtimeHighlightColor(val) {
+    if (_color.Color._isValidColor(val)) {
+      this._runtimeHighlightColor = val;
+    }
+  }
+
+  get thermometer() {
+    if (this._thermometer === null) {
+      this._thermometer = new Proxy(new _thermometer.Thermometer({
+        send: this._send
+      }), this._proxyHandler);
+    }
+
+    return this._thermometer;
+  }
+
+  set thermometer(_) {
+    throw new Error("app.thermometer is read-only");
+  }
+
+  get toolbar() {
+    return this._toolbar;
+  }
+
+  set toolbar(val) {
+    this._toolbar = val;
+  }
+
+  get toolbarHorizontal() {
+    return this.toolbar;
+  }
+
+  set toolbarHorizontal(value) {
+    this.toolbar = value;
+  }
+
+  get toolbarVertical() {
+    return this.toolbar;
+  }
+
+  set toolbarVertical(value) {
+    this.toolbar = value;
+  }
+
+  get viewerType() {
+    return VIEWER_TYPE;
+  }
+
+  set viewerType(_) {
+    throw new Error("app.viewerType is read-only");
+  }
+
+  get viewerVariation() {
+    return VIEWER_VARIATION;
+  }
+
+  set viewerVariation(_) {
+    throw new Error("app.viewerVariation is read-only");
+  }
+
+  get viewerVersion() {
+    return VIEWER_VERSION;
+  }
+
+  set viewerVersion(_) {
+    throw new Error("app.viewerVersion is read-only");
+  }
+
+  addMenuItem() {}
+
+  addSubMenu() {}
+
+  addToolButton() {}
+
+  alert(cMsg, nIcon = 0, nType = 0, cTitle = "PDF.js", oDoc = null, oCheckbox = null) {
+    this._externalCall("alert", [cMsg]);
+  }
+
+  beep() {}
+
+  beginPriv() {}
+
+  browseForDoc() {}
+
+  clearInterval(oInterval) {
+    this._unregisterTimeout(oInterval);
+  }
+
+  clearTimeOut(oTime) {
+    this._unregisterTimeout(oTime);
+  }
+
+  endPriv() {}
+
+  execDialog() {}
+
+  execMenuItem() {}
+
+  getNthPlugInName() {}
+
+  getPath() {}
+
+  goBack() {}
+
+  goForward() {}
+
+  hideMenuItem() {}
+
+  hideToolbarButton() {}
+
+  launchURL() {}
+
+  listMenuItems() {}
+
+  listToolbarButtons() {}
+
+  loadPolicyFile() {}
+
+  mailGetAddrs() {}
+
+  mailMsg() {}
+
+  newDoc() {}
+
+  newCollection() {}
+
+  newFDF() {}
+
+  openDoc() {}
+
+  openFDF() {}
+
+  popUpMenu() {}
+
+  popUpMenuEx() {}
+
+  removeToolButton() {}
+
+  response(cQuestion, cTitle = "", cDefault = "", bPassword = "", cLabel = "") {
+    return this._externalCall("prompt", [cQuestion, cDefault || ""]);
+  }
+
+  setInterval(cExpr, nMilliseconds) {
+    if (typeof cExpr !== "string") {
+      throw new TypeError("First argument of app.setInterval must be a string");
+    }
+
+    if (typeof nMilliseconds !== "number") {
+      throw new TypeError("Second argument of app.setInterval must be a number");
+    }
+
+    const callbackId = this._registerTimeoutCallback(cExpr);
+
+    this._externalCall("setInterval", [callbackId, nMilliseconds]);
+
+    return this._registerTimeout(callbackId, true);
+  }
+
+  setTimeOut(cExpr, nMilliseconds) {
+    if (typeof cExpr !== "string") {
+      throw new TypeError("First argument of app.setTimeOut must be a string");
+    }
+
+    if (typeof nMilliseconds !== "number") {
+      throw new TypeError("Second argument of app.setTimeOut must be a number");
+    }
+
+    const callbackId = this._registerTimeoutCallback(cExpr);
+
+    this._externalCall("setTimeout", [callbackId, nMilliseconds]);
+
+    return this._registerTimeout(callbackId, false);
+  }
+
+  trustedFunction() {}
+
+  trustPropagatorFunction() {}
+
+}
+
+exports.App = App;
+
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.EventDispatcher = exports.Event = void 0;
+
+class Event {
+  constructor(data) {
+    this.change = data.change || "";
+    this.changeEx = data.changeEx || null;
+    this.commitKey = data.commitKey || 0;
+    this.fieldFull = data.fieldFull || false;
+    this.keyDown = data.keyDown || false;
+    this.modifier = data.modifier || false;
+    this.name = data.name;
+    this.rc = true;
+    this.richChange = data.richChange || [];
+    this.richChangeEx = data.richChangeEx || [];
+    this.richValue = data.richValue || [];
+    this.selEnd = data.selEnd || -1;
+    this.selStart = data.selStart || -1;
+    this.shift = data.shift || false;
+    this.source = data.source || null;
+    this.target = data.target || null;
+    this.targetName = "";
+    this.type = "Field";
+    this.value = data.value || "";
+    this.willCommit = data.willCommit || false;
+  }
+
+}
+
+exports.Event = Event;
+
+class EventDispatcher {
+  constructor(document, calculationOrder, objects) {
+    this._document = document;
+    this._calculationOrder = calculationOrder;
+    this._objects = objects;
+    this._document.obj._eventDispatcher = this;
+  }
+
+  mergeChange(event) {
+    let value = event.value;
+
+    if (typeof value !== "string") {
+      value = value.toString();
+    }
+
+    const prefix = event.selStart >= 0 ? value.substring(0, event.selStart) : "";
+    const postfix = event.selEnd >= 0 && event.selEnd <= value.length ? value.substring(event.selEnd) : "";
+    return `${prefix}${event.change}${postfix}`;
+  }
+
+  dispatch(baseEvent) {
+    const id = baseEvent.id;
+
+    if (!(id in this._objects)) {
+      let event;
+
+      if (id === "doc" || id === "page") {
+        event = globalThis.event = new Event(baseEvent);
+        event.source = event.target = this._document.wrapped;
+        event.name = baseEvent.name;
+      }
+
+      if (id === "doc") {
+        this._document.obj._dispatchDocEvent(event.name);
+      } else if (id === "page") {
+        this._document.obj._dispatchPageEvent(event.name, baseEvent.actions, baseEvent.pageNumber);
+      }
+
+      return;
+    }
+
+    const name = baseEvent.name.replace(" ", "");
+    const source = this._objects[id];
+    const event = globalThis.event = new Event(baseEvent);
+    let savedChange;
+
+    if (source.obj._isButton()) {
+      source.obj._id = id;
+      event.value = source.obj._getExportValue(event.value);
+
+      if (name === "Action") {
+        source.obj._value = event.value;
+      }
+    }
+
+    if (name === "Keystroke") {
+      savedChange = {
+        value: event.value,
+        change: event.change,
+        selStart: event.selStart,
+        selEnd: event.selEnd
+      };
+    } else if (name === "Blur" || name === "Focus") {
+      Object.defineProperty(event, "value", {
+        configurable: false,
+        writable: false,
+        enumerable: true,
+        value: event.value
+      });
+    } else if (name === "Validate") {
+      this.runValidation(source, event);
+      return;
+    }
+
+    this.runActions(source, source, event, name);
+
+    if (name === "Keystroke") {
+      if (event.rc) {
+        if (event.willCommit) {
+          this.runValidation(source, event);
+        } else if (event.change !== savedChange.change || event.selStart !== savedChange.selStart || event.selEnd !== savedChange.selEnd) {
+          source.wrapped.value = this.mergeChange(event);
+        }
+      } else if (!event.willCommit) {
+        source.obj._send({
+          id: source.obj._id,
+          value: savedChange.value,
+          selRange: [savedChange.selStart, savedChange.selEnd]
+        });
+      }
+    }
+  }
+
+  runValidation(source, event) {
+    const hasRan = this.runActions(source, source, event, "Validate");
+
+    if (event.rc) {
+      if (hasRan) {
+        source.wrapped.value = event.value;
+      } else {
+        source.obj.value = event.value;
+      }
+
+      if (this._document.obj.calculate) {
+        this.runCalculate(source, event);
+      }
+
+      event.value = source.obj.value;
+      this.runActions(source, source, event, "Format");
+      source.wrapped.valueAsString = event.value;
+    }
+  }
+
+  runActions(source, target, event, eventName) {
+    event.source = source.wrapped;
+    event.target = target.wrapped;
+    event.name = eventName;
+    event.targetName = target.obj.name;
+    event.rc = true;
+    return target.obj._runActions(event);
+  }
+
+  calculateNow() {
+    if (!this._calculationOrder) {
+      return;
+    }
+
+    const first = this._calculationOrder[0];
+    const source = this._objects[first];
+    globalThis.event = new Event({});
+    this.runCalculate(source, globalThis.event);
+  }
+
+  runCalculate(source, event) {
+    if (!this._calculationOrder) {
+      return;
+    }
+
+    for (const targetId of this._calculationOrder) {
+      if (!(targetId in this._objects)) {
+        continue;
+      }
+
+      const target = this._objects[targetId];
+      this.runActions(source, target, event, "Calculate");
+      this.runActions(target, target, event, "Validate");
+
+      if (!event.rc) {
+        continue;
+      }
+
+      target.wrapped.value = event.value;
+      this.runActions(target, target, event, "Format");
+      target.wrapped.valueAsString = event.value;
+    }
+  }
+
+}
+
+exports.EventDispatcher = EventDispatcher;
+
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.FullScreen = void 0;
+
+var _constants = __w_pdfjs_require__(2);
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class FullScreen extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this._backgroundColor = [];
+    this._clickAdvances = true;
+    this._cursor = _constants.Cursor.hidden;
+    this._defaultTransition = "";
+    this._escapeExits = true;
+    this._isFullScreen = true;
+    this._loop = false;
+    this._timeDelay = 3600;
+    this._usePageTiming = false;
+    this._useTimer = false;
+  }
+
+  get backgroundColor() {
+    return this._backgroundColor;
+  }
+
+  set backgroundColor(_) {}
+
+  get clickAdvances() {
+    return this._clickAdvances;
+  }
+
+  set clickAdvances(_) {}
+
+  get cursor() {
+    return this._cursor;
+  }
+
+  set cursor(_) {}
+
+  get defaultTransition() {
+    return this._defaultTransition;
+  }
+
+  set defaultTransition(_) {}
+
+  get escapeExits() {
+    return this._escapeExits;
+  }
+
+  set escapeExits(_) {}
+
+  get isFullScreen() {
+    return this._isFullScreen;
+  }
+
+  set isFullScreen(_) {}
+
+  get loop() {
+    return this._loop;
+  }
+
+  set loop(_) {}
+
+  get timeDelay() {
+    return this._timeDelay;
+  }
+
+  set timeDelay(_) {}
+
+  get transitions() {
+    return ["Replace", "WipeRight", "WipeLeft", "WipeDown", "WipeUp", "SplitHorizontalIn", "SplitHorizontalOut", "SplitVerticalIn", "SplitVerticalOut", "BlindsHorizontal", "BlindsVertical", "BoxIn", "BoxOut", "GlitterRight", "GlitterDown", "GlitterRightDown", "Dissolve", "Random"];
+  }
+
+  set transitions(_) {
+    throw new Error("fullscreen.transitions is read-only");
+  }
+
+  get usePageTiming() {
+    return this._usePageTiming;
+  }
+
+  set usePageTiming(_) {}
+
+  get useTimer() {
+    return this._useTimer;
+  }
+
+  set useTimer(_) {}
+
+}
+
+exports.FullScreen = FullScreen;
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Thermometer = void 0;
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class Thermometer extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this._cancelled = false;
+    this._duration = 100;
+    this._text = "";
+    this._value = 0;
+  }
+
+  get cancelled() {
+    return this._cancelled;
+  }
+
+  set cancelled(_) {
+    throw new Error("thermometer.cancelled is read-only");
+  }
+
+  get duration() {
+    return this._duration;
+  }
+
+  set duration(val) {
+    this._duration = val;
+  }
+
+  get text() {
+    return this._text;
+  }
+
+  set text(val) {
+    this._text = val;
+  }
+
+  get value() {
+    return this._value;
+  }
+
+  set value(val) {
+    this._value = val;
+  }
+
+  begin() {}
+
+  end() {}
+
+}
+
+exports.Thermometer = Thermometer;
+
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Console = void 0;
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class Console extends _pdf_object.PDFObject {
+  clear() {
+    this._send({
+      id: "clear"
+    });
+  }
+
+  hide() {}
+
+  println(msg) {
+    if (typeof msg === "string") {
+      this._send({
+        command: "println",
+        value: "PDF.js Console:: " + msg
+      });
+    }
+  }
+
+  show() {}
+
+}
+
+exports.Console = Console;
+
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Doc = void 0;
+
+var _common = __w_pdfjs_require__(7);
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+var _print_params = __w_pdfjs_require__(15);
+
+var _constants = __w_pdfjs_require__(2);
+
+class InfoProxyHandler {
+  static get(obj, prop) {
+    return obj[prop.toLowerCase()];
+  }
+
+  static set(obj, prop, value) {
+    throw new Error(`doc.info.${prop} is read-only`);
+  }
+
+}
+
+class Doc extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this._expandos = globalThis;
+    this._baseURL = data.baseURL || "";
+    this._calculate = true;
+    this._delay = false;
+    this._dirty = false;
+    this._disclosed = false;
+    this._media = undefined;
+    this._metadata = data.metadata;
+    this._noautocomplete = undefined;
+    this._nocache = undefined;
+    this._spellDictionaryOrder = [];
+    this._spellLanguageOrder = [];
+    this._printParams = null;
+    this._fields = new Map();
+    this._fieldNames = [];
+    this._event = null;
+    this._author = data.Author || "";
+    this._creator = data.Creator || "";
+    this._creationDate = this._getDate(data.CreationDate) || null;
+    this._docID = data.docID || ["", ""];
+    this._documentFileName = data.filename || "";
+    this._filesize = data.filesize || 0;
+    this._keywords = data.Keywords || "";
+    this._layout = data.layout || "";
+    this._modDate = this._getDate(data.ModDate) || null;
+    this._numFields = 0;
+    this._numPages = data.numPages || 1;
+    this._pageNum = data.pageNum || 0;
+    this._producer = data.Producer || "";
+    this._subject = data.Subject || "";
+    this._title = data.Title || "";
+    this._URL = data.URL || "";
+    this._info = new Proxy({
+      title: this.title,
+      author: this.author,
+      subject: this.subject,
+      keywords: this.keywords,
+      creator: this.creator,
+      producer: this.producer,
+      creationdate: this._creationDate,
+      moddate: this._modDate,
+      trapped: data.Trapped || "Unknown"
+    }, InfoProxyHandler);
+    this._zoomType = _constants.ZoomType.none;
+    this._zoom = data.zoom || 100;
+    this._actions = (0, _common.createActionsMap)(data.actions);
+    this._globalEval = data.globalEval;
+    this._pageActions = new Map();
+  }
+
+  _dispatchDocEvent(name) {
+    if (name === "Open") {
+      const dontRun = new Set(["WillClose", "WillSave", "DidSave", "WillPrint", "DidPrint", "OpenAction"]);
+
+      for (const actionName of this._actions.keys()) {
+        if (!dontRun.has(actionName)) {
+          this._runActions(actionName);
+        }
+      }
+
+      this._runActions("OpenAction");
+    } else {
+      this._runActions(name);
+    }
+  }
+
+  _dispatchPageEvent(name, actions, pageNumber) {
+    if (name === "PageOpen") {
+      if (!this._pageActions.has(pageNumber)) {
+        this._pageActions.set(pageNumber, (0, _common.createActionsMap)(actions));
+      }
+
+      this._pageNum = pageNumber - 1;
+    }
+
+    actions = this._pageActions.get(pageNumber)?.get(name);
+
+    if (actions) {
+      for (const action of actions) {
+        this._globalEval(action);
+      }
+    }
+  }
+
+  _runActions(name) {
+    const actions = this._actions.get(name);
+
+    if (actions) {
+      for (const action of actions) {
+        this._globalEval(action);
+      }
+    }
+  }
+
+  _addField(name, field) {
+    this._fields.set(name, field);
+
+    this._fieldNames.push(name);
+
+    this._numFields++;
+  }
+
+  _getDate(date) {
+    if (!date || date.length < 15 || !date.startsWith("D:")) {
+      return date;
+    }
+
+    date = date.substring(2);
+    const year = date.substring(0, 4);
+    const month = date.substring(4, 6);
+    const day = date.substring(6, 8);
+    const hour = date.substring(8, 10);
+    const minute = date.substring(10, 12);
+    const o = date.charAt(12);
+    let second, offsetPos;
+
+    if (o === "Z" || o === "+" || o === "-") {
+      second = "00";
+      offsetPos = 12;
+    } else {
+      second = date.substring(12, 14);
+      offsetPos = 14;
+    }
+
+    const offset = date.substring(offsetPos).replaceAll("'", "");
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}${offset}`);
+  }
+
+  get author() {
+    return this._author;
+  }
+
+  set author(_) {
+    throw new Error("doc.author is read-only");
+  }
+
+  get baseURL() {
+    return this._baseURL;
+  }
+
+  set baseURL(baseURL) {
+    this._baseURL = baseURL;
+  }
+
+  get bookmarkRoot() {
+    return undefined;
+  }
+
+  set bookmarkRoot(_) {
+    throw new Error("doc.bookmarkRoot is read-only");
+  }
+
+  get calculate() {
+    return this._calculate;
+  }
+
+  set calculate(calculate) {
+    this._calculate = calculate;
+  }
+
+  get creator() {
+    return this._creator;
+  }
+
+  set creator(_) {
+    throw new Error("doc.creator is read-only");
+  }
+
+  get dataObjects() {
+    return [];
+  }
+
+  set dataObjects(_) {
+    throw new Error("doc.dataObjects is read-only");
+  }
+
+  get delay() {
+    return this._delay;
+  }
+
+  set delay(delay) {
+    this._delay = delay;
+  }
+
+  get dirty() {
+    return this._dirty;
+  }
+
+  set dirty(dirty) {
+    this._dirty = dirty;
+  }
+
+  get disclosed() {
+    return this._disclosed;
+  }
+
+  set disclosed(disclosed) {
+    this._disclosed = disclosed;
+  }
+
+  get docID() {
+    return this._docID;
+  }
+
+  set docID(_) {
+    throw new Error("doc.docID is read-only");
+  }
+
+  get documentFileName() {
+    return this._documentFileName;
+  }
+
+  set documentFileName(_) {
+    throw new Error("doc.documentFileName is read-only");
+  }
+
+  get dynamicXFAForm() {
+    return false;
+  }
+
+  set dynamicXFAForm(_) {
+    throw new Error("doc.dynamicXFAForm is read-only");
+  }
+
+  get external() {
+    return true;
+  }
+
+  set external(_) {
+    throw new Error("doc.external is read-only");
+  }
+
+  get filesize() {
+    return this._filesize;
+  }
+
+  set filesize(_) {
+    throw new Error("doc.filesize is read-only");
+  }
+
+  get hidden() {
+    return false;
+  }
+
+  set hidden(_) {
+    throw new Error("doc.hidden is read-only");
+  }
+
+  get hostContainer() {
+    return undefined;
+  }
+
+  set hostContainer(_) {
+    throw new Error("doc.hostContainer is read-only");
+  }
+
+  get icons() {
+    return undefined;
+  }
+
+  set icons(_) {
+    throw new Error("doc.icons is read-only");
+  }
+
+  get info() {
+    return this._info;
+  }
+
+  set info(_) {
+    throw new Error("doc.info is read-only");
+  }
+
+  get innerAppWindowRect() {
+    return [0, 0, 0, 0];
+  }
+
+  set innerAppWindowRect(_) {
+    throw new Error("doc.innerAppWindowRect is read-only");
+  }
+
+  get innerDocWindowRect() {
+    return [0, 0, 0, 0];
+  }
+
+  set innerDocWindowRect(_) {
+    throw new Error("doc.innerDocWindowRect is read-only");
+  }
+
+  get isModal() {
+    return false;
+  }
+
+  set isModal(_) {
+    throw new Error("doc.isModal is read-only");
+  }
+
+  get keywords() {
+    return this._keywords;
+  }
+
+  set keywords(_) {
+    throw new Error("doc.keywords is read-only");
+  }
+
+  get layout() {
+    return this._layout;
+  }
+
+  set layout(value) {
+    if (typeof value !== "string") {
+      return;
+    }
+
+    if (value !== "SinglePage" && value !== "OneColumn" && value !== "TwoColumnLeft" && value !== "TwoPageLeft" && value !== "TwoColumnRight" && value !== "TwoPageRight") {
+      value = "SinglePage";
+    }
+
+    this._send({
+      command: "layout",
+      value
+    });
+
+    this._layout = value;
+  }
+
+  get media() {
+    return this._media;
+  }
+
+  set media(media) {
+    this._media = media;
+  }
+
+  get metadata() {
+    return this._metadata;
+  }
+
+  set metadata(metadata) {
+    this._metadata = metadata;
+  }
+
+  get modDate() {
+    return this._modDate;
+  }
+
+  set modDate(_) {
+    throw new Error("doc.modDate is read-only");
+  }
+
+  get mouseX() {
+    return 0;
+  }
+
+  set mouseX(_) {
+    throw new Error("doc.mouseX is read-only");
+  }
+
+  get mouseY() {
+    return 0;
+  }
+
+  set mouseY(_) {
+    throw new Error("doc.mouseY is read-only");
+  }
+
+  get noautocomplete() {
+    return this._noautocomplete;
+  }
+
+  set noautocomplete(noautocomplete) {
+    this._noautocomplete = noautocomplete;
+  }
+
+  get nocache() {
+    return this._nocache;
+  }
+
+  set nocache(nocache) {
+    this._nocache = nocache;
+  }
+
+  get numFields() {
+    return this._numFields;
+  }
+
+  set numFields(_) {
+    throw new Error("doc.numFields is read-only");
+  }
+
+  get numPages() {
+    return this._numPages;
+  }
+
+  set numPages(_) {
+    throw new Error("doc.numPages is read-only");
+  }
+
+  get numTemplates() {
+    return 0;
+  }
+
+  set numTemplates(_) {
+    throw new Error("doc.numTemplates is read-only");
+  }
+
+  get outerAppWindowRect() {
+    return [0, 0, 0, 0];
+  }
+
+  set outerAppWindowRect(_) {
+    throw new Error("doc.outerAppWindowRect is read-only");
+  }
+
+  get outerDocWindowRect() {
+    return [0, 0, 0, 0];
+  }
+
+  set outerDocWindowRect(_) {
+    throw new Error("doc.outerDocWindowRect is read-only");
+  }
+
+  get pageNum() {
+    return this._pageNum;
+  }
+
+  set pageNum(value) {
+    if (typeof value !== "number" || value < 0 || value >= this._numPages) {
+      return;
+    }
+
+    this._send({
+      command: "page-num",
+      value
+    });
+
+    this._pageNum = value;
+  }
+
+  get pageWindowRect() {
+    return [0, 0, 0, 0];
+  }
+
+  set pageWindowRect(_) {
+    throw new Error("doc.pageWindowRect is read-only");
+  }
+
+  get path() {
+    return "";
+  }
+
+  set path(_) {
+    throw new Error("doc.path is read-only");
+  }
+
+  get permStatusReady() {
+    return true;
+  }
+
+  set permStatusReady(_) {
+    throw new Error("doc.permStatusReady is read-only");
+  }
+
+  get producer() {
+    return this._producer;
+  }
+
+  set producer(_) {
+    throw new Error("doc.producer is read-only");
+  }
+
+  get requiresFullSave() {
+    return false;
+  }
+
+  set requiresFullSave(_) {
+    throw new Error("doc.requiresFullSave is read-only");
+  }
+
+  get securityHandler() {
+    return null;
+  }
+
+  set securityHandler(_) {
+    throw new Error("doc.securityHandler is read-only");
+  }
+
+  get selectedAnnots() {
+    return [];
+  }
+
+  set selectedAnnots(_) {
+    throw new Error("doc.selectedAnnots is read-only");
+  }
+
+  get sounds() {
+    return [];
+  }
+
+  set sounds(_) {
+    throw new Error("doc.sounds is read-only");
+  }
+
+  get spellDictionaryOrder() {
+    return this._spellDictionaryOrder;
+  }
+
+  set spellDictionaryOrder(spellDictionaryOrder) {
+    this._spellDictionaryOrder = spellDictionaryOrder;
+  }
+
+  get spellLanguageOrder() {
+    return this._spellLanguageOrder;
+  }
+
+  set spellLanguageOrder(spellLanguageOrder) {
+    this._spellLanguageOrder = spellLanguageOrder;
+  }
+
+  get subject() {
+    return this._subject;
+  }
+
+  set subject(_) {
+    throw new Error("doc.subject is read-only");
+  }
+
+  get templates() {
+    return [];
+  }
+
+  set templates(_) {
+    throw new Error("doc.templates is read-only");
+  }
+
+  get title() {
+    return this._title;
+  }
+
+  set title(_) {
+    throw new Error("doc.title is read-only");
+  }
+
+  get URL() {
+    return this._URL;
+  }
+
+  set URL(_) {
+    throw new Error("doc.URL is read-only");
+  }
+
+  get viewState() {
+    return undefined;
+  }
+
+  set viewState(_) {
+    throw new Error("doc.viewState is read-only");
+  }
+
+  get xfa() {
+    return this._xfa;
+  }
+
+  set xfa(_) {
+    throw new Error("doc.xfa is read-only");
+  }
+
+  get XFAForeground() {
+    return false;
+  }
+
+  set XFAForeground(_) {
+    throw new Error("doc.XFAForeground is read-only");
+  }
+
+  get zoomType() {
+    return this._zoomType;
+  }
+
+  set zoomType(type) {
+    if (typeof type !== "string") {
+      return;
+    }
+
+    switch (type) {
+      case _constants.ZoomType.none:
+        this._send({
+          command: "zoom",
+          value: 1
+        });
+
+        break;
+
+      case _constants.ZoomType.fitP:
+        this._send({
+          command: "zoom",
+          value: "page-fit"
+        });
+
+        break;
+
+      case _constants.ZoomType.fitW:
+        this._send({
+          command: "zoom",
+          value: "page-width"
+        });
+
+        break;
+
+      case _constants.ZoomType.fitH:
+        this._send({
+          command: "zoom",
+          value: "page-height"
+        });
+
+        break;
+
+      case _constants.ZoomType.fitV:
+        this._send({
+          command: "zoom",
+          value: "auto"
+        });
+
+        break;
+
+      case _constants.ZoomType.pref:
+      case _constants.ZoomType.refW:
+        break;
+
+      default:
+        return;
+    }
+
+    this._zoomType = type;
+  }
+
+  get zoom() {
+    return this._zoom;
+  }
+
+  set zoom(value) {
+    if (typeof value !== "number" || value < 8.33 || value > 6400) {
+      return;
+    }
+
+    this._send({
+      command: "zoom",
+      value: value / 100
+    });
+  }
+
+  addAnnot() {}
+
+  addField() {}
+
+  addIcon() {}
+
+  addLink() {}
+
+  addRecipientListCryptFilter() {}
+
+  addRequirement() {}
+
+  addScript() {}
+
+  addThumbnails() {}
+
+  addWatermarkFromFile() {}
+
+  addWatermarkFromText() {}
+
+  addWeblinks() {}
+
+  bringToFront() {}
+
+  calculateNow() {
+    this._eventDispatcher.calculateNow();
+  }
+
+  closeDoc() {}
+
+  colorConvertPage() {}
+
+  createDataObject() {}
+
+  createTemplate() {}
+
+  deletePages() {}
+
+  deleteSound() {}
+
+  embedDocAsDataObject() {}
+
+  embedOutputIntent() {}
+
+  encryptForRecipients() {}
+
+  encryptUsingPolicy() {}
+
+  exportAsFDF() {}
+
+  exportAsFDFStr() {}
+
+  exportAsText() {}
+
+  exportAsXFDF() {}
+
+  exportAsXFDFStr() {}
+
+  exportDataObject() {}
+
+  exportXFAData() {}
+
+  extractPages() {}
+
+  flattenPages() {}
+
+  getAnnot() {}
+
+  getAnnots() {}
+
+  getAnnot3D() {}
+
+  getAnnots3D() {}
+
+  getColorConvertAction() {}
+
+  getDataObject() {}
+
+  getDataObjectContents() {}
+
+  getField(cName) {
+    if (typeof cName !== "string") {
+      throw new TypeError("Invalid field name: must be a string");
+    }
+
+    const searchedField = this._fields.get(cName);
+
+    if (searchedField) {
+      return searchedField;
+    }
+
+    for (const [name, field] of this._fields.entries()) {
+      if (name.includes(cName)) {
+        return field;
+      }
+    }
+
+    return undefined;
+  }
+
+  getIcon() {}
+
+  getLegalWarnings() {}
+
+  getLinks() {}
+
+  getNthFieldName(nIndex) {
+    if (typeof nIndex !== "number") {
+      throw new TypeError("Invalid field index: must be a number");
+    }
+
+    if (0 <= nIndex && nIndex < this.numFields) {
+      return this._fieldNames[Math.trunc(nIndex)];
+    }
+
+    return null;
+  }
+
+  getNthTemplate() {
+    return null;
+  }
+
+  getOCGs() {}
+
+  getOCGOrder() {}
+
+  getPageBox() {}
+
+  getPageLabel() {}
+
+  getPageNthWord() {}
+
+  getPageNthWordQuads() {}
+
+  getPageNumWords() {}
+
+  getPageRotation() {}
+
+  getPageTransition() {}
+
+  getPrintParams() {
+    if (!this._printParams) {
+      this._printParams = new _print_params.PrintParams({
+        lastPage: this._numPages - 1
+      });
+    }
+
+    return this._printParams;
+  }
+
+  getSound() {}
+
+  getTemplate() {}
+
+  getURL() {}
+
+  gotoNamedDest() {}
+
+  importAnFDF() {}
+
+  importAnXFDF() {}
+
+  importDataObject() {}
+
+  importIcon() {}
+
+  importSound() {}
+
+  importTextData() {}
+
+  importXFAData() {}
+
+  insertPages() {}
+
+  mailDoc() {}
+
+  mailForm() {}
+
+  movePage() {}
+
+  newPage() {}
+
+  openDataObject() {}
+
+  print(bUI = true, nStart = 0, nEnd = -1, bSilent = false, bShrinkToFit = false, bPrintAsImage = false, bReverse = false, bAnnotations = true, printParams = null) {
+    if (printParams) {
+      nStart = printParams.firstPage;
+      nEnd = printParams.lastPage;
+    }
+
+    if (typeof nStart === "number") {
+      nStart = Math.max(0, Math.trunc(nStart));
+    } else {
+      nStart = 0;
+    }
+
+    if (typeof nEnd === "number") {
+      nEnd = Math.max(0, Math.trunc(nEnd));
+    } else {
+      nEnd = -1;
+    }
+
+    this._send({
+      command: "print",
+      start: nStart,
+      end: nEnd
+    });
+  }
+
+  removeDataObject() {}
+
+  removeField() {}
+
+  removeIcon() {}
+
+  removeLinks() {}
+
+  removeRequirement() {}
+
+  removeScript() {}
+
+  removeTemplate() {}
+
+  removeThumbnails() {}
+
+  removeWeblinks() {}
+
+  replacePages() {}
+
+  resetForm(aFields = null) {
+    let mustCalculate = false;
+
+    if (aFields) {
+      for (const fieldName of aFields) {
+        const field = this.getField(fieldName);
+
+        if (field) {
+          field.value = field.defaultValue;
+          field.valueAsString = field.value;
+          mustCalculate = true;
+        }
+      }
+    } else {
+      mustCalculate = this._fields.size !== 0;
+
+      for (const field of this._fields.values()) {
+        field.value = field.defaultValue;
+        field.valueAsString = field.value;
+      }
+    }
+
+    if (mustCalculate) {
+      this.calculateNow();
+    }
+  }
+
+  saveAs() {}
+
+  scroll() {}
+
+  selectPageNthWord() {}
+
+  setAction() {}
+
+  setDataObjectContents() {}
+
+  setOCGOrder() {}
+
+  setPageAction() {}
+
+  setPageBoxes() {}
+
+  setPageLabels() {}
+
+  setPageRotations() {}
+
+  setPageTabOrder() {}
+
+  setPageTransitions() {}
+
+  spawnPageFromTemplate() {}
+
+  submitForm() {}
+
+  syncAnnotScan() {}
+
+}
+
+exports.Doc = Doc;
+
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PrintParams = void 0;
+
+class PrintParams {
+  constructor(data) {
+    this.binaryOk = true;
+    this.bitmapDPI = 150;
+    this.booklet = {
+      binding: 0,
+      duplexMode: 0,
+      subsetFrom: 0,
+      subsetTo: -1
+    };
+    this.colorOverride = 0;
+    this.colorProfile = "";
+    this.constants = Object.freeze({
+      bookletBindings: Object.freeze({
+        Left: 0,
+        Right: 1,
+        LeftTall: 2,
+        RightTall: 3
+      }),
+      bookletDuplexMode: Object.freeze({
+        BothSides: 0,
+        FrontSideOnly: 1,
+        BasicSideOnly: 2
+      }),
+      colorOverrides: Object.freeze({
+        auto: 0,
+        gray: 1,
+        mono: 2
+      }),
+      fontPolicies: Object.freeze({
+        everyPage: 0,
+        jobStart: 1,
+        pageRange: 2
+      }),
+      handling: Object.freeze({
+        none: 0,
+        fit: 1,
+        shrink: 2,
+        tileAll: 3,
+        tileLarge: 4,
+        nUp: 5,
+        booklet: 6
+      }),
+      interactionLevel: Object.freeze({
+        automatic: 0,
+        full: 1,
+        silent: 2
+      }),
+      nUpPageOrders: Object.freeze({
+        Horizontal: 0,
+        HorizontalReversed: 1,
+        Vertical: 2
+      }),
+      printContents: Object.freeze({
+        doc: 0,
+        docAndComments: 1,
+        formFieldsOnly: 2
+      }),
+      flagValues: Object.freeze({
+        applyOverPrint: 1,
+        applySoftProofSettings: 1 << 1,
+        applyWorkingColorSpaces: 1 << 2,
+        emitHalftones: 1 << 3,
+        emitPostScriptXObjects: 1 << 4,
+        emitFormsAsPSForms: 1 << 5,
+        maxJP2KRes: 1 << 6,
+        setPageSize: 1 << 7,
+        suppressBG: 1 << 8,
+        suppressCenter: 1 << 9,
+        suppressCJKFontSubst: 1 << 10,
+        suppressCropClip: 1 << 1,
+        suppressRotate: 1 << 12,
+        suppressTransfer: 1 << 13,
+        suppressUCR: 1 << 14,
+        useTrapAnnots: 1 << 15,
+        usePrintersMarks: 1 << 16
+      }),
+      rasterFlagValues: Object.freeze({
+        textToOutline: 1,
+        strokesToOutline: 1 << 1,
+        allowComplexClip: 1 << 2,
+        preserveOverprint: 1 << 3
+      }),
+      subsets: Object.freeze({
+        all: 0,
+        even: 1,
+        odd: 2
+      }),
+      tileMarks: Object.freeze({
+        none: 0,
+        west: 1,
+        east: 2
+      }),
+      usages: Object.freeze({
+        auto: 0,
+        use: 1,
+        noUse: 2
+      })
+    });
+    this.downloadFarEastFonts = false;
+    this.fileName = "";
+    this.firstPage = 0;
+    this.flags = 0;
+    this.fontPolicy = 0;
+    this.gradientDPI = 150;
+    this.interactive = 1;
+    this.lastPage = data.lastPage;
+    this.npUpAutoRotate = false;
+    this.npUpNumPagesH = 2;
+    this.npUpNumPagesV = 2;
+    this.npUpPageBorder = false;
+    this.npUpPageOrder = 0;
+    this.pageHandling = 0;
+    this.pageSubset = 0;
+    this.printAsImage = false;
+    this.printContent = 0;
+    this.printerName = "";
+    this.psLevel = 0;
+    this.rasterFlags = 0;
+    this.reversePages = false;
+    this.tileLabel = false;
+    this.tileMark = 0;
+    this.tileOverlap = 0;
+    this.tileScale = 1.0;
+    this.transparencyLevel = 75;
+    this.usePrinterCRD = 0;
+    this.useT1Conversion = 0;
+  }
+
+}
+
+exports.PrintParams = PrintParams;
+
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ProxyHandler = void 0;
+
+class ProxyHandler {
+  get(obj, prop) {
+    if (prop in obj._expandos) {
+      const val = obj._expandos[prop];
+
+      if (typeof val === "function") {
+        return val.bind(obj);
+      }
+
+      return val;
+    }
+
+    if (typeof prop === "string" && !prop.startsWith("_") && prop in obj) {
+      const val = obj[prop];
+
+      if (typeof val === "function") {
+        return val.bind(obj);
+      }
+
+      return val;
+    }
+
+    return undefined;
+  }
+
+  set(obj, prop, value) {
+    if (typeof prop === "string" && !prop.startsWith("_") && prop in obj) {
+      const old = obj[prop];
+      obj[prop] = value;
+
+      if (obj._send && obj._id !== null && typeof old !== "function") {
+        const data = {
+          id: obj._id
+        };
+        data[prop] = obj[prop];
+
+        obj._send(data);
+      }
+    } else {
+      obj._expandos[prop] = value;
+    }
+
+    return true;
+  }
+
+  has(obj, prop) {
+    return prop in obj._expandos || typeof prop === "string" && !prop.startsWith("_") && prop in obj;
+  }
+
+  getPrototypeOf(obj) {
+    return null;
+  }
+
+  setPrototypeOf(obj, proto) {
+    return false;
+  }
+
+  isExtensible(obj) {
+    return true;
+  }
+
+  preventExtensions(obj) {
+    return false;
+  }
+
+  getOwnPropertyDescriptor(obj, prop) {
+    if (prop in obj._expandos) {
+      return {
+        configurable: true,
+        enumerable: true,
+        value: obj._expandos[prop]
+      };
+    }
+
+    if (typeof prop === "string" && !prop.startsWith("_") && prop in obj) {
+      return {
+        configurable: true,
+        enumerable: true,
+        value: obj[prop]
+      };
+    }
+
+    return undefined;
+  }
+
+  defineProperty(obj, key, descriptor) {
+    Object.defineProperty(obj._expandos, key, descriptor);
+    return true;
+  }
+
+  deleteProperty(obj, prop) {
+    if (prop in obj._expandos) {
+      delete obj._expandos[prop];
+    }
+  }
+
+  ownKeys(obj) {
+    const fromExpandos = Reflect.ownKeys(obj._expandos);
+    const fromObj = Reflect.ownKeys(obj).filter(k => !k.startsWith("_"));
+    return fromExpandos.concat(fromObj);
+  }
+
+}
+
+exports.ProxyHandler = ProxyHandler;
+
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Util = void 0;
+
+var _pdf_object = __w_pdfjs_require__(6);
+
+class Util extends _pdf_object.PDFObject {
+  constructor(data) {
+    super(data);
+    this._scandCache = new Map();
+    this._months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+    this._days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    this.MILLISECONDS_IN_DAY = 86400000;
+    this.MILLISECONDS_IN_WEEK = 604800000;
+    this._externalCall = data.externalCall;
+  }
+
+  printf(...args) {
+    if (args.length === 0) {
+      throw new Error("Invalid number of params in printf");
+    }
+
+    if (typeof args[0] !== "string") {
+      throw new TypeError("First argument of printf must be a string");
+    }
+
+    const pattern = /%(,[0-4])?([+ 0#]+)?([0-9]+)?(\.[0-9]+)?(.)/g;
+    const PLUS = 1;
+    const SPACE = 2;
+    const ZERO = 4;
+    const HASH = 8;
+    let i = 0;
+    return args[0].replace(pattern, function (match, nDecSep, cFlags, nWidth, nPrecision, cConvChar) {
+      if (cConvChar !== "d" && cConvChar !== "f" && cConvChar !== "s" && cConvChar !== "x") {
+        const buf = ["%"];
+
+        for (const str of [nDecSep, cFlags, nWidth, nPrecision, cConvChar]) {
+          if (str) {
+            buf.push(str);
+          }
+        }
+
+        return buf.join("");
+      }
+
+      i++;
+
+      if (i === args.length) {
+        throw new Error("Not enough arguments in printf");
+      }
+
+      const arg = args[i];
+
+      if (cConvChar === "s") {
+        return arg.toString();
+      }
+
+      let flags = 0;
+
+      if (cFlags) {
+        for (const flag of cFlags) {
+          switch (flag) {
+            case "+":
+              flags |= PLUS;
+              break;
+
+            case " ":
+              flags |= SPACE;
+              break;
+
+            case "0":
+              flags |= ZERO;
+              break;
+
+            case "#":
+              flags |= HASH;
+              break;
+          }
+        }
+      }
+
+      cFlags = flags;
+
+      if (nWidth) {
+        nWidth = parseInt(nWidth);
+      }
+
+      let intPart = Math.trunc(arg);
+
+      if (cConvChar === "x") {
+        let hex = Math.abs(intPart).toString(16).toUpperCase();
+
+        if (nWidth !== undefined) {
+          hex = hex.padStart(nWidth, cFlags & ZERO ? "0" : " ");
+        }
+
+        if (cFlags & HASH) {
+          hex = `0x${hex}`;
+        }
+
+        return hex;
+      }
+
+      if (nPrecision) {
+        nPrecision = parseInt(nPrecision.substring(1));
+      }
+
+      nDecSep = nDecSep ? nDecSep.substring(1) : "0";
+      const separators = {
+        0: [",", "."],
+        1: ["", "."],
+        2: [".", ","],
+        3: ["", ","],
+        4: ["'", "."]
+      };
+      const [thousandSep, decimalSep] = separators[nDecSep];
+      let decPart = "";
+
+      if (cConvChar === "f") {
+        if (nPrecision !== undefined) {
+          decPart = Math.abs(arg - intPart).toFixed(nPrecision);
+        } else {
+          decPart = Math.abs(arg - intPart).toString();
+        }
+
+        if (decPart.length > 2) {
+          decPart = `${decimalSep}${decPart.substring(2)}`;
+        } else if (cFlags & HASH) {
+          decPart = ".";
+        } else {
+          decPart = "";
+        }
+      }
+
+      let sign = "";
+
+      if (intPart < 0) {
+        sign = "-";
+        intPart = -intPart;
+      } else if (cFlags & PLUS) {
+        sign = "+";
+      } else if (cFlags & SPACE) {
+        sign = " ";
+      }
+
+      if (thousandSep && intPart >= 1000) {
+        const buf = [];
+
+        while (true) {
+          buf.push((intPart % 1000).toString().padStart(3, "0"));
+          intPart = Math.trunc(intPart / 1000);
+
+          if (intPart < 1000) {
+            buf.push(intPart.toString());
+            break;
+          }
+        }
+
+        intPart = buf.reverse().join(thousandSep);
+      } else {
+        intPart = intPart.toString();
+      }
+
+      let n = `${intPart}${decPart}`;
+
+      if (nWidth !== undefined) {
+        n = n.padStart(nWidth - sign.length, cFlags & ZERO ? "0" : " ");
+      }
+
+      return `${sign}${n}`;
+    });
+  }
+
+  iconStreamFromIcon() {}
+
+  printd(cFormat, oDate) {
+    switch (cFormat) {
+      case 0:
+        return this.printd("D:yyyymmddHHMMss", oDate);
+
+      case 1:
+        return this.printd("yyyy.mm.dd HH:MM:ss", oDate);
+
+      case 2:
+        return this.printd("m/d/yy h:MM:ss tt", oDate);
+    }
+
+    const handlers = {
+      mmmm: data => {
+        return this._months[data.month];
+      },
+      mmm: data => {
+        return this._months[data.month].substring(0, 3);
+      },
+      mm: data => {
+        return (data.month + 1).toString().padStart(2, "0");
+      },
+      m: data => {
+        return (data.month + 1).toString();
+      },
+      dddd: data => {
+        return this._days[data.dayOfWeek];
+      },
+      ddd: data => {
+        return this._days[data.dayOfWeek].substring(0, 3);
+      },
+      dd: data => {
+        return data.day.toString().padStart(2, "0");
+      },
+      d: data => {
+        return data.day.toString();
+      },
+      yyyy: data => {
+        return data.year.toString();
+      },
+      yy: data => {
+        return (data.year % 100).toString().padStart(2, "0");
+      },
+      HH: data => {
+        return data.hours.toString().padStart(2, "0");
+      },
+      H: data => {
+        return data.hours.toString();
+      },
+      hh: data => {
+        return (1 + (data.hours + 11) % 12).toString().padStart(2, "0");
+      },
+      h: data => {
+        return (1 + (data.hours + 11) % 12).toString();
+      },
+      MM: data => {
+        return data.minutes.toString().padStart(2, "0");
+      },
+      M: data => {
+        return data.minutes.toString();
+      },
+      ss: data => {
+        return data.seconds.toString().padStart(2, "0");
+      },
+      s: data => {
+        return data.seconds.toString();
+      },
+      tt: data => {
+        return data.hours < 12 ? "am" : "pm";
+      },
+      t: data => {
+        return data.hours < 12 ? "a" : "p";
+      }
+    };
+    const data = {
+      year: oDate.getFullYear(),
+      month: oDate.getMonth(),
+      day: oDate.getDate(),
+      dayOfWeek: oDate.getDay(),
+      hours: oDate.getHours(),
+      minutes: oDate.getMinutes(),
+      seconds: oDate.getSeconds()
+    };
+    const patterns = /(mmmm|mmm|mm|m|dddd|ddd|dd|d|yyyy|yy|HH|H|hh|h|MM|M|ss|s|tt|t|\\.)/g;
+    return cFormat.replace(patterns, function (match, pattern) {
+      if (pattern in handlers) {
+        return handlers[pattern](data);
+      }
+
+      return pattern.charCodeAt(1);
+    });
+  }
+
+  printx(cFormat, cSource) {
+    const handlers = [x => x, x => x.toUpperCase(), x => x.toLowerCase()];
+    const buf = [];
+    let i = 0;
+    const ii = cSource.length;
+    let currCase = handlers[0];
+    let escaped = false;
+
+    for (const command of cFormat) {
+      if (escaped) {
+        buf.push(command);
+        escaped = false;
+        continue;
+      }
+
+      if (i >= ii) {
+        break;
+      }
+
+      switch (command) {
+        case "?":
+          buf.push(currCase(cSource.charAt(i++)));
+          break;
+
+        case "X":
+          while (i < ii) {
+            const char = cSource.charAt(i++);
+
+            if ("a" <= char && char <= "z" || "A" <= char && char <= "Z" || "0" <= char && char <= "9") {
+              buf.push(currCase(char));
+              break;
+            }
+          }
+
+          break;
+
+        case "A":
+          while (i < ii) {
+            const char = cSource.charAt(i++);
+
+            if ("a" <= char && char <= "z" || "A" <= char && char <= "Z") {
+              buf.push(currCase(char));
+              break;
+            }
+          }
+
+          break;
+
+        case "9":
+          while (i < ii) {
+            const char = cSource.charAt(i++);
+
+            if ("0" <= char && char <= "9") {
+              buf.push(char);
+              break;
+            }
+          }
+
+          break;
+
+        case "*":
+          while (i < ii) {
+            buf.push(currCase(cSource.charAt(i++)));
+          }
+
+          break;
+
+        case "\\":
+          escaped = true;
+          break;
+
+        case ">":
+          currCase = handlers[1];
+          break;
+
+        case "<":
+          currCase = handlers[2];
+          break;
+
+        case "=":
+          currCase = handlers[0];
+          break;
+
+        default:
+          buf.push(command);
+      }
+    }
+
+    return buf.join("");
+  }
+
+  scand(cFormat, cDate) {
+    switch (cFormat) {
+      case 0:
+        return this.scand("D:yyyymmddHHMMss", cDate);
+
+      case 1:
+        return this.scand("yyyy.mm.dd HH:MM:ss", cDate);
+
+      case 2:
+        return this.scand("m/d/yy h:MM:ss tt", cDate);
+    }
+
+    if (!this._scandCache.has(cFormat)) {
+      const months = this._months;
+      const days = this._days;
+      const handlers = {
+        mmmm: {
+          pattern: `(${months.join("|")})`,
+          action: (value, data) => {
+            data.month = months.indexOf(value);
+          }
+        },
+        mmm: {
+          pattern: `(${months.map(month => month.substring(0, 3)).join("|")})`,
+          action: (value, data) => {
+            data.month = months.findIndex(month => month.substring(0, 3) === value);
+          }
+        },
+        mm: {
+          pattern: `([0-9]{2})`,
+          action: (value, data) => {
+            data.month = parseInt(value) - 1;
+          }
+        },
+        m: {
+          pattern: `([0-9]{1,2})`,
+          action: (value, data) => {
+            data.month = parseInt(value) - 1;
+          }
+        },
+        dddd: {
+          pattern: `(${days.join("|")})`,
+          action: (value, data) => {
+            data.day = days.indexOf(value);
+          }
+        },
+        ddd: {
+          pattern: `(${days.map(day => day.substring(0, 3)).join("|")})`,
+          action: (value, data) => {
+            data.day = days.findIndex(day => day.substring(0, 3) === value);
+          }
+        },
+        dd: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.day = parseInt(value);
+          }
+        },
+        d: {
+          pattern: "([0-9]{1,2})",
+          action: (value, data) => {
+            data.day = parseInt(value);
+          }
+        },
+        yyyy: {
+          pattern: "([0-9]{4})",
+          action: (value, data) => {
+            data.year = parseInt(value);
+          }
+        },
+        yy: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.year = 2000 + parseInt(value);
+          }
+        },
+        HH: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.hours = parseInt(value);
+          }
+        },
+        H: {
+          pattern: "([0-9]{1,2})",
+          action: (value, data) => {
+            data.hours = parseInt(value);
+          }
+        },
+        hh: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.hours = parseInt(value);
+          }
+        },
+        h: {
+          pattern: "([0-9]{1,2})",
+          action: (value, data) => {
+            data.hours = parseInt(value);
+          }
+        },
+        MM: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.minutes = parseInt(value);
+          }
+        },
+        M: {
+          pattern: "([0-9]{1,2})",
+          action: (value, data) => {
+            data.minutes = parseInt(value);
+          }
+        },
+        ss: {
+          pattern: "([0-9]{2})",
+          action: (value, data) => {
+            data.seconds = parseInt(value);
+          }
+        },
+        s: {
+          pattern: "([0-9]{1,2})",
+          action: (value, data) => {
+            data.seconds = parseInt(value);
+          }
+        },
+        tt: {
+          pattern: "([aApP][mM])",
+          action: (value, data) => {
+            const char = value.charAt(0);
+            data.am = char === "a" || char === "A";
+          }
+        },
+        t: {
+          pattern: "([aApP])",
+          action: (value, data) => {
+            data.am = value === "a" || value === "A";
+          }
+        }
+      };
+      const escapedFormat = cFormat.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+      const patterns = /(mmmm|mmm|mm|m|dddd|ddd|dd|d|yyyy|yy|HH|H|hh|h|MM|M|ss|s|tt|t)/g;
+      const actions = [];
+      const re = escapedFormat.replace(patterns, function (match, patternElement) {
+        const {
+          pattern,
+          action
+        } = handlers[patternElement];
+        actions.push(action);
+        return pattern;
+      });
+
+      this._scandCache.set(cFormat, [new RegExp(re, "g"), actions]);
+    }
+
+    const [regexForFormat, actions] = this._scandCache.get(cFormat);
+
+    const matches = regexForFormat.exec(cDate);
+
+    if (matches.length !== actions.length + 1) {
+      throw new Error("Invalid date in util.scand");
+    }
+
+    const data = {
+      year: 0,
+      month: 0,
+      day: 0,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+      am: null
+    };
+    actions.forEach((action, i) => action(matches[i + 1], data));
+
+    if (data.am !== null) {
+      data.hours = data.hours % 12 + (data.am ? 0 : 12);
+    }
+
+    return new Date(data.year, data.month, data.day, data.hours, data.minutes, data.seconds);
+  }
+
+  spansToXML() {}
+
+  stringFromStream() {}
+
+  xmlToSpans() {}
+
+}
+
+exports.Util = Util;
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __w_pdfjs_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	// module exports must be returned from runtime so entry inlining is disabled
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	return __w_pdfjs_require__(0);
+/******/ })()
+;
+});
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/build/pdf.worker.js b/toolkit/components/pdfjs/content/build/pdf.worker.js
new file mode 100644
index 0000000000..f485c6d067
--- /dev/null
+++ b/toolkit/components/pdfjs/content/build/pdf.worker.js
@@ -0,0 +1,43356 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("pdfjs-dist/build/pdf.worker", [], factory);
+	else if(typeof exports === 'object')
+		exports["pdfjs-dist/build/pdf.worker"] = factory();
+	else
+		root["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
+})(this, function() {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "WorkerMessageHandler", ({
+  enumerable: true,
+  get: function () {
+    return _worker.WorkerMessageHandler;
+  }
+}));
+
+var _worker = __w_pdfjs_require__(1);
+
+const pdfjsVersion = '2.7.510';
+const pdfjsBuild = '631bada0d';
+
+/***/ }),
+/* 1 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.WorkerTask = exports.WorkerMessageHandler = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _pdf_manager = __w_pdfjs_require__(6);
+
+var _writer = __w_pdfjs_require__(27);
+
+var _is_node = __w_pdfjs_require__(4);
+
+var _message_handler = __w_pdfjs_require__(47);
+
+var _worker_stream = __w_pdfjs_require__(48);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+class WorkerTask {
+  constructor(name) {
+    this.name = name;
+    this.terminated = false;
+    this._capability = (0, _util.createPromiseCapability)();
+  }
+
+  get finished() {
+    return this._capability.promise;
+  }
+
+  finish() {
+    this._capability.resolve();
+  }
+
+  terminate() {
+    this.terminated = true;
+  }
+
+  ensureNotTerminated() {
+    if (this.terminated) {
+      throw new Error("Worker task was terminated");
+    }
+  }
+
+}
+
+exports.WorkerTask = WorkerTask;
+
+class WorkerMessageHandler {
+  static setup(handler, port) {
+    var testMessageProcessed = false;
+    handler.on("test", function wphSetupTest(data) {
+      if (testMessageProcessed) {
+        return;
+      }
+
+      testMessageProcessed = true;
+
+      if (!(data instanceof Uint8Array)) {
+        handler.send("test", null);
+        return;
+      }
+
+      const supportTransfers = data[0] === 255;
+      handler.postMessageTransfers = supportTransfers;
+      handler.send("test", {
+        supportTransfers
+      });
+    });
+    handler.on("configure", function wphConfigure(data) {
+      (0, _util.setVerbosityLevel)(data.verbosity);
+    });
+    handler.on("GetDocRequest", function wphSetupDoc(data) {
+      return WorkerMessageHandler.createDocumentHandler(data, port);
+    });
+  }
+
+  static createDocumentHandler(docParams, port) {
+    var pdfManager;
+    var terminated = false;
+    var cancelXHRs = null;
+    var WorkerTasks = [];
+    const verbosity = (0, _util.getVerbosityLevel)();
+    const apiVersion = docParams.apiVersion;
+    const workerVersion = '2.7.510';
+
+    if (apiVersion !== workerVersion) {
+      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
+    }
+
+    var docId = docParams.docId;
+    var docBaseUrl = docParams.docBaseUrl;
+    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");
+      }
+    }
+
+    function startWorkerTask(task) {
+      WorkerTasks.push(task);
+    }
+
+    function finishWorkerTask(task) {
+      task.finish();
+      var i = WorkerTasks.indexOf(task);
+      WorkerTasks.splice(i, 1);
+    }
+
+    async function loadDocument(recoveryMode) {
+      await pdfManager.ensureDoc("checkHeader");
+      await pdfManager.ensureDoc("parseStartXRef");
+      await pdfManager.ensureDoc("parse", [recoveryMode]);
+
+      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)();
+      let newPdfManager;
+      var source = data.source;
+
+      if (source.data) {
+        try {
+          newPdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
+          pdfManagerCapability.resolve(newPdfManager);
+        } catch (ex) {
+          pdfManagerCapability.reject(ex);
+        }
+
+        return pdfManagerCapability.promise;
+      }
+
+      var pdfStream,
+          cachedChunks = [];
+
+      try {
+        pdfStream = new _worker_stream.PDFWorkerStream(handler);
+      } catch (ex) {
+        pdfManagerCapability.reject(ex);
+        return pdfManagerCapability.promise;
+      }
+
+      var fullRequest = pdfStream.getFullReader();
+      fullRequest.headersReady.then(function () {
+        if (!fullRequest.isRangeSupported) {
+          return;
+        }
+
+        var disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
+        newPdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
+          msgHandler: handler,
+          password: source.password,
+          length: fullRequest.contentLength,
+          disableAutoFetch,
+          rangeChunkSize: source.rangeChunkSize
+        }, evaluatorOptions, docBaseUrl);
+
+        for (let i = 0; i < cachedChunks.length; i++) {
+          newPdfManager.sendProgressiveData(cachedChunks[i]);
+        }
+
+        cachedChunks = [];
+        pdfManagerCapability.resolve(newPdfManager);
+        cancelXHRs = null;
+      }).catch(function (reason) {
+        pdfManagerCapability.reject(reason);
+        cancelXHRs = null;
+      });
+      var loaded = 0;
+
+      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");
+        }
+
+        try {
+          newPdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
+          pdfManagerCapability.resolve(newPdfManager);
+        } catch (ex) {
+          pdfManagerCapability.reject(ex);
+        }
+
+        cachedChunks = [];
+      };
+
+      var readPromise = new Promise(function (resolve, reject) {
+        var readChunk = function ({
+          value,
+          done
+        }) {
+          try {
+            ensureNotTerminated();
+
+            if (done) {
+              if (!newPdfManager) {
+                flushChunks();
+              }
+
+              cancelXHRs = null;
+              return;
+            }
+
+            loaded += (0, _util.arrayByteLength)(value);
+
+            if (!fullRequest.isStreamingSupported) {
+              handler.send("DocProgress", {
+                loaded,
+                total: Math.max(loaded, fullRequest.contentLength || 0)
+              });
+            }
+
+            if (newPdfManager) {
+              newPdfManager.sendProgressiveData(value);
+            } else {
+              cachedChunks.push(value);
+            }
+
+            fullRequest.read().then(readChunk, reject);
+          } catch (e) {
+            reject(e);
+          }
+        };
+
+        fullRequest.read().then(readChunk, reject);
+      });
+      readPromise.catch(function (e) {
+        pdfManagerCapability.reject(e);
+        cancelXHRs = null;
+      });
+
+      cancelXHRs = function (reason) {
+        pdfStream.cancelAllRequests(reason);
+      };
+
+      return pdfManagerCapability.promise;
+    }
+
+    function setupDoc(data) {
+      function onSuccess(doc) {
+        ensureNotTerminated();
+        handler.send("GetDoc", {
+          pdfInfo: doc
+        });
+      }
+
+      function onFailure(ex) {
+        ensureNotTerminated();
+
+        if (ex instanceof _util.PasswordException) {
+          var task = new WorkerTask(`PasswordException: response ${ex.code}`);
+          startWorkerTask(task);
+          handler.sendWithPromise("PasswordRequest", ex).then(function ({
+            password
+          }) {
+            finishWorkerTask(task);
+            pdfManager.updatePassword(password);
+            pdfManagerReady();
+          }).catch(function () {
+            finishWorkerTask(task);
+            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("DocException", new _util.UnknownErrorException(ex.message, ex.toString()));
+        }
+      }
+
+      function pdfManagerReady() {
+        ensureNotTerminated();
+        loadDocument(false).then(onSuccess, function (reason) {
+          ensureNotTerminated();
+
+          if (!(reason instanceof _core_utils.XRefParseException)) {
+            onFailure(reason);
+            return;
+          }
+
+          pdfManager.requestLoadedStream();
+          pdfManager.onLoadedStream().then(function () {
+            ensureNotTerminated();
+            loadDocument(true).then(onSuccess, onFailure);
+          });
+        });
+      }
+
+      ensureNotTerminated();
+      var evaluatorOptions = {
+        maxImageSize: data.maxImageSize,
+        disableFontFace: data.disableFontFace,
+        ignoreErrors: data.ignoreErrors,
+        isEvalSupported: data.isEvalSupported,
+        fontExtraProperties: data.fontExtraProperties
+      };
+      getPdfManager(data, evaluatorOptions).then(function (newPdfManager) {
+        if (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", {
+            length: stream.bytes.byteLength
+          });
+        });
+      }).then(pdfManagerReady, onFailure);
+    }
+
+    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 ([rotate, ref, userUnit, view]) {
+          return {
+            rotate,
+            ref,
+            userUnit,
+            view
+          };
+        });
+      });
+    });
+    handler.on("GetPageIndex", function wphSetupGetPageIndex({
+      ref
+    }) {
+      const pageRef = _primitives.Ref.get(ref.num, ref.gen);
+
+      return pdfManager.ensureCatalog("getPageIndex", [pageRef]);
+    });
+    handler.on("GetDestinations", function wphSetupGetDestinations(data) {
+      return pdfManager.ensureCatalog("destinations");
+    });
+    handler.on("GetDestination", function wphSetupGetDestination(data) {
+      return pdfManager.ensureCatalog("getDestination", [data.id]);
+    });
+    handler.on("GetPageLabels", function wphSetupGetPageLabels(data) {
+      return pdfManager.ensureCatalog("pageLabels");
+    });
+    handler.on("GetPageLayout", function wphSetupGetPageLayout(data) {
+      return pdfManager.ensureCatalog("pageLayout");
+    });
+    handler.on("GetPageMode", function wphSetupGetPageMode(data) {
+      return pdfManager.ensureCatalog("pageMode");
+    });
+    handler.on("GetViewerPreferences", function (data) {
+      return pdfManager.ensureCatalog("viewerPreferences");
+    });
+    handler.on("GetOpenAction", function (data) {
+      return pdfManager.ensureCatalog("openAction");
+    });
+    handler.on("GetAttachments", function wphSetupGetAttachments(data) {
+      return pdfManager.ensureCatalog("attachments");
+    });
+    handler.on("GetJavaScript", function wphSetupGetJavaScript(data) {
+      return pdfManager.ensureCatalog("javaScript");
+    });
+    handler.on("GetDocJSActions", function wphSetupGetDocJSActions(data) {
+      return pdfManager.ensureCatalog("jsActions");
+    });
+    handler.on("GetPageJSActions", function ({
+      pageIndex
+    }) {
+      return pdfManager.getPage(pageIndex).then(function (page) {
+        return page.jsActions;
+      });
+    });
+    handler.on("GetOutline", function wphSetupGetOutline(data) {
+      return pdfManager.ensureCatalog("documentOutline");
+    });
+    handler.on("GetOptionalContentConfig", function (data) {
+      return pdfManager.ensureCatalog("optionalContentConfig");
+    });
+    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("GetMarkInfo", function wphSetupGetMarkInfo(data) {
+      return pdfManager.ensureCatalog("markInfo");
+    });
+    handler.on("GetData", function wphSetupGetData(data) {
+      pdfManager.requestLoadedStream();
+      return pdfManager.onLoadedStream().then(function (stream) {
+        return stream.bytes;
+      });
+    });
+    handler.on("GetStats", function wphSetupGetStats(data) {
+      return pdfManager.ensureXRef("stats");
+    });
+    handler.on("GetAnnotations", function ({
+      pageIndex,
+      intent
+    }) {
+      return pdfManager.getPage(pageIndex).then(function (page) {
+        return page.getAnnotationsData(intent);
+      });
+    });
+    handler.on("GetFieldObjects", function (data) {
+      return pdfManager.ensureDoc("fieldObjects");
+    });
+    handler.on("HasJSActions", function (data) {
+      return pdfManager.ensureDoc("hasJSActions");
+    });
+    handler.on("GetCalculationOrderIds", function (data) {
+      return pdfManager.ensureDoc("calculationOrderIds");
+    });
+    handler.on("SaveDocument", function ({
+      numPages,
+      annotationStorage,
+      filename
+    }) {
+      pdfManager.requestLoadedStream();
+      const promises = [pdfManager.onLoadedStream(), pdfManager.ensureCatalog("acroForm"), pdfManager.ensureDoc("xref"), pdfManager.ensureDoc("startXRef")];
+
+      for (let pageIndex = 0; pageIndex < numPages; pageIndex++) {
+        promises.push(pdfManager.getPage(pageIndex).then(function (page) {
+          const task = new WorkerTask(`Save: page ${pageIndex}`);
+          startWorkerTask(task);
+          return page.save(handler, task, annotationStorage).finally(function () {
+            finishWorkerTask(task);
+          });
+        }));
+      }
+
+      return Promise.all(promises).then(function ([stream, acroForm, xref, startXRef, ...refs]) {
+        let newRefs = [];
+
+        for (const ref of refs) {
+          newRefs = ref.filter(x => x !== null).reduce((a, b) => a.concat(b), newRefs);
+        }
+
+        if (newRefs.length === 0) {
+          return stream.bytes;
+        }
+
+        const xfa = acroForm instanceof _primitives.Dict && acroForm.get("XFA") || [];
+        let xfaDatasets = null;
+
+        if (Array.isArray(xfa)) {
+          for (let i = 0, ii = xfa.length; i < ii; i += 2) {
+            if (xfa[i] === "datasets") {
+              xfaDatasets = xfa[i + 1];
+            }
+          }
+        } else {
+          (0, _util.warn)("Unsupported XFA type.");
+        }
+
+        let newXrefInfo = Object.create(null);
+
+        if (xref.trailer) {
+          const infoObj = Object.create(null);
+          const xrefInfo = xref.trailer.get("Info") || null;
+
+          if (xrefInfo instanceof _primitives.Dict) {
+            xrefInfo.forEach((key, value) => {
+              if ((0, _util.isString)(key) && (0, _util.isString)(value)) {
+                infoObj[key] = (0, _util.stringToPDFString)(value);
+              }
+            });
+          }
+
+          newXrefInfo = {
+            rootRef: xref.trailer.getRaw("Root") || null,
+            encrypt: xref.trailer.getRaw("Encrypt") || null,
+            newRef: xref.getNewRef(),
+            infoRef: xref.trailer.getRaw("Info") || null,
+            info: infoObj,
+            fileIds: xref.trailer.getRaw("ID") || null,
+            startXRef,
+            filename
+          };
+        }
+
+        xref.resetNewRef();
+        return (0, _writer.incrementalUpdate)({
+          originalData: stream.bytes,
+          xrefInfo: newXrefInfo,
+          newRefs,
+          xref,
+          datasetsRef: xfaDatasets
+        });
+      });
+    });
+    handler.on("GetOperatorList", function wphSetupRenderPage(data, sink) {
+      var pageIndex = data.pageIndex;
+      pdfManager.getPage(pageIndex).then(function (page) {
+        var task = new WorkerTask(`GetOperatorList: page ${pageIndex}`);
+        startWorkerTask(task);
+        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
+        page.getOperatorList({
+          handler,
+          sink,
+          task,
+          intent: data.intent,
+          renderInteractiveForms: data.renderInteractiveForms,
+          annotationStorage: data.annotationStorage
+        }).then(function (operatorListInfo) {
+          finishWorkerTask(task);
+
+          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.errorOperatorList
+          });
+          sink.error(reason);
+        });
+      });
+    });
+    handler.on("GetTextContent", function wphExtractText(data, sink) {
+      var pageIndex = data.pageIndex;
+
+      sink.onPull = function (desiredSize) {};
+
+      sink.onCancel = function (reason) {};
+
+      pdfManager.getPage(pageIndex).then(function (page) {
+        var task = new WorkerTask("GetTextContent: page " + pageIndex);
+        startWorkerTask(task);
+        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
+        page.extractTextContent({
+          handler,
+          task,
+          sink,
+          normalizeWhitespace: data.normalizeWhitespace,
+          combineTextItems: data.combineTextItems
+        }).then(function () {
+          finishWorkerTask(task);
+
+          if (start) {
+            (0, _util.info)(`page=${pageIndex + 1} - getTextContent: time=` + `${Date.now() - start}ms`);
+          }
+
+          sink.close();
+        }, function (reason) {
+          finishWorkerTask(task);
+
+          if (task.terminated) {
+            return;
+          }
+
+          sink.error(reason);
+        });
+      });
+    });
+    handler.on("FontFallback", function (data) {
+      return pdfManager.fontFallback(data.id, handler);
+    });
+    handler.on("Cleanup", function wphCleanup(data) {
+      return pdfManager.cleanup(true);
+    });
+    handler.on("Terminate", function wphTerminate(data) {
+      terminated = true;
+      const waitOn = [];
+
+      if (pdfManager) {
+        pdfManager.terminate(new _util.AbortException("Worker was terminated."));
+        const cleanupPromise = pdfManager.cleanup();
+        waitOn.push(cleanupPromise);
+        pdfManager = null;
+      } else {
+        (0, _primitives.clearPrimitiveCaches)();
+      }
+
+      if (cancelXHRs) {
+        cancelXHRs(new _util.AbortException("Worker was terminated."));
+      }
+
+      WorkerTasks.forEach(function (task) {
+        waitOn.push(task.finished);
+        task.terminate();
+      });
+      return Promise.all(waitOn).then(function () {
+        handler.destroy();
+        handler = null;
+      });
+    });
+    handler.on("Ready", function wphReady(data) {
+      setupDoc(docParams);
+      docParams = null;
+    });
+    return workerHandlerName;
+  }
+
+  static initializeFromPort(port) {
+    var handler = new _message_handler.MessageHandler("worker", "main", port);
+    WorkerMessageHandler.setup(handler, port);
+    handler.send("ready", null);
+  }
+
+}
+
+exports.WorkerMessageHandler = WorkerMessageHandler;
+
+function isMessagePort(maybePort) {
+  return typeof maybePort.postMessage === "function" && "onmessage" in maybePort;
+}
+
+if (typeof window === "undefined" && !_is_node.isNodeJS && typeof self !== "undefined" && isMessagePort(self)) {
+  WorkerMessageHandler.initializeFromPort(self);
+}
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.arrayByteLength = arrayByteLength;
+exports.arraysToBytes = arraysToBytes;
+exports.assert = assert;
+exports.bytesToString = bytesToString;
+exports.createPromiseCapability = createPromiseCapability;
+exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
+exports.encodeToXmlString = encodeToXmlString;
+exports.escapeString = escapeString;
+exports.getModificationDate = getModificationDate;
+exports.getVerbosityLevel = getVerbosityLevel;
+exports.info = info;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isArrayEqual = isArrayEqual;
+exports.isAscii = isAscii;
+exports.isBool = isBool;
+exports.isNum = isNum;
+exports.isSameOrigin = isSameOrigin;
+exports.isString = isString;
+exports.objectFromEntries = objectFromEntries;
+exports.objectSize = objectSize;
+exports.removeNullCharacters = removeNullCharacters;
+exports.setVerbosityLevel = setVerbosityLevel;
+exports.shadow = shadow;
+exports.string32 = string32;
+exports.stringToBytes = stringToBytes;
+exports.stringToPDFString = stringToPDFString;
+exports.stringToUTF16BEString = stringToUTF16BEString;
+exports.stringToUTF8String = stringToUTF8String;
+exports.unreachable = unreachable;
+exports.utf8StringToString = utf8StringToString;
+exports.warn = warn;
+exports.VerbosityLevel = exports.Util = exports.UNSUPPORTED_FEATURES = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.IsLittleEndianCached = exports.IsEvalSupportedCached = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.createObjectURL = exports.CMapCompressionType = exports.BaseException = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
+
+__w_pdfjs_require__(3);
+
+const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
+const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
+exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
+const PermissionFlag = {
+  PRINT: 0x04,
+  MODIFY_CONTENTS: 0x08,
+  COPY: 0x10,
+  MODIFY_ANNOTATIONS: 0x20,
+  FILL_INTERACTIVE_FORMS: 0x100,
+  COPY_FOR_ACCESSIBILITY: 0x200,
+  ASSEMBLE: 0x400,
+  PRINT_HIGH_QUALITY: 0x800
+};
+exports.PermissionFlag = PermissionFlag;
+const TextRenderingMode = {
+  FILL: 0,
+  STROKE: 1,
+  FILL_STROKE: 2,
+  INVISIBLE: 3,
+  FILL_ADD_TO_PATH: 4,
+  STROKE_ADD_TO_PATH: 5,
+  FILL_STROKE_ADD_TO_PATH: 6,
+  ADD_TO_PATH: 7,
+  FILL_STROKE_MASK: 3,
+  ADD_TO_PATH_FLAG: 4
+};
+exports.TextRenderingMode = TextRenderingMode;
+const ImageKind = {
+  GRAYSCALE_1BPP: 1,
+  RGB_24BPP: 2,
+  RGBA_32BPP: 3
+};
+exports.ImageKind = ImageKind;
+const AnnotationType = {
+  TEXT: 1,
+  LINK: 2,
+  FREETEXT: 3,
+  LINE: 4,
+  SQUARE: 5,
+  CIRCLE: 6,
+  POLYGON: 7,
+  POLYLINE: 8,
+  HIGHLIGHT: 9,
+  UNDERLINE: 10,
+  SQUIGGLY: 11,
+  STRIKEOUT: 12,
+  STAMP: 13,
+  CARET: 14,
+  INK: 15,
+  POPUP: 16,
+  FILEATTACHMENT: 17,
+  SOUND: 18,
+  MOVIE: 19,
+  WIDGET: 20,
+  SCREEN: 21,
+  PRINTERMARK: 22,
+  TRAPNET: 23,
+  WATERMARK: 24,
+  THREED: 25,
+  REDACT: 26
+};
+exports.AnnotationType = AnnotationType;
+const AnnotationStateModelType = {
+  MARKED: "Marked",
+  REVIEW: "Review"
+};
+exports.AnnotationStateModelType = AnnotationStateModelType;
+const AnnotationMarkedState = {
+  MARKED: "Marked",
+  UNMARKED: "Unmarked"
+};
+exports.AnnotationMarkedState = AnnotationMarkedState;
+const AnnotationReviewState = {
+  ACCEPTED: "Accepted",
+  REJECTED: "Rejected",
+  CANCELLED: "Cancelled",
+  COMPLETED: "Completed",
+  NONE: "None"
+};
+exports.AnnotationReviewState = AnnotationReviewState;
+const AnnotationReplyType = {
+  GROUP: "Group",
+  REPLY: "R"
+};
+exports.AnnotationReplyType = AnnotationReplyType;
+const AnnotationFlag = {
+  INVISIBLE: 0x01,
+  HIDDEN: 0x02,
+  PRINT: 0x04,
+  NOZOOM: 0x08,
+  NOROTATE: 0x10,
+  NOVIEW: 0x20,
+  READONLY: 0x40,
+  LOCKED: 0x80,
+  TOGGLENOVIEW: 0x100,
+  LOCKEDCONTENTS: 0x200
+};
+exports.AnnotationFlag = AnnotationFlag;
+const AnnotationFieldFlag = {
+  READONLY: 0x0000001,
+  REQUIRED: 0x0000002,
+  NOEXPORT: 0x0000004,
+  MULTILINE: 0x0001000,
+  PASSWORD: 0x0002000,
+  NOTOGGLETOOFF: 0x0004000,
+  RADIO: 0x0008000,
+  PUSHBUTTON: 0x0010000,
+  COMBO: 0x0020000,
+  EDIT: 0x0040000,
+  SORT: 0x0080000,
+  FILESELECT: 0x0100000,
+  MULTISELECT: 0x0200000,
+  DONOTSPELLCHECK: 0x0400000,
+  DONOTSCROLL: 0x0800000,
+  COMB: 0x1000000,
+  RICHTEXT: 0x2000000,
+  RADIOSINUNISON: 0x2000000,
+  COMMITONSELCHANGE: 0x4000000
+};
+exports.AnnotationFieldFlag = AnnotationFieldFlag;
+const AnnotationBorderStyleType = {
+  SOLID: 1,
+  DASHED: 2,
+  BEVELED: 3,
+  INSET: 4,
+  UNDERLINE: 5
+};
+exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
+const AnnotationActionEventType = {
+  E: "MouseEnter",
+  X: "MouseExit",
+  D: "MouseDown",
+  U: "MouseUp",
+  Fo: "Focus",
+  Bl: "Blur",
+  PO: "PageOpen",
+  PC: "PageClose",
+  PV: "PageVisible",
+  PI: "PageInvisible",
+  K: "Keystroke",
+  F: "Format",
+  V: "Validate",
+  C: "Calculate"
+};
+exports.AnnotationActionEventType = AnnotationActionEventType;
+const DocumentActionEventType = {
+  WC: "WillClose",
+  WS: "WillSave",
+  DS: "DidSave",
+  WP: "WillPrint",
+  DP: "DidPrint"
+};
+exports.DocumentActionEventType = DocumentActionEventType;
+const PageActionEventType = {
+  O: "PageOpen",
+  C: "PageClose"
+};
+exports.PageActionEventType = PageActionEventType;
+const StreamType = {
+  UNKNOWN: "UNKNOWN",
+  FLATE: "FLATE",
+  LZW: "LZW",
+  DCT: "DCT",
+  JPX: "JPX",
+  JBIG: "JBIG",
+  A85: "A85",
+  AHX: "AHX",
+  CCF: "CCF",
+  RLX: "RLX"
+};
+exports.StreamType = StreamType;
+const FontType = {
+  UNKNOWN: "UNKNOWN",
+  TYPE1: "TYPE1",
+  TYPE1C: "TYPE1C",
+  CIDFONTTYPE0: "CIDFONTTYPE0",
+  CIDFONTTYPE0C: "CIDFONTTYPE0C",
+  TRUETYPE: "TRUETYPE",
+  CIDFONTTYPE2: "CIDFONTTYPE2",
+  TYPE3: "TYPE3",
+  OPENTYPE: "OPENTYPE",
+  TYPE0: "TYPE0",
+  MMTYPE1: "MMTYPE1"
+};
+exports.FontType = FontType;
+const VerbosityLevel = {
+  ERRORS: 0,
+  WARNINGS: 1,
+  INFOS: 5
+};
+exports.VerbosityLevel = VerbosityLevel;
+const CMapCompressionType = {
+  NONE: 0,
+  BINARY: 1,
+  STREAM: 2
+};
+exports.CMapCompressionType = CMapCompressionType;
+const OPS = {
+  dependency: 1,
+  setLineWidth: 2,
+  setLineCap: 3,
+  setLineJoin: 4,
+  setMiterLimit: 5,
+  setDash: 6,
+  setRenderingIntent: 7,
+  setFlatness: 8,
+  setGState: 9,
+  save: 10,
+  restore: 11,
+  transform: 12,
+  moveTo: 13,
+  lineTo: 14,
+  curveTo: 15,
+  curveTo2: 16,
+  curveTo3: 17,
+  closePath: 18,
+  rectangle: 19,
+  stroke: 20,
+  closeStroke: 21,
+  fill: 22,
+  eoFill: 23,
+  fillStroke: 24,
+  eoFillStroke: 25,
+  closeFillStroke: 26,
+  closeEOFillStroke: 27,
+  endPath: 28,
+  clip: 29,
+  eoClip: 30,
+  beginText: 31,
+  endText: 32,
+  setCharSpacing: 33,
+  setWordSpacing: 34,
+  setHScale: 35,
+  setLeading: 36,
+  setFont: 37,
+  setTextRenderingMode: 38,
+  setTextRise: 39,
+  moveText: 40,
+  setLeadingMoveText: 41,
+  setTextMatrix: 42,
+  nextLine: 43,
+  showText: 44,
+  showSpacedText: 45,
+  nextLineShowText: 46,
+  nextLineSetSpacingShowText: 47,
+  setCharWidth: 48,
+  setCharWidthAndBounds: 49,
+  setStrokeColorSpace: 50,
+  setFillColorSpace: 51,
+  setStrokeColor: 52,
+  setStrokeColorN: 53,
+  setFillColor: 54,
+  setFillColorN: 55,
+  setStrokeGray: 56,
+  setFillGray: 57,
+  setStrokeRGBColor: 58,
+  setFillRGBColor: 59,
+  setStrokeCMYKColor: 60,
+  setFillCMYKColor: 61,
+  shadingFill: 62,
+  beginInlineImage: 63,
+  beginImageData: 64,
+  endInlineImage: 65,
+  paintXObject: 66,
+  markPoint: 67,
+  markPointProps: 68,
+  beginMarkedContent: 69,
+  beginMarkedContentProps: 70,
+  endMarkedContent: 71,
+  beginCompat: 72,
+  endCompat: 73,
+  paintFormXObjectBegin: 74,
+  paintFormXObjectEnd: 75,
+  beginGroup: 76,
+  endGroup: 77,
+  beginAnnotations: 78,
+  endAnnotations: 79,
+  beginAnnotation: 80,
+  endAnnotation: 81,
+  paintJpegXObject: 82,
+  paintImageMaskXObject: 83,
+  paintImageMaskXObjectGroup: 84,
+  paintImageXObject: 85,
+  paintInlineImageXObject: 86,
+  paintInlineImageXObjectGroup: 87,
+  paintImageXObjectRepeat: 88,
+  paintImageMaskXObjectRepeat: 89,
+  paintSolidColorImageMask: 90,
+  constructPath: 91
+};
+exports.OPS = OPS;
+const UNSUPPORTED_FEATURES = {
+  unknown: "unknown",
+  forms: "forms",
+  javaScript: "javaScript",
+  smask: "smask",
+  shadingPattern: "shadingPattern",
+  font: "font",
+  errorTilingPattern: "errorTilingPattern",
+  errorExtGState: "errorExtGState",
+  errorXObject: "errorXObject",
+  errorFontLoadType3: "errorFontLoadType3",
+  errorFontState: "errorFontState",
+  errorFontMissing: "errorFontMissing",
+  errorFontTranslate: "errorFontTranslate",
+  errorColorSpace: "errorColorSpace",
+  errorOperatorList: "errorOperatorList",
+  errorFontToUnicode: "errorFontToUnicode",
+  errorFontLoadNative: "errorFontLoadNative",
+  errorFontGetPath: "errorFontGetPath",
+  errorMarkedContent: "errorMarkedContent"
+};
+exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
+const PasswordResponses = {
+  NEED_PASSWORD: 1,
+  INCORRECT_PASSWORD: 2
+};
+exports.PasswordResponses = PasswordResponses;
+let verbosity = VerbosityLevel.WARNINGS;
+
+function setVerbosityLevel(level) {
+  if (Number.isInteger(level)) {
+    verbosity = level;
+  }
+}
+
+function getVerbosityLevel() {
+  return verbosity;
+}
+
+function info(msg) {
+  if (verbosity >= VerbosityLevel.INFOS) {
+    console.log(`Info: ${msg}`);
+  }
+}
+
+function warn(msg) {
+  if (verbosity >= VerbosityLevel.WARNINGS) {
+    console.log(`Warning: ${msg}`);
+  }
+}
+
+function unreachable(msg) {
+  throw new Error(msg);
+}
+
+function assert(cond, msg) {
+  if (!cond) {
+    unreachable(msg);
+  }
+}
+
+function isSameOrigin(baseUrl, otherUrl) {
+  let base;
+
+  try {
+    base = new URL(baseUrl);
+
+    if (!base.origin || base.origin === "null") {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+
+  const other = new URL(otherUrl, base);
+  return base.origin === other.origin;
+}
+
+function _isValidProtocol(url) {
+  if (!url) {
+    return false;
+  }
+
+  switch (url.protocol) {
+    case "http:":
+    case "https:":
+    case "ftp:":
+    case "mailto:":
+    case "tel:":
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+function createValidAbsoluteUrl(url, baseUrl) {
+  if (!url) {
+    return null;
+  }
+
+  try {
+    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+
+    if (_isValidProtocol(absoluteUrl)) {
+      return absoluteUrl;
+    }
+  } catch (ex) {}
+
+  return null;
+}
+
+function shadow(obj, prop, value) {
+  Object.defineProperty(obj, prop, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: false
+  });
+  return value;
+}
+
+const BaseException = function BaseExceptionClosure() {
+  function BaseException(message) {
+    if (this.constructor === BaseException) {
+      unreachable("Cannot initialize BaseException.");
+    }
+
+    this.message = message;
+    this.name = this.constructor.name;
+  }
+
+  BaseException.prototype = new Error();
+  BaseException.constructor = BaseException;
+  return BaseException;
+}();
+
+exports.BaseException = BaseException;
+
+class PasswordException extends BaseException {
+  constructor(msg, code) {
+    super(msg);
+    this.code = code;
+  }
+
+}
+
+exports.PasswordException = PasswordException;
+
+class UnknownErrorException extends BaseException {
+  constructor(msg, details) {
+    super(msg);
+    this.details = details;
+  }
+
+}
+
+exports.UnknownErrorException = UnknownErrorException;
+
+class InvalidPDFException extends BaseException {}
+
+exports.InvalidPDFException = InvalidPDFException;
+
+class MissingPDFException extends BaseException {}
+
+exports.MissingPDFException = MissingPDFException;
+
+class UnexpectedResponseException extends BaseException {
+  constructor(msg, status) {
+    super(msg);
+    this.status = status;
+  }
+
+}
+
+exports.UnexpectedResponseException = UnexpectedResponseException;
+
+class FormatError extends BaseException {}
+
+exports.FormatError = FormatError;
+
+class AbortException extends BaseException {}
+
+exports.AbortException = AbortException;
+const NullCharactersRegExp = /\x00/g;
+
+function removeNullCharacters(str) {
+  if (typeof str !== "string") {
+    warn("The argument for removeNullCharacters must be a string.");
+    return str;
+  }
+
+  return str.replace(NullCharactersRegExp, "");
+}
+
+function bytesToString(bytes) {
+  assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
+  const length = bytes.length;
+  const MAX_ARGUMENT_COUNT = 8192;
+
+  if (length < MAX_ARGUMENT_COUNT) {
+    return String.fromCharCode.apply(null, bytes);
+  }
+
+  const strBuf = [];
+
+  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+    const chunk = bytes.subarray(i, chunkEnd);
+    strBuf.push(String.fromCharCode.apply(null, chunk));
+  }
+
+  return strBuf.join("");
+}
+
+function stringToBytes(str) {
+  assert(typeof str === "string", "Invalid argument for stringToBytes");
+  const length = str.length;
+  const bytes = new Uint8Array(length);
+
+  for (let i = 0; i < length; ++i) {
+    bytes[i] = str.charCodeAt(i) & 0xff;
+  }
+
+  return bytes;
+}
+
+function arrayByteLength(arr) {
+  if (arr.length !== undefined) {
+    return arr.length;
+  }
+
+  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
+  return arr.byteLength;
+}
+
+function arraysToBytes(arr) {
+  const length = arr.length;
+
+  if (length === 1 && arr[0] instanceof Uint8Array) {
+    return arr[0];
+  }
+
+  let resultLength = 0;
+
+  for (let i = 0; i < length; i++) {
+    resultLength += arrayByteLength(arr[i]);
+  }
+
+  let pos = 0;
+  const data = new Uint8Array(resultLength);
+
+  for (let i = 0; i < length; i++) {
+    let item = arr[i];
+
+    if (!(item instanceof Uint8Array)) {
+      if (typeof item === "string") {
+        item = stringToBytes(item);
+      } else {
+        item = new Uint8Array(item);
+      }
+    }
+
+    const itemLength = item.byteLength;
+    data.set(item, pos);
+    pos += itemLength;
+  }
+
+  return data;
+}
+
+function string32(value) {
+  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
+}
+
+function objectSize(obj) {
+  return Object.keys(obj).length;
+}
+
+function objectFromEntries(iterable) {
+  return Object.assign(Object.create(null), Object.fromEntries(iterable));
+}
+
+function isLittleEndian() {
+  const buffer8 = new Uint8Array(4);
+  buffer8[0] = 1;
+  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
+  return view32[0] === 1;
+}
+
+const IsLittleEndianCached = {
+  get value() {
+    return shadow(this, "value", isLittleEndian());
+  }
+
+};
+exports.IsLittleEndianCached = IsLittleEndianCached;
+
+function isEvalSupported() {
+  try {
+    new Function("");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const IsEvalSupportedCached = {
+  get value() {
+    return shadow(this, "value", isEvalSupported());
+  }
+
+};
+exports.IsEvalSupportedCached = IsEvalSupportedCached;
+const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
+
+class Util {
+  static makeHexColor(r, g, b) {
+    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
+  }
+
+  static transform(m1, m2) {
+    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
+  }
+
+  static applyTransform(p, m) {
+    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
+    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
+    return [xt, yt];
+  }
+
+  static applyInverseTransform(p, m) {
+    const d = m[0] * m[3] - m[1] * m[2];
+    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
+    return [xt, yt];
+  }
+
+  static getAxialAlignedBoundingBox(r, m) {
+    const p1 = Util.applyTransform(r, m);
+    const p2 = Util.applyTransform(r.slice(2, 4), m);
+    const p3 = Util.applyTransform([r[0], r[3]], m);
+    const p4 = Util.applyTransform([r[2], r[1]], m);
+    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
+  }
+
+  static inverseTransform(m) {
+    const d = m[0] * m[3] - m[1] * m[2];
+    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
+  }
+
+  static apply3dTransform(m, v) {
+    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
+  }
+
+  static singularValueDecompose2dScale(m) {
+    const transpose = [m[0], m[2], m[1], m[3]];
+    const a = m[0] * transpose[0] + m[1] * transpose[2];
+    const b = m[0] * transpose[1] + m[1] * transpose[3];
+    const c = m[2] * transpose[0] + m[3] * transpose[2];
+    const d = m[2] * transpose[1] + m[3] * transpose[3];
+    const first = (a + d) / 2;
+    const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
+    const sx = first + second || 1;
+    const sy = first - second || 1;
+    return [Math.sqrt(sx), Math.sqrt(sy)];
+  }
+
+  static normalizeRect(rect) {
+    const r = rect.slice(0);
+
+    if (rect[0] > rect[2]) {
+      r[0] = rect[2];
+      r[2] = rect[0];
+    }
+
+    if (rect[1] > rect[3]) {
+      r[1] = rect[3];
+      r[3] = rect[1];
+    }
+
+    return r;
+  }
+
+  static intersect(rect1, rect2) {
+    function compare(a, b) {
+      return a - b;
+    }
+
+    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);
+    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
+    const result = [];
+    rect1 = Util.normalizeRect(rect1);
+    rect2 = Util.normalizeRect(rect2);
+
+    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
+      result[0] = orderedX[1];
+      result[2] = orderedX[2];
+    } else {
+      return null;
+    }
+
+    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
+      result[1] = orderedY[1];
+      result[3] = orderedY[2];
+    } else {
+      return null;
+    }
+
+    return result;
+  }
+
+}
+
+exports.Util = Util;
+const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
+
+function stringToPDFString(str) {
+  const length = str.length,
+        strBuf = [];
+
+  if (str[0] === "\xFE" && str[1] === "\xFF") {
+    for (let i = 2; i < length; i += 2) {
+      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
+    }
+  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
+    for (let i = 2; i < length; i += 2) {
+      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
+    }
+  } else {
+    for (let i = 0; i < length; ++i) {
+      const code = PDFStringTranslateTable[str.charCodeAt(i)];
+      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
+    }
+  }
+
+  return strBuf.join("");
+}
+
+function escapeString(str) {
+  return str.replace(/([()\\\n\r])/g, match => {
+    if (match === "\n") {
+      return "\\n";
+    } else if (match === "\r") {
+      return "\\r";
+    }
+
+    return `\\${match}`;
+  });
+}
+
+function isAscii(str) {
+  return /^[\x00-\x7F]*$/.test(str);
+}
+
+function stringToUTF16BEString(str) {
+  const buf = ["\xFE\xFF"];
+
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.charCodeAt(i);
+    buf.push(String.fromCharCode(char >> 8 & 0xff));
+    buf.push(String.fromCharCode(char & 0xff));
+  }
+
+  return buf.join("");
+}
+
+function stringToUTF8String(str) {
+  return decodeURIComponent(escape(str));
+}
+
+function utf8StringToString(str) {
+  return unescape(encodeURIComponent(str));
+}
+
+function isBool(v) {
+  return typeof v === "boolean";
+}
+
+function isNum(v) {
+  return typeof v === "number";
+}
+
+function isString(v) {
+  return typeof v === "string";
+}
+
+function isArrayBuffer(v) {
+  return typeof v === "object" && v !== null && v.byteLength !== undefined;
+}
+
+function isArrayEqual(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+
+  return arr1.every(function (element, index) {
+    return element === arr2[index];
+  });
+}
+
+function getModificationDate(date = new Date()) {
+  const buffer = [date.getUTCFullYear().toString(), (date.getUTCMonth() + 1).toString().padStart(2, "0"), date.getUTCDate().toString().padStart(2, "0"), date.getUTCHours().toString().padStart(2, "0"), date.getUTCMinutes().toString().padStart(2, "0"), date.getUTCSeconds().toString().padStart(2, "0")];
+  return buffer.join("");
+}
+
+function createPromiseCapability() {
+  const capability = Object.create(null);
+  let isSettled = false;
+  Object.defineProperty(capability, "settled", {
+    get() {
+      return isSettled;
+    }
+
+  });
+  capability.promise = new Promise(function (resolve, reject) {
+    capability.resolve = function (data) {
+      isSettled = true;
+      resolve(data);
+    };
+
+    capability.reject = function (reason) {
+      isSettled = true;
+      reject(reason);
+    };
+  });
+  return capability;
+}
+
+const createObjectURL = function createObjectURLClosure() {
+  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  return function createObjectURL(data, contentType, forceDataSchema = false) {
+    if (!forceDataSchema && URL.createObjectURL) {
+      const blob = new Blob([data], {
+        type: contentType
+      });
+      return URL.createObjectURL(blob);
+    }
+
+    let buffer = `data:${contentType};base64,`;
+
+    for (let i = 0, ii = data.length; i < ii; i += 3) {
+      const b1 = data[i] & 0xff;
+      const b2 = data[i + 1] & 0xff;
+      const b3 = data[i + 2] & 0xff;
+      const d1 = b1 >> 2,
+            d2 = (b1 & 3) << 4 | b2 >> 4;
+      const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
+      const d4 = i + 2 < ii ? b3 & 0x3f : 64;
+      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
+    }
+
+    return buffer;
+  };
+}();
+
+exports.createObjectURL = createObjectURL;
+const XMLEntities = {
+  0x3c: "&lt;",
+  0x3e: "&gt;",
+  0x26: "&amp;",
+  0x22: "&quot;",
+  0x27: "&apos;"
+};
+
+function encodeToXmlString(str) {
+  const buffer = [];
+  let start = 0;
+
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.codePointAt(i);
+
+    if (0x20 <= char && char <= 0x7e) {
+      const entity = XMLEntities[char];
+
+      if (entity) {
+        if (start < i) {
+          buffer.push(str.substring(start, i));
+        }
+
+        buffer.push(entity);
+        start = i + 1;
+      }
+    } else {
+      if (start < i) {
+        buffer.push(str.substring(start, i));
+      }
+
+      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
+
+      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
+        i++;
+      }
+
+      start = i + 1;
+    }
+  }
+
+  if (buffer.length === 0) {
+    return str;
+  }
+
+  if (start < str.length) {
+    buffer.push(str.substring(start, str.length));
+  }
+
+  return buffer.join("");
+}
+
+/***/ }),
+/* 3 */
+/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
+
+
+
+var _is_node = __w_pdfjs_require__(4);
+
+;
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.isNodeJS = void 0;
+const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
+exports.isNodeJS = isNodeJS;
+
+/***/ }),
+/* 5 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.clearPrimitiveCaches = clearPrimitiveCaches;
+exports.isCmd = isCmd;
+exports.isDict = isDict;
+exports.isEOF = isEOF;
+exports.isName = isName;
+exports.isRef = isRef;
+exports.isRefsEqual = isRefsEqual;
+exports.isStream = isStream;
+exports.RefSetCache = exports.RefSet = exports.Ref = exports.Name = exports.EOF = exports.Dict = exports.Cmd = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var EOF = {};
+exports.EOF = EOF;
+
+var Name = function NameClosure() {
+  let nameCache = Object.create(null);
+
+  function Name(name) {
+    this.name = name;
+  }
+
+  Name.prototype = {};
+
+  Name.get = function Name_get(name) {
+    var nameValue = nameCache[name];
+    return nameValue ? nameValue : nameCache[name] = new Name(name);
+  };
+
+  Name._clearCache = function () {
+    nameCache = Object.create(null);
+  };
+
+  return Name;
+}();
+
+exports.Name = Name;
+
+var Cmd = function CmdClosure() {
+  let cmdCache = Object.create(null);
+
+  function Cmd(cmd) {
+    this.cmd = cmd;
+  }
+
+  Cmd.prototype = {};
+
+  Cmd.get = function Cmd_get(cmd) {
+    var cmdValue = cmdCache[cmd];
+    return cmdValue ? cmdValue : cmdCache[cmd] = new Cmd(cmd);
+  };
+
+  Cmd._clearCache = function () {
+    cmdCache = Object.create(null);
+  };
+
+  return Cmd;
+}();
+
+exports.Cmd = Cmd;
+
+var Dict = function DictClosure() {
+  var nonSerializable = function nonSerializableClosure() {
+    return nonSerializable;
+  };
+
+  function Dict(xref) {
+    this._map = Object.create(null);
+    this.xref = xref;
+    this.objId = null;
+    this.suppressEncryption = false;
+    this.__nonSerializable__ = nonSerializable;
+  }
+
+  Dict.prototype = {
+    assignXref: function Dict_assignXref(newXref) {
+      this.xref = newXref;
+    },
+
+    get size() {
+      return Object.keys(this._map).length;
+    },
+
+    get(key1, key2, key3) {
+      let value = this._map[key1];
+
+      if (value === undefined && key2 !== undefined) {
+        value = this._map[key2];
+
+        if (value === undefined && key3 !== undefined) {
+          value = this._map[key3];
+        }
+      }
+
+      if (value instanceof Ref && this.xref) {
+        return this.xref.fetch(value, this.suppressEncryption);
+      }
+
+      return value;
+    },
+
+    async getAsync(key1, key2, key3) {
+      let value = this._map[key1];
+
+      if (value === undefined && key2 !== undefined) {
+        value = this._map[key2];
+
+        if (value === undefined && key3 !== undefined) {
+          value = this._map[key3];
+        }
+      }
+
+      if (value instanceof Ref && this.xref) {
+        return this.xref.fetchAsync(value, this.suppressEncryption);
+      }
+
+      return value;
+    },
+
+    getArray(key1, key2, key3) {
+      let value = this.get(key1, key2, key3);
+
+      if (!Array.isArray(value) || !this.xref) {
+        return value;
+      }
+
+      value = value.slice();
+
+      for (let i = 0, ii = value.length; i < ii; i++) {
+        if (!(value[i] instanceof Ref)) {
+          continue;
+        }
+
+        value[i] = this.xref.fetch(value[i], this.suppressEncryption);
+      }
+
+      return value;
+    },
+
+    getRaw: function Dict_getRaw(key) {
+      return this._map[key];
+    },
+    getKeys: function Dict_getKeys() {
+      return Object.keys(this._map);
+    },
+    getRawValues: function Dict_getRawValues() {
+      return Object.values(this._map);
+    },
+    set: function Dict_set(key, value) {
+      this._map[key] = value;
+    },
+    has: function Dict_has(key) {
+      return this._map[key] !== undefined;
+    },
+    forEach: function Dict_forEach(callback) {
+      for (var key in this._map) {
+        callback(key, this.get(key));
+      }
+    }
+  };
+
+  Dict.empty = function () {
+    const emptyDict = new Dict(null);
+
+    emptyDict.set = (key, value) => {
+      (0, _util.unreachable)("Should not call `set` on the empty dictionary.");
+    };
+
+    return emptyDict;
+  }();
+
+  Dict.merge = function ({
+    xref,
+    dictArray,
+    mergeSubDicts = false
+  }) {
+    const mergedDict = new Dict(xref);
+
+    if (!mergeSubDicts) {
+      for (const dict of dictArray) {
+        if (!(dict instanceof Dict)) {
+          continue;
+        }
+
+        for (const [key, value] of Object.entries(dict._map)) {
+          if (mergedDict._map[key] === undefined) {
+            mergedDict._map[key] = value;
+          }
+        }
+      }
+
+      return mergedDict.size > 0 ? mergedDict : Dict.empty;
+    }
+
+    const properties = new Map();
+
+    for (const dict of dictArray) {
+      if (!(dict instanceof Dict)) {
+        continue;
+      }
+
+      for (const [key, value] of Object.entries(dict._map)) {
+        let property = properties.get(key);
+
+        if (property === undefined) {
+          property = [];
+          properties.set(key, property);
+        }
+
+        property.push(value);
+      }
+    }
+
+    for (const [name, values] of properties) {
+      if (values.length === 1 || !(values[0] instanceof Dict)) {
+        mergedDict._map[name] = values[0];
+        continue;
+      }
+
+      const subDict = new Dict(xref);
+
+      for (const dict of values) {
+        if (!(dict instanceof Dict)) {
+          continue;
+        }
+
+        for (const [key, value] of Object.entries(dict._map)) {
+          if (subDict._map[key] === undefined) {
+            subDict._map[key] = value;
+          }
+        }
+      }
+
+      if (subDict.size > 0) {
+        mergedDict._map[name] = subDict;
+      }
+    }
+
+    properties.clear();
+    return mergedDict.size > 0 ? mergedDict : Dict.empty;
+  };
+
+  return Dict;
+}();
+
+exports.Dict = Dict;
+
+var Ref = function RefClosure() {
+  let refCache = Object.create(null);
+
+  function Ref(num, gen) {
+    this.num = num;
+    this.gen = gen;
+  }
+
+  Ref.prototype = {
+    toString: function Ref_toString() {
+      if (this.gen === 0) {
+        return `${this.num}R`;
+      }
+
+      return `${this.num}R${this.gen}`;
+    }
+  };
+
+  Ref.get = function (num, gen) {
+    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
+    const refValue = refCache[key];
+    return refValue ? refValue : refCache[key] = new Ref(num, gen);
+  };
+
+  Ref._clearCache = function () {
+    refCache = Object.create(null);
+  };
+
+  return Ref;
+}();
+
+exports.Ref = Ref;
+
+class RefSet {
+  constructor(parent = null) {
+    this._set = new Set(parent && parent._set);
+  }
+
+  has(ref) {
+    return this._set.has(ref.toString());
+  }
+
+  put(ref) {
+    this._set.add(ref.toString());
+  }
+
+  remove(ref) {
+    this._set.delete(ref.toString());
+  }
+
+  forEach(callback) {
+    for (const ref of this._set.values()) {
+      callback(ref);
+    }
+  }
+
+  clear() {
+    this._set.clear();
+  }
+
+}
+
+exports.RefSet = RefSet;
+
+class RefSetCache {
+  constructor() {
+    this._map = new Map();
+  }
+
+  get size() {
+    return this._map.size;
+  }
+
+  get(ref) {
+    return this._map.get(ref.toString());
+  }
+
+  has(ref) {
+    return this._map.has(ref.toString());
+  }
+
+  put(ref, obj) {
+    this._map.set(ref.toString(), obj);
+  }
+
+  putAlias(ref, aliasRef) {
+    this._map.set(ref.toString(), this.get(aliasRef));
+  }
+
+  forEach(callback) {
+    for (const value of this._map.values()) {
+      callback(value);
+    }
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+}
+
+exports.RefSetCache = RefSetCache;
+
+function isEOF(v) {
+  return v === EOF;
+}
+
+function isName(v, name) {
+  return v instanceof Name && (name === undefined || v.name === name);
+}
+
+function isCmd(v, cmd) {
+  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
+}
+
+function isDict(v, type) {
+  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
+}
+
+function isRef(v) {
+  return v instanceof Ref;
+}
+
+function isRefsEqual(v1, v2) {
+  return v1.num === v2.num && v1.gen === v2.gen;
+}
+
+function isStream(v) {
+  return typeof v === "object" && v !== null && v.getBytes !== undefined;
+}
+
+function clearPrimitiveCaches() {
+  Cmd._clearCache();
+
+  Name._clearCache();
+
+  Ref._clearCache();
+}
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.NetworkPdfManager = exports.LocalPdfManager = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _chunked_stream = __w_pdfjs_require__(7);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _document = __w_pdfjs_require__(9);
+
+var _stream = __w_pdfjs_require__(12);
+
+class BasePdfManager {
+  constructor() {
+    if (this.constructor === BasePdfManager) {
+      (0, _util.unreachable)("Cannot initialize BasePdfManager.");
+    }
+  }
+
+  get docId() {
+    return this._docId;
+  }
+
+  get password() {
+    return this._password;
+  }
+
+  get docBaseUrl() {
+    let docBaseUrl = null;
+
+    if (this._docBaseUrl) {
+      const absoluteUrl = (0, _util.createValidAbsoluteUrl)(this._docBaseUrl);
+
+      if (absoluteUrl) {
+        docBaseUrl = absoluteUrl.href;
+      } else {
+        (0, _util.warn)(`Invalid absolute docBaseUrl: "${this._docBaseUrl}".`);
+      }
+    }
+
+    return (0, _util.shadow)(this, "docBaseUrl", docBaseUrl);
+  }
+
+  onLoadedStream() {
+    (0, _util.unreachable)("Abstract method `onLoadedStream` called");
+  }
+
+  ensureDoc(prop, args) {
+    return this.ensure(this.pdfDocument, prop, args);
+  }
+
+  ensureXRef(prop, args) {
+    return this.ensure(this.pdfDocument.xref, prop, args);
+  }
+
+  ensureCatalog(prop, args) {
+    return this.ensure(this.pdfDocument.catalog, prop, args);
+  }
+
+  getPage(pageIndex) {
+    return this.pdfDocument.getPage(pageIndex);
+  }
+
+  fontFallback(id, handler) {
+    return this.pdfDocument.fontFallback(id, handler);
+  }
+
+  cleanup(manuallyTriggered = false) {
+    return this.pdfDocument.cleanup(manuallyTriggered);
+  }
+
+  async ensure(obj, prop, args) {
+    (0, _util.unreachable)("Abstract method `ensure` called");
+  }
+
+  requestRange(begin, end) {
+    (0, _util.unreachable)("Abstract method `requestRange` called");
+  }
+
+  requestLoadedStream() {
+    (0, _util.unreachable)("Abstract method `requestLoadedStream` called");
+  }
+
+  sendProgressiveData(chunk) {
+    (0, _util.unreachable)("Abstract method `sendProgressiveData` called");
+  }
+
+  updatePassword(password) {
+    this._password = password;
+  }
+
+  terminate(reason) {
+    (0, _util.unreachable)("Abstract method `terminate` called");
+  }
+
+}
+
+class LocalPdfManager extends BasePdfManager {
+  constructor(docId, data, password, evaluatorOptions, docBaseUrl) {
+    super();
+    this._docId = docId;
+    this._password = password;
+    this._docBaseUrl = docBaseUrl;
+    this.evaluatorOptions = evaluatorOptions;
+    const stream = new _stream.Stream(data);
+    this.pdfDocument = new _document.PDFDocument(this, stream);
+    this._loadedStreamPromise = Promise.resolve(stream);
+  }
+
+  async ensure(obj, prop, args) {
+    const value = obj[prop];
+
+    if (typeof value === "function") {
+      return value.apply(obj, args);
+    }
+
+    return value;
+  }
+
+  requestRange(begin, end) {
+    return Promise.resolve();
+  }
+
+  requestLoadedStream() {}
+
+  onLoadedStream() {
+    return this._loadedStreamPromise;
+  }
+
+  terminate(reason) {}
+
+}
+
+exports.LocalPdfManager = LocalPdfManager;
+
+class NetworkPdfManager extends BasePdfManager {
+  constructor(docId, pdfNetworkStream, args, evaluatorOptions, docBaseUrl) {
+    super();
+    this._docId = docId;
+    this._password = args.password;
+    this._docBaseUrl = docBaseUrl;
+    this.msgHandler = args.msgHandler;
+    this.evaluatorOptions = evaluatorOptions;
+    this.streamManager = new _chunked_stream.ChunkedStreamManager(pdfNetworkStream, {
+      msgHandler: args.msgHandler,
+      length: args.length,
+      disableAutoFetch: args.disableAutoFetch,
+      rangeChunkSize: args.rangeChunkSize
+    });
+    this.pdfDocument = new _document.PDFDocument(this, this.streamManager.getStream());
+  }
+
+  async ensure(obj, prop, args) {
+    try {
+      const value = obj[prop];
+
+      if (typeof value === "function") {
+        return value.apply(obj, args);
+      }
+
+      return value;
+    } catch (ex) {
+      if (!(ex instanceof _core_utils.MissingDataException)) {
+        throw ex;
+      }
+
+      await this.requestRange(ex.begin, ex.end);
+      return this.ensure(obj, prop, args);
+    }
+  }
+
+  requestRange(begin, end) {
+    return this.streamManager.requestRange(begin, end);
+  }
+
+  requestLoadedStream() {
+    this.streamManager.requestAllChunks();
+  }
+
+  sendProgressiveData(chunk) {
+    this.streamManager.onReceiveData({
+      chunk
+    });
+  }
+
+  onLoadedStream() {
+    return this.streamManager.onLoadedStream();
+  }
+
+  terminate(reason) {
+    this.streamManager.abort(reason);
+  }
+
+}
+
+exports.NetworkPdfManager = NetworkPdfManager;
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ChunkedStreamManager = exports.ChunkedStream = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+class ChunkedStream {
+  constructor(length, chunkSize, manager) {
+    this.bytes = new Uint8Array(length);
+    this.start = 0;
+    this.pos = 0;
+    this.end = length;
+    this.chunkSize = chunkSize;
+    this._loadedChunks = new Set();
+    this.numChunks = Math.ceil(length / chunkSize);
+    this.manager = manager;
+    this.progressiveDataLength = 0;
+    this.lastSuccessfulEnsureByteChunk = -1;
+  }
+
+  getMissingChunks() {
+    const chunks = [];
+
+    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
+      if (!this._loadedChunks.has(chunk)) {
+        chunks.push(chunk);
+      }
+    }
+
+    return chunks;
+  }
+
+  getBaseStreams() {
+    return [this];
+  }
+
+  get numChunksLoaded() {
+    return this._loadedChunks.size;
+  }
+
+  allChunksLoaded() {
+    return this.numChunksLoaded === this.numChunks;
+  }
+
+  onReceiveData(begin, chunk) {
+    const chunkSize = this.chunkSize;
+
+    if (begin % chunkSize !== 0) {
+      throw new Error(`Bad begin offset: ${begin}`);
+    }
+
+    const end = begin + chunk.byteLength;
+
+    if (end % chunkSize !== 0 && end !== this.bytes.length) {
+      throw new Error(`Bad end offset: ${end}`);
+    }
+
+    this.bytes.set(new Uint8Array(chunk), begin);
+    const beginChunk = Math.floor(begin / chunkSize);
+    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
+
+    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
+      this._loadedChunks.add(curChunk);
+    }
+  }
+
+  onReceiveProgressiveData(data) {
+    let position = this.progressiveDataLength;
+    const beginChunk = Math.floor(position / this.chunkSize);
+    this.bytes.set(new Uint8Array(data), position);
+    position += data.byteLength;
+    this.progressiveDataLength = position;
+    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
+
+    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
+      this._loadedChunks.add(curChunk);
+    }
+  }
+
+  ensureByte(pos) {
+    if (pos < this.progressiveDataLength) {
+      return;
+    }
+
+    const chunk = Math.floor(pos / this.chunkSize);
+
+    if (chunk === this.lastSuccessfulEnsureByteChunk) {
+      return;
+    }
+
+    if (!this._loadedChunks.has(chunk)) {
+      throw new _core_utils.MissingDataException(pos, pos + 1);
+    }
+
+    this.lastSuccessfulEnsureByteChunk = chunk;
+  }
+
+  ensureRange(begin, end) {
+    if (begin >= end) {
+      return;
+    }
+
+    if (end <= this.progressiveDataLength) {
+      return;
+    }
+
+    const chunkSize = this.chunkSize;
+    const beginChunk = Math.floor(begin / chunkSize);
+    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
+
+    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
+      if (!this._loadedChunks.has(chunk)) {
+        throw new _core_utils.MissingDataException(begin, end);
+      }
+    }
+  }
+
+  nextEmptyChunk(beginChunk) {
+    const numChunks = this.numChunks;
+
+    for (let i = 0; i < numChunks; ++i) {
+      const chunk = (beginChunk + i) % numChunks;
+
+      if (!this._loadedChunks.has(chunk)) {
+        return chunk;
+      }
+    }
+
+    return null;
+  }
+
+  hasChunk(chunk) {
+    return this._loadedChunks.has(chunk);
+  }
+
+  get length() {
+    return this.end - this.start;
+  }
+
+  get isEmpty() {
+    return this.length === 0;
+  }
+
+  getByte() {
+    const pos = this.pos;
+
+    if (pos >= this.end) {
+      return -1;
+    }
+
+    if (pos >= this.progressiveDataLength) {
+      this.ensureByte(pos);
+    }
+
+    return this.bytes[this.pos++];
+  }
+
+  getUint16() {
+    const b0 = this.getByte();
+    const b1 = this.getByte();
+
+    if (b0 === -1 || b1 === -1) {
+      return -1;
+    }
+
+    return (b0 << 8) + b1;
+  }
+
+  getInt32() {
+    const b0 = this.getByte();
+    const b1 = this.getByte();
+    const b2 = this.getByte();
+    const b3 = this.getByte();
+    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+  }
+
+  getBytes(length, forceClamped = false) {
+    const bytes = this.bytes;
+    const pos = this.pos;
+    const strEnd = this.end;
+
+    if (!length) {
+      if (strEnd > this.progressiveDataLength) {
+        this.ensureRange(pos, strEnd);
+      }
+
+      const subarray = bytes.subarray(pos, strEnd);
+      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+    }
+
+    let end = pos + length;
+
+    if (end > strEnd) {
+      end = strEnd;
+    }
+
+    if (end > this.progressiveDataLength) {
+      this.ensureRange(pos, end);
+    }
+
+    this.pos = end;
+    const subarray = bytes.subarray(pos, end);
+    return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+  }
+
+  peekByte() {
+    const peekedByte = this.getByte();
+
+    if (peekedByte !== -1) {
+      this.pos--;
+    }
+
+    return peekedByte;
+  }
+
+  peekBytes(length, forceClamped = false) {
+    const bytes = this.getBytes(length, forceClamped);
+    this.pos -= bytes.length;
+    return bytes;
+  }
+
+  getByteRange(begin, end) {
+    if (begin < 0) {
+      begin = 0;
+    }
+
+    if (end > this.end) {
+      end = this.end;
+    }
+
+    if (end > this.progressiveDataLength) {
+      this.ensureRange(begin, end);
+    }
+
+    return this.bytes.subarray(begin, end);
+  }
+
+  skip(n) {
+    if (!n) {
+      n = 1;
+    }
+
+    this.pos += n;
+  }
+
+  reset() {
+    this.pos = this.start;
+  }
+
+  moveStart() {
+    this.start = this.pos;
+  }
+
+  makeSubStream(start, length, dict) {
+    if (length) {
+      if (start + length > this.progressiveDataLength) {
+        this.ensureRange(start, start + length);
+      }
+    } else {
+      if (start >= this.progressiveDataLength) {
+        this.ensureByte(start);
+      }
+    }
+
+    function ChunkedStreamSubstream() {}
+
+    ChunkedStreamSubstream.prototype = Object.create(this);
+
+    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
+      const chunkSize = this.chunkSize;
+      const beginChunk = Math.floor(this.start / chunkSize);
+      const endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
+      const missingChunks = [];
+
+      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
+        if (!this._loadedChunks.has(chunk)) {
+          missingChunks.push(chunk);
+        }
+      }
+
+      return missingChunks;
+    };
+
+    ChunkedStreamSubstream.prototype.allChunksLoaded = function () {
+      if (this.numChunksLoaded === this.numChunks) {
+        return true;
+      }
+
+      return this.getMissingChunks().length === 0;
+    };
+
+    const subStream = new ChunkedStreamSubstream();
+    subStream.pos = subStream.start = start;
+    subStream.end = start + length || this.end;
+    subStream.dict = dict;
+    return subStream;
+  }
+
+}
+
+exports.ChunkedStream = ChunkedStream;
+
+class ChunkedStreamManager {
+  constructor(pdfNetworkStream, args) {
+    this.length = args.length;
+    this.chunkSize = args.rangeChunkSize;
+    this.stream = new ChunkedStream(this.length, this.chunkSize, this);
+    this.pdfNetworkStream = pdfNetworkStream;
+    this.disableAutoFetch = args.disableAutoFetch;
+    this.msgHandler = args.msgHandler;
+    this.currRequestId = 0;
+    this._chunksNeededByRequest = new Map();
+    this._requestsByChunk = new Map();
+    this._promisesByRequest = new Map();
+    this.progressiveDataLength = 0;
+    this.aborted = false;
+    this._loadedStreamCapability = (0, _util.createPromiseCapability)();
+  }
+
+  onLoadedStream() {
+    return this._loadedStreamCapability.promise;
+  }
+
+  sendRequest(begin, end) {
+    const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
+
+    if (!rangeReader.isStreamingSupported) {
+      rangeReader.onProgress = this.onProgress.bind(this);
+    }
+
+    let chunks = [],
+        loaded = 0;
+    const promise = new Promise((resolve, reject) => {
+      const readChunk = chunk => {
+        try {
+          if (!chunk.done) {
+            const data = chunk.value;
+            chunks.push(data);
+            loaded += (0, _util.arrayByteLength)(data);
+
+            if (rangeReader.isStreamingSupported) {
+              this.onProgress({
+                loaded
+              });
+            }
+
+            rangeReader.read().then(readChunk, reject);
+            return;
+          }
+
+          const chunkData = (0, _util.arraysToBytes)(chunks);
+          chunks = null;
+          resolve(chunkData);
+        } catch (e) {
+          reject(e);
+        }
+      };
+
+      rangeReader.read().then(readChunk, reject);
+    });
+    promise.then(data => {
+      if (this.aborted) {
+        return;
+      }
+
+      this.onReceiveData({
+        chunk: data,
+        begin
+      });
+    });
+  }
+
+  requestAllChunks() {
+    const missingChunks = this.stream.getMissingChunks();
+
+    this._requestChunks(missingChunks);
+
+    return this._loadedStreamCapability.promise;
+  }
+
+  _requestChunks(chunks) {
+    const requestId = this.currRequestId++;
+    const chunksNeeded = new Set();
+
+    this._chunksNeededByRequest.set(requestId, chunksNeeded);
+
+    for (const chunk of chunks) {
+      if (!this.stream.hasChunk(chunk)) {
+        chunksNeeded.add(chunk);
+      }
+    }
+
+    if (chunksNeeded.size === 0) {
+      return Promise.resolve();
+    }
+
+    const capability = (0, _util.createPromiseCapability)();
+
+    this._promisesByRequest.set(requestId, capability);
+
+    const chunksToRequest = [];
+
+    for (const chunk of chunksNeeded) {
+      let requestIds = this._requestsByChunk.get(chunk);
+
+      if (!requestIds) {
+        requestIds = [];
+
+        this._requestsByChunk.set(chunk, requestIds);
+
+        chunksToRequest.push(chunk);
+      }
+
+      requestIds.push(requestId);
+    }
+
+    if (chunksToRequest.length > 0) {
+      const groupedChunksToRequest = this.groupChunks(chunksToRequest);
+
+      for (const groupedChunk of groupedChunksToRequest) {
+        const begin = groupedChunk.beginChunk * this.chunkSize;
+        const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
+        this.sendRequest(begin, end);
+      }
+    }
+
+    return capability.promise.catch(reason => {
+      if (this.aborted) {
+        return;
+      }
+
+      throw reason;
+    });
+  }
+
+  getStream() {
+    return this.stream;
+  }
+
+  requestRange(begin, end) {
+    end = Math.min(end, this.length);
+    const beginChunk = this.getBeginChunk(begin);
+    const endChunk = this.getEndChunk(end);
+    const chunks = [];
+
+    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
+      chunks.push(chunk);
+    }
+
+    return this._requestChunks(chunks);
+  }
+
+  requestRanges(ranges = []) {
+    const chunksToRequest = [];
+
+    for (const range of ranges) {
+      const beginChunk = this.getBeginChunk(range.begin);
+      const endChunk = this.getEndChunk(range.end);
+
+      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
+        if (!chunksToRequest.includes(chunk)) {
+          chunksToRequest.push(chunk);
+        }
+      }
+    }
+
+    chunksToRequest.sort(function (a, b) {
+      return a - b;
+    });
+    return this._requestChunks(chunksToRequest);
+  }
+
+  groupChunks(chunks) {
+    const groupedChunks = [];
+    let beginChunk = -1;
+    let prevChunk = -1;
+
+    for (let i = 0, ii = chunks.length; i < ii; ++i) {
+      const chunk = chunks[i];
+
+      if (beginChunk < 0) {
+        beginChunk = chunk;
+      }
+
+      if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
+        groupedChunks.push({
+          beginChunk,
+          endChunk: prevChunk + 1
+        });
+        beginChunk = chunk;
+      }
+
+      if (i + 1 === chunks.length) {
+        groupedChunks.push({
+          beginChunk,
+          endChunk: chunk + 1
+        });
+      }
+
+      prevChunk = chunk;
+    }
+
+    return groupedChunks;
+  }
+
+  onProgress(args) {
+    this.msgHandler.send("DocProgress", {
+      loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
+      total: this.length
+    });
+  }
+
+  onReceiveData(args) {
+    const chunk = args.chunk;
+    const isProgressive = args.begin === undefined;
+    const begin = isProgressive ? this.progressiveDataLength : args.begin;
+    const end = begin + chunk.byteLength;
+    const beginChunk = Math.floor(begin / this.chunkSize);
+    const endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);
+
+    if (isProgressive) {
+      this.stream.onReceiveProgressiveData(chunk);
+      this.progressiveDataLength = end;
+    } else {
+      this.stream.onReceiveData(begin, chunk);
+    }
+
+    if (this.stream.allChunksLoaded()) {
+      this._loadedStreamCapability.resolve(this.stream);
+    }
+
+    const loadedRequests = [];
+
+    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
+      const requestIds = this._requestsByChunk.get(curChunk);
+
+      if (!requestIds) {
+        continue;
+      }
+
+      this._requestsByChunk.delete(curChunk);
+
+      for (const requestId of requestIds) {
+        const chunksNeeded = this._chunksNeededByRequest.get(requestId);
+
+        if (chunksNeeded.has(curChunk)) {
+          chunksNeeded.delete(curChunk);
+        }
+
+        if (chunksNeeded.size > 0) {
+          continue;
+        }
+
+        loadedRequests.push(requestId);
+      }
+    }
+
+    if (!this.disableAutoFetch && this._requestsByChunk.size === 0) {
+      let nextEmptyChunk;
+
+      if (this.stream.numChunksLoaded === 1) {
+        const lastChunk = this.stream.numChunks - 1;
+
+        if (!this.stream.hasChunk(lastChunk)) {
+          nextEmptyChunk = lastChunk;
+        }
+      } else {
+        nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
+      }
+
+      if (Number.isInteger(nextEmptyChunk)) {
+        this._requestChunks([nextEmptyChunk]);
+      }
+    }
+
+    for (const requestId of loadedRequests) {
+      const capability = this._promisesByRequest.get(requestId);
+
+      this._promisesByRequest.delete(requestId);
+
+      capability.resolve();
+    }
+
+    this.msgHandler.send("DocProgress", {
+      loaded: this.stream.numChunksLoaded * this.chunkSize,
+      total: this.length
+    });
+  }
+
+  onError(err) {
+    this._loadedStreamCapability.reject(err);
+  }
+
+  getBeginChunk(begin) {
+    return Math.floor(begin / this.chunkSize);
+  }
+
+  getEndChunk(end) {
+    return Math.floor((end - 1) / this.chunkSize) + 1;
+  }
+
+  abort(reason) {
+    this.aborted = true;
+
+    if (this.pdfNetworkStream) {
+      this.pdfNetworkStream.cancelAllRequests(reason);
+    }
+
+    for (const capability of this._promisesByRequest.values()) {
+      capability.reject(reason);
+    }
+  }
+
+}
+
+exports.ChunkedStreamManager = ChunkedStreamManager;
+
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.collectActions = collectActions;
+exports.escapePDFName = escapePDFName;
+exports.getArrayLookupTableFactory = getArrayLookupTableFactory;
+exports.getInheritableProperty = getInheritableProperty;
+exports.getLookupTableFactory = getLookupTableFactory;
+exports.isWhiteSpace = isWhiteSpace;
+exports.log2 = log2;
+exports.parseXFAPath = parseXFAPath;
+exports.readInt8 = readInt8;
+exports.readUint16 = readUint16;
+exports.readUint32 = readUint32;
+exports.toRomanNumerals = toRomanNumerals;
+exports.XRefParseException = exports.XRefEntryException = exports.MissingDataException = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+function getLookupTableFactory(initializer) {
+  let lookup;
+  return function () {
+    if (initializer) {
+      lookup = Object.create(null);
+      initializer(lookup);
+      initializer = null;
+    }
+
+    return lookup;
+  };
+}
+
+function getArrayLookupTableFactory(initializer) {
+  let lookup;
+  return function () {
+    if (initializer) {
+      let arr = initializer();
+      initializer = null;
+      lookup = Object.create(null);
+
+      for (let i = 0, ii = arr.length; i < ii; i += 2) {
+        lookup[arr[i]] = arr[i + 1];
+      }
+
+      arr = null;
+    }
+
+    return lookup;
+  };
+}
+
+class MissingDataException extends _util.BaseException {
+  constructor(begin, end) {
+    super(`Missing data [${begin}, ${end})`);
+    this.begin = begin;
+    this.end = end;
+  }
+
+}
+
+exports.MissingDataException = MissingDataException;
+
+class XRefEntryException extends _util.BaseException {}
+
+exports.XRefEntryException = XRefEntryException;
+
+class XRefParseException extends _util.BaseException {}
+
+exports.XRefParseException = XRefParseException;
+
+function getInheritableProperty({
+  dict,
+  key,
+  getArray = false,
+  stopWhenFound = true
+}) {
+  const LOOP_LIMIT = 100;
+  let loopCount = 0;
+  let values;
+
+  while (dict) {
+    const value = getArray ? dict.getArray(key) : dict.get(key);
+
+    if (value !== undefined) {
+      if (stopWhenFound) {
+        return value;
+      }
+
+      if (!values) {
+        values = [];
+      }
+
+      values.push(value);
+    }
+
+    if (++loopCount > LOOP_LIMIT) {
+      (0, _util.warn)(`getInheritableProperty: maximum loop count exceeded for "${key}"`);
+      break;
+    }
+
+    dict = dict.get("Parent");
+  }
+
+  return values;
+}
+
+const ROMAN_NUMBER_MAP = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
+
+function toRomanNumerals(number, lowerCase = false) {
+  (0, _util.assert)(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
+  const romanBuf = [];
+  let pos;
+
+  while (number >= 1000) {
+    number -= 1000;
+    romanBuf.push("M");
+  }
+
+  pos = number / 100 | 0;
+  number %= 100;
+  romanBuf.push(ROMAN_NUMBER_MAP[pos]);
+  pos = number / 10 | 0;
+  number %= 10;
+  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
+  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
+  const romanStr = romanBuf.join("");
+  return lowerCase ? romanStr.toLowerCase() : romanStr;
+}
+
+function log2(x) {
+  if (x <= 0) {
+    return 0;
+  }
+
+  return Math.ceil(Math.log2(x));
+}
+
+function readInt8(data, offset) {
+  return data[offset] << 24 >> 24;
+}
+
+function readUint16(data, offset) {
+  return data[offset] << 8 | data[offset + 1];
+}
+
+function readUint32(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+
+function isWhiteSpace(ch) {
+  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+}
+
+function parseXFAPath(path) {
+  const positionPattern = /(.+)\[([0-9]+)\]$/;
+  return path.split(".").map(component => {
+    const m = component.match(positionPattern);
+
+    if (m) {
+      return {
+        name: m[1],
+        pos: parseInt(m[2], 10)
+      };
+    }
+
+    return {
+      name: component,
+      pos: 0
+    };
+  });
+}
+
+function escapePDFName(str) {
+  const buffer = [];
+  let start = 0;
+
+  for (let i = 0, ii = str.length; i < ii; i++) {
+    const char = str.charCodeAt(i);
+
+    if (char < 0x21 || char > 0x7e || char === 0x23 || char === 0x28 || char === 0x29 || char === 0x3c || char === 0x3e || char === 0x5b || char === 0x5d || char === 0x7b || char === 0x7d || char === 0x2f || char === 0x25) {
+      if (start < i) {
+        buffer.push(str.substring(start, i));
+      }
+
+      buffer.push(`#${char.toString(16)}`);
+      start = i + 1;
+    }
+  }
+
+  if (buffer.length === 0) {
+    return str;
+  }
+
+  if (start < str.length) {
+    buffer.push(str.substring(start, str.length));
+  }
+
+  return buffer.join("");
+}
+
+function _collectJS(entry, xref, list, parents) {
+  if (!entry) {
+    return;
+  }
+
+  let parent = null;
+
+  if ((0, _primitives.isRef)(entry)) {
+    if (parents.has(entry)) {
+      return;
+    }
+
+    parent = entry;
+    parents.put(parent);
+    entry = xref.fetch(entry);
+  }
+
+  if (Array.isArray(entry)) {
+    for (const element of entry) {
+      _collectJS(element, xref, list, parents);
+    }
+  } else if (entry instanceof _primitives.Dict) {
+    if ((0, _primitives.isName)(entry.get("S"), "JavaScript") && entry.has("JS")) {
+      const js = entry.get("JS");
+      let code;
+
+      if ((0, _primitives.isStream)(js)) {
+        code = (0, _util.bytesToString)(js.getBytes());
+      } else {
+        code = js;
+      }
+
+      code = (0, _util.stringToPDFString)(code);
+
+      if (code) {
+        list.push(code);
+      }
+    }
+
+    _collectJS(entry.getRaw("Next"), xref, list, parents);
+  }
+
+  if (parent) {
+    parents.remove(parent);
+  }
+}
+
+function collectActions(xref, dict, eventType) {
+  const actions = Object.create(null);
+
+  if (dict.has("AA")) {
+    const additionalActions = dict.get("AA");
+
+    for (const key of additionalActions.getKeys()) {
+      const action = eventType[key];
+
+      if (!action) {
+        continue;
+      }
+
+      const actionDict = additionalActions.getRaw(key);
+      const parents = new _primitives.RefSet();
+      const list = [];
+
+      _collectJS(actionDict, xref, list, parents);
+
+      if (list.length > 0) {
+        actions[action] = list;
+      }
+    }
+  }
+
+  if (dict.has("A")) {
+    const actionDict = dict.get("A");
+    const parents = new _primitives.RefSet();
+    const list = [];
+
+    _collectJS(actionDict, xref, list, parents);
+
+    if (list.length > 0) {
+      actions.Action = list;
+    }
+  }
+
+  return (0, _util.objectSize)(actions) > 0 ? actions : null;
+}
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFDocument = exports.Page = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _obj = __w_pdfjs_require__(10);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _annotation = __w_pdfjs_require__(25);
+
+var _crypto = __w_pdfjs_require__(22);
+
+var _parser = __w_pdfjs_require__(11);
+
+var _operator_list = __w_pdfjs_require__(26);
+
+var _evaluator = __w_pdfjs_require__(29);
+
+const DEFAULT_USER_UNIT = 1.0;
+const LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];
+
+function isAnnotationRenderable(annotation, intent) {
+  return intent === "display" && annotation.viewable || intent === "print" && annotation.printable;
+}
+
+class Page {
+  constructor({
+    pdfManager,
+    xref,
+    pageIndex,
+    pageDict,
+    ref,
+    globalIdFactory,
+    fontCache,
+    builtInCMapCache,
+    globalImageCache,
+    nonBlendModesSet
+  }) {
+    this.pdfManager = pdfManager;
+    this.pageIndex = pageIndex;
+    this.pageDict = pageDict;
+    this.xref = xref;
+    this.ref = ref;
+    this.fontCache = fontCache;
+    this.builtInCMapCache = builtInCMapCache;
+    this.globalImageCache = globalImageCache;
+    this.nonBlendModesSet = nonBlendModesSet;
+    this.evaluatorOptions = pdfManager.evaluatorOptions;
+    this.resourcesPromise = null;
+    const idCounters = {
+      obj: 0
+    };
+    this._localIdFactory = class extends globalIdFactory {
+      static createObjId() {
+        return `p${pageIndex}_${++idCounters.obj}`;
+      }
+
+    };
+  }
+
+  _getInheritableProperty(key, getArray = false) {
+    const value = (0, _core_utils.getInheritableProperty)({
+      dict: this.pageDict,
+      key,
+      getArray,
+      stopWhenFound: false
+    });
+
+    if (!Array.isArray(value)) {
+      return value;
+    }
+
+    if (value.length === 1 || !(0, _primitives.isDict)(value[0])) {
+      return value[0];
+    }
+
+    return _primitives.Dict.merge({
+      xref: this.xref,
+      dictArray: value
+    });
+  }
+
+  get content() {
+    return this.pageDict.get("Contents");
+  }
+
+  get resources() {
+    return (0, _util.shadow)(this, "resources", this._getInheritableProperty("Resources") || _primitives.Dict.empty);
+  }
+
+  _getBoundingBox(name) {
+    const box = this._getInheritableProperty(name, true);
+
+    if (Array.isArray(box) && box.length === 4) {
+      if (box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
+        return box;
+      }
+
+      (0, _util.warn)(`Empty /${name} entry.`);
+    }
+
+    return null;
+  }
+
+  get mediaBox() {
+    return (0, _util.shadow)(this, "mediaBox", this._getBoundingBox("MediaBox") || LETTER_SIZE_MEDIABOX);
+  }
+
+  get cropBox() {
+    return (0, _util.shadow)(this, "cropBox", this._getBoundingBox("CropBox") || this.mediaBox);
+  }
+
+  get userUnit() {
+    let obj = this.pageDict.get("UserUnit");
+
+    if (!(0, _util.isNum)(obj) || obj <= 0) {
+      obj = DEFAULT_USER_UNIT;
+    }
+
+    return (0, _util.shadow)(this, "userUnit", obj);
+  }
+
+  get view() {
+    const {
+      cropBox,
+      mediaBox
+    } = this;
+    let view;
+
+    if (cropBox === mediaBox || (0, _util.isArrayEqual)(cropBox, mediaBox)) {
+      view = mediaBox;
+    } else {
+      const box = _util.Util.intersect(cropBox, mediaBox);
+
+      if (box && box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
+        view = box;
+      } else {
+        (0, _util.warn)("Empty /CropBox and /MediaBox intersection.");
+      }
+    }
+
+    return (0, _util.shadow)(this, "view", view || mediaBox);
+  }
+
+  get rotate() {
+    let rotate = this._getInheritableProperty("Rotate") || 0;
+
+    if (rotate % 90 !== 0) {
+      rotate = 0;
+    } else if (rotate >= 360) {
+      rotate = rotate % 360;
+    } else if (rotate < 0) {
+      rotate = (rotate % 360 + 360) % 360;
+    }
+
+    return (0, _util.shadow)(this, "rotate", rotate);
+  }
+
+  getContentStream() {
+    const content = this.content;
+    let stream;
+
+    if (Array.isArray(content)) {
+      const xref = this.xref;
+      const streams = [];
+
+      for (const subStream of content) {
+        streams.push(xref.fetchIfRef(subStream));
+      }
+
+      stream = new _stream.StreamsSequenceStream(streams);
+    } else if ((0, _primitives.isStream)(content)) {
+      stream = content;
+    } else {
+      stream = new _stream.NullStream();
+    }
+
+    return stream;
+  }
+
+  save(handler, task, annotationStorage) {
+    const partialEvaluator = new _evaluator.PartialEvaluator({
+      xref: this.xref,
+      handler,
+      pageIndex: this.pageIndex,
+      idFactory: this._localIdFactory,
+      fontCache: this.fontCache,
+      builtInCMapCache: this.builtInCMapCache,
+      globalImageCache: this.globalImageCache,
+      options: this.evaluatorOptions
+    });
+    return this._parsedAnnotations.then(function (annotations) {
+      const newRefsPromises = [];
+
+      for (const annotation of annotations) {
+        if (!isAnnotationRenderable(annotation, "print")) {
+          continue;
+        }
+
+        newRefsPromises.push(annotation.save(partialEvaluator, task, annotationStorage).catch(function (reason) {
+          (0, _util.warn)("save - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
+          return null;
+        }));
+      }
+
+      return Promise.all(newRefsPromises);
+    });
+  }
+
+  loadResources(keys) {
+    if (!this.resourcesPromise) {
+      this.resourcesPromise = this.pdfManager.ensure(this, "resources");
+    }
+
+    return this.resourcesPromise.then(() => {
+      const objectLoader = new _obj.ObjectLoader(this.resources, keys, this.xref);
+      return objectLoader.load();
+    });
+  }
+
+  getOperatorList({
+    handler,
+    sink,
+    task,
+    intent,
+    renderInteractiveForms,
+    annotationStorage
+  }) {
+    const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
+    const resourcesPromise = this.loadResources(["ExtGState", "ColorSpace", "Pattern", "Shading", "XObject", "Font"]);
+    const partialEvaluator = new _evaluator.PartialEvaluator({
+      xref: this.xref,
+      handler,
+      pageIndex: this.pageIndex,
+      idFactory: this._localIdFactory,
+      fontCache: this.fontCache,
+      builtInCMapCache: this.builtInCMapCache,
+      globalImageCache: this.globalImageCache,
+      options: this.evaluatorOptions
+    });
+    const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
+    const pageListPromise = dataPromises.then(([contentStream]) => {
+      const opList = new _operator_list.OperatorList(intent, sink);
+      handler.send("StartRenderPage", {
+        transparency: partialEvaluator.hasBlendModes(this.resources, this.nonBlendModesSet),
+        pageIndex: this.pageIndex,
+        intent
+      });
+      return partialEvaluator.getOperatorList({
+        stream: contentStream,
+        task,
+        resources: this.resources,
+        operatorList: opList
+      }).then(function () {
+        return opList;
+      });
+    });
+    return Promise.all([pageListPromise, this._parsedAnnotations]).then(function ([pageOpList, annotations]) {
+      if (annotations.length === 0) {
+        pageOpList.flush(true);
+        return {
+          length: pageOpList.totalLength
+        };
+      }
+
+      const opListPromises = [];
+
+      for (const annotation of annotations) {
+        if (isAnnotationRenderable(annotation, intent) && !annotation.isHidden(annotationStorage)) {
+          opListPromises.push(annotation.getOperatorList(partialEvaluator, task, renderInteractiveForms, annotationStorage).catch(function (reason) {
+            (0, _util.warn)("getOperatorList - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
+            return null;
+          }));
+        }
+      }
+
+      return Promise.all(opListPromises).then(function (opLists) {
+        pageOpList.addOp(_util.OPS.beginAnnotations, []);
+
+        for (const opList of opLists) {
+          pageOpList.addOpList(opList);
+        }
+
+        pageOpList.addOp(_util.OPS.endAnnotations, []);
+        pageOpList.flush(true);
+        return {
+          length: pageOpList.totalLength
+        };
+      });
+    });
+  }
+
+  extractTextContent({
+    handler,
+    task,
+    normalizeWhitespace,
+    sink,
+    combineTextItems
+  }) {
+    const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
+    const resourcesPromise = this.loadResources(["ExtGState", "XObject", "Font"]);
+    const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
+    return dataPromises.then(([contentStream]) => {
+      const partialEvaluator = new _evaluator.PartialEvaluator({
+        xref: this.xref,
+        handler,
+        pageIndex: this.pageIndex,
+        idFactory: this._localIdFactory,
+        fontCache: this.fontCache,
+        builtInCMapCache: this.builtInCMapCache,
+        globalImageCache: this.globalImageCache,
+        options: this.evaluatorOptions
+      });
+      return partialEvaluator.getTextContent({
+        stream: contentStream,
+        task,
+        resources: this.resources,
+        normalizeWhitespace,
+        combineTextItems,
+        sink
+      });
+    });
+  }
+
+  getAnnotationsData(intent) {
+    return this._parsedAnnotations.then(function (annotations) {
+      const annotationsData = [];
+
+      for (let i = 0, ii = annotations.length; i < ii; i++) {
+        if (!intent || isAnnotationRenderable(annotations[i], intent)) {
+          annotationsData.push(annotations[i].data);
+        }
+      }
+
+      return annotationsData;
+    });
+  }
+
+  get annotations() {
+    const annots = this._getInheritableProperty("Annots");
+
+    return (0, _util.shadow)(this, "annotations", Array.isArray(annots) ? annots : []);
+  }
+
+  get _parsedAnnotations() {
+    const parsedAnnotations = this.pdfManager.ensure(this, "annotations").then(() => {
+      const annotationPromises = [];
+
+      for (const annotationRef of this.annotations) {
+        annotationPromises.push(_annotation.AnnotationFactory.create(this.xref, annotationRef, this.pdfManager, this._localIdFactory).catch(function (reason) {
+          (0, _util.warn)(`_parsedAnnotations: "${reason}".`);
+          return null;
+        }));
+      }
+
+      return Promise.all(annotationPromises).then(function (annotations) {
+        return annotations.filter(annotation => !!annotation);
+      });
+    });
+    return (0, _util.shadow)(this, "_parsedAnnotations", parsedAnnotations);
+  }
+
+  get jsActions() {
+    const actions = (0, _core_utils.collectActions)(this.xref, this.pageDict, _util.PageActionEventType);
+    return (0, _util.shadow)(this, "jsActions", actions);
+  }
+
+}
+
+exports.Page = Page;
+const PDF_HEADER_SIGNATURE = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
+const STARTXREF_SIGNATURE = new Uint8Array([0x73, 0x74, 0x61, 0x72, 0x74, 0x78, 0x72, 0x65, 0x66]);
+const ENDOBJ_SIGNATURE = new Uint8Array([0x65, 0x6e, 0x64, 0x6f, 0x62, 0x6a]);
+const FINGERPRINT_FIRST_BYTES = 1024;
+const EMPTY_FINGERPRINT = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
+const PDF_HEADER_VERSION_REGEXP = /^[1-9]\.[0-9]$/;
+
+function find(stream, signature, limit = 1024, backwards = false) {
+  const signatureLength = signature.length;
+  const scanBytes = stream.peekBytes(limit);
+  const scanLength = scanBytes.length - signatureLength;
+
+  if (scanLength <= 0) {
+    return false;
+  }
+
+  if (backwards) {
+    const signatureEnd = signatureLength - 1;
+    let pos = scanBytes.length - 1;
+
+    while (pos >= signatureEnd) {
+      let j = 0;
+
+      while (j < signatureLength && scanBytes[pos - j] === signature[signatureEnd - j]) {
+        j++;
+      }
+
+      if (j >= signatureLength) {
+        stream.pos += pos - signatureEnd;
+        return true;
+      }
+
+      pos--;
+    }
+  } else {
+    let pos = 0;
+
+    while (pos <= scanLength) {
+      let j = 0;
+
+      while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
+        j++;
+      }
+
+      if (j >= signatureLength) {
+        stream.pos += pos;
+        return true;
+      }
+
+      pos++;
+    }
+  }
+
+  return false;
+}
+
+class PDFDocument {
+  constructor(pdfManager, arg) {
+    let stream;
+
+    if ((0, _primitives.isStream)(arg)) {
+      stream = arg;
+    } else if ((0, _util.isArrayBuffer)(arg)) {
+      stream = new _stream.Stream(arg);
+    } else {
+      throw new Error("PDFDocument: Unknown argument type");
+    }
+
+    if (stream.length <= 0) {
+      throw new _util.InvalidPDFException("The PDF file is empty, i.e. its size is zero bytes.");
+    }
+
+    this.pdfManager = pdfManager;
+    this.stream = stream;
+    this.xref = new _obj.XRef(stream, pdfManager);
+    this._pagePromises = [];
+    this._version = null;
+    const idCounters = {
+      font: 0
+    };
+    this._globalIdFactory = class {
+      static getDocId() {
+        return `g_${pdfManager.docId}`;
+      }
+
+      static createFontId() {
+        return `f${++idCounters.font}`;
+      }
+
+      static createObjId() {
+        (0, _util.unreachable)("Abstract method `createObjId` called.");
+      }
+
+    };
+  }
+
+  parse(recoveryMode) {
+    this.xref.parse(recoveryMode);
+    this.catalog = new _obj.Catalog(this.pdfManager, this.xref);
+
+    if (this.catalog.version) {
+      this._version = this.catalog.version;
+    }
+  }
+
+  get linearization() {
+    let linearization = null;
+
+    try {
+      linearization = _parser.Linearization.create(this.stream);
+    } catch (err) {
+      if (err instanceof _core_utils.MissingDataException) {
+        throw err;
+      }
+
+      (0, _util.info)(err);
+    }
+
+    return (0, _util.shadow)(this, "linearization", linearization);
+  }
+
+  get startXRef() {
+    const stream = this.stream;
+    let startXRef = 0;
+
+    if (this.linearization) {
+      stream.reset();
+
+      if (find(stream, ENDOBJ_SIGNATURE)) {
+        startXRef = stream.pos + 6 - stream.start;
+      }
+    } else {
+      const step = 1024;
+      const startXRefLength = STARTXREF_SIGNATURE.length;
+      let found = false,
+          pos = stream.end;
+
+      while (!found && pos > 0) {
+        pos -= step - startXRefLength;
+
+        if (pos < 0) {
+          pos = 0;
+        }
+
+        stream.pos = pos;
+        found = find(stream, STARTXREF_SIGNATURE, step, true);
+      }
+
+      if (found) {
+        stream.skip(9);
+        let ch;
+
+        do {
+          ch = stream.getByte();
+        } while ((0, _core_utils.isWhiteSpace)(ch));
+
+        let str = "";
+
+        while (ch >= 0x20 && ch <= 0x39) {
+          str += String.fromCharCode(ch);
+          ch = stream.getByte();
+        }
+
+        startXRef = parseInt(str, 10);
+
+        if (isNaN(startXRef)) {
+          startXRef = 0;
+        }
+      }
+    }
+
+    return (0, _util.shadow)(this, "startXRef", startXRef);
+  }
+
+  checkHeader() {
+    const stream = this.stream;
+    stream.reset();
+
+    if (!find(stream, PDF_HEADER_SIGNATURE)) {
+      return;
+    }
+
+    stream.moveStart();
+    const MAX_PDF_VERSION_LENGTH = 12;
+    let version = "",
+        ch;
+
+    while ((ch = stream.getByte()) > 0x20) {
+      if (version.length >= MAX_PDF_VERSION_LENGTH) {
+        break;
+      }
+
+      version += String.fromCharCode(ch);
+    }
+
+    if (!this._version) {
+      this._version = version.substring(5);
+    }
+  }
+
+  parseStartXRef() {
+    this.xref.setStartXRef(this.startXRef);
+  }
+
+  get numPages() {
+    const linearization = this.linearization;
+    const num = linearization ? linearization.numPages : this.catalog.numPages;
+    return (0, _util.shadow)(this, "numPages", num);
+  }
+
+  _hasOnlyDocumentSignatures(fields, recursionDepth = 0) {
+    const RECURSION_LIMIT = 10;
+
+    if (!Array.isArray(fields)) {
+      return false;
+    }
+
+    return fields.every(field => {
+      field = this.xref.fetchIfRef(field);
+
+      if (!(field instanceof _primitives.Dict)) {
+        return false;
+      }
+
+      if (field.has("Kids")) {
+        if (++recursionDepth > RECURSION_LIMIT) {
+          (0, _util.warn)("_hasOnlyDocumentSignatures: maximum recursion depth reached");
+          return false;
+        }
+
+        return this._hasOnlyDocumentSignatures(field.get("Kids"), recursionDepth);
+      }
+
+      const isSignature = (0, _primitives.isName)(field.get("FT"), "Sig");
+      const rectangle = field.get("Rect");
+      const isInvisible = Array.isArray(rectangle) && rectangle.every(value => value === 0);
+      return isSignature && isInvisible;
+    });
+  }
+
+  get formInfo() {
+    const formInfo = {
+      hasFields: false,
+      hasAcroForm: false,
+      hasXfa: false
+    };
+    const acroForm = this.catalog.acroForm;
+
+    if (!acroForm) {
+      return (0, _util.shadow)(this, "formInfo", formInfo);
+    }
+
+    try {
+      const fields = acroForm.get("Fields");
+      const hasFields = Array.isArray(fields) && fields.length > 0;
+      formInfo.hasFields = hasFields;
+      const xfa = acroForm.get("XFA");
+      formInfo.hasXfa = Array.isArray(xfa) && xfa.length > 0 || (0, _primitives.isStream)(xfa) && !xfa.isEmpty;
+      const sigFlags = acroForm.get("SigFlags");
+
+      const hasOnlyDocumentSignatures = !!(sigFlags & 0x1) && this._hasOnlyDocumentSignatures(fields);
+
+      formInfo.hasAcroForm = hasFields && !hasOnlyDocumentSignatures;
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)(`Cannot fetch form information: "${ex}".`);
+    }
+
+    return (0, _util.shadow)(this, "formInfo", formInfo);
+  }
+
+  get documentInfo() {
+    const DocumentInfoValidators = {
+      Title: _util.isString,
+      Author: _util.isString,
+      Subject: _util.isString,
+      Keywords: _util.isString,
+      Creator: _util.isString,
+      Producer: _util.isString,
+      CreationDate: _util.isString,
+      ModDate: _util.isString,
+      Trapped: _primitives.isName
+    };
+    let version = this._version;
+
+    if (typeof version !== "string" || !PDF_HEADER_VERSION_REGEXP.test(version)) {
+      (0, _util.warn)(`Invalid PDF header version number: ${version}`);
+      version = null;
+    }
+
+    const docInfo = {
+      PDFFormatVersion: version,
+      IsLinearized: !!this.linearization,
+      IsAcroFormPresent: this.formInfo.hasAcroForm,
+      IsXFAPresent: this.formInfo.hasXfa,
+      IsCollectionPresent: !!this.catalog.collection
+    };
+    let infoDict;
+
+    try {
+      infoDict = this.xref.trailer.get("Info");
+    } catch (err) {
+      if (err instanceof _core_utils.MissingDataException) {
+        throw err;
+      }
+
+      (0, _util.info)("The document information dictionary is invalid.");
+    }
+
+    if ((0, _primitives.isDict)(infoDict)) {
+      for (const key of infoDict.getKeys()) {
+        const value = infoDict.get(key);
+
+        if (DocumentInfoValidators[key]) {
+          if (DocumentInfoValidators[key](value)) {
+            docInfo[key] = typeof value !== "string" ? value : (0, _util.stringToPDFString)(value);
+          } else {
+            (0, _util.info)(`Bad value in document info for "${key}".`);
+          }
+        } else if (typeof key === "string") {
+          let customValue;
+
+          if ((0, _util.isString)(value)) {
+            customValue = (0, _util.stringToPDFString)(value);
+          } else if ((0, _primitives.isName)(value) || (0, _util.isNum)(value) || (0, _util.isBool)(value)) {
+            customValue = value;
+          } else {
+            (0, _util.info)(`Unsupported value in document info for (custom) "${key}".`);
+            continue;
+          }
+
+          if (!docInfo.Custom) {
+            docInfo.Custom = Object.create(null);
+          }
+
+          docInfo.Custom[key] = customValue;
+        }
+      }
+    }
+
+    return (0, _util.shadow)(this, "documentInfo", docInfo);
+  }
+
+  get fingerprint() {
+    let hash;
+    const idArray = this.xref.trailer.get("ID");
+
+    if (Array.isArray(idArray) && idArray[0] && (0, _util.isString)(idArray[0]) && idArray[0] !== EMPTY_FINGERPRINT) {
+      hash = (0, _util.stringToBytes)(idArray[0]);
+    } else {
+      hash = (0, _crypto.calculateMD5)(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
+    }
+
+    const fingerprintBuf = [];
+
+    for (let i = 0, ii = hash.length; i < ii; i++) {
+      const hex = hash[i].toString(16);
+      fingerprintBuf.push(hex.padStart(2, "0"));
+    }
+
+    return (0, _util.shadow)(this, "fingerprint", fingerprintBuf.join(""));
+  }
+
+  _getLinearizationPage(pageIndex) {
+    const {
+      catalog,
+      linearization
+    } = this;
+
+    const ref = _primitives.Ref.get(linearization.objectNumberFirst, 0);
+
+    return this.xref.fetchAsync(ref).then(obj => {
+      if ((0, _primitives.isDict)(obj, "Page") || (0, _primitives.isDict)(obj) && !obj.has("Type") && obj.has("Contents")) {
+        if (ref && !catalog.pageKidsCountCache.has(ref)) {
+          catalog.pageKidsCountCache.put(ref, 1);
+        }
+
+        return [obj, ref];
+      }
+
+      throw new _util.FormatError("The Linearization dictionary doesn't point " + "to a valid Page dictionary.");
+    }).catch(reason => {
+      (0, _util.info)(reason);
+      return catalog.getPageDict(pageIndex);
+    });
+  }
+
+  getPage(pageIndex) {
+    if (this._pagePromises[pageIndex] !== undefined) {
+      return this._pagePromises[pageIndex];
+    }
+
+    const {
+      catalog,
+      linearization
+    } = this;
+    const promise = linearization && linearization.pageFirst === pageIndex ? this._getLinearizationPage(pageIndex) : catalog.getPageDict(pageIndex);
+    return this._pagePromises[pageIndex] = promise.then(([pageDict, ref]) => {
+      return new Page({
+        pdfManager: this.pdfManager,
+        xref: this.xref,
+        pageIndex,
+        pageDict,
+        ref,
+        globalIdFactory: this._globalIdFactory,
+        fontCache: catalog.fontCache,
+        builtInCMapCache: catalog.builtInCMapCache,
+        globalImageCache: catalog.globalImageCache,
+        nonBlendModesSet: catalog.nonBlendModesSet
+      });
+    });
+  }
+
+  checkFirstPage() {
+    return this.getPage(0).catch(async reason => {
+      if (reason instanceof _core_utils.XRefEntryException) {
+        this._pagePromises.length = 0;
+        await this.cleanup();
+        throw new _core_utils.XRefParseException();
+      }
+    });
+  }
+
+  fontFallback(id, handler) {
+    return this.catalog.fontFallback(id, handler);
+  }
+
+  async cleanup(manuallyTriggered = false) {
+    return this.catalog ? this.catalog.cleanup(manuallyTriggered) : (0, _primitives.clearPrimitiveCaches)();
+  }
+
+  _collectFieldObjects(name, fieldRef, promises) {
+    const field = this.xref.fetchIfRef(fieldRef);
+
+    if (field.has("T")) {
+      const partName = (0, _util.stringToPDFString)(field.get("T"));
+
+      if (name === "") {
+        name = partName;
+      } else {
+        name = `${name}.${partName}`;
+      }
+    }
+
+    if (!promises.has(name)) {
+      promises.set(name, []);
+    }
+
+    promises.get(name).push(_annotation.AnnotationFactory.create(this.xref, fieldRef, this.pdfManager, this._localIdFactory).then(annotation => annotation && annotation.getFieldObject()).catch(function (reason) {
+      (0, _util.warn)(`_collectFieldObjects: "${reason}".`);
+      return null;
+    }));
+
+    if (field.has("Kids")) {
+      const kids = field.get("Kids");
+
+      for (const kid of kids) {
+        this._collectFieldObjects(name, kid, promises);
+      }
+    }
+  }
+
+  get fieldObjects() {
+    if (!this.formInfo.hasFields) {
+      return (0, _util.shadow)(this, "fieldObjects", Promise.resolve(null));
+    }
+
+    const allFields = Object.create(null);
+    const fieldPromises = new Map();
+
+    for (const fieldRef of this.catalog.acroForm.get("Fields")) {
+      this._collectFieldObjects("", fieldRef, fieldPromises);
+    }
+
+    const allPromises = [];
+
+    for (const [name, promises] of fieldPromises) {
+      allPromises.push(Promise.all(promises).then(fields => {
+        fields = fields.filter(field => !!field);
+
+        if (fields.length > 0) {
+          allFields[name] = fields;
+        }
+      }));
+    }
+
+    return (0, _util.shadow)(this, "fieldObjects", Promise.all(allPromises).then(() => allFields));
+  }
+
+  get hasJSActions() {
+    return (0, _util.shadow)(this, "hasJSActions", this.fieldObjects.then(fieldObjects => {
+      return fieldObjects !== null && Object.values(fieldObjects).some(fieldObject => fieldObject.some(object => object.actions !== null)) || !!this.catalog.jsActions;
+    }));
+  }
+
+  get calculationOrderIds() {
+    const acroForm = this.catalog.acroForm;
+
+    if (!acroForm || !acroForm.has("CO")) {
+      return (0, _util.shadow)(this, "calculationOrderIds", null);
+    }
+
+    const calculationOrder = acroForm.get("CO");
+
+    if (!Array.isArray(calculationOrder) || calculationOrder.length === 0) {
+      return (0, _util.shadow)(this, "calculationOrderIds", null);
+    }
+
+    const ids = calculationOrder.filter(_primitives.isRef).map(ref => ref.toString());
+
+    if (ids.length === 0) {
+      return (0, _util.shadow)(this, "calculationOrderIds", null);
+    }
+
+    return (0, _util.shadow)(this, "calculationOrderIds", ids);
+  }
+
+}
+
+exports.PDFDocument = PDFDocument;
+
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.XRef = exports.ObjectLoader = exports.FileSpec = exports.Catalog = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _parser = __w_pdfjs_require__(11);
+
+var _crypto = __w_pdfjs_require__(22);
+
+var _colorspace = __w_pdfjs_require__(23);
+
+var _image_utils = __w_pdfjs_require__(24);
+
+function fetchDestination(dest) {
+  return (0, _primitives.isDict)(dest) ? dest.get("D") : dest;
+}
+
+class Catalog {
+  constructor(pdfManager, xref) {
+    this.pdfManager = pdfManager;
+    this.xref = xref;
+    this._catDict = xref.getCatalogObj();
+
+    if (!(0, _primitives.isDict)(this._catDict)) {
+      throw new _util.FormatError("Catalog object is not a dictionary.");
+    }
+
+    this.fontCache = new _primitives.RefSetCache();
+    this.builtInCMapCache = new Map();
+    this.globalImageCache = new _image_utils.GlobalImageCache();
+    this.pageKidsCountCache = new _primitives.RefSetCache();
+    this.nonBlendModesSet = new _primitives.RefSet();
+  }
+
+  get version() {
+    const version = this._catDict.get("Version");
+
+    if (!(0, _primitives.isName)(version)) {
+      return (0, _util.shadow)(this, "version", null);
+    }
+
+    return (0, _util.shadow)(this, "version", version.name);
+  }
+
+  get collection() {
+    let collection = null;
+
+    try {
+      const obj = this._catDict.get("Collection");
+
+      if ((0, _primitives.isDict)(obj) && obj.size > 0) {
+        collection = obj;
+      }
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.info)("Cannot fetch Collection entry; assuming no collection is present.");
+    }
+
+    return (0, _util.shadow)(this, "collection", collection);
+  }
+
+  get acroForm() {
+    let acroForm = null;
+
+    try {
+      const obj = this._catDict.get("AcroForm");
+
+      if ((0, _primitives.isDict)(obj) && obj.size > 0) {
+        acroForm = obj;
+      }
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.info)("Cannot fetch AcroForm entry; assuming no forms are present.");
+    }
+
+    return (0, _util.shadow)(this, "acroForm", acroForm);
+  }
+
+  get metadata() {
+    const streamRef = this._catDict.getRaw("Metadata");
+
+    if (!(0, _primitives.isRef)(streamRef)) {
+      return (0, _util.shadow)(this, "metadata", null);
+    }
+
+    const suppressEncryption = !(this.xref.encrypt && this.xref.encrypt.encryptMetadata);
+    const stream = this.xref.fetch(streamRef, suppressEncryption);
+    let metadata;
+
+    if (stream && (0, _primitives.isDict)(stream.dict)) {
+      const type = stream.dict.get("Type");
+      const subtype = stream.dict.get("Subtype");
+
+      if ((0, _primitives.isName)(type, "Metadata") && (0, _primitives.isName)(subtype, "XML")) {
+        try {
+          metadata = (0, _util.stringToUTF8String)((0, _util.bytesToString)(stream.getBytes()));
+        } catch (e) {
+          if (e instanceof _core_utils.MissingDataException) {
+            throw e;
+          }
+
+          (0, _util.info)("Skipping invalid metadata.");
+        }
+      }
+    }
+
+    return (0, _util.shadow)(this, "metadata", metadata);
+  }
+
+  get markInfo() {
+    let markInfo = null;
+
+    try {
+      markInfo = this._readMarkInfo();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)("Unable to read mark info.");
+    }
+
+    return (0, _util.shadow)(this, "markInfo", markInfo);
+  }
+
+  _readMarkInfo() {
+    const obj = this._catDict.get("MarkInfo");
+
+    if (!(0, _primitives.isDict)(obj)) {
+      return null;
+    }
+
+    const markInfo = Object.assign(Object.create(null), {
+      Marked: false,
+      UserProperties: false,
+      Suspects: false
+    });
+
+    for (const key in markInfo) {
+      if (!obj.has(key)) {
+        continue;
+      }
+
+      const value = obj.get(key);
+
+      if (!(0, _util.isBool)(value)) {
+        continue;
+      }
+
+      markInfo[key] = value;
+    }
+
+    return markInfo;
+  }
+
+  get toplevelPagesDict() {
+    const pagesObj = this._catDict.get("Pages");
+
+    if (!(0, _primitives.isDict)(pagesObj)) {
+      throw new _util.FormatError("Invalid top-level pages dictionary.");
+    }
+
+    return (0, _util.shadow)(this, "toplevelPagesDict", pagesObj);
+  }
+
+  get documentOutline() {
+    let obj = null;
+
+    try {
+      obj = this._readDocumentOutline();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)("Unable to read document outline.");
+    }
+
+    return (0, _util.shadow)(this, "documentOutline", obj);
+  }
+
+  _readDocumentOutline() {
+    let obj = this._catDict.get("Outlines");
+
+    if (!(0, _primitives.isDict)(obj)) {
+      return null;
+    }
+
+    obj = obj.getRaw("First");
+
+    if (!(0, _primitives.isRef)(obj)) {
+      return null;
+    }
+
+    const root = {
+      items: []
+    };
+    const queue = [{
+      obj,
+      parent: root
+    }];
+    const processed = new _primitives.RefSet();
+    processed.put(obj);
+    const xref = this.xref,
+          blackColor = new Uint8ClampedArray(3);
+
+    while (queue.length > 0) {
+      const i = queue.shift();
+      const outlineDict = xref.fetchIfRef(i.obj);
+
+      if (outlineDict === null) {
+        continue;
+      }
+
+      if (!outlineDict.has("Title")) {
+        throw new _util.FormatError("Invalid outline item encountered.");
+      }
+
+      const data = {
+        url: null,
+        dest: null
+      };
+      Catalog.parseDestDictionary({
+        destDict: outlineDict,
+        resultObj: data,
+        docBaseUrl: this.pdfManager.docBaseUrl
+      });
+      const title = outlineDict.get("Title");
+      const flags = outlineDict.get("F") || 0;
+      const color = outlineDict.getArray("C");
+      const count = outlineDict.get("Count");
+      let rgbColor = blackColor;
+
+      if (Array.isArray(color) && color.length === 3 && (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)) {
+        rgbColor = _colorspace.ColorSpace.singletons.rgb.getRgb(color, 0);
+      }
+
+      const outlineItem = {
+        dest: data.dest,
+        url: data.url,
+        unsafeUrl: data.unsafeUrl,
+        newWindow: data.newWindow,
+        title: (0, _util.stringToPDFString)(title),
+        color: rgbColor,
+        count: Number.isInteger(count) ? count : undefined,
+        bold: !!(flags & 2),
+        italic: !!(flags & 1),
+        items: []
+      };
+      i.parent.items.push(outlineItem);
+      obj = outlineDict.getRaw("First");
+
+      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
+        queue.push({
+          obj,
+          parent: outlineItem
+        });
+        processed.put(obj);
+      }
+
+      obj = outlineDict.getRaw("Next");
+
+      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
+        queue.push({
+          obj,
+          parent: i.parent
+        });
+        processed.put(obj);
+      }
+    }
+
+    return root.items.length > 0 ? root.items : null;
+  }
+
+  get permissions() {
+    let permissions = null;
+
+    try {
+      permissions = this._readPermissions();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)("Unable to read permissions.");
+    }
+
+    return (0, _util.shadow)(this, "permissions", permissions);
+  }
+
+  _readPermissions() {
+    const encrypt = this.xref.trailer.get("Encrypt");
+
+    if (!(0, _primitives.isDict)(encrypt)) {
+      return null;
+    }
+
+    let flags = encrypt.get("P");
+
+    if (!(0, _util.isNum)(flags)) {
+      return null;
+    }
+
+    flags += 2 ** 32;
+    const permissions = [];
+
+    for (const key in _util.PermissionFlag) {
+      const value = _util.PermissionFlag[key];
+
+      if (flags & value) {
+        permissions.push(value);
+      }
+    }
+
+    return permissions;
+  }
+
+  get optionalContentConfig() {
+    let config = null;
+
+    try {
+      const properties = this._catDict.get("OCProperties");
+
+      if (!properties) {
+        return (0, _util.shadow)(this, "optionalContentConfig", null);
+      }
+
+      const defaultConfig = properties.get("D");
+
+      if (!defaultConfig) {
+        return (0, _util.shadow)(this, "optionalContentConfig", null);
+      }
+
+      const groupsData = properties.get("OCGs");
+
+      if (!Array.isArray(groupsData)) {
+        return (0, _util.shadow)(this, "optionalContentConfig", null);
+      }
+
+      const groups = [];
+      const groupRefs = [];
+
+      for (const groupRef of groupsData) {
+        if (!(0, _primitives.isRef)(groupRef)) {
+          continue;
+        }
+
+        groupRefs.push(groupRef);
+        const group = this.xref.fetchIfRef(groupRef);
+        groups.push({
+          id: groupRef.toString(),
+          name: (0, _util.isString)(group.get("Name")) ? (0, _util.stringToPDFString)(group.get("Name")) : null,
+          intent: (0, _util.isString)(group.get("Intent")) ? (0, _util.stringToPDFString)(group.get("Intent")) : null
+        });
+      }
+
+      config = this._readOptionalContentConfig(defaultConfig, groupRefs);
+      config.groups = groups;
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)(`Unable to read optional content config: ${ex}`);
+    }
+
+    return (0, _util.shadow)(this, "optionalContentConfig", config);
+  }
+
+  _readOptionalContentConfig(config, contentGroupRefs) {
+    function parseOnOff(refs) {
+      const onParsed = [];
+
+      if (Array.isArray(refs)) {
+        for (const value of refs) {
+          if (!(0, _primitives.isRef)(value)) {
+            continue;
+          }
+
+          if (contentGroupRefs.includes(value)) {
+            onParsed.push(value.toString());
+          }
+        }
+      }
+
+      return onParsed;
+    }
+
+    function parseOrder(refs, nestedLevels = 0) {
+      if (!Array.isArray(refs)) {
+        return null;
+      }
+
+      const order = [];
+
+      for (const value of refs) {
+        if ((0, _primitives.isRef)(value) && contentGroupRefs.includes(value)) {
+          parsedOrderRefs.put(value);
+          order.push(value.toString());
+          continue;
+        }
+
+        const nestedOrder = parseNestedOrder(value, nestedLevels);
+
+        if (nestedOrder) {
+          order.push(nestedOrder);
+        }
+      }
+
+      if (nestedLevels > 0) {
+        return order;
+      }
+
+      const hiddenGroups = [];
+
+      for (const groupRef of contentGroupRefs) {
+        if (parsedOrderRefs.has(groupRef)) {
+          continue;
+        }
+
+        hiddenGroups.push(groupRef.toString());
+      }
+
+      if (hiddenGroups.length) {
+        order.push({
+          name: null,
+          order: hiddenGroups
+        });
+      }
+
+      return order;
+    }
+
+    function parseNestedOrder(ref, nestedLevels) {
+      if (++nestedLevels > MAX_NESTED_LEVELS) {
+        (0, _util.warn)("parseNestedOrder - reached MAX_NESTED_LEVELS.");
+        return null;
+      }
+
+      const value = xref.fetchIfRef(ref);
+
+      if (!Array.isArray(value)) {
+        return null;
+      }
+
+      const nestedName = xref.fetchIfRef(value[0]);
+
+      if (typeof nestedName !== "string") {
+        return null;
+      }
+
+      const nestedOrder = parseOrder(value.slice(1), nestedLevels);
+
+      if (!nestedOrder || !nestedOrder.length) {
+        return null;
+      }
+
+      return {
+        name: (0, _util.stringToPDFString)(nestedName),
+        order: nestedOrder
+      };
+    }
+
+    const xref = this.xref,
+          parsedOrderRefs = new _primitives.RefSet(),
+          MAX_NESTED_LEVELS = 10;
+    return {
+      name: (0, _util.isString)(config.get("Name")) ? (0, _util.stringToPDFString)(config.get("Name")) : null,
+      creator: (0, _util.isString)(config.get("Creator")) ? (0, _util.stringToPDFString)(config.get("Creator")) : null,
+      baseState: (0, _primitives.isName)(config.get("BaseState")) ? config.get("BaseState").name : null,
+      on: parseOnOff(config.get("ON")),
+      off: parseOnOff(config.get("OFF")),
+      order: parseOrder(config.get("Order")),
+      groups: null
+    };
+  }
+
+  get numPages() {
+    const obj = this.toplevelPagesDict.get("Count");
+
+    if (!Number.isInteger(obj)) {
+      throw new _util.FormatError("Page count in top-level pages dictionary is not an integer.");
+    }
+
+    return (0, _util.shadow)(this, "numPages", obj);
+  }
+
+  get destinations() {
+    const obj = this._readDests(),
+          dests = Object.create(null);
+
+    if (obj instanceof NameTree) {
+      const names = obj.getAll();
+
+      for (const name in names) {
+        dests[name] = fetchDestination(names[name]);
+      }
+    } else if (obj instanceof _primitives.Dict) {
+      obj.forEach(function (key, value) {
+        if (value) {
+          dests[key] = fetchDestination(value);
+        }
+      });
+    }
+
+    return (0, _util.shadow)(this, "destinations", dests);
+  }
+
+  getDestination(destinationId) {
+    const obj = this._readDests();
+
+    if (obj instanceof NameTree || obj instanceof _primitives.Dict) {
+      return fetchDestination(obj.get(destinationId) || null);
+    }
+
+    return null;
+  }
+
+  _readDests() {
+    const obj = this._catDict.get("Names");
+
+    if (obj && obj.has("Dests")) {
+      return new NameTree(obj.getRaw("Dests"), this.xref);
+    } else if (this._catDict.has("Dests")) {
+      return this._catDict.get("Dests");
+    }
+
+    return undefined;
+  }
+
+  get pageLabels() {
+    let obj = null;
+
+    try {
+      obj = this._readPageLabels();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)("Unable to read page labels.");
+    }
+
+    return (0, _util.shadow)(this, "pageLabels", obj);
+  }
+
+  _readPageLabels() {
+    const obj = this._catDict.getRaw("PageLabels");
+
+    if (!obj) {
+      return null;
+    }
+
+    const pageLabels = new Array(this.numPages);
+    let style = null,
+        prefix = "";
+    const numberTree = new NumberTree(obj, this.xref);
+    const nums = numberTree.getAll();
+    let currentLabel = "",
+        currentIndex = 1;
+
+    for (let i = 0, ii = this.numPages; i < ii; i++) {
+      if (i in nums) {
+        const labelDict = nums[i];
+
+        if (!(0, _primitives.isDict)(labelDict)) {
+          throw new _util.FormatError("PageLabel is not a dictionary.");
+        }
+
+        if (labelDict.has("Type") && !(0, _primitives.isName)(labelDict.get("Type"), "PageLabel")) {
+          throw new _util.FormatError("Invalid type in PageLabel dictionary.");
+        }
+
+        if (labelDict.has("S")) {
+          const s = labelDict.get("S");
+
+          if (!(0, _primitives.isName)(s)) {
+            throw new _util.FormatError("Invalid style in PageLabel dictionary.");
+          }
+
+          style = s.name;
+        } else {
+          style = null;
+        }
+
+        if (labelDict.has("P")) {
+          const p = labelDict.get("P");
+
+          if (!(0, _util.isString)(p)) {
+            throw new _util.FormatError("Invalid prefix in PageLabel dictionary.");
+          }
+
+          prefix = (0, _util.stringToPDFString)(p);
+        } else {
+          prefix = "";
+        }
+
+        if (labelDict.has("St")) {
+          const st = labelDict.get("St");
+
+          if (!(Number.isInteger(st) && st >= 1)) {
+            throw new _util.FormatError("Invalid start in PageLabel dictionary.");
+          }
+
+          currentIndex = st;
+        } else {
+          currentIndex = 1;
+        }
+      }
+
+      switch (style) {
+        case "D":
+          currentLabel = currentIndex;
+          break;
+
+        case "R":
+        case "r":
+          currentLabel = (0, _core_utils.toRomanNumerals)(currentIndex, style === "r");
+          break;
+
+        case "A":
+        case "a":
+          const LIMIT = 26;
+          const A_UPPER_CASE = 0x41,
+                A_LOWER_CASE = 0x61;
+          const baseCharCode = style === "a" ? A_LOWER_CASE : A_UPPER_CASE;
+          const letterIndex = currentIndex - 1;
+          const character = String.fromCharCode(baseCharCode + letterIndex % LIMIT);
+          const charBuf = [];
+
+          for (let j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
+            charBuf.push(character);
+          }
+
+          currentLabel = charBuf.join("");
+          break;
+
+        default:
+          if (style) {
+            throw new _util.FormatError(`Invalid style "${style}" in PageLabel dictionary.`);
+          }
+
+          currentLabel = "";
+      }
+
+      pageLabels[i] = prefix + currentLabel;
+      currentIndex++;
+    }
+
+    return pageLabels;
+  }
+
+  get pageLayout() {
+    const obj = this._catDict.get("PageLayout");
+
+    let pageLayout = "";
+
+    if ((0, _primitives.isName)(obj)) {
+      switch (obj.name) {
+        case "SinglePage":
+        case "OneColumn":
+        case "TwoColumnLeft":
+        case "TwoColumnRight":
+        case "TwoPageLeft":
+        case "TwoPageRight":
+          pageLayout = obj.name;
+      }
+    }
+
+    return (0, _util.shadow)(this, "pageLayout", pageLayout);
+  }
+
+  get pageMode() {
+    const obj = this._catDict.get("PageMode");
+
+    let pageMode = "UseNone";
+
+    if ((0, _primitives.isName)(obj)) {
+      switch (obj.name) {
+        case "UseNone":
+        case "UseOutlines":
+        case "UseThumbs":
+        case "FullScreen":
+        case "UseOC":
+        case "UseAttachments":
+          pageMode = obj.name;
+      }
+    }
+
+    return (0, _util.shadow)(this, "pageMode", pageMode);
+  }
+
+  get viewerPreferences() {
+    const ViewerPreferencesValidators = {
+      HideToolbar: _util.isBool,
+      HideMenubar: _util.isBool,
+      HideWindowUI: _util.isBool,
+      FitWindow: _util.isBool,
+      CenterWindow: _util.isBool,
+      DisplayDocTitle: _util.isBool,
+      NonFullScreenPageMode: _primitives.isName,
+      Direction: _primitives.isName,
+      ViewArea: _primitives.isName,
+      ViewClip: _primitives.isName,
+      PrintArea: _primitives.isName,
+      PrintClip: _primitives.isName,
+      PrintScaling: _primitives.isName,
+      Duplex: _primitives.isName,
+      PickTrayByPDFSize: _util.isBool,
+      PrintPageRange: Array.isArray,
+      NumCopies: Number.isInteger
+    };
+
+    const obj = this._catDict.get("ViewerPreferences");
+
+    let prefs = null;
+
+    if ((0, _primitives.isDict)(obj)) {
+      for (const key in ViewerPreferencesValidators) {
+        if (!obj.has(key)) {
+          continue;
+        }
+
+        const value = obj.get(key);
+
+        if (!ViewerPreferencesValidators[key](value)) {
+          (0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
+          continue;
+        }
+
+        let prefValue;
+
+        switch (key) {
+          case "NonFullScreenPageMode":
+            switch (value.name) {
+              case "UseNone":
+              case "UseOutlines":
+              case "UseThumbs":
+              case "UseOC":
+                prefValue = value.name;
+                break;
+
+              default:
+                prefValue = "UseNone";
+            }
+
+            break;
+
+          case "Direction":
+            switch (value.name) {
+              case "L2R":
+              case "R2L":
+                prefValue = value.name;
+                break;
+
+              default:
+                prefValue = "L2R";
+            }
+
+            break;
+
+          case "ViewArea":
+          case "ViewClip":
+          case "PrintArea":
+          case "PrintClip":
+            switch (value.name) {
+              case "MediaBox":
+              case "CropBox":
+              case "BleedBox":
+              case "TrimBox":
+              case "ArtBox":
+                prefValue = value.name;
+                break;
+
+              default:
+                prefValue = "CropBox";
+            }
+
+            break;
+
+          case "PrintScaling":
+            switch (value.name) {
+              case "None":
+              case "AppDefault":
+                prefValue = value.name;
+                break;
+
+              default:
+                prefValue = "AppDefault";
+            }
+
+            break;
+
+          case "Duplex":
+            switch (value.name) {
+              case "Simplex":
+              case "DuplexFlipShortEdge":
+              case "DuplexFlipLongEdge":
+                prefValue = value.name;
+                break;
+
+              default:
+                prefValue = "None";
+            }
+
+            break;
+
+          case "PrintPageRange":
+            const length = value.length;
+
+            if (length % 2 !== 0) {
+              break;
+            }
+
+            const isValid = value.every((page, i, arr) => {
+              return Number.isInteger(page) && page > 0 && (i === 0 || page >= arr[i - 1]) && page <= this.numPages;
+            });
+
+            if (isValid) {
+              prefValue = value;
+            }
+
+            break;
+
+          case "NumCopies":
+            if (value > 0) {
+              prefValue = value;
+            }
+
+            break;
+
+          default:
+            if (typeof value !== "boolean") {
+              throw new _util.FormatError(`viewerPreferences - expected a boolean value for: ${key}`);
+            }
+
+            prefValue = value;
+        }
+
+        if (prefValue !== undefined) {
+          if (!prefs) {
+            prefs = Object.create(null);
+          }
+
+          prefs[key] = prefValue;
+        } else {
+          (0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
+        }
+      }
+    }
+
+    return (0, _util.shadow)(this, "viewerPreferences", prefs);
+  }
+
+  get openAction() {
+    const obj = this._catDict.get("OpenAction");
+
+    const openAction = Object.create(null);
+
+    if ((0, _primitives.isDict)(obj)) {
+      const destDict = new _primitives.Dict(this.xref);
+      destDict.set("A", obj);
+      const resultObj = {
+        url: null,
+        dest: null,
+        action: null
+      };
+      Catalog.parseDestDictionary({
+        destDict,
+        resultObj
+      });
+
+      if (Array.isArray(resultObj.dest)) {
+        openAction.dest = resultObj.dest;
+      } else if (resultObj.action) {
+        openAction.action = resultObj.action;
+      }
+    } else if (Array.isArray(obj)) {
+      openAction.dest = obj;
+    }
+
+    return (0, _util.shadow)(this, "openAction", (0, _util.objectSize)(openAction) > 0 ? openAction : null);
+  }
+
+  get attachments() {
+    const obj = this._catDict.get("Names");
+
+    let attachments = null;
+
+    if (obj && obj.has("EmbeddedFiles")) {
+      const nameTree = new NameTree(obj.getRaw("EmbeddedFiles"), this.xref);
+      const names = nameTree.getAll();
+
+      for (const name in names) {
+        const fs = new FileSpec(names[name], this.xref);
+
+        if (!attachments) {
+          attachments = Object.create(null);
+        }
+
+        attachments[(0, _util.stringToPDFString)(name)] = fs.serializable;
+      }
+    }
+
+    return (0, _util.shadow)(this, "attachments", attachments);
+  }
+
+  _collectJavaScript() {
+    const obj = this._catDict.get("Names");
+
+    let javaScript = null;
+
+    function appendIfJavaScriptDict(name, jsDict) {
+      const type = jsDict.get("S");
+
+      if (!(0, _primitives.isName)(type, "JavaScript")) {
+        return;
+      }
+
+      let js = jsDict.get("JS");
+
+      if ((0, _primitives.isStream)(js)) {
+        js = (0, _util.bytesToString)(js.getBytes());
+      } else if (!(0, _util.isString)(js)) {
+        return;
+      }
+
+      if (javaScript === null) {
+        javaScript = Object.create(null);
+      }
+
+      javaScript[name] = (0, _util.stringToPDFString)(js);
+    }
+
+    if (obj && obj.has("JavaScript")) {
+      const nameTree = new NameTree(obj.getRaw("JavaScript"), this.xref);
+      const names = nameTree.getAll();
+
+      for (const name in names) {
+        const jsDict = names[name];
+
+        if ((0, _primitives.isDict)(jsDict)) {
+          appendIfJavaScriptDict(name, jsDict);
+        }
+      }
+    }
+
+    const openAction = this._catDict.get("OpenAction");
+
+    if ((0, _primitives.isDict)(openAction) && (0, _primitives.isName)(openAction.get("S"), "JavaScript")) {
+      appendIfJavaScriptDict("OpenAction", openAction);
+    }
+
+    return javaScript;
+  }
+
+  get javaScript() {
+    const javaScript = this._collectJavaScript();
+
+    return (0, _util.shadow)(this, "javaScript", javaScript ? Object.values(javaScript) : null);
+  }
+
+  get jsActions() {
+    const js = this._collectJavaScript();
+
+    let actions = (0, _core_utils.collectActions)(this.xref, this._catDict, _util.DocumentActionEventType);
+
+    if (!actions && js) {
+      actions = Object.create(null);
+    }
+
+    if (actions && js) {
+      for (const [key, val] of Object.entries(js)) {
+        if (key in actions) {
+          actions[key].push(val);
+        } else {
+          actions[key] = [val];
+        }
+      }
+    }
+
+    return (0, _util.shadow)(this, "jsActions", actions);
+  }
+
+  fontFallback(id, handler) {
+    const promises = [];
+    this.fontCache.forEach(function (promise) {
+      promises.push(promise);
+    });
+    return Promise.all(promises).then(translatedFonts => {
+      for (const translatedFont of translatedFonts) {
+        if (translatedFont.loadedName === id) {
+          translatedFont.fallback(handler);
+          return;
+        }
+      }
+    });
+  }
+
+  cleanup(manuallyTriggered = false) {
+    (0, _primitives.clearPrimitiveCaches)();
+    this.globalImageCache.clear(manuallyTriggered);
+    this.pageKidsCountCache.clear();
+    this.nonBlendModesSet.clear();
+    const promises = [];
+    this.fontCache.forEach(function (promise) {
+      promises.push(promise);
+    });
+    return Promise.all(promises).then(translatedFonts => {
+      for (const {
+        dict
+      } of translatedFonts) {
+        delete dict.cacheKey;
+      }
+
+      this.fontCache.clear();
+      this.builtInCMapCache.clear();
+    });
+  }
+
+  getPageDict(pageIndex) {
+    const capability = (0, _util.createPromiseCapability)();
+    const nodesToVisit = [this._catDict.getRaw("Pages")];
+    const visitedNodes = new _primitives.RefSet();
+    const xref = this.xref,
+          pageKidsCountCache = this.pageKidsCountCache;
+    let count,
+        currentPageIndex = 0;
+
+    function next() {
+      while (nodesToVisit.length) {
+        const currentNode = nodesToVisit.pop();
+
+        if ((0, _primitives.isRef)(currentNode)) {
+          count = pageKidsCountCache.get(currentNode);
+
+          if (count > 0 && currentPageIndex + count < pageIndex) {
+            currentPageIndex += count;
+            continue;
+          }
+
+          if (visitedNodes.has(currentNode)) {
+            capability.reject(new _util.FormatError("Pages tree contains circular reference."));
+            return;
+          }
+
+          visitedNodes.put(currentNode);
+          xref.fetchAsync(currentNode).then(function (obj) {
+            if ((0, _primitives.isDict)(obj, "Page") || (0, _primitives.isDict)(obj) && !obj.has("Kids")) {
+              if (pageIndex === currentPageIndex) {
+                if (currentNode && !pageKidsCountCache.has(currentNode)) {
+                  pageKidsCountCache.put(currentNode, 1);
+                }
+
+                capability.resolve([obj, currentNode]);
+              } else {
+                currentPageIndex++;
+                next();
+              }
+
+              return;
+            }
+
+            nodesToVisit.push(obj);
+            next();
+          }, capability.reject);
+          return;
+        }
+
+        if (!(0, _primitives.isDict)(currentNode)) {
+          capability.reject(new _util.FormatError("Page dictionary kid reference points to wrong type of object."));
+          return;
+        }
+
+        count = currentNode.get("Count");
+
+        if (Number.isInteger(count) && count >= 0) {
+          const objId = currentNode.objId;
+
+          if (objId && !pageKidsCountCache.has(objId)) {
+            pageKidsCountCache.put(objId, count);
+          }
+
+          if (currentPageIndex + count <= pageIndex) {
+            currentPageIndex += count;
+            continue;
+          }
+        }
+
+        const kids = currentNode.get("Kids");
+
+        if (!Array.isArray(kids)) {
+          if ((0, _primitives.isName)(currentNode.get("Type"), "Page") || !currentNode.has("Type") && currentNode.has("Contents")) {
+            if (currentPageIndex === pageIndex) {
+              capability.resolve([currentNode, null]);
+              return;
+            }
+
+            currentPageIndex++;
+            continue;
+          }
+
+          capability.reject(new _util.FormatError("Page dictionary kids object is not an array."));
+          return;
+        }
+
+        for (let last = kids.length - 1; last >= 0; last--) {
+          nodesToVisit.push(kids[last]);
+        }
+      }
+
+      capability.reject(new Error(`Page index ${pageIndex} not found.`));
+    }
+
+    next();
+    return capability.promise;
+  }
+
+  getPageIndex(pageRef) {
+    const xref = this.xref;
+
+    function pagesBeforeRef(kidRef) {
+      let total = 0,
+          parentRef;
+      return xref.fetchAsync(kidRef).then(function (node) {
+        if ((0, _primitives.isRefsEqual)(kidRef, pageRef) && !(0, _primitives.isDict)(node, "Page") && !((0, _primitives.isDict)(node) && !node.has("Type") && node.has("Contents"))) {
+          throw new _util.FormatError("The reference does not point to a /Page dictionary.");
+        }
+
+        if (!node) {
+          return null;
+        }
+
+        if (!(0, _primitives.isDict)(node)) {
+          throw new _util.FormatError("Node must be a dictionary.");
+        }
+
+        parentRef = node.getRaw("Parent");
+        return node.getAsync("Parent");
+      }).then(function (parent) {
+        if (!parent) {
+          return null;
+        }
+
+        if (!(0, _primitives.isDict)(parent)) {
+          throw new _util.FormatError("Parent must be a dictionary.");
+        }
+
+        return parent.getAsync("Kids");
+      }).then(function (kids) {
+        if (!kids) {
+          return null;
+        }
+
+        const kidPromises = [];
+        let found = false;
+
+        for (let i = 0, ii = kids.length; i < ii; i++) {
+          const kid = kids[i];
+
+          if (!(0, _primitives.isRef)(kid)) {
+            throw new _util.FormatError("Kid must be a reference.");
+          }
+
+          if ((0, _primitives.isRefsEqual)(kid, kidRef)) {
+            found = true;
+            break;
+          }
+
+          kidPromises.push(xref.fetchAsync(kid).then(function (obj) {
+            if (!(0, _primitives.isDict)(obj)) {
+              throw new _util.FormatError("Kid node must be a dictionary.");
+            }
+
+            if (obj.has("Count")) {
+              total += obj.get("Count");
+            } else {
+              total++;
+            }
+          }));
+        }
+
+        if (!found) {
+          throw new _util.FormatError("Kid reference not found in parent's kids.");
+        }
+
+        return Promise.all(kidPromises).then(function () {
+          return [total, parentRef];
+        });
+      });
+    }
+
+    let total = 0;
+
+    function next(ref) {
+      return pagesBeforeRef(ref).then(function (args) {
+        if (!args) {
+          return total;
+        }
+
+        const [count, parentRef] = args;
+        total += count;
+        return next(parentRef);
+      });
+    }
+
+    return next(pageRef);
+  }
+
+  static parseDestDictionary(params) {
+    function addDefaultProtocolToUrl(url) {
+      return url.startsWith("www.") ? `http://${url}` : url;
+    }
+
+    function tryConvertUrlEncoding(url) {
+      try {
+        return (0, _util.stringToUTF8String)(url);
+      } catch (e) {
+        return url;
+      }
+    }
+
+    const destDict = params.destDict;
+
+    if (!(0, _primitives.isDict)(destDict)) {
+      (0, _util.warn)("parseDestDictionary: `destDict` must be a dictionary.");
+      return;
+    }
+
+    const resultObj = params.resultObj;
+
+    if (typeof resultObj !== "object") {
+      (0, _util.warn)("parseDestDictionary: `resultObj` must be an object.");
+      return;
+    }
+
+    const docBaseUrl = params.docBaseUrl || null;
+    let action = destDict.get("A"),
+        url,
+        dest;
+
+    if (!(0, _primitives.isDict)(action)) {
+      if (destDict.has("Dest")) {
+        action = destDict.get("Dest");
+      } else {
+        action = destDict.get("AA");
+
+        if ((0, _primitives.isDict)(action)) {
+          if (action.has("D")) {
+            action = action.get("D");
+          } else if (action.has("U")) {
+            action = action.get("U");
+          }
+        }
+      }
+    }
+
+    if ((0, _primitives.isDict)(action)) {
+      const actionType = action.get("S");
+
+      if (!(0, _primitives.isName)(actionType)) {
+        (0, _util.warn)("parseDestDictionary: Invalid type in Action dictionary.");
+        return;
+      }
+
+      const actionName = actionType.name;
+
+      switch (actionName) {
+        case "URI":
+          url = action.get("URI");
+
+          if ((0, _primitives.isName)(url)) {
+            url = "/" + url.name;
+          } else if ((0, _util.isString)(url)) {
+            url = addDefaultProtocolToUrl(url);
+          }
+
+          break;
+
+        case "GoTo":
+          dest = action.get("D");
+          break;
+
+        case "Launch":
+        case "GoToR":
+          const urlDict = action.get("F");
+
+          if ((0, _primitives.isDict)(urlDict)) {
+            url = urlDict.get("F") || null;
+          } else if ((0, _util.isString)(urlDict)) {
+            url = urlDict;
+          }
+
+          let remoteDest = action.get("D");
+
+          if (remoteDest) {
+            if ((0, _primitives.isName)(remoteDest)) {
+              remoteDest = remoteDest.name;
+            }
+
+            if ((0, _util.isString)(url)) {
+              const baseUrl = url.split("#")[0];
+
+              if ((0, _util.isString)(remoteDest)) {
+                url = baseUrl + "#" + remoteDest;
+              } else if (Array.isArray(remoteDest)) {
+                url = baseUrl + "#" + JSON.stringify(remoteDest);
+              }
+            }
+          }
+
+          const newWindow = action.get("NewWindow");
+
+          if ((0, _util.isBool)(newWindow)) {
+            resultObj.newWindow = newWindow;
+          }
+
+          break;
+
+        case "Named":
+          const namedAction = action.get("N");
+
+          if ((0, _primitives.isName)(namedAction)) {
+            resultObj.action = namedAction.name;
+          }
+
+          break;
+
+        case "JavaScript":
+          const jsAction = action.get("JS");
+          let js;
+
+          if ((0, _primitives.isStream)(jsAction)) {
+            js = (0, _util.bytesToString)(jsAction.getBytes());
+          } else if ((0, _util.isString)(jsAction)) {
+            js = jsAction;
+          }
+
+          if (js) {
+            const URL_OPEN_METHODS = ["app.launchURL", "window.open"];
+            const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").split(".").join("\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
+            const jsUrl = regex.exec((0, _util.stringToPDFString)(js));
+
+            if (jsUrl && jsUrl[2]) {
+              url = jsUrl[2];
+
+              if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
+                resultObj.newWindow = true;
+              }
+
+              break;
+            }
+          }
+
+        default:
+          (0, _util.warn)(`parseDestDictionary: unsupported action type "${actionName}".`);
+          break;
+      }
+    } else if (destDict.has("Dest")) {
+      dest = destDict.get("Dest");
+    }
+
+    if ((0, _util.isString)(url)) {
+      url = tryConvertUrlEncoding(url);
+      const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url, docBaseUrl);
+
+      if (absoluteUrl) {
+        resultObj.url = absoluteUrl.href;
+      }
+
+      resultObj.unsafeUrl = url;
+    }
+
+    if (dest) {
+      if ((0, _primitives.isName)(dest)) {
+        dest = dest.name;
+      }
+
+      if ((0, _util.isString)(dest) || Array.isArray(dest)) {
+        resultObj.dest = dest;
+      }
+    }
+  }
+
+}
+
+exports.Catalog = Catalog;
+
+var XRef = function XRefClosure() {
+  function XRef(stream, pdfManager) {
+    this.stream = stream;
+    this.pdfManager = pdfManager;
+    this.entries = [];
+    this.xrefstms = Object.create(null);
+    this._cacheMap = new Map();
+    this.stats = {
+      streamTypes: Object.create(null),
+      fontTypes: Object.create(null)
+    };
+    this._newRefNum = null;
+  }
+
+  XRef.prototype = {
+    getNewRef: function XRef_getNewRef() {
+      if (this._newRefNum === null) {
+        this._newRefNum = this.entries.length;
+      }
+
+      return _primitives.Ref.get(this._newRefNum++, 0);
+    },
+    resetNewRef: function XRef_resetNewRef() {
+      this._newRefNum = null;
+    },
+    setStartXRef: function XRef_setStartXRef(startXRef) {
+      this.startXRefQueue = [startXRef];
+    },
+    parse: function XRef_parse(recoveryMode) {
+      var trailerDict;
+
+      if (!recoveryMode) {
+        trailerDict = this.readXRef();
+      } else {
+        (0, _util.warn)("Indexing all PDF objects");
+        trailerDict = this.indexObjects();
+      }
+
+      trailerDict.assignXref(this);
+      this.trailer = trailerDict;
+      let encrypt;
+
+      try {
+        encrypt = trailerDict.get("Encrypt");
+      } catch (ex) {
+        if (ex instanceof _core_utils.MissingDataException) {
+          throw ex;
+        }
+
+        (0, _util.warn)(`XRef.parse - Invalid "Encrypt" reference: "${ex}".`);
+      }
+
+      if ((0, _primitives.isDict)(encrypt)) {
+        var ids = trailerDict.get("ID");
+        var fileId = ids && ids.length ? ids[0] : "";
+        encrypt.suppressEncryption = true;
+        this.encrypt = new _crypto.CipherTransformFactory(encrypt, fileId, this.pdfManager.password);
+      }
+
+      let root;
+
+      try {
+        root = trailerDict.get("Root");
+      } catch (ex) {
+        if (ex instanceof _core_utils.MissingDataException) {
+          throw ex;
+        }
+
+        (0, _util.warn)(`XRef.parse - Invalid "Root" reference: "${ex}".`);
+      }
+
+      if ((0, _primitives.isDict)(root) && root.has("Pages")) {
+        this.root = root;
+      } else {
+        if (!recoveryMode) {
+          throw new _core_utils.XRefParseException();
+        }
+
+        throw new _util.FormatError("Invalid root reference");
+      }
+    },
+    processXRefTable: function XRef_processXRefTable(parser) {
+      if (!("tableState" in this)) {
+        this.tableState = {
+          entryNum: 0,
+          streamPos: parser.lexer.stream.pos,
+          parserBuf1: parser.buf1,
+          parserBuf2: parser.buf2
+        };
+      }
+
+      var obj = this.readXRefTable(parser);
+
+      if (!(0, _primitives.isCmd)(obj, "trailer")) {
+        throw new _util.FormatError("Invalid XRef table: could not find trailer dictionary");
+      }
+
+      var dict = parser.getObj();
+
+      if (!(0, _primitives.isDict)(dict) && dict.dict) {
+        dict = dict.dict;
+      }
+
+      if (!(0, _primitives.isDict)(dict)) {
+        throw new _util.FormatError("Invalid XRef table: could not parse trailer dictionary");
+      }
+
+      delete this.tableState;
+      return dict;
+    },
+    readXRefTable: function XRef_readXRefTable(parser) {
+      var stream = parser.lexer.stream;
+      var tableState = this.tableState;
+      stream.pos = tableState.streamPos;
+      parser.buf1 = tableState.parserBuf1;
+      parser.buf2 = tableState.parserBuf2;
+      var obj;
+
+      while (true) {
+        if (!("firstEntryNum" in tableState) || !("entryCount" in tableState)) {
+          if ((0, _primitives.isCmd)(obj = parser.getObj(), "trailer")) {
+            break;
+          }
+
+          tableState.firstEntryNum = obj;
+          tableState.entryCount = parser.getObj();
+        }
+
+        var first = tableState.firstEntryNum;
+        var count = tableState.entryCount;
+
+        if (!Number.isInteger(first) || !Number.isInteger(count)) {
+          throw new _util.FormatError("Invalid XRef table: wrong types in subsection header");
+        }
+
+        for (var i = tableState.entryNum; i < count; i++) {
+          tableState.streamPos = stream.pos;
+          tableState.entryNum = i;
+          tableState.parserBuf1 = parser.buf1;
+          tableState.parserBuf2 = parser.buf2;
+          var entry = {};
+          entry.offset = parser.getObj();
+          entry.gen = parser.getObj();
+          var type = parser.getObj();
+
+          if (type instanceof _primitives.Cmd) {
+            switch (type.cmd) {
+              case "f":
+                entry.free = true;
+                break;
+
+              case "n":
+                entry.uncompressed = true;
+                break;
+            }
+          }
+
+          if (!Number.isInteger(entry.offset) || !Number.isInteger(entry.gen) || !(entry.free || entry.uncompressed)) {
+            throw new _util.FormatError(`Invalid entry in XRef subsection: ${first}, ${count}`);
+          }
+
+          if (i === 0 && entry.free && first === 1) {
+            first = 0;
+          }
+
+          if (!this.entries[i + first]) {
+            this.entries[i + first] = entry;
+          }
+        }
+
+        tableState.entryNum = 0;
+        tableState.streamPos = stream.pos;
+        tableState.parserBuf1 = parser.buf1;
+        tableState.parserBuf2 = parser.buf2;
+        delete tableState.firstEntryNum;
+        delete tableState.entryCount;
+      }
+
+      if (this.entries[0] && !this.entries[0].free) {
+        throw new _util.FormatError("Invalid XRef table: unexpected first object");
+      }
+
+      return obj;
+    },
+    processXRefStream: function XRef_processXRefStream(stream) {
+      if (!("streamState" in this)) {
+        var streamParameters = stream.dict;
+        var byteWidths = streamParameters.get("W");
+        var range = streamParameters.get("Index");
+
+        if (!range) {
+          range = [0, streamParameters.get("Size")];
+        }
+
+        this.streamState = {
+          entryRanges: range,
+          byteWidths,
+          entryNum: 0,
+          streamPos: stream.pos
+        };
+      }
+
+      this.readXRefStream(stream);
+      delete this.streamState;
+      return stream.dict;
+    },
+    readXRefStream: function XRef_readXRefStream(stream) {
+      var i, j;
+      var streamState = this.streamState;
+      stream.pos = streamState.streamPos;
+      var byteWidths = streamState.byteWidths;
+      var typeFieldWidth = byteWidths[0];
+      var offsetFieldWidth = byteWidths[1];
+      var generationFieldWidth = byteWidths[2];
+      var entryRanges = streamState.entryRanges;
+
+      while (entryRanges.length > 0) {
+        var first = entryRanges[0];
+        var n = entryRanges[1];
+
+        if (!Number.isInteger(first) || !Number.isInteger(n)) {
+          throw new _util.FormatError(`Invalid XRef range fields: ${first}, ${n}`);
+        }
+
+        if (!Number.isInteger(typeFieldWidth) || !Number.isInteger(offsetFieldWidth) || !Number.isInteger(generationFieldWidth)) {
+          throw new _util.FormatError(`Invalid XRef entry fields length: ${first}, ${n}`);
+        }
+
+        for (i = streamState.entryNum; i < n; ++i) {
+          streamState.entryNum = i;
+          streamState.streamPos = stream.pos;
+          var type = 0,
+              offset = 0,
+              generation = 0;
+
+          for (j = 0; j < typeFieldWidth; ++j) {
+            type = type << 8 | stream.getByte();
+          }
+
+          if (typeFieldWidth === 0) {
+            type = 1;
+          }
+
+          for (j = 0; j < offsetFieldWidth; ++j) {
+            offset = offset << 8 | stream.getByte();
+          }
+
+          for (j = 0; j < generationFieldWidth; ++j) {
+            generation = generation << 8 | stream.getByte();
+          }
+
+          var entry = {};
+          entry.offset = offset;
+          entry.gen = generation;
+
+          switch (type) {
+            case 0:
+              entry.free = true;
+              break;
+
+            case 1:
+              entry.uncompressed = true;
+              break;
+
+            case 2:
+              break;
+
+            default:
+              throw new _util.FormatError(`Invalid XRef entry type: ${type}`);
+          }
+
+          if (!this.entries[first + i]) {
+            this.entries[first + i] = entry;
+          }
+        }
+
+        streamState.entryNum = 0;
+        streamState.streamPos = stream.pos;
+        entryRanges.splice(0, 2);
+      }
+    },
+    indexObjects: function XRef_indexObjects() {
+      var TAB = 0x9,
+          LF = 0xa,
+          CR = 0xd,
+          SPACE = 0x20;
+      var PERCENT = 0x25,
+          LT = 0x3c;
+
+      function readToken(data, offset) {
+        var token = "",
+            ch = data[offset];
+
+        while (ch !== LF && ch !== CR && ch !== LT) {
+          if (++offset >= data.length) {
+            break;
+          }
+
+          token += String.fromCharCode(ch);
+          ch = data[offset];
+        }
+
+        return token;
+      }
+
+      function skipUntil(data, offset, what) {
+        var length = what.length,
+            dataLength = data.length;
+        var skipped = 0;
+
+        while (offset < dataLength) {
+          var i = 0;
+
+          while (i < length && data[offset + i] === what[i]) {
+            ++i;
+          }
+
+          if (i >= length) {
+            break;
+          }
+
+          offset++;
+          skipped++;
+        }
+
+        return skipped;
+      }
+
+      var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
+      const endobjRegExp = /\bendobj[\b\s]$/;
+      const nestedObjRegExp = /\s+(\d+\s+\d+\s+obj[\b\s<])$/;
+      const CHECK_CONTENT_LENGTH = 25;
+      var trailerBytes = new Uint8Array([116, 114, 97, 105, 108, 101, 114]);
+      var startxrefBytes = new Uint8Array([115, 116, 97, 114, 116, 120, 114, 101, 102]);
+      const objBytes = new Uint8Array([111, 98, 106]);
+      var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);
+      this.entries.length = 0;
+      var stream = this.stream;
+      stream.pos = 0;
+      var buffer = stream.getBytes();
+      var position = stream.start,
+          length = buffer.length;
+      var trailers = [],
+          xrefStms = [];
+
+      while (position < length) {
+        var ch = buffer[position];
+
+        if (ch === TAB || ch === LF || ch === CR || ch === SPACE) {
+          ++position;
+          continue;
+        }
+
+        if (ch === PERCENT) {
+          do {
+            ++position;
+
+            if (position >= length) {
+              break;
+            }
+
+            ch = buffer[position];
+          } while (ch !== LF && ch !== CR);
+
+          continue;
+        }
+
+        var token = readToken(buffer, position);
+        var m;
+
+        if (token.startsWith("xref") && (token.length === 4 || /\s/.test(token[4]))) {
+          position += skipUntil(buffer, position, trailerBytes);
+          trailers.push(position);
+          position += skipUntil(buffer, position, startxrefBytes);
+        } else if (m = objRegExp.exec(token)) {
+          const num = m[1] | 0,
+                gen = m[2] | 0;
+
+          if (!this.entries[num] || this.entries[num].gen === gen) {
+            this.entries[num] = {
+              offset: position - stream.start,
+              gen,
+              uncompressed: true
+            };
+          }
+
+          let contentLength,
+              startPos = position + token.length;
+
+          while (startPos < buffer.length) {
+            const endPos = startPos + skipUntil(buffer, startPos, objBytes) + 4;
+            contentLength = endPos - position;
+            const checkPos = Math.max(endPos - CHECK_CONTENT_LENGTH, startPos);
+            const tokenStr = (0, _util.bytesToString)(buffer.subarray(checkPos, endPos));
+
+            if (endobjRegExp.test(tokenStr)) {
+              break;
+            } else {
+              const objToken = nestedObjRegExp.exec(tokenStr);
+
+              if (objToken && objToken[1]) {
+                (0, _util.warn)('indexObjects: Found new "obj" inside of another "obj", ' + 'caused by missing "endobj" -- trying to recover.');
+                contentLength -= objToken[1].length;
+                break;
+              }
+            }
+
+            startPos = endPos;
+          }
+
+          const content = buffer.subarray(position, position + contentLength);
+          var xrefTagOffset = skipUntil(content, 0, xrefBytes);
+
+          if (xrefTagOffset < contentLength && content[xrefTagOffset + 5] < 64) {
+            xrefStms.push(position - stream.start);
+            this.xrefstms[position - stream.start] = 1;
+          }
+
+          position += contentLength;
+        } else if (token.startsWith("trailer") && (token.length === 7 || /\s/.test(token[7]))) {
+          trailers.push(position);
+          position += skipUntil(buffer, position, startxrefBytes);
+        } else {
+          position += token.length + 1;
+        }
+      }
+
+      for (let i = 0, ii = xrefStms.length; i < ii; ++i) {
+        this.startXRefQueue.push(xrefStms[i]);
+        this.readXRef(true);
+      }
+
+      let trailerDict;
+
+      for (let i = 0, ii = trailers.length; i < ii; ++i) {
+        stream.pos = trailers[i];
+        const parser = new _parser.Parser({
+          lexer: new _parser.Lexer(stream),
+          xref: this,
+          allowStreams: true,
+          recoveryMode: true
+        });
+        var obj = parser.getObj();
+
+        if (!(0, _primitives.isCmd)(obj, "trailer")) {
+          continue;
+        }
+
+        const dict = parser.getObj();
+
+        if (!(0, _primitives.isDict)(dict)) {
+          continue;
+        }
+
+        try {
+          const rootDict = dict.get("Root");
+
+          if (!(rootDict instanceof _primitives.Dict)) {
+            continue;
+          }
+
+          const pagesDict = rootDict.get("Pages");
+
+          if (!(pagesDict instanceof _primitives.Dict)) {
+            continue;
+          }
+
+          const pagesCount = pagesDict.get("Count");
+
+          if (!Number.isInteger(pagesCount)) {
+            continue;
+          }
+        } catch (ex) {
+          if (ex instanceof _core_utils.MissingDataException) {
+            throw ex;
+          }
+
+          continue;
+        }
+
+        if (dict.has("ID")) {
+          return dict;
+        }
+
+        trailerDict = dict;
+      }
+
+      if (trailerDict) {
+        return trailerDict;
+      }
+
+      throw new _util.InvalidPDFException("Invalid PDF structure.");
+    },
+    readXRef: function XRef_readXRef(recoveryMode) {
+      var stream = this.stream;
+      const startXRefParsedCache = Object.create(null);
+
+      try {
+        while (this.startXRefQueue.length) {
+          var startXRef = this.startXRefQueue[0];
+
+          if (startXRefParsedCache[startXRef]) {
+            (0, _util.warn)("readXRef - skipping XRef table since it was already parsed.");
+            this.startXRefQueue.shift();
+            continue;
+          }
+
+          startXRefParsedCache[startXRef] = true;
+          stream.pos = startXRef + stream.start;
+          const parser = new _parser.Parser({
+            lexer: new _parser.Lexer(stream),
+            xref: this,
+            allowStreams: true
+          });
+          var obj = parser.getObj();
+          var dict;
+
+          if ((0, _primitives.isCmd)(obj, "xref")) {
+            dict = this.processXRefTable(parser);
+
+            if (!this.topDict) {
+              this.topDict = dict;
+            }
+
+            obj = dict.get("XRefStm");
+
+            if (Number.isInteger(obj)) {
+              var pos = obj;
+
+              if (!(pos in this.xrefstms)) {
+                this.xrefstms[pos] = 1;
+                this.startXRefQueue.push(pos);
+              }
+            }
+          } else if (Number.isInteger(obj)) {
+            if (!Number.isInteger(parser.getObj()) || !(0, _primitives.isCmd)(parser.getObj(), "obj") || !(0, _primitives.isStream)(obj = parser.getObj())) {
+              throw new _util.FormatError("Invalid XRef stream");
+            }
+
+            dict = this.processXRefStream(obj);
+
+            if (!this.topDict) {
+              this.topDict = dict;
+            }
+
+            if (!dict) {
+              throw new _util.FormatError("Failed to read XRef stream");
+            }
+          } else {
+            throw new _util.FormatError("Invalid XRef stream header");
+          }
+
+          obj = dict.get("Prev");
+
+          if (Number.isInteger(obj)) {
+            this.startXRefQueue.push(obj);
+          } else if ((0, _primitives.isRef)(obj)) {
+            this.startXRefQueue.push(obj.num);
+          }
+
+          this.startXRefQueue.shift();
+        }
+
+        return this.topDict;
+      } catch (e) {
+        if (e instanceof _core_utils.MissingDataException) {
+          throw e;
+        }
+
+        (0, _util.info)("(while reading XRef): " + e);
+      }
+
+      if (recoveryMode) {
+        return undefined;
+      }
+
+      throw new _core_utils.XRefParseException();
+    },
+    getEntry: function XRef_getEntry(i) {
+      var xrefEntry = this.entries[i];
+
+      if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {
+        return xrefEntry;
+      }
+
+      return null;
+    },
+    fetchIfRef: function XRef_fetchIfRef(obj, suppressEncryption) {
+      if (obj instanceof _primitives.Ref) {
+        return this.fetch(obj, suppressEncryption);
+      }
+
+      return obj;
+    },
+    fetch: function XRef_fetch(ref, suppressEncryption) {
+      if (!(ref instanceof _primitives.Ref)) {
+        throw new Error("ref object is not a reference");
+      }
+
+      const num = ref.num;
+
+      const cacheEntry = this._cacheMap.get(num);
+
+      if (cacheEntry !== undefined) {
+        if (cacheEntry instanceof _primitives.Dict && !cacheEntry.objId) {
+          cacheEntry.objId = ref.toString();
+        }
+
+        return cacheEntry;
+      }
+
+      let xrefEntry = this.getEntry(num);
+
+      if (xrefEntry === null) {
+        this._cacheMap.set(num, xrefEntry);
+
+        return xrefEntry;
+      }
+
+      if (xrefEntry.uncompressed) {
+        xrefEntry = this.fetchUncompressed(ref, xrefEntry, suppressEncryption);
+      } else {
+        xrefEntry = this.fetchCompressed(ref, xrefEntry, suppressEncryption);
+      }
+
+      if ((0, _primitives.isDict)(xrefEntry)) {
+        xrefEntry.objId = ref.toString();
+      } else if ((0, _primitives.isStream)(xrefEntry)) {
+        xrefEntry.dict.objId = ref.toString();
+      }
+
+      return xrefEntry;
+    },
+
+    fetchUncompressed(ref, xrefEntry, suppressEncryption = false) {
+      var gen = ref.gen;
+      var num = ref.num;
+
+      if (xrefEntry.gen !== gen) {
+        throw new _core_utils.XRefEntryException(`Inconsistent generation in XRef: ${ref}`);
+      }
+
+      var stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
+      const parser = new _parser.Parser({
+        lexer: new _parser.Lexer(stream),
+        xref: this,
+        allowStreams: true
+      });
+      var obj1 = parser.getObj();
+      var obj2 = parser.getObj();
+      var obj3 = parser.getObj();
+
+      if (obj1 !== num || obj2 !== gen || !(obj3 instanceof _primitives.Cmd)) {
+        throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
+      }
+
+      if (obj3.cmd !== "obj") {
+        if (obj3.cmd.startsWith("obj")) {
+          num = parseInt(obj3.cmd.substring(3), 10);
+
+          if (!Number.isNaN(num)) {
+            return num;
+          }
+        }
+
+        throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
+      }
+
+      if (this.encrypt && !suppressEncryption) {
+        xrefEntry = parser.getObj(this.encrypt.createCipherTransform(num, gen));
+      } else {
+        xrefEntry = parser.getObj();
+      }
+
+      if (!(0, _primitives.isStream)(xrefEntry)) {
+        this._cacheMap.set(num, xrefEntry);
+      }
+
+      return xrefEntry;
+    },
+
+    fetchCompressed(ref, xrefEntry, suppressEncryption = false) {
+      const tableOffset = xrefEntry.offset;
+      const stream = this.fetch(_primitives.Ref.get(tableOffset, 0));
+
+      if (!(0, _primitives.isStream)(stream)) {
+        throw new _util.FormatError("bad ObjStm stream");
+      }
+
+      const first = stream.dict.get("First");
+      const n = stream.dict.get("N");
+
+      if (!Number.isInteger(first) || !Number.isInteger(n)) {
+        throw new _util.FormatError("invalid first and n parameters for ObjStm stream");
+      }
+
+      const parser = new _parser.Parser({
+        lexer: new _parser.Lexer(stream),
+        xref: this,
+        allowStreams: true
+      });
+      const nums = new Array(n);
+
+      for (let i = 0; i < n; ++i) {
+        const num = parser.getObj();
+
+        if (!Number.isInteger(num)) {
+          throw new _util.FormatError(`invalid object number in the ObjStm stream: ${num}`);
+        }
+
+        const offset = parser.getObj();
+
+        if (!Number.isInteger(offset)) {
+          throw new _util.FormatError(`invalid object offset in the ObjStm stream: ${offset}`);
+        }
+
+        nums[i] = num;
+      }
+
+      const entries = new Array(n);
+
+      for (let i = 0; i < n; ++i) {
+        const obj = parser.getObj();
+        entries[i] = obj;
+
+        if (parser.buf1 instanceof _primitives.Cmd && parser.buf1.cmd === "endobj") {
+          parser.shift();
+        }
+
+        if ((0, _primitives.isStream)(obj)) {
+          continue;
+        }
+
+        const num = nums[i],
+              entry = this.entries[num];
+
+        if (entry && entry.offset === tableOffset && entry.gen === i) {
+          this._cacheMap.set(num, obj);
+        }
+      }
+
+      xrefEntry = entries[xrefEntry.gen];
+
+      if (xrefEntry === undefined) {
+        throw new _core_utils.XRefEntryException(`Bad (compressed) XRef entry: ${ref}`);
+      }
+
+      return xrefEntry;
+    },
+
+    async fetchIfRefAsync(obj, suppressEncryption) {
+      if (obj instanceof _primitives.Ref) {
+        return this.fetchAsync(obj, suppressEncryption);
+      }
+
+      return obj;
+    },
+
+    async fetchAsync(ref, suppressEncryption) {
+      try {
+        return this.fetch(ref, suppressEncryption);
+      } catch (ex) {
+        if (!(ex instanceof _core_utils.MissingDataException)) {
+          throw ex;
+        }
+
+        await this.pdfManager.requestRange(ex.begin, ex.end);
+        return this.fetchAsync(ref, suppressEncryption);
+      }
+    },
+
+    getCatalogObj: function XRef_getCatalogObj() {
+      return this.root;
+    }
+  };
+  return XRef;
+}();
+
+exports.XRef = XRef;
+
+class NameOrNumberTree {
+  constructor(root, xref, type) {
+    if (this.constructor === NameOrNumberTree) {
+      (0, _util.unreachable)("Cannot initialize NameOrNumberTree.");
+    }
+
+    this.root = root;
+    this.xref = xref;
+    this._type = type;
+  }
+
+  getAll() {
+    const dict = Object.create(null);
+
+    if (!this.root) {
+      return dict;
+    }
+
+    const xref = this.xref;
+    const processed = new _primitives.RefSet();
+    processed.put(this.root);
+    const queue = [this.root];
+
+    while (queue.length > 0) {
+      const obj = xref.fetchIfRef(queue.shift());
+
+      if (!(0, _primitives.isDict)(obj)) {
+        continue;
+      }
+
+      if (obj.has("Kids")) {
+        const kids = obj.get("Kids");
+
+        for (let i = 0, ii = kids.length; i < ii; i++) {
+          const kid = kids[i];
+
+          if (processed.has(kid)) {
+            throw new _util.FormatError(`Duplicate entry in "${this._type}" tree.`);
+          }
+
+          queue.push(kid);
+          processed.put(kid);
+        }
+
+        continue;
+      }
+
+      const entries = obj.get(this._type);
+
+      if (Array.isArray(entries)) {
+        for (let i = 0, ii = entries.length; i < ii; i += 2) {
+          dict[xref.fetchIfRef(entries[i])] = xref.fetchIfRef(entries[i + 1]);
+        }
+      }
+    }
+
+    return dict;
+  }
+
+  get(key) {
+    if (!this.root) {
+      return null;
+    }
+
+    const xref = this.xref;
+    let kidsOrEntries = xref.fetchIfRef(this.root);
+    let loopCount = 0;
+    const MAX_LEVELS = 10;
+
+    while (kidsOrEntries.has("Kids")) {
+      if (++loopCount > MAX_LEVELS) {
+        (0, _util.warn)(`Search depth limit reached for "${this._type}" tree.`);
+        return null;
+      }
+
+      const kids = kidsOrEntries.get("Kids");
+
+      if (!Array.isArray(kids)) {
+        return null;
+      }
+
+      let l = 0,
+          r = kids.length - 1;
+
+      while (l <= r) {
+        const m = l + r >> 1;
+        const kid = xref.fetchIfRef(kids[m]);
+        const limits = kid.get("Limits");
+
+        if (key < xref.fetchIfRef(limits[0])) {
+          r = m - 1;
+        } else if (key > xref.fetchIfRef(limits[1])) {
+          l = m + 1;
+        } else {
+          kidsOrEntries = xref.fetchIfRef(kids[m]);
+          break;
+        }
+      }
+
+      if (l > r) {
+        return null;
+      }
+    }
+
+    const entries = kidsOrEntries.get(this._type);
+
+    if (Array.isArray(entries)) {
+      let l = 0,
+          r = entries.length - 2;
+
+      while (l <= r) {
+        const tmp = l + r >> 1,
+              m = tmp + (tmp & 1);
+        const currentKey = xref.fetchIfRef(entries[m]);
+
+        if (key < currentKey) {
+          r = m - 2;
+        } else if (key > currentKey) {
+          l = m + 2;
+        } else {
+          return xref.fetchIfRef(entries[m + 1]);
+        }
+      }
+
+      (0, _util.info)(`Falling back to an exhaustive search, for key "${key}", ` + `in "${this._type}" tree.`);
+
+      for (let m = 0, mm = entries.length; m < mm; m += 2) {
+        const currentKey = xref.fetchIfRef(entries[m]);
+
+        if (currentKey === key) {
+          (0, _util.warn)(`The "${key}" key was found at an incorrect, ` + `i.e. out-of-order, position in "${this._type}" tree.`);
+          return xref.fetchIfRef(entries[m + 1]);
+        }
+      }
+    }
+
+    return null;
+  }
+
+}
+
+class NameTree extends NameOrNumberTree {
+  constructor(root, xref) {
+    super(root, xref, "Names");
+  }
+
+}
+
+class NumberTree extends NameOrNumberTree {
+  constructor(root, xref) {
+    super(root, xref, "Nums");
+  }
+
+}
+
+var FileSpec = function FileSpecClosure() {
+  function FileSpec(root, xref) {
+    if (!root || !(0, _primitives.isDict)(root)) {
+      return;
+    }
+
+    this.xref = xref;
+    this.root = root;
+
+    if (root.has("FS")) {
+      this.fs = root.get("FS");
+    }
+
+    this.description = root.has("Desc") ? (0, _util.stringToPDFString)(root.get("Desc")) : "";
+
+    if (root.has("RF")) {
+      (0, _util.warn)("Related file specifications are not supported");
+    }
+
+    this.contentAvailable = true;
+
+    if (!root.has("EF")) {
+      this.contentAvailable = false;
+      (0, _util.warn)("Non-embedded file specifications are not supported");
+    }
+  }
+
+  function pickPlatformItem(dict) {
+    if (dict.has("UF")) {
+      return dict.get("UF");
+    } else if (dict.has("F")) {
+      return dict.get("F");
+    } else if (dict.has("Unix")) {
+      return dict.get("Unix");
+    } else if (dict.has("Mac")) {
+      return dict.get("Mac");
+    } else if (dict.has("DOS")) {
+      return dict.get("DOS");
+    }
+
+    return null;
+  }
+
+  FileSpec.prototype = {
+    get filename() {
+      if (!this._filename && this.root) {
+        var filename = pickPlatformItem(this.root) || "unnamed";
+        this._filename = (0, _util.stringToPDFString)(filename).replace(/\\\\/g, "\\").replace(/\\\//g, "/").replace(/\\/g, "/");
+      }
+
+      return this._filename;
+    },
+
+    get content() {
+      if (!this.contentAvailable) {
+        return null;
+      }
+
+      if (!this.contentRef && this.root) {
+        this.contentRef = pickPlatformItem(this.root.get("EF"));
+      }
+
+      var content = null;
+
+      if (this.contentRef) {
+        var xref = this.xref;
+        var fileObj = xref.fetchIfRef(this.contentRef);
+
+        if (fileObj && (0, _primitives.isStream)(fileObj)) {
+          content = fileObj.getBytes();
+        } else {
+          (0, _util.warn)("Embedded file specification points to non-existing/invalid " + "content");
+        }
+      } else {
+        (0, _util.warn)("Embedded file specification does not have a content");
+      }
+
+      return content;
+    },
+
+    get serializable() {
+      return {
+        filename: this.filename,
+        content: this.content
+      };
+    }
+
+  };
+  return FileSpec;
+}();
+
+exports.FileSpec = FileSpec;
+
+const ObjectLoader = function () {
+  function mayHaveChildren(value) {
+    return value instanceof _primitives.Ref || value instanceof _primitives.Dict || Array.isArray(value) || (0, _primitives.isStream)(value);
+  }
+
+  function addChildren(node, nodesToVisit) {
+    if (node instanceof _primitives.Dict) {
+      node = node.getRawValues();
+    } else if ((0, _primitives.isStream)(node)) {
+      node = node.dict.getRawValues();
+    } else if (!Array.isArray(node)) {
+      return;
+    }
+
+    for (const rawValue of node) {
+      if (mayHaveChildren(rawValue)) {
+        nodesToVisit.push(rawValue);
+      }
+    }
+  }
+
+  function ObjectLoader(dict, keys, xref) {
+    this.dict = dict;
+    this.keys = keys;
+    this.xref = xref;
+    this.refSet = null;
+  }
+
+  ObjectLoader.prototype = {
+    async load() {
+      if (!this.xref.stream.allChunksLoaded || this.xref.stream.allChunksLoaded()) {
+        return undefined;
+      }
+
+      const {
+        keys,
+        dict
+      } = this;
+      this.refSet = new _primitives.RefSet();
+      const nodesToVisit = [];
+
+      for (let i = 0, ii = keys.length; i < ii; i++) {
+        const rawValue = dict.getRaw(keys[i]);
+
+        if (rawValue !== undefined) {
+          nodesToVisit.push(rawValue);
+        }
+      }
+
+      return this._walk(nodesToVisit);
+    },
+
+    async _walk(nodesToVisit) {
+      const nodesToRevisit = [];
+      const pendingRequests = [];
+
+      while (nodesToVisit.length) {
+        let currentNode = nodesToVisit.pop();
+
+        if (currentNode instanceof _primitives.Ref) {
+          if (this.refSet.has(currentNode)) {
+            continue;
+          }
+
+          try {
+            this.refSet.put(currentNode);
+            currentNode = this.xref.fetch(currentNode);
+          } catch (ex) {
+            if (!(ex instanceof _core_utils.MissingDataException)) {
+              throw ex;
+            }
+
+            nodesToRevisit.push(currentNode);
+            pendingRequests.push({
+              begin: ex.begin,
+              end: ex.end
+            });
+          }
+        }
+
+        if (currentNode && currentNode.getBaseStreams) {
+          const baseStreams = currentNode.getBaseStreams();
+          let foundMissingData = false;
+
+          for (let i = 0, ii = baseStreams.length; i < ii; i++) {
+            const stream = baseStreams[i];
+
+            if (stream.allChunksLoaded && !stream.allChunksLoaded()) {
+              foundMissingData = true;
+              pendingRequests.push({
+                begin: stream.start,
+                end: stream.end
+              });
+            }
+          }
+
+          if (foundMissingData) {
+            nodesToRevisit.push(currentNode);
+          }
+        }
+
+        addChildren(currentNode, nodesToVisit);
+      }
+
+      if (pendingRequests.length) {
+        await this.xref.stream.manager.requestRanges(pendingRequests);
+
+        for (let i = 0, ii = nodesToRevisit.length; i < ii; i++) {
+          const node = nodesToRevisit[i];
+
+          if (node instanceof _primitives.Ref) {
+            this.refSet.remove(node);
+          }
+        }
+
+        return this._walk(nodesToRevisit);
+      }
+
+      this.refSet = null;
+      return undefined;
+    }
+
+  };
+  return ObjectLoader;
+}();
+
+exports.ObjectLoader = ObjectLoader;
+
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Parser = exports.Linearization = exports.Lexer = void 0;
+
+var _stream = __w_pdfjs_require__(12);
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _ccitt_stream = __w_pdfjs_require__(13);
+
+var _jbig2_stream = __w_pdfjs_require__(15);
+
+var _jpeg_stream = __w_pdfjs_require__(18);
+
+var _jpx_stream = __w_pdfjs_require__(20);
+
+const MAX_LENGTH_TO_CACHE = 1000;
+const MAX_ADLER32_LENGTH = 5552;
+
+function computeAdler32(bytes) {
+  const bytesLength = bytes.length;
+  let a = 1,
+      b = 0;
+
+  for (let i = 0; i < bytesLength; ++i) {
+    a += bytes[i] & 0xff;
+    b += a;
+  }
+
+  return b % 65521 << 16 | a % 65521;
+}
+
+class Parser {
+  constructor({
+    lexer,
+    xref,
+    allowStreams = false,
+    recoveryMode = false
+  }) {
+    this.lexer = lexer;
+    this.xref = xref;
+    this.allowStreams = allowStreams;
+    this.recoveryMode = recoveryMode;
+    this.imageCache = Object.create(null);
+    this.refill();
+  }
+
+  refill() {
+    this.buf1 = this.lexer.getObj();
+    this.buf2 = this.lexer.getObj();
+  }
+
+  shift() {
+    if (this.buf2 instanceof _primitives.Cmd && this.buf2.cmd === "ID") {
+      this.buf1 = this.buf2;
+      this.buf2 = null;
+    } else {
+      this.buf1 = this.buf2;
+      this.buf2 = this.lexer.getObj();
+    }
+  }
+
+  tryShift() {
+    try {
+      this.shift();
+      return true;
+    } catch (e) {
+      if (e instanceof _core_utils.MissingDataException) {
+        throw e;
+      }
+
+      return false;
+    }
+  }
+
+  getObj(cipherTransform = null) {
+    const buf1 = this.buf1;
+    this.shift();
+
+    if (buf1 instanceof _primitives.Cmd) {
+      switch (buf1.cmd) {
+        case "BI":
+          return this.makeInlineImage(cipherTransform);
+
+        case "[":
+          const array = [];
+
+          while (!(0, _primitives.isCmd)(this.buf1, "]") && !(0, _primitives.isEOF)(this.buf1)) {
+            array.push(this.getObj(cipherTransform));
+          }
+
+          if ((0, _primitives.isEOF)(this.buf1)) {
+            if (!this.recoveryMode) {
+              throw new _util.FormatError("End of file inside array");
+            }
+
+            return array;
+          }
+
+          this.shift();
+          return array;
+
+        case "<<":
+          const dict = new _primitives.Dict(this.xref);
+
+          while (!(0, _primitives.isCmd)(this.buf1, ">>") && !(0, _primitives.isEOF)(this.buf1)) {
+            if (!(0, _primitives.isName)(this.buf1)) {
+              (0, _util.info)("Malformed dictionary: key must be a name object");
+              this.shift();
+              continue;
+            }
+
+            const key = this.buf1.name;
+            this.shift();
+
+            if ((0, _primitives.isEOF)(this.buf1)) {
+              break;
+            }
+
+            dict.set(key, this.getObj(cipherTransform));
+          }
+
+          if ((0, _primitives.isEOF)(this.buf1)) {
+            if (!this.recoveryMode) {
+              throw new _util.FormatError("End of file inside dictionary");
+            }
+
+            return dict;
+          }
+
+          if ((0, _primitives.isCmd)(this.buf2, "stream")) {
+            return this.allowStreams ? this.makeStream(dict, cipherTransform) : dict;
+          }
+
+          this.shift();
+          return dict;
+
+        default:
+          return buf1;
+      }
+    }
+
+    if (Number.isInteger(buf1)) {
+      if (Number.isInteger(this.buf1) && (0, _primitives.isCmd)(this.buf2, "R")) {
+        const ref = _primitives.Ref.get(buf1, this.buf1);
+
+        this.shift();
+        this.shift();
+        return ref;
+      }
+
+      return buf1;
+    }
+
+    if (typeof buf1 === "string") {
+      if (cipherTransform) {
+        return cipherTransform.decryptString(buf1);
+      }
+
+      return buf1;
+    }
+
+    return buf1;
+  }
+
+  findDefaultInlineStreamEnd(stream) {
+    const E = 0x45,
+          I = 0x49,
+          SPACE = 0x20,
+          LF = 0xa,
+          CR = 0xd,
+          NUL = 0x0;
+    const lexer = this.lexer,
+          startPos = stream.pos,
+          n = 10;
+    let state = 0,
+        ch,
+        maybeEIPos;
+
+    while ((ch = stream.getByte()) !== -1) {
+      if (state === 0) {
+        state = ch === E ? 1 : 0;
+      } else if (state === 1) {
+        state = ch === I ? 2 : 0;
+      } else {
+        (0, _util.assert)(state === 2, "findDefaultInlineStreamEnd - invalid state.");
+
+        if (ch === SPACE || ch === LF || ch === CR) {
+          maybeEIPos = stream.pos;
+          const followingBytes = stream.peekBytes(n);
+
+          for (let i = 0, ii = followingBytes.length; i < ii; i++) {
+            ch = followingBytes[i];
+
+            if (ch === NUL && followingBytes[i + 1] !== NUL) {
+              continue;
+            }
+
+            if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7f)) {
+              state = 0;
+              break;
+            }
+          }
+
+          if (state !== 2) {
+            continue;
+          }
+
+          if (lexer.knownCommands) {
+            const nextObj = lexer.peekObj();
+
+            if (nextObj instanceof _primitives.Cmd && !lexer.knownCommands[nextObj.cmd]) {
+              state = 0;
+            }
+          } else {
+            (0, _util.warn)("findDefaultInlineStreamEnd - `lexer.knownCommands` is undefined.");
+          }
+
+          if (state === 2) {
+            break;
+          }
+        } else {
+          state = 0;
+        }
+      }
+    }
+
+    if (ch === -1) {
+      (0, _util.warn)("findDefaultInlineStreamEnd: " + "Reached the end of the stream without finding a valid EI marker");
+
+      if (maybeEIPos) {
+        (0, _util.warn)('... trying to recover by using the last "EI" occurrence.');
+        stream.skip(-(stream.pos - maybeEIPos));
+      }
+    }
+
+    let endOffset = 4;
+    stream.skip(-endOffset);
+    ch = stream.peekByte();
+    stream.skip(endOffset);
+
+    if (!(0, _core_utils.isWhiteSpace)(ch)) {
+      endOffset--;
+    }
+
+    return stream.pos - endOffset - startPos;
+  }
+
+  findDCTDecodeInlineStreamEnd(stream) {
+    const startPos = stream.pos;
+    let foundEOI = false,
+        b,
+        markerLength;
+
+    while ((b = stream.getByte()) !== -1) {
+      if (b !== 0xff) {
+        continue;
+      }
+
+      switch (stream.getByte()) {
+        case 0x00:
+          break;
+
+        case 0xff:
+          stream.skip(-1);
+          break;
+
+        case 0xd9:
+          foundEOI = true;
+          break;
+
+        case 0xc0:
+        case 0xc1:
+        case 0xc2:
+        case 0xc3:
+        case 0xc5:
+        case 0xc6:
+        case 0xc7:
+        case 0xc9:
+        case 0xca:
+        case 0xcb:
+        case 0xcd:
+        case 0xce:
+        case 0xcf:
+        case 0xc4:
+        case 0xcc:
+        case 0xda:
+        case 0xdb:
+        case 0xdc:
+        case 0xdd:
+        case 0xde:
+        case 0xdf:
+        case 0xe0:
+        case 0xe1:
+        case 0xe2:
+        case 0xe3:
+        case 0xe4:
+        case 0xe5:
+        case 0xe6:
+        case 0xe7:
+        case 0xe8:
+        case 0xe9:
+        case 0xea:
+        case 0xeb:
+        case 0xec:
+        case 0xed:
+        case 0xee:
+        case 0xef:
+        case 0xfe:
+          markerLength = stream.getUint16();
+
+          if (markerLength > 2) {
+            stream.skip(markerLength - 2);
+          } else {
+            stream.skip(-2);
+          }
+
+          break;
+      }
+
+      if (foundEOI) {
+        break;
+      }
+    }
+
+    const length = stream.pos - startPos;
+
+    if (b === -1) {
+      (0, _util.warn)("Inline DCTDecode image stream: " + "EOI marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
+
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  findASCII85DecodeInlineStreamEnd(stream) {
+    const TILDE = 0x7e,
+          GT = 0x3e;
+    const startPos = stream.pos;
+    let ch;
+
+    while ((ch = stream.getByte()) !== -1) {
+      if (ch === TILDE) {
+        const tildePos = stream.pos;
+        ch = stream.peekByte();
+
+        while ((0, _core_utils.isWhiteSpace)(ch)) {
+          stream.skip();
+          ch = stream.peekByte();
+        }
+
+        if (ch === GT) {
+          stream.skip();
+          break;
+        }
+
+        if (stream.pos > tildePos) {
+          const maybeEI = stream.peekBytes(2);
+
+          if (maybeEI[0] === 0x45 && maybeEI[1] === 0x49) {
+            break;
+          }
+        }
+      }
+    }
+
+    const length = stream.pos - startPos;
+
+    if (ch === -1) {
+      (0, _util.warn)("Inline ASCII85Decode image stream: " + "EOD marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
+
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  findASCIIHexDecodeInlineStreamEnd(stream) {
+    const GT = 0x3e;
+    const startPos = stream.pos;
+    let ch;
+
+    while ((ch = stream.getByte()) !== -1) {
+      if (ch === GT) {
+        break;
+      }
+    }
+
+    const length = stream.pos - startPos;
+
+    if (ch === -1) {
+      (0, _util.warn)("Inline ASCIIHexDecode image stream: " + "EOD marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
+
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  inlineStreamSkipEI(stream) {
+    const E = 0x45,
+          I = 0x49;
+    let state = 0,
+        ch;
+
+    while ((ch = stream.getByte()) !== -1) {
+      if (state === 0) {
+        state = ch === E ? 1 : 0;
+      } else if (state === 1) {
+        state = ch === I ? 2 : 0;
+      } else if (state === 2) {
+        break;
+      }
+    }
+  }
+
+  makeInlineImage(cipherTransform) {
+    const lexer = this.lexer;
+    const stream = lexer.stream;
+    const dict = new _primitives.Dict(this.xref);
+    let dictLength;
+
+    while (!(0, _primitives.isCmd)(this.buf1, "ID") && !(0, _primitives.isEOF)(this.buf1)) {
+      if (!(0, _primitives.isName)(this.buf1)) {
+        throw new _util.FormatError("Dictionary key must be a name object");
+      }
+
+      const key = this.buf1.name;
+      this.shift();
+
+      if ((0, _primitives.isEOF)(this.buf1)) {
+        break;
+      }
+
+      dict.set(key, this.getObj(cipherTransform));
+    }
+
+    if (lexer.beginInlineImagePos !== -1) {
+      dictLength = stream.pos - lexer.beginInlineImagePos;
+    }
+
+    const filter = dict.get("Filter", "F");
+    let filterName;
+
+    if ((0, _primitives.isName)(filter)) {
+      filterName = filter.name;
+    } else if (Array.isArray(filter)) {
+      const filterZero = this.xref.fetchIfRef(filter[0]);
+
+      if ((0, _primitives.isName)(filterZero)) {
+        filterName = filterZero.name;
+      }
+    }
+
+    const startPos = stream.pos;
+    let length;
+
+    if (filterName === "DCTDecode" || filterName === "DCT") {
+      length = this.findDCTDecodeInlineStreamEnd(stream);
+    } else if (filterName === "ASCII85Decode" || filterName === "A85") {
+      length = this.findASCII85DecodeInlineStreamEnd(stream);
+    } else if (filterName === "ASCIIHexDecode" || filterName === "AHx") {
+      length = this.findASCIIHexDecodeInlineStreamEnd(stream);
+    } else {
+      length = this.findDefaultInlineStreamEnd(stream);
+    }
+
+    let imageStream = stream.makeSubStream(startPos, length, dict);
+    let cacheKey;
+
+    if (length < MAX_LENGTH_TO_CACHE && dictLength < MAX_ADLER32_LENGTH) {
+      const imageBytes = imageStream.getBytes();
+      imageStream.reset();
+      const initialStreamPos = stream.pos;
+      stream.pos = lexer.beginInlineImagePos;
+      const dictBytes = stream.getBytes(dictLength);
+      stream.pos = initialStreamPos;
+      cacheKey = computeAdler32(imageBytes) + "_" + computeAdler32(dictBytes);
+      const cacheEntry = this.imageCache[cacheKey];
+
+      if (cacheEntry !== undefined) {
+        this.buf2 = _primitives.Cmd.get("EI");
+        this.shift();
+        cacheEntry.reset();
+        return cacheEntry;
+      }
+    }
+
+    if (cipherTransform) {
+      imageStream = cipherTransform.createStream(imageStream, length);
+    }
+
+    imageStream = this.filter(imageStream, dict, length);
+    imageStream.dict = dict;
+
+    if (cacheKey !== undefined) {
+      imageStream.cacheKey = `inline_${length}_${cacheKey}`;
+      this.imageCache[cacheKey] = imageStream;
+    }
+
+    this.buf2 = _primitives.Cmd.get("EI");
+    this.shift();
+    return imageStream;
+  }
+
+  _findStreamLength(startPos, signature) {
+    const {
+      stream
+    } = this.lexer;
+    stream.pos = startPos;
+    const SCAN_BLOCK_LENGTH = 2048;
+    const signatureLength = signature.length;
+
+    while (stream.pos < stream.end) {
+      const scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
+      const scanLength = scanBytes.length - signatureLength;
+
+      if (scanLength <= 0) {
+        break;
+      }
+
+      let pos = 0;
+
+      while (pos < scanLength) {
+        let j = 0;
+
+        while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
+          j++;
+        }
+
+        if (j >= signatureLength) {
+          stream.pos += pos;
+          return stream.pos - startPos;
+        }
+
+        pos++;
+      }
+
+      stream.pos += scanLength;
+    }
+
+    return -1;
+  }
+
+  makeStream(dict, cipherTransform) {
+    const lexer = this.lexer;
+    let stream = lexer.stream;
+    lexer.skipToNextLine();
+    const startPos = stream.pos - 1;
+    let length = dict.get("Length");
+
+    if (!Number.isInteger(length)) {
+      (0, _util.info)(`Bad length "${length}" in stream`);
+      length = 0;
+    }
+
+    stream.pos = startPos + length;
+    lexer.nextChar();
+
+    if (this.tryShift() && (0, _primitives.isCmd)(this.buf2, "endstream")) {
+      this.shift();
+    } else {
+      const ENDSTREAM_SIGNATURE = new Uint8Array([0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D]);
+
+      let actualLength = this._findStreamLength(startPos, ENDSTREAM_SIGNATURE);
+
+      if (actualLength < 0) {
+        const MAX_TRUNCATION = 1;
+
+        for (let i = 1; i <= MAX_TRUNCATION; i++) {
+          const end = ENDSTREAM_SIGNATURE.length - i;
+          const TRUNCATED_SIGNATURE = ENDSTREAM_SIGNATURE.slice(0, end);
+
+          const maybeLength = this._findStreamLength(startPos, TRUNCATED_SIGNATURE);
+
+          if (maybeLength >= 0) {
+            const lastByte = stream.peekBytes(end + 1)[end];
+
+            if (!(0, _core_utils.isWhiteSpace)(lastByte)) {
+              break;
+            }
+
+            (0, _util.info)(`Found "${(0, _util.bytesToString)(TRUNCATED_SIGNATURE)}" when ` + "searching for endstream command.");
+            actualLength = maybeLength;
+            break;
+          }
+        }
+
+        if (actualLength < 0) {
+          throw new _util.FormatError("Missing endstream command.");
+        }
+      }
+
+      length = actualLength;
+      lexer.nextChar();
+      this.shift();
+      this.shift();
+    }
+
+    this.shift();
+    stream = stream.makeSubStream(startPos, length, dict);
+
+    if (cipherTransform) {
+      stream = cipherTransform.createStream(stream, length);
+    }
+
+    stream = this.filter(stream, dict, length);
+    stream.dict = dict;
+    return stream;
+  }
+
+  filter(stream, dict, length) {
+    let filter = dict.get("Filter", "F");
+    let params = dict.get("DecodeParms", "DP");
+
+    if ((0, _primitives.isName)(filter)) {
+      if (Array.isArray(params)) {
+        (0, _util.warn)("/DecodeParms should not contain an Array, " + "when /Filter contains a Name.");
+      }
+
+      return this.makeFilter(stream, filter.name, length, params);
+    }
+
+    let maybeLength = length;
+
+    if (Array.isArray(filter)) {
+      const filterArray = filter;
+      const paramsArray = params;
+
+      for (let i = 0, ii = filterArray.length; i < ii; ++i) {
+        filter = this.xref.fetchIfRef(filterArray[i]);
+
+        if (!(0, _primitives.isName)(filter)) {
+          throw new _util.FormatError(`Bad filter name "${filter}"`);
+        }
+
+        params = null;
+
+        if (Array.isArray(paramsArray) && i in paramsArray) {
+          params = this.xref.fetchIfRef(paramsArray[i]);
+        }
+
+        stream = this.makeFilter(stream, filter.name, maybeLength, params);
+        maybeLength = null;
+      }
+    }
+
+    return stream;
+  }
+
+  makeFilter(stream, name, maybeLength, params) {
+    if (maybeLength === 0) {
+      (0, _util.warn)(`Empty "${name}" stream.`);
+      return new _stream.NullStream();
+    }
+
+    try {
+      const xrefStreamStats = this.xref.stats.streamTypes;
+
+      if (name === "FlateDecode" || name === "Fl") {
+        xrefStreamStats[_util.StreamType.FLATE] = true;
+
+        if (params) {
+          return new _stream.PredictorStream(new _stream.FlateStream(stream, maybeLength), maybeLength, params);
+        }
+
+        return new _stream.FlateStream(stream, maybeLength);
+      }
+
+      if (name === "LZWDecode" || name === "LZW") {
+        xrefStreamStats[_util.StreamType.LZW] = true;
+        let earlyChange = 1;
+
+        if (params) {
+          if (params.has("EarlyChange")) {
+            earlyChange = params.get("EarlyChange");
+          }
+
+          return new _stream.PredictorStream(new _stream.LZWStream(stream, maybeLength, earlyChange), maybeLength, params);
+        }
+
+        return new _stream.LZWStream(stream, maybeLength, earlyChange);
+      }
+
+      if (name === "DCTDecode" || name === "DCT") {
+        xrefStreamStats[_util.StreamType.DCT] = true;
+        return new _jpeg_stream.JpegStream(stream, maybeLength, stream.dict, params);
+      }
+
+      if (name === "JPXDecode" || name === "JPX") {
+        xrefStreamStats[_util.StreamType.JPX] = true;
+        return new _jpx_stream.JpxStream(stream, maybeLength, stream.dict, params);
+      }
+
+      if (name === "ASCII85Decode" || name === "A85") {
+        xrefStreamStats[_util.StreamType.A85] = true;
+        return new _stream.Ascii85Stream(stream, maybeLength);
+      }
+
+      if (name === "ASCIIHexDecode" || name === "AHx") {
+        xrefStreamStats[_util.StreamType.AHX] = true;
+        return new _stream.AsciiHexStream(stream, maybeLength);
+      }
+
+      if (name === "CCITTFaxDecode" || name === "CCF") {
+        xrefStreamStats[_util.StreamType.CCF] = true;
+        return new _ccitt_stream.CCITTFaxStream(stream, maybeLength, params);
+      }
+
+      if (name === "RunLengthDecode" || name === "RL") {
+        xrefStreamStats[_util.StreamType.RLX] = true;
+        return new _stream.RunLengthStream(stream, maybeLength);
+      }
+
+      if (name === "JBIG2Decode") {
+        xrefStreamStats[_util.StreamType.JBIG] = true;
+        return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
+      }
+
+      (0, _util.warn)(`Filter "${name}" is not supported.`);
+      return stream;
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)(`Invalid stream: "${ex}"`);
+      return new _stream.NullStream();
+    }
+  }
+
+}
+
+exports.Parser = Parser;
+const specialChars = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+function toHexDigit(ch) {
+  if (ch >= 0x30 && ch <= 0x39) {
+    return ch & 0x0f;
+  }
+
+  if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+    return (ch & 0x0f) + 9;
+  }
+
+  return -1;
+}
+
+class Lexer {
+  constructor(stream, knownCommands = null) {
+    this.stream = stream;
+    this.nextChar();
+    this.strBuf = [];
+    this.knownCommands = knownCommands;
+    this._hexStringNumWarn = 0;
+    this.beginInlineImagePos = -1;
+  }
+
+  nextChar() {
+    return this.currentChar = this.stream.getByte();
+  }
+
+  peekChar() {
+    return this.stream.peekByte();
+  }
+
+  getNumber() {
+    let ch = this.currentChar;
+    let eNotation = false;
+    let divideBy = 0;
+    let sign = 0;
+
+    if (ch === 0x2d) {
+      sign = -1;
+      ch = this.nextChar();
+
+      if (ch === 0x2d) {
+        ch = this.nextChar();
+      }
+    } else if (ch === 0x2b) {
+      sign = 1;
+      ch = this.nextChar();
+    }
+
+    if (ch === 0x0a || ch === 0x0d) {
+      do {
+        ch = this.nextChar();
+      } while (ch === 0x0a || ch === 0x0d);
+    }
+
+    if (ch === 0x2e) {
+      divideBy = 10;
+      ch = this.nextChar();
+    }
+
+    if (ch < 0x30 || ch > 0x39) {
+      if (divideBy === 10 && sign === 0 && ((0, _core_utils.isWhiteSpace)(ch) || ch === -1)) {
+        (0, _util.warn)("Lexer.getNumber - treating a single decimal point as zero.");
+        return 0;
+      }
+
+      throw new _util.FormatError(`Invalid number: ${String.fromCharCode(ch)} (charCode ${ch})`);
+    }
+
+    sign = sign || 1;
+    let baseValue = ch - 0x30;
+    let powerValue = 0;
+    let powerValueSign = 1;
+
+    while ((ch = this.nextChar()) >= 0) {
+      if (ch >= 0x30 && ch <= 0x39) {
+        const currentDigit = ch - 0x30;
+
+        if (eNotation) {
+          powerValue = powerValue * 10 + currentDigit;
+        } else {
+          if (divideBy !== 0) {
+            divideBy *= 10;
+          }
+
+          baseValue = baseValue * 10 + currentDigit;
+        }
+      } else if (ch === 0x2e) {
+        if (divideBy === 0) {
+          divideBy = 1;
+        } else {
+          break;
+        }
+      } else if (ch === 0x2d) {
+        (0, _util.warn)("Badly formatted number: minus sign in the middle");
+      } else if (ch === 0x45 || ch === 0x65) {
+        ch = this.peekChar();
+
+        if (ch === 0x2b || ch === 0x2d) {
+          powerValueSign = ch === 0x2d ? -1 : 1;
+          this.nextChar();
+        } else if (ch < 0x30 || ch > 0x39) {
+          break;
+        }
+
+        eNotation = true;
+      } else {
+        break;
+      }
+    }
+
+    if (divideBy !== 0) {
+      baseValue /= divideBy;
+    }
+
+    if (eNotation) {
+      baseValue *= 10 ** (powerValueSign * powerValue);
+    }
+
+    return sign * baseValue;
+  }
+
+  getString() {
+    let numParen = 1;
+    let done = false;
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    let ch = this.nextChar();
+
+    while (true) {
+      let charBuffered = false;
+
+      switch (ch | 0) {
+        case -1:
+          (0, _util.warn)("Unterminated string");
+          done = true;
+          break;
+
+        case 0x28:
+          ++numParen;
+          strBuf.push("(");
+          break;
+
+        case 0x29:
+          if (--numParen === 0) {
+            this.nextChar();
+            done = true;
+          } else {
+            strBuf.push(")");
+          }
+
+          break;
+
+        case 0x5c:
+          ch = this.nextChar();
+
+          switch (ch) {
+            case -1:
+              (0, _util.warn)("Unterminated string");
+              done = true;
+              break;
+
+            case 0x6e:
+              strBuf.push("\n");
+              break;
+
+            case 0x72:
+              strBuf.push("\r");
+              break;
+
+            case 0x74:
+              strBuf.push("\t");
+              break;
+
+            case 0x62:
+              strBuf.push("\b");
+              break;
+
+            case 0x66:
+              strBuf.push("\f");
+              break;
+
+            case 0x5c:
+            case 0x28:
+            case 0x29:
+              strBuf.push(String.fromCharCode(ch));
+              break;
+
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+              let x = ch & 0x0f;
+              ch = this.nextChar();
+              charBuffered = true;
+
+              if (ch >= 0x30 && ch <= 0x37) {
+                x = (x << 3) + (ch & 0x0f);
+                ch = this.nextChar();
+
+                if (ch >= 0x30 && ch <= 0x37) {
+                  charBuffered = false;
+                  x = (x << 3) + (ch & 0x0f);
+                }
+              }
+
+              strBuf.push(String.fromCharCode(x));
+              break;
+
+            case 0x0d:
+              if (this.peekChar() === 0x0a) {
+                this.nextChar();
+              }
+
+              break;
+
+            case 0x0a:
+              break;
+
+            default:
+              strBuf.push(String.fromCharCode(ch));
+              break;
+          }
+
+          break;
+
+        default:
+          strBuf.push(String.fromCharCode(ch));
+          break;
+      }
+
+      if (done) {
+        break;
+      }
+
+      if (!charBuffered) {
+        ch = this.nextChar();
+      }
+    }
+
+    return strBuf.join("");
+  }
+
+  getName() {
+    let ch, previousCh;
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+
+    while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
+      if (ch === 0x23) {
+        ch = this.nextChar();
+
+        if (specialChars[ch]) {
+          (0, _util.warn)("Lexer_getName: " + "NUMBER SIGN (#) should be followed by a hexadecimal number.");
+          strBuf.push("#");
+          break;
+        }
+
+        const x = toHexDigit(ch);
+
+        if (x !== -1) {
+          previousCh = ch;
+          ch = this.nextChar();
+          const x2 = toHexDigit(ch);
+
+          if (x2 === -1) {
+            (0, _util.warn)(`Lexer_getName: Illegal digit (${String.fromCharCode(ch)}) ` + "in hexadecimal number.");
+            strBuf.push("#", String.fromCharCode(previousCh));
+
+            if (specialChars[ch]) {
+              break;
+            }
+
+            strBuf.push(String.fromCharCode(ch));
+            continue;
+          }
+
+          strBuf.push(String.fromCharCode(x << 4 | x2));
+        } else {
+          strBuf.push("#", String.fromCharCode(ch));
+        }
+      } else {
+        strBuf.push(String.fromCharCode(ch));
+      }
+    }
+
+    if (strBuf.length > 127) {
+      (0, _util.warn)(`Name token is longer than allowed by the spec: ${strBuf.length}`);
+    }
+
+    return _primitives.Name.get(strBuf.join(""));
+  }
+
+  _hexStringWarn(ch) {
+    const MAX_HEX_STRING_NUM_WARN = 5;
+
+    if (this._hexStringNumWarn++ === MAX_HEX_STRING_NUM_WARN) {
+      (0, _util.warn)("getHexString - ignoring additional invalid characters.");
+      return;
+    }
+
+    if (this._hexStringNumWarn > MAX_HEX_STRING_NUM_WARN) {
+      return;
+    }
+
+    (0, _util.warn)(`getHexString - ignoring invalid character: ${ch}`);
+  }
+
+  getHexString() {
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    let ch = this.currentChar;
+    let isFirstHex = true;
+    let firstDigit, secondDigit;
+    this._hexStringNumWarn = 0;
+
+    while (true) {
+      if (ch < 0) {
+        (0, _util.warn)("Unterminated hex string");
+        break;
+      } else if (ch === 0x3e) {
+        this.nextChar();
+        break;
+      } else if (specialChars[ch] === 1) {
+        ch = this.nextChar();
+        continue;
+      } else {
+        if (isFirstHex) {
+          firstDigit = toHexDigit(ch);
+
+          if (firstDigit === -1) {
+            this._hexStringWarn(ch);
+
+            ch = this.nextChar();
+            continue;
+          }
+        } else {
+          secondDigit = toHexDigit(ch);
+
+          if (secondDigit === -1) {
+            this._hexStringWarn(ch);
+
+            ch = this.nextChar();
+            continue;
+          }
+
+          strBuf.push(String.fromCharCode(firstDigit << 4 | secondDigit));
+        }
+
+        isFirstHex = !isFirstHex;
+        ch = this.nextChar();
+      }
+    }
+
+    return strBuf.join("");
+  }
+
+  getObj() {
+    let comment = false;
+    let ch = this.currentChar;
+
+    while (true) {
+      if (ch < 0) {
+        return _primitives.EOF;
+      }
+
+      if (comment) {
+        if (ch === 0x0a || ch === 0x0d) {
+          comment = false;
+        }
+      } else if (ch === 0x25) {
+        comment = true;
+      } else if (specialChars[ch] !== 1) {
+        break;
+      }
+
+      ch = this.nextChar();
+    }
+
+    switch (ch | 0) {
+      case 0x30:
+      case 0x31:
+      case 0x32:
+      case 0x33:
+      case 0x34:
+      case 0x35:
+      case 0x36:
+      case 0x37:
+      case 0x38:
+      case 0x39:
+      case 0x2b:
+      case 0x2d:
+      case 0x2e:
+        return this.getNumber();
+
+      case 0x28:
+        return this.getString();
+
+      case 0x2f:
+        return this.getName();
+
+      case 0x5b:
+        this.nextChar();
+        return _primitives.Cmd.get("[");
+
+      case 0x5d:
+        this.nextChar();
+        return _primitives.Cmd.get("]");
+
+      case 0x3c:
+        ch = this.nextChar();
+
+        if (ch === 0x3c) {
+          this.nextChar();
+          return _primitives.Cmd.get("<<");
+        }
+
+        return this.getHexString();
+
+      case 0x3e:
+        ch = this.nextChar();
+
+        if (ch === 0x3e) {
+          this.nextChar();
+          return _primitives.Cmd.get(">>");
+        }
+
+        return _primitives.Cmd.get(">");
+
+      case 0x7b:
+        this.nextChar();
+        return _primitives.Cmd.get("{");
+
+      case 0x7d:
+        this.nextChar();
+        return _primitives.Cmd.get("}");
+
+      case 0x29:
+        this.nextChar();
+        throw new _util.FormatError(`Illegal character: ${ch}`);
+    }
+
+    let str = String.fromCharCode(ch);
+    const knownCommands = this.knownCommands;
+    let knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+
+    while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
+      const possibleCommand = str + String.fromCharCode(ch);
+
+      if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
+        break;
+      }
+
+      if (str.length === 128) {
+        throw new _util.FormatError(`Command token too long: ${str.length}`);
+      }
+
+      str = possibleCommand;
+      knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+    }
+
+    if (str === "true") {
+      return true;
+    }
+
+    if (str === "false") {
+      return false;
+    }
+
+    if (str === "null") {
+      return null;
+    }
+
+    if (str === "BI") {
+      this.beginInlineImagePos = this.stream.pos;
+    }
+
+    return _primitives.Cmd.get(str);
+  }
+
+  peekObj() {
+    const streamPos = this.stream.pos,
+          currentChar = this.currentChar,
+          beginInlineImagePos = this.beginInlineImagePos;
+    let nextObj;
+
+    try {
+      nextObj = this.getObj();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      (0, _util.warn)(`peekObj: ${ex}`);
+    }
+
+    this.stream.pos = streamPos;
+    this.currentChar = currentChar;
+    this.beginInlineImagePos = beginInlineImagePos;
+    return nextObj;
+  }
+
+  skipToNextLine() {
+    let ch = this.currentChar;
+
+    while (ch >= 0) {
+      if (ch === 0x0d) {
+        ch = this.nextChar();
+
+        if (ch === 0x0a) {
+          this.nextChar();
+        }
+
+        break;
+      } else if (ch === 0x0a) {
+        this.nextChar();
+        break;
+      }
+
+      ch = this.nextChar();
+    }
+  }
+
+}
+
+exports.Lexer = Lexer;
+
+class Linearization {
+  static create(stream) {
+    function getInt(linDict, name, allowZeroValue = false) {
+      const obj = linDict.get(name);
+
+      if (Number.isInteger(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
+        return obj;
+      }
+
+      throw new Error(`The "${name}" parameter in the linearization ` + "dictionary is invalid.");
+    }
+
+    function getHints(linDict) {
+      const hints = linDict.get("H");
+      let hintsLength;
+
+      if (Array.isArray(hints) && ((hintsLength = hints.length) === 2 || hintsLength === 4)) {
+        for (let index = 0; index < hintsLength; index++) {
+          const hint = hints[index];
+
+          if (!(Number.isInteger(hint) && hint > 0)) {
+            throw new Error(`Hint (${index}) in the linearization dictionary is invalid.`);
+          }
+        }
+
+        return hints;
+      }
+
+      throw new Error("Hint array in the linearization dictionary is invalid.");
+    }
+
+    const parser = new Parser({
+      lexer: new Lexer(stream),
+      xref: null
+    });
+    const obj1 = parser.getObj();
+    const obj2 = parser.getObj();
+    const obj3 = parser.getObj();
+    const linDict = parser.getObj();
+    let obj, length;
+
+    if (!(Number.isInteger(obj1) && Number.isInteger(obj2) && (0, _primitives.isCmd)(obj3, "obj") && (0, _primitives.isDict)(linDict) && (0, _util.isNum)(obj = linDict.get("Linearized")) && obj > 0)) {
+      return null;
+    } else if ((length = getInt(linDict, "L")) !== stream.length) {
+      throw new Error('The "L" parameter in the linearization dictionary ' + "does not equal the stream length.");
+    }
+
+    return {
+      length,
+      hints: getHints(linDict),
+      objectNumberFirst: getInt(linDict, "O"),
+      endFirst: getInt(linDict, "E"),
+      numPages: getInt(linDict, "N"),
+      mainXRefEntriesOffset: getInt(linDict, "T"),
+      pageFirst: linDict.has("P") ? getInt(linDict, "P", true) : 0
+    };
+  }
+
+}
+
+exports.Linearization = Linearization;
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.StringStream = exports.StreamsSequenceStream = exports.Stream = exports.RunLengthStream = exports.PredictorStream = exports.NullStream = exports.LZWStream = exports.FlateStream = exports.DecryptStream = exports.DecodeStream = exports.AsciiHexStream = exports.Ascii85Stream = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var Stream = function StreamClosure() {
+  function Stream(arrayBuffer, start, length, dict) {
+    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
+    this.start = start || 0;
+    this.pos = this.start;
+    this.end = start + length || this.bytes.length;
+    this.dict = dict;
+  }
+
+  Stream.prototype = {
+    get length() {
+      return this.end - this.start;
+    },
+
+    get isEmpty() {
+      return this.length === 0;
+    },
+
+    getByte: function Stream_getByte() {
+      if (this.pos >= this.end) {
+        return -1;
+      }
+
+      return this.bytes[this.pos++];
+    },
+    getUint16: function Stream_getUint16() {
+      var b0 = this.getByte();
+      var b1 = this.getByte();
+
+      if (b0 === -1 || b1 === -1) {
+        return -1;
+      }
+
+      return (b0 << 8) + b1;
+    },
+    getInt32: function Stream_getInt32() {
+      var b0 = this.getByte();
+      var b1 = this.getByte();
+      var b2 = this.getByte();
+      var b3 = this.getByte();
+      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+    },
+
+    getBytes(length, forceClamped = false) {
+      var bytes = this.bytes;
+      var pos = this.pos;
+      var strEnd = this.end;
+
+      if (!length) {
+        const subarray = bytes.subarray(pos, strEnd);
+        return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+      }
+
+      var end = pos + length;
+
+      if (end > strEnd) {
+        end = strEnd;
+      }
+
+      this.pos = end;
+      const subarray = bytes.subarray(pos, end);
+      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
+    },
+
+    peekByte: function Stream_peekByte() {
+      var peekedByte = this.getByte();
+
+      if (peekedByte !== -1) {
+        this.pos--;
+      }
+
+      return peekedByte;
+    },
+
+    peekBytes(length, forceClamped = false) {
+      var bytes = this.getBytes(length, forceClamped);
+      this.pos -= bytes.length;
+      return bytes;
+    },
+
+    getByteRange(begin, end) {
+      if (begin < 0) {
+        begin = 0;
+      }
+
+      if (end > this.end) {
+        end = this.end;
+      }
+
+      return this.bytes.subarray(begin, end);
+    },
+
+    skip: function Stream_skip(n) {
+      if (!n) {
+        n = 1;
+      }
+
+      this.pos += n;
+    },
+    reset: function Stream_reset() {
+      this.pos = this.start;
+    },
+    moveStart: function Stream_moveStart() {
+      this.start = this.pos;
+    },
+    makeSubStream: function Stream_makeSubStream(start, length, dict) {
+      return new Stream(this.bytes.buffer, start, length, dict);
+    }
+  };
+  return Stream;
+}();
+
+exports.Stream = Stream;
+
+var StringStream = function StringStreamClosure() {
+  function StringStream(str) {
+    const bytes = (0, _util.stringToBytes)(str);
+    Stream.call(this, bytes);
+  }
+
+  StringStream.prototype = Stream.prototype;
+  return StringStream;
+}();
+
+exports.StringStream = StringStream;
+
+var DecodeStream = function DecodeStreamClosure() {
+  var emptyBuffer = new Uint8Array(0);
+
+  function DecodeStream(maybeMinBufferLength) {
+    this._rawMinBufferLength = maybeMinBufferLength || 0;
+    this.pos = 0;
+    this.bufferLength = 0;
+    this.eof = false;
+    this.buffer = emptyBuffer;
+    this.minBufferLength = 512;
+
+    if (maybeMinBufferLength) {
+      while (this.minBufferLength < maybeMinBufferLength) {
+        this.minBufferLength *= 2;
+      }
+    }
+  }
+
+  DecodeStream.prototype = {
+    get length() {
+      (0, _util.unreachable)("Should not access DecodeStream.length");
+    },
+
+    get isEmpty() {
+      while (!this.eof && this.bufferLength === 0) {
+        this.readBlock();
+      }
+
+      return this.bufferLength === 0;
+    },
+
+    ensureBuffer: function DecodeStream_ensureBuffer(requested) {
+      var buffer = this.buffer;
+
+      if (requested <= buffer.byteLength) {
+        return buffer;
+      }
+
+      var size = this.minBufferLength;
+
+      while (size < requested) {
+        size *= 2;
+      }
+
+      var buffer2 = new Uint8Array(size);
+      buffer2.set(buffer);
+      return this.buffer = buffer2;
+    },
+    getByte: function DecodeStream_getByte() {
+      var pos = this.pos;
+
+      while (this.bufferLength <= pos) {
+        if (this.eof) {
+          return -1;
+        }
+
+        this.readBlock();
+      }
+
+      return this.buffer[this.pos++];
+    },
+    getUint16: function DecodeStream_getUint16() {
+      var b0 = this.getByte();
+      var b1 = this.getByte();
+
+      if (b0 === -1 || b1 === -1) {
+        return -1;
+      }
+
+      return (b0 << 8) + b1;
+    },
+    getInt32: function DecodeStream_getInt32() {
+      var b0 = this.getByte();
+      var b1 = this.getByte();
+      var b2 = this.getByte();
+      var b3 = this.getByte();
+      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+    },
+
+    getBytes(length, forceClamped = false) {
+      var end,
+          pos = this.pos;
+
+      if (length) {
+        this.ensureBuffer(pos + length);
+        end = pos + length;
+
+        while (!this.eof && this.bufferLength < end) {
+          this.readBlock();
+        }
+
+        var bufEnd = this.bufferLength;
+
+        if (end > bufEnd) {
+          end = bufEnd;
+        }
+      } else {
+        while (!this.eof) {
+          this.readBlock();
+        }
+
+        end = this.bufferLength;
+      }
+
+      this.pos = end;
+      const subarray = this.buffer.subarray(pos, end);
+      return forceClamped && !(subarray instanceof Uint8ClampedArray) ? new Uint8ClampedArray(subarray) : subarray;
+    },
+
+    peekByte: function DecodeStream_peekByte() {
+      var peekedByte = this.getByte();
+
+      if (peekedByte !== -1) {
+        this.pos--;
+      }
+
+      return peekedByte;
+    },
+
+    peekBytes(length, forceClamped = false) {
+      var bytes = this.getBytes(length, forceClamped);
+      this.pos -= bytes.length;
+      return bytes;
+    },
+
+    makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
+      var end = start + length;
+
+      while (this.bufferLength <= end && !this.eof) {
+        this.readBlock();
+      }
+
+      return new Stream(this.buffer, start, length, dict);
+    },
+
+    getByteRange(begin, end) {
+      (0, _util.unreachable)("Should not call DecodeStream.getByteRange");
+    },
+
+    skip: function DecodeStream_skip(n) {
+      if (!n) {
+        n = 1;
+      }
+
+      this.pos += n;
+    },
+    reset: function DecodeStream_reset() {
+      this.pos = 0;
+    },
+    getBaseStreams: function DecodeStream_getBaseStreams() {
+      if (this.str && this.str.getBaseStreams) {
+        return this.str.getBaseStreams();
+      }
+
+      return [];
+    }
+  };
+  return DecodeStream;
+}();
+
+exports.DecodeStream = DecodeStream;
+
+var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
+  function StreamsSequenceStream(streams) {
+    this.streams = streams;
+    let maybeLength = 0;
+
+    for (let i = 0, ii = streams.length; i < ii; i++) {
+      const stream = streams[i];
+
+      if (stream instanceof DecodeStream) {
+        maybeLength += stream._rawMinBufferLength;
+      } else {
+        maybeLength += stream.length;
+      }
+    }
+
+    DecodeStream.call(this, maybeLength);
+  }
+
+  StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
+
+  StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
+    var streams = this.streams;
+
+    if (streams.length === 0) {
+      this.eof = true;
+      return;
+    }
+
+    var stream = streams.shift();
+    var chunk = stream.getBytes();
+    var bufferLength = this.bufferLength;
+    var newLength = bufferLength + chunk.length;
+    var buffer = this.ensureBuffer(newLength);
+    buffer.set(chunk, bufferLength);
+    this.bufferLength = newLength;
+  };
+
+  StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
+    var baseStreams = [];
+
+    for (var i = 0, ii = this.streams.length; i < ii; i++) {
+      var stream = this.streams[i];
+
+      if (stream.getBaseStreams) {
+        baseStreams.push(...stream.getBaseStreams());
+      }
+    }
+
+    return baseStreams;
+  };
+
+  return StreamsSequenceStream;
+}();
+
+exports.StreamsSequenceStream = StreamsSequenceStream;
+
+var FlateStream = function FlateStreamClosure() {
+  var codeLenCodeMap = new Int32Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  var lengthDecode = new Int32Array([0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a, 0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f, 0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073, 0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102]);
+  var distDecode = new Int32Array([0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d, 0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1, 0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01, 0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001]);
+  var fixedLitCodeTab = [new Int32Array([0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0, 0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0, 0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0, 0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8, 0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8, 0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8, 0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4, 0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4, 0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4, 0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc, 0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec, 0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc, 0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2, 0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2, 0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2, 0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca, 0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea, 0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da, 0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6, 0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6, 0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6, 0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce, 0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee, 0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de, 0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe, 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1, 0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1, 0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1, 0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9, 0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9, 0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9, 0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5, 0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5, 0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5, 0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd, 0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed, 0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd, 0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3, 0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3, 0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3, 0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb, 0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb, 0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db, 0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7, 0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7, 0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7, 0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf, 0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef, 0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df, 0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff]), 9];
+  var fixedDistCodeTab = [new Int32Array([0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c, 0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000, 0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d, 0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000]), 5];
+
+  function FlateStream(str, maybeLength) {
+    this.str = str;
+    this.dict = str.dict;
+    var cmf = str.getByte();
+    var flg = str.getByte();
+
+    if (cmf === -1 || flg === -1) {
+      throw new _util.FormatError(`Invalid header in flate stream: ${cmf}, ${flg}`);
+    }
+
+    if ((cmf & 0x0f) !== 0x08) {
+      throw new _util.FormatError(`Unknown compression method in flate stream: ${cmf}, ${flg}`);
+    }
+
+    if (((cmf << 8) + flg) % 31 !== 0) {
+      throw new _util.FormatError(`Bad FCHECK in flate stream: ${cmf}, ${flg}`);
+    }
+
+    if (flg & 0x20) {
+      throw new _util.FormatError(`FDICT bit set in flate stream: ${cmf}, ${flg}`);
+    }
+
+    this.codeSize = 0;
+    this.codeBuf = 0;
+    DecodeStream.call(this, maybeLength);
+  }
+
+  FlateStream.prototype = Object.create(DecodeStream.prototype);
+
+  FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
+    var str = this.str;
+    var codeSize = this.codeSize;
+    var codeBuf = this.codeBuf;
+    var b;
+
+    while (codeSize < bits) {
+      if ((b = str.getByte()) === -1) {
+        throw new _util.FormatError("Bad encoding in flate stream");
+      }
+
+      codeBuf |= b << codeSize;
+      codeSize += 8;
+    }
+
+    b = codeBuf & (1 << bits) - 1;
+    this.codeBuf = codeBuf >> bits;
+    this.codeSize = codeSize -= bits;
+    return b;
+  };
+
+  FlateStream.prototype.getCode = function FlateStream_getCode(table) {
+    var str = this.str;
+    var codes = table[0];
+    var maxLen = table[1];
+    var codeSize = this.codeSize;
+    var codeBuf = this.codeBuf;
+    var b;
+
+    while (codeSize < maxLen) {
+      if ((b = str.getByte()) === -1) {
+        break;
+      }
+
+      codeBuf |= b << codeSize;
+      codeSize += 8;
+    }
+
+    var code = codes[codeBuf & (1 << maxLen) - 1];
+    var codeLen = code >> 16;
+    var codeVal = code & 0xffff;
+
+    if (codeLen < 1 || codeSize < codeLen) {
+      throw new _util.FormatError("Bad encoding in flate stream");
+    }
+
+    this.codeBuf = codeBuf >> codeLen;
+    this.codeSize = codeSize - codeLen;
+    return codeVal;
+  };
+
+  FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
+    var n = lengths.length;
+    var maxLen = 0;
+    var i;
+
+    for (i = 0; i < n; ++i) {
+      if (lengths[i] > maxLen) {
+        maxLen = lengths[i];
+      }
+    }
+
+    var size = 1 << maxLen;
+    var codes = new Int32Array(size);
+
+    for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
+      for (var val = 0; val < n; ++val) {
+        if (lengths[val] === len) {
+          var code2 = 0;
+          var t = code;
+
+          for (i = 0; i < len; ++i) {
+            code2 = code2 << 1 | t & 1;
+            t >>= 1;
+          }
+
+          for (i = code2; i < size; i += skip) {
+            codes[i] = len << 16 | val;
+          }
+
+          ++code;
+        }
+      }
+    }
+
+    return [codes, maxLen];
+  };
+
+  FlateStream.prototype.readBlock = function FlateStream_readBlock() {
+    var buffer, len;
+    var str = this.str;
+    var hdr = this.getBits(3);
+
+    if (hdr & 1) {
+      this.eof = true;
+    }
+
+    hdr >>= 1;
+
+    if (hdr === 0) {
+      var b;
+
+      if ((b = str.getByte()) === -1) {
+        throw new _util.FormatError("Bad block header in flate stream");
+      }
+
+      var blockLen = b;
+
+      if ((b = str.getByte()) === -1) {
+        throw new _util.FormatError("Bad block header in flate stream");
+      }
+
+      blockLen |= b << 8;
+
+      if ((b = str.getByte()) === -1) {
+        throw new _util.FormatError("Bad block header in flate stream");
+      }
+
+      var check = b;
+
+      if ((b = str.getByte()) === -1) {
+        throw new _util.FormatError("Bad block header in flate stream");
+      }
+
+      check |= b << 8;
+
+      if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
+        throw new _util.FormatError("Bad uncompressed block length in flate stream");
+      }
+
+      this.codeBuf = 0;
+      this.codeSize = 0;
+      const bufferLength = this.bufferLength,
+            end = bufferLength + blockLen;
+      buffer = this.ensureBuffer(end);
+      this.bufferLength = end;
+
+      if (blockLen === 0) {
+        if (str.peekByte() === -1) {
+          this.eof = true;
+        }
+      } else {
+        const block = str.getBytes(blockLen);
+        buffer.set(block, bufferLength);
+
+        if (block.length < blockLen) {
+          this.eof = true;
+        }
+      }
+
+      return;
+    }
+
+    var litCodeTable;
+    var distCodeTable;
+
+    if (hdr === 1) {
+      litCodeTable = fixedLitCodeTab;
+      distCodeTable = fixedDistCodeTab;
+    } else if (hdr === 2) {
+      var numLitCodes = this.getBits(5) + 257;
+      var numDistCodes = this.getBits(5) + 1;
+      var numCodeLenCodes = this.getBits(4) + 4;
+      var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
+      var i;
+
+      for (i = 0; i < numCodeLenCodes; ++i) {
+        codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
+      }
+
+      var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
+      len = 0;
+      i = 0;
+      var codes = numLitCodes + numDistCodes;
+      var codeLengths = new Uint8Array(codes);
+      var bitsLength, bitsOffset, what;
+
+      while (i < codes) {
+        var code = this.getCode(codeLenCodeTab);
+
+        if (code === 16) {
+          bitsLength = 2;
+          bitsOffset = 3;
+          what = len;
+        } else if (code === 17) {
+          bitsLength = 3;
+          bitsOffset = 3;
+          what = len = 0;
+        } else if (code === 18) {
+          bitsLength = 7;
+          bitsOffset = 11;
+          what = len = 0;
+        } else {
+          codeLengths[i++] = len = code;
+          continue;
+        }
+
+        var repeatLength = this.getBits(bitsLength) + bitsOffset;
+
+        while (repeatLength-- > 0) {
+          codeLengths[i++] = what;
+        }
+      }
+
+      litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
+      distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
+    } else {
+      throw new _util.FormatError("Unknown block type in flate stream");
+    }
+
+    buffer = this.buffer;
+    var limit = buffer ? buffer.length : 0;
+    var pos = this.bufferLength;
+
+    while (true) {
+      var code1 = this.getCode(litCodeTable);
+
+      if (code1 < 256) {
+        if (pos + 1 >= limit) {
+          buffer = this.ensureBuffer(pos + 1);
+          limit = buffer.length;
+        }
+
+        buffer[pos++] = code1;
+        continue;
+      }
+
+      if (code1 === 256) {
+        this.bufferLength = pos;
+        return;
+      }
+
+      code1 -= 257;
+      code1 = lengthDecode[code1];
+      var code2 = code1 >> 16;
+
+      if (code2 > 0) {
+        code2 = this.getBits(code2);
+      }
+
+      len = (code1 & 0xffff) + code2;
+      code1 = this.getCode(distCodeTable);
+      code1 = distDecode[code1];
+      code2 = code1 >> 16;
+
+      if (code2 > 0) {
+        code2 = this.getBits(code2);
+      }
+
+      var dist = (code1 & 0xffff) + code2;
+
+      if (pos + len >= limit) {
+        buffer = this.ensureBuffer(pos + len);
+        limit = buffer.length;
+      }
+
+      for (var k = 0; k < len; ++k, ++pos) {
+        buffer[pos] = buffer[pos - dist];
+      }
+    }
+  };
+
+  return FlateStream;
+}();
+
+exports.FlateStream = FlateStream;
+
+var PredictorStream = function PredictorStreamClosure() {
+  function PredictorStream(str, maybeLength, params) {
+    if (!(0, _primitives.isDict)(params)) {
+      return str;
+    }
+
+    var predictor = this.predictor = params.get("Predictor") || 1;
+
+    if (predictor <= 1) {
+      return str;
+    }
+
+    if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
+      throw new _util.FormatError(`Unsupported predictor: ${predictor}`);
+    }
+
+    if (predictor === 2) {
+      this.readBlock = this.readBlockTiff;
+    } else {
+      this.readBlock = this.readBlockPng;
+    }
+
+    this.str = str;
+    this.dict = str.dict;
+    var colors = this.colors = params.get("Colors") || 1;
+    var bits = this.bits = params.get("BitsPerComponent") || 8;
+    var columns = this.columns = params.get("Columns") || 1;
+    this.pixBytes = colors * bits + 7 >> 3;
+    this.rowBytes = columns * colors * bits + 7 >> 3;
+    DecodeStream.call(this, maybeLength);
+    return this;
+  }
+
+  PredictorStream.prototype = Object.create(DecodeStream.prototype);
+
+  PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
+    var rowBytes = this.rowBytes;
+    var bufferLength = this.bufferLength;
+    var buffer = this.ensureBuffer(bufferLength + rowBytes);
+    var bits = this.bits;
+    var colors = this.colors;
+    var rawBytes = this.str.getBytes(rowBytes);
+    this.eof = !rawBytes.length;
+
+    if (this.eof) {
+      return;
+    }
+
+    var inbuf = 0,
+        outbuf = 0;
+    var inbits = 0,
+        outbits = 0;
+    var pos = bufferLength;
+    var i;
+
+    if (bits === 1 && colors === 1) {
+      for (i = 0; i < rowBytes; ++i) {
+        var c = rawBytes[i] ^ inbuf;
+        c ^= c >> 1;
+        c ^= c >> 2;
+        c ^= c >> 4;
+        inbuf = (c & 1) << 7;
+        buffer[pos++] = c;
+      }
+    } else if (bits === 8) {
+      for (i = 0; i < colors; ++i) {
+        buffer[pos++] = rawBytes[i];
+      }
+
+      for (; i < rowBytes; ++i) {
+        buffer[pos] = buffer[pos - colors] + rawBytes[i];
+        pos++;
+      }
+    } else if (bits === 16) {
+      var bytesPerPixel = colors * 2;
+
+      for (i = 0; i < bytesPerPixel; ++i) {
+        buffer[pos++] = rawBytes[i];
+      }
+
+      for (; i < rowBytes; i += 2) {
+        var sum = ((rawBytes[i] & 0xff) << 8) + (rawBytes[i + 1] & 0xff) + ((buffer[pos - bytesPerPixel] & 0xff) << 8) + (buffer[pos - bytesPerPixel + 1] & 0xff);
+        buffer[pos++] = sum >> 8 & 0xff;
+        buffer[pos++] = sum & 0xff;
+      }
+    } else {
+      var compArray = new Uint8Array(colors + 1);
+      var bitMask = (1 << bits) - 1;
+      var j = 0,
+          k = bufferLength;
+      var columns = this.columns;
+
+      for (i = 0; i < columns; ++i) {
+        for (var kk = 0; kk < colors; ++kk) {
+          if (inbits < bits) {
+            inbuf = inbuf << 8 | rawBytes[j++] & 0xff;
+            inbits += 8;
+          }
+
+          compArray[kk] = compArray[kk] + (inbuf >> inbits - bits) & bitMask;
+          inbits -= bits;
+          outbuf = outbuf << bits | compArray[kk];
+          outbits += bits;
+
+          if (outbits >= 8) {
+            buffer[k++] = outbuf >> outbits - 8 & 0xff;
+            outbits -= 8;
+          }
+        }
+      }
+
+      if (outbits > 0) {
+        buffer[k++] = (outbuf << 8 - outbits) + (inbuf & (1 << 8 - outbits) - 1);
+      }
+    }
+
+    this.bufferLength += rowBytes;
+  };
+
+  PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
+    var rowBytes = this.rowBytes;
+    var pixBytes = this.pixBytes;
+    var predictor = this.str.getByte();
+    var rawBytes = this.str.getBytes(rowBytes);
+    this.eof = !rawBytes.length;
+
+    if (this.eof) {
+      return;
+    }
+
+    var bufferLength = this.bufferLength;
+    var buffer = this.ensureBuffer(bufferLength + rowBytes);
+    var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
+
+    if (prevRow.length === 0) {
+      prevRow = new Uint8Array(rowBytes);
+    }
+
+    var i,
+        j = bufferLength,
+        up,
+        c;
+
+    switch (predictor) {
+      case 0:
+        for (i = 0; i < rowBytes; ++i) {
+          buffer[j++] = rawBytes[i];
+        }
+
+        break;
+
+      case 1:
+        for (i = 0; i < pixBytes; ++i) {
+          buffer[j++] = rawBytes[i];
+        }
+
+        for (; i < rowBytes; ++i) {
+          buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xff;
+          j++;
+        }
+
+        break;
+
+      case 2:
+        for (i = 0; i < rowBytes; ++i) {
+          buffer[j++] = prevRow[i] + rawBytes[i] & 0xff;
+        }
+
+        break;
+
+      case 3:
+        for (i = 0; i < pixBytes; ++i) {
+          buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
+        }
+
+        for (; i < rowBytes; ++i) {
+          buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xff;
+          j++;
+        }
+
+        break;
+
+      case 4:
+        for (i = 0; i < pixBytes; ++i) {
+          up = prevRow[i];
+          c = rawBytes[i];
+          buffer[j++] = up + c;
+        }
+
+        for (; i < rowBytes; ++i) {
+          up = prevRow[i];
+          var upLeft = prevRow[i - pixBytes];
+          var left = buffer[j - pixBytes];
+          var p = left + up - upLeft;
+          var pa = p - left;
+
+          if (pa < 0) {
+            pa = -pa;
+          }
+
+          var pb = p - up;
+
+          if (pb < 0) {
+            pb = -pb;
+          }
+
+          var pc = p - upLeft;
+
+          if (pc < 0) {
+            pc = -pc;
+          }
+
+          c = rawBytes[i];
+
+          if (pa <= pb && pa <= pc) {
+            buffer[j++] = left + c;
+          } else if (pb <= pc) {
+            buffer[j++] = up + c;
+          } else {
+            buffer[j++] = upLeft + c;
+          }
+        }
+
+        break;
+
+      default:
+        throw new _util.FormatError(`Unsupported predictor: ${predictor}`);
+    }
+
+    this.bufferLength += rowBytes;
+  };
+
+  return PredictorStream;
+}();
+
+exports.PredictorStream = PredictorStream;
+
+var DecryptStream = function DecryptStreamClosure() {
+  function DecryptStream(str, maybeLength, decrypt) {
+    this.str = str;
+    this.dict = str.dict;
+    this.decrypt = decrypt;
+    this.nextChunk = null;
+    this.initialized = false;
+    DecodeStream.call(this, maybeLength);
+  }
+
+  var chunkSize = 512;
+  DecryptStream.prototype = Object.create(DecodeStream.prototype);
+
+  DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
+    var chunk;
+
+    if (this.initialized) {
+      chunk = this.nextChunk;
+    } else {
+      chunk = this.str.getBytes(chunkSize);
+      this.initialized = true;
+    }
+
+    if (!chunk || chunk.length === 0) {
+      this.eof = true;
+      return;
+    }
+
+    this.nextChunk = this.str.getBytes(chunkSize);
+    var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
+    var decrypt = this.decrypt;
+    chunk = decrypt(chunk, !hasMoreData);
+    var bufferLength = this.bufferLength;
+    var i,
+        n = chunk.length;
+    var buffer = this.ensureBuffer(bufferLength + n);
+
+    for (i = 0; i < n; i++) {
+      buffer[bufferLength++] = chunk[i];
+    }
+
+    this.bufferLength = bufferLength;
+  };
+
+  return DecryptStream;
+}();
+
+exports.DecryptStream = DecryptStream;
+
+var Ascii85Stream = function Ascii85StreamClosure() {
+  function Ascii85Stream(str, maybeLength) {
+    this.str = str;
+    this.dict = str.dict;
+    this.input = new Uint8Array(5);
+
+    if (maybeLength) {
+      maybeLength = 0.8 * maybeLength;
+    }
+
+    DecodeStream.call(this, maybeLength);
+  }
+
+  Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
+
+  Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
+    var TILDA_CHAR = 0x7e;
+    var Z_LOWER_CHAR = 0x7a;
+    var EOF = -1;
+    var str = this.str;
+    var c = str.getByte();
+
+    while ((0, _core_utils.isWhiteSpace)(c)) {
+      c = str.getByte();
+    }
+
+    if (c === EOF || c === TILDA_CHAR) {
+      this.eof = true;
+      return;
+    }
+
+    var bufferLength = this.bufferLength,
+        buffer;
+    var i;
+
+    if (c === Z_LOWER_CHAR) {
+      buffer = this.ensureBuffer(bufferLength + 4);
+
+      for (i = 0; i < 4; ++i) {
+        buffer[bufferLength + i] = 0;
+      }
+
+      this.bufferLength += 4;
+    } else {
+      var input = this.input;
+      input[0] = c;
+
+      for (i = 1; i < 5; ++i) {
+        c = str.getByte();
+
+        while ((0, _core_utils.isWhiteSpace)(c)) {
+          c = str.getByte();
+        }
+
+        input[i] = c;
+
+        if (c === EOF || c === TILDA_CHAR) {
+          break;
+        }
+      }
+
+      buffer = this.ensureBuffer(bufferLength + i - 1);
+      this.bufferLength += i - 1;
+
+      if (i < 5) {
+        for (; i < 5; ++i) {
+          input[i] = 0x21 + 84;
+        }
+
+        this.eof = true;
+      }
+
+      var t = 0;
+
+      for (i = 0; i < 5; ++i) {
+        t = t * 85 + (input[i] - 0x21);
+      }
+
+      for (i = 3; i >= 0; --i) {
+        buffer[bufferLength + i] = t & 0xff;
+        t >>= 8;
+      }
+    }
+  };
+
+  return Ascii85Stream;
+}();
+
+exports.Ascii85Stream = Ascii85Stream;
+
+var AsciiHexStream = function AsciiHexStreamClosure() {
+  function AsciiHexStream(str, maybeLength) {
+    this.str = str;
+    this.dict = str.dict;
+    this.firstDigit = -1;
+
+    if (maybeLength) {
+      maybeLength = 0.5 * maybeLength;
+    }
+
+    DecodeStream.call(this, maybeLength);
+  }
+
+  AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
+
+  AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
+    var UPSTREAM_BLOCK_SIZE = 8000;
+    var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
+
+    if (!bytes.length) {
+      this.eof = true;
+      return;
+    }
+
+    var maxDecodeLength = bytes.length + 1 >> 1;
+    var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
+    var bufferLength = this.bufferLength;
+    var firstDigit = this.firstDigit;
+
+    for (var i = 0, ii = bytes.length; i < ii; i++) {
+      var ch = bytes[i],
+          digit;
+
+      if (ch >= 0x30 && ch <= 0x39) {
+        digit = ch & 0x0f;
+      } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+        digit = (ch & 0x0f) + 9;
+      } else if (ch === 0x3e) {
+        this.eof = true;
+        break;
+      } else {
+        continue;
+      }
+
+      if (firstDigit < 0) {
+        firstDigit = digit;
+      } else {
+        buffer[bufferLength++] = firstDigit << 4 | digit;
+        firstDigit = -1;
+      }
+    }
+
+    if (firstDigit >= 0 && this.eof) {
+      buffer[bufferLength++] = firstDigit << 4;
+      firstDigit = -1;
+    }
+
+    this.firstDigit = firstDigit;
+    this.bufferLength = bufferLength;
+  };
+
+  return AsciiHexStream;
+}();
+
+exports.AsciiHexStream = AsciiHexStream;
+
+var RunLengthStream = function RunLengthStreamClosure() {
+  function RunLengthStream(str, maybeLength) {
+    this.str = str;
+    this.dict = str.dict;
+    DecodeStream.call(this, maybeLength);
+  }
+
+  RunLengthStream.prototype = Object.create(DecodeStream.prototype);
+
+  RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
+    var repeatHeader = this.str.getBytes(2);
+
+    if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
+      this.eof = true;
+      return;
+    }
+
+    var buffer;
+    var bufferLength = this.bufferLength;
+    var n = repeatHeader[0];
+
+    if (n < 128) {
+      buffer = this.ensureBuffer(bufferLength + n + 1);
+      buffer[bufferLength++] = repeatHeader[1];
+
+      if (n > 0) {
+        var source = this.str.getBytes(n);
+        buffer.set(source, bufferLength);
+        bufferLength += n;
+      }
+    } else {
+      n = 257 - n;
+      var b = repeatHeader[1];
+      buffer = this.ensureBuffer(bufferLength + n + 1);
+
+      for (var i = 0; i < n; i++) {
+        buffer[bufferLength++] = b;
+      }
+    }
+
+    this.bufferLength = bufferLength;
+  };
+
+  return RunLengthStream;
+}();
+
+exports.RunLengthStream = RunLengthStream;
+
+var LZWStream = function LZWStreamClosure() {
+  function LZWStream(str, maybeLength, earlyChange) {
+    this.str = str;
+    this.dict = str.dict;
+    this.cachedData = 0;
+    this.bitsCached = 0;
+    var maxLzwDictionarySize = 4096;
+    var lzwState = {
+      earlyChange,
+      codeLength: 9,
+      nextCode: 258,
+      dictionaryValues: new Uint8Array(maxLzwDictionarySize),
+      dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
+      dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
+      currentSequence: new Uint8Array(maxLzwDictionarySize),
+      currentSequenceLength: 0
+    };
+
+    for (var i = 0; i < 256; ++i) {
+      lzwState.dictionaryValues[i] = i;
+      lzwState.dictionaryLengths[i] = 1;
+    }
+
+    this.lzwState = lzwState;
+    DecodeStream.call(this, maybeLength);
+  }
+
+  LZWStream.prototype = Object.create(DecodeStream.prototype);
+
+  LZWStream.prototype.readBits = function LZWStream_readBits(n) {
+    var bitsCached = this.bitsCached;
+    var cachedData = this.cachedData;
+
+    while (bitsCached < n) {
+      var c = this.str.getByte();
+
+      if (c === -1) {
+        this.eof = true;
+        return null;
+      }
+
+      cachedData = cachedData << 8 | c;
+      bitsCached += 8;
+    }
+
+    this.bitsCached = bitsCached -= n;
+    this.cachedData = cachedData;
+    this.lastCode = null;
+    return cachedData >>> bitsCached & (1 << n) - 1;
+  };
+
+  LZWStream.prototype.readBlock = function LZWStream_readBlock() {
+    var blockSize = 512;
+    var estimatedDecodedSize = blockSize * 2,
+        decodedSizeDelta = blockSize;
+    var i, j, q;
+    var lzwState = this.lzwState;
+
+    if (!lzwState) {
+      return;
+    }
+
+    var earlyChange = lzwState.earlyChange;
+    var nextCode = lzwState.nextCode;
+    var dictionaryValues = lzwState.dictionaryValues;
+    var dictionaryLengths = lzwState.dictionaryLengths;
+    var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
+    var codeLength = lzwState.codeLength;
+    var prevCode = lzwState.prevCode;
+    var currentSequence = lzwState.currentSequence;
+    var currentSequenceLength = lzwState.currentSequenceLength;
+    var decodedLength = 0;
+    var currentBufferLength = this.bufferLength;
+    var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
+
+    for (i = 0; i < blockSize; i++) {
+      var code = this.readBits(codeLength);
+      var hasPrev = currentSequenceLength > 0;
+
+      if (code < 256) {
+        currentSequence[0] = code;
+        currentSequenceLength = 1;
+      } else if (code >= 258) {
+        if (code < nextCode) {
+          currentSequenceLength = dictionaryLengths[code];
+
+          for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
+            currentSequence[j] = dictionaryValues[q];
+            q = dictionaryPrevCodes[q];
+          }
+        } else {
+          currentSequence[currentSequenceLength++] = currentSequence[0];
+        }
+      } else if (code === 256) {
+        codeLength = 9;
+        nextCode = 258;
+        currentSequenceLength = 0;
+        continue;
+      } else {
+        this.eof = true;
+        delete this.lzwState;
+        break;
+      }
+
+      if (hasPrev) {
+        dictionaryPrevCodes[nextCode] = prevCode;
+        dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;
+        dictionaryValues[nextCode] = currentSequence[0];
+        nextCode++;
+        codeLength = nextCode + earlyChange & nextCode + earlyChange - 1 ? codeLength : Math.min(Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1, 12) | 0;
+      }
+
+      prevCode = code;
+      decodedLength += currentSequenceLength;
+
+      if (estimatedDecodedSize < decodedLength) {
+        do {
+          estimatedDecodedSize += decodedSizeDelta;
+        } while (estimatedDecodedSize < decodedLength);
+
+        buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
+      }
+
+      for (j = 0; j < currentSequenceLength; j++) {
+        buffer[currentBufferLength++] = currentSequence[j];
+      }
+    }
+
+    lzwState.nextCode = nextCode;
+    lzwState.codeLength = codeLength;
+    lzwState.prevCode = prevCode;
+    lzwState.currentSequenceLength = currentSequenceLength;
+    this.bufferLength = currentBufferLength;
+  };
+
+  return LZWStream;
+}();
+
+exports.LZWStream = LZWStream;
+
+var NullStream = function NullStreamClosure() {
+  function NullStream() {
+    Stream.call(this, new Uint8Array(0));
+  }
+
+  NullStream.prototype = Stream.prototype;
+  return NullStream;
+}();
+
+exports.NullStream = NullStream;
+
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.CCITTFaxStream = void 0;
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _ccitt = __w_pdfjs_require__(14);
+
+var _stream = __w_pdfjs_require__(12);
+
+var CCITTFaxStream = function CCITTFaxStreamClosure() {
+  function CCITTFaxStream(str, maybeLength, params) {
+    this.str = str;
+    this.dict = str.dict;
+
+    if (!(0, _primitives.isDict)(params)) {
+      params = _primitives.Dict.empty;
+    }
+
+    const source = {
+      next() {
+        return str.getByte();
+      }
+
+    };
+    this.ccittFaxDecoder = new _ccitt.CCITTFaxDecoder(source, {
+      K: params.get("K"),
+      EndOfLine: params.get("EndOfLine"),
+      EncodedByteAlign: params.get("EncodedByteAlign"),
+      Columns: params.get("Columns"),
+      Rows: params.get("Rows"),
+      EndOfBlock: params.get("EndOfBlock"),
+      BlackIs1: params.get("BlackIs1")
+    });
+
+    _stream.DecodeStream.call(this, maybeLength);
+  }
+
+  CCITTFaxStream.prototype = Object.create(_stream.DecodeStream.prototype);
+
+  CCITTFaxStream.prototype.readBlock = function () {
+    while (!this.eof) {
+      const c = this.ccittFaxDecoder.readNextChar();
+
+      if (c === -1) {
+        this.eof = true;
+        return;
+      }
+
+      this.ensureBuffer(this.bufferLength + 1);
+      this.buffer[this.bufferLength++] = c;
+    }
+  };
+
+  return CCITTFaxStream;
+}();
+
+exports.CCITTFaxStream = CCITTFaxStream;
+
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.CCITTFaxDecoder = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const CCITTFaxDecoder = function CCITTFaxDecoder() {
+  const ccittEOL = -2;
+  const ccittEOF = -1;
+  const twoDimPass = 0;
+  const twoDimHoriz = 1;
+  const twoDimVert0 = 2;
+  const twoDimVertR1 = 3;
+  const twoDimVertL1 = 4;
+  const twoDimVertR2 = 5;
+  const twoDimVertL2 = 6;
+  const twoDimVertR3 = 7;
+  const twoDimVertL3 = 8;
+  const twoDimTable = [[-1, -1], [-1, -1], [7, twoDimVertL3], [7, twoDimVertR3], [6, twoDimVertL2], [6, twoDimVertL2], [6, twoDimVertR2], [6, twoDimVertR2], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [4, twoDimPass], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimHoriz], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertL1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [3, twoDimVertR1], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0], [1, twoDimVert0]];
+  const whiteTable1 = [[-1, -1], [12, ccittEOL], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [11, 1792], [11, 1792], [12, 1984], [12, 2048], [12, 2112], [12, 2176], [12, 2240], [12, 2304], [11, 1856], [11, 1856], [11, 1920], [11, 1920], [12, 2368], [12, 2432], [12, 2496], [12, 2560]];
+  const whiteTable2 = [[-1, -1], [-1, -1], [-1, -1], [-1, -1], [8, 29], [8, 29], [8, 30], [8, 30], [8, 45], [8, 45], [8, 46], [8, 46], [7, 22], [7, 22], [7, 22], [7, 22], [7, 23], [7, 23], [7, 23], [7, 23], [8, 47], [8, 47], [8, 48], [8, 48], [6, 13], [6, 13], [6, 13], [6, 13], [6, 13], [6, 13], [6, 13], [6, 13], [7, 20], [7, 20], [7, 20], [7, 20], [8, 33], [8, 33], [8, 34], [8, 34], [8, 35], [8, 35], [8, 36], [8, 36], [8, 37], [8, 37], [8, 38], [8, 38], [7, 19], [7, 19], [7, 19], [7, 19], [8, 31], [8, 31], [8, 32], [8, 32], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 12], [6, 12], [6, 12], [6, 12], [6, 12], [6, 12], [6, 12], [6, 12], [8, 53], [8, 53], [8, 54], [8, 54], [7, 26], [7, 26], [7, 26], [7, 26], [8, 39], [8, 39], [8, 40], [8, 40], [8, 41], [8, 41], [8, 42], [8, 42], [8, 43], [8, 43], [8, 44], [8, 44], [7, 21], [7, 21], [7, 21], [7, 21], [7, 28], [7, 28], [7, 28], [7, 28], [8, 61], [8, 61], [8, 62], [8, 62], [8, 63], [8, 63], [8, 0], [8, 0], [8, 320], [8, 320], [8, 384], [8, 384], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 10], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [5, 11], [7, 27], [7, 27], [7, 27], [7, 27], [8, 59], [8, 59], [8, 60], [8, 60], [9, 1472], [9, 1536], [9, 1600], [9, 1728], [7, 18], [7, 18], [7, 18], [7, 18], [7, 24], [7, 24], [7, 24], [7, 24], [8, 49], [8, 49], [8, 50], [8, 50], [8, 51], [8, 51], [8, 52], [8, 52], [7, 25], [7, 25], [7, 25], [7, 25], [8, 55], [8, 55], [8, 56], [8, 56], [8, 57], [8, 57], [8, 58], [8, 58], [6, 192], [6, 192], [6, 192], [6, 192], [6, 192], [6, 192], [6, 192], [6, 192], [6, 1664], [6, 1664], [6, 1664], [6, 1664], [6, 1664], [6, 1664], [6, 1664], [6, 1664], [8, 448], [8, 448], [8, 512], [8, 512], [9, 704], [9, 768], [8, 640], [8, 640], [8, 576], [8, 576], [9, 832], [9, 896], [9, 960], [9, 1024], [9, 1088], [9, 1152], [9, 1216], [9, 1280], [9, 1344], [9, 1408], [7, 256], [7, 256], [7, 256], [7, 256], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 2], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 128], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 8], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [5, 9], [6, 16], [6, 16], [6, 16], [6, 16], [6, 16], [6, 16], [6, 16], [6, 16], [6, 17], [6, 17], [6, 17], [6, 17], [6, 17], [6, 17], [6, 17], [6, 17], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 4], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [4, 5], [6, 14], [6, 14], [6, 14], [6, 14], [6, 14], [6, 14], [6, 14], [6, 14], [6, 15], [6, 15], [6, 15], [6, 15], [6, 15], [6, 15], [6, 15], [6, 15], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [5, 64], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 6], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7], [4, 7]];
+  const blackTable1 = [[-1, -1], [-1, -1], [12, ccittEOL], [12, ccittEOL], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [-1, -1], [11, 1792], [11, 1792], [11, 1792], [11, 1792], [12, 1984], [12, 1984], [12, 2048], [12, 2048], [12, 2112], [12, 2112], [12, 2176], [12, 2176], [12, 2240], [12, 2240], [12, 2304], [12, 2304], [11, 1856], [11, 1856], [11, 1856], [11, 1856], [11, 1920], [11, 1920], [11, 1920], [11, 1920], [12, 2368], [12, 2368], [12, 2432], [12, 2432], [12, 2496], [12, 2496], [12, 2560], [12, 2560], [10, 18], [10, 18], [10, 18], [10, 18], [10, 18], [10, 18], [10, 18], [10, 18], [12, 52], [12, 52], [13, 640], [13, 704], [13, 768], [13, 832], [12, 55], [12, 55], [12, 56], [12, 56], [13, 1280], [13, 1344], [13, 1408], [13, 1472], [12, 59], [12, 59], [12, 60], [12, 60], [13, 1536], [13, 1600], [11, 24], [11, 24], [11, 24], [11, 24], [11, 25], [11, 25], [11, 25], [11, 25], [13, 1664], [13, 1728], [12, 320], [12, 320], [12, 384], [12, 384], [12, 448], [12, 448], [13, 512], [13, 576], [12, 53], [12, 53], [12, 54], [12, 54], [13, 896], [13, 960], [13, 1024], [13, 1088], [13, 1152], [13, 1216], [10, 64], [10, 64], [10, 64], [10, 64], [10, 64], [10, 64], [10, 64], [10, 64]];
+  const blackTable2 = [[8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [8, 13], [11, 23], [11, 23], [12, 50], [12, 51], [12, 44], [12, 45], [12, 46], [12, 47], [12, 57], [12, 58], [12, 61], [12, 256], [10, 16], [10, 16], [10, 16], [10, 16], [10, 17], [10, 17], [10, 17], [10, 17], [12, 48], [12, 49], [12, 62], [12, 63], [12, 30], [12, 31], [12, 32], [12, 33], [12, 40], [12, 41], [11, 22], [11, 22], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [8, 14], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 10], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [9, 15], [9, 15], [9, 15], [9, 15], [9, 15], [9, 15], [9, 15], [9, 15], [12, 128], [12, 192], [12, 26], [12, 27], [12, 28], [12, 29], [11, 19], [11, 19], [11, 20], [11, 20], [12, 34], [12, 35], [12, 36], [12, 37], [12, 38], [12, 39], [11, 21], [11, 21], [12, 42], [12, 43], [10, 0], [10, 0], [10, 0], [10, 0], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12], [7, 12]];
+  const blackTable3 = [[-1, -1], [-1, -1], [-1, -1], [-1, -1], [6, 9], [6, 8], [5, 7], [5, 7], [4, 6], [4, 6], [4, 6], [4, 6], [4, 5], [4, 5], [4, 5], [4, 5], [3, 1], [3, 1], [3, 1], [3, 1], [3, 1], [3, 1], [3, 1], [3, 1], [3, 4], [3, 4], [3, 4], [3, 4], [3, 4], [3, 4], [3, 4], [3, 4], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2]];
+
+  function CCITTFaxDecoder(source, options = {}) {
+    if (!source || typeof source.next !== "function") {
+      throw new Error('CCITTFaxDecoder - invalid "source" parameter.');
+    }
+
+    this.source = source;
+    this.eof = false;
+    this.encoding = options.K || 0;
+    this.eoline = options.EndOfLine || false;
+    this.byteAlign = options.EncodedByteAlign || false;
+    this.columns = options.Columns || 1728;
+    this.rows = options.Rows || 0;
+    let eoblock = options.EndOfBlock;
+
+    if (eoblock === null || eoblock === undefined) {
+      eoblock = true;
+    }
+
+    this.eoblock = eoblock;
+    this.black = options.BlackIs1 || false;
+    this.codingLine = new Uint32Array(this.columns + 1);
+    this.refLine = new Uint32Array(this.columns + 2);
+    this.codingLine[0] = this.columns;
+    this.codingPos = 0;
+    this.row = 0;
+    this.nextLine2D = this.encoding < 0;
+    this.inputBits = 0;
+    this.inputBuf = 0;
+    this.outputBits = 0;
+    this.rowsDone = false;
+    let code1;
+
+    while ((code1 = this._lookBits(12)) === 0) {
+      this._eatBits(1);
+    }
+
+    if (code1 === 1) {
+      this._eatBits(12);
+    }
+
+    if (this.encoding > 0) {
+      this.nextLine2D = !this._lookBits(1);
+
+      this._eatBits(1);
+    }
+  }
+
+  CCITTFaxDecoder.prototype = {
+    readNextChar() {
+      if (this.eof) {
+        return -1;
+      }
+
+      const refLine = this.refLine;
+      const codingLine = this.codingLine;
+      const columns = this.columns;
+      let refPos, blackPixels, bits, i;
+
+      if (this.outputBits === 0) {
+        if (this.rowsDone) {
+          this.eof = true;
+        }
+
+        if (this.eof) {
+          return -1;
+        }
+
+        this.err = false;
+        let code1, code2, code3;
+
+        if (this.nextLine2D) {
+          for (i = 0; codingLine[i] < columns; ++i) {
+            refLine[i] = codingLine[i];
+          }
+
+          refLine[i++] = columns;
+          refLine[i] = columns;
+          codingLine[0] = 0;
+          this.codingPos = 0;
+          refPos = 0;
+          blackPixels = 0;
+
+          while (codingLine[this.codingPos] < columns) {
+            code1 = this._getTwoDimCode();
+
+            switch (code1) {
+              case twoDimPass:
+                this._addPixels(refLine[refPos + 1], blackPixels);
+
+                if (refLine[refPos + 1] < columns) {
+                  refPos += 2;
+                }
+
+                break;
+
+              case twoDimHoriz:
+                code1 = code2 = 0;
+
+                if (blackPixels) {
+                  do {
+                    code1 += code3 = this._getBlackCode();
+                  } while (code3 >= 64);
+
+                  do {
+                    code2 += code3 = this._getWhiteCode();
+                  } while (code3 >= 64);
+                } else {
+                  do {
+                    code1 += code3 = this._getWhiteCode();
+                  } while (code3 >= 64);
+
+                  do {
+                    code2 += code3 = this._getBlackCode();
+                  } while (code3 >= 64);
+                }
+
+                this._addPixels(codingLine[this.codingPos] + code1, blackPixels);
+
+                if (codingLine[this.codingPos] < columns) {
+                  this._addPixels(codingLine[this.codingPos] + code2, blackPixels ^ 1);
+                }
+
+                while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                  refPos += 2;
+                }
+
+                break;
+
+              case twoDimVertR3:
+                this._addPixels(refLine[refPos] + 3, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  ++refPos;
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVertR2:
+                this._addPixels(refLine[refPos] + 2, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  ++refPos;
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVertR1:
+                this._addPixels(refLine[refPos] + 1, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  ++refPos;
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVert0:
+                this._addPixels(refLine[refPos], blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  ++refPos;
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVertL3:
+                this._addPixelsNeg(refLine[refPos] - 3, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  if (refPos > 0) {
+                    --refPos;
+                  } else {
+                    ++refPos;
+                  }
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVertL2:
+                this._addPixelsNeg(refLine[refPos] - 2, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  if (refPos > 0) {
+                    --refPos;
+                  } else {
+                    ++refPos;
+                  }
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case twoDimVertL1:
+                this._addPixelsNeg(refLine[refPos] - 1, blackPixels);
+
+                blackPixels ^= 1;
+
+                if (codingLine[this.codingPos] < columns) {
+                  if (refPos > 0) {
+                    --refPos;
+                  } else {
+                    ++refPos;
+                  }
+
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                }
+
+                break;
+
+              case ccittEOF:
+                this._addPixels(columns, 0);
+
+                this.eof = true;
+                break;
+
+              default:
+                (0, _util.info)("bad 2d code");
+
+                this._addPixels(columns, 0);
+
+                this.err = true;
+            }
+          }
+        } else {
+          codingLine[0] = 0;
+          this.codingPos = 0;
+          blackPixels = 0;
+
+          while (codingLine[this.codingPos] < columns) {
+            code1 = 0;
+
+            if (blackPixels) {
+              do {
+                code1 += code3 = this._getBlackCode();
+              } while (code3 >= 64);
+            } else {
+              do {
+                code1 += code3 = this._getWhiteCode();
+              } while (code3 >= 64);
+            }
+
+            this._addPixels(codingLine[this.codingPos] + code1, blackPixels);
+
+            blackPixels ^= 1;
+          }
+        }
+
+        let gotEOL = false;
+
+        if (this.byteAlign) {
+          this.inputBits &= ~7;
+        }
+
+        if (!this.eoblock && this.row === this.rows - 1) {
+          this.rowsDone = true;
+        } else {
+          code1 = this._lookBits(12);
+
+          if (this.eoline) {
+            while (code1 !== ccittEOF && code1 !== 1) {
+              this._eatBits(1);
+
+              code1 = this._lookBits(12);
+            }
+          } else {
+            while (code1 === 0) {
+              this._eatBits(1);
+
+              code1 = this._lookBits(12);
+            }
+          }
+
+          if (code1 === 1) {
+            this._eatBits(12);
+
+            gotEOL = true;
+          } else if (code1 === ccittEOF) {
+            this.eof = true;
+          }
+        }
+
+        if (!this.eof && this.encoding > 0 && !this.rowsDone) {
+          this.nextLine2D = !this._lookBits(1);
+
+          this._eatBits(1);
+        }
+
+        if (this.eoblock && gotEOL && this.byteAlign) {
+          code1 = this._lookBits(12);
+
+          if (code1 === 1) {
+            this._eatBits(12);
+
+            if (this.encoding > 0) {
+              this._lookBits(1);
+
+              this._eatBits(1);
+            }
+
+            if (this.encoding >= 0) {
+              for (i = 0; i < 4; ++i) {
+                code1 = this._lookBits(12);
+
+                if (code1 !== 1) {
+                  (0, _util.info)("bad rtc code: " + code1);
+                }
+
+                this._eatBits(12);
+
+                if (this.encoding > 0) {
+                  this._lookBits(1);
+
+                  this._eatBits(1);
+                }
+              }
+            }
+
+            this.eof = true;
+          }
+        } else if (this.err && this.eoline) {
+          while (true) {
+            code1 = this._lookBits(13);
+
+            if (code1 === ccittEOF) {
+              this.eof = true;
+              return -1;
+            }
+
+            if (code1 >> 1 === 1) {
+              break;
+            }
+
+            this._eatBits(1);
+          }
+
+          this._eatBits(12);
+
+          if (this.encoding > 0) {
+            this._eatBits(1);
+
+            this.nextLine2D = !(code1 & 1);
+          }
+        }
+
+        if (codingLine[0] > 0) {
+          this.outputBits = codingLine[this.codingPos = 0];
+        } else {
+          this.outputBits = codingLine[this.codingPos = 1];
+        }
+
+        this.row++;
+      }
+
+      let c;
+
+      if (this.outputBits >= 8) {
+        c = this.codingPos & 1 ? 0 : 0xff;
+        this.outputBits -= 8;
+
+        if (this.outputBits === 0 && codingLine[this.codingPos] < columns) {
+          this.codingPos++;
+          this.outputBits = codingLine[this.codingPos] - codingLine[this.codingPos - 1];
+        }
+      } else {
+        bits = 8;
+        c = 0;
+
+        do {
+          if (this.outputBits > bits) {
+            c <<= bits;
+
+            if (!(this.codingPos & 1)) {
+              c |= 0xff >> 8 - bits;
+            }
+
+            this.outputBits -= bits;
+            bits = 0;
+          } else {
+            c <<= this.outputBits;
+
+            if (!(this.codingPos & 1)) {
+              c |= 0xff >> 8 - this.outputBits;
+            }
+
+            bits -= this.outputBits;
+            this.outputBits = 0;
+
+            if (codingLine[this.codingPos] < columns) {
+              this.codingPos++;
+              this.outputBits = codingLine[this.codingPos] - codingLine[this.codingPos - 1];
+            } else if (bits > 0) {
+              c <<= bits;
+              bits = 0;
+            }
+          }
+        } while (bits);
+      }
+
+      if (this.black) {
+        c ^= 0xff;
+      }
+
+      return c;
+    },
+
+    _addPixels(a1, blackPixels) {
+      const codingLine = this.codingLine;
+      let codingPos = this.codingPos;
+
+      if (a1 > codingLine[codingPos]) {
+        if (a1 > this.columns) {
+          (0, _util.info)("row is wrong length");
+          this.err = true;
+          a1 = this.columns;
+        }
+
+        if (codingPos & 1 ^ blackPixels) {
+          ++codingPos;
+        }
+
+        codingLine[codingPos] = a1;
+      }
+
+      this.codingPos = codingPos;
+    },
+
+    _addPixelsNeg(a1, blackPixels) {
+      const codingLine = this.codingLine;
+      let codingPos = this.codingPos;
+
+      if (a1 > codingLine[codingPos]) {
+        if (a1 > this.columns) {
+          (0, _util.info)("row is wrong length");
+          this.err = true;
+          a1 = this.columns;
+        }
+
+        if (codingPos & 1 ^ blackPixels) {
+          ++codingPos;
+        }
+
+        codingLine[codingPos] = a1;
+      } else if (a1 < codingLine[codingPos]) {
+        if (a1 < 0) {
+          (0, _util.info)("invalid code");
+          this.err = true;
+          a1 = 0;
+        }
+
+        while (codingPos > 0 && a1 < codingLine[codingPos - 1]) {
+          --codingPos;
+        }
+
+        codingLine[codingPos] = a1;
+      }
+
+      this.codingPos = codingPos;
+    },
+
+    _findTableCode(start, end, table, limit) {
+      const limitValue = limit || 0;
+
+      for (let i = start; i <= end; ++i) {
+        let code = this._lookBits(i);
+
+        if (code === ccittEOF) {
+          return [true, 1, false];
+        }
+
+        if (i < end) {
+          code <<= end - i;
+        }
+
+        if (!limitValue || code >= limitValue) {
+          const p = table[code - limitValue];
+
+          if (p[0] === i) {
+            this._eatBits(i);
+
+            return [true, p[1], true];
+          }
+        }
+      }
+
+      return [false, 0, false];
+    },
+
+    _getTwoDimCode() {
+      let code = 0;
+      let p;
+
+      if (this.eoblock) {
+        code = this._lookBits(7);
+        p = twoDimTable[code];
+
+        if (p && p[0] > 0) {
+          this._eatBits(p[0]);
+
+          return p[1];
+        }
+      } else {
+        const result = this._findTableCode(1, 7, twoDimTable);
+
+        if (result[0] && result[2]) {
+          return result[1];
+        }
+      }
+
+      (0, _util.info)("Bad two dim code");
+      return ccittEOF;
+    },
+
+    _getWhiteCode() {
+      let code = 0;
+      let p;
+
+      if (this.eoblock) {
+        code = this._lookBits(12);
+
+        if (code === ccittEOF) {
+          return 1;
+        }
+
+        if (code >> 5 === 0) {
+          p = whiteTable1[code];
+        } else {
+          p = whiteTable2[code >> 3];
+        }
+
+        if (p[0] > 0) {
+          this._eatBits(p[0]);
+
+          return p[1];
+        }
+      } else {
+        let result = this._findTableCode(1, 9, whiteTable2);
+
+        if (result[0]) {
+          return result[1];
+        }
+
+        result = this._findTableCode(11, 12, whiteTable1);
+
+        if (result[0]) {
+          return result[1];
+        }
+      }
+
+      (0, _util.info)("bad white code");
+
+      this._eatBits(1);
+
+      return 1;
+    },
+
+    _getBlackCode() {
+      let code, p;
+
+      if (this.eoblock) {
+        code = this._lookBits(13);
+
+        if (code === ccittEOF) {
+          return 1;
+        }
+
+        if (code >> 7 === 0) {
+          p = blackTable1[code];
+        } else if (code >> 9 === 0 && code >> 7 !== 0) {
+          p = blackTable2[(code >> 1) - 64];
+        } else {
+          p = blackTable3[code >> 7];
+        }
+
+        if (p[0] > 0) {
+          this._eatBits(p[0]);
+
+          return p[1];
+        }
+      } else {
+        let result = this._findTableCode(2, 6, blackTable3);
+
+        if (result[0]) {
+          return result[1];
+        }
+
+        result = this._findTableCode(7, 12, blackTable2, 64);
+
+        if (result[0]) {
+          return result[1];
+        }
+
+        result = this._findTableCode(10, 13, blackTable1);
+
+        if (result[0]) {
+          return result[1];
+        }
+      }
+
+      (0, _util.info)("bad black code");
+
+      this._eatBits(1);
+
+      return 1;
+    },
+
+    _lookBits(n) {
+      let c;
+
+      while (this.inputBits < n) {
+        if ((c = this.source.next()) === -1) {
+          if (this.inputBits === 0) {
+            return ccittEOF;
+          }
+
+          return this.inputBuf << n - this.inputBits & 0xffff >> 16 - n;
+        }
+
+        this.inputBuf = this.inputBuf << 8 | c;
+        this.inputBits += 8;
+      }
+
+      return this.inputBuf >> this.inputBits - n & 0xffff >> 16 - n;
+    },
+
+    _eatBits(n) {
+      if ((this.inputBits -= n) < 0) {
+        this.inputBits = 0;
+      }
+    }
+
+  };
+  return CCITTFaxDecoder;
+}();
+
+exports.CCITTFaxDecoder = CCITTFaxDecoder;
+
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Jbig2Stream = void 0;
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _jbig = __w_pdfjs_require__(16);
+
+var _util = __w_pdfjs_require__(2);
+
+const Jbig2Stream = function Jbig2StreamClosure() {
+  function Jbig2Stream(stream, maybeLength, dict, params) {
+    this.stream = stream;
+    this.maybeLength = maybeLength;
+    this.dict = dict;
+    this.params = params;
+
+    _stream.DecodeStream.call(this, maybeLength);
+  }
+
+  Jbig2Stream.prototype = Object.create(_stream.DecodeStream.prototype);
+  Object.defineProperty(Jbig2Stream.prototype, "bytes", {
+    get() {
+      return (0, _util.shadow)(this, "bytes", this.stream.getBytes(this.maybeLength));
+    },
+
+    configurable: true
+  });
+
+  Jbig2Stream.prototype.ensureBuffer = function (requested) {};
+
+  Jbig2Stream.prototype.readBlock = function () {
+    if (this.eof) {
+      return;
+    }
+
+    const jbig2Image = new _jbig.Jbig2Image();
+    const chunks = [];
+
+    if ((0, _primitives.isDict)(this.params)) {
+      const globalsStream = this.params.get("JBIG2Globals");
+
+      if ((0, _primitives.isStream)(globalsStream)) {
+        const globals = globalsStream.getBytes();
+        chunks.push({
+          data: globals,
+          start: 0,
+          end: globals.length
+        });
+      }
+    }
+
+    chunks.push({
+      data: this.bytes,
+      start: 0,
+      end: this.bytes.length
+    });
+    const data = jbig2Image.parseChunks(chunks);
+    const dataLength = data.length;
+
+    for (let i = 0; i < dataLength; i++) {
+      data[i] ^= 0xff;
+    }
+
+    this.buffer = data;
+    this.bufferLength = dataLength;
+    this.eof = true;
+  };
+
+  return Jbig2Stream;
+}();
+
+exports.Jbig2Stream = Jbig2Stream;
+
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Jbig2Image = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _arithmetic_decoder = __w_pdfjs_require__(17);
+
+var _ccitt = __w_pdfjs_require__(14);
+
+class Jbig2Error extends _util.BaseException {
+  constructor(msg) {
+    super(`JBIG2 error: ${msg}`);
+  }
+
+}
+
+var Jbig2Image = function Jbig2ImageClosure() {
+  function ContextCache() {}
+
+  ContextCache.prototype = {
+    getContexts(id) {
+      if (id in this) {
+        return this[id];
+      }
+
+      return this[id] = new Int8Array(1 << 16);
+    }
+
+  };
+
+  function DecodingContext(data, start, end) {
+    this.data = data;
+    this.start = start;
+    this.end = end;
+  }
+
+  DecodingContext.prototype = {
+    get decoder() {
+      var decoder = new _arithmetic_decoder.ArithmeticDecoder(this.data, this.start, this.end);
+      return (0, _util.shadow)(this, "decoder", decoder);
+    },
+
+    get contextCache() {
+      var cache = new ContextCache();
+      return (0, _util.shadow)(this, "contextCache", cache);
+    }
+
+  };
+
+  function decodeInteger(contextCache, procedure, decoder) {
+    var contexts = contextCache.getContexts(procedure);
+    var prev = 1;
+
+    function readBits(length) {
+      var v = 0;
+
+      for (var i = 0; i < length; i++) {
+        var bit = decoder.readBit(contexts, prev);
+        prev = prev < 256 ? prev << 1 | bit : (prev << 1 | bit) & 511 | 256;
+        v = v << 1 | bit;
+      }
+
+      return v >>> 0;
+    }
+
+    var sign = readBits(1);
+    var value = readBits(1) ? readBits(1) ? readBits(1) ? readBits(1) ? readBits(1) ? readBits(32) + 4436 : readBits(12) + 340 : readBits(8) + 84 : readBits(6) + 20 : readBits(4) + 4 : readBits(2);
+
+    if (sign === 0) {
+      return value;
+    } else if (value > 0) {
+      return -value;
+    }
+
+    return null;
+  }
+
+  function decodeIAID(contextCache, decoder, codeLength) {
+    var contexts = contextCache.getContexts("IAID");
+    var prev = 1;
+
+    for (var i = 0; i < codeLength; i++) {
+      var bit = decoder.readBit(contexts, prev);
+      prev = prev << 1 | bit;
+    }
+
+    if (codeLength < 31) {
+      return prev & (1 << codeLength) - 1;
+    }
+
+    return prev & 0x7fffffff;
+  }
+
+  var SegmentTypes = ["SymbolDictionary", null, null, null, "IntermediateTextRegion", null, "ImmediateTextRegion", "ImmediateLosslessTextRegion", null, null, null, null, null, null, null, null, "PatternDictionary", null, null, null, "IntermediateHalftoneRegion", null, "ImmediateHalftoneRegion", "ImmediateLosslessHalftoneRegion", null, null, null, null, null, null, null, null, null, null, null, null, "IntermediateGenericRegion", null, "ImmediateGenericRegion", "ImmediateLosslessGenericRegion", "IntermediateGenericRefinementRegion", null, "ImmediateGenericRefinementRegion", "ImmediateLosslessGenericRefinementRegion", null, null, null, null, "PageInformation", "EndOfPage", "EndOfStripe", "EndOfFile", "Profiles", "Tables", null, null, null, null, null, null, null, null, "Extension"];
+  var CodingTemplates = [[{
+    x: -1,
+    y: -2
+  }, {
+    x: 0,
+    y: -2
+  }, {
+    x: 1,
+    y: -2
+  }, {
+    x: -2,
+    y: -1
+  }, {
+    x: -1,
+    y: -1
+  }, {
+    x: 0,
+    y: -1
+  }, {
+    x: 1,
+    y: -1
+  }, {
+    x: 2,
+    y: -1
+  }, {
+    x: -4,
+    y: 0
+  }, {
+    x: -3,
+    y: 0
+  }, {
+    x: -2,
+    y: 0
+  }, {
+    x: -1,
+    y: 0
+  }], [{
+    x: -1,
+    y: -2
+  }, {
+    x: 0,
+    y: -2
+  }, {
+    x: 1,
+    y: -2
+  }, {
+    x: 2,
+    y: -2
+  }, {
+    x: -2,
+    y: -1
+  }, {
+    x: -1,
+    y: -1
+  }, {
+    x: 0,
+    y: -1
+  }, {
+    x: 1,
+    y: -1
+  }, {
+    x: 2,
+    y: -1
+  }, {
+    x: -3,
+    y: 0
+  }, {
+    x: -2,
+    y: 0
+  }, {
+    x: -1,
+    y: 0
+  }], [{
+    x: -1,
+    y: -2
+  }, {
+    x: 0,
+    y: -2
+  }, {
+    x: 1,
+    y: -2
+  }, {
+    x: -2,
+    y: -1
+  }, {
+    x: -1,
+    y: -1
+  }, {
+    x: 0,
+    y: -1
+  }, {
+    x: 1,
+    y: -1
+  }, {
+    x: -2,
+    y: 0
+  }, {
+    x: -1,
+    y: 0
+  }], [{
+    x: -3,
+    y: -1
+  }, {
+    x: -2,
+    y: -1
+  }, {
+    x: -1,
+    y: -1
+  }, {
+    x: 0,
+    y: -1
+  }, {
+    x: 1,
+    y: -1
+  }, {
+    x: -4,
+    y: 0
+  }, {
+    x: -3,
+    y: 0
+  }, {
+    x: -2,
+    y: 0
+  }, {
+    x: -1,
+    y: 0
+  }]];
+  var RefinementTemplates = [{
+    coding: [{
+      x: 0,
+      y: -1
+    }, {
+      x: 1,
+      y: -1
+    }, {
+      x: -1,
+      y: 0
+    }],
+    reference: [{
+      x: 0,
+      y: -1
+    }, {
+      x: 1,
+      y: -1
+    }, {
+      x: -1,
+      y: 0
+    }, {
+      x: 0,
+      y: 0
+    }, {
+      x: 1,
+      y: 0
+    }, {
+      x: -1,
+      y: 1
+    }, {
+      x: 0,
+      y: 1
+    }, {
+      x: 1,
+      y: 1
+    }]
+  }, {
+    coding: [{
+      x: -1,
+      y: -1
+    }, {
+      x: 0,
+      y: -1
+    }, {
+      x: 1,
+      y: -1
+    }, {
+      x: -1,
+      y: 0
+    }],
+    reference: [{
+      x: 0,
+      y: -1
+    }, {
+      x: -1,
+      y: 0
+    }, {
+      x: 0,
+      y: 0
+    }, {
+      x: 1,
+      y: 0
+    }, {
+      x: 0,
+      y: 1
+    }, {
+      x: 1,
+      y: 1
+    }]
+  }];
+  var ReusedContexts = [0x9b25, 0x0795, 0x00e5, 0x0195];
+  var RefinementReusedContexts = [0x0020, 0x0008];
+
+  function decodeBitmapTemplate0(width, height, decodingContext) {
+    var decoder = decodingContext.decoder;
+    var contexts = decodingContext.contextCache.getContexts("GB");
+    var contextLabel,
+        i,
+        j,
+        pixel,
+        row,
+        row1,
+        row2,
+        bitmap = [];
+    var OLD_PIXEL_MASK = 0x7bf7;
+
+    for (i = 0; i < height; i++) {
+      row = bitmap[i] = new Uint8Array(width);
+      row1 = i < 1 ? row : bitmap[i - 1];
+      row2 = i < 2 ? row : bitmap[i - 2];
+      contextLabel = row2[0] << 13 | row2[1] << 12 | row2[2] << 11 | row1[0] << 7 | row1[1] << 6 | row1[2] << 5 | row1[3] << 4;
+
+      for (j = 0; j < width; j++) {
+        row[j] = pixel = decoder.readBit(contexts, contextLabel);
+        contextLabel = (contextLabel & OLD_PIXEL_MASK) << 1 | (j + 3 < width ? row2[j + 3] << 11 : 0) | (j + 4 < width ? row1[j + 4] << 4 : 0) | pixel;
+      }
+    }
+
+    return bitmap;
+  }
+
+  function decodeBitmap(mmr, width, height, templateIndex, prediction, skip, at, decodingContext) {
+    if (mmr) {
+      const input = new Reader(decodingContext.data, decodingContext.start, decodingContext.end);
+      return decodeMMRBitmap(input, width, height, false);
+    }
+
+    if (templateIndex === 0 && !skip && !prediction && at.length === 4 && at[0].x === 3 && at[0].y === -1 && at[1].x === -3 && at[1].y === -1 && at[2].x === 2 && at[2].y === -2 && at[3].x === -2 && at[3].y === -2) {
+      return decodeBitmapTemplate0(width, height, decodingContext);
+    }
+
+    var useskip = !!skip;
+    var template = CodingTemplates[templateIndex].concat(at);
+    template.sort(function (a, b) {
+      return a.y - b.y || a.x - b.x;
+    });
+    var templateLength = template.length;
+    var templateX = new Int8Array(templateLength);
+    var templateY = new Int8Array(templateLength);
+    var changingTemplateEntries = [];
+    var reuseMask = 0,
+        minX = 0,
+        maxX = 0,
+        minY = 0;
+    var c, k;
+
+    for (k = 0; k < templateLength; k++) {
+      templateX[k] = template[k].x;
+      templateY[k] = template[k].y;
+      minX = Math.min(minX, template[k].x);
+      maxX = Math.max(maxX, template[k].x);
+      minY = Math.min(minY, template[k].y);
+
+      if (k < templateLength - 1 && template[k].y === template[k + 1].y && template[k].x === template[k + 1].x - 1) {
+        reuseMask |= 1 << templateLength - 1 - k;
+      } else {
+        changingTemplateEntries.push(k);
+      }
+    }
+
+    var changingEntriesLength = changingTemplateEntries.length;
+    var changingTemplateX = new Int8Array(changingEntriesLength);
+    var changingTemplateY = new Int8Array(changingEntriesLength);
+    var changingTemplateBit = new Uint16Array(changingEntriesLength);
+
+    for (c = 0; c < changingEntriesLength; c++) {
+      k = changingTemplateEntries[c];
+      changingTemplateX[c] = template[k].x;
+      changingTemplateY[c] = template[k].y;
+      changingTemplateBit[c] = 1 << templateLength - 1 - k;
+    }
+
+    var sbb_left = -minX;
+    var sbb_top = -minY;
+    var sbb_right = width - maxX;
+    var pseudoPixelContext = ReusedContexts[templateIndex];
+    var row = new Uint8Array(width);
+    var bitmap = [];
+    var decoder = decodingContext.decoder;
+    var contexts = decodingContext.contextCache.getContexts("GB");
+    var ltp = 0,
+        j,
+        i0,
+        j0,
+        contextLabel = 0,
+        bit,
+        shift;
+
+    for (var i = 0; i < height; i++) {
+      if (prediction) {
+        var sltp = decoder.readBit(contexts, pseudoPixelContext);
+        ltp ^= sltp;
+
+        if (ltp) {
+          bitmap.push(row);
+          continue;
+        }
+      }
+
+      row = new Uint8Array(row);
+      bitmap.push(row);
+
+      for (j = 0; j < width; j++) {
+        if (useskip && skip[i][j]) {
+          row[j] = 0;
+          continue;
+        }
+
+        if (j >= sbb_left && j < sbb_right && i >= sbb_top) {
+          contextLabel = contextLabel << 1 & reuseMask;
+
+          for (k = 0; k < changingEntriesLength; k++) {
+            i0 = i + changingTemplateY[k];
+            j0 = j + changingTemplateX[k];
+            bit = bitmap[i0][j0];
+
+            if (bit) {
+              bit = changingTemplateBit[k];
+              contextLabel |= bit;
+            }
+          }
+        } else {
+          contextLabel = 0;
+          shift = templateLength - 1;
+
+          for (k = 0; k < templateLength; k++, shift--) {
+            j0 = j + templateX[k];
+
+            if (j0 >= 0 && j0 < width) {
+              i0 = i + templateY[k];
+
+              if (i0 >= 0) {
+                bit = bitmap[i0][j0];
+
+                if (bit) {
+                  contextLabel |= bit << shift;
+                }
+              }
+            }
+          }
+        }
+
+        var pixel = decoder.readBit(contexts, contextLabel);
+        row[j] = pixel;
+      }
+    }
+
+    return bitmap;
+  }
+
+  function decodeRefinement(width, height, templateIndex, referenceBitmap, offsetX, offsetY, prediction, at, decodingContext) {
+    var codingTemplate = RefinementTemplates[templateIndex].coding;
+
+    if (templateIndex === 0) {
+      codingTemplate = codingTemplate.concat([at[0]]);
+    }
+
+    var codingTemplateLength = codingTemplate.length;
+    var codingTemplateX = new Int32Array(codingTemplateLength);
+    var codingTemplateY = new Int32Array(codingTemplateLength);
+    var k;
+
+    for (k = 0; k < codingTemplateLength; k++) {
+      codingTemplateX[k] = codingTemplate[k].x;
+      codingTemplateY[k] = codingTemplate[k].y;
+    }
+
+    var referenceTemplate = RefinementTemplates[templateIndex].reference;
+
+    if (templateIndex === 0) {
+      referenceTemplate = referenceTemplate.concat([at[1]]);
+    }
+
+    var referenceTemplateLength = referenceTemplate.length;
+    var referenceTemplateX = new Int32Array(referenceTemplateLength);
+    var referenceTemplateY = new Int32Array(referenceTemplateLength);
+
+    for (k = 0; k < referenceTemplateLength; k++) {
+      referenceTemplateX[k] = referenceTemplate[k].x;
+      referenceTemplateY[k] = referenceTemplate[k].y;
+    }
+
+    var referenceWidth = referenceBitmap[0].length;
+    var referenceHeight = referenceBitmap.length;
+    var pseudoPixelContext = RefinementReusedContexts[templateIndex];
+    var bitmap = [];
+    var decoder = decodingContext.decoder;
+    var contexts = decodingContext.contextCache.getContexts("GR");
+    var ltp = 0;
+
+    for (var i = 0; i < height; i++) {
+      if (prediction) {
+        var sltp = decoder.readBit(contexts, pseudoPixelContext);
+        ltp ^= sltp;
+
+        if (ltp) {
+          throw new Jbig2Error("prediction is not supported");
+        }
+      }
+
+      var row = new Uint8Array(width);
+      bitmap.push(row);
+
+      for (var j = 0; j < width; j++) {
+        var i0, j0;
+        var contextLabel = 0;
+
+        for (k = 0; k < codingTemplateLength; k++) {
+          i0 = i + codingTemplateY[k];
+          j0 = j + codingTemplateX[k];
+
+          if (i0 < 0 || j0 < 0 || j0 >= width) {
+            contextLabel <<= 1;
+          } else {
+            contextLabel = contextLabel << 1 | bitmap[i0][j0];
+          }
+        }
+
+        for (k = 0; k < referenceTemplateLength; k++) {
+          i0 = i + referenceTemplateY[k] - offsetY;
+          j0 = j + referenceTemplateX[k] - offsetX;
+
+          if (i0 < 0 || i0 >= referenceHeight || j0 < 0 || j0 >= referenceWidth) {
+            contextLabel <<= 1;
+          } else {
+            contextLabel = contextLabel << 1 | referenceBitmap[i0][j0];
+          }
+        }
+
+        var pixel = decoder.readBit(contexts, contextLabel);
+        row[j] = pixel;
+      }
+    }
+
+    return bitmap;
+  }
+
+  function decodeSymbolDictionary(huffman, refinement, symbols, numberOfNewSymbols, numberOfExportedSymbols, huffmanTables, templateIndex, at, refinementTemplateIndex, refinementAt, decodingContext, huffmanInput) {
+    if (huffman && refinement) {
+      throw new Jbig2Error("symbol refinement with Huffman is not supported");
+    }
+
+    var newSymbols = [];
+    var currentHeight = 0;
+    var symbolCodeLength = (0, _core_utils.log2)(symbols.length + numberOfNewSymbols);
+    var decoder = decodingContext.decoder;
+    var contextCache = decodingContext.contextCache;
+    let tableB1, symbolWidths;
+
+    if (huffman) {
+      tableB1 = getStandardTable(1);
+      symbolWidths = [];
+      symbolCodeLength = Math.max(symbolCodeLength, 1);
+    }
+
+    while (newSymbols.length < numberOfNewSymbols) {
+      var deltaHeight = huffman ? huffmanTables.tableDeltaHeight.decode(huffmanInput) : decodeInteger(contextCache, "IADH", decoder);
+      currentHeight += deltaHeight;
+      let currentWidth = 0,
+          totalWidth = 0;
+      const firstSymbol = huffman ? symbolWidths.length : 0;
+
+      while (true) {
+        var deltaWidth = huffman ? huffmanTables.tableDeltaWidth.decode(huffmanInput) : decodeInteger(contextCache, "IADW", decoder);
+
+        if (deltaWidth === null) {
+          break;
+        }
+
+        currentWidth += deltaWidth;
+        totalWidth += currentWidth;
+        var bitmap;
+
+        if (refinement) {
+          var numberOfInstances = decodeInteger(contextCache, "IAAI", decoder);
+
+          if (numberOfInstances > 1) {
+            bitmap = decodeTextRegion(huffman, refinement, currentWidth, currentHeight, 0, numberOfInstances, 1, symbols.concat(newSymbols), symbolCodeLength, 0, 0, 1, 0, huffmanTables, refinementTemplateIndex, refinementAt, decodingContext, 0, huffmanInput);
+          } else {
+            var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);
+            var rdx = decodeInteger(contextCache, "IARDX", decoder);
+            var rdy = decodeInteger(contextCache, "IARDY", decoder);
+            var symbol = symbolId < symbols.length ? symbols[symbolId] : newSymbols[symbolId - symbols.length];
+            bitmap = decodeRefinement(currentWidth, currentHeight, refinementTemplateIndex, symbol, rdx, rdy, false, refinementAt, decodingContext);
+          }
+
+          newSymbols.push(bitmap);
+        } else if (huffman) {
+          symbolWidths.push(currentWidth);
+        } else {
+          bitmap = decodeBitmap(false, currentWidth, currentHeight, templateIndex, false, null, at, decodingContext);
+          newSymbols.push(bitmap);
+        }
+      }
+
+      if (huffman && !refinement) {
+        const bitmapSize = huffmanTables.tableBitmapSize.decode(huffmanInput);
+        huffmanInput.byteAlign();
+        let collectiveBitmap;
+
+        if (bitmapSize === 0) {
+          collectiveBitmap = readUncompressedBitmap(huffmanInput, totalWidth, currentHeight);
+        } else {
+          const originalEnd = huffmanInput.end;
+          const bitmapEnd = huffmanInput.position + bitmapSize;
+          huffmanInput.end = bitmapEnd;
+          collectiveBitmap = decodeMMRBitmap(huffmanInput, totalWidth, currentHeight, false);
+          huffmanInput.end = originalEnd;
+          huffmanInput.position = bitmapEnd;
+        }
+
+        const numberOfSymbolsDecoded = symbolWidths.length;
+
+        if (firstSymbol === numberOfSymbolsDecoded - 1) {
+          newSymbols.push(collectiveBitmap);
+        } else {
+          let i,
+              y,
+              xMin = 0,
+              xMax,
+              bitmapWidth,
+              symbolBitmap;
+
+          for (i = firstSymbol; i < numberOfSymbolsDecoded; i++) {
+            bitmapWidth = symbolWidths[i];
+            xMax = xMin + bitmapWidth;
+            symbolBitmap = [];
+
+            for (y = 0; y < currentHeight; y++) {
+              symbolBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));
+            }
+
+            newSymbols.push(symbolBitmap);
+            xMin = xMax;
+          }
+        }
+      }
+    }
+
+    var exportedSymbols = [];
+    var flags = [],
+        currentFlag = false;
+    var totalSymbolsLength = symbols.length + numberOfNewSymbols;
+
+    while (flags.length < totalSymbolsLength) {
+      var runLength = huffman ? tableB1.decode(huffmanInput) : decodeInteger(contextCache, "IAEX", decoder);
+
+      while (runLength--) {
+        flags.push(currentFlag);
+      }
+
+      currentFlag = !currentFlag;
+    }
+
+    for (var i = 0, ii = symbols.length; i < ii; i++) {
+      if (flags[i]) {
+        exportedSymbols.push(symbols[i]);
+      }
+    }
+
+    for (var j = 0; j < numberOfNewSymbols; i++, j++) {
+      if (flags[i]) {
+        exportedSymbols.push(newSymbols[j]);
+      }
+    }
+
+    return exportedSymbols;
+  }
+
+  function decodeTextRegion(huffman, refinement, width, height, defaultPixelValue, numberOfSymbolInstances, stripSize, inputSymbols, symbolCodeLength, transposed, dsOffset, referenceCorner, combinationOperator, huffmanTables, refinementTemplateIndex, refinementAt, decodingContext, logStripSize, huffmanInput) {
+    if (huffman && refinement) {
+      throw new Jbig2Error("refinement with Huffman is not supported");
+    }
+
+    var bitmap = [];
+    var i, row;
+
+    for (i = 0; i < height; i++) {
+      row = new Uint8Array(width);
+
+      if (defaultPixelValue) {
+        for (var j = 0; j < width; j++) {
+          row[j] = defaultPixelValue;
+        }
+      }
+
+      bitmap.push(row);
+    }
+
+    var decoder = decodingContext.decoder;
+    var contextCache = decodingContext.contextCache;
+    var stripT = huffman ? -huffmanTables.tableDeltaT.decode(huffmanInput) : -decodeInteger(contextCache, "IADT", decoder);
+    var firstS = 0;
+    i = 0;
+
+    while (i < numberOfSymbolInstances) {
+      var deltaT = huffman ? huffmanTables.tableDeltaT.decode(huffmanInput) : decodeInteger(contextCache, "IADT", decoder);
+      stripT += deltaT;
+      var deltaFirstS = huffman ? huffmanTables.tableFirstS.decode(huffmanInput) : decodeInteger(contextCache, "IAFS", decoder);
+      firstS += deltaFirstS;
+      var currentS = firstS;
+
+      do {
+        let currentT = 0;
+
+        if (stripSize > 1) {
+          currentT = huffman ? huffmanInput.readBits(logStripSize) : decodeInteger(contextCache, "IAIT", decoder);
+        }
+
+        var t = stripSize * stripT + currentT;
+        var symbolId = huffman ? huffmanTables.symbolIDTable.decode(huffmanInput) : decodeIAID(contextCache, decoder, symbolCodeLength);
+        var applyRefinement = refinement && (huffman ? huffmanInput.readBit() : decodeInteger(contextCache, "IARI", decoder));
+        var symbolBitmap = inputSymbols[symbolId];
+        var symbolWidth = symbolBitmap[0].length;
+        var symbolHeight = symbolBitmap.length;
+
+        if (applyRefinement) {
+          var rdw = decodeInteger(contextCache, "IARDW", decoder);
+          var rdh = decodeInteger(contextCache, "IARDH", decoder);
+          var rdx = decodeInteger(contextCache, "IARDX", decoder);
+          var rdy = decodeInteger(contextCache, "IARDY", decoder);
+          symbolWidth += rdw;
+          symbolHeight += rdh;
+          symbolBitmap = decodeRefinement(symbolWidth, symbolHeight, refinementTemplateIndex, symbolBitmap, (rdw >> 1) + rdx, (rdh >> 1) + rdy, false, refinementAt, decodingContext);
+        }
+
+        var offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight - 1);
+        var offsetS = currentS - (referenceCorner & 2 ? symbolWidth - 1 : 0);
+        var s2, t2, symbolRow;
+
+        if (transposed) {
+          for (s2 = 0; s2 < symbolHeight; s2++) {
+            row = bitmap[offsetS + s2];
+
+            if (!row) {
+              continue;
+            }
+
+            symbolRow = symbolBitmap[s2];
+            var maxWidth = Math.min(width - offsetT, symbolWidth);
+
+            switch (combinationOperator) {
+              case 0:
+                for (t2 = 0; t2 < maxWidth; t2++) {
+                  row[offsetT + t2] |= symbolRow[t2];
+                }
+
+                break;
+
+              case 2:
+                for (t2 = 0; t2 < maxWidth; t2++) {
+                  row[offsetT + t2] ^= symbolRow[t2];
+                }
+
+                break;
+
+              default:
+                throw new Jbig2Error(`operator ${combinationOperator} is not supported`);
+            }
+          }
+
+          currentS += symbolHeight - 1;
+        } else {
+          for (t2 = 0; t2 < symbolHeight; t2++) {
+            row = bitmap[offsetT + t2];
+
+            if (!row) {
+              continue;
+            }
+
+            symbolRow = symbolBitmap[t2];
+
+            switch (combinationOperator) {
+              case 0:
+                for (s2 = 0; s2 < symbolWidth; s2++) {
+                  row[offsetS + s2] |= symbolRow[s2];
+                }
+
+                break;
+
+              case 2:
+                for (s2 = 0; s2 < symbolWidth; s2++) {
+                  row[offsetS + s2] ^= symbolRow[s2];
+                }
+
+                break;
+
+              default:
+                throw new Jbig2Error(`operator ${combinationOperator} is not supported`);
+            }
+          }
+
+          currentS += symbolWidth - 1;
+        }
+
+        i++;
+        var deltaS = huffman ? huffmanTables.tableDeltaS.decode(huffmanInput) : decodeInteger(contextCache, "IADS", decoder);
+
+        if (deltaS === null) {
+          break;
+        }
+
+        currentS += deltaS + dsOffset;
+      } while (true);
+    }
+
+    return bitmap;
+  }
+
+  function decodePatternDictionary(mmr, patternWidth, patternHeight, maxPatternIndex, template, decodingContext) {
+    const at = [];
+
+    if (!mmr) {
+      at.push({
+        x: -patternWidth,
+        y: 0
+      });
+
+      if (template === 0) {
+        at.push({
+          x: -3,
+          y: -1
+        });
+        at.push({
+          x: 2,
+          y: -2
+        });
+        at.push({
+          x: -2,
+          y: -2
+        });
+      }
+    }
+
+    const collectiveWidth = (maxPatternIndex + 1) * patternWidth;
+    const collectiveBitmap = decodeBitmap(mmr, collectiveWidth, patternHeight, template, false, null, at, decodingContext);
+    const patterns = [];
+
+    for (let i = 0; i <= maxPatternIndex; i++) {
+      const patternBitmap = [];
+      const xMin = patternWidth * i;
+      const xMax = xMin + patternWidth;
+
+      for (let y = 0; y < patternHeight; y++) {
+        patternBitmap.push(collectiveBitmap[y].subarray(xMin, xMax));
+      }
+
+      patterns.push(patternBitmap);
+    }
+
+    return patterns;
+  }
+
+  function decodeHalftoneRegion(mmr, patterns, template, regionWidth, regionHeight, defaultPixelValue, enableSkip, combinationOperator, gridWidth, gridHeight, gridOffsetX, gridOffsetY, gridVectorX, gridVectorY, decodingContext) {
+    const skip = null;
+
+    if (enableSkip) {
+      throw new Jbig2Error("skip is not supported");
+    }
+
+    if (combinationOperator !== 0) {
+      throw new Jbig2Error("operator " + combinationOperator + " is not supported in halftone region");
+    }
+
+    const regionBitmap = [];
+    let i, j, row;
+
+    for (i = 0; i < regionHeight; i++) {
+      row = new Uint8Array(regionWidth);
+
+      if (defaultPixelValue) {
+        for (j = 0; j < regionWidth; j++) {
+          row[j] = defaultPixelValue;
+        }
+      }
+
+      regionBitmap.push(row);
+    }
+
+    const numberOfPatterns = patterns.length;
+    const pattern0 = patterns[0];
+    const patternWidth = pattern0[0].length,
+          patternHeight = pattern0.length;
+    const bitsPerValue = (0, _core_utils.log2)(numberOfPatterns);
+    const at = [];
+
+    if (!mmr) {
+      at.push({
+        x: template <= 1 ? 3 : 2,
+        y: -1
+      });
+
+      if (template === 0) {
+        at.push({
+          x: -3,
+          y: -1
+        });
+        at.push({
+          x: 2,
+          y: -2
+        });
+        at.push({
+          x: -2,
+          y: -2
+        });
+      }
+    }
+
+    const grayScaleBitPlanes = [];
+    let mmrInput, bitmap;
+
+    if (mmr) {
+      mmrInput = new Reader(decodingContext.data, decodingContext.start, decodingContext.end);
+    }
+
+    for (i = bitsPerValue - 1; i >= 0; i--) {
+      if (mmr) {
+        bitmap = decodeMMRBitmap(mmrInput, gridWidth, gridHeight, true);
+      } else {
+        bitmap = decodeBitmap(false, gridWidth, gridHeight, template, false, skip, at, decodingContext);
+      }
+
+      grayScaleBitPlanes[i] = bitmap;
+    }
+
+    let mg, ng, bit, patternIndex, patternBitmap, x, y, patternRow, regionRow;
+
+    for (mg = 0; mg < gridHeight; mg++) {
+      for (ng = 0; ng < gridWidth; ng++) {
+        bit = 0;
+        patternIndex = 0;
+
+        for (j = bitsPerValue - 1; j >= 0; j--) {
+          bit = grayScaleBitPlanes[j][mg][ng] ^ bit;
+          patternIndex |= bit << j;
+        }
+
+        patternBitmap = patterns[patternIndex];
+        x = gridOffsetX + mg * gridVectorY + ng * gridVectorX >> 8;
+        y = gridOffsetY + mg * gridVectorX - ng * gridVectorY >> 8;
+
+        if (x >= 0 && x + patternWidth <= regionWidth && y >= 0 && y + patternHeight <= regionHeight) {
+          for (i = 0; i < patternHeight; i++) {
+            regionRow = regionBitmap[y + i];
+            patternRow = patternBitmap[i];
+
+            for (j = 0; j < patternWidth; j++) {
+              regionRow[x + j] |= patternRow[j];
+            }
+          }
+        } else {
+          let regionX, regionY;
+
+          for (i = 0; i < patternHeight; i++) {
+            regionY = y + i;
+
+            if (regionY < 0 || regionY >= regionHeight) {
+              continue;
+            }
+
+            regionRow = regionBitmap[regionY];
+            patternRow = patternBitmap[i];
+
+            for (j = 0; j < patternWidth; j++) {
+              regionX = x + j;
+
+              if (regionX >= 0 && regionX < regionWidth) {
+                regionRow[regionX] |= patternRow[j];
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return regionBitmap;
+  }
+
+  function readSegmentHeader(data, start) {
+    var segmentHeader = {};
+    segmentHeader.number = (0, _core_utils.readUint32)(data, start);
+    var flags = data[start + 4];
+    var segmentType = flags & 0x3f;
+
+    if (!SegmentTypes[segmentType]) {
+      throw new Jbig2Error("invalid segment type: " + segmentType);
+    }
+
+    segmentHeader.type = segmentType;
+    segmentHeader.typeName = SegmentTypes[segmentType];
+    segmentHeader.deferredNonRetain = !!(flags & 0x80);
+    var pageAssociationFieldSize = !!(flags & 0x40);
+    var referredFlags = data[start + 5];
+    var referredToCount = referredFlags >> 5 & 7;
+    var retainBits = [referredFlags & 31];
+    var position = start + 6;
+
+    if (referredFlags === 7) {
+      referredToCount = (0, _core_utils.readUint32)(data, position - 1) & 0x1fffffff;
+      position += 3;
+      var bytes = referredToCount + 7 >> 3;
+      retainBits[0] = data[position++];
+
+      while (--bytes > 0) {
+        retainBits.push(data[position++]);
+      }
+    } else if (referredFlags === 5 || referredFlags === 6) {
+      throw new Jbig2Error("invalid referred-to flags");
+    }
+
+    segmentHeader.retainBits = retainBits;
+    let referredToSegmentNumberSize = 4;
+
+    if (segmentHeader.number <= 256) {
+      referredToSegmentNumberSize = 1;
+    } else if (segmentHeader.number <= 65536) {
+      referredToSegmentNumberSize = 2;
+    }
+
+    var referredTo = [];
+    var i, ii;
+
+    for (i = 0; i < referredToCount; i++) {
+      let number;
+
+      if (referredToSegmentNumberSize === 1) {
+        number = data[position];
+      } else if (referredToSegmentNumberSize === 2) {
+        number = (0, _core_utils.readUint16)(data, position);
+      } else {
+        number = (0, _core_utils.readUint32)(data, position);
+      }
+
+      referredTo.push(number);
+      position += referredToSegmentNumberSize;
+    }
+
+    segmentHeader.referredTo = referredTo;
+
+    if (!pageAssociationFieldSize) {
+      segmentHeader.pageAssociation = data[position++];
+    } else {
+      segmentHeader.pageAssociation = (0, _core_utils.readUint32)(data, position);
+      position += 4;
+    }
+
+    segmentHeader.length = (0, _core_utils.readUint32)(data, position);
+    position += 4;
+
+    if (segmentHeader.length === 0xffffffff) {
+      if (segmentType === 38) {
+        var genericRegionInfo = readRegionSegmentInformation(data, position);
+        var genericRegionSegmentFlags = data[position + RegionSegmentInformationFieldLength];
+        var genericRegionMmr = !!(genericRegionSegmentFlags & 1);
+        var searchPatternLength = 6;
+        var searchPattern = new Uint8Array(searchPatternLength);
+
+        if (!genericRegionMmr) {
+          searchPattern[0] = 0xff;
+          searchPattern[1] = 0xac;
+        }
+
+        searchPattern[2] = genericRegionInfo.height >>> 24 & 0xff;
+        searchPattern[3] = genericRegionInfo.height >> 16 & 0xff;
+        searchPattern[4] = genericRegionInfo.height >> 8 & 0xff;
+        searchPattern[5] = genericRegionInfo.height & 0xff;
+
+        for (i = position, ii = data.length; i < ii; i++) {
+          var j = 0;
+
+          while (j < searchPatternLength && searchPattern[j] === data[i + j]) {
+            j++;
+          }
+
+          if (j === searchPatternLength) {
+            segmentHeader.length = i + searchPatternLength;
+            break;
+          }
+        }
+
+        if (segmentHeader.length === 0xffffffff) {
+          throw new Jbig2Error("segment end was not found");
+        }
+      } else {
+        throw new Jbig2Error("invalid unknown segment length");
+      }
+    }
+
+    segmentHeader.headerEnd = position;
+    return segmentHeader;
+  }
+
+  function readSegments(header, data, start, end) {
+    var segments = [];
+    var position = start;
+
+    while (position < end) {
+      var segmentHeader = readSegmentHeader(data, position);
+      position = segmentHeader.headerEnd;
+      var segment = {
+        header: segmentHeader,
+        data
+      };
+
+      if (!header.randomAccess) {
+        segment.start = position;
+        position += segmentHeader.length;
+        segment.end = position;
+      }
+
+      segments.push(segment);
+
+      if (segmentHeader.type === 51) {
+        break;
+      }
+    }
+
+    if (header.randomAccess) {
+      for (var i = 0, ii = segments.length; i < ii; i++) {
+        segments[i].start = position;
+        position += segments[i].header.length;
+        segments[i].end = position;
+      }
+    }
+
+    return segments;
+  }
+
+  function readRegionSegmentInformation(data, start) {
+    return {
+      width: (0, _core_utils.readUint32)(data, start),
+      height: (0, _core_utils.readUint32)(data, start + 4),
+      x: (0, _core_utils.readUint32)(data, start + 8),
+      y: (0, _core_utils.readUint32)(data, start + 12),
+      combinationOperator: data[start + 16] & 7
+    };
+  }
+
+  var RegionSegmentInformationFieldLength = 17;
+
+  function processSegment(segment, visitor) {
+    var header = segment.header;
+    var data = segment.data,
+        position = segment.start,
+        end = segment.end;
+    var args, at, i, atLength;
+
+    switch (header.type) {
+      case 0:
+        var dictionary = {};
+        var dictionaryFlags = (0, _core_utils.readUint16)(data, position);
+        dictionary.huffman = !!(dictionaryFlags & 1);
+        dictionary.refinement = !!(dictionaryFlags & 2);
+        dictionary.huffmanDHSelector = dictionaryFlags >> 2 & 3;
+        dictionary.huffmanDWSelector = dictionaryFlags >> 4 & 3;
+        dictionary.bitmapSizeSelector = dictionaryFlags >> 6 & 1;
+        dictionary.aggregationInstancesSelector = dictionaryFlags >> 7 & 1;
+        dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);
+        dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512);
+        dictionary.template = dictionaryFlags >> 10 & 3;
+        dictionary.refinementTemplate = dictionaryFlags >> 12 & 1;
+        position += 2;
+
+        if (!dictionary.huffman) {
+          atLength = dictionary.template === 0 ? 4 : 1;
+          at = [];
+
+          for (i = 0; i < atLength; i++) {
+            at.push({
+              x: (0, _core_utils.readInt8)(data, position),
+              y: (0, _core_utils.readInt8)(data, position + 1)
+            });
+            position += 2;
+          }
+
+          dictionary.at = at;
+        }
+
+        if (dictionary.refinement && !dictionary.refinementTemplate) {
+          at = [];
+
+          for (i = 0; i < 2; i++) {
+            at.push({
+              x: (0, _core_utils.readInt8)(data, position),
+              y: (0, _core_utils.readInt8)(data, position + 1)
+            });
+            position += 2;
+          }
+
+          dictionary.refinementAt = at;
+        }
+
+        dictionary.numberOfExportedSymbols = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        dictionary.numberOfNewSymbols = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        args = [dictionary, header.number, header.referredTo, data, position, end];
+        break;
+
+      case 6:
+      case 7:
+        var textRegion = {};
+        textRegion.info = readRegionSegmentInformation(data, position);
+        position += RegionSegmentInformationFieldLength;
+        var textRegionSegmentFlags = (0, _core_utils.readUint16)(data, position);
+        position += 2;
+        textRegion.huffman = !!(textRegionSegmentFlags & 1);
+        textRegion.refinement = !!(textRegionSegmentFlags & 2);
+        textRegion.logStripSize = textRegionSegmentFlags >> 2 & 3;
+        textRegion.stripSize = 1 << textRegion.logStripSize;
+        textRegion.referenceCorner = textRegionSegmentFlags >> 4 & 3;
+        textRegion.transposed = !!(textRegionSegmentFlags & 64);
+        textRegion.combinationOperator = textRegionSegmentFlags >> 7 & 3;
+        textRegion.defaultPixelValue = textRegionSegmentFlags >> 9 & 1;
+        textRegion.dsOffset = textRegionSegmentFlags << 17 >> 27;
+        textRegion.refinementTemplate = textRegionSegmentFlags >> 15 & 1;
+
+        if (textRegion.huffman) {
+          var textRegionHuffmanFlags = (0, _core_utils.readUint16)(data, position);
+          position += 2;
+          textRegion.huffmanFS = textRegionHuffmanFlags & 3;
+          textRegion.huffmanDS = textRegionHuffmanFlags >> 2 & 3;
+          textRegion.huffmanDT = textRegionHuffmanFlags >> 4 & 3;
+          textRegion.huffmanRefinementDW = textRegionHuffmanFlags >> 6 & 3;
+          textRegion.huffmanRefinementDH = textRegionHuffmanFlags >> 8 & 3;
+          textRegion.huffmanRefinementDX = textRegionHuffmanFlags >> 10 & 3;
+          textRegion.huffmanRefinementDY = textRegionHuffmanFlags >> 12 & 3;
+          textRegion.huffmanRefinementSizeSelector = !!(textRegionHuffmanFlags & 0x4000);
+        }
+
+        if (textRegion.refinement && !textRegion.refinementTemplate) {
+          at = [];
+
+          for (i = 0; i < 2; i++) {
+            at.push({
+              x: (0, _core_utils.readInt8)(data, position),
+              y: (0, _core_utils.readInt8)(data, position + 1)
+            });
+            position += 2;
+          }
+
+          textRegion.refinementAt = at;
+        }
+
+        textRegion.numberOfSymbolInstances = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        args = [textRegion, header.referredTo, data, position, end];
+        break;
+
+      case 16:
+        const patternDictionary = {};
+        const patternDictionaryFlags = data[position++];
+        patternDictionary.mmr = !!(patternDictionaryFlags & 1);
+        patternDictionary.template = patternDictionaryFlags >> 1 & 3;
+        patternDictionary.patternWidth = data[position++];
+        patternDictionary.patternHeight = data[position++];
+        patternDictionary.maxPatternIndex = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        args = [patternDictionary, header.number, data, position, end];
+        break;
+
+      case 22:
+      case 23:
+        const halftoneRegion = {};
+        halftoneRegion.info = readRegionSegmentInformation(data, position);
+        position += RegionSegmentInformationFieldLength;
+        const halftoneRegionFlags = data[position++];
+        halftoneRegion.mmr = !!(halftoneRegionFlags & 1);
+        halftoneRegion.template = halftoneRegionFlags >> 1 & 3;
+        halftoneRegion.enableSkip = !!(halftoneRegionFlags & 8);
+        halftoneRegion.combinationOperator = halftoneRegionFlags >> 4 & 7;
+        halftoneRegion.defaultPixelValue = halftoneRegionFlags >> 7 & 1;
+        halftoneRegion.gridWidth = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        halftoneRegion.gridHeight = (0, _core_utils.readUint32)(data, position);
+        position += 4;
+        halftoneRegion.gridOffsetX = (0, _core_utils.readUint32)(data, position) & 0xffffffff;
+        position += 4;
+        halftoneRegion.gridOffsetY = (0, _core_utils.readUint32)(data, position) & 0xffffffff;
+        position += 4;
+        halftoneRegion.gridVectorX = (0, _core_utils.readUint16)(data, position);
+        position += 2;
+        halftoneRegion.gridVectorY = (0, _core_utils.readUint16)(data, position);
+        position += 2;
+        args = [halftoneRegion, header.referredTo, data, position, end];
+        break;
+
+      case 38:
+      case 39:
+        var genericRegion = {};
+        genericRegion.info = readRegionSegmentInformation(data, position);
+        position += RegionSegmentInformationFieldLength;
+        var genericRegionSegmentFlags = data[position++];
+        genericRegion.mmr = !!(genericRegionSegmentFlags & 1);
+        genericRegion.template = genericRegionSegmentFlags >> 1 & 3;
+        genericRegion.prediction = !!(genericRegionSegmentFlags & 8);
+
+        if (!genericRegion.mmr) {
+          atLength = genericRegion.template === 0 ? 4 : 1;
+          at = [];
+
+          for (i = 0; i < atLength; i++) {
+            at.push({
+              x: (0, _core_utils.readInt8)(data, position),
+              y: (0, _core_utils.readInt8)(data, position + 1)
+            });
+            position += 2;
+          }
+
+          genericRegion.at = at;
+        }
+
+        args = [genericRegion, data, position, end];
+        break;
+
+      case 48:
+        var pageInfo = {
+          width: (0, _core_utils.readUint32)(data, position),
+          height: (0, _core_utils.readUint32)(data, position + 4),
+          resolutionX: (0, _core_utils.readUint32)(data, position + 8),
+          resolutionY: (0, _core_utils.readUint32)(data, position + 12)
+        };
+
+        if (pageInfo.height === 0xffffffff) {
+          delete pageInfo.height;
+        }
+
+        var pageSegmentFlags = data[position + 16];
+        (0, _core_utils.readUint16)(data, position + 17);
+        pageInfo.lossless = !!(pageSegmentFlags & 1);
+        pageInfo.refinement = !!(pageSegmentFlags & 2);
+        pageInfo.defaultPixelValue = pageSegmentFlags >> 2 & 1;
+        pageInfo.combinationOperator = pageSegmentFlags >> 3 & 3;
+        pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);
+        pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64);
+        args = [pageInfo];
+        break;
+
+      case 49:
+        break;
+
+      case 50:
+        break;
+
+      case 51:
+        break;
+
+      case 53:
+        args = [header.number, data, position, end];
+        break;
+
+      case 62:
+        break;
+
+      default:
+        throw new Jbig2Error(`segment type ${header.typeName}(${header.type})` + " is not implemented");
+    }
+
+    var callbackName = "on" + header.typeName;
+
+    if (callbackName in visitor) {
+      visitor[callbackName].apply(visitor, args);
+    }
+  }
+
+  function processSegments(segments, visitor) {
+    for (var i = 0, ii = segments.length; i < ii; i++) {
+      processSegment(segments[i], visitor);
+    }
+  }
+
+  function parseJbig2Chunks(chunks) {
+    var visitor = new SimpleSegmentVisitor();
+
+    for (var i = 0, ii = chunks.length; i < ii; i++) {
+      var chunk = chunks[i];
+      var segments = readSegments({}, chunk.data, chunk.start, chunk.end);
+      processSegments(segments, visitor);
+    }
+
+    return visitor.buffer;
+  }
+
+  function parseJbig2(data) {
+    const end = data.length;
+    let position = 0;
+
+    if (data[position] !== 0x97 || data[position + 1] !== 0x4a || data[position + 2] !== 0x42 || data[position + 3] !== 0x32 || data[position + 4] !== 0x0d || data[position + 5] !== 0x0a || data[position + 6] !== 0x1a || data[position + 7] !== 0x0a) {
+      throw new Jbig2Error("parseJbig2 - invalid header.");
+    }
+
+    const header = Object.create(null);
+    position += 8;
+    const flags = data[position++];
+    header.randomAccess = !(flags & 1);
+
+    if (!(flags & 2)) {
+      header.numberOfPages = (0, _core_utils.readUint32)(data, position);
+      position += 4;
+    }
+
+    const segments = readSegments(header, data, position, end);
+    const visitor = new SimpleSegmentVisitor();
+    processSegments(segments, visitor);
+    const {
+      width,
+      height
+    } = visitor.currentPageInfo;
+    const bitPacked = visitor.buffer;
+    const imgData = new Uint8ClampedArray(width * height);
+    let q = 0,
+        k = 0;
+
+    for (let i = 0; i < height; i++) {
+      let mask = 0,
+          buffer;
+
+      for (let j = 0; j < width; j++) {
+        if (!mask) {
+          mask = 128;
+          buffer = bitPacked[k++];
+        }
+
+        imgData[q++] = buffer & mask ? 0 : 255;
+        mask >>= 1;
+      }
+    }
+
+    return {
+      imgData,
+      width,
+      height
+    };
+  }
+
+  function SimpleSegmentVisitor() {}
+
+  SimpleSegmentVisitor.prototype = {
+    onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) {
+      this.currentPageInfo = info;
+      var rowSize = info.width + 7 >> 3;
+      var buffer = new Uint8ClampedArray(rowSize * info.height);
+
+      if (info.defaultPixelValue) {
+        for (var i = 0, ii = buffer.length; i < ii; i++) {
+          buffer[i] = 0xff;
+        }
+      }
+
+      this.buffer = buffer;
+    },
+    drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) {
+      var pageInfo = this.currentPageInfo;
+      var width = regionInfo.width,
+          height = regionInfo.height;
+      var rowSize = pageInfo.width + 7 >> 3;
+      var combinationOperator = pageInfo.combinationOperatorOverride ? regionInfo.combinationOperator : pageInfo.combinationOperator;
+      var buffer = this.buffer;
+      var mask0 = 128 >> (regionInfo.x & 7);
+      var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);
+      var i, j, mask, offset;
+
+      switch (combinationOperator) {
+        case 0:
+          for (i = 0; i < height; i++) {
+            mask = mask0;
+            offset = offset0;
+
+            for (j = 0; j < width; j++) {
+              if (bitmap[i][j]) {
+                buffer[offset] |= mask;
+              }
+
+              mask >>= 1;
+
+              if (!mask) {
+                mask = 128;
+                offset++;
+              }
+            }
+
+            offset0 += rowSize;
+          }
+
+          break;
+
+        case 2:
+          for (i = 0; i < height; i++) {
+            mask = mask0;
+            offset = offset0;
+
+            for (j = 0; j < width; j++) {
+              if (bitmap[i][j]) {
+                buffer[offset] ^= mask;
+              }
+
+              mask >>= 1;
+
+              if (!mask) {
+                mask = 128;
+                offset++;
+              }
+            }
+
+            offset0 += rowSize;
+          }
+
+          break;
+
+        default:
+          throw new Jbig2Error(`operator ${combinationOperator} is not supported`);
+      }
+    },
+    onImmediateGenericRegion: function SimpleSegmentVisitor_onImmediateGenericRegion(region, data, start, end) {
+      var regionInfo = region.info;
+      var decodingContext = new DecodingContext(data, start, end);
+      var bitmap = decodeBitmap(region.mmr, regionInfo.width, regionInfo.height, region.template, region.prediction, null, region.at, decodingContext);
+      this.drawBitmap(regionInfo, bitmap);
+    },
+    onImmediateLosslessGenericRegion: function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {
+      this.onImmediateGenericRegion.apply(this, arguments);
+    },
+    onSymbolDictionary: function SimpleSegmentVisitor_onSymbolDictionary(dictionary, currentSegment, referredSegments, data, start, end) {
+      let huffmanTables, huffmanInput;
+
+      if (dictionary.huffman) {
+        huffmanTables = getSymbolDictionaryHuffmanTables(dictionary, referredSegments, this.customTables);
+        huffmanInput = new Reader(data, start, end);
+      }
+
+      var symbols = this.symbols;
+
+      if (!symbols) {
+        this.symbols = symbols = {};
+      }
+
+      var inputSymbols = [];
+
+      for (var i = 0, ii = referredSegments.length; i < ii; i++) {
+        const referredSymbols = symbols[referredSegments[i]];
+
+        if (referredSymbols) {
+          inputSymbols = inputSymbols.concat(referredSymbols);
+        }
+      }
+
+      var decodingContext = new DecodingContext(data, start, end);
+      symbols[currentSegment] = decodeSymbolDictionary(dictionary.huffman, dictionary.refinement, inputSymbols, dictionary.numberOfNewSymbols, dictionary.numberOfExportedSymbols, huffmanTables, dictionary.template, dictionary.at, dictionary.refinementTemplate, dictionary.refinementAt, decodingContext, huffmanInput);
+    },
+    onImmediateTextRegion: function SimpleSegmentVisitor_onImmediateTextRegion(region, referredSegments, data, start, end) {
+      var regionInfo = region.info;
+      let huffmanTables, huffmanInput;
+      var symbols = this.symbols;
+      var inputSymbols = [];
+
+      for (var i = 0, ii = referredSegments.length; i < ii; i++) {
+        const referredSymbols = symbols[referredSegments[i]];
+
+        if (referredSymbols) {
+          inputSymbols = inputSymbols.concat(referredSymbols);
+        }
+      }
+
+      var symbolCodeLength = (0, _core_utils.log2)(inputSymbols.length);
+
+      if (region.huffman) {
+        huffmanInput = new Reader(data, start, end);
+        huffmanTables = getTextRegionHuffmanTables(region, referredSegments, this.customTables, inputSymbols.length, huffmanInput);
+      }
+
+      var decodingContext = new DecodingContext(data, start, end);
+      var bitmap = decodeTextRegion(region.huffman, region.refinement, regionInfo.width, regionInfo.height, region.defaultPixelValue, region.numberOfSymbolInstances, region.stripSize, inputSymbols, symbolCodeLength, region.transposed, region.dsOffset, region.referenceCorner, region.combinationOperator, huffmanTables, region.refinementTemplate, region.refinementAt, decodingContext, region.logStripSize, huffmanInput);
+      this.drawBitmap(regionInfo, bitmap);
+    },
+    onImmediateLosslessTextRegion: function SimpleSegmentVisitor_onImmediateLosslessTextRegion() {
+      this.onImmediateTextRegion.apply(this, arguments);
+    },
+
+    onPatternDictionary(dictionary, currentSegment, data, start, end) {
+      let patterns = this.patterns;
+
+      if (!patterns) {
+        this.patterns = patterns = {};
+      }
+
+      const decodingContext = new DecodingContext(data, start, end);
+      patterns[currentSegment] = decodePatternDictionary(dictionary.mmr, dictionary.patternWidth, dictionary.patternHeight, dictionary.maxPatternIndex, dictionary.template, decodingContext);
+    },
+
+    onImmediateHalftoneRegion(region, referredSegments, data, start, end) {
+      const patterns = this.patterns[referredSegments[0]];
+      const regionInfo = region.info;
+      const decodingContext = new DecodingContext(data, start, end);
+      const bitmap = decodeHalftoneRegion(region.mmr, patterns, region.template, regionInfo.width, regionInfo.height, region.defaultPixelValue, region.enableSkip, region.combinationOperator, region.gridWidth, region.gridHeight, region.gridOffsetX, region.gridOffsetY, region.gridVectorX, region.gridVectorY, decodingContext);
+      this.drawBitmap(regionInfo, bitmap);
+    },
+
+    onImmediateLosslessHalftoneRegion() {
+      this.onImmediateHalftoneRegion.apply(this, arguments);
+    },
+
+    onTables(currentSegment, data, start, end) {
+      let customTables = this.customTables;
+
+      if (!customTables) {
+        this.customTables = customTables = {};
+      }
+
+      customTables[currentSegment] = decodeTablesSegment(data, start, end);
+    }
+
+  };
+
+  function HuffmanLine(lineData) {
+    if (lineData.length === 2) {
+      this.isOOB = true;
+      this.rangeLow = 0;
+      this.prefixLength = lineData[0];
+      this.rangeLength = 0;
+      this.prefixCode = lineData[1];
+      this.isLowerRange = false;
+    } else {
+      this.isOOB = false;
+      this.rangeLow = lineData[0];
+      this.prefixLength = lineData[1];
+      this.rangeLength = lineData[2];
+      this.prefixCode = lineData[3];
+      this.isLowerRange = lineData[4] === "lower";
+    }
+  }
+
+  function HuffmanTreeNode(line) {
+    this.children = [];
+
+    if (line) {
+      this.isLeaf = true;
+      this.rangeLength = line.rangeLength;
+      this.rangeLow = line.rangeLow;
+      this.isLowerRange = line.isLowerRange;
+      this.isOOB = line.isOOB;
+    } else {
+      this.isLeaf = false;
+    }
+  }
+
+  HuffmanTreeNode.prototype = {
+    buildTree(line, shift) {
+      const bit = line.prefixCode >> shift & 1;
+
+      if (shift <= 0) {
+        this.children[bit] = new HuffmanTreeNode(line);
+      } else {
+        let node = this.children[bit];
+
+        if (!node) {
+          this.children[bit] = node = new HuffmanTreeNode(null);
+        }
+
+        node.buildTree(line, shift - 1);
+      }
+    },
+
+    decodeNode(reader) {
+      if (this.isLeaf) {
+        if (this.isOOB) {
+          return null;
+        }
+
+        const htOffset = reader.readBits(this.rangeLength);
+        return this.rangeLow + (this.isLowerRange ? -htOffset : htOffset);
+      }
+
+      const node = this.children[reader.readBit()];
+
+      if (!node) {
+        throw new Jbig2Error("invalid Huffman data");
+      }
+
+      return node.decodeNode(reader);
+    }
+
+  };
+
+  function HuffmanTable(lines, prefixCodesDone) {
+    if (!prefixCodesDone) {
+      this.assignPrefixCodes(lines);
+    }
+
+    this.rootNode = new HuffmanTreeNode(null);
+
+    for (let i = 0, ii = lines.length; i < ii; i++) {
+      const line = lines[i];
+
+      if (line.prefixLength > 0) {
+        this.rootNode.buildTree(line, line.prefixLength - 1);
+      }
+    }
+  }
+
+  HuffmanTable.prototype = {
+    decode(reader) {
+      return this.rootNode.decodeNode(reader);
+    },
+
+    assignPrefixCodes(lines) {
+      const linesLength = lines.length;
+      let prefixLengthMax = 0;
+
+      for (let i = 0; i < linesLength; i++) {
+        prefixLengthMax = Math.max(prefixLengthMax, lines[i].prefixLength);
+      }
+
+      const histogram = new Uint32Array(prefixLengthMax + 1);
+
+      for (let i = 0; i < linesLength; i++) {
+        histogram[lines[i].prefixLength]++;
+      }
+
+      let currentLength = 1,
+          firstCode = 0,
+          currentCode,
+          currentTemp,
+          line;
+      histogram[0] = 0;
+
+      while (currentLength <= prefixLengthMax) {
+        firstCode = firstCode + histogram[currentLength - 1] << 1;
+        currentCode = firstCode;
+        currentTemp = 0;
+
+        while (currentTemp < linesLength) {
+          line = lines[currentTemp];
+
+          if (line.prefixLength === currentLength) {
+            line.prefixCode = currentCode;
+            currentCode++;
+          }
+
+          currentTemp++;
+        }
+
+        currentLength++;
+      }
+    }
+
+  };
+
+  function decodeTablesSegment(data, start, end) {
+    const flags = data[start];
+    const lowestValue = (0, _core_utils.readUint32)(data, start + 1) & 0xffffffff;
+    const highestValue = (0, _core_utils.readUint32)(data, start + 5) & 0xffffffff;
+    const reader = new Reader(data, start + 9, end);
+    const prefixSizeBits = (flags >> 1 & 7) + 1;
+    const rangeSizeBits = (flags >> 4 & 7) + 1;
+    const lines = [];
+    let prefixLength,
+        rangeLength,
+        currentRangeLow = lowestValue;
+
+    do {
+      prefixLength = reader.readBits(prefixSizeBits);
+      rangeLength = reader.readBits(rangeSizeBits);
+      lines.push(new HuffmanLine([currentRangeLow, prefixLength, rangeLength, 0]));
+      currentRangeLow += 1 << rangeLength;
+    } while (currentRangeLow < highestValue);
+
+    prefixLength = reader.readBits(prefixSizeBits);
+    lines.push(new HuffmanLine([lowestValue - 1, prefixLength, 32, 0, "lower"]));
+    prefixLength = reader.readBits(prefixSizeBits);
+    lines.push(new HuffmanLine([highestValue, prefixLength, 32, 0]));
+
+    if (flags & 1) {
+      prefixLength = reader.readBits(prefixSizeBits);
+      lines.push(new HuffmanLine([prefixLength, 0]));
+    }
+
+    return new HuffmanTable(lines, false);
+  }
+
+  const standardTablesCache = {};
+
+  function getStandardTable(number) {
+    let table = standardTablesCache[number];
+
+    if (table) {
+      return table;
+    }
+
+    let lines;
+
+    switch (number) {
+      case 1:
+        lines = [[0, 1, 4, 0x0], [16, 2, 8, 0x2], [272, 3, 16, 0x6], [65808, 3, 32, 0x7]];
+        break;
+
+      case 2:
+        lines = [[0, 1, 0, 0x0], [1, 2, 0, 0x2], [2, 3, 0, 0x6], [3, 4, 3, 0xe], [11, 5, 6, 0x1e], [75, 6, 32, 0x3e], [6, 0x3f]];
+        break;
+
+      case 3:
+        lines = [[-256, 8, 8, 0xfe], [0, 1, 0, 0x0], [1, 2, 0, 0x2], [2, 3, 0, 0x6], [3, 4, 3, 0xe], [11, 5, 6, 0x1e], [-257, 8, 32, 0xff, "lower"], [75, 7, 32, 0x7e], [6, 0x3e]];
+        break;
+
+      case 4:
+        lines = [[1, 1, 0, 0x0], [2, 2, 0, 0x2], [3, 3, 0, 0x6], [4, 4, 3, 0xe], [12, 5, 6, 0x1e], [76, 5, 32, 0x1f]];
+        break;
+
+      case 5:
+        lines = [[-255, 7, 8, 0x7e], [1, 1, 0, 0x0], [2, 2, 0, 0x2], [3, 3, 0, 0x6], [4, 4, 3, 0xe], [12, 5, 6, 0x1e], [-256, 7, 32, 0x7f, "lower"], [76, 6, 32, 0x3e]];
+        break;
+
+      case 6:
+        lines = [[-2048, 5, 10, 0x1c], [-1024, 4, 9, 0x8], [-512, 4, 8, 0x9], [-256, 4, 7, 0xa], [-128, 5, 6, 0x1d], [-64, 5, 5, 0x1e], [-32, 4, 5, 0xb], [0, 2, 7, 0x0], [128, 3, 7, 0x2], [256, 3, 8, 0x3], [512, 4, 9, 0xc], [1024, 4, 10, 0xd], [-2049, 6, 32, 0x3e, "lower"], [2048, 6, 32, 0x3f]];
+        break;
+
+      case 7:
+        lines = [[-1024, 4, 9, 0x8], [-512, 3, 8, 0x0], [-256, 4, 7, 0x9], [-128, 5, 6, 0x1a], [-64, 5, 5, 0x1b], [-32, 4, 5, 0xa], [0, 4, 5, 0xb], [32, 5, 5, 0x1c], [64, 5, 6, 0x1d], [128, 4, 7, 0xc], [256, 3, 8, 0x1], [512, 3, 9, 0x2], [1024, 3, 10, 0x3], [-1025, 5, 32, 0x1e, "lower"], [2048, 5, 32, 0x1f]];
+        break;
+
+      case 8:
+        lines = [[-15, 8, 3, 0xfc], [-7, 9, 1, 0x1fc], [-5, 8, 1, 0xfd], [-3, 9, 0, 0x1fd], [-2, 7, 0, 0x7c], [-1, 4, 0, 0xa], [0, 2, 1, 0x0], [2, 5, 0, 0x1a], [3, 6, 0, 0x3a], [4, 3, 4, 0x4], [20, 6, 1, 0x3b], [22, 4, 4, 0xb], [38, 4, 5, 0xc], [70, 5, 6, 0x1b], [134, 5, 7, 0x1c], [262, 6, 7, 0x3c], [390, 7, 8, 0x7d], [646, 6, 10, 0x3d], [-16, 9, 32, 0x1fe, "lower"], [1670, 9, 32, 0x1ff], [2, 0x1]];
+        break;
+
+      case 9:
+        lines = [[-31, 8, 4, 0xfc], [-15, 9, 2, 0x1fc], [-11, 8, 2, 0xfd], [-7, 9, 1, 0x1fd], [-5, 7, 1, 0x7c], [-3, 4, 1, 0xa], [-1, 3, 1, 0x2], [1, 3, 1, 0x3], [3, 5, 1, 0x1a], [5, 6, 1, 0x3a], [7, 3, 5, 0x4], [39, 6, 2, 0x3b], [43, 4, 5, 0xb], [75, 4, 6, 0xc], [139, 5, 7, 0x1b], [267, 5, 8, 0x1c], [523, 6, 8, 0x3c], [779, 7, 9, 0x7d], [1291, 6, 11, 0x3d], [-32, 9, 32, 0x1fe, "lower"], [3339, 9, 32, 0x1ff], [2, 0x0]];
+        break;
+
+      case 10:
+        lines = [[-21, 7, 4, 0x7a], [-5, 8, 0, 0xfc], [-4, 7, 0, 0x7b], [-3, 5, 0, 0x18], [-2, 2, 2, 0x0], [2, 5, 0, 0x19], [3, 6, 0, 0x36], [4, 7, 0, 0x7c], [5, 8, 0, 0xfd], [6, 2, 6, 0x1], [70, 5, 5, 0x1a], [102, 6, 5, 0x37], [134, 6, 6, 0x38], [198, 6, 7, 0x39], [326, 6, 8, 0x3a], [582, 6, 9, 0x3b], [1094, 6, 10, 0x3c], [2118, 7, 11, 0x7d], [-22, 8, 32, 0xfe, "lower"], [4166, 8, 32, 0xff], [2, 0x2]];
+        break;
+
+      case 11:
+        lines = [[1, 1, 0, 0x0], [2, 2, 1, 0x2], [4, 4, 0, 0xc], [5, 4, 1, 0xd], [7, 5, 1, 0x1c], [9, 5, 2, 0x1d], [13, 6, 2, 0x3c], [17, 7, 2, 0x7a], [21, 7, 3, 0x7b], [29, 7, 4, 0x7c], [45, 7, 5, 0x7d], [77, 7, 6, 0x7e], [141, 7, 32, 0x7f]];
+        break;
+
+      case 12:
+        lines = [[1, 1, 0, 0x0], [2, 2, 0, 0x2], [3, 3, 1, 0x6], [5, 5, 0, 0x1c], [6, 5, 1, 0x1d], [8, 6, 1, 0x3c], [10, 7, 0, 0x7a], [11, 7, 1, 0x7b], [13, 7, 2, 0x7c], [17, 7, 3, 0x7d], [25, 7, 4, 0x7e], [41, 8, 5, 0xfe], [73, 8, 32, 0xff]];
+        break;
+
+      case 13:
+        lines = [[1, 1, 0, 0x0], [2, 3, 0, 0x4], [3, 4, 0, 0xc], [4, 5, 0, 0x1c], [5, 4, 1, 0xd], [7, 3, 3, 0x5], [15, 6, 1, 0x3a], [17, 6, 2, 0x3b], [21, 6, 3, 0x3c], [29, 6, 4, 0x3d], [45, 6, 5, 0x3e], [77, 7, 6, 0x7e], [141, 7, 32, 0x7f]];
+        break;
+
+      case 14:
+        lines = [[-2, 3, 0, 0x4], [-1, 3, 0, 0x5], [0, 1, 0, 0x0], [1, 3, 0, 0x6], [2, 3, 0, 0x7]];
+        break;
+
+      case 15:
+        lines = [[-24, 7, 4, 0x7c], [-8, 6, 2, 0x3c], [-4, 5, 1, 0x1c], [-2, 4, 0, 0xc], [-1, 3, 0, 0x4], [0, 1, 0, 0x0], [1, 3, 0, 0x5], [2, 4, 0, 0xd], [3, 5, 1, 0x1d], [5, 6, 2, 0x3d], [9, 7, 4, 0x7d], [-25, 7, 32, 0x7e, "lower"], [25, 7, 32, 0x7f]];
+        break;
+
+      default:
+        throw new Jbig2Error(`standard table B.${number} does not exist`);
+    }
+
+    for (let i = 0, ii = lines.length; i < ii; i++) {
+      lines[i] = new HuffmanLine(lines[i]);
+    }
+
+    table = new HuffmanTable(lines, true);
+    standardTablesCache[number] = table;
+    return table;
+  }
+
+  function Reader(data, start, end) {
+    this.data = data;
+    this.start = start;
+    this.end = end;
+    this.position = start;
+    this.shift = -1;
+    this.currentByte = 0;
+  }
+
+  Reader.prototype = {
+    readBit() {
+      if (this.shift < 0) {
+        if (this.position >= this.end) {
+          throw new Jbig2Error("end of data while reading bit");
+        }
+
+        this.currentByte = this.data[this.position++];
+        this.shift = 7;
+      }
+
+      const bit = this.currentByte >> this.shift & 1;
+      this.shift--;
+      return bit;
+    },
+
+    readBits(numBits) {
+      let result = 0,
+          i;
+
+      for (i = numBits - 1; i >= 0; i--) {
+        result |= this.readBit() << i;
+      }
+
+      return result;
+    },
+
+    byteAlign() {
+      this.shift = -1;
+    },
+
+    next() {
+      if (this.position >= this.end) {
+        return -1;
+      }
+
+      return this.data[this.position++];
+    }
+
+  };
+
+  function getCustomHuffmanTable(index, referredTo, customTables) {
+    let currentIndex = 0;
+
+    for (let i = 0, ii = referredTo.length; i < ii; i++) {
+      const table = customTables[referredTo[i]];
+
+      if (table) {
+        if (index === currentIndex) {
+          return table;
+        }
+
+        currentIndex++;
+      }
+    }
+
+    throw new Jbig2Error("can't find custom Huffman table");
+  }
+
+  function getTextRegionHuffmanTables(textRegion, referredTo, customTables, numberOfSymbols, reader) {
+    const codes = [];
+
+    for (let i = 0; i <= 34; i++) {
+      const codeLength = reader.readBits(4);
+      codes.push(new HuffmanLine([i, codeLength, 0, 0]));
+    }
+
+    const runCodesTable = new HuffmanTable(codes, false);
+    codes.length = 0;
+
+    for (let i = 0; i < numberOfSymbols;) {
+      const codeLength = runCodesTable.decode(reader);
+
+      if (codeLength >= 32) {
+        let repeatedLength, numberOfRepeats, j;
+
+        switch (codeLength) {
+          case 32:
+            if (i === 0) {
+              throw new Jbig2Error("no previous value in symbol ID table");
+            }
+
+            numberOfRepeats = reader.readBits(2) + 3;
+            repeatedLength = codes[i - 1].prefixLength;
+            break;
+
+          case 33:
+            numberOfRepeats = reader.readBits(3) + 3;
+            repeatedLength = 0;
+            break;
+
+          case 34:
+            numberOfRepeats = reader.readBits(7) + 11;
+            repeatedLength = 0;
+            break;
+
+          default:
+            throw new Jbig2Error("invalid code length in symbol ID table");
+        }
+
+        for (j = 0; j < numberOfRepeats; j++) {
+          codes.push(new HuffmanLine([i, repeatedLength, 0, 0]));
+          i++;
+        }
+      } else {
+        codes.push(new HuffmanLine([i, codeLength, 0, 0]));
+        i++;
+      }
+    }
+
+    reader.byteAlign();
+    const symbolIDTable = new HuffmanTable(codes, false);
+    let customIndex = 0,
+        tableFirstS,
+        tableDeltaS,
+        tableDeltaT;
+
+    switch (textRegion.huffmanFS) {
+      case 0:
+      case 1:
+        tableFirstS = getStandardTable(textRegion.huffmanFS + 6);
+        break;
+
+      case 3:
+        tableFirstS = getCustomHuffmanTable(customIndex, referredTo, customTables);
+        customIndex++;
+        break;
+
+      default:
+        throw new Jbig2Error("invalid Huffman FS selector");
+    }
+
+    switch (textRegion.huffmanDS) {
+      case 0:
+      case 1:
+      case 2:
+        tableDeltaS = getStandardTable(textRegion.huffmanDS + 8);
+        break;
+
+      case 3:
+        tableDeltaS = getCustomHuffmanTable(customIndex, referredTo, customTables);
+        customIndex++;
+        break;
+
+      default:
+        throw new Jbig2Error("invalid Huffman DS selector");
+    }
+
+    switch (textRegion.huffmanDT) {
+      case 0:
+      case 1:
+      case 2:
+        tableDeltaT = getStandardTable(textRegion.huffmanDT + 11);
+        break;
+
+      case 3:
+        tableDeltaT = getCustomHuffmanTable(customIndex, referredTo, customTables);
+        customIndex++;
+        break;
+
+      default:
+        throw new Jbig2Error("invalid Huffman DT selector");
+    }
+
+    if (textRegion.refinement) {
+      throw new Jbig2Error("refinement with Huffman is not supported");
+    }
+
+    return {
+      symbolIDTable,
+      tableFirstS,
+      tableDeltaS,
+      tableDeltaT
+    };
+  }
+
+  function getSymbolDictionaryHuffmanTables(dictionary, referredTo, customTables) {
+    let customIndex = 0,
+        tableDeltaHeight,
+        tableDeltaWidth;
+
+    switch (dictionary.huffmanDHSelector) {
+      case 0:
+      case 1:
+        tableDeltaHeight = getStandardTable(dictionary.huffmanDHSelector + 4);
+        break;
+
+      case 3:
+        tableDeltaHeight = getCustomHuffmanTable(customIndex, referredTo, customTables);
+        customIndex++;
+        break;
+
+      default:
+        throw new Jbig2Error("invalid Huffman DH selector");
+    }
+
+    switch (dictionary.huffmanDWSelector) {
+      case 0:
+      case 1:
+        tableDeltaWidth = getStandardTable(dictionary.huffmanDWSelector + 2);
+        break;
+
+      case 3:
+        tableDeltaWidth = getCustomHuffmanTable(customIndex, referredTo, customTables);
+        customIndex++;
+        break;
+
+      default:
+        throw new Jbig2Error("invalid Huffman DW selector");
+    }
+
+    let tableBitmapSize, tableAggregateInstances;
+
+    if (dictionary.bitmapSizeSelector) {
+      tableBitmapSize = getCustomHuffmanTable(customIndex, referredTo, customTables);
+      customIndex++;
+    } else {
+      tableBitmapSize = getStandardTable(1);
+    }
+
+    if (dictionary.aggregationInstancesSelector) {
+      tableAggregateInstances = getCustomHuffmanTable(customIndex, referredTo, customTables);
+    } else {
+      tableAggregateInstances = getStandardTable(1);
+    }
+
+    return {
+      tableDeltaHeight,
+      tableDeltaWidth,
+      tableBitmapSize,
+      tableAggregateInstances
+    };
+  }
+
+  function readUncompressedBitmap(reader, width, height) {
+    const bitmap = [];
+
+    for (let y = 0; y < height; y++) {
+      const row = new Uint8Array(width);
+      bitmap.push(row);
+
+      for (let x = 0; x < width; x++) {
+        row[x] = reader.readBit();
+      }
+
+      reader.byteAlign();
+    }
+
+    return bitmap;
+  }
+
+  function decodeMMRBitmap(input, width, height, endOfBlock) {
+    const params = {
+      K: -1,
+      Columns: width,
+      Rows: height,
+      BlackIs1: true,
+      EndOfBlock: endOfBlock
+    };
+    const decoder = new _ccitt.CCITTFaxDecoder(input, params);
+    const bitmap = [];
+    let currentByte,
+        eof = false;
+
+    for (let y = 0; y < height; y++) {
+      const row = new Uint8Array(width);
+      bitmap.push(row);
+      let shift = -1;
+
+      for (let x = 0; x < width; x++) {
+        if (shift < 0) {
+          currentByte = decoder.readNextChar();
+
+          if (currentByte === -1) {
+            currentByte = 0;
+            eof = true;
+          }
+
+          shift = 7;
+        }
+
+        row[x] = currentByte >> shift & 1;
+        shift--;
+      }
+    }
+
+    if (endOfBlock && !eof) {
+      const lookForEOFLimit = 5;
+
+      for (let i = 0; i < lookForEOFLimit; i++) {
+        if (decoder.readNextChar() === -1) {
+          break;
+        }
+      }
+    }
+
+    return bitmap;
+  }
+
+  function Jbig2Image() {}
+
+  Jbig2Image.prototype = {
+    parseChunks(chunks) {
+      return parseJbig2Chunks(chunks);
+    },
+
+    parse(data) {
+      const {
+        imgData,
+        width,
+        height
+      } = parseJbig2(data);
+      this.width = width;
+      this.height = height;
+      return imgData;
+    }
+
+  };
+  return Jbig2Image;
+}();
+
+exports.Jbig2Image = Jbig2Image;
+
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ArithmeticDecoder = void 0;
+const QeTable = [{
+  qe: 0x5601,
+  nmps: 1,
+  nlps: 1,
+  switchFlag: 1
+}, {
+  qe: 0x3401,
+  nmps: 2,
+  nlps: 6,
+  switchFlag: 0
+}, {
+  qe: 0x1801,
+  nmps: 3,
+  nlps: 9,
+  switchFlag: 0
+}, {
+  qe: 0x0ac1,
+  nmps: 4,
+  nlps: 12,
+  switchFlag: 0
+}, {
+  qe: 0x0521,
+  nmps: 5,
+  nlps: 29,
+  switchFlag: 0
+}, {
+  qe: 0x0221,
+  nmps: 38,
+  nlps: 33,
+  switchFlag: 0
+}, {
+  qe: 0x5601,
+  nmps: 7,
+  nlps: 6,
+  switchFlag: 1
+}, {
+  qe: 0x5401,
+  nmps: 8,
+  nlps: 14,
+  switchFlag: 0
+}, {
+  qe: 0x4801,
+  nmps: 9,
+  nlps: 14,
+  switchFlag: 0
+}, {
+  qe: 0x3801,
+  nmps: 10,
+  nlps: 14,
+  switchFlag: 0
+}, {
+  qe: 0x3001,
+  nmps: 11,
+  nlps: 17,
+  switchFlag: 0
+}, {
+  qe: 0x2401,
+  nmps: 12,
+  nlps: 18,
+  switchFlag: 0
+}, {
+  qe: 0x1c01,
+  nmps: 13,
+  nlps: 20,
+  switchFlag: 0
+}, {
+  qe: 0x1601,
+  nmps: 29,
+  nlps: 21,
+  switchFlag: 0
+}, {
+  qe: 0x5601,
+  nmps: 15,
+  nlps: 14,
+  switchFlag: 1
+}, {
+  qe: 0x5401,
+  nmps: 16,
+  nlps: 14,
+  switchFlag: 0
+}, {
+  qe: 0x5101,
+  nmps: 17,
+  nlps: 15,
+  switchFlag: 0
+}, {
+  qe: 0x4801,
+  nmps: 18,
+  nlps: 16,
+  switchFlag: 0
+}, {
+  qe: 0x3801,
+  nmps: 19,
+  nlps: 17,
+  switchFlag: 0
+}, {
+  qe: 0x3401,
+  nmps: 20,
+  nlps: 18,
+  switchFlag: 0
+}, {
+  qe: 0x3001,
+  nmps: 21,
+  nlps: 19,
+  switchFlag: 0
+}, {
+  qe: 0x2801,
+  nmps: 22,
+  nlps: 19,
+  switchFlag: 0
+}, {
+  qe: 0x2401,
+  nmps: 23,
+  nlps: 20,
+  switchFlag: 0
+}, {
+  qe: 0x2201,
+  nmps: 24,
+  nlps: 21,
+  switchFlag: 0
+}, {
+  qe: 0x1c01,
+  nmps: 25,
+  nlps: 22,
+  switchFlag: 0
+}, {
+  qe: 0x1801,
+  nmps: 26,
+  nlps: 23,
+  switchFlag: 0
+}, {
+  qe: 0x1601,
+  nmps: 27,
+  nlps: 24,
+  switchFlag: 0
+}, {
+  qe: 0x1401,
+  nmps: 28,
+  nlps: 25,
+  switchFlag: 0
+}, {
+  qe: 0x1201,
+  nmps: 29,
+  nlps: 26,
+  switchFlag: 0
+}, {
+  qe: 0x1101,
+  nmps: 30,
+  nlps: 27,
+  switchFlag: 0
+}, {
+  qe: 0x0ac1,
+  nmps: 31,
+  nlps: 28,
+  switchFlag: 0
+}, {
+  qe: 0x09c1,
+  nmps: 32,
+  nlps: 29,
+  switchFlag: 0
+}, {
+  qe: 0x08a1,
+  nmps: 33,
+  nlps: 30,
+  switchFlag: 0
+}, {
+  qe: 0x0521,
+  nmps: 34,
+  nlps: 31,
+  switchFlag: 0
+}, {
+  qe: 0x0441,
+  nmps: 35,
+  nlps: 32,
+  switchFlag: 0
+}, {
+  qe: 0x02a1,
+  nmps: 36,
+  nlps: 33,
+  switchFlag: 0
+}, {
+  qe: 0x0221,
+  nmps: 37,
+  nlps: 34,
+  switchFlag: 0
+}, {
+  qe: 0x0141,
+  nmps: 38,
+  nlps: 35,
+  switchFlag: 0
+}, {
+  qe: 0x0111,
+  nmps: 39,
+  nlps: 36,
+  switchFlag: 0
+}, {
+  qe: 0x0085,
+  nmps: 40,
+  nlps: 37,
+  switchFlag: 0
+}, {
+  qe: 0x0049,
+  nmps: 41,
+  nlps: 38,
+  switchFlag: 0
+}, {
+  qe: 0x0025,
+  nmps: 42,
+  nlps: 39,
+  switchFlag: 0
+}, {
+  qe: 0x0015,
+  nmps: 43,
+  nlps: 40,
+  switchFlag: 0
+}, {
+  qe: 0x0009,
+  nmps: 44,
+  nlps: 41,
+  switchFlag: 0
+}, {
+  qe: 0x0005,
+  nmps: 45,
+  nlps: 42,
+  switchFlag: 0
+}, {
+  qe: 0x0001,
+  nmps: 45,
+  nlps: 43,
+  switchFlag: 0
+}, {
+  qe: 0x5601,
+  nmps: 46,
+  nlps: 46,
+  switchFlag: 0
+}];
+
+class ArithmeticDecoder {
+  constructor(data, start, end) {
+    this.data = data;
+    this.bp = start;
+    this.dataEnd = end;
+    this.chigh = data[start];
+    this.clow = 0;
+    this.byteIn();
+    this.chigh = this.chigh << 7 & 0xffff | this.clow >> 9 & 0x7f;
+    this.clow = this.clow << 7 & 0xffff;
+    this.ct -= 7;
+    this.a = 0x8000;
+  }
+
+  byteIn() {
+    const data = this.data;
+    let bp = this.bp;
+
+    if (data[bp] === 0xff) {
+      if (data[bp + 1] > 0x8f) {
+        this.clow += 0xff00;
+        this.ct = 8;
+      } else {
+        bp++;
+        this.clow += data[bp] << 9;
+        this.ct = 7;
+        this.bp = bp;
+      }
+    } else {
+      bp++;
+      this.clow += bp < this.dataEnd ? data[bp] << 8 : 0xff00;
+      this.ct = 8;
+      this.bp = bp;
+    }
+
+    if (this.clow > 0xffff) {
+      this.chigh += this.clow >> 16;
+      this.clow &= 0xffff;
+    }
+  }
+
+  readBit(contexts, pos) {
+    let cx_index = contexts[pos] >> 1,
+        cx_mps = contexts[pos] & 1;
+    const qeTableIcx = QeTable[cx_index];
+    const qeIcx = qeTableIcx.qe;
+    let d;
+    let a = this.a - qeIcx;
+
+    if (this.chigh < qeIcx) {
+      if (a < qeIcx) {
+        a = qeIcx;
+        d = cx_mps;
+        cx_index = qeTableIcx.nmps;
+      } else {
+        a = qeIcx;
+        d = 1 ^ cx_mps;
+
+        if (qeTableIcx.switchFlag === 1) {
+          cx_mps = d;
+        }
+
+        cx_index = qeTableIcx.nlps;
+      }
+    } else {
+      this.chigh -= qeIcx;
+
+      if ((a & 0x8000) !== 0) {
+        this.a = a;
+        return cx_mps;
+      }
+
+      if (a < qeIcx) {
+        d = 1 ^ cx_mps;
+
+        if (qeTableIcx.switchFlag === 1) {
+          cx_mps = d;
+        }
+
+        cx_index = qeTableIcx.nlps;
+      } else {
+        d = cx_mps;
+        cx_index = qeTableIcx.nmps;
+      }
+    }
+
+    do {
+      if (this.ct === 0) {
+        this.byteIn();
+      }
+
+      a <<= 1;
+      this.chigh = this.chigh << 1 & 0xffff | this.clow >> 15 & 1;
+      this.clow = this.clow << 1 & 0xffff;
+      this.ct--;
+    } while ((a & 0x8000) === 0);
+
+    this.a = a;
+    contexts[pos] = cx_index << 1 | cx_mps;
+    return d;
+  }
+
+}
+
+exports.ArithmeticDecoder = ArithmeticDecoder;
+
+/***/ }),
+/* 18 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.JpegStream = void 0;
+
+var _stream = __w_pdfjs_require__(12);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _jpg = __w_pdfjs_require__(19);
+
+var _util = __w_pdfjs_require__(2);
+
+const JpegStream = function JpegStreamClosure() {
+  function JpegStream(stream, maybeLength, dict, params) {
+    let ch;
+
+    while ((ch = stream.getByte()) !== -1) {
+      if (ch === 0xff) {
+        stream.skip(-1);
+        break;
+      }
+    }
+
+    this.stream = stream;
+    this.maybeLength = maybeLength;
+    this.dict = dict;
+    this.params = params;
+
+    _stream.DecodeStream.call(this, maybeLength);
+  }
+
+  JpegStream.prototype = Object.create(_stream.DecodeStream.prototype);
+  Object.defineProperty(JpegStream.prototype, "bytes", {
+    get: function JpegStream_bytes() {
+      return (0, _util.shadow)(this, "bytes", this.stream.getBytes(this.maybeLength));
+    },
+    configurable: true
+  });
+
+  JpegStream.prototype.ensureBuffer = function (requested) {};
+
+  JpegStream.prototype.readBlock = function () {
+    if (this.eof) {
+      return;
+    }
+
+    const jpegOptions = {
+      decodeTransform: undefined,
+      colorTransform: undefined
+    };
+    const decodeArr = this.dict.getArray("Decode", "D");
+
+    if (this.forceRGB && Array.isArray(decodeArr)) {
+      const bitsPerComponent = this.dict.get("BitsPerComponent") || 8;
+      const decodeArrLength = decodeArr.length;
+      const transform = new Int32Array(decodeArrLength);
+      let transformNeeded = false;
+      const maxValue = (1 << bitsPerComponent) - 1;
+
+      for (let i = 0; i < decodeArrLength; i += 2) {
+        transform[i] = (decodeArr[i + 1] - decodeArr[i]) * 256 | 0;
+        transform[i + 1] = decodeArr[i] * maxValue | 0;
+
+        if (transform[i] !== 256 || transform[i + 1] !== 0) {
+          transformNeeded = true;
+        }
+      }
+
+      if (transformNeeded) {
+        jpegOptions.decodeTransform = transform;
+      }
+    }
+
+    if ((0, _primitives.isDict)(this.params)) {
+      const colorTransform = this.params.get("ColorTransform");
+
+      if (Number.isInteger(colorTransform)) {
+        jpegOptions.colorTransform = colorTransform;
+      }
+    }
+
+    const jpegImage = new _jpg.JpegImage(jpegOptions);
+    jpegImage.parse(this.bytes);
+    const data = jpegImage.getData({
+      width: this.drawWidth,
+      height: this.drawHeight,
+      forceRGB: this.forceRGB,
+      isSourcePDF: true
+    });
+    this.buffer = data;
+    this.bufferLength = data.length;
+    this.eof = true;
+  };
+
+  return JpegStream;
+}();
+
+exports.JpegStream = JpegStream;
+
+/***/ }),
+/* 19 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.JpegImage = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+class JpegError extends _util.BaseException {
+  constructor(msg) {
+    super(`JPEG error: ${msg}`);
+  }
+
+}
+
+class DNLMarkerError extends _util.BaseException {
+  constructor(message, scanLines) {
+    super(message);
+    this.scanLines = scanLines;
+  }
+
+}
+
+class EOIMarkerError extends _util.BaseException {}
+
+var JpegImage = function JpegImageClosure() {
+  var dctZigZag = new Uint8Array([0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63]);
+  var dctCos1 = 4017;
+  var dctSin1 = 799;
+  var dctCos3 = 3406;
+  var dctSin3 = 2276;
+  var dctCos6 = 1567;
+  var dctSin6 = 3784;
+  var dctSqrt2 = 5793;
+  var dctSqrt1d2 = 2896;
+
+  function JpegImage({
+    decodeTransform = null,
+    colorTransform = -1
+  } = {}) {
+    this._decodeTransform = decodeTransform;
+    this._colorTransform = colorTransform;
+  }
+
+  function buildHuffmanTable(codeLengths, values) {
+    var k = 0,
+        code = [],
+        i,
+        j,
+        length = 16;
+
+    while (length > 0 && !codeLengths[length - 1]) {
+      length--;
+    }
+
+    code.push({
+      children: [],
+      index: 0
+    });
+    var p = code[0],
+        q;
+
+    for (i = 0; i < length; i++) {
+      for (j = 0; j < codeLengths[i]; j++) {
+        p = code.pop();
+        p.children[p.index] = values[k];
+
+        while (p.index > 0) {
+          p = code.pop();
+        }
+
+        p.index++;
+        code.push(p);
+
+        while (code.length <= i) {
+          code.push(q = {
+            children: [],
+            index: 0
+          });
+          p.children[p.index] = q.children;
+          p = q;
+        }
+
+        k++;
+      }
+
+      if (i + 1 < length) {
+        code.push(q = {
+          children: [],
+          index: 0
+        });
+        p.children[p.index] = q.children;
+        p = q;
+      }
+    }
+
+    return code[0].children;
+  }
+
+  function getBlockBufferOffset(component, row, col) {
+    return 64 * ((component.blocksPerLine + 1) * row + col);
+  }
+
+  function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, parseDNLMarker = false) {
+    var mcusPerLine = frame.mcusPerLine;
+    var progressive = frame.progressive;
+    const startOffset = offset;
+    let bitsData = 0,
+        bitsCount = 0;
+
+    function readBit() {
+      if (bitsCount > 0) {
+        bitsCount--;
+        return bitsData >> bitsCount & 1;
+      }
+
+      bitsData = data[offset++];
+
+      if (bitsData === 0xff) {
+        var nextByte = data[offset++];
+
+        if (nextByte) {
+          if (nextByte === 0xdc && parseDNLMarker) {
+            offset += 2;
+            const scanLines = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+
+            if (scanLines > 0 && scanLines !== frame.scanLines) {
+              throw new DNLMarkerError("Found DNL marker (0xFFDC) while parsing scan data", scanLines);
+            }
+          } else if (nextByte === 0xd9) {
+            if (parseDNLMarker) {
+              const maybeScanLines = blockRow * (frame.precision === 8 ? 8 : 0);
+
+              if (maybeScanLines > 0 && Math.round(frame.scanLines / maybeScanLines) >= 10) {
+                throw new DNLMarkerError("Found EOI marker (0xFFD9) while parsing scan data, " + "possibly caused by incorrect `scanLines` parameter", maybeScanLines);
+              }
+            }
+
+            throw new EOIMarkerError("Found EOI marker (0xFFD9) while parsing scan data");
+          }
+
+          throw new JpegError(`unexpected marker ${(bitsData << 8 | nextByte).toString(16)}`);
+        }
+      }
+
+      bitsCount = 7;
+      return bitsData >>> 7;
+    }
+
+    function decodeHuffman(tree) {
+      var node = tree;
+
+      while (true) {
+        node = node[readBit()];
+
+        switch (typeof node) {
+          case "number":
+            return node;
+
+          case "object":
+            continue;
+        }
+
+        throw new JpegError("invalid huffman sequence");
+      }
+    }
+
+    function receive(length) {
+      var n = 0;
+
+      while (length > 0) {
+        n = n << 1 | readBit();
+        length--;
+      }
+
+      return n;
+    }
+
+    function receiveAndExtend(length) {
+      if (length === 1) {
+        return readBit() === 1 ? 1 : -1;
+      }
+
+      var n = receive(length);
+
+      if (n >= 1 << length - 1) {
+        return n;
+      }
+
+      return n + (-1 << length) + 1;
+    }
+
+    function decodeBaseline(component, blockOffset) {
+      var t = decodeHuffman(component.huffmanTableDC);
+      var diff = t === 0 ? 0 : receiveAndExtend(t);
+      component.blockData[blockOffset] = component.pred += diff;
+      var k = 1;
+
+      while (k < 64) {
+        var rs = decodeHuffman(component.huffmanTableAC);
+        var s = rs & 15,
+            r = rs >> 4;
+
+        if (s === 0) {
+          if (r < 15) {
+            break;
+          }
+
+          k += 16;
+          continue;
+        }
+
+        k += r;
+        var z = dctZigZag[k];
+        component.blockData[blockOffset + z] = receiveAndExtend(s);
+        k++;
+      }
+    }
+
+    function decodeDCFirst(component, blockOffset) {
+      var t = decodeHuffman(component.huffmanTableDC);
+      var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
+      component.blockData[blockOffset] = component.pred += diff;
+    }
+
+    function decodeDCSuccessive(component, blockOffset) {
+      component.blockData[blockOffset] |= readBit() << successive;
+    }
+
+    var eobrun = 0;
+
+    function decodeACFirst(component, blockOffset) {
+      if (eobrun > 0) {
+        eobrun--;
+        return;
+      }
+
+      var k = spectralStart,
+          e = spectralEnd;
+
+      while (k <= e) {
+        var rs = decodeHuffman(component.huffmanTableAC);
+        var s = rs & 15,
+            r = rs >> 4;
+
+        if (s === 0) {
+          if (r < 15) {
+            eobrun = receive(r) + (1 << r) - 1;
+            break;
+          }
+
+          k += 16;
+          continue;
+        }
+
+        k += r;
+        var z = dctZigZag[k];
+        component.blockData[blockOffset + z] = receiveAndExtend(s) * (1 << successive);
+        k++;
+      }
+    }
+
+    var successiveACState = 0,
+        successiveACNextValue;
+
+    function decodeACSuccessive(component, blockOffset) {
+      var k = spectralStart;
+      var e = spectralEnd;
+      var r = 0;
+      var s;
+      var rs;
+
+      while (k <= e) {
+        const offsetZ = blockOffset + dctZigZag[k];
+        const sign = component.blockData[offsetZ] < 0 ? -1 : 1;
+
+        switch (successiveACState) {
+          case 0:
+            rs = decodeHuffman(component.huffmanTableAC);
+            s = rs & 15;
+            r = rs >> 4;
+
+            if (s === 0) {
+              if (r < 15) {
+                eobrun = receive(r) + (1 << r);
+                successiveACState = 4;
+              } else {
+                r = 16;
+                successiveACState = 1;
+              }
+            } else {
+              if (s !== 1) {
+                throw new JpegError("invalid ACn encoding");
+              }
+
+              successiveACNextValue = receiveAndExtend(s);
+              successiveACState = r ? 2 : 3;
+            }
+
+            continue;
+
+          case 1:
+          case 2:
+            if (component.blockData[offsetZ]) {
+              component.blockData[offsetZ] += sign * (readBit() << successive);
+            } else {
+              r--;
+
+              if (r === 0) {
+                successiveACState = successiveACState === 2 ? 3 : 0;
+              }
+            }
+
+            break;
+
+          case 3:
+            if (component.blockData[offsetZ]) {
+              component.blockData[offsetZ] += sign * (readBit() << successive);
+            } else {
+              component.blockData[offsetZ] = successiveACNextValue << successive;
+              successiveACState = 0;
+            }
+
+            break;
+
+          case 4:
+            if (component.blockData[offsetZ]) {
+              component.blockData[offsetZ] += sign * (readBit() << successive);
+            }
+
+            break;
+        }
+
+        k++;
+      }
+
+      if (successiveACState === 4) {
+        eobrun--;
+
+        if (eobrun === 0) {
+          successiveACState = 0;
+        }
+      }
+    }
+
+    let blockRow = 0;
+
+    function decodeMcu(component, decode, mcu, row, col) {
+      var mcuRow = mcu / mcusPerLine | 0;
+      var mcuCol = mcu % mcusPerLine;
+      blockRow = mcuRow * component.v + row;
+      var blockCol = mcuCol * component.h + col;
+      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);
+      decode(component, blockOffset);
+    }
+
+    function decodeBlock(component, decode, mcu) {
+      blockRow = mcu / component.blocksPerLine | 0;
+      var blockCol = mcu % component.blocksPerLine;
+      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);
+      decode(component, blockOffset);
+    }
+
+    var componentsLength = components.length;
+    var component, i, j, k, n;
+    var decodeFn;
+
+    if (progressive) {
+      if (spectralStart === 0) {
+        decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+      } else {
+        decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+      }
+    } else {
+      decodeFn = decodeBaseline;
+    }
+
+    var mcu = 0,
+        fileMarker;
+    var mcuExpected;
+
+    if (componentsLength === 1) {
+      mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+    } else {
+      mcuExpected = mcusPerLine * frame.mcusPerColumn;
+    }
+
+    var h, v;
+
+    while (mcu <= mcuExpected) {
+      var mcuToRead = resetInterval ? Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;
+
+      if (mcuToRead > 0) {
+        for (i = 0; i < componentsLength; i++) {
+          components[i].pred = 0;
+        }
+
+        eobrun = 0;
+
+        if (componentsLength === 1) {
+          component = components[0];
+
+          for (n = 0; n < mcuToRead; n++) {
+            decodeBlock(component, decodeFn, mcu);
+            mcu++;
+          }
+        } else {
+          for (n = 0; n < mcuToRead; n++) {
+            for (i = 0; i < componentsLength; i++) {
+              component = components[i];
+              h = component.h;
+              v = component.v;
+
+              for (j = 0; j < v; j++) {
+                for (k = 0; k < h; k++) {
+                  decodeMcu(component, decodeFn, mcu, j, k);
+                }
+              }
+            }
+
+            mcu++;
+          }
+        }
+      }
+
+      bitsCount = 0;
+      fileMarker = findNextFileMarker(data, offset);
+
+      if (!fileMarker) {
+        break;
+      }
+
+      if (fileMarker.invalid) {
+        const partialMsg = mcuToRead > 0 ? "unexpected" : "excessive";
+        (0, _util.warn)(`decodeScan - ${partialMsg} MCU data, current marker is: ${fileMarker.invalid}`);
+        offset = fileMarker.offset;
+      }
+
+      if (fileMarker.marker >= 0xffd0 && fileMarker.marker <= 0xffd7) {
+        offset += 2;
+      } else {
+        break;
+      }
+    }
+
+    return offset - startOffset;
+  }
+
+  function quantizeAndInverse(component, blockBufferOffset, p) {
+    var qt = component.quantizationTable,
+        blockData = component.blockData;
+    var v0, v1, v2, v3, v4, v5, v6, v7;
+    var p0, p1, p2, p3, p4, p5, p6, p7;
+    var t;
+
+    if (!qt) {
+      throw new JpegError("missing required Quantization Table.");
+    }
+
+    for (var row = 0; row < 64; row += 8) {
+      p0 = blockData[blockBufferOffset + row];
+      p1 = blockData[blockBufferOffset + row + 1];
+      p2 = blockData[blockBufferOffset + row + 2];
+      p3 = blockData[blockBufferOffset + row + 3];
+      p4 = blockData[blockBufferOffset + row + 4];
+      p5 = blockData[blockBufferOffset + row + 5];
+      p6 = blockData[blockBufferOffset + row + 6];
+      p7 = blockData[blockBufferOffset + row + 7];
+      p0 *= qt[row];
+
+      if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
+        t = dctSqrt2 * p0 + 512 >> 10;
+        p[row] = t;
+        p[row + 1] = t;
+        p[row + 2] = t;
+        p[row + 3] = t;
+        p[row + 4] = t;
+        p[row + 5] = t;
+        p[row + 6] = t;
+        p[row + 7] = t;
+        continue;
+      }
+
+      p1 *= qt[row + 1];
+      p2 *= qt[row + 2];
+      p3 *= qt[row + 3];
+      p4 *= qt[row + 4];
+      p5 *= qt[row + 5];
+      p6 *= qt[row + 6];
+      p7 *= qt[row + 7];
+      v0 = dctSqrt2 * p0 + 128 >> 8;
+      v1 = dctSqrt2 * p4 + 128 >> 8;
+      v2 = p2;
+      v3 = p6;
+      v4 = dctSqrt1d2 * (p1 - p7) + 128 >> 8;
+      v7 = dctSqrt1d2 * (p1 + p7) + 128 >> 8;
+      v5 = p3 << 4;
+      v6 = p5 << 4;
+      v0 = v0 + v1 + 1 >> 1;
+      v1 = v0 - v1;
+      t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
+      v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
+      v3 = t;
+      v4 = v4 + v6 + 1 >> 1;
+      v6 = v4 - v6;
+      v7 = v7 + v5 + 1 >> 1;
+      v5 = v7 - v5;
+      v0 = v0 + v3 + 1 >> 1;
+      v3 = v0 - v3;
+      v1 = v1 + v2 + 1 >> 1;
+      v2 = v1 - v2;
+      t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+      v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+      v7 = t;
+      t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+      v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+      v6 = t;
+      p[row] = v0 + v7;
+      p[row + 7] = v0 - v7;
+      p[row + 1] = v1 + v6;
+      p[row + 6] = v1 - v6;
+      p[row + 2] = v2 + v5;
+      p[row + 5] = v2 - v5;
+      p[row + 3] = v3 + v4;
+      p[row + 4] = v3 - v4;
+    }
+
+    for (var col = 0; col < 8; ++col) {
+      p0 = p[col];
+      p1 = p[col + 8];
+      p2 = p[col + 16];
+      p3 = p[col + 24];
+      p4 = p[col + 32];
+      p5 = p[col + 40];
+      p6 = p[col + 48];
+      p7 = p[col + 56];
+
+      if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
+        t = dctSqrt2 * p0 + 8192 >> 14;
+
+        if (t < -2040) {
+          t = 0;
+        } else if (t >= 2024) {
+          t = 255;
+        } else {
+          t = t + 2056 >> 4;
+        }
+
+        blockData[blockBufferOffset + col] = t;
+        blockData[blockBufferOffset + col + 8] = t;
+        blockData[blockBufferOffset + col + 16] = t;
+        blockData[blockBufferOffset + col + 24] = t;
+        blockData[blockBufferOffset + col + 32] = t;
+        blockData[blockBufferOffset + col + 40] = t;
+        blockData[blockBufferOffset + col + 48] = t;
+        blockData[blockBufferOffset + col + 56] = t;
+        continue;
+      }
+
+      v0 = dctSqrt2 * p0 + 2048 >> 12;
+      v1 = dctSqrt2 * p4 + 2048 >> 12;
+      v2 = p2;
+      v3 = p6;
+      v4 = dctSqrt1d2 * (p1 - p7) + 2048 >> 12;
+      v7 = dctSqrt1d2 * (p1 + p7) + 2048 >> 12;
+      v5 = p3;
+      v6 = p5;
+      v0 = (v0 + v1 + 1 >> 1) + 4112;
+      v1 = v0 - v1;
+      t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
+      v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
+      v3 = t;
+      v4 = v4 + v6 + 1 >> 1;
+      v6 = v4 - v6;
+      v7 = v7 + v5 + 1 >> 1;
+      v5 = v7 - v5;
+      v0 = v0 + v3 + 1 >> 1;
+      v3 = v0 - v3;
+      v1 = v1 + v2 + 1 >> 1;
+      v2 = v1 - v2;
+      t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+      v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+      v7 = t;
+      t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+      v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+      v6 = t;
+      p0 = v0 + v7;
+      p7 = v0 - v7;
+      p1 = v1 + v6;
+      p6 = v1 - v6;
+      p2 = v2 + v5;
+      p5 = v2 - v5;
+      p3 = v3 + v4;
+      p4 = v3 - v4;
+
+      if (p0 < 16) {
+        p0 = 0;
+      } else if (p0 >= 4080) {
+        p0 = 255;
+      } else {
+        p0 >>= 4;
+      }
+
+      if (p1 < 16) {
+        p1 = 0;
+      } else if (p1 >= 4080) {
+        p1 = 255;
+      } else {
+        p1 >>= 4;
+      }
+
+      if (p2 < 16) {
+        p2 = 0;
+      } else if (p2 >= 4080) {
+        p2 = 255;
+      } else {
+        p2 >>= 4;
+      }
+
+      if (p3 < 16) {
+        p3 = 0;
+      } else if (p3 >= 4080) {
+        p3 = 255;
+      } else {
+        p3 >>= 4;
+      }
+
+      if (p4 < 16) {
+        p4 = 0;
+      } else if (p4 >= 4080) {
+        p4 = 255;
+      } else {
+        p4 >>= 4;
+      }
+
+      if (p5 < 16) {
+        p5 = 0;
+      } else if (p5 >= 4080) {
+        p5 = 255;
+      } else {
+        p5 >>= 4;
+      }
+
+      if (p6 < 16) {
+        p6 = 0;
+      } else if (p6 >= 4080) {
+        p6 = 255;
+      } else {
+        p6 >>= 4;
+      }
+
+      if (p7 < 16) {
+        p7 = 0;
+      } else if (p7 >= 4080) {
+        p7 = 255;
+      } else {
+        p7 >>= 4;
+      }
+
+      blockData[blockBufferOffset + col] = p0;
+      blockData[blockBufferOffset + col + 8] = p1;
+      blockData[blockBufferOffset + col + 16] = p2;
+      blockData[blockBufferOffset + col + 24] = p3;
+      blockData[blockBufferOffset + col + 32] = p4;
+      blockData[blockBufferOffset + col + 40] = p5;
+      blockData[blockBufferOffset + col + 48] = p6;
+      blockData[blockBufferOffset + col + 56] = p7;
+    }
+  }
+
+  function buildComponentData(frame, component) {
+    var blocksPerLine = component.blocksPerLine;
+    var blocksPerColumn = component.blocksPerColumn;
+    var computationBuffer = new Int16Array(64);
+
+    for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+      for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+        var offset = getBlockBufferOffset(component, blockRow, blockCol);
+        quantizeAndInverse(component, offset, computationBuffer);
+      }
+    }
+
+    return component.blockData;
+  }
+
+  function findNextFileMarker(data, currentPos, startPos = currentPos) {
+    const maxPos = data.length - 1;
+    var newPos = startPos < currentPos ? startPos : currentPos;
+
+    if (currentPos >= maxPos) {
+      return null;
+    }
+
+    var currentMarker = (0, _core_utils.readUint16)(data, currentPos);
+
+    if (currentMarker >= 0xffc0 && currentMarker <= 0xfffe) {
+      return {
+        invalid: null,
+        marker: currentMarker,
+        offset: currentPos
+      };
+    }
+
+    var newMarker = (0, _core_utils.readUint16)(data, newPos);
+
+    while (!(newMarker >= 0xffc0 && newMarker <= 0xfffe)) {
+      if (++newPos >= maxPos) {
+        return null;
+      }
+
+      newMarker = (0, _core_utils.readUint16)(data, newPos);
+    }
+
+    return {
+      invalid: currentMarker.toString(16),
+      marker: newMarker,
+      offset: newPos
+    };
+  }
+
+  JpegImage.prototype = {
+    parse(data, {
+      dnlScanLines = null
+    } = {}) {
+      function readDataBlock() {
+        const length = (0, _core_utils.readUint16)(data, offset);
+        offset += 2;
+        let endOffset = offset + length - 2;
+        var fileMarker = findNextFileMarker(data, endOffset, offset);
+
+        if (fileMarker && fileMarker.invalid) {
+          (0, _util.warn)("readDataBlock - incorrect length, current marker is: " + fileMarker.invalid);
+          endOffset = fileMarker.offset;
+        }
+
+        var array = data.subarray(offset, endOffset);
+        offset += array.length;
+        return array;
+      }
+
+      function prepareComponents(frame) {
+        var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);
+        var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);
+
+        for (var i = 0; i < frame.components.length; i++) {
+          component = frame.components[i];
+          var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / frame.maxH);
+          var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / frame.maxV);
+          var blocksPerLineForMcu = mcusPerLine * component.h;
+          var blocksPerColumnForMcu = mcusPerColumn * component.v;
+          var blocksBufferSize = 64 * blocksPerColumnForMcu * (blocksPerLineForMcu + 1);
+          component.blockData = new Int16Array(blocksBufferSize);
+          component.blocksPerLine = blocksPerLine;
+          component.blocksPerColumn = blocksPerColumn;
+        }
+
+        frame.mcusPerLine = mcusPerLine;
+        frame.mcusPerColumn = mcusPerColumn;
+      }
+
+      var offset = 0;
+      var jfif = null;
+      var adobe = null;
+      var frame, resetInterval;
+      let numSOSMarkers = 0;
+      var quantizationTables = [];
+      var huffmanTablesAC = [],
+          huffmanTablesDC = [];
+      let fileMarker = (0, _core_utils.readUint16)(data, offset);
+      offset += 2;
+
+      if (fileMarker !== 0xffd8) {
+        throw new JpegError("SOI not found");
+      }
+
+      fileMarker = (0, _core_utils.readUint16)(data, offset);
+      offset += 2;
+
+      markerLoop: while (fileMarker !== 0xffd9) {
+        var i, j, l;
+
+        switch (fileMarker) {
+          case 0xffe0:
+          case 0xffe1:
+          case 0xffe2:
+          case 0xffe3:
+          case 0xffe4:
+          case 0xffe5:
+          case 0xffe6:
+          case 0xffe7:
+          case 0xffe8:
+          case 0xffe9:
+          case 0xffea:
+          case 0xffeb:
+          case 0xffec:
+          case 0xffed:
+          case 0xffee:
+          case 0xffef:
+          case 0xfffe:
+            var appData = readDataBlock();
+
+            if (fileMarker === 0xffe0) {
+              if (appData[0] === 0x4a && appData[1] === 0x46 && appData[2] === 0x49 && appData[3] === 0x46 && appData[4] === 0) {
+                jfif = {
+                  version: {
+                    major: appData[5],
+                    minor: appData[6]
+                  },
+                  densityUnits: appData[7],
+                  xDensity: appData[8] << 8 | appData[9],
+                  yDensity: appData[10] << 8 | appData[11],
+                  thumbWidth: appData[12],
+                  thumbHeight: appData[13],
+                  thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+                };
+              }
+            }
+
+            if (fileMarker === 0xffee) {
+              if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6f && appData[3] === 0x62 && appData[4] === 0x65) {
+                adobe = {
+                  version: appData[5] << 8 | appData[6],
+                  flags0: appData[7] << 8 | appData[8],
+                  flags1: appData[9] << 8 | appData[10],
+                  transformCode: appData[11]
+                };
+              }
+            }
+
+            break;
+
+          case 0xffdb:
+            const quantizationTablesLength = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+            var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+            var z;
+
+            while (offset < quantizationTablesEnd) {
+              var quantizationTableSpec = data[offset++];
+              var tableData = new Uint16Array(64);
+
+              if (quantizationTableSpec >> 4 === 0) {
+                for (j = 0; j < 64; j++) {
+                  z = dctZigZag[j];
+                  tableData[z] = data[offset++];
+                }
+              } else if (quantizationTableSpec >> 4 === 1) {
+                for (j = 0; j < 64; j++) {
+                  z = dctZigZag[j];
+                  tableData[z] = (0, _core_utils.readUint16)(data, offset);
+                  offset += 2;
+                }
+              } else {
+                throw new JpegError("DQT - invalid table spec");
+              }
+
+              quantizationTables[quantizationTableSpec & 15] = tableData;
+            }
+
+            break;
+
+          case 0xffc0:
+          case 0xffc1:
+          case 0xffc2:
+            if (frame) {
+              throw new JpegError("Only single frame JPEGs supported");
+            }
+
+            offset += 2;
+            frame = {};
+            frame.extended = fileMarker === 0xffc1;
+            frame.progressive = fileMarker === 0xffc2;
+            frame.precision = data[offset++];
+            const sofScanLines = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+            frame.scanLines = dnlScanLines || sofScanLines;
+            frame.samplesPerLine = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+            frame.components = [];
+            frame.componentIds = {};
+            var componentsCount = data[offset++],
+                componentId;
+            var maxH = 0,
+                maxV = 0;
+
+            for (i = 0; i < componentsCount; i++) {
+              componentId = data[offset];
+              var h = data[offset + 1] >> 4;
+              var v = data[offset + 1] & 15;
+
+              if (maxH < h) {
+                maxH = h;
+              }
+
+              if (maxV < v) {
+                maxV = v;
+              }
+
+              var qId = data[offset + 2];
+              l = frame.components.push({
+                h,
+                v,
+                quantizationId: qId,
+                quantizationTable: null
+              });
+              frame.componentIds[componentId] = l - 1;
+              offset += 3;
+            }
+
+            frame.maxH = maxH;
+            frame.maxV = maxV;
+            prepareComponents(frame);
+            break;
+
+          case 0xffc4:
+            const huffmanLength = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+
+            for (i = 2; i < huffmanLength;) {
+              var huffmanTableSpec = data[offset++];
+              var codeLengths = new Uint8Array(16);
+              var codeLengthSum = 0;
+
+              for (j = 0; j < 16; j++, offset++) {
+                codeLengthSum += codeLengths[j] = data[offset];
+              }
+
+              var huffmanValues = new Uint8Array(codeLengthSum);
+
+              for (j = 0; j < codeLengthSum; j++, offset++) {
+                huffmanValues[j] = data[offset];
+              }
+
+              i += 17 + codeLengthSum;
+              (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
+            }
+
+            break;
+
+          case 0xffdd:
+            offset += 2;
+            resetInterval = (0, _core_utils.readUint16)(data, offset);
+            offset += 2;
+            break;
+
+          case 0xffda:
+            const parseDNLMarker = ++numSOSMarkers === 1 && !dnlScanLines;
+            offset += 2;
+            var selectorsCount = data[offset++];
+            var components = [],
+                component;
+
+            for (i = 0; i < selectorsCount; i++) {
+              const index = data[offset++];
+              var componentIndex = frame.componentIds[index];
+              component = frame.components[componentIndex];
+              component.index = index;
+              var tableSpec = data[offset++];
+              component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+              component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+              components.push(component);
+            }
+
+            var spectralStart = data[offset++];
+            var spectralEnd = data[offset++];
+            var successiveApproximation = data[offset++];
+
+            try {
+              var processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15, parseDNLMarker);
+              offset += processed;
+            } catch (ex) {
+              if (ex instanceof DNLMarkerError) {
+                (0, _util.warn)(`${ex.message} -- attempting to re-parse the JPEG image.`);
+                return this.parse(data, {
+                  dnlScanLines: ex.scanLines
+                });
+              } else if (ex instanceof EOIMarkerError) {
+                (0, _util.warn)(`${ex.message} -- ignoring the rest of the image data.`);
+                break markerLoop;
+              }
+
+              throw ex;
+            }
+
+            break;
+
+          case 0xffdc:
+            offset += 4;
+            break;
+
+          case 0xffff:
+            if (data[offset] !== 0xff) {
+              offset--;
+            }
+
+            break;
+
+          default:
+            const nextFileMarker = findNextFileMarker(data, offset - 2, offset - 3);
+
+            if (nextFileMarker && nextFileMarker.invalid) {
+              (0, _util.warn)("JpegImage.parse - unexpected data, current marker is: " + nextFileMarker.invalid);
+              offset = nextFileMarker.offset;
+              break;
+            }
+
+            if (!nextFileMarker || offset >= data.length - 1) {
+              (0, _util.warn)("JpegImage.parse - reached the end of the image data " + "without finding an EOI marker (0xFFD9).");
+              break markerLoop;
+            }
+
+            throw new JpegError("JpegImage.parse - unknown marker: " + fileMarker.toString(16));
+        }
+
+        fileMarker = (0, _core_utils.readUint16)(data, offset);
+        offset += 2;
+      }
+
+      this.width = frame.samplesPerLine;
+      this.height = frame.scanLines;
+      this.jfif = jfif;
+      this.adobe = adobe;
+      this.components = [];
+
+      for (i = 0; i < frame.components.length; i++) {
+        component = frame.components[i];
+        var quantizationTable = quantizationTables[component.quantizationId];
+
+        if (quantizationTable) {
+          component.quantizationTable = quantizationTable;
+        }
+
+        this.components.push({
+          index: component.index,
+          output: buildComponentData(frame, component),
+          scaleX: component.h / frame.maxH,
+          scaleY: component.v / frame.maxV,
+          blocksPerLine: component.blocksPerLine,
+          blocksPerColumn: component.blocksPerColumn
+        });
+      }
+
+      this.numComponents = this.components.length;
+      return undefined;
+    },
+
+    _getLinearizedBlockData(width, height, isSourcePDF = false) {
+      var scaleX = this.width / width,
+          scaleY = this.height / height;
+      var component, componentScaleX, componentScaleY, blocksPerScanline;
+      var x, y, i, j, k;
+      var index;
+      var offset = 0;
+      var output;
+      var numComponents = this.components.length;
+      var dataLength = width * height * numComponents;
+      var data = new Uint8ClampedArray(dataLength);
+      var xScaleBlockOffset = new Uint32Array(width);
+      var mask3LSB = 0xfffffff8;
+      let lastComponentScaleX;
+
+      for (i = 0; i < numComponents; i++) {
+        component = this.components[i];
+        componentScaleX = component.scaleX * scaleX;
+        componentScaleY = component.scaleY * scaleY;
+        offset = i;
+        output = component.output;
+        blocksPerScanline = component.blocksPerLine + 1 << 3;
+
+        if (componentScaleX !== lastComponentScaleX) {
+          for (x = 0; x < width; x++) {
+            j = 0 | x * componentScaleX;
+            xScaleBlockOffset[x] = (j & mask3LSB) << 3 | j & 7;
+          }
+
+          lastComponentScaleX = componentScaleX;
+        }
+
+        for (y = 0; y < height; y++) {
+          j = 0 | y * componentScaleY;
+          index = blocksPerScanline * (j & mask3LSB) | (j & 7) << 3;
+
+          for (x = 0; x < width; x++) {
+            data[offset] = output[index + xScaleBlockOffset[x]];
+            offset += numComponents;
+          }
+        }
+      }
+
+      let transform = this._decodeTransform;
+
+      if (!isSourcePDF && numComponents === 4 && !transform) {
+        transform = new Int32Array([-256, 255, -256, 255, -256, 255, -256, 255]);
+      }
+
+      if (transform) {
+        for (i = 0; i < dataLength;) {
+          for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
+            data[i] = (data[i] * transform[k] >> 8) + transform[k + 1];
+          }
+        }
+      }
+
+      return data;
+    },
+
+    get _isColorConversionNeeded() {
+      if (this.adobe) {
+        return !!this.adobe.transformCode;
+      }
+
+      if (this.numComponents === 3) {
+        if (this._colorTransform === 0) {
+          return false;
+        } else if (this.components[0].index === 0x52 && this.components[1].index === 0x47 && this.components[2].index === 0x42) {
+          return false;
+        }
+
+        return true;
+      }
+
+      if (this._colorTransform === 1) {
+        return true;
+      }
+
+      return false;
+    },
+
+    _convertYccToRgb: function convertYccToRgb(data) {
+      var Y, Cb, Cr;
+
+      for (var i = 0, length = data.length; i < length; i += 3) {
+        Y = data[i];
+        Cb = data[i + 1];
+        Cr = data[i + 2];
+        data[i] = Y - 179.456 + 1.402 * Cr;
+        data[i + 1] = Y + 135.459 - 0.344 * Cb - 0.714 * Cr;
+        data[i + 2] = Y - 226.816 + 1.772 * Cb;
+      }
+
+      return data;
+    },
+    _convertYcckToRgb: function convertYcckToRgb(data) {
+      var Y, Cb, Cr, k;
+      var offset = 0;
+
+      for (var i = 0, length = data.length; i < length; i += 4) {
+        Y = data[i];
+        Cb = data[i + 1];
+        Cr = data[i + 2];
+        k = data[i + 3];
+        data[offset++] = -122.67195406894 + Cb * (-6.60635669420364e-5 * Cb + 0.000437130475926232 * Cr - 5.4080610064599e-5 * Y + 0.00048449797120281 * k - 0.154362151871126) + Cr * (-0.000957964378445773 * Cr + 0.000817076911346625 * Y - 0.00477271405408747 * k + 1.53380253221734) + Y * (0.000961250184130688 * Y - 0.00266257332283933 * k + 0.48357088451265) + k * (-0.000336197177618394 * k + 0.484791561490776);
+        data[offset++] = 107.268039397724 + Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr + 0.000659397001245577 * Y + 0.000426105652938837 * k - 0.176491792462875) + Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y + 0.000770482631801132 * k - 0.151051492775562) + Y * (0.00126935368114843 * Y - 0.00265090189010898 * k + 0.25802910206845) + k * (-0.000318913117588328 * k - 0.213742400323665);
+        data[offset++] = -20.810012546947 + Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr + 0.0020741088115012 * Y - 0.00288260236853442 * k + 0.814272968359295) + Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y + 0.000560833691242812 * k - 0.195152027534049) + Y * (0.00174418132927582 * Y - 0.00255243321439347 * k + 0.116935020465145) + k * (-0.000343531996510555 * k + 0.24165260232407);
+      }
+
+      return data.subarray(0, offset);
+    },
+    _convertYcckToCmyk: function convertYcckToCmyk(data) {
+      var Y, Cb, Cr;
+
+      for (var i = 0, length = data.length; i < length; i += 4) {
+        Y = data[i];
+        Cb = data[i + 1];
+        Cr = data[i + 2];
+        data[i] = 434.456 - Y - 1.402 * Cr;
+        data[i + 1] = 119.541 - Y + 0.344 * Cb + 0.714 * Cr;
+        data[i + 2] = 481.816 - Y - 1.772 * Cb;
+      }
+
+      return data;
+    },
+    _convertCmykToRgb: function convertCmykToRgb(data) {
+      var c, m, y, k;
+      var offset = 0;
+
+      for (var i = 0, length = data.length; i < length; i += 4) {
+        c = data[i];
+        m = data[i + 1];
+        y = data[i + 2];
+        k = data[i + 3];
+        data[offset++] = 255 + c * (-0.00006747147073602441 * c + 0.0008379262121013727 * m + 0.0002894718188643294 * y + 0.003264231057537806 * k - 1.1185611867203937) + m * (0.000026374107616089405 * m - 0.00008626949158638572 * y - 0.0002748769067499491 * k - 0.02155688794978967) + y * (-0.00003878099212869363 * y - 0.0003267808279485286 * k + 0.0686742238595345) - k * (0.0003361971776183937 * k + 0.7430659151342254);
+        data[offset++] = 255 + c * (0.00013596372813588848 * c + 0.000924537132573585 * m + 0.00010567359618683593 * y + 0.0004791864687436512 * k - 0.3109689587515875) + m * (-0.00023545346108370344 * m + 0.0002702845253534714 * y + 0.0020200308977307156 * k - 0.7488052167015494) + y * (0.00006834815998235662 * y + 0.00015168452363460973 * k - 0.09751927774728933) - k * (0.00031891311758832814 * k + 0.7364883807733168);
+        data[offset++] = 255 + c * (0.000013598650411385307 * c + 0.00012423956175490851 * m + 0.0004751985097583589 * y - 0.0000036729317476630422 * k - 0.05562186980264034) + m * (0.00016141380598724676 * m + 0.0009692239130725186 * y + 0.0007782692450036253 * k - 0.44015232367526463) + y * (5.068882914068769e-7 * y + 0.0017778369011375071 * k - 0.7591454649749609) - k * (0.0003435319965105553 * k + 0.7063770186160144);
+      }
+
+      return data.subarray(0, offset);
+    },
+
+    getData({
+      width,
+      height,
+      forceRGB = false,
+      isSourcePDF = false
+    }) {
+      if (this.numComponents > 4) {
+        throw new JpegError("Unsupported color mode");
+      }
+
+      var data = this._getLinearizedBlockData(width, height, isSourcePDF);
+
+      if (this.numComponents === 1 && forceRGB) {
+        var dataLength = data.length;
+        var rgbData = new Uint8ClampedArray(dataLength * 3);
+        var offset = 0;
+
+        for (var i = 0; i < dataLength; i++) {
+          var grayColor = data[i];
+          rgbData[offset++] = grayColor;
+          rgbData[offset++] = grayColor;
+          rgbData[offset++] = grayColor;
+        }
+
+        return rgbData;
+      } else if (this.numComponents === 3 && this._isColorConversionNeeded) {
+        return this._convertYccToRgb(data);
+      } else if (this.numComponents === 4) {
+        if (this._isColorConversionNeeded) {
+          if (forceRGB) {
+            return this._convertYcckToRgb(data);
+          }
+
+          return this._convertYcckToCmyk(data);
+        } else if (forceRGB) {
+          return this._convertCmykToRgb(data);
+        }
+      }
+
+      return data;
+    }
+
+  };
+  return JpegImage;
+}();
+
+exports.JpegImage = JpegImage;
+
+/***/ }),
+/* 20 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.JpxStream = void 0;
+
+var _stream = __w_pdfjs_require__(12);
+
+var _jpx = __w_pdfjs_require__(21);
+
+var _util = __w_pdfjs_require__(2);
+
+const JpxStream = function JpxStreamClosure() {
+  function JpxStream(stream, maybeLength, dict, params) {
+    this.stream = stream;
+    this.maybeLength = maybeLength;
+    this.dict = dict;
+    this.params = params;
+
+    _stream.DecodeStream.call(this, maybeLength);
+  }
+
+  JpxStream.prototype = Object.create(_stream.DecodeStream.prototype);
+  Object.defineProperty(JpxStream.prototype, "bytes", {
+    get: function JpxStream_bytes() {
+      return (0, _util.shadow)(this, "bytes", this.stream.getBytes(this.maybeLength));
+    },
+    configurable: true
+  });
+
+  JpxStream.prototype.ensureBuffer = function (requested) {};
+
+  JpxStream.prototype.readBlock = function () {
+    if (this.eof) {
+      return;
+    }
+
+    const jpxImage = new _jpx.JpxImage();
+    jpxImage.parse(this.bytes);
+    const width = jpxImage.width;
+    const height = jpxImage.height;
+    const componentsCount = jpxImage.componentsCount;
+    const tileCount = jpxImage.tiles.length;
+
+    if (tileCount === 1) {
+      this.buffer = jpxImage.tiles[0].items;
+    } else {
+      const data = new Uint8ClampedArray(width * height * componentsCount);
+
+      for (let k = 0; k < tileCount; k++) {
+        const tileComponents = jpxImage.tiles[k];
+        const tileWidth = tileComponents.width;
+        const tileHeight = tileComponents.height;
+        const tileLeft = tileComponents.left;
+        const tileTop = tileComponents.top;
+        const src = tileComponents.items;
+        let srcPosition = 0;
+        let dataPosition = (width * tileTop + tileLeft) * componentsCount;
+        const imgRowSize = width * componentsCount;
+        const tileRowSize = tileWidth * componentsCount;
+
+        for (let j = 0; j < tileHeight; j++) {
+          const rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);
+          data.set(rowBytes, dataPosition);
+          srcPosition += tileRowSize;
+          dataPosition += imgRowSize;
+        }
+      }
+
+      this.buffer = data;
+    }
+
+    this.bufferLength = this.buffer.length;
+    this.eof = true;
+  };
+
+  return JpxStream;
+}();
+
+exports.JpxStream = JpxStream;
+
+/***/ }),
+/* 21 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.JpxImage = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _arithmetic_decoder = __w_pdfjs_require__(17);
+
+class JpxError extends _util.BaseException {
+  constructor(msg) {
+    super(`JPX error: ${msg}`);
+  }
+
+}
+
+var JpxImage = function JpxImageClosure() {
+  var SubbandsGainLog2 = {
+    LL: 0,
+    LH: 1,
+    HL: 1,
+    HH: 2
+  };
+
+  function JpxImage() {
+    this.failOnCorruptedImage = false;
+  }
+
+  JpxImage.prototype = {
+    parse: function JpxImage_parse(data) {
+      var head = (0, _core_utils.readUint16)(data, 0);
+
+      if (head === 0xff4f) {
+        this.parseCodestream(data, 0, data.length);
+        return;
+      }
+
+      var position = 0,
+          length = data.length;
+
+      while (position < length) {
+        var headerSize = 8;
+        var lbox = (0, _core_utils.readUint32)(data, position);
+        var tbox = (0, _core_utils.readUint32)(data, position + 4);
+        position += headerSize;
+
+        if (lbox === 1) {
+          lbox = (0, _core_utils.readUint32)(data, position) * 4294967296 + (0, _core_utils.readUint32)(data, position + 4);
+          position += 8;
+          headerSize += 8;
+        }
+
+        if (lbox === 0) {
+          lbox = length - position + headerSize;
+        }
+
+        if (lbox < headerSize) {
+          throw new JpxError("Invalid box field size");
+        }
+
+        var dataLength = lbox - headerSize;
+        var jumpDataLength = true;
+
+        switch (tbox) {
+          case 0x6a703268:
+            jumpDataLength = false;
+            break;
+
+          case 0x636f6c72:
+            var method = data[position];
+
+            if (method === 1) {
+              var colorspace = (0, _core_utils.readUint32)(data, position + 3);
+
+              switch (colorspace) {
+                case 16:
+                case 17:
+                case 18:
+                  break;
+
+                default:
+                  (0, _util.warn)("Unknown colorspace " + colorspace);
+                  break;
+              }
+            } else if (method === 2) {
+              (0, _util.info)("ICC profile not supported");
+            }
+
+            break;
+
+          case 0x6a703263:
+            this.parseCodestream(data, position, position + dataLength);
+            break;
+
+          case 0x6a502020:
+            if ((0, _core_utils.readUint32)(data, position) !== 0x0d0a870a) {
+              (0, _util.warn)("Invalid JP2 signature");
+            }
+
+            break;
+
+          case 0x6a501a1a:
+          case 0x66747970:
+          case 0x72726571:
+          case 0x72657320:
+          case 0x69686472:
+            break;
+
+          default:
+            var headerType = String.fromCharCode(tbox >> 24 & 0xff, tbox >> 16 & 0xff, tbox >> 8 & 0xff, tbox & 0xff);
+            (0, _util.warn)("Unsupported header type " + tbox + " (" + headerType + ")");
+            break;
+        }
+
+        if (jumpDataLength) {
+          position += dataLength;
+        }
+      }
+    },
+    parseImageProperties: function JpxImage_parseImageProperties(stream) {
+      var newByte = stream.getByte();
+
+      while (newByte >= 0) {
+        var oldByte = newByte;
+        newByte = stream.getByte();
+        var code = oldByte << 8 | newByte;
+
+        if (code === 0xff51) {
+          stream.skip(4);
+          var Xsiz = stream.getInt32() >>> 0;
+          var Ysiz = stream.getInt32() >>> 0;
+          var XOsiz = stream.getInt32() >>> 0;
+          var YOsiz = stream.getInt32() >>> 0;
+          stream.skip(16);
+          var Csiz = stream.getUint16();
+          this.width = Xsiz - XOsiz;
+          this.height = Ysiz - YOsiz;
+          this.componentsCount = Csiz;
+          this.bitsPerComponent = 8;
+          return;
+        }
+      }
+
+      throw new JpxError("No size marker found in JPX stream");
+    },
+    parseCodestream: function JpxImage_parseCodestream(data, start, end) {
+      var context = {};
+      var doNotRecover = false;
+
+      try {
+        var position = start;
+
+        while (position + 1 < end) {
+          var code = (0, _core_utils.readUint16)(data, position);
+          position += 2;
+          var length = 0,
+              j,
+              sqcd,
+              spqcds,
+              spqcdSize,
+              scalarExpounded,
+              tile;
+
+          switch (code) {
+            case 0xff4f:
+              context.mainHeader = true;
+              break;
+
+            case 0xffd9:
+              break;
+
+            case 0xff51:
+              length = (0, _core_utils.readUint16)(data, position);
+              var siz = {};
+              siz.Xsiz = (0, _core_utils.readUint32)(data, position + 4);
+              siz.Ysiz = (0, _core_utils.readUint32)(data, position + 8);
+              siz.XOsiz = (0, _core_utils.readUint32)(data, position + 12);
+              siz.YOsiz = (0, _core_utils.readUint32)(data, position + 16);
+              siz.XTsiz = (0, _core_utils.readUint32)(data, position + 20);
+              siz.YTsiz = (0, _core_utils.readUint32)(data, position + 24);
+              siz.XTOsiz = (0, _core_utils.readUint32)(data, position + 28);
+              siz.YTOsiz = (0, _core_utils.readUint32)(data, position + 32);
+              var componentsCount = (0, _core_utils.readUint16)(data, position + 36);
+              siz.Csiz = componentsCount;
+              var components = [];
+              j = position + 38;
+
+              for (var i = 0; i < componentsCount; i++) {
+                var component = {
+                  precision: (data[j] & 0x7f) + 1,
+                  isSigned: !!(data[j] & 0x80),
+                  XRsiz: data[j + 1],
+                  YRsiz: data[j + 2]
+                };
+                j += 3;
+                calculateComponentDimensions(component, siz);
+                components.push(component);
+              }
+
+              context.SIZ = siz;
+              context.components = components;
+              calculateTileGrids(context, components);
+              context.QCC = [];
+              context.COC = [];
+              break;
+
+            case 0xff5c:
+              length = (0, _core_utils.readUint16)(data, position);
+              var qcd = {};
+              j = position + 2;
+              sqcd = data[j++];
+
+              switch (sqcd & 0x1f) {
+                case 0:
+                  spqcdSize = 8;
+                  scalarExpounded = true;
+                  break;
+
+                case 1:
+                  spqcdSize = 16;
+                  scalarExpounded = false;
+                  break;
+
+                case 2:
+                  spqcdSize = 16;
+                  scalarExpounded = true;
+                  break;
+
+                default:
+                  throw new Error("Invalid SQcd value " + sqcd);
+              }
+
+              qcd.noQuantization = spqcdSize === 8;
+              qcd.scalarExpounded = scalarExpounded;
+              qcd.guardBits = sqcd >> 5;
+              spqcds = [];
+
+              while (j < length + position) {
+                var spqcd = {};
+
+                if (spqcdSize === 8) {
+                  spqcd.epsilon = data[j++] >> 3;
+                  spqcd.mu = 0;
+                } else {
+                  spqcd.epsilon = data[j] >> 3;
+                  spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
+                  j += 2;
+                }
+
+                spqcds.push(spqcd);
+              }
+
+              qcd.SPqcds = spqcds;
+
+              if (context.mainHeader) {
+                context.QCD = qcd;
+              } else {
+                context.currentTile.QCD = qcd;
+                context.currentTile.QCC = [];
+              }
+
+              break;
+
+            case 0xff5d:
+              length = (0, _core_utils.readUint16)(data, position);
+              var qcc = {};
+              j = position + 2;
+              var cqcc;
+
+              if (context.SIZ.Csiz < 257) {
+                cqcc = data[j++];
+              } else {
+                cqcc = (0, _core_utils.readUint16)(data, j);
+                j += 2;
+              }
+
+              sqcd = data[j++];
+
+              switch (sqcd & 0x1f) {
+                case 0:
+                  spqcdSize = 8;
+                  scalarExpounded = true;
+                  break;
+
+                case 1:
+                  spqcdSize = 16;
+                  scalarExpounded = false;
+                  break;
+
+                case 2:
+                  spqcdSize = 16;
+                  scalarExpounded = true;
+                  break;
+
+                default:
+                  throw new Error("Invalid SQcd value " + sqcd);
+              }
+
+              qcc.noQuantization = spqcdSize === 8;
+              qcc.scalarExpounded = scalarExpounded;
+              qcc.guardBits = sqcd >> 5;
+              spqcds = [];
+
+              while (j < length + position) {
+                spqcd = {};
+
+                if (spqcdSize === 8) {
+                  spqcd.epsilon = data[j++] >> 3;
+                  spqcd.mu = 0;
+                } else {
+                  spqcd.epsilon = data[j] >> 3;
+                  spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
+                  j += 2;
+                }
+
+                spqcds.push(spqcd);
+              }
+
+              qcc.SPqcds = spqcds;
+
+              if (context.mainHeader) {
+                context.QCC[cqcc] = qcc;
+              } else {
+                context.currentTile.QCC[cqcc] = qcc;
+              }
+
+              break;
+
+            case 0xff52:
+              length = (0, _core_utils.readUint16)(data, position);
+              var cod = {};
+              j = position + 2;
+              var scod = data[j++];
+              cod.entropyCoderWithCustomPrecincts = !!(scod & 1);
+              cod.sopMarkerUsed = !!(scod & 2);
+              cod.ephMarkerUsed = !!(scod & 4);
+              cod.progressionOrder = data[j++];
+              cod.layersCount = (0, _core_utils.readUint16)(data, j);
+              j += 2;
+              cod.multipleComponentTransform = data[j++];
+              cod.decompositionLevelsCount = data[j++];
+              cod.xcb = (data[j++] & 0xf) + 2;
+              cod.ycb = (data[j++] & 0xf) + 2;
+              var blockStyle = data[j++];
+              cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);
+              cod.resetContextProbabilities = !!(blockStyle & 2);
+              cod.terminationOnEachCodingPass = !!(blockStyle & 4);
+              cod.verticallyStripe = !!(blockStyle & 8);
+              cod.predictableTermination = !!(blockStyle & 16);
+              cod.segmentationSymbolUsed = !!(blockStyle & 32);
+              cod.reversibleTransformation = data[j++];
+
+              if (cod.entropyCoderWithCustomPrecincts) {
+                var precinctsSizes = [];
+
+                while (j < length + position) {
+                  var precinctsSize = data[j++];
+                  precinctsSizes.push({
+                    PPx: precinctsSize & 0xf,
+                    PPy: precinctsSize >> 4
+                  });
+                }
+
+                cod.precinctsSizes = precinctsSizes;
+              }
+
+              var unsupported = [];
+
+              if (cod.selectiveArithmeticCodingBypass) {
+                unsupported.push("selectiveArithmeticCodingBypass");
+              }
+
+              if (cod.resetContextProbabilities) {
+                unsupported.push("resetContextProbabilities");
+              }
+
+              if (cod.terminationOnEachCodingPass) {
+                unsupported.push("terminationOnEachCodingPass");
+              }
+
+              if (cod.verticallyStripe) {
+                unsupported.push("verticallyStripe");
+              }
+
+              if (cod.predictableTermination) {
+                unsupported.push("predictableTermination");
+              }
+
+              if (unsupported.length > 0) {
+                doNotRecover = true;
+                (0, _util.warn)(`JPX: Unsupported COD options (${unsupported.join(", ")}).`);
+              }
+
+              if (context.mainHeader) {
+                context.COD = cod;
+              } else {
+                context.currentTile.COD = cod;
+                context.currentTile.COC = [];
+              }
+
+              break;
+
+            case 0xff90:
+              length = (0, _core_utils.readUint16)(data, position);
+              tile = {};
+              tile.index = (0, _core_utils.readUint16)(data, position + 2);
+              tile.length = (0, _core_utils.readUint32)(data, position + 4);
+              tile.dataEnd = tile.length + position - 2;
+              tile.partIndex = data[position + 8];
+              tile.partsCount = data[position + 9];
+              context.mainHeader = false;
+
+              if (tile.partIndex === 0) {
+                tile.COD = context.COD;
+                tile.COC = context.COC.slice(0);
+                tile.QCD = context.QCD;
+                tile.QCC = context.QCC.slice(0);
+              }
+
+              context.currentTile = tile;
+              break;
+
+            case 0xff93:
+              tile = context.currentTile;
+
+              if (tile.partIndex === 0) {
+                initializeTile(context, tile.index);
+                buildPackets(context);
+              }
+
+              length = tile.dataEnd - position;
+              parseTilePackets(context, data, position, length);
+              break;
+
+            case 0xff53:
+              (0, _util.warn)("JPX: Codestream code 0xFF53 (COC) is not implemented.");
+
+            case 0xff55:
+            case 0xff57:
+            case 0xff58:
+            case 0xff64:
+              length = (0, _core_utils.readUint16)(data, position);
+              break;
+
+            default:
+              throw new Error("Unknown codestream code: " + code.toString(16));
+          }
+
+          position += length;
+        }
+      } catch (e) {
+        if (doNotRecover || this.failOnCorruptedImage) {
+          throw new JpxError(e.message);
+        } else {
+          (0, _util.warn)(`JPX: Trying to recover from: "${e.message}".`);
+        }
+      }
+
+      this.tiles = transformComponents(context);
+      this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;
+      this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;
+      this.componentsCount = context.SIZ.Csiz;
+    }
+  };
+
+  function calculateComponentDimensions(component, siz) {
+    component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);
+    component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);
+    component.y0 = Math.ceil(siz.YOsiz / component.YRsiz);
+    component.y1 = Math.ceil(siz.Ysiz / component.YRsiz);
+    component.width = component.x1 - component.x0;
+    component.height = component.y1 - component.y0;
+  }
+
+  function calculateTileGrids(context, components) {
+    var siz = context.SIZ;
+    var tile,
+        tiles = [];
+    var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);
+    var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);
+
+    for (var q = 0; q < numYtiles; q++) {
+      for (var p = 0; p < numXtiles; p++) {
+        tile = {};
+        tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz);
+        tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz);
+        tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz);
+        tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz);
+        tile.width = tile.tx1 - tile.tx0;
+        tile.height = tile.ty1 - tile.ty0;
+        tile.components = [];
+        tiles.push(tile);
+      }
+    }
+
+    context.tiles = tiles;
+    var componentsCount = siz.Csiz;
+
+    for (var i = 0, ii = componentsCount; i < ii; i++) {
+      var component = components[i];
+
+      for (var j = 0, jj = tiles.length; j < jj; j++) {
+        var tileComponent = {};
+        tile = tiles[j];
+        tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz);
+        tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz);
+        tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz);
+        tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz);
+        tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0;
+        tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0;
+        tile.components[i] = tileComponent;
+      }
+    }
+  }
+
+  function getBlocksDimensions(context, component, r) {
+    var codOrCoc = component.codingStyleParameters;
+    var result = {};
+
+    if (!codOrCoc.entropyCoderWithCustomPrecincts) {
+      result.PPx = 15;
+      result.PPy = 15;
+    } else {
+      result.PPx = codOrCoc.precinctsSizes[r].PPx;
+      result.PPy = codOrCoc.precinctsSizes[r].PPy;
+    }
+
+    result.xcb_ = r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) : Math.min(codOrCoc.xcb, result.PPx);
+    result.ycb_ = r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) : Math.min(codOrCoc.ycb, result.PPy);
+    return result;
+  }
+
+  function buildPrecincts(context, resolution, dimensions) {
+    var precinctWidth = 1 << dimensions.PPx;
+    var precinctHeight = 1 << dimensions.PPy;
+    var isZeroRes = resolution.resLevel === 0;
+    var precinctWidthInSubband = 1 << dimensions.PPx + (isZeroRes ? 0 : -1);
+    var precinctHeightInSubband = 1 << dimensions.PPy + (isZeroRes ? 0 : -1);
+    var numprecinctswide = resolution.trx1 > resolution.trx0 ? Math.ceil(resolution.trx1 / precinctWidth) - Math.floor(resolution.trx0 / precinctWidth) : 0;
+    var numprecinctshigh = resolution.try1 > resolution.try0 ? Math.ceil(resolution.try1 / precinctHeight) - Math.floor(resolution.try0 / precinctHeight) : 0;
+    var numprecincts = numprecinctswide * numprecinctshigh;
+    resolution.precinctParameters = {
+      precinctWidth,
+      precinctHeight,
+      numprecinctswide,
+      numprecinctshigh,
+      numprecincts,
+      precinctWidthInSubband,
+      precinctHeightInSubband
+    };
+  }
+
+  function buildCodeblocks(context, subband, dimensions) {
+    var xcb_ = dimensions.xcb_;
+    var ycb_ = dimensions.ycb_;
+    var codeblockWidth = 1 << xcb_;
+    var codeblockHeight = 1 << ycb_;
+    var cbx0 = subband.tbx0 >> xcb_;
+    var cby0 = subband.tby0 >> ycb_;
+    var cbx1 = subband.tbx1 + codeblockWidth - 1 >> xcb_;
+    var cby1 = subband.tby1 + codeblockHeight - 1 >> ycb_;
+    var precinctParameters = subband.resolution.precinctParameters;
+    var codeblocks = [];
+    var precincts = [];
+    var i, j, codeblock, precinctNumber;
+
+    for (j = cby0; j < cby1; j++) {
+      for (i = cbx0; i < cbx1; i++) {
+        codeblock = {
+          cbx: i,
+          cby: j,
+          tbx0: codeblockWidth * i,
+          tby0: codeblockHeight * j,
+          tbx1: codeblockWidth * (i + 1),
+          tby1: codeblockHeight * (j + 1)
+        };
+        codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0);
+        codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0);
+        codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1);
+        codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1);
+        var pi = Math.floor((codeblock.tbx0_ - subband.tbx0) / precinctParameters.precinctWidthInSubband);
+        var pj = Math.floor((codeblock.tby0_ - subband.tby0) / precinctParameters.precinctHeightInSubband);
+        precinctNumber = pi + pj * precinctParameters.numprecinctswide;
+        codeblock.precinctNumber = precinctNumber;
+        codeblock.subbandType = subband.type;
+        codeblock.Lblock = 3;
+
+        if (codeblock.tbx1_ <= codeblock.tbx0_ || codeblock.tby1_ <= codeblock.tby0_) {
+          continue;
+        }
+
+        codeblocks.push(codeblock);
+        var precinct = precincts[precinctNumber];
+
+        if (precinct !== undefined) {
+          if (i < precinct.cbxMin) {
+            precinct.cbxMin = i;
+          } else if (i > precinct.cbxMax) {
+            precinct.cbxMax = i;
+          }
+
+          if (j < precinct.cbyMin) {
+            precinct.cbxMin = j;
+          } else if (j > precinct.cbyMax) {
+            precinct.cbyMax = j;
+          }
+        } else {
+          precincts[precinctNumber] = precinct = {
+            cbxMin: i,
+            cbyMin: j,
+            cbxMax: i,
+            cbyMax: j
+          };
+        }
+
+        codeblock.precinct = precinct;
+      }
+    }
+
+    subband.codeblockParameters = {
+      codeblockWidth: xcb_,
+      codeblockHeight: ycb_,
+      numcodeblockwide: cbx1 - cbx0 + 1,
+      numcodeblockhigh: cby1 - cby0 + 1
+    };
+    subband.codeblocks = codeblocks;
+    subband.precincts = precincts;
+  }
+
+  function createPacket(resolution, precinctNumber, layerNumber) {
+    var precinctCodeblocks = [];
+    var subbands = resolution.subbands;
+
+    for (var i = 0, ii = subbands.length; i < ii; i++) {
+      var subband = subbands[i];
+      var codeblocks = subband.codeblocks;
+
+      for (var j = 0, jj = codeblocks.length; j < jj; j++) {
+        var codeblock = codeblocks[j];
+
+        if (codeblock.precinctNumber !== precinctNumber) {
+          continue;
+        }
+
+        precinctCodeblocks.push(codeblock);
+      }
+    }
+
+    return {
+      layerNumber,
+      codeblocks: precinctCodeblocks
+    };
+  }
+
+  function LayerResolutionComponentPositionIterator(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var layersCount = tile.codingStyleDefaultParameters.layersCount;
+    var componentsCount = siz.Csiz;
+    var maxDecompositionLevelsCount = 0;
+
+    for (var q = 0; q < componentsCount; q++) {
+      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
+    }
+
+    var l = 0,
+        r = 0,
+        i = 0,
+        k = 0;
+
+    this.nextPacket = function JpxImage_nextPacket() {
+      for (; l < layersCount; l++) {
+        for (; r <= maxDecompositionLevelsCount; r++) {
+          for (; i < componentsCount; i++) {
+            var component = tile.components[i];
+
+            if (r > component.codingStyleParameters.decompositionLevelsCount) {
+              continue;
+            }
+
+            var resolution = component.resolutions[r];
+            var numprecincts = resolution.precinctParameters.numprecincts;
+
+            for (; k < numprecincts;) {
+              var packet = createPacket(resolution, k, l);
+              k++;
+              return packet;
+            }
+
+            k = 0;
+          }
+
+          i = 0;
+        }
+
+        r = 0;
+      }
+
+      throw new JpxError("Out of packets");
+    };
+  }
+
+  function ResolutionLayerComponentPositionIterator(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var layersCount = tile.codingStyleDefaultParameters.layersCount;
+    var componentsCount = siz.Csiz;
+    var maxDecompositionLevelsCount = 0;
+
+    for (var q = 0; q < componentsCount; q++) {
+      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
+    }
+
+    var r = 0,
+        l = 0,
+        i = 0,
+        k = 0;
+
+    this.nextPacket = function JpxImage_nextPacket() {
+      for (; r <= maxDecompositionLevelsCount; r++) {
+        for (; l < layersCount; l++) {
+          for (; i < componentsCount; i++) {
+            var component = tile.components[i];
+
+            if (r > component.codingStyleParameters.decompositionLevelsCount) {
+              continue;
+            }
+
+            var resolution = component.resolutions[r];
+            var numprecincts = resolution.precinctParameters.numprecincts;
+
+            for (; k < numprecincts;) {
+              var packet = createPacket(resolution, k, l);
+              k++;
+              return packet;
+            }
+
+            k = 0;
+          }
+
+          i = 0;
+        }
+
+        l = 0;
+      }
+
+      throw new JpxError("Out of packets");
+    };
+  }
+
+  function ResolutionPositionComponentLayerIterator(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var layersCount = tile.codingStyleDefaultParameters.layersCount;
+    var componentsCount = siz.Csiz;
+    var l, r, c, p;
+    var maxDecompositionLevelsCount = 0;
+
+    for (c = 0; c < componentsCount; c++) {
+      const component = tile.components[c];
+      maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, component.codingStyleParameters.decompositionLevelsCount);
+    }
+
+    var maxNumPrecinctsInLevel = new Int32Array(maxDecompositionLevelsCount + 1);
+
+    for (r = 0; r <= maxDecompositionLevelsCount; ++r) {
+      var maxNumPrecincts = 0;
+
+      for (c = 0; c < componentsCount; ++c) {
+        var resolutions = tile.components[c].resolutions;
+
+        if (r < resolutions.length) {
+          maxNumPrecincts = Math.max(maxNumPrecincts, resolutions[r].precinctParameters.numprecincts);
+        }
+      }
+
+      maxNumPrecinctsInLevel[r] = maxNumPrecincts;
+    }
+
+    l = 0;
+    r = 0;
+    c = 0;
+    p = 0;
+
+    this.nextPacket = function JpxImage_nextPacket() {
+      for (; r <= maxDecompositionLevelsCount; r++) {
+        for (; p < maxNumPrecinctsInLevel[r]; p++) {
+          for (; c < componentsCount; c++) {
+            const component = tile.components[c];
+
+            if (r > component.codingStyleParameters.decompositionLevelsCount) {
+              continue;
+            }
+
+            var resolution = component.resolutions[r];
+            var numprecincts = resolution.precinctParameters.numprecincts;
+
+            if (p >= numprecincts) {
+              continue;
+            }
+
+            for (; l < layersCount;) {
+              var packet = createPacket(resolution, p, l);
+              l++;
+              return packet;
+            }
+
+            l = 0;
+          }
+
+          c = 0;
+        }
+
+        p = 0;
+      }
+
+      throw new JpxError("Out of packets");
+    };
+  }
+
+  function PositionComponentResolutionLayerIterator(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var layersCount = tile.codingStyleDefaultParameters.layersCount;
+    var componentsCount = siz.Csiz;
+    var precinctsSizes = getPrecinctSizesInImageScale(tile);
+    var precinctsIterationSizes = precinctsSizes;
+    var l = 0,
+        r = 0,
+        c = 0,
+        px = 0,
+        py = 0;
+
+    this.nextPacket = function JpxImage_nextPacket() {
+      for (; py < precinctsIterationSizes.maxNumHigh; py++) {
+        for (; px < precinctsIterationSizes.maxNumWide; px++) {
+          for (; c < componentsCount; c++) {
+            var component = tile.components[c];
+            var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+
+            for (; r <= decompositionLevelsCount; r++) {
+              var resolution = component.resolutions[r];
+              var sizeInImageScale = precinctsSizes.components[c].resolutions[r];
+              var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+
+              if (k === null) {
+                continue;
+              }
+
+              for (; l < layersCount;) {
+                var packet = createPacket(resolution, k, l);
+                l++;
+                return packet;
+              }
+
+              l = 0;
+            }
+
+            r = 0;
+          }
+
+          c = 0;
+        }
+
+        px = 0;
+      }
+
+      throw new JpxError("Out of packets");
+    };
+  }
+
+  function ComponentPositionResolutionLayerIterator(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var layersCount = tile.codingStyleDefaultParameters.layersCount;
+    var componentsCount = siz.Csiz;
+    var precinctsSizes = getPrecinctSizesInImageScale(tile);
+    var l = 0,
+        r = 0,
+        c = 0,
+        px = 0,
+        py = 0;
+
+    this.nextPacket = function JpxImage_nextPacket() {
+      for (; c < componentsCount; ++c) {
+        var component = tile.components[c];
+        var precinctsIterationSizes = precinctsSizes.components[c];
+        var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+
+        for (; py < precinctsIterationSizes.maxNumHigh; py++) {
+          for (; px < precinctsIterationSizes.maxNumWide; px++) {
+            for (; r <= decompositionLevelsCount; r++) {
+              var resolution = component.resolutions[r];
+              var sizeInImageScale = precinctsIterationSizes.resolutions[r];
+              var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+
+              if (k === null) {
+                continue;
+              }
+
+              for (; l < layersCount;) {
+                var packet = createPacket(resolution, k, l);
+                l++;
+                return packet;
+              }
+
+              l = 0;
+            }
+
+            r = 0;
+          }
+
+          px = 0;
+        }
+
+        py = 0;
+      }
+
+      throw new JpxError("Out of packets");
+    };
+  }
+
+  function getPrecinctIndexIfExist(pxIndex, pyIndex, sizeInImageScale, precinctIterationSizes, resolution) {
+    var posX = pxIndex * precinctIterationSizes.minWidth;
+    var posY = pyIndex * precinctIterationSizes.minHeight;
+
+    if (posX % sizeInImageScale.width !== 0 || posY % sizeInImageScale.height !== 0) {
+      return null;
+    }
+
+    var startPrecinctRowIndex = posY / sizeInImageScale.width * resolution.precinctParameters.numprecinctswide;
+    return posX / sizeInImageScale.height + startPrecinctRowIndex;
+  }
+
+  function getPrecinctSizesInImageScale(tile) {
+    var componentsCount = tile.components.length;
+    var minWidth = Number.MAX_VALUE;
+    var minHeight = Number.MAX_VALUE;
+    var maxNumWide = 0;
+    var maxNumHigh = 0;
+    var sizePerComponent = new Array(componentsCount);
+
+    for (var c = 0; c < componentsCount; c++) {
+      var component = tile.components[c];
+      var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+      var sizePerResolution = new Array(decompositionLevelsCount + 1);
+      var minWidthCurrentComponent = Number.MAX_VALUE;
+      var minHeightCurrentComponent = Number.MAX_VALUE;
+      var maxNumWideCurrentComponent = 0;
+      var maxNumHighCurrentComponent = 0;
+      var scale = 1;
+
+      for (var r = decompositionLevelsCount; r >= 0; --r) {
+        var resolution = component.resolutions[r];
+        var widthCurrentResolution = scale * resolution.precinctParameters.precinctWidth;
+        var heightCurrentResolution = scale * resolution.precinctParameters.precinctHeight;
+        minWidthCurrentComponent = Math.min(minWidthCurrentComponent, widthCurrentResolution);
+        minHeightCurrentComponent = Math.min(minHeightCurrentComponent, heightCurrentResolution);
+        maxNumWideCurrentComponent = Math.max(maxNumWideCurrentComponent, resolution.precinctParameters.numprecinctswide);
+        maxNumHighCurrentComponent = Math.max(maxNumHighCurrentComponent, resolution.precinctParameters.numprecinctshigh);
+        sizePerResolution[r] = {
+          width: widthCurrentResolution,
+          height: heightCurrentResolution
+        };
+        scale <<= 1;
+      }
+
+      minWidth = Math.min(minWidth, minWidthCurrentComponent);
+      minHeight = Math.min(minHeight, minHeightCurrentComponent);
+      maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent);
+      maxNumHigh = Math.max(maxNumHigh, maxNumHighCurrentComponent);
+      sizePerComponent[c] = {
+        resolutions: sizePerResolution,
+        minWidth: minWidthCurrentComponent,
+        minHeight: minHeightCurrentComponent,
+        maxNumWide: maxNumWideCurrentComponent,
+        maxNumHigh: maxNumHighCurrentComponent
+      };
+    }
+
+    return {
+      components: sizePerComponent,
+      minWidth,
+      minHeight,
+      maxNumWide,
+      maxNumHigh
+    };
+  }
+
+  function buildPackets(context) {
+    var siz = context.SIZ;
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var componentsCount = siz.Csiz;
+
+    for (var c = 0; c < componentsCount; c++) {
+      var component = tile.components[c];
+      var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+      var resolutions = [];
+      var subbands = [];
+
+      for (var r = 0; r <= decompositionLevelsCount; r++) {
+        var blocksDimensions = getBlocksDimensions(context, component, r);
+        var resolution = {};
+        var scale = 1 << decompositionLevelsCount - r;
+        resolution.trx0 = Math.ceil(component.tcx0 / scale);
+        resolution.try0 = Math.ceil(component.tcy0 / scale);
+        resolution.trx1 = Math.ceil(component.tcx1 / scale);
+        resolution.try1 = Math.ceil(component.tcy1 / scale);
+        resolution.resLevel = r;
+        buildPrecincts(context, resolution, blocksDimensions);
+        resolutions.push(resolution);
+        var subband;
+
+        if (r === 0) {
+          subband = {};
+          subband.type = "LL";
+          subband.tbx0 = Math.ceil(component.tcx0 / scale);
+          subband.tby0 = Math.ceil(component.tcy0 / scale);
+          subband.tbx1 = Math.ceil(component.tcx1 / scale);
+          subband.tby1 = Math.ceil(component.tcy1 / scale);
+          subband.resolution = resolution;
+          buildCodeblocks(context, subband, blocksDimensions);
+          subbands.push(subband);
+          resolution.subbands = [subband];
+        } else {
+          var bscale = 1 << decompositionLevelsCount - r + 1;
+          var resolutionSubbands = [];
+          subband = {};
+          subband.type = "HL";
+          subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
+          subband.tby0 = Math.ceil(component.tcy0 / bscale);
+          subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
+          subband.tby1 = Math.ceil(component.tcy1 / bscale);
+          subband.resolution = resolution;
+          buildCodeblocks(context, subband, blocksDimensions);
+          subbands.push(subband);
+          resolutionSubbands.push(subband);
+          subband = {};
+          subband.type = "LH";
+          subband.tbx0 = Math.ceil(component.tcx0 / bscale);
+          subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
+          subband.tbx1 = Math.ceil(component.tcx1 / bscale);
+          subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
+          subband.resolution = resolution;
+          buildCodeblocks(context, subband, blocksDimensions);
+          subbands.push(subband);
+          resolutionSubbands.push(subband);
+          subband = {};
+          subband.type = "HH";
+          subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
+          subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
+          subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
+          subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
+          subband.resolution = resolution;
+          buildCodeblocks(context, subband, blocksDimensions);
+          subbands.push(subband);
+          resolutionSubbands.push(subband);
+          resolution.subbands = resolutionSubbands;
+        }
+      }
+
+      component.resolutions = resolutions;
+      component.subbands = subbands;
+    }
+
+    var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder;
+
+    switch (progressionOrder) {
+      case 0:
+        tile.packetsIterator = new LayerResolutionComponentPositionIterator(context);
+        break;
+
+      case 1:
+        tile.packetsIterator = new ResolutionLayerComponentPositionIterator(context);
+        break;
+
+      case 2:
+        tile.packetsIterator = new ResolutionPositionComponentLayerIterator(context);
+        break;
+
+      case 3:
+        tile.packetsIterator = new PositionComponentResolutionLayerIterator(context);
+        break;
+
+      case 4:
+        tile.packetsIterator = new ComponentPositionResolutionLayerIterator(context);
+        break;
+
+      default:
+        throw new JpxError(`Unsupported progression order ${progressionOrder}`);
+    }
+  }
+
+  function parseTilePackets(context, data, offset, dataLength) {
+    var position = 0;
+    var buffer,
+        bufferSize = 0,
+        skipNextBit = false;
+
+    function readBits(count) {
+      while (bufferSize < count) {
+        var b = data[offset + position];
+        position++;
+
+        if (skipNextBit) {
+          buffer = buffer << 7 | b;
+          bufferSize += 7;
+          skipNextBit = false;
+        } else {
+          buffer = buffer << 8 | b;
+          bufferSize += 8;
+        }
+
+        if (b === 0xff) {
+          skipNextBit = true;
+        }
+      }
+
+      bufferSize -= count;
+      return buffer >>> bufferSize & (1 << count) - 1;
+    }
+
+    function skipMarkerIfEqual(value) {
+      if (data[offset + position - 1] === 0xff && data[offset + position] === value) {
+        skipBytes(1);
+        return true;
+      } else if (data[offset + position] === 0xff && data[offset + position + 1] === value) {
+        skipBytes(2);
+        return true;
+      }
+
+      return false;
+    }
+
+    function skipBytes(count) {
+      position += count;
+    }
+
+    function alignToByte() {
+      bufferSize = 0;
+
+      if (skipNextBit) {
+        position++;
+        skipNextBit = false;
+      }
+    }
+
+    function readCodingpasses() {
+      if (readBits(1) === 0) {
+        return 1;
+      }
+
+      if (readBits(1) === 0) {
+        return 2;
+      }
+
+      var value = readBits(2);
+
+      if (value < 3) {
+        return value + 3;
+      }
+
+      value = readBits(5);
+
+      if (value < 31) {
+        return value + 6;
+      }
+
+      value = readBits(7);
+      return value + 37;
+    }
+
+    var tileIndex = context.currentTile.index;
+    var tile = context.tiles[tileIndex];
+    var sopMarkerUsed = context.COD.sopMarkerUsed;
+    var ephMarkerUsed = context.COD.ephMarkerUsed;
+    var packetsIterator = tile.packetsIterator;
+
+    while (position < dataLength) {
+      alignToByte();
+
+      if (sopMarkerUsed && skipMarkerIfEqual(0x91)) {
+        skipBytes(4);
+      }
+
+      var packet = packetsIterator.nextPacket();
+
+      if (!readBits(1)) {
+        continue;
+      }
+
+      var layerNumber = packet.layerNumber;
+      var queue = [],
+          codeblock;
+
+      for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {
+        codeblock = packet.codeblocks[i];
+        var precinct = codeblock.precinct;
+        var codeblockColumn = codeblock.cbx - precinct.cbxMin;
+        var codeblockRow = codeblock.cby - precinct.cbyMin;
+        var codeblockIncluded = false;
+        var firstTimeInclusion = false;
+        var valueReady;
+
+        if (codeblock.included !== undefined) {
+          codeblockIncluded = !!readBits(1);
+        } else {
+          precinct = codeblock.precinct;
+          var inclusionTree, zeroBitPlanesTree;
+
+          if (precinct.inclusionTree !== undefined) {
+            inclusionTree = precinct.inclusionTree;
+          } else {
+            var width = precinct.cbxMax - precinct.cbxMin + 1;
+            var height = precinct.cbyMax - precinct.cbyMin + 1;
+            inclusionTree = new InclusionTree(width, height, layerNumber);
+            zeroBitPlanesTree = new TagTree(width, height);
+            precinct.inclusionTree = inclusionTree;
+            precinct.zeroBitPlanesTree = zeroBitPlanesTree;
+          }
+
+          if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) {
+            while (true) {
+              if (readBits(1)) {
+                valueReady = !inclusionTree.nextLevel();
+
+                if (valueReady) {
+                  codeblock.included = true;
+                  codeblockIncluded = firstTimeInclusion = true;
+                  break;
+                }
+              } else {
+                inclusionTree.incrementValue(layerNumber);
+                break;
+              }
+            }
+          }
+        }
+
+        if (!codeblockIncluded) {
+          continue;
+        }
+
+        if (firstTimeInclusion) {
+          zeroBitPlanesTree = precinct.zeroBitPlanesTree;
+          zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);
+
+          while (true) {
+            if (readBits(1)) {
+              valueReady = !zeroBitPlanesTree.nextLevel();
+
+              if (valueReady) {
+                break;
+              }
+            } else {
+              zeroBitPlanesTree.incrementValue();
+            }
+          }
+
+          codeblock.zeroBitPlanes = zeroBitPlanesTree.value;
+        }
+
+        var codingpasses = readCodingpasses();
+
+        while (readBits(1)) {
+          codeblock.Lblock++;
+        }
+
+        var codingpassesLog2 = (0, _core_utils.log2)(codingpasses);
+        var bits = (codingpasses < 1 << codingpassesLog2 ? codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock;
+        var codedDataLength = readBits(bits);
+        queue.push({
+          codeblock,
+          codingpasses,
+          dataLength: codedDataLength
+        });
+      }
+
+      alignToByte();
+
+      if (ephMarkerUsed) {
+        skipMarkerIfEqual(0x92);
+      }
+
+      while (queue.length > 0) {
+        var packetItem = queue.shift();
+        codeblock = packetItem.codeblock;
+
+        if (codeblock.data === undefined) {
+          codeblock.data = [];
+        }
+
+        codeblock.data.push({
+          data,
+          start: offset + position,
+          end: offset + position + packetItem.dataLength,
+          codingpasses: packetItem.codingpasses
+        });
+        position += packetItem.dataLength;
+      }
+    }
+
+    return position;
+  }
+
+  function copyCoefficients(coefficients, levelWidth, levelHeight, subband, delta, mb, reversible, segmentationSymbolUsed) {
+    var x0 = subband.tbx0;
+    var y0 = subband.tby0;
+    var width = subband.tbx1 - subband.tbx0;
+    var codeblocks = subband.codeblocks;
+    var right = subband.type.charAt(0) === "H" ? 1 : 0;
+    var bottom = subband.type.charAt(1) === "H" ? levelWidth : 0;
+
+    for (var i = 0, ii = codeblocks.length; i < ii; ++i) {
+      var codeblock = codeblocks[i];
+      var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;
+      var blockHeight = codeblock.tby1_ - codeblock.tby0_;
+
+      if (blockWidth === 0 || blockHeight === 0) {
+        continue;
+      }
+
+      if (codeblock.data === undefined) {
+        continue;
+      }
+
+      var bitModel, currentCodingpassType;
+      bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType, codeblock.zeroBitPlanes, mb);
+      currentCodingpassType = 2;
+      var data = codeblock.data,
+          totalLength = 0,
+          codingpasses = 0;
+      var j, jj, dataItem;
+
+      for (j = 0, jj = data.length; j < jj; j++) {
+        dataItem = data[j];
+        totalLength += dataItem.end - dataItem.start;
+        codingpasses += dataItem.codingpasses;
+      }
+
+      var encodedData = new Uint8Array(totalLength);
+      var position = 0;
+
+      for (j = 0, jj = data.length; j < jj; j++) {
+        dataItem = data[j];
+        var chunk = dataItem.data.subarray(dataItem.start, dataItem.end);
+        encodedData.set(chunk, position);
+        position += chunk.length;
+      }
+
+      var decoder = new _arithmetic_decoder.ArithmeticDecoder(encodedData, 0, totalLength);
+      bitModel.setDecoder(decoder);
+
+      for (j = 0; j < codingpasses; j++) {
+        switch (currentCodingpassType) {
+          case 0:
+            bitModel.runSignificancePropagationPass();
+            break;
+
+          case 1:
+            bitModel.runMagnitudeRefinementPass();
+            break;
+
+          case 2:
+            bitModel.runCleanupPass();
+
+            if (segmentationSymbolUsed) {
+              bitModel.checkSegmentationSymbol();
+            }
+
+            break;
+        }
+
+        currentCodingpassType = (currentCodingpassType + 1) % 3;
+      }
+
+      var offset = codeblock.tbx0_ - x0 + (codeblock.tby0_ - y0) * width;
+      var sign = bitModel.coefficentsSign;
+      var magnitude = bitModel.coefficentsMagnitude;
+      var bitsDecoded = bitModel.bitsDecoded;
+      var magnitudeCorrection = reversible ? 0 : 0.5;
+      var k, n, nb;
+      position = 0;
+      var interleave = subband.type !== "LL";
+
+      for (j = 0; j < blockHeight; j++) {
+        var row = offset / width | 0;
+        var levelOffset = 2 * row * (levelWidth - width) + right + bottom;
+
+        for (k = 0; k < blockWidth; k++) {
+          n = magnitude[position];
+
+          if (n !== 0) {
+            n = (n + magnitudeCorrection) * delta;
+
+            if (sign[position] !== 0) {
+              n = -n;
+            }
+
+            nb = bitsDecoded[position];
+            var pos = interleave ? levelOffset + (offset << 1) : offset;
+
+            if (reversible && nb >= mb) {
+              coefficients[pos] = n;
+            } else {
+              coefficients[pos] = n * (1 << mb - nb);
+            }
+          }
+
+          offset++;
+          position++;
+        }
+
+        offset += width - blockWidth;
+      }
+    }
+  }
+
+  function transformTile(context, tile, c) {
+    var component = tile.components[c];
+    var codingStyleParameters = component.codingStyleParameters;
+    var quantizationParameters = component.quantizationParameters;
+    var decompositionLevelsCount = codingStyleParameters.decompositionLevelsCount;
+    var spqcds = quantizationParameters.SPqcds;
+    var scalarExpounded = quantizationParameters.scalarExpounded;
+    var guardBits = quantizationParameters.guardBits;
+    var segmentationSymbolUsed = codingStyleParameters.segmentationSymbolUsed;
+    var precision = context.components[c].precision;
+    var reversible = codingStyleParameters.reversibleTransformation;
+    var transform = reversible ? new ReversibleTransform() : new IrreversibleTransform();
+    var subbandCoefficients = [];
+    var b = 0;
+
+    for (var i = 0; i <= decompositionLevelsCount; i++) {
+      var resolution = component.resolutions[i];
+      var width = resolution.trx1 - resolution.trx0;
+      var height = resolution.try1 - resolution.try0;
+      var coefficients = new Float32Array(width * height);
+
+      for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {
+        var mu, epsilon;
+
+        if (!scalarExpounded) {
+          mu = spqcds[0].mu;
+          epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);
+        } else {
+          mu = spqcds[b].mu;
+          epsilon = spqcds[b].epsilon;
+          b++;
+        }
+
+        var subband = resolution.subbands[j];
+        var gainLog2 = SubbandsGainLog2[subband.type];
+        var delta = reversible ? 1 : 2 ** (precision + gainLog2 - epsilon) * (1 + mu / 2048);
+        var mb = guardBits + epsilon - 1;
+        copyCoefficients(coefficients, width, height, subband, delta, mb, reversible, segmentationSymbolUsed);
+      }
+
+      subbandCoefficients.push({
+        width,
+        height,
+        items: coefficients
+      });
+    }
+
+    var result = transform.calculate(subbandCoefficients, component.tcx0, component.tcy0);
+    return {
+      left: component.tcx0,
+      top: component.tcy0,
+      width: result.width,
+      height: result.height,
+      items: result.items
+    };
+  }
+
+  function transformComponents(context) {
+    var siz = context.SIZ;
+    var components = context.components;
+    var componentsCount = siz.Csiz;
+    var resultImages = [];
+
+    for (var i = 0, ii = context.tiles.length; i < ii; i++) {
+      var tile = context.tiles[i];
+      var transformedTiles = [];
+      var c;
+
+      for (c = 0; c < componentsCount; c++) {
+        transformedTiles[c] = transformTile(context, tile, c);
+      }
+
+      var tile0 = transformedTiles[0];
+      var out = new Uint8ClampedArray(tile0.items.length * componentsCount);
+      var result = {
+        left: tile0.left,
+        top: tile0.top,
+        width: tile0.width,
+        height: tile0.height,
+        items: out
+      };
+      var shift, offset;
+      var pos = 0,
+          j,
+          jj,
+          y0,
+          y1,
+          y2;
+
+      if (tile.codingStyleDefaultParameters.multipleComponentTransform) {
+        var fourComponents = componentsCount === 4;
+        var y0items = transformedTiles[0].items;
+        var y1items = transformedTiles[1].items;
+        var y2items = transformedTiles[2].items;
+        var y3items = fourComponents ? transformedTiles[3].items : null;
+        shift = components[0].precision - 8;
+        offset = (128 << shift) + 0.5;
+        var component0 = tile.components[0];
+        var alpha01 = componentsCount - 3;
+        jj = y0items.length;
+
+        if (!component0.codingStyleParameters.reversibleTransformation) {
+          for (j = 0; j < jj; j++, pos += alpha01) {
+            y0 = y0items[j] + offset;
+            y1 = y1items[j];
+            y2 = y2items[j];
+            out[pos++] = y0 + 1.402 * y2 >> shift;
+            out[pos++] = y0 - 0.34413 * y1 - 0.71414 * y2 >> shift;
+            out[pos++] = y0 + 1.772 * y1 >> shift;
+          }
+        } else {
+          for (j = 0; j < jj; j++, pos += alpha01) {
+            y0 = y0items[j] + offset;
+            y1 = y1items[j];
+            y2 = y2items[j];
+            const g = y0 - (y2 + y1 >> 2);
+            out[pos++] = g + y2 >> shift;
+            out[pos++] = g >> shift;
+            out[pos++] = g + y1 >> shift;
+          }
+        }
+
+        if (fourComponents) {
+          for (j = 0, pos = 3; j < jj; j++, pos += 4) {
+            out[pos] = y3items[j] + offset >> shift;
+          }
+        }
+      } else {
+        for (c = 0; c < componentsCount; c++) {
+          var items = transformedTiles[c].items;
+          shift = components[c].precision - 8;
+          offset = (128 << shift) + 0.5;
+
+          for (pos = c, j = 0, jj = items.length; j < jj; j++) {
+            out[pos] = items[j] + offset >> shift;
+            pos += componentsCount;
+          }
+        }
+      }
+
+      resultImages.push(result);
+    }
+
+    return resultImages;
+  }
+
+  function initializeTile(context, tileIndex) {
+    var siz = context.SIZ;
+    var componentsCount = siz.Csiz;
+    var tile = context.tiles[tileIndex];
+
+    for (var c = 0; c < componentsCount; c++) {
+      var component = tile.components[c];
+      var qcdOrQcc = context.currentTile.QCC[c] !== undefined ? context.currentTile.QCC[c] : context.currentTile.QCD;
+      component.quantizationParameters = qcdOrQcc;
+      var codOrCoc = context.currentTile.COC[c] !== undefined ? context.currentTile.COC[c] : context.currentTile.COD;
+      component.codingStyleParameters = codOrCoc;
+    }
+
+    tile.codingStyleDefaultParameters = context.currentTile.COD;
+  }
+
+  var TagTree = function TagTreeClosure() {
+    function TagTree(width, height) {
+      var levelsLength = (0, _core_utils.log2)(Math.max(width, height)) + 1;
+      this.levels = [];
+
+      for (var i = 0; i < levelsLength; i++) {
+        var level = {
+          width,
+          height,
+          items: []
+        };
+        this.levels.push(level);
+        width = Math.ceil(width / 2);
+        height = Math.ceil(height / 2);
+      }
+    }
+
+    TagTree.prototype = {
+      reset: function TagTree_reset(i, j) {
+        var currentLevel = 0,
+            value = 0,
+            level;
+
+        while (currentLevel < this.levels.length) {
+          level = this.levels[currentLevel];
+          var index = i + j * level.width;
+
+          if (level.items[index] !== undefined) {
+            value = level.items[index];
+            break;
+          }
+
+          level.index = index;
+          i >>= 1;
+          j >>= 1;
+          currentLevel++;
+        }
+
+        currentLevel--;
+        level = this.levels[currentLevel];
+        level.items[level.index] = value;
+        this.currentLevel = currentLevel;
+        delete this.value;
+      },
+      incrementValue: function TagTree_incrementValue() {
+        var level = this.levels[this.currentLevel];
+        level.items[level.index]++;
+      },
+      nextLevel: function TagTree_nextLevel() {
+        var currentLevel = this.currentLevel;
+        var level = this.levels[currentLevel];
+        var value = level.items[level.index];
+        currentLevel--;
+
+        if (currentLevel < 0) {
+          this.value = value;
+          return false;
+        }
+
+        this.currentLevel = currentLevel;
+        level = this.levels[currentLevel];
+        level.items[level.index] = value;
+        return true;
+      }
+    };
+    return TagTree;
+  }();
+
+  var InclusionTree = function InclusionTreeClosure() {
+    function InclusionTree(width, height, defaultValue) {
+      var levelsLength = (0, _core_utils.log2)(Math.max(width, height)) + 1;
+      this.levels = [];
+
+      for (var i = 0; i < levelsLength; i++) {
+        var items = new Uint8Array(width * height);
+
+        for (var j = 0, jj = items.length; j < jj; j++) {
+          items[j] = defaultValue;
+        }
+
+        var level = {
+          width,
+          height,
+          items
+        };
+        this.levels.push(level);
+        width = Math.ceil(width / 2);
+        height = Math.ceil(height / 2);
+      }
+    }
+
+    InclusionTree.prototype = {
+      reset: function InclusionTree_reset(i, j, stopValue) {
+        var currentLevel = 0;
+
+        while (currentLevel < this.levels.length) {
+          var level = this.levels[currentLevel];
+          var index = i + j * level.width;
+          level.index = index;
+          var value = level.items[index];
+
+          if (value === 0xff) {
+            break;
+          }
+
+          if (value > stopValue) {
+            this.currentLevel = currentLevel;
+            this.propagateValues();
+            return false;
+          }
+
+          i >>= 1;
+          j >>= 1;
+          currentLevel++;
+        }
+
+        this.currentLevel = currentLevel - 1;
+        return true;
+      },
+      incrementValue: function InclusionTree_incrementValue(stopValue) {
+        var level = this.levels[this.currentLevel];
+        level.items[level.index] = stopValue + 1;
+        this.propagateValues();
+      },
+      propagateValues: function InclusionTree_propagateValues() {
+        var levelIndex = this.currentLevel;
+        var level = this.levels[levelIndex];
+        var currentValue = level.items[level.index];
+
+        while (--levelIndex >= 0) {
+          level = this.levels[levelIndex];
+          level.items[level.index] = currentValue;
+        }
+      },
+      nextLevel: function InclusionTree_nextLevel() {
+        var currentLevel = this.currentLevel;
+        var level = this.levels[currentLevel];
+        var value = level.items[level.index];
+        level.items[level.index] = 0xff;
+        currentLevel--;
+
+        if (currentLevel < 0) {
+          return false;
+        }
+
+        this.currentLevel = currentLevel;
+        level = this.levels[currentLevel];
+        level.items[level.index] = value;
+        return true;
+      }
+    };
+    return InclusionTree;
+  }();
+
+  var BitModel = function BitModelClosure() {
+    var UNIFORM_CONTEXT = 17;
+    var RUNLENGTH_CONTEXT = 18;
+    var LLAndLHContextsLabel = new Uint8Array([0, 5, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 1, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8]);
+    var HLContextLabel = new Uint8Array([0, 3, 4, 0, 5, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 1, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8]);
+    var HHContextLabel = new Uint8Array([0, 1, 2, 0, 1, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 3, 4, 5, 0, 4, 5, 5, 0, 5, 5, 5, 0, 0, 0, 0, 0, 6, 7, 7, 0, 7, 7, 7, 0, 7, 7, 7, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8]);
+
+    function BitModel(width, height, subband, zeroBitPlanes, mb) {
+      this.width = width;
+      this.height = height;
+      let contextLabelTable;
+
+      if (subband === "HH") {
+        contextLabelTable = HHContextLabel;
+      } else if (subband === "HL") {
+        contextLabelTable = HLContextLabel;
+      } else {
+        contextLabelTable = LLAndLHContextsLabel;
+      }
+
+      this.contextLabelTable = contextLabelTable;
+      var coefficientCount = width * height;
+      this.neighborsSignificance = new Uint8Array(coefficientCount);
+      this.coefficentsSign = new Uint8Array(coefficientCount);
+      let coefficentsMagnitude;
+
+      if (mb > 14) {
+        coefficentsMagnitude = new Uint32Array(coefficientCount);
+      } else if (mb > 6) {
+        coefficentsMagnitude = new Uint16Array(coefficientCount);
+      } else {
+        coefficentsMagnitude = new Uint8Array(coefficientCount);
+      }
+
+      this.coefficentsMagnitude = coefficentsMagnitude;
+      this.processingFlags = new Uint8Array(coefficientCount);
+      var bitsDecoded = new Uint8Array(coefficientCount);
+
+      if (zeroBitPlanes !== 0) {
+        for (var i = 0; i < coefficientCount; i++) {
+          bitsDecoded[i] = zeroBitPlanes;
+        }
+      }
+
+      this.bitsDecoded = bitsDecoded;
+      this.reset();
+    }
+
+    BitModel.prototype = {
+      setDecoder: function BitModel_setDecoder(decoder) {
+        this.decoder = decoder;
+      },
+      reset: function BitModel_reset() {
+        this.contexts = new Int8Array(19);
+        this.contexts[0] = 4 << 1 | 0;
+        this.contexts[UNIFORM_CONTEXT] = 46 << 1 | 0;
+        this.contexts[RUNLENGTH_CONTEXT] = 3 << 1 | 0;
+      },
+      setNeighborsSignificance: function BitModel_setNeighborsSignificance(row, column, index) {
+        var neighborsSignificance = this.neighborsSignificance;
+        var width = this.width,
+            height = this.height;
+        var left = column > 0;
+        var right = column + 1 < width;
+        var i;
+
+        if (row > 0) {
+          i = index - width;
+
+          if (left) {
+            neighborsSignificance[i - 1] += 0x10;
+          }
+
+          if (right) {
+            neighborsSignificance[i + 1] += 0x10;
+          }
+
+          neighborsSignificance[i] += 0x04;
+        }
+
+        if (row + 1 < height) {
+          i = index + width;
+
+          if (left) {
+            neighborsSignificance[i - 1] += 0x10;
+          }
+
+          if (right) {
+            neighborsSignificance[i + 1] += 0x10;
+          }
+
+          neighborsSignificance[i] += 0x04;
+        }
+
+        if (left) {
+          neighborsSignificance[index - 1] += 0x01;
+        }
+
+        if (right) {
+          neighborsSignificance[index + 1] += 0x01;
+        }
+
+        neighborsSignificance[index] |= 0x80;
+      },
+      runSignificancePropagationPass: function BitModel_runSignificancePropagationPass() {
+        var decoder = this.decoder;
+        var width = this.width,
+            height = this.height;
+        var coefficentsMagnitude = this.coefficentsMagnitude;
+        var coefficentsSign = this.coefficentsSign;
+        var neighborsSignificance = this.neighborsSignificance;
+        var processingFlags = this.processingFlags;
+        var contexts = this.contexts;
+        var labels = this.contextLabelTable;
+        var bitsDecoded = this.bitsDecoded;
+        var processedInverseMask = ~1;
+        var processedMask = 1;
+        var firstMagnitudeBitMask = 2;
+
+        for (var i0 = 0; i0 < height; i0 += 4) {
+          for (var j = 0; j < width; j++) {
+            var index = i0 * width + j;
+
+            for (var i1 = 0; i1 < 4; i1++, index += width) {
+              var i = i0 + i1;
+
+              if (i >= height) {
+                break;
+              }
+
+              processingFlags[index] &= processedInverseMask;
+
+              if (coefficentsMagnitude[index] || !neighborsSignificance[index]) {
+                continue;
+              }
+
+              var contextLabel = labels[neighborsSignificance[index]];
+              var decision = decoder.readBit(contexts, contextLabel);
+
+              if (decision) {
+                var sign = this.decodeSignBit(i, j, index);
+                coefficentsSign[index] = sign;
+                coefficentsMagnitude[index] = 1;
+                this.setNeighborsSignificance(i, j, index);
+                processingFlags[index] |= firstMagnitudeBitMask;
+              }
+
+              bitsDecoded[index]++;
+              processingFlags[index] |= processedMask;
+            }
+          }
+        }
+      },
+      decodeSignBit: function BitModel_decodeSignBit(row, column, index) {
+        var width = this.width,
+            height = this.height;
+        var coefficentsMagnitude = this.coefficentsMagnitude;
+        var coefficentsSign = this.coefficentsSign;
+        var contribution, sign0, sign1, significance1;
+        var contextLabel, decoded;
+        significance1 = column > 0 && coefficentsMagnitude[index - 1] !== 0;
+
+        if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) {
+          sign1 = coefficentsSign[index + 1];
+
+          if (significance1) {
+            sign0 = coefficentsSign[index - 1];
+            contribution = 1 - sign1 - sign0;
+          } else {
+            contribution = 1 - sign1 - sign1;
+          }
+        } else if (significance1) {
+          sign0 = coefficentsSign[index - 1];
+          contribution = 1 - sign0 - sign0;
+        } else {
+          contribution = 0;
+        }
+
+        var horizontalContribution = 3 * contribution;
+        significance1 = row > 0 && coefficentsMagnitude[index - width] !== 0;
+
+        if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) {
+          sign1 = coefficentsSign[index + width];
+
+          if (significance1) {
+            sign0 = coefficentsSign[index - width];
+            contribution = 1 - sign1 - sign0 + horizontalContribution;
+          } else {
+            contribution = 1 - sign1 - sign1 + horizontalContribution;
+          }
+        } else if (significance1) {
+          sign0 = coefficentsSign[index - width];
+          contribution = 1 - sign0 - sign0 + horizontalContribution;
+        } else {
+          contribution = horizontalContribution;
+        }
+
+        if (contribution >= 0) {
+          contextLabel = 9 + contribution;
+          decoded = this.decoder.readBit(this.contexts, contextLabel);
+        } else {
+          contextLabel = 9 - contribution;
+          decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1;
+        }
+
+        return decoded;
+      },
+      runMagnitudeRefinementPass: function BitModel_runMagnitudeRefinementPass() {
+        var decoder = this.decoder;
+        var width = this.width,
+            height = this.height;
+        var coefficentsMagnitude = this.coefficentsMagnitude;
+        var neighborsSignificance = this.neighborsSignificance;
+        var contexts = this.contexts;
+        var bitsDecoded = this.bitsDecoded;
+        var processingFlags = this.processingFlags;
+        var processedMask = 1;
+        var firstMagnitudeBitMask = 2;
+        var length = width * height;
+        var width4 = width * 4;
+
+        for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) {
+          indexNext = Math.min(length, index0 + width4);
+
+          for (var j = 0; j < width; j++) {
+            for (var index = index0 + j; index < indexNext; index += width) {
+              if (!coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
+                continue;
+              }
+
+              var contextLabel = 16;
+
+              if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) {
+                processingFlags[index] ^= firstMagnitudeBitMask;
+                var significance = neighborsSignificance[index] & 127;
+                contextLabel = significance === 0 ? 15 : 14;
+              }
+
+              var bit = decoder.readBit(contexts, contextLabel);
+              coefficentsMagnitude[index] = coefficentsMagnitude[index] << 1 | bit;
+              bitsDecoded[index]++;
+              processingFlags[index] |= processedMask;
+            }
+          }
+        }
+      },
+      runCleanupPass: function BitModel_runCleanupPass() {
+        var decoder = this.decoder;
+        var width = this.width,
+            height = this.height;
+        var neighborsSignificance = this.neighborsSignificance;
+        var coefficentsMagnitude = this.coefficentsMagnitude;
+        var coefficentsSign = this.coefficentsSign;
+        var contexts = this.contexts;
+        var labels = this.contextLabelTable;
+        var bitsDecoded = this.bitsDecoded;
+        var processingFlags = this.processingFlags;
+        var processedMask = 1;
+        var firstMagnitudeBitMask = 2;
+        var oneRowDown = width;
+        var twoRowsDown = width * 2;
+        var threeRowsDown = width * 3;
+        var iNext;
+
+        for (var i0 = 0; i0 < height; i0 = iNext) {
+          iNext = Math.min(i0 + 4, height);
+          var indexBase = i0 * width;
+          var checkAllEmpty = i0 + 3 < height;
+
+          for (var j = 0; j < width; j++) {
+            var index0 = indexBase + j;
+            var allEmpty = checkAllEmpty && processingFlags[index0] === 0 && processingFlags[index0 + oneRowDown] === 0 && processingFlags[index0 + twoRowsDown] === 0 && processingFlags[index0 + threeRowsDown] === 0 && neighborsSignificance[index0] === 0 && neighborsSignificance[index0 + oneRowDown] === 0 && neighborsSignificance[index0 + twoRowsDown] === 0 && neighborsSignificance[index0 + threeRowsDown] === 0;
+            var i1 = 0,
+                index = index0;
+            var i = i0,
+                sign;
+
+            if (allEmpty) {
+              var hasSignificantCoefficent = decoder.readBit(contexts, RUNLENGTH_CONTEXT);
+
+              if (!hasSignificantCoefficent) {
+                bitsDecoded[index0]++;
+                bitsDecoded[index0 + oneRowDown]++;
+                bitsDecoded[index0 + twoRowsDown]++;
+                bitsDecoded[index0 + threeRowsDown]++;
+                continue;
+              }
+
+              i1 = decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
+
+              if (i1 !== 0) {
+                i = i0 + i1;
+                index += i1 * width;
+              }
+
+              sign = this.decodeSignBit(i, j, index);
+              coefficentsSign[index] = sign;
+              coefficentsMagnitude[index] = 1;
+              this.setNeighborsSignificance(i, j, index);
+              processingFlags[index] |= firstMagnitudeBitMask;
+              index = index0;
+
+              for (var i2 = i0; i2 <= i; i2++, index += width) {
+                bitsDecoded[index]++;
+              }
+
+              i1++;
+            }
+
+            for (i = i0 + i1; i < iNext; i++, index += width) {
+              if (coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
+                continue;
+              }
+
+              var contextLabel = labels[neighborsSignificance[index]];
+              var decision = decoder.readBit(contexts, contextLabel);
+
+              if (decision === 1) {
+                sign = this.decodeSignBit(i, j, index);
+                coefficentsSign[index] = sign;
+                coefficentsMagnitude[index] = 1;
+                this.setNeighborsSignificance(i, j, index);
+                processingFlags[index] |= firstMagnitudeBitMask;
+              }
+
+              bitsDecoded[index]++;
+            }
+          }
+        }
+      },
+      checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() {
+        var decoder = this.decoder;
+        var contexts = this.contexts;
+        var symbol = decoder.readBit(contexts, UNIFORM_CONTEXT) << 3 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 2 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
+
+        if (symbol !== 0xa) {
+          throw new JpxError("Invalid segmentation symbol");
+        }
+      }
+    };
+    return BitModel;
+  }();
+
+  var Transform = function TransformClosure() {
+    function Transform() {}
+
+    Transform.prototype.calculate = function transformCalculate(subbands, u0, v0) {
+      var ll = subbands[0];
+
+      for (var i = 1, ii = subbands.length; i < ii; i++) {
+        ll = this.iterate(ll, subbands[i], u0, v0);
+      }
+
+      return ll;
+    };
+
+    Transform.prototype.extend = function extend(buffer, offset, size) {
+      var i1 = offset - 1,
+          j1 = offset + 1;
+      var i2 = offset + size - 2,
+          j2 = offset + size;
+      buffer[i1--] = buffer[j1++];
+      buffer[j2++] = buffer[i2--];
+      buffer[i1--] = buffer[j1++];
+      buffer[j2++] = buffer[i2--];
+      buffer[i1--] = buffer[j1++];
+      buffer[j2++] = buffer[i2--];
+      buffer[i1] = buffer[j1];
+      buffer[j2] = buffer[i2];
+    };
+
+    Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh, u0, v0) {
+      var llWidth = ll.width,
+          llHeight = ll.height,
+          llItems = ll.items;
+      var width = hl_lh_hh.width;
+      var height = hl_lh_hh.height;
+      var items = hl_lh_hh.items;
+      var i, j, k, l, u, v;
+
+      for (k = 0, i = 0; i < llHeight; i++) {
+        l = i * 2 * width;
+
+        for (j = 0; j < llWidth; j++, k++, l += 2) {
+          items[l] = llItems[k];
+        }
+      }
+
+      llItems = ll.items = null;
+      var bufferPadding = 4;
+      var rowBuffer = new Float32Array(width + 2 * bufferPadding);
+
+      if (width === 1) {
+        if ((u0 & 1) !== 0) {
+          for (v = 0, k = 0; v < height; v++, k += width) {
+            items[k] *= 0.5;
+          }
+        }
+      } else {
+        for (v = 0, k = 0; v < height; v++, k += width) {
+          rowBuffer.set(items.subarray(k, k + width), bufferPadding);
+          this.extend(rowBuffer, bufferPadding, width);
+          this.filter(rowBuffer, bufferPadding, width);
+          items.set(rowBuffer.subarray(bufferPadding, bufferPadding + width), k);
+        }
+      }
+
+      var numBuffers = 16;
+      var colBuffers = [];
+
+      for (i = 0; i < numBuffers; i++) {
+        colBuffers.push(new Float32Array(height + 2 * bufferPadding));
+      }
+
+      var b,
+          currentBuffer = 0;
+      ll = bufferPadding + height;
+
+      if (height === 1) {
+        if ((v0 & 1) !== 0) {
+          for (u = 0; u < width; u++) {
+            items[u] *= 0.5;
+          }
+        }
+      } else {
+        for (u = 0; u < width; u++) {
+          if (currentBuffer === 0) {
+            numBuffers = Math.min(width - u, numBuffers);
+
+            for (k = u, l = bufferPadding; l < ll; k += width, l++) {
+              for (b = 0; b < numBuffers; b++) {
+                colBuffers[b][l] = items[k + b];
+              }
+            }
+
+            currentBuffer = numBuffers;
+          }
+
+          currentBuffer--;
+          var buffer = colBuffers[currentBuffer];
+          this.extend(buffer, bufferPadding, height);
+          this.filter(buffer, bufferPadding, height);
+
+          if (currentBuffer === 0) {
+            k = u - numBuffers + 1;
+
+            for (l = bufferPadding; l < ll; k += width, l++) {
+              for (b = 0; b < numBuffers; b++) {
+                items[k + b] = colBuffers[b][l];
+              }
+            }
+          }
+        }
+      }
+
+      return {
+        width,
+        height,
+        items
+      };
+    };
+
+    return Transform;
+  }();
+
+  var IrreversibleTransform = function IrreversibleTransformClosure() {
+    function IrreversibleTransform() {
+      Transform.call(this);
+    }
+
+    IrreversibleTransform.prototype = Object.create(Transform.prototype);
+
+    IrreversibleTransform.prototype.filter = function irreversibleTransformFilter(x, offset, length) {
+      var len = length >> 1;
+      offset = offset | 0;
+      var j, n, current, next;
+      var alpha = -1.586134342059924;
+      var beta = -0.052980118572961;
+      var gamma = 0.882911075530934;
+      var delta = 0.443506852043971;
+      var K = 1.230174104914001;
+      var K_ = 1 / K;
+      j = offset - 3;
+
+      for (n = len + 4; n--; j += 2) {
+        x[j] *= K_;
+      }
+
+      j = offset - 2;
+      current = delta * x[j - 1];
+
+      for (n = len + 3; n--; j += 2) {
+        next = delta * x[j + 1];
+        x[j] = K * x[j] - current - next;
+
+        if (n--) {
+          j += 2;
+          current = delta * x[j + 1];
+          x[j] = K * x[j] - current - next;
+        } else {
+          break;
+        }
+      }
+
+      j = offset - 1;
+      current = gamma * x[j - 1];
+
+      for (n = len + 2; n--; j += 2) {
+        next = gamma * x[j + 1];
+        x[j] -= current + next;
+
+        if (n--) {
+          j += 2;
+          current = gamma * x[j + 1];
+          x[j] -= current + next;
+        } else {
+          break;
+        }
+      }
+
+      j = offset;
+      current = beta * x[j - 1];
+
+      for (n = len + 1; n--; j += 2) {
+        next = beta * x[j + 1];
+        x[j] -= current + next;
+
+        if (n--) {
+          j += 2;
+          current = beta * x[j + 1];
+          x[j] -= current + next;
+        } else {
+          break;
+        }
+      }
+
+      if (len !== 0) {
+        j = offset + 1;
+        current = alpha * x[j - 1];
+
+        for (n = len; n--; j += 2) {
+          next = alpha * x[j + 1];
+          x[j] -= current + next;
+
+          if (n--) {
+            j += 2;
+            current = alpha * x[j + 1];
+            x[j] -= current + next;
+          } else {
+            break;
+          }
+        }
+      }
+    };
+
+    return IrreversibleTransform;
+  }();
+
+  var ReversibleTransform = function ReversibleTransformClosure() {
+    function ReversibleTransform() {
+      Transform.call(this);
+    }
+
+    ReversibleTransform.prototype = Object.create(Transform.prototype);
+
+    ReversibleTransform.prototype.filter = function reversibleTransformFilter(x, offset, length) {
+      var len = length >> 1;
+      offset = offset | 0;
+      var j, n;
+
+      for (j = offset, n = len + 1; n--; j += 2) {
+        x[j] -= x[j - 1] + x[j + 1] + 2 >> 2;
+      }
+
+      for (j = offset + 1, n = len; n--; j += 2) {
+        x[j] += x[j - 1] + x[j + 1] >> 1;
+      }
+    };
+
+    return ReversibleTransform;
+  }();
+
+  return JpxImage;
+}();
+
+exports.JpxImage = JpxImage;
+
+/***/ }),
+/* 22 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDF20 = exports.PDF17 = exports.CipherTransformFactory = exports.calculateSHA512 = exports.calculateSHA384 = exports.calculateSHA256 = exports.calculateMD5 = exports.ARCFourCipher = exports.AES256Cipher = exports.AES128Cipher = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _stream = __w_pdfjs_require__(12);
+
+var ARCFourCipher = function ARCFourCipherClosure() {
+  function ARCFourCipher(key) {
+    this.a = 0;
+    this.b = 0;
+    var s = new Uint8Array(256);
+    var i,
+        j = 0,
+        tmp,
+        keyLength = key.length;
+
+    for (i = 0; i < 256; ++i) {
+      s[i] = i;
+    }
+
+    for (i = 0; i < 256; ++i) {
+      tmp = s[i];
+      j = j + tmp + key[i % keyLength] & 0xff;
+      s[i] = s[j];
+      s[j] = tmp;
+    }
+
+    this.s = s;
+  }
+
+  ARCFourCipher.prototype = {
+    encryptBlock: function ARCFourCipher_encryptBlock(data) {
+      var i,
+          n = data.length,
+          tmp,
+          tmp2;
+      var a = this.a,
+          b = this.b,
+          s = this.s;
+      var output = new Uint8Array(n);
+
+      for (i = 0; i < n; ++i) {
+        a = a + 1 & 0xff;
+        tmp = s[a];
+        b = b + tmp & 0xff;
+        tmp2 = s[b];
+        s[a] = tmp2;
+        s[b] = tmp;
+        output[i] = data[i] ^ s[tmp + tmp2 & 0xff];
+      }
+
+      this.a = a;
+      this.b = b;
+      return output;
+    }
+  };
+  ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock;
+  ARCFourCipher.prototype.encrypt = ARCFourCipher.prototype.encryptBlock;
+  return ARCFourCipher;
+}();
+
+exports.ARCFourCipher = ARCFourCipher;
+
+var calculateMD5 = function calculateMD5Closure() {
+  var r = new Uint8Array([7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]);
+  var k = new Int32Array([-680876936, -389564586, 606105819, -1044525330, -176418897, 1200080426, -1473231341, -45705983, 1770035416, -1958414417, -42063, -1990404162, 1804603682, -40341101, -1502002290, 1236535329, -165796510, -1069501632, 643717713, -373897302, -701558691, 38016083, -660478335, -405537848, 568446438, -1019803690, -187363961, 1163531501, -1444681467, -51403784, 1735328473, -1926607734, -378558, -2022574463, 1839030562, -35309556, -1530992060, 1272893353, -155497632, -1094730640, 681279174, -358537222, -722521979, 76029189, -640364487, -421815835, 530742520, -995338651, -198630844, 1126891415, -1416354905, -57434055, 1700485571, -1894986606, -1051523, -2054922799, 1873313359, -30611744, -1560198380, 1309151649, -145523070, -1120210379, 718787259, -343485551]);
+
+  function hash(data, offset, length) {
+    var h0 = 1732584193,
+        h1 = -271733879,
+        h2 = -1732584194,
+        h3 = 271733878;
+    var paddedLength = length + 72 & ~63;
+    var padded = new Uint8Array(paddedLength);
+    var i, j, n;
+
+    for (i = 0; i < length; ++i) {
+      padded[i] = data[offset++];
+    }
+
+    padded[i++] = 0x80;
+    n = paddedLength - 8;
+
+    while (i < n) {
+      padded[i++] = 0;
+    }
+
+    padded[i++] = length << 3 & 0xff;
+    padded[i++] = length >> 5 & 0xff;
+    padded[i++] = length >> 13 & 0xff;
+    padded[i++] = length >> 21 & 0xff;
+    padded[i++] = length >>> 29 & 0xff;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    var w = new Int32Array(16);
+
+    for (i = 0; i < paddedLength;) {
+      for (j = 0; j < 16; ++j, i += 4) {
+        w[j] = padded[i] | padded[i + 1] << 8 | padded[i + 2] << 16 | padded[i + 3] << 24;
+      }
+
+      var a = h0,
+          b = h1,
+          c = h2,
+          d = h3,
+          f,
+          g;
+
+      for (j = 0; j < 64; ++j) {
+        if (j < 16) {
+          f = b & c | ~b & d;
+          g = j;
+        } else if (j < 32) {
+          f = d & b | ~d & c;
+          g = 5 * j + 1 & 15;
+        } else if (j < 48) {
+          f = b ^ c ^ d;
+          g = 3 * j + 5 & 15;
+        } else {
+          f = c ^ (b | ~d);
+          g = 7 * j & 15;
+        }
+
+        var tmp = d,
+            rotateArg = a + f + k[j] + w[g] | 0,
+            rotate = r[j];
+        d = c;
+        c = b;
+        b = b + (rotateArg << rotate | rotateArg >>> 32 - rotate) | 0;
+        a = tmp;
+      }
+
+      h0 = h0 + a | 0;
+      h1 = h1 + b | 0;
+      h2 = h2 + c | 0;
+      h3 = h3 + d | 0;
+    }
+
+    return new Uint8Array([h0 & 0xFF, h0 >> 8 & 0xFF, h0 >> 16 & 0xFF, h0 >>> 24 & 0xFF, h1 & 0xFF, h1 >> 8 & 0xFF, h1 >> 16 & 0xFF, h1 >>> 24 & 0xFF, h2 & 0xFF, h2 >> 8 & 0xFF, h2 >> 16 & 0xFF, h2 >>> 24 & 0xFF, h3 & 0xFF, h3 >> 8 & 0xFF, h3 >> 16 & 0xFF, h3 >>> 24 & 0xFF]);
+  }
+
+  return hash;
+}();
+
+exports.calculateMD5 = calculateMD5;
+
+var Word64 = function Word64Closure() {
+  function Word64(highInteger, lowInteger) {
+    this.high = highInteger | 0;
+    this.low = lowInteger | 0;
+  }
+
+  Word64.prototype = {
+    and: function Word64_and(word) {
+      this.high &= word.high;
+      this.low &= word.low;
+    },
+    xor: function Word64_xor(word) {
+      this.high ^= word.high;
+      this.low ^= word.low;
+    },
+    or: function Word64_or(word) {
+      this.high |= word.high;
+      this.low |= word.low;
+    },
+    shiftRight: function Word64_shiftRight(places) {
+      if (places >= 32) {
+        this.low = this.high >>> places - 32 | 0;
+        this.high = 0;
+      } else {
+        this.low = this.low >>> places | this.high << 32 - places;
+        this.high = this.high >>> places | 0;
+      }
+    },
+    shiftLeft: function Word64_shiftLeft(places) {
+      if (places >= 32) {
+        this.high = this.low << places - 32;
+        this.low = 0;
+      } else {
+        this.high = this.high << places | this.low >>> 32 - places;
+        this.low = this.low << places;
+      }
+    },
+    rotateRight: function Word64_rotateRight(places) {
+      var low, high;
+
+      if (places & 32) {
+        high = this.low;
+        low = this.high;
+      } else {
+        low = this.low;
+        high = this.high;
+      }
+
+      places &= 31;
+      this.low = low >>> places | high << 32 - places;
+      this.high = high >>> places | low << 32 - places;
+    },
+    not: function Word64_not() {
+      this.high = ~this.high;
+      this.low = ~this.low;
+    },
+    add: function Word64_add(word) {
+      var lowAdd = (this.low >>> 0) + (word.low >>> 0);
+      var highAdd = (this.high >>> 0) + (word.high >>> 0);
+
+      if (lowAdd > 0xffffffff) {
+        highAdd += 1;
+      }
+
+      this.low = lowAdd | 0;
+      this.high = highAdd | 0;
+    },
+    copyTo: function Word64_copyTo(bytes, offset) {
+      bytes[offset] = this.high >>> 24 & 0xff;
+      bytes[offset + 1] = this.high >> 16 & 0xff;
+      bytes[offset + 2] = this.high >> 8 & 0xff;
+      bytes[offset + 3] = this.high & 0xff;
+      bytes[offset + 4] = this.low >>> 24 & 0xff;
+      bytes[offset + 5] = this.low >> 16 & 0xff;
+      bytes[offset + 6] = this.low >> 8 & 0xff;
+      bytes[offset + 7] = this.low & 0xff;
+    },
+    assign: function Word64_assign(word) {
+      this.high = word.high;
+      this.low = word.low;
+    }
+  };
+  return Word64;
+}();
+
+var calculateSHA256 = function calculateSHA256Closure() {
+  function rotr(x, n) {
+    return x >>> n | x << 32 - n;
+  }
+
+  function ch(x, y, z) {
+    return x & y ^ ~x & z;
+  }
+
+  function maj(x, y, z) {
+    return x & y ^ x & z ^ y & z;
+  }
+
+  function sigma(x) {
+    return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+  }
+
+  function sigmaPrime(x) {
+    return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+  }
+
+  function littleSigma(x) {
+    return rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3;
+  }
+
+  function littleSigmaPrime(x) {
+    return rotr(x, 17) ^ rotr(x, 19) ^ x >>> 10;
+  }
+
+  var k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
+
+  function hash(data, offset, length) {
+    var h0 = 0x6a09e667,
+        h1 = 0xbb67ae85,
+        h2 = 0x3c6ef372,
+        h3 = 0xa54ff53a,
+        h4 = 0x510e527f,
+        h5 = 0x9b05688c,
+        h6 = 0x1f83d9ab,
+        h7 = 0x5be0cd19;
+    var paddedLength = Math.ceil((length + 9) / 64) * 64;
+    var padded = new Uint8Array(paddedLength);
+    var i, j, n;
+
+    for (i = 0; i < length; ++i) {
+      padded[i] = data[offset++];
+    }
+
+    padded[i++] = 0x80;
+    n = paddedLength - 8;
+
+    while (i < n) {
+      padded[i++] = 0;
+    }
+
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = length >>> 29 & 0xff;
+    padded[i++] = length >> 21 & 0xff;
+    padded[i++] = length >> 13 & 0xff;
+    padded[i++] = length >> 5 & 0xff;
+    padded[i++] = length << 3 & 0xff;
+    var w = new Uint32Array(64);
+
+    for (i = 0; i < paddedLength;) {
+      for (j = 0; j < 16; ++j) {
+        w[j] = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
+        i += 4;
+      }
+
+      for (j = 16; j < 64; ++j) {
+        w[j] = littleSigmaPrime(w[j - 2]) + w[j - 7] + littleSigma(w[j - 15]) + w[j - 16] | 0;
+      }
+
+      var a = h0,
+          b = h1,
+          c = h2,
+          d = h3,
+          e = h4,
+          f = h5,
+          g = h6,
+          h = h7,
+          t1,
+          t2;
+
+      for (j = 0; j < 64; ++j) {
+        t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j];
+        t2 = sigma(a) + maj(a, b, c);
+        h = g;
+        g = f;
+        f = e;
+        e = d + t1 | 0;
+        d = c;
+        c = b;
+        b = a;
+        a = t1 + t2 | 0;
+      }
+
+      h0 = h0 + a | 0;
+      h1 = h1 + b | 0;
+      h2 = h2 + c | 0;
+      h3 = h3 + d | 0;
+      h4 = h4 + e | 0;
+      h5 = h5 + f | 0;
+      h6 = h6 + g | 0;
+      h7 = h7 + h | 0;
+    }
+
+    return new Uint8Array([h0 >> 24 & 0xFF, h0 >> 16 & 0xFF, h0 >> 8 & 0xFF, h0 & 0xFF, h1 >> 24 & 0xFF, h1 >> 16 & 0xFF, h1 >> 8 & 0xFF, h1 & 0xFF, h2 >> 24 & 0xFF, h2 >> 16 & 0xFF, h2 >> 8 & 0xFF, h2 & 0xFF, h3 >> 24 & 0xFF, h3 >> 16 & 0xFF, h3 >> 8 & 0xFF, h3 & 0xFF, h4 >> 24 & 0xFF, h4 >> 16 & 0xFF, h4 >> 8 & 0xFF, h4 & 0xFF, h5 >> 24 & 0xFF, h5 >> 16 & 0xFF, h5 >> 8 & 0xFF, h5 & 0xFF, h6 >> 24 & 0xFF, h6 >> 16 & 0xFF, h6 >> 8 & 0xFF, h6 & 0xFF, h7 >> 24 & 0xFF, h7 >> 16 & 0xFF, h7 >> 8 & 0xFF, h7 & 0xFF]);
+  }
+
+  return hash;
+}();
+
+exports.calculateSHA256 = calculateSHA256;
+
+var calculateSHA512 = function calculateSHA512Closure() {
+  function ch(result, x, y, z, tmp) {
+    result.assign(x);
+    result.and(y);
+    tmp.assign(x);
+    tmp.not();
+    tmp.and(z);
+    result.xor(tmp);
+  }
+
+  function maj(result, x, y, z, tmp) {
+    result.assign(x);
+    result.and(y);
+    tmp.assign(x);
+    tmp.and(z);
+    result.xor(tmp);
+    tmp.assign(y);
+    tmp.and(z);
+    result.xor(tmp);
+  }
+
+  function sigma(result, x, tmp) {
+    result.assign(x);
+    result.rotateRight(28);
+    tmp.assign(x);
+    tmp.rotateRight(34);
+    result.xor(tmp);
+    tmp.assign(x);
+    tmp.rotateRight(39);
+    result.xor(tmp);
+  }
+
+  function sigmaPrime(result, x, tmp) {
+    result.assign(x);
+    result.rotateRight(14);
+    tmp.assign(x);
+    tmp.rotateRight(18);
+    result.xor(tmp);
+    tmp.assign(x);
+    tmp.rotateRight(41);
+    result.xor(tmp);
+  }
+
+  function littleSigma(result, x, tmp) {
+    result.assign(x);
+    result.rotateRight(1);
+    tmp.assign(x);
+    tmp.rotateRight(8);
+    result.xor(tmp);
+    tmp.assign(x);
+    tmp.shiftRight(7);
+    result.xor(tmp);
+  }
+
+  function littleSigmaPrime(result, x, tmp) {
+    result.assign(x);
+    result.rotateRight(19);
+    tmp.assign(x);
+    tmp.rotateRight(61);
+    result.xor(tmp);
+    tmp.assign(x);
+    tmp.shiftRight(6);
+    result.xor(tmp);
+  }
+
+  var k = [new Word64(0x428a2f98, 0xd728ae22), new Word64(0x71374491, 0x23ef65cd), new Word64(0xb5c0fbcf, 0xec4d3b2f), new Word64(0xe9b5dba5, 0x8189dbbc), new Word64(0x3956c25b, 0xf348b538), new Word64(0x59f111f1, 0xb605d019), new Word64(0x923f82a4, 0xaf194f9b), new Word64(0xab1c5ed5, 0xda6d8118), new Word64(0xd807aa98, 0xa3030242), new Word64(0x12835b01, 0x45706fbe), new Word64(0x243185be, 0x4ee4b28c), new Word64(0x550c7dc3, 0xd5ffb4e2), new Word64(0x72be5d74, 0xf27b896f), new Word64(0x80deb1fe, 0x3b1696b1), new Word64(0x9bdc06a7, 0x25c71235), new Word64(0xc19bf174, 0xcf692694), new Word64(0xe49b69c1, 0x9ef14ad2), new Word64(0xefbe4786, 0x384f25e3), new Word64(0x0fc19dc6, 0x8b8cd5b5), new Word64(0x240ca1cc, 0x77ac9c65), new Word64(0x2de92c6f, 0x592b0275), new Word64(0x4a7484aa, 0x6ea6e483), new Word64(0x5cb0a9dc, 0xbd41fbd4), new Word64(0x76f988da, 0x831153b5), new Word64(0x983e5152, 0xee66dfab), new Word64(0xa831c66d, 0x2db43210), new Word64(0xb00327c8, 0x98fb213f), new Word64(0xbf597fc7, 0xbeef0ee4), new Word64(0xc6e00bf3, 0x3da88fc2), new Word64(0xd5a79147, 0x930aa725), new Word64(0x06ca6351, 0xe003826f), new Word64(0x14292967, 0x0a0e6e70), new Word64(0x27b70a85, 0x46d22ffc), new Word64(0x2e1b2138, 0x5c26c926), new Word64(0x4d2c6dfc, 0x5ac42aed), new Word64(0x53380d13, 0x9d95b3df), new Word64(0x650a7354, 0x8baf63de), new Word64(0x766a0abb, 0x3c77b2a8), new Word64(0x81c2c92e, 0x47edaee6), new Word64(0x92722c85, 0x1482353b), new Word64(0xa2bfe8a1, 0x4cf10364), new Word64(0xa81a664b, 0xbc423001), new Word64(0xc24b8b70, 0xd0f89791), new Word64(0xc76c51a3, 0x0654be30), new Word64(0xd192e819, 0xd6ef5218), new Word64(0xd6990624, 0x5565a910), new Word64(0xf40e3585, 0x5771202a), new Word64(0x106aa070, 0x32bbd1b8), new Word64(0x19a4c116, 0xb8d2d0c8), new Word64(0x1e376c08, 0x5141ab53), new Word64(0x2748774c, 0xdf8eeb99), new Word64(0x34b0bcb5, 0xe19b48a8), new Word64(0x391c0cb3, 0xc5c95a63), new Word64(0x4ed8aa4a, 0xe3418acb), new Word64(0x5b9cca4f, 0x7763e373), new Word64(0x682e6ff3, 0xd6b2b8a3), new Word64(0x748f82ee, 0x5defb2fc), new Word64(0x78a5636f, 0x43172f60), new Word64(0x84c87814, 0xa1f0ab72), new Word64(0x8cc70208, 0x1a6439ec), new Word64(0x90befffa, 0x23631e28), new Word64(0xa4506ceb, 0xde82bde9), new Word64(0xbef9a3f7, 0xb2c67915), new Word64(0xc67178f2, 0xe372532b), new Word64(0xca273ece, 0xea26619c), new Word64(0xd186b8c7, 0x21c0c207), new Word64(0xeada7dd6, 0xcde0eb1e), new Word64(0xf57d4f7f, 0xee6ed178), new Word64(0x06f067aa, 0x72176fba), new Word64(0x0a637dc5, 0xa2c898a6), new Word64(0x113f9804, 0xbef90dae), new Word64(0x1b710b35, 0x131c471b), new Word64(0x28db77f5, 0x23047d84), new Word64(0x32caab7b, 0x40c72493), new Word64(0x3c9ebe0a, 0x15c9bebc), new Word64(0x431d67c4, 0x9c100d4c), new Word64(0x4cc5d4be, 0xcb3e42b6), new Word64(0x597f299c, 0xfc657e2a), new Word64(0x5fcb6fab, 0x3ad6faec), new Word64(0x6c44198c, 0x4a475817)];
+
+  function hash(data, offset, length, mode384) {
+    mode384 = !!mode384;
+    var h0, h1, h2, h3, h4, h5, h6, h7;
+
+    if (!mode384) {
+      h0 = new Word64(0x6a09e667, 0xf3bcc908);
+      h1 = new Word64(0xbb67ae85, 0x84caa73b);
+      h2 = new Word64(0x3c6ef372, 0xfe94f82b);
+      h3 = new Word64(0xa54ff53a, 0x5f1d36f1);
+      h4 = new Word64(0x510e527f, 0xade682d1);
+      h5 = new Word64(0x9b05688c, 0x2b3e6c1f);
+      h6 = new Word64(0x1f83d9ab, 0xfb41bd6b);
+      h7 = new Word64(0x5be0cd19, 0x137e2179);
+    } else {
+      h0 = new Word64(0xcbbb9d5d, 0xc1059ed8);
+      h1 = new Word64(0x629a292a, 0x367cd507);
+      h2 = new Word64(0x9159015a, 0x3070dd17);
+      h3 = new Word64(0x152fecd8, 0xf70e5939);
+      h4 = new Word64(0x67332667, 0xffc00b31);
+      h5 = new Word64(0x8eb44a87, 0x68581511);
+      h6 = new Word64(0xdb0c2e0d, 0x64f98fa7);
+      h7 = new Word64(0x47b5481d, 0xbefa4fa4);
+    }
+
+    var paddedLength = Math.ceil((length + 17) / 128) * 128;
+    var padded = new Uint8Array(paddedLength);
+    var i, j, n;
+
+    for (i = 0; i < length; ++i) {
+      padded[i] = data[offset++];
+    }
+
+    padded[i++] = 0x80;
+    n = paddedLength - 16;
+
+    while (i < n) {
+      padded[i++] = 0;
+    }
+
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = 0;
+    padded[i++] = length >>> 29 & 0xff;
+    padded[i++] = length >> 21 & 0xff;
+    padded[i++] = length >> 13 & 0xff;
+    padded[i++] = length >> 5 & 0xff;
+    padded[i++] = length << 3 & 0xff;
+    var w = new Array(80);
+
+    for (i = 0; i < 80; i++) {
+      w[i] = new Word64(0, 0);
+    }
+
+    var a = new Word64(0, 0),
+        b = new Word64(0, 0),
+        c = new Word64(0, 0);
+    var d = new Word64(0, 0),
+        e = new Word64(0, 0),
+        f = new Word64(0, 0);
+    var g = new Word64(0, 0),
+        h = new Word64(0, 0);
+    var t1 = new Word64(0, 0),
+        t2 = new Word64(0, 0);
+    var tmp1 = new Word64(0, 0),
+        tmp2 = new Word64(0, 0),
+        tmp3;
+
+    for (i = 0; i < paddedLength;) {
+      for (j = 0; j < 16; ++j) {
+        w[j].high = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
+        w[j].low = padded[i + 4] << 24 | padded[i + 5] << 16 | padded[i + 6] << 8 | padded[i + 7];
+        i += 8;
+      }
+
+      for (j = 16; j < 80; ++j) {
+        tmp3 = w[j];
+        littleSigmaPrime(tmp3, w[j - 2], tmp2);
+        tmp3.add(w[j - 7]);
+        littleSigma(tmp1, w[j - 15], tmp2);
+        tmp3.add(tmp1);
+        tmp3.add(w[j - 16]);
+      }
+
+      a.assign(h0);
+      b.assign(h1);
+      c.assign(h2);
+      d.assign(h3);
+      e.assign(h4);
+      f.assign(h5);
+      g.assign(h6);
+      h.assign(h7);
+
+      for (j = 0; j < 80; ++j) {
+        t1.assign(h);
+        sigmaPrime(tmp1, e, tmp2);
+        t1.add(tmp1);
+        ch(tmp1, e, f, g, tmp2);
+        t1.add(tmp1);
+        t1.add(k[j]);
+        t1.add(w[j]);
+        sigma(t2, a, tmp2);
+        maj(tmp1, a, b, c, tmp2);
+        t2.add(tmp1);
+        tmp3 = h;
+        h = g;
+        g = f;
+        f = e;
+        d.add(t1);
+        e = d;
+        d = c;
+        c = b;
+        b = a;
+        tmp3.assign(t1);
+        tmp3.add(t2);
+        a = tmp3;
+      }
+
+      h0.add(a);
+      h1.add(b);
+      h2.add(c);
+      h3.add(d);
+      h4.add(e);
+      h5.add(f);
+      h6.add(g);
+      h7.add(h);
+    }
+
+    var result;
+
+    if (!mode384) {
+      result = new Uint8Array(64);
+      h0.copyTo(result, 0);
+      h1.copyTo(result, 8);
+      h2.copyTo(result, 16);
+      h3.copyTo(result, 24);
+      h4.copyTo(result, 32);
+      h5.copyTo(result, 40);
+      h6.copyTo(result, 48);
+      h7.copyTo(result, 56);
+    } else {
+      result = new Uint8Array(48);
+      h0.copyTo(result, 0);
+      h1.copyTo(result, 8);
+      h2.copyTo(result, 16);
+      h3.copyTo(result, 24);
+      h4.copyTo(result, 32);
+      h5.copyTo(result, 40);
+    }
+
+    return result;
+  }
+
+  return hash;
+}();
+
+exports.calculateSHA512 = calculateSHA512;
+
+var calculateSHA384 = function calculateSHA384Closure() {
+  function hash(data, offset, length) {
+    return calculateSHA512(data, offset, length, true);
+  }
+
+  return hash;
+}();
+
+exports.calculateSHA384 = calculateSHA384;
+
+var NullCipher = function NullCipherClosure() {
+  function NullCipher() {}
+
+  NullCipher.prototype = {
+    decryptBlock: function NullCipher_decryptBlock(data) {
+      return data;
+    },
+    encrypt: function NullCipher_encrypt(data) {
+      return data;
+    }
+  };
+  return NullCipher;
+}();
+
+class AESBaseCipher {
+  constructor() {
+    if (this.constructor === AESBaseCipher) {
+      (0, _util.unreachable)("Cannot initialize AESBaseCipher.");
+    }
+
+    this._s = new Uint8Array([0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16]);
+    this._inv_s = new Uint8Array([0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d]);
+    this._mix = new Uint32Array([0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]);
+    this._mixCol = new Uint8Array(256);
+
+    for (let i = 0; i < 256; i++) {
+      if (i < 128) {
+        this._mixCol[i] = i << 1;
+      } else {
+        this._mixCol[i] = i << 1 ^ 0x1b;
+      }
+    }
+
+    this.buffer = new Uint8Array(16);
+    this.bufferPosition = 0;
+  }
+
+  _expandKey(cipherKey) {
+    (0, _util.unreachable)("Cannot call `_expandKey` on the base class");
+  }
+
+  _decrypt(input, key) {
+    let t, u, v;
+    const state = new Uint8Array(16);
+    state.set(input);
+
+    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
+      state[j] ^= key[k];
+    }
+
+    for (let i = this._cyclesOfRepetition - 1; i >= 1; --i) {
+      t = state[13];
+      state[13] = state[9];
+      state[9] = state[5];
+      state[5] = state[1];
+      state[1] = t;
+      t = state[14];
+      u = state[10];
+      state[14] = state[6];
+      state[10] = state[2];
+      state[6] = t;
+      state[2] = u;
+      t = state[15];
+      u = state[11];
+      v = state[7];
+      state[15] = state[3];
+      state[11] = t;
+      state[7] = u;
+      state[3] = v;
+
+      for (let j = 0; j < 16; ++j) {
+        state[j] = this._inv_s[state[j]];
+      }
+
+      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
+        state[j] ^= key[k];
+      }
+
+      for (let j = 0; j < 16; j += 4) {
+        const s0 = this._mix[state[j]];
+        const s1 = this._mix[state[j + 1]];
+        const s2 = this._mix[state[j + 2]];
+        const s3 = this._mix[state[j + 3]];
+        t = s0 ^ s1 >>> 8 ^ s1 << 24 ^ s2 >>> 16 ^ s2 << 16 ^ s3 >>> 24 ^ s3 << 8;
+        state[j] = t >>> 24 & 0xff;
+        state[j + 1] = t >> 16 & 0xff;
+        state[j + 2] = t >> 8 & 0xff;
+        state[j + 3] = t & 0xff;
+      }
+    }
+
+    t = state[13];
+    state[13] = state[9];
+    state[9] = state[5];
+    state[5] = state[1];
+    state[1] = t;
+    t = state[14];
+    u = state[10];
+    state[14] = state[6];
+    state[10] = state[2];
+    state[6] = t;
+    state[2] = u;
+    t = state[15];
+    u = state[11];
+    v = state[7];
+    state[15] = state[3];
+    state[11] = t;
+    state[7] = u;
+    state[3] = v;
+
+    for (let j = 0; j < 16; ++j) {
+      state[j] = this._inv_s[state[j]];
+      state[j] ^= key[j];
+    }
+
+    return state;
+  }
+
+  _encrypt(input, key) {
+    const s = this._s;
+    let t, u, v;
+    const state = new Uint8Array(16);
+    state.set(input);
+
+    for (let j = 0; j < 16; ++j) {
+      state[j] ^= key[j];
+    }
+
+    for (let i = 1; i < this._cyclesOfRepetition; i++) {
+      for (let j = 0; j < 16; ++j) {
+        state[j] = s[state[j]];
+      }
+
+      v = state[1];
+      state[1] = state[5];
+      state[5] = state[9];
+      state[9] = state[13];
+      state[13] = v;
+      v = state[2];
+      u = state[6];
+      state[2] = state[10];
+      state[6] = state[14];
+      state[10] = v;
+      state[14] = u;
+      v = state[3];
+      u = state[7];
+      t = state[11];
+      state[3] = state[15];
+      state[7] = v;
+      state[11] = u;
+      state[15] = t;
+
+      for (let j = 0; j < 16; j += 4) {
+        const s0 = state[j + 0];
+        const s1 = state[j + 1];
+        const s2 = state[j + 2];
+        const s3 = state[j + 3];
+        t = s0 ^ s1 ^ s2 ^ s3;
+        state[j + 0] ^= t ^ this._mixCol[s0 ^ s1];
+        state[j + 1] ^= t ^ this._mixCol[s1 ^ s2];
+        state[j + 2] ^= t ^ this._mixCol[s2 ^ s3];
+        state[j + 3] ^= t ^ this._mixCol[s3 ^ s0];
+      }
+
+      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
+        state[j] ^= key[k];
+      }
+    }
+
+    for (let j = 0; j < 16; ++j) {
+      state[j] = s[state[j]];
+    }
+
+    v = state[1];
+    state[1] = state[5];
+    state[5] = state[9];
+    state[9] = state[13];
+    state[13] = v;
+    v = state[2];
+    u = state[6];
+    state[2] = state[10];
+    state[6] = state[14];
+    state[10] = v;
+    state[14] = u;
+    v = state[3];
+    u = state[7];
+    t = state[11];
+    state[3] = state[15];
+    state[7] = v;
+    state[11] = u;
+    state[15] = t;
+
+    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
+      state[j] ^= key[k];
+    }
+
+    return state;
+  }
+
+  _decryptBlock2(data, finalize) {
+    const sourceLength = data.length;
+    let buffer = this.buffer,
+        bufferLength = this.bufferPosition;
+    const result = [];
+    let iv = this.iv;
+
+    for (let i = 0; i < sourceLength; ++i) {
+      buffer[bufferLength] = data[i];
+      ++bufferLength;
+
+      if (bufferLength < 16) {
+        continue;
+      }
+
+      const plain = this._decrypt(buffer, this._key);
+
+      for (let j = 0; j < 16; ++j) {
+        plain[j] ^= iv[j];
+      }
+
+      iv = buffer;
+      result.push(plain);
+      buffer = new Uint8Array(16);
+      bufferLength = 0;
+    }
+
+    this.buffer = buffer;
+    this.bufferLength = bufferLength;
+    this.iv = iv;
+
+    if (result.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    let outputLength = 16 * result.length;
+
+    if (finalize) {
+      const lastBlock = result[result.length - 1];
+      let psLen = lastBlock[15];
+
+      if (psLen <= 16) {
+        for (let i = 15, ii = 16 - psLen; i >= ii; --i) {
+          if (lastBlock[i] !== psLen) {
+            psLen = 0;
+            break;
+          }
+        }
+
+        outputLength -= psLen;
+        result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
+      }
+    }
+
+    const output = new Uint8Array(outputLength);
+
+    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+      output.set(result[i], j);
+    }
+
+    return output;
+  }
+
+  decryptBlock(data, finalize, iv = null) {
+    const sourceLength = data.length;
+    const buffer = this.buffer;
+    let bufferLength = this.bufferPosition;
+
+    if (iv) {
+      this.iv = iv;
+    } else {
+      for (let i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
+        buffer[bufferLength] = data[i];
+      }
+
+      if (bufferLength < 16) {
+        this.bufferLength = bufferLength;
+        return new Uint8Array(0);
+      }
+
+      this.iv = buffer;
+      data = data.subarray(16);
+    }
+
+    this.buffer = new Uint8Array(16);
+    this.bufferLength = 0;
+    this.decryptBlock = this._decryptBlock2;
+    return this.decryptBlock(data, finalize);
+  }
+
+  encrypt(data, iv) {
+    const sourceLength = data.length;
+    let buffer = this.buffer,
+        bufferLength = this.bufferPosition;
+    const result = [];
+
+    if (!iv) {
+      iv = new Uint8Array(16);
+    }
+
+    for (let i = 0; i < sourceLength; ++i) {
+      buffer[bufferLength] = data[i];
+      ++bufferLength;
+
+      if (bufferLength < 16) {
+        continue;
+      }
+
+      for (let j = 0; j < 16; ++j) {
+        buffer[j] ^= iv[j];
+      }
+
+      const cipher = this._encrypt(buffer, this._key);
+
+      iv = cipher;
+      result.push(cipher);
+      buffer = new Uint8Array(16);
+      bufferLength = 0;
+    }
+
+    this.buffer = buffer;
+    this.bufferLength = bufferLength;
+    this.iv = iv;
+
+    if (result.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    const outputLength = 16 * result.length;
+    const output = new Uint8Array(outputLength);
+
+    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+      output.set(result[i], j);
+    }
+
+    return output;
+  }
+
+}
+
+class AES128Cipher extends AESBaseCipher {
+  constructor(key) {
+    super();
+    this._cyclesOfRepetition = 10;
+    this._keySize = 160;
+    this._rcon = new Uint8Array([0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d]);
+    this._key = this._expandKey(key);
+  }
+
+  _expandKey(cipherKey) {
+    const b = 176;
+    const s = this._s;
+    const rcon = this._rcon;
+    const result = new Uint8Array(b);
+    result.set(cipherKey);
+
+    for (let j = 16, i = 1; j < b; ++i) {
+      let t1 = result[j - 3];
+      let t2 = result[j - 2];
+      let t3 = result[j - 1];
+      let t4 = result[j - 4];
+      t1 = s[t1];
+      t2 = s[t2];
+      t3 = s[t3];
+      t4 = s[t4];
+      t1 = t1 ^ rcon[i];
+
+      for (let n = 0; n < 4; ++n) {
+        result[j] = t1 ^= result[j - 16];
+        j++;
+        result[j] = t2 ^= result[j - 16];
+        j++;
+        result[j] = t3 ^= result[j - 16];
+        j++;
+        result[j] = t4 ^= result[j - 16];
+        j++;
+      }
+    }
+
+    return result;
+  }
+
+}
+
+exports.AES128Cipher = AES128Cipher;
+
+class AES256Cipher extends AESBaseCipher {
+  constructor(key) {
+    super();
+    this._cyclesOfRepetition = 14;
+    this._keySize = 224;
+    this._key = this._expandKey(key);
+  }
+
+  _expandKey(cipherKey) {
+    const b = 240;
+    const s = this._s;
+    const result = new Uint8Array(b);
+    result.set(cipherKey);
+    let r = 1;
+    let t1, t2, t3, t4;
+
+    for (let j = 32, i = 1; j < b; ++i) {
+      if (j % 32 === 16) {
+        t1 = s[t1];
+        t2 = s[t2];
+        t3 = s[t3];
+        t4 = s[t4];
+      } else if (j % 32 === 0) {
+        t1 = result[j - 3];
+        t2 = result[j - 2];
+        t3 = result[j - 1];
+        t4 = result[j - 4];
+        t1 = s[t1];
+        t2 = s[t2];
+        t3 = s[t3];
+        t4 = s[t4];
+        t1 = t1 ^ r;
+
+        if ((r <<= 1) >= 256) {
+          r = (r ^ 0x1b) & 0xff;
+        }
+      }
+
+      for (let n = 0; n < 4; ++n) {
+        result[j] = t1 ^= result[j - 32];
+        j++;
+        result[j] = t2 ^= result[j - 32];
+        j++;
+        result[j] = t3 ^= result[j - 32];
+        j++;
+        result[j] = t4 ^= result[j - 32];
+        j++;
+      }
+    }
+
+    return result;
+  }
+
+}
+
+exports.AES256Cipher = AES256Cipher;
+
+var PDF17 = function PDF17Closure() {
+  function compareByteArrays(array1, array2) {
+    if (array1.length !== array2.length) {
+      return false;
+    }
+
+    for (var i = 0; i < array1.length; i++) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function PDF17() {}
+
+  PDF17.prototype = {
+    checkOwnerPassword: function PDF17_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
+      var hashData = new Uint8Array(password.length + 56);
+      hashData.set(password, 0);
+      hashData.set(ownerValidationSalt, password.length);
+      hashData.set(userBytes, password.length + ownerValidationSalt.length);
+      var result = calculateSHA256(hashData, 0, hashData.length);
+      return compareByteArrays(result, ownerPassword);
+    },
+    checkUserPassword: function PDF17_checkUserPassword(password, userValidationSalt, userPassword) {
+      var hashData = new Uint8Array(password.length + 8);
+      hashData.set(password, 0);
+      hashData.set(userValidationSalt, password.length);
+      var result = calculateSHA256(hashData, 0, hashData.length);
+      return compareByteArrays(result, userPassword);
+    },
+    getOwnerKey: function PDF17_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
+      var hashData = new Uint8Array(password.length + 56);
+      hashData.set(password, 0);
+      hashData.set(ownerKeySalt, password.length);
+      hashData.set(userBytes, password.length + ownerKeySalt.length);
+      var key = calculateSHA256(hashData, 0, hashData.length);
+      var cipher = new AES256Cipher(key);
+      return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
+    },
+    getUserKey: function PDF17_getUserKey(password, userKeySalt, userEncryption) {
+      var hashData = new Uint8Array(password.length + 8);
+      hashData.set(password, 0);
+      hashData.set(userKeySalt, password.length);
+      var key = calculateSHA256(hashData, 0, hashData.length);
+      var cipher = new AES256Cipher(key);
+      return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
+    }
+  };
+  return PDF17;
+}();
+
+exports.PDF17 = PDF17;
+
+var PDF20 = function PDF20Closure() {
+  function concatArrays(array1, array2) {
+    var t = new Uint8Array(array1.length + array2.length);
+    t.set(array1, 0);
+    t.set(array2, array1.length);
+    return t;
+  }
+
+  function calculatePDF20Hash(password, input, userBytes) {
+    var k = calculateSHA256(input, 0, input.length).subarray(0, 32);
+    var e = [0];
+    var i = 0;
+
+    while (i < 64 || e[e.length - 1] > i - 32) {
+      var arrayLength = password.length + k.length + userBytes.length;
+      var k1 = new Uint8Array(arrayLength * 64);
+      var array = concatArrays(password, k);
+      array = concatArrays(array, userBytes);
+
+      for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
+        k1.set(array, pos);
+      }
+
+      var cipher = new AES128Cipher(k.subarray(0, 16));
+      e = cipher.encrypt(k1, k.subarray(16, 32));
+      var remainder = 0;
+
+      for (var z = 0; z < 16; z++) {
+        remainder *= 256 % 3;
+        remainder %= 3;
+        remainder += (e[z] >>> 0) % 3;
+        remainder %= 3;
+      }
+
+      if (remainder === 0) {
+        k = calculateSHA256(e, 0, e.length);
+      } else if (remainder === 1) {
+        k = calculateSHA384(e, 0, e.length);
+      } else if (remainder === 2) {
+        k = calculateSHA512(e, 0, e.length);
+      }
+
+      i++;
+    }
+
+    return k.subarray(0, 32);
+  }
+
+  function PDF20() {}
+
+  function compareByteArrays(array1, array2) {
+    if (array1.length !== array2.length) {
+      return false;
+    }
+
+    for (var i = 0; i < array1.length; i++) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  PDF20.prototype = {
+    hash: function PDF20_hash(password, concatBytes, userBytes) {
+      return calculatePDF20Hash(password, concatBytes, userBytes);
+    },
+    checkOwnerPassword: function PDF20_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
+      var hashData = new Uint8Array(password.length + 56);
+      hashData.set(password, 0);
+      hashData.set(ownerValidationSalt, password.length);
+      hashData.set(userBytes, password.length + ownerValidationSalt.length);
+      var result = calculatePDF20Hash(password, hashData, userBytes);
+      return compareByteArrays(result, ownerPassword);
+    },
+    checkUserPassword: function PDF20_checkUserPassword(password, userValidationSalt, userPassword) {
+      var hashData = new Uint8Array(password.length + 8);
+      hashData.set(password, 0);
+      hashData.set(userValidationSalt, password.length);
+      var result = calculatePDF20Hash(password, hashData, []);
+      return compareByteArrays(result, userPassword);
+    },
+    getOwnerKey: function PDF20_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
+      var hashData = new Uint8Array(password.length + 56);
+      hashData.set(password, 0);
+      hashData.set(ownerKeySalt, password.length);
+      hashData.set(userBytes, password.length + ownerKeySalt.length);
+      var key = calculatePDF20Hash(password, hashData, userBytes);
+      var cipher = new AES256Cipher(key);
+      return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
+    },
+    getUserKey: function PDF20_getUserKey(password, userKeySalt, userEncryption) {
+      var hashData = new Uint8Array(password.length + 8);
+      hashData.set(password, 0);
+      hashData.set(userKeySalt, password.length);
+      var key = calculatePDF20Hash(password, hashData, []);
+      var cipher = new AES256Cipher(key);
+      return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
+    }
+  };
+  return PDF20;
+}();
+
+exports.PDF20 = PDF20;
+
+var CipherTransform = function CipherTransformClosure() {
+  function CipherTransform(stringCipherConstructor, streamCipherConstructor) {
+    this.StringCipherConstructor = stringCipherConstructor;
+    this.StreamCipherConstructor = streamCipherConstructor;
+  }
+
+  CipherTransform.prototype = {
+    createStream: function CipherTransform_createStream(stream, length) {
+      var cipher = new this.StreamCipherConstructor();
+      return new _stream.DecryptStream(stream, length, function cipherTransformDecryptStream(data, finalize) {
+        return cipher.decryptBlock(data, finalize);
+      });
+    },
+    decryptString: function CipherTransform_decryptString(s) {
+      var cipher = new this.StringCipherConstructor();
+      var data = (0, _util.stringToBytes)(s);
+      data = cipher.decryptBlock(data, true);
+      return (0, _util.bytesToString)(data);
+    },
+    encryptString: function CipherTransform_encryptString(s) {
+      const cipher = new this.StringCipherConstructor();
+
+      if (cipher instanceof AESBaseCipher) {
+        const strLen = s.length;
+        const pad = 16 - strLen % 16;
+
+        if (pad !== 16) {
+          s = s.padEnd(16 * Math.ceil(strLen / 16), String.fromCharCode(pad));
+        }
+
+        const iv = new Uint8Array(16);
+
+        if (typeof crypto !== "undefined") {
+          crypto.getRandomValues(iv);
+        } else {
+          for (let i = 0; i < 16; i++) {
+            iv[i] = Math.floor(256 * Math.random());
+          }
+        }
+
+        let data = (0, _util.stringToBytes)(s);
+        data = cipher.encrypt(data, iv);
+        const buf = new Uint8Array(16 + data.length);
+        buf.set(iv);
+        buf.set(data, 16);
+        return (0, _util.bytesToString)(buf);
+      }
+
+      let data = (0, _util.stringToBytes)(s);
+      data = cipher.encrypt(data);
+      return (0, _util.bytesToString)(data);
+    }
+  };
+  return CipherTransform;
+}();
+
+var CipherTransformFactory = function CipherTransformFactoryClosure() {
+  var defaultPasswordBytes = new Uint8Array([0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08, 0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A]);
+
+  function createEncryptionKey20(revision, password, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms) {
+    if (password) {
+      var passwordLength = Math.min(127, password.length);
+      password = password.subarray(0, passwordLength);
+    } else {
+      password = [];
+    }
+
+    var pdfAlgorithm;
+
+    if (revision === 6) {
+      pdfAlgorithm = new PDF20();
+    } else {
+      pdfAlgorithm = new PDF17();
+    }
+
+    if (pdfAlgorithm.checkUserPassword(password, userValidationSalt, userPassword)) {
+      return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption);
+    } else if (password.length && pdfAlgorithm.checkOwnerPassword(password, ownerValidationSalt, uBytes, ownerPassword)) {
+      return pdfAlgorithm.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
+    }
+
+    return null;
+  }
+
+  function prepareKeyData(fileId, password, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata) {
+    var hashDataSize = 40 + ownerPassword.length + fileId.length;
+    var hashData = new Uint8Array(hashDataSize),
+        i = 0,
+        j,
+        n;
+
+    if (password) {
+      n = Math.min(32, password.length);
+
+      for (; i < n; ++i) {
+        hashData[i] = password[i];
+      }
+    }
+
+    j = 0;
+
+    while (i < 32) {
+      hashData[i++] = defaultPasswordBytes[j++];
+    }
+
+    for (j = 0, n = ownerPassword.length; j < n; ++j) {
+      hashData[i++] = ownerPassword[j];
+    }
+
+    hashData[i++] = flags & 0xff;
+    hashData[i++] = flags >> 8 & 0xff;
+    hashData[i++] = flags >> 16 & 0xff;
+    hashData[i++] = flags >>> 24 & 0xff;
+
+    for (j = 0, n = fileId.length; j < n; ++j) {
+      hashData[i++] = fileId[j];
+    }
+
+    if (revision >= 4 && !encryptMetadata) {
+      hashData[i++] = 0xff;
+      hashData[i++] = 0xff;
+      hashData[i++] = 0xff;
+      hashData[i++] = 0xff;
+    }
+
+    var hash = calculateMD5(hashData, 0, i);
+    var keyLengthInBytes = keyLength >> 3;
+
+    if (revision >= 3) {
+      for (j = 0; j < 50; ++j) {
+        hash = calculateMD5(hash, 0, keyLengthInBytes);
+      }
+    }
+
+    var encryptionKey = hash.subarray(0, keyLengthInBytes);
+    var cipher, checkData;
+
+    if (revision >= 3) {
+      for (i = 0; i < 32; ++i) {
+        hashData[i] = defaultPasswordBytes[i];
+      }
+
+      for (j = 0, n = fileId.length; j < n; ++j) {
+        hashData[i++] = fileId[j];
+      }
+
+      cipher = new ARCFourCipher(encryptionKey);
+      checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
+      n = encryptionKey.length;
+      var derivedKey = new Uint8Array(n),
+          k;
+
+      for (j = 1; j <= 19; ++j) {
+        for (k = 0; k < n; ++k) {
+          derivedKey[k] = encryptionKey[k] ^ j;
+        }
+
+        cipher = new ARCFourCipher(derivedKey);
+        checkData = cipher.encryptBlock(checkData);
+      }
+
+      for (j = 0, n = checkData.length; j < n; ++j) {
+        if (userPassword[j] !== checkData[j]) {
+          return null;
+        }
+      }
+    } else {
+      cipher = new ARCFourCipher(encryptionKey);
+      checkData = cipher.encryptBlock(defaultPasswordBytes);
+
+      for (j = 0, n = checkData.length; j < n; ++j) {
+        if (userPassword[j] !== checkData[j]) {
+          return null;
+        }
+      }
+    }
+
+    return encryptionKey;
+  }
+
+  function decodeUserPassword(password, ownerPassword, revision, keyLength) {
+    var hashData = new Uint8Array(32),
+        i = 0,
+        j,
+        n;
+    n = Math.min(32, password.length);
+
+    for (; i < n; ++i) {
+      hashData[i] = password[i];
+    }
+
+    j = 0;
+
+    while (i < 32) {
+      hashData[i++] = defaultPasswordBytes[j++];
+    }
+
+    var hash = calculateMD5(hashData, 0, i);
+    var keyLengthInBytes = keyLength >> 3;
+
+    if (revision >= 3) {
+      for (j = 0; j < 50; ++j) {
+        hash = calculateMD5(hash, 0, hash.length);
+      }
+    }
+
+    var cipher, userPassword;
+
+    if (revision >= 3) {
+      userPassword = ownerPassword;
+      var derivedKey = new Uint8Array(keyLengthInBytes),
+          k;
+
+      for (j = 19; j >= 0; j--) {
+        for (k = 0; k < keyLengthInBytes; ++k) {
+          derivedKey[k] = hash[k] ^ j;
+        }
+
+        cipher = new ARCFourCipher(derivedKey);
+        userPassword = cipher.encryptBlock(userPassword);
+      }
+    } else {
+      cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
+      userPassword = cipher.encryptBlock(ownerPassword);
+    }
+
+    return userPassword;
+  }
+
+  var identityName = _primitives.Name.get("Identity");
+
+  function CipherTransformFactory(dict, fileId, password) {
+    var filter = dict.get("Filter");
+
+    if (!(0, _primitives.isName)(filter, "Standard")) {
+      throw new _util.FormatError("unknown encryption method");
+    }
+
+    this.dict = dict;
+    var algorithm = dict.get("V");
+
+    if (!Number.isInteger(algorithm) || algorithm !== 1 && algorithm !== 2 && algorithm !== 4 && algorithm !== 5) {
+      throw new _util.FormatError("unsupported encryption algorithm");
+    }
+
+    this.algorithm = algorithm;
+    var keyLength = dict.get("Length");
+
+    if (!keyLength) {
+      if (algorithm <= 3) {
+        keyLength = 40;
+      } else {
+        var cfDict = dict.get("CF");
+        var streamCryptoName = dict.get("StmF");
+
+        if ((0, _primitives.isDict)(cfDict) && (0, _primitives.isName)(streamCryptoName)) {
+          cfDict.suppressEncryption = true;
+          var handlerDict = cfDict.get(streamCryptoName.name);
+          keyLength = handlerDict && handlerDict.get("Length") || 128;
+
+          if (keyLength < 40) {
+            keyLength <<= 3;
+          }
+        }
+      }
+    }
+
+    if (!Number.isInteger(keyLength) || keyLength < 40 || keyLength % 8 !== 0) {
+      throw new _util.FormatError("invalid key length");
+    }
+
+    var ownerPassword = (0, _util.stringToBytes)(dict.get("O")).subarray(0, 32);
+    var userPassword = (0, _util.stringToBytes)(dict.get("U")).subarray(0, 32);
+    var flags = dict.get("P");
+    var revision = dict.get("R");
+    var encryptMetadata = (algorithm === 4 || algorithm === 5) && dict.get("EncryptMetadata") !== false;
+    this.encryptMetadata = encryptMetadata;
+    var fileIdBytes = (0, _util.stringToBytes)(fileId);
+    var passwordBytes;
+
+    if (password) {
+      if (revision === 6) {
+        try {
+          password = (0, _util.utf8StringToString)(password);
+        } catch (ex) {
+          (0, _util.warn)("CipherTransformFactory: " + "Unable to convert UTF8 encoded password.");
+        }
+      }
+
+      passwordBytes = (0, _util.stringToBytes)(password);
+    }
+
+    var encryptionKey;
+
+    if (algorithm !== 5) {
+      encryptionKey = prepareKeyData(fileIdBytes, passwordBytes, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
+    } else {
+      var ownerValidationSalt = (0, _util.stringToBytes)(dict.get("O")).subarray(32, 40);
+      var ownerKeySalt = (0, _util.stringToBytes)(dict.get("O")).subarray(40, 48);
+      var uBytes = (0, _util.stringToBytes)(dict.get("U")).subarray(0, 48);
+      var userValidationSalt = (0, _util.stringToBytes)(dict.get("U")).subarray(32, 40);
+      var userKeySalt = (0, _util.stringToBytes)(dict.get("U")).subarray(40, 48);
+      var ownerEncryption = (0, _util.stringToBytes)(dict.get("OE"));
+      var userEncryption = (0, _util.stringToBytes)(dict.get("UE"));
+      var perms = (0, _util.stringToBytes)(dict.get("Perms"));
+      encryptionKey = createEncryptionKey20(revision, passwordBytes, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms);
+    }
+
+    if (!encryptionKey && !password) {
+      throw new _util.PasswordException("No password given", _util.PasswordResponses.NEED_PASSWORD);
+    } else if (!encryptionKey && password) {
+      var decodedPassword = decodeUserPassword(passwordBytes, ownerPassword, revision, keyLength);
+      encryptionKey = prepareKeyData(fileIdBytes, decodedPassword, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
+    }
+
+    if (!encryptionKey) {
+      throw new _util.PasswordException("Incorrect Password", _util.PasswordResponses.INCORRECT_PASSWORD);
+    }
+
+    this.encryptionKey = encryptionKey;
+
+    if (algorithm >= 4) {
+      var cf = dict.get("CF");
+
+      if ((0, _primitives.isDict)(cf)) {
+        cf.suppressEncryption = true;
+      }
+
+      this.cf = cf;
+      this.stmf = dict.get("StmF") || identityName;
+      this.strf = dict.get("StrF") || identityName;
+      this.eff = dict.get("EFF") || this.stmf;
+    }
+  }
+
+  function buildObjectKey(num, gen, encryptionKey, isAes) {
+    var key = new Uint8Array(encryptionKey.length + 9),
+        i,
+        n;
+
+    for (i = 0, n = encryptionKey.length; i < n; ++i) {
+      key[i] = encryptionKey[i];
+    }
+
+    key[i++] = num & 0xff;
+    key[i++] = num >> 8 & 0xff;
+    key[i++] = num >> 16 & 0xff;
+    key[i++] = gen & 0xff;
+    key[i++] = gen >> 8 & 0xff;
+
+    if (isAes) {
+      key[i++] = 0x73;
+      key[i++] = 0x41;
+      key[i++] = 0x6c;
+      key[i++] = 0x54;
+    }
+
+    var hash = calculateMD5(key, 0, i);
+    return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
+  }
+
+  function buildCipherConstructor(cf, name, num, gen, key) {
+    if (!(0, _primitives.isName)(name)) {
+      throw new _util.FormatError("Invalid crypt filter name.");
+    }
+
+    var cryptFilter = cf.get(name.name);
+    var cfm;
+
+    if (cryptFilter !== null && cryptFilter !== undefined) {
+      cfm = cryptFilter.get("CFM");
+    }
+
+    if (!cfm || cfm.name === "None") {
+      return function cipherTransformFactoryBuildCipherConstructorNone() {
+        return new NullCipher();
+      };
+    }
+
+    if (cfm.name === "V2") {
+      return function cipherTransformFactoryBuildCipherConstructorV2() {
+        return new ARCFourCipher(buildObjectKey(num, gen, key, false));
+      };
+    }
+
+    if (cfm.name === "AESV2") {
+      return function cipherTransformFactoryBuildCipherConstructorAESV2() {
+        return new AES128Cipher(buildObjectKey(num, gen, key, true));
+      };
+    }
+
+    if (cfm.name === "AESV3") {
+      return function cipherTransformFactoryBuildCipherConstructorAESV3() {
+        return new AES256Cipher(key);
+      };
+    }
+
+    throw new _util.FormatError("Unknown crypto method");
+  }
+
+  CipherTransformFactory.prototype = {
+    createCipherTransform: function CipherTransformFactory_createCipherTransform(num, gen) {
+      if (this.algorithm === 4 || this.algorithm === 5) {
+        return new CipherTransform(buildCipherConstructor(this.cf, this.stmf, num, gen, this.encryptionKey), buildCipherConstructor(this.cf, this.strf, num, gen, this.encryptionKey));
+      }
+
+      var key = buildObjectKey(num, gen, this.encryptionKey, false);
+
+      var cipherConstructor = function buildCipherCipherConstructor() {
+        return new ARCFourCipher(key);
+      };
+
+      return new CipherTransform(cipherConstructor, cipherConstructor);
+    }
+  };
+  return CipherTransformFactory;
+}();
+
+exports.CipherTransformFactory = CipherTransformFactory;
+
+/***/ }),
+/* 23 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ColorSpace = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
+  const COMPONENTS = 3;
+  alpha01 = alpha01 !== 1 ? 0 : alpha01;
+  const xRatio = w1 / w2;
+  const yRatio = h1 / h2;
+  let newIndex = 0,
+      oldIndex;
+  const xScaled = new Uint16Array(w2);
+  const w1Scanline = w1 * COMPONENTS;
+
+  for (let i = 0; i < w2; i++) {
+    xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
+  }
+
+  for (let i = 0; i < h2; i++) {
+    const py = Math.floor(i * yRatio) * w1Scanline;
+
+    for (let j = 0; j < w2; j++) {
+      oldIndex = py + xScaled[j];
+      dest[newIndex++] = src[oldIndex++];
+      dest[newIndex++] = src[oldIndex++];
+      dest[newIndex++] = src[oldIndex++];
+      newIndex += alpha01;
+    }
+  }
+}
+
+class ColorSpace {
+  constructor(name, numComps) {
+    if (this.constructor === ColorSpace) {
+      (0, _util.unreachable)("Cannot initialize ColorSpace.");
+    }
+
+    this.name = name;
+    this.numComps = numComps;
+  }
+
+  getRgb(src, srcOffset) {
+    const rgb = new Uint8ClampedArray(3);
+    this.getRgbItem(src, srcOffset, rgb, 0);
+    return rgb;
+  }
+
+  getRgbItem(src, srcOffset, dest, destOffset) {
+    (0, _util.unreachable)("Should not call ColorSpace.getRgbItem");
+  }
+
+  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+    (0, _util.unreachable)("Should not call ColorSpace.getRgbBuffer");
+  }
+
+  getOutputLength(inputLength, alpha01) {
+    (0, _util.unreachable)("Should not call ColorSpace.getOutputLength");
+  }
+
+  isPassthrough(bits) {
+    return false;
+  }
+
+  isDefaultDecode(decodeMap, bpc) {
+    return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+  }
+
+  fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
+    const count = originalWidth * originalHeight;
+    let rgbBuf = null;
+    const numComponentColors = 1 << bpc;
+    const needsResizing = originalHeight !== height || originalWidth !== width;
+
+    if (this.isPassthrough(bpc)) {
+      rgbBuf = comps;
+    } else if (this.numComps === 1 && count > numComponentColors && this.name !== "DeviceGray" && this.name !== "DeviceRGB") {
+      const allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
+
+      for (let i = 0; i < numComponentColors; i++) {
+        allColors[i] = i;
+      }
+
+      const colorMap = new Uint8ClampedArray(numComponentColors * 3);
+      this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, 0);
+
+      if (!needsResizing) {
+        let destPos = 0;
+
+        for (let i = 0; i < count; ++i) {
+          const key = comps[i] * 3;
+          dest[destPos++] = colorMap[key];
+          dest[destPos++] = colorMap[key + 1];
+          dest[destPos++] = colorMap[key + 2];
+          destPos += alpha01;
+        }
+      } else {
+        rgbBuf = new Uint8Array(count * 3);
+        let rgbPos = 0;
+
+        for (let i = 0; i < count; ++i) {
+          const key = comps[i] * 3;
+          rgbBuf[rgbPos++] = colorMap[key];
+          rgbBuf[rgbPos++] = colorMap[key + 1];
+          rgbBuf[rgbPos++] = colorMap[key + 2];
+        }
+      }
+    } else {
+      if (!needsResizing) {
+        this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
+      } else {
+        rgbBuf = new Uint8ClampedArray(count * 3);
+        this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, 0);
+      }
+    }
+
+    if (rgbBuf) {
+      if (needsResizing) {
+        resizeRgbImage(rgbBuf, dest, originalWidth, originalHeight, width, height, alpha01);
+      } else {
+        let destPos = 0,
+            rgbPos = 0;
+
+        for (let i = 0, ii = width * actualHeight; i < ii; i++) {
+          dest[destPos++] = rgbBuf[rgbPos++];
+          dest[destPos++] = rgbBuf[rgbPos++];
+          dest[destPos++] = rgbBuf[rgbPos++];
+          destPos += alpha01;
+        }
+      }
+    }
+  }
+
+  get usesZeroToOneRange() {
+    return (0, _util.shadow)(this, "usesZeroToOneRange", true);
+  }
+
+  static _cache(cacheKey, xref, localColorSpaceCache, parsedColorSpace) {
+    if (!localColorSpaceCache) {
+      throw new Error('ColorSpace._cache - expected "localColorSpaceCache" argument.');
+    }
+
+    if (!parsedColorSpace) {
+      throw new Error('ColorSpace._cache - expected "parsedColorSpace" argument.');
+    }
+
+    let csName, csRef;
+
+    if (cacheKey instanceof _primitives.Ref) {
+      csRef = cacheKey;
+      cacheKey = xref.fetch(cacheKey);
+    }
+
+    if (cacheKey instanceof _primitives.Name) {
+      csName = cacheKey.name;
+    }
+
+    if (csName || csRef) {
+      localColorSpaceCache.set(csName, csRef, parsedColorSpace);
+    }
+  }
+
+  static getCached(cacheKey, xref, localColorSpaceCache) {
+    if (!localColorSpaceCache) {
+      throw new Error('ColorSpace.getCached - expected "localColorSpaceCache" argument.');
+    }
+
+    if (cacheKey instanceof _primitives.Ref) {
+      const localColorSpace = localColorSpaceCache.getByRef(cacheKey);
+
+      if (localColorSpace) {
+        return localColorSpace;
+      }
+
+      try {
+        cacheKey = xref.fetch(cacheKey);
+      } catch (ex) {
+        if (ex instanceof _core_utils.MissingDataException) {
+          throw ex;
+        }
+      }
+    }
+
+    if (cacheKey instanceof _primitives.Name) {
+      const localColorSpace = localColorSpaceCache.getByName(cacheKey.name);
+
+      if (localColorSpace) {
+        return localColorSpace;
+      }
+    }
+
+    return null;
+  }
+
+  static async parseAsync({
+    cs,
+    xref,
+    resources = null,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
+
+    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
+
+    return parsedColorSpace;
+  }
+
+  static parse({
+    cs,
+    xref,
+    resources = null,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    const cachedColorSpace = this.getCached(cs, xref, localColorSpaceCache);
+
+    if (cachedColorSpace) {
+      return cachedColorSpace;
+    }
+
+    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
+
+    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
+
+    return parsedColorSpace;
+  }
+
+  static _parse(cs, xref, resources = null, pdfFunctionFactory) {
+    cs = xref.fetchIfRef(cs);
+
+    if ((0, _primitives.isName)(cs)) {
+      switch (cs.name) {
+        case "DeviceGray":
+        case "G":
+          return this.singletons.gray;
+
+        case "DeviceRGB":
+        case "RGB":
+          return this.singletons.rgb;
+
+        case "DeviceCMYK":
+        case "CMYK":
+          return this.singletons.cmyk;
+
+        case "Pattern":
+          return new PatternCS(null);
+
+        default:
+          if ((0, _primitives.isDict)(resources)) {
+            const colorSpaces = resources.get("ColorSpace");
+
+            if ((0, _primitives.isDict)(colorSpaces)) {
+              const resourcesCS = colorSpaces.get(cs.name);
+
+              if (resourcesCS) {
+                if ((0, _primitives.isName)(resourcesCS)) {
+                  return this._parse(resourcesCS, xref, resources, pdfFunctionFactory);
+                }
+
+                cs = resourcesCS;
+                break;
+              }
+            }
+          }
+
+          throw new _util.FormatError(`Unrecognized ColorSpace: ${cs.name}`);
+      }
+    }
+
+    if (Array.isArray(cs)) {
+      const mode = xref.fetchIfRef(cs[0]).name;
+      let params, numComps, baseCS, whitePoint, blackPoint, gamma;
+
+      switch (mode) {
+        case "DeviceGray":
+        case "G":
+          return this.singletons.gray;
+
+        case "DeviceRGB":
+        case "RGB":
+          return this.singletons.rgb;
+
+        case "DeviceCMYK":
+        case "CMYK":
+          return this.singletons.cmyk;
+
+        case "CalGray":
+          params = xref.fetchIfRef(cs[1]);
+          whitePoint = params.getArray("WhitePoint");
+          blackPoint = params.getArray("BlackPoint");
+          gamma = params.get("Gamma");
+          return new CalGrayCS(whitePoint, blackPoint, gamma);
+
+        case "CalRGB":
+          params = xref.fetchIfRef(cs[1]);
+          whitePoint = params.getArray("WhitePoint");
+          blackPoint = params.getArray("BlackPoint");
+          gamma = params.getArray("Gamma");
+          const matrix = params.getArray("Matrix");
+          return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
+
+        case "ICCBased":
+          const stream = xref.fetchIfRef(cs[1]);
+          const dict = stream.dict;
+          numComps = dict.get("N");
+          const alt = dict.get("Alternate");
+
+          if (alt) {
+            const altCS = this._parse(alt, xref, resources, pdfFunctionFactory);
+
+            if (altCS.numComps === numComps) {
+              return altCS;
+            }
+
+            (0, _util.warn)("ICCBased color space: Ignoring incorrect /Alternate entry.");
+          }
+
+          if (numComps === 1) {
+            return this.singletons.gray;
+          } else if (numComps === 3) {
+            return this.singletons.rgb;
+          } else if (numComps === 4) {
+            return this.singletons.cmyk;
+          }
+
+          break;
+
+        case "Pattern":
+          baseCS = cs[1] || null;
+
+          if (baseCS) {
+            baseCS = this._parse(baseCS, xref, resources, pdfFunctionFactory);
+          }
+
+          return new PatternCS(baseCS);
+
+        case "Indexed":
+        case "I":
+          baseCS = this._parse(cs[1], xref, resources, pdfFunctionFactory);
+          const hiVal = xref.fetchIfRef(cs[2]) + 1;
+          const lookup = xref.fetchIfRef(cs[3]);
+          return new IndexedCS(baseCS, hiVal, lookup);
+
+        case "Separation":
+        case "DeviceN":
+          const name = xref.fetchIfRef(cs[1]);
+          numComps = Array.isArray(name) ? name.length : 1;
+          baseCS = this._parse(cs[2], xref, resources, pdfFunctionFactory);
+          const tintFn = pdfFunctionFactory.create(cs[3]);
+          return new AlternateCS(numComps, baseCS, tintFn);
+
+        case "Lab":
+          params = xref.fetchIfRef(cs[1]);
+          whitePoint = params.getArray("WhitePoint");
+          blackPoint = params.getArray("BlackPoint");
+          const range = params.getArray("Range");
+          return new LabCS(whitePoint, blackPoint, range);
+
+        default:
+          throw new _util.FormatError(`Unimplemented ColorSpace object: ${mode}`);
+      }
+    }
+
+    throw new _util.FormatError(`Unrecognized ColorSpace object: ${cs}`);
+  }
+
+  static isDefaultDecode(decode, numComps) {
+    if (!Array.isArray(decode)) {
+      return true;
+    }
+
+    if (numComps * 2 !== decode.length) {
+      (0, _util.warn)("The decode map is not the correct length");
+      return true;
+    }
+
+    for (let i = 0, ii = decode.length; i < ii; i += 2) {
+      if (decode[i] !== 0 || decode[i + 1] !== 1) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  static get singletons() {
+    return (0, _util.shadow)(this, "singletons", {
+      get gray() {
+        return (0, _util.shadow)(this, "gray", new DeviceGrayCS());
+      },
+
+      get rgb() {
+        return (0, _util.shadow)(this, "rgb", new DeviceRgbCS());
+      },
+
+      get cmyk() {
+        return (0, _util.shadow)(this, "cmyk", new DeviceCmykCS());
+      }
+
+    });
+  }
+
+}
+
+exports.ColorSpace = ColorSpace;
+
+class AlternateCS extends ColorSpace {
+  constructor(numComps, base, tintFn) {
+    super("Alternate", numComps);
+    this.base = base;
+    this.tintFn = tintFn;
+    this.tmpBuf = new Float32Array(base.numComps);
+  }
+
+  getRgbItem(src, srcOffset, dest, destOffset) {
+    const tmpBuf = this.tmpBuf;
+    this.tintFn(src, srcOffset, tmpBuf, 0);
+    this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
+  }
+
+  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+    const tintFn = this.tintFn;
+    const base = this.base;
+    const scale = 1 / ((1 << bits) - 1);
+    const baseNumComps = base.numComps;
+    const usesZeroToOneRange = base.usesZeroToOneRange;
+    const isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;
+    let pos = isPassthrough ? destOffset : 0;
+    const baseBuf = isPassthrough ? dest : new Uint8ClampedArray(baseNumComps * count);
+    const numComps = this.numComps;
+    const scaled = new Float32Array(numComps);
+    const tinted = new Float32Array(baseNumComps);
+    let i, j;
+
+    for (i = 0; i < count; i++) {
+      for (j = 0; j < numComps; j++) {
+        scaled[j] = src[srcOffset++] * scale;
+      }
+
+      tintFn(scaled, 0, tinted, 0);
+
+      if (usesZeroToOneRange) {
+        for (j = 0; j < baseNumComps; j++) {
+          baseBuf[pos++] = tinted[j] * 255;
+        }
+      } else {
+        base.getRgbItem(tinted, 0, baseBuf, pos);
+        pos += baseNumComps;
+      }
+    }
+
+    if (!isPassthrough) {
+      base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
+    }
+  }
+
+  getOutputLength(inputLength, alpha01) {
+    return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
+  }
+
+}
+
+class PatternCS extends ColorSpace {
+  constructor(baseCS) {
+    super("Pattern", null);
+    this.base = baseCS;
+  }
+
+  isDefaultDecode(decodeMap, bpc) {
+    (0, _util.unreachable)("Should not call PatternCS.isDefaultDecode");
+  }
+
+}
+
+class IndexedCS extends ColorSpace {
+  constructor(base, highVal, lookup) {
+    super("Indexed", 1);
+    this.base = base;
+    this.highVal = highVal;
+    const length = base.numComps * highVal;
+    this.lookup = new Uint8Array(length);
+
+    if ((0, _primitives.isStream)(lookup)) {
+      const bytes = lookup.getBytes(length);
+      this.lookup.set(bytes);
+    } else if (typeof lookup === "string") {
+      for (let i = 0; i < length; ++i) {
+        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
+      }
+    } else {
+      throw new _util.FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
+    }
+  }
+
+  getRgbItem(src, srcOffset, dest, destOffset) {
+    const numComps = this.base.numComps;
+    const start = src[srcOffset] * numComps;
+    this.base.getRgbBuffer(this.lookup, start, 1, dest, destOffset, 8, 0);
+  }
+
+  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+    const base = this.base;
+    const numComps = base.numComps;
+    const outputDelta = base.getOutputLength(numComps, alpha01);
+    const lookup = this.lookup;
+
+    for (let i = 0; i < count; ++i) {
+      const lookupPos = src[srcOffset++] * numComps;
+      base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
+      destOffset += outputDelta;
+    }
+  }
+
+  getOutputLength(inputLength, alpha01) {
+    return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
+  }
+
+  isDefaultDecode(decodeMap, bpc) {
+    if (!Array.isArray(decodeMap)) {
+      return true;
+    }
+
+    if (decodeMap.length !== 2) {
+      (0, _util.warn)("Decode map length is not correct");
+      return true;
+    }
+
+    if (!Number.isInteger(bpc) || bpc < 1) {
+      (0, _util.warn)("Bits per component is not correct");
+      return true;
+    }
+
+    return decodeMap[0] === 0 && decodeMap[1] === (1 << bpc) - 1;
+  }
+
+}
+
+class DeviceGrayCS extends ColorSpace {
+  constructor() {
+    super("DeviceGray", 1);
+  }
+
+  getRgbItem(src, srcOffset, dest, destOffset) {
+    const c = src[srcOffset] * 255;
+    dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
+  }
+
+  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+    const scale = 255 / ((1 << bits) - 1);
+    let j = srcOffset,
+        q = destOffset;
+
+    for (let i = 0; i < count; ++i) {
+      const c = scale * src[j++];
+      dest[q++] = c;
+      dest[q++] = c;
+      dest[q++] = c;
+      q += alpha01;
+    }
+  }
+
+  getOutputLength(inputLength, alpha01) {
+    return inputLength * (3 + alpha01);
+  }
+
+}
+
+class DeviceRgbCS extends ColorSpace {
+  constructor() {
+    super("DeviceRGB", 3);
+  }
+
+  getRgbItem(src, srcOffset, dest, destOffset) {
+    dest[destOffset] = src[srcOffset] * 255;
+    dest[destOffset + 1] = src[srcOffset + 1] * 255;
+    dest[destOffset + 2] = src[srcOffset + 2] * 255;
+  }
+
+  getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+    if (bits === 8 && alpha01 === 0) {
+      dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
+      return;
+    }
+
+    const scale = 255 / ((1 << bits) - 1);
+    let j = srcOffset,
+        q = destOffset;
+
+    for (let i = 0; i < count; ++i) {
+      dest[q++] = scale * src[j++];
+      dest[q++] = scale * src[j++];
+      dest[q++] = scale * src[j++];
+      q += alpha01;
+    }
+  }
+
+  getOutputLength(inputLength, alpha01) {
+    return inputLength * (3 + alpha01) / 3 | 0;
+  }
+
+  isPassthrough(bits) {
+    return bits === 8;
+  }
+
+}
+
+const DeviceCmykCS = function DeviceCmykCSClosure() {
+  function convertToRgb(src, srcOffset, srcScale, dest, destOffset) {
+    const c = src[srcOffset] * srcScale;
+    const m = src[srcOffset + 1] * srcScale;
+    const y = src[srcOffset + 2] * srcScale;
+    const k = src[srcOffset + 3] * srcScale;
+    dest[destOffset] = 255 + c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k + -285.2331026137004) + m * (1.7149763477362134 * m - 5.6096736904047315 * y + -17.873870861415444 * k - 5.497006427196366) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) + k * (-21.86122147463605 * k - 189.48180835922747);
+    dest[destOffset + 1] = 255 + c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k + -79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + k * (-20.737325471181034 * k - 187.80453709719578);
+    dest[destOffset + 2] = 255 + c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k + -14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k + -193.58209356861505) + k * (-22.33816807309886 * k - 180.12613974708367);
+  }
+
+  class DeviceCmykCS extends ColorSpace {
+    constructor() {
+      super("DeviceCMYK", 4);
+    }
+
+    getRgbItem(src, srcOffset, dest, destOffset) {
+      convertToRgb(src, srcOffset, 1, dest, destOffset);
+    }
+
+    getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+      const scale = 1 / ((1 << bits) - 1);
+
+      for (let i = 0; i < count; i++) {
+        convertToRgb(src, srcOffset, scale, dest, destOffset);
+        srcOffset += 4;
+        destOffset += 3 + alpha01;
+      }
+    }
+
+    getOutputLength(inputLength, alpha01) {
+      return inputLength / 4 * (3 + alpha01) | 0;
+    }
+
+  }
+
+  return DeviceCmykCS;
+}();
+
+const CalGrayCS = function CalGrayCSClosure() {
+  function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
+    const A = src[srcOffset] * scale;
+    const AG = A ** cs.G;
+    const L = cs.YW * AG;
+    const val = Math.max(295.8 * L ** 0.333333333333333333 - 40.8, 0);
+    dest[destOffset] = val;
+    dest[destOffset + 1] = val;
+    dest[destOffset + 2] = val;
+  }
+
+  class CalGrayCS extends ColorSpace {
+    constructor(whitePoint, blackPoint, gamma) {
+      super("CalGray", 1);
+
+      if (!whitePoint) {
+        throw new _util.FormatError("WhitePoint missing - required for color space CalGray");
+      }
+
+      blackPoint = blackPoint || [0, 0, 0];
+      gamma = gamma || 1;
+      this.XW = whitePoint[0];
+      this.YW = whitePoint[1];
+      this.ZW = whitePoint[2];
+      this.XB = blackPoint[0];
+      this.YB = blackPoint[1];
+      this.ZB = blackPoint[2];
+      this.G = gamma;
+
+      if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+        throw new _util.FormatError(`Invalid WhitePoint components for ${this.name}` + ", no fallback available");
+      }
+
+      if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+        (0, _util.info)(`Invalid BlackPoint for ${this.name}, falling back to default.`);
+        this.XB = this.YB = this.ZB = 0;
+      }
+
+      if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
+        (0, _util.warn)(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);
+      }
+
+      if (this.G < 1) {
+        (0, _util.info)(`Invalid Gamma: ${this.G} for ${this.name}, ` + "falling back to default.");
+        this.G = 1;
+      }
+    }
+
+    getRgbItem(src, srcOffset, dest, destOffset) {
+      convertToRgb(this, src, srcOffset, dest, destOffset, 1);
+    }
+
+    getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+      const scale = 1 / ((1 << bits) - 1);
+
+      for (let i = 0; i < count; ++i) {
+        convertToRgb(this, src, srcOffset, dest, destOffset, scale);
+        srcOffset += 1;
+        destOffset += 3 + alpha01;
+      }
+    }
+
+    getOutputLength(inputLength, alpha01) {
+      return inputLength * (3 + alpha01);
+    }
+
+  }
+
+  return CalGrayCS;
+}();
+
+const CalRGBCS = function CalRGBCSClosure() {
+  const BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);
+  const BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([0.9869929, -0.1470543, 0.1599627, 0.4323053, 0.5183603, 0.0492912, -0.0085287, 0.0400428, 0.9684867]);
+  const SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([3.2404542, -1.5371385, -0.4985314, -0.9692660, 1.8760108, 0.0415560, 0.0556434, -0.2040259, 1.0572252]);
+  const FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);
+  const tempNormalizeMatrix = new Float32Array(3);
+  const tempConvertMatrix1 = new Float32Array(3);
+  const tempConvertMatrix2 = new Float32Array(3);
+  const DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;
+
+  function matrixProduct(a, b, result) {
+    result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
+    result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
+  }
+
+  function convertToFlat(sourceWhitePoint, LMS, result) {
+    result[0] = LMS[0] * 1 / sourceWhitePoint[0];
+    result[1] = LMS[1] * 1 / sourceWhitePoint[1];
+    result[2] = LMS[2] * 1 / sourceWhitePoint[2];
+  }
+
+  function convertToD65(sourceWhitePoint, LMS, result) {
+    const D65X = 0.95047;
+    const D65Y = 1;
+    const D65Z = 1.08883;
+    result[0] = LMS[0] * D65X / sourceWhitePoint[0];
+    result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
+    result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
+  }
+
+  function sRGBTransferFunction(color) {
+    if (color <= 0.0031308) {
+      return adjustToRange(0, 1, 12.92 * color);
+    }
+
+    if (color >= 0.99554525) {
+      return 1;
+    }
+
+    return adjustToRange(0, 1, (1 + 0.055) * color ** (1 / 2.4) - 0.055);
+  }
+
+  function adjustToRange(min, max, value) {
+    return Math.max(min, Math.min(max, value));
+  }
+
+  function decodeL(L) {
+    if (L < 0) {
+      return -decodeL(-L);
+    }
+
+    if (L > 8.0) {
+      return ((L + 16) / 116) ** 3;
+    }
+
+    return L * DECODE_L_CONSTANT;
+  }
+
+  function compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
+    if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
+      result[0] = XYZ_Flat[0];
+      result[1] = XYZ_Flat[1];
+      result[2] = XYZ_Flat[2];
+      return;
+    }
+
+    const zeroDecodeL = decodeL(0);
+    const X_DST = zeroDecodeL;
+    const X_SRC = decodeL(sourceBlackPoint[0]);
+    const Y_DST = zeroDecodeL;
+    const Y_SRC = decodeL(sourceBlackPoint[1]);
+    const Z_DST = zeroDecodeL;
+    const Z_SRC = decodeL(sourceBlackPoint[2]);
+    const X_Scale = (1 - X_DST) / (1 - X_SRC);
+    const X_Offset = 1 - X_Scale;
+    const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
+    const Y_Offset = 1 - Y_Scale;
+    const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
+    const Z_Offset = 1 - Z_Scale;
+    result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
+    result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
+    result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
+  }
+
+  function normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
+    if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
+      result[0] = XYZ_In[0];
+      result[1] = XYZ_In[1];
+      result[2] = XYZ_In[2];
+      return;
+    }
+
+    const LMS = result;
+    matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+    const LMS_Flat = tempNormalizeMatrix;
+    convertToFlat(sourceWhitePoint, LMS, LMS_Flat);
+    matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
+  }
+
+  function normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
+    const LMS = result;
+    matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+    const LMS_D65 = tempNormalizeMatrix;
+    convertToD65(sourceWhitePoint, LMS, LMS_D65);
+    matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
+  }
+
+  function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
+    const A = adjustToRange(0, 1, src[srcOffset] * scale);
+    const B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
+    const C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
+    const AGR = A === 1 ? 1 : A ** cs.GR;
+    const BGG = B === 1 ? 1 : B ** cs.GG;
+    const CGB = C === 1 ? 1 : C ** cs.GB;
+    const X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
+    const Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
+    const Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;
+    const XYZ = tempConvertMatrix1;
+    XYZ[0] = X;
+    XYZ[1] = Y;
+    XYZ[2] = Z;
+    const XYZ_Flat = tempConvertMatrix2;
+    normalizeWhitePointToFlat(cs.whitePoint, XYZ, XYZ_Flat);
+    const XYZ_Black = tempConvertMatrix1;
+    compensateBlackPoint(cs.blackPoint, XYZ_Flat, XYZ_Black);
+    const XYZ_D65 = tempConvertMatrix2;
+    normalizeWhitePointToD65(FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
+    const SRGB = tempConvertMatrix1;
+    matrixProduct(SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
+    dest[destOffset] = sRGBTransferFunction(SRGB[0]) * 255;
+    dest[destOffset + 1] = sRGBTransferFunction(SRGB[1]) * 255;
+    dest[destOffset + 2] = sRGBTransferFunction(SRGB[2]) * 255;
+  }
+
+  class CalRGBCS extends ColorSpace {
+    constructor(whitePoint, blackPoint, gamma, matrix) {
+      super("CalRGB", 3);
+
+      if (!whitePoint) {
+        throw new _util.FormatError("WhitePoint missing - required for color space CalRGB");
+      }
+
+      blackPoint = blackPoint || new Float32Array(3);
+      gamma = gamma || new Float32Array([1, 1, 1]);
+      matrix = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+      const XW = whitePoint[0];
+      const YW = whitePoint[1];
+      const ZW = whitePoint[2];
+      this.whitePoint = whitePoint;
+      const XB = blackPoint[0];
+      const YB = blackPoint[1];
+      const ZB = blackPoint[2];
+      this.blackPoint = blackPoint;
+      this.GR = gamma[0];
+      this.GG = gamma[1];
+      this.GB = gamma[2];
+      this.MXA = matrix[0];
+      this.MYA = matrix[1];
+      this.MZA = matrix[2];
+      this.MXB = matrix[3];
+      this.MYB = matrix[4];
+      this.MZB = matrix[5];
+      this.MXC = matrix[6];
+      this.MYC = matrix[7];
+      this.MZC = matrix[8];
+
+      if (XW < 0 || ZW < 0 || YW !== 1) {
+        throw new _util.FormatError(`Invalid WhitePoint components for ${this.name}` + ", no fallback available");
+      }
+
+      if (XB < 0 || YB < 0 || ZB < 0) {
+        (0, _util.info)(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");
+        this.blackPoint = new Float32Array(3);
+      }
+
+      if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
+        (0, _util.info)(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);
+        this.GR = this.GG = this.GB = 1;
+      }
+    }
+
+    getRgbItem(src, srcOffset, dest, destOffset) {
+      convertToRgb(this, src, srcOffset, dest, destOffset, 1);
+    }
+
+    getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+      const scale = 1 / ((1 << bits) - 1);
+
+      for (let i = 0; i < count; ++i) {
+        convertToRgb(this, src, srcOffset, dest, destOffset, scale);
+        srcOffset += 3;
+        destOffset += 3 + alpha01;
+      }
+    }
+
+    getOutputLength(inputLength, alpha01) {
+      return inputLength * (3 + alpha01) / 3 | 0;
+    }
+
+  }
+
+  return CalRGBCS;
+}();
+
+const LabCS = function LabCSClosure() {
+  function fn_g(x) {
+    let result;
+
+    if (x >= 6 / 29) {
+      result = x * x * x;
+    } else {
+      result = 108 / 841 * (x - 4 / 29);
+    }
+
+    return result;
+  }
+
+  function decode(value, high1, low2, high2) {
+    return low2 + value * (high2 - low2) / high1;
+  }
+
+  function convertToRgb(cs, src, srcOffset, maxVal, dest, destOffset) {
+    let Ls = src[srcOffset];
+    let as = src[srcOffset + 1];
+    let bs = src[srcOffset + 2];
+
+    if (maxVal !== false) {
+      Ls = decode(Ls, maxVal, 0, 100);
+      as = decode(as, maxVal, cs.amin, cs.amax);
+      bs = decode(bs, maxVal, cs.bmin, cs.bmax);
+    }
+
+    if (as > cs.amax) {
+      as = cs.amax;
+    } else if (as < cs.amin) {
+      as = cs.amin;
+    }
+
+    if (bs > cs.bmax) {
+      bs = cs.bmax;
+    } else if (bs < cs.bmin) {
+      bs = cs.bmin;
+    }
+
+    const M = (Ls + 16) / 116;
+    const L = M + as / 500;
+    const N = M - bs / 200;
+    const X = cs.XW * fn_g(L);
+    const Y = cs.YW * fn_g(M);
+    const Z = cs.ZW * fn_g(N);
+    let r, g, b;
+
+    if (cs.ZW < 1) {
+      r = X * 3.1339 + Y * -1.617 + Z * -0.4906;
+      g = X * -0.9785 + Y * 1.916 + Z * 0.0333;
+      b = X * 0.072 + Y * -0.229 + Z * 1.4057;
+    } else {
+      r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
+      g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
+      b = X * 0.0557 + Y * -0.204 + Z * 1.057;
+    }
+
+    dest[destOffset] = Math.sqrt(r) * 255;
+    dest[destOffset + 1] = Math.sqrt(g) * 255;
+    dest[destOffset + 2] = Math.sqrt(b) * 255;
+  }
+
+  class LabCS extends ColorSpace {
+    constructor(whitePoint, blackPoint, range) {
+      super("Lab", 3);
+
+      if (!whitePoint) {
+        throw new _util.FormatError("WhitePoint missing - required for color space Lab");
+      }
+
+      blackPoint = blackPoint || [0, 0, 0];
+      range = range || [-100, 100, -100, 100];
+      this.XW = whitePoint[0];
+      this.YW = whitePoint[1];
+      this.ZW = whitePoint[2];
+      this.amin = range[0];
+      this.amax = range[1];
+      this.bmin = range[2];
+      this.bmax = range[3];
+      this.XB = blackPoint[0];
+      this.YB = blackPoint[1];
+      this.ZB = blackPoint[2];
+
+      if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+        throw new _util.FormatError("Invalid WhitePoint components, no fallback available");
+      }
+
+      if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+        (0, _util.info)("Invalid BlackPoint, falling back to default");
+        this.XB = this.YB = this.ZB = 0;
+      }
+
+      if (this.amin > this.amax || this.bmin > this.bmax) {
+        (0, _util.info)("Invalid Range, falling back to defaults");
+        this.amin = -100;
+        this.amax = 100;
+        this.bmin = -100;
+        this.bmax = 100;
+      }
+    }
+
+    getRgbItem(src, srcOffset, dest, destOffset) {
+      convertToRgb(this, src, srcOffset, false, dest, destOffset);
+    }
+
+    getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+      const maxVal = (1 << bits) - 1;
+
+      for (let i = 0; i < count; i++) {
+        convertToRgb(this, src, srcOffset, maxVal, dest, destOffset);
+        srcOffset += 3;
+        destOffset += 3 + alpha01;
+      }
+    }
+
+    getOutputLength(inputLength, alpha01) {
+      return inputLength * (3 + alpha01) / 3 | 0;
+    }
+
+    isDefaultDecode(decodeMap, bpc) {
+      return true;
+    }
+
+    get usesZeroToOneRange() {
+      return (0, _util.shadow)(this, "usesZeroToOneRange", false);
+    }
+
+  }
+
+  return LabCS;
+}();
+
+/***/ }),
+/* 24 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.LocalTilingPatternCache = exports.LocalImageCache = exports.LocalGStateCache = exports.LocalFunctionCache = exports.LocalColorSpaceCache = exports.GlobalImageCache = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+class BaseLocalCache {
+  constructor(options) {
+    if (this.constructor === BaseLocalCache) {
+      (0, _util.unreachable)("Cannot initialize BaseLocalCache.");
+    }
+
+    if (!options || !options.onlyRefs) {
+      this._nameRefMap = new Map();
+      this._imageMap = new Map();
+    }
+
+    this._imageCache = new _primitives.RefSetCache();
+  }
+
+  getByName(name) {
+    const ref = this._nameRefMap.get(name);
+
+    if (ref) {
+      return this.getByRef(ref);
+    }
+
+    return this._imageMap.get(name) || null;
+  }
+
+  getByRef(ref) {
+    return this._imageCache.get(ref) || null;
+  }
+
+  set(name, ref, data) {
+    (0, _util.unreachable)("Abstract method `set` called.");
+  }
+
+}
+
+class LocalImageCache extends BaseLocalCache {
+  set(name, ref = null, data) {
+    if (!name) {
+      throw new Error('LocalImageCache.set - expected "name" argument.');
+    }
+
+    if (ref) {
+      if (this._imageCache.has(ref)) {
+        return;
+      }
+
+      this._nameRefMap.set(name, ref);
+
+      this._imageCache.put(ref, data);
+
+      return;
+    }
+
+    if (this._imageMap.has(name)) {
+      return;
+    }
+
+    this._imageMap.set(name, data);
+  }
+
+}
+
+exports.LocalImageCache = LocalImageCache;
+
+class LocalColorSpaceCache extends BaseLocalCache {
+  set(name = null, ref = null, data) {
+    if (!name && !ref) {
+      throw new Error('LocalColorSpaceCache.set - expected "name" and/or "ref" argument.');
+    }
+
+    if (ref) {
+      if (this._imageCache.has(ref)) {
+        return;
+      }
+
+      if (name) {
+        this._nameRefMap.set(name, ref);
+      }
+
+      this._imageCache.put(ref, data);
+
+      return;
+    }
+
+    if (this._imageMap.has(name)) {
+      return;
+    }
+
+    this._imageMap.set(name, data);
+  }
+
+}
+
+exports.LocalColorSpaceCache = LocalColorSpaceCache;
+
+class LocalFunctionCache extends BaseLocalCache {
+  constructor(options) {
+    super({
+      onlyRefs: true
+    });
+  }
+
+  getByName(name) {
+    (0, _util.unreachable)("Should not call `getByName` method.");
+  }
+
+  set(name = null, ref, data) {
+    if (!ref) {
+      throw new Error('LocalFunctionCache.set - expected "ref" argument.');
+    }
+
+    if (this._imageCache.has(ref)) {
+      return;
+    }
+
+    this._imageCache.put(ref, data);
+  }
+
+}
+
+exports.LocalFunctionCache = LocalFunctionCache;
+
+class LocalGStateCache extends BaseLocalCache {
+  set(name, ref = null, data) {
+    if (!name) {
+      throw new Error('LocalGStateCache.set - expected "name" argument.');
+    }
+
+    if (ref) {
+      if (this._imageCache.has(ref)) {
+        return;
+      }
+
+      this._nameRefMap.set(name, ref);
+
+      this._imageCache.put(ref, data);
+
+      return;
+    }
+
+    if (this._imageMap.has(name)) {
+      return;
+    }
+
+    this._imageMap.set(name, data);
+  }
+
+}
+
+exports.LocalGStateCache = LocalGStateCache;
+
+class LocalTilingPatternCache extends BaseLocalCache {
+  set(name, ref = null, data) {
+    if (!name) {
+      throw new Error('LocalTilingPatternCache.set - expected "name" argument.');
+    }
+
+    if (ref) {
+      if (this._imageCache.has(ref)) {
+        return;
+      }
+
+      this._nameRefMap.set(name, ref);
+
+      this._imageCache.put(ref, data);
+
+      return;
+    }
+
+    if (this._imageMap.has(name)) {
+      return;
+    }
+
+    this._imageMap.set(name, data);
+  }
+
+}
+
+exports.LocalTilingPatternCache = LocalTilingPatternCache;
+
+class GlobalImageCache {
+  static get NUM_PAGES_THRESHOLD() {
+    return (0, _util.shadow)(this, "NUM_PAGES_THRESHOLD", 2);
+  }
+
+  static get MAX_IMAGES_TO_CACHE() {
+    return (0, _util.shadow)(this, "MAX_IMAGES_TO_CACHE", 10);
+  }
+
+  constructor() {
+    this._refCache = new _primitives.RefSetCache();
+    this._imageCache = new _primitives.RefSetCache();
+  }
+
+  shouldCache(ref, pageIndex) {
+    const pageIndexSet = this._refCache.get(ref);
+
+    const numPages = pageIndexSet ? pageIndexSet.size + (pageIndexSet.has(pageIndex) ? 0 : 1) : 1;
+
+    if (numPages < GlobalImageCache.NUM_PAGES_THRESHOLD) {
+      return false;
+    }
+
+    if (!this._imageCache.has(ref) && this._imageCache.size >= GlobalImageCache.MAX_IMAGES_TO_CACHE) {
+      return false;
+    }
+
+    return true;
+  }
+
+  addPageIndex(ref, pageIndex) {
+    let pageIndexSet = this._refCache.get(ref);
+
+    if (!pageIndexSet) {
+      pageIndexSet = new Set();
+
+      this._refCache.put(ref, pageIndexSet);
+    }
+
+    pageIndexSet.add(pageIndex);
+  }
+
+  getData(ref, pageIndex) {
+    const pageIndexSet = this._refCache.get(ref);
+
+    if (!pageIndexSet) {
+      return null;
+    }
+
+    if (pageIndexSet.size < GlobalImageCache.NUM_PAGES_THRESHOLD) {
+      return null;
+    }
+
+    if (!this._imageCache.has(ref)) {
+      return null;
+    }
+
+    pageIndexSet.add(pageIndex);
+    return this._imageCache.get(ref);
+  }
+
+  setData(ref, data) {
+    if (!this._refCache.has(ref)) {
+      throw new Error('GlobalImageCache.setData - expected "addPageIndex" to have been called.');
+    }
+
+    if (this._imageCache.has(ref)) {
+      return;
+    }
+
+    if (this._imageCache.size >= GlobalImageCache.MAX_IMAGES_TO_CACHE) {
+      (0, _util.info)("GlobalImageCache.setData - ignoring image above MAX_IMAGES_TO_CACHE.");
+      return;
+    }
+
+    this._imageCache.put(ref, data);
+  }
+
+  clear(onlyData = false) {
+    if (!onlyData) {
+      this._refCache.clear();
+    }
+
+    this._imageCache.clear();
+  }
+
+}
+
+exports.GlobalImageCache = GlobalImageCache;
+
+/***/ }),
+/* 25 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getQuadPoints = getQuadPoints;
+exports.MarkupAnnotation = exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _obj = __w_pdfjs_require__(10);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _colorspace = __w_pdfjs_require__(23);
+
+var _operator_list = __w_pdfjs_require__(26);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _writer = __w_pdfjs_require__(27);
+
+class AnnotationFactory {
+  static create(xref, ref, pdfManager, idFactory) {
+    return pdfManager.ensureCatalog("acroForm").then(acroForm => {
+      return pdfManager.ensure(this, "_create", [xref, ref, pdfManager, idFactory, acroForm]);
+    });
+  }
+
+  static _create(xref, ref, pdfManager, idFactory, acroForm) {
+    const dict = xref.fetchIfRef(ref);
+
+    if (!(0, _primitives.isDict)(dict)) {
+      return undefined;
+    }
+
+    const id = (0, _primitives.isRef)(ref) ? ref.toString() : `annot_${idFactory.createObjId()}`;
+    let subtype = dict.get("Subtype");
+    subtype = (0, _primitives.isName)(subtype) ? subtype.name : null;
+    const parameters = {
+      xref,
+      ref,
+      dict,
+      subtype,
+      id,
+      pdfManager,
+      acroForm: acroForm instanceof _primitives.Dict ? acroForm : _primitives.Dict.empty
+    };
+
+    switch (subtype) {
+      case "Link":
+        return new LinkAnnotation(parameters);
+
+      case "Text":
+        return new TextAnnotation(parameters);
+
+      case "Widget":
+        let fieldType = (0, _core_utils.getInheritableProperty)({
+          dict,
+          key: "FT"
+        });
+        fieldType = (0, _primitives.isName)(fieldType) ? fieldType.name : null;
+
+        switch (fieldType) {
+          case "Tx":
+            return new TextWidgetAnnotation(parameters);
+
+          case "Btn":
+            return new ButtonWidgetAnnotation(parameters);
+
+          case "Ch":
+            return new ChoiceWidgetAnnotation(parameters);
+        }
+
+        (0, _util.warn)('Unimplemented widget field type "' + fieldType + '", ' + "falling back to base field type.");
+        return new WidgetAnnotation(parameters);
+
+      case "Popup":
+        return new PopupAnnotation(parameters);
+
+      case "FreeText":
+        return new FreeTextAnnotation(parameters);
+
+      case "Line":
+        return new LineAnnotation(parameters);
+
+      case "Square":
+        return new SquareAnnotation(parameters);
+
+      case "Circle":
+        return new CircleAnnotation(parameters);
+
+      case "PolyLine":
+        return new PolylineAnnotation(parameters);
+
+      case "Polygon":
+        return new PolygonAnnotation(parameters);
+
+      case "Caret":
+        return new CaretAnnotation(parameters);
+
+      case "Ink":
+        return new InkAnnotation(parameters);
+
+      case "Highlight":
+        return new HighlightAnnotation(parameters);
+
+      case "Underline":
+        return new UnderlineAnnotation(parameters);
+
+      case "Squiggly":
+        return new SquigglyAnnotation(parameters);
+
+      case "StrikeOut":
+        return new StrikeOutAnnotation(parameters);
+
+      case "Stamp":
+        return new StampAnnotation(parameters);
+
+      case "FileAttachment":
+        return new FileAttachmentAnnotation(parameters);
+
+      default:
+        if (!subtype) {
+          (0, _util.warn)("Annotation is missing the required /Subtype.");
+        } else {
+          (0, _util.warn)('Unimplemented annotation type "' + subtype + '", ' + "falling back to base annotation.");
+        }
+
+        return new Annotation(parameters);
+    }
+  }
+
+}
+
+exports.AnnotationFactory = AnnotationFactory;
+
+function getQuadPoints(dict, rect) {
+  if (!dict.has("QuadPoints")) {
+    return null;
+  }
+
+  const quadPoints = dict.getArray("QuadPoints");
+
+  if (!Array.isArray(quadPoints) || quadPoints.length === 0 || quadPoints.length % 8 > 0) {
+    return null;
+  }
+
+  const quadPointsLists = [];
+
+  for (let i = 0, ii = quadPoints.length / 8; i < ii; i++) {
+    quadPointsLists.push([]);
+
+    for (let j = i * 8, jj = i * 8 + 8; j < jj; j += 2) {
+      const x = quadPoints[j];
+      const y = quadPoints[j + 1];
+
+      if (rect !== null && (x < rect[0] || x > rect[2] || y < rect[1] || y > rect[3])) {
+        return null;
+      }
+
+      quadPointsLists[i].push({
+        x,
+        y
+      });
+    }
+  }
+
+  return quadPointsLists.map(quadPointsList => {
+    const [minX, maxX, minY, maxY] = quadPointsList.reduce(([mX, MX, mY, MY], quadPoint) => [Math.min(mX, quadPoint.x), Math.max(MX, quadPoint.x), Math.min(mY, quadPoint.y), Math.max(MY, quadPoint.y)], [Number.MAX_VALUE, Number.MIN_VALUE, Number.MAX_VALUE, Number.MIN_VALUE]);
+    return [{
+      x: minX,
+      y: maxY
+    }, {
+      x: maxX,
+      y: maxY
+    }, {
+      x: minX,
+      y: minY
+    }, {
+      x: maxX,
+      y: minY
+    }];
+  });
+}
+
+function getTransformMatrix(rect, bbox, matrix) {
+  const [minX, minY, maxX, maxY] = _util.Util.getAxialAlignedBoundingBox(bbox, matrix);
+
+  if (minX === maxX || minY === maxY) {
+    return [1, 0, 0, 1, rect[0], rect[1]];
+  }
+
+  const xRatio = (rect[2] - rect[0]) / (maxX - minX);
+  const yRatio = (rect[3] - rect[1]) / (maxY - minY);
+  return [xRatio, 0, 0, yRatio, rect[0] - minX * xRatio, rect[1] - minY * yRatio];
+}
+
+class Annotation {
+  constructor(params) {
+    const dict = params.dict;
+    this.setContents(dict.get("Contents"));
+    this.setModificationDate(dict.get("M"));
+    this.setFlags(dict.get("F"));
+    this.setRectangle(dict.getArray("Rect"));
+    this.setColor(dict.getArray("C"));
+    this.setBorderStyle(dict);
+    this.setAppearance(dict);
+    this._streams = [];
+
+    if (this.appearance) {
+      this._streams.push(this.appearance);
+    }
+
+    this.data = {
+      annotationFlags: this.flags,
+      borderStyle: this.borderStyle,
+      color: this.color,
+      contents: this.contents,
+      hasAppearance: !!this.appearance,
+      id: params.id,
+      modificationDate: this.modificationDate,
+      rect: this.rectangle,
+      subtype: params.subtype
+    };
+    this._fallbackFontDict = null;
+  }
+
+  _hasFlag(flags, flag) {
+    return !!(flags & flag);
+  }
+
+  _isViewable(flags) {
+    return !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW);
+  }
+
+  _isPrintable(flags) {
+    return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE);
+  }
+
+  isHidden(annotationStorage) {
+    const data = annotationStorage && annotationStorage[this.data.id];
+
+    if (data && "hidden" in data) {
+      return data.hidden;
+    }
+
+    return this._hasFlag(this.flags, _util.AnnotationFlag.HIDDEN);
+  }
+
+  get viewable() {
+    if (this.data.quadPoints === null) {
+      return false;
+    }
+
+    if (this.flags === 0) {
+      return true;
+    }
+
+    return this._isViewable(this.flags);
+  }
+
+  get printable() {
+    if (this.data.quadPoints === null) {
+      return false;
+    }
+
+    if (this.flags === 0) {
+      return false;
+    }
+
+    return this._isPrintable(this.flags);
+  }
+
+  setContents(contents) {
+    this.contents = (0, _util.stringToPDFString)(contents || "");
+  }
+
+  setModificationDate(modificationDate) {
+    this.modificationDate = (0, _util.isString)(modificationDate) ? modificationDate : null;
+  }
+
+  setFlags(flags) {
+    this.flags = Number.isInteger(flags) && flags > 0 ? flags : 0;
+  }
+
+  hasFlag(flag) {
+    return this._hasFlag(this.flags, flag);
+  }
+
+  setRectangle(rectangle) {
+    if (Array.isArray(rectangle) && rectangle.length === 4) {
+      this.rectangle = _util.Util.normalizeRect(rectangle);
+    } else {
+      this.rectangle = [0, 0, 0, 0];
+    }
+  }
+
+  setColor(color) {
+    const rgbColor = new Uint8ClampedArray(3);
+
+    if (!Array.isArray(color)) {
+      this.color = rgbColor;
+      return;
+    }
+
+    switch (color.length) {
+      case 0:
+        this.color = null;
+        break;
+
+      case 1:
+        _colorspace.ColorSpace.singletons.gray.getRgbItem(color, 0, rgbColor, 0);
+
+        this.color = rgbColor;
+        break;
+
+      case 3:
+        _colorspace.ColorSpace.singletons.rgb.getRgbItem(color, 0, rgbColor, 0);
+
+        this.color = rgbColor;
+        break;
+
+      case 4:
+        _colorspace.ColorSpace.singletons.cmyk.getRgbItem(color, 0, rgbColor, 0);
+
+        this.color = rgbColor;
+        break;
+
+      default:
+        this.color = rgbColor;
+        break;
+    }
+  }
+
+  setBorderStyle(borderStyle) {
+    this.borderStyle = new AnnotationBorderStyle();
+
+    if (!(0, _primitives.isDict)(borderStyle)) {
+      return;
+    }
+
+    if (borderStyle.has("BS")) {
+      const dict = borderStyle.get("BS");
+      const dictType = dict.get("Type");
+
+      if (!dictType || (0, _primitives.isName)(dictType, "Border")) {
+        this.borderStyle.setWidth(dict.get("W"), this.rectangle);
+        this.borderStyle.setStyle(dict.get("S"));
+        this.borderStyle.setDashArray(dict.getArray("D"));
+      }
+    } else if (borderStyle.has("Border")) {
+      const array = borderStyle.getArray("Border");
+
+      if (Array.isArray(array) && array.length >= 3) {
+        this.borderStyle.setHorizontalCornerRadius(array[0]);
+        this.borderStyle.setVerticalCornerRadius(array[1]);
+        this.borderStyle.setWidth(array[2], this.rectangle);
+
+        if (array.length === 4) {
+          this.borderStyle.setDashArray(array[3]);
+        }
+      }
+    } else {
+      this.borderStyle.setWidth(0);
+    }
+  }
+
+  setAppearance(dict) {
+    this.appearance = null;
+    const appearanceStates = dict.get("AP");
+
+    if (!(0, _primitives.isDict)(appearanceStates)) {
+      return;
+    }
+
+    const normalAppearanceState = appearanceStates.get("N");
+
+    if ((0, _primitives.isStream)(normalAppearanceState)) {
+      this.appearance = normalAppearanceState;
+      return;
+    }
+
+    if (!(0, _primitives.isDict)(normalAppearanceState)) {
+      return;
+    }
+
+    const as = dict.get("AS");
+
+    if (!(0, _primitives.isName)(as) || !normalAppearanceState.has(as.name)) {
+      return;
+    }
+
+    this.appearance = normalAppearanceState.get(as.name);
+  }
+
+  loadResources(keys) {
+    return this.appearance.dict.getAsync("Resources").then(resources => {
+      if (!resources) {
+        return undefined;
+      }
+
+      const objectLoader = new _obj.ObjectLoader(resources, keys, resources.xref);
+      return objectLoader.load().then(function () {
+        return resources;
+      });
+    });
+  }
+
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
+    if (!this.appearance) {
+      return Promise.resolve(new _operator_list.OperatorList());
+    }
+
+    const appearance = this.appearance;
+    const data = this.data;
+    const appearanceDict = appearance.dict;
+    const resourcesPromise = this.loadResources(["ExtGState", "ColorSpace", "Pattern", "Shading", "XObject", "Font"]);
+    const bbox = appearanceDict.getArray("BBox") || [0, 0, 1, 1];
+    const matrix = appearanceDict.getArray("Matrix") || [1, 0, 0, 1, 0, 0];
+    const transform = getTransformMatrix(data.rect, bbox, matrix);
+    return resourcesPromise.then(resources => {
+      const opList = new _operator_list.OperatorList();
+      opList.addOp(_util.OPS.beginAnnotation, [data.rect, transform, matrix]);
+      return evaluator.getOperatorList({
+        stream: appearance,
+        task,
+        resources,
+        operatorList: opList,
+        fallbackFontDict: this._fallbackFontDict
+      }).then(() => {
+        opList.addOp(_util.OPS.endAnnotation, []);
+        this.reset();
+        return opList;
+      });
+    });
+  }
+
+  async save(evaluator, task, annotationStorage) {
+    return null;
+  }
+
+  getFieldObject() {
+    return null;
+  }
+
+  reset() {
+    for (const stream of this._streams) {
+      stream.reset();
+    }
+  }
+
+}
+
+exports.Annotation = Annotation;
+
+class AnnotationBorderStyle {
+  constructor() {
+    this.width = 1;
+    this.style = _util.AnnotationBorderStyleType.SOLID;
+    this.dashArray = [3];
+    this.horizontalCornerRadius = 0;
+    this.verticalCornerRadius = 0;
+  }
+
+  setWidth(width, rect = [0, 0, 0, 0]) {
+    if ((0, _primitives.isName)(width)) {
+      this.width = 0;
+      return;
+    }
+
+    if (Number.isInteger(width)) {
+      if (width > 0) {
+        const maxWidth = (rect[2] - rect[0]) / 2;
+        const maxHeight = (rect[3] - rect[1]) / 2;
+
+        if (maxWidth > 0 && maxHeight > 0 && (width > maxWidth || width > maxHeight)) {
+          (0, _util.warn)(`AnnotationBorderStyle.setWidth - ignoring width: ${width}`);
+          width = 1;
+        }
+      }
+
+      this.width = width;
+    }
+  }
+
+  setStyle(style) {
+    if (!(0, _primitives.isName)(style)) {
+      return;
+    }
+
+    switch (style.name) {
+      case "S":
+        this.style = _util.AnnotationBorderStyleType.SOLID;
+        break;
+
+      case "D":
+        this.style = _util.AnnotationBorderStyleType.DASHED;
+        break;
+
+      case "B":
+        this.style = _util.AnnotationBorderStyleType.BEVELED;
+        break;
+
+      case "I":
+        this.style = _util.AnnotationBorderStyleType.INSET;
+        break;
+
+      case "U":
+        this.style = _util.AnnotationBorderStyleType.UNDERLINE;
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  setDashArray(dashArray) {
+    if (Array.isArray(dashArray) && dashArray.length > 0) {
+      let isValid = true;
+      let allZeros = true;
+
+      for (const element of dashArray) {
+        const validNumber = +element >= 0;
+
+        if (!validNumber) {
+          isValid = false;
+          break;
+        } else if (element > 0) {
+          allZeros = false;
+        }
+      }
+
+      if (isValid && !allZeros) {
+        this.dashArray = dashArray;
+      } else {
+        this.width = 0;
+      }
+    } else if (dashArray) {
+      this.width = 0;
+    }
+  }
+
+  setHorizontalCornerRadius(radius) {
+    if (Number.isInteger(radius)) {
+      this.horizontalCornerRadius = radius;
+    }
+  }
+
+  setVerticalCornerRadius(radius) {
+    if (Number.isInteger(radius)) {
+      this.verticalCornerRadius = radius;
+    }
+  }
+
+}
+
+exports.AnnotationBorderStyle = AnnotationBorderStyle;
+
+class MarkupAnnotation extends Annotation {
+  constructor(parameters) {
+    super(parameters);
+    const dict = parameters.dict;
+
+    if (dict.has("IRT")) {
+      const rawIRT = dict.getRaw("IRT");
+      this.data.inReplyTo = (0, _primitives.isRef)(rawIRT) ? rawIRT.toString() : null;
+      const rt = dict.get("RT");
+      this.data.replyType = (0, _primitives.isName)(rt) ? rt.name : _util.AnnotationReplyType.REPLY;
+    }
+
+    if (this.data.replyType === _util.AnnotationReplyType.GROUP) {
+      const parent = dict.get("IRT");
+      this.data.title = (0, _util.stringToPDFString)(parent.get("T") || "");
+      this.setContents(parent.get("Contents"));
+      this.data.contents = this.contents;
+
+      if (!parent.has("CreationDate")) {
+        this.data.creationDate = null;
+      } else {
+        this.setCreationDate(parent.get("CreationDate"));
+        this.data.creationDate = this.creationDate;
+      }
+
+      if (!parent.has("M")) {
+        this.data.modificationDate = null;
+      } else {
+        this.setModificationDate(parent.get("M"));
+        this.data.modificationDate = this.modificationDate;
+      }
+
+      this.data.hasPopup = parent.has("Popup");
+
+      if (!parent.has("C")) {
+        this.data.color = null;
+      } else {
+        this.setColor(parent.getArray("C"));
+        this.data.color = this.color;
+      }
+    } else {
+      this.data.title = (0, _util.stringToPDFString)(dict.get("T") || "");
+      this.setCreationDate(dict.get("CreationDate"));
+      this.data.creationDate = this.creationDate;
+      this.data.hasPopup = dict.has("Popup");
+
+      if (!dict.has("C")) {
+        this.data.color = null;
+      }
+    }
+  }
+
+  setCreationDate(creationDate) {
+    this.creationDate = (0, _util.isString)(creationDate) ? creationDate : null;
+  }
+
+  _setDefaultAppearance({
+    xref,
+    extra,
+    strokeColor,
+    fillColor,
+    blendMode,
+    pointsCallback
+  }) {
+    let minX = Number.MAX_VALUE;
+    let minY = Number.MAX_VALUE;
+    let maxX = Number.MIN_VALUE;
+    let maxY = Number.MIN_VALUE;
+    const buffer = ["q"];
+
+    if (extra) {
+      buffer.push(extra);
+    }
+
+    if (strokeColor) {
+      buffer.push(`${strokeColor[0]} ${strokeColor[1]} ${strokeColor[2]} RG`);
+    }
+
+    if (fillColor) {
+      buffer.push(`${fillColor[0]} ${fillColor[1]} ${fillColor[2]} rg`);
+    }
+
+    for (const points of this.data.quadPoints) {
+      const [mX, MX, mY, MY] = pointsCallback(buffer, points);
+      minX = Math.min(minX, mX);
+      maxX = Math.max(maxX, MX);
+      minY = Math.min(minY, mY);
+      maxY = Math.max(maxY, MY);
+    }
+
+    buffer.push("Q");
+    const formDict = new _primitives.Dict(xref);
+    const appearanceStreamDict = new _primitives.Dict(xref);
+    appearanceStreamDict.set("Subtype", _primitives.Name.get("Form"));
+    const appearanceStream = new _stream.StringStream(buffer.join(" "));
+    appearanceStream.dict = appearanceStreamDict;
+    formDict.set("Fm0", appearanceStream);
+    const gsDict = new _primitives.Dict(xref);
+
+    if (blendMode) {
+      gsDict.set("BM", _primitives.Name.get(blendMode));
+    }
+
+    const stateDict = new _primitives.Dict(xref);
+    stateDict.set("GS0", gsDict);
+    const resources = new _primitives.Dict(xref);
+    resources.set("ExtGState", stateDict);
+    resources.set("XObject", formDict);
+    const appearanceDict = new _primitives.Dict(xref);
+    appearanceDict.set("Resources", resources);
+    const bbox = this.data.rect = [minX, minY, maxX, maxY];
+    appearanceDict.set("BBox", bbox);
+    this.appearance = new _stream.StringStream("/GS0 gs /Fm0 Do");
+    this.appearance.dict = appearanceDict;
+
+    this._streams.push(this.appearance, appearanceStream);
+  }
+
+}
+
+exports.MarkupAnnotation = MarkupAnnotation;
+
+class WidgetAnnotation extends Annotation {
+  constructor(params) {
+    super(params);
+    const dict = params.dict;
+    const data = this.data;
+    this.ref = params.ref;
+    data.annotationType = _util.AnnotationType.WIDGET;
+    data.fieldName = this._constructFieldName(dict);
+    data.actions = (0, _core_utils.collectActions)(params.xref, dict, _util.AnnotationActionEventType);
+    const fieldValue = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "V",
+      getArray: true
+    });
+    data.fieldValue = this._decodeFormValue(fieldValue);
+    const defaultFieldValue = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "DV",
+      getArray: true
+    });
+    data.defaultFieldValue = this._decodeFormValue(defaultFieldValue);
+    data.alternativeText = (0, _util.stringToPDFString)(dict.get("TU") || "");
+    const defaultAppearance = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "DA"
+    }) || params.acroForm.get("DA") || "";
+    data.defaultAppearance = (0, _util.isString)(defaultAppearance) ? defaultAppearance : "";
+    const fieldType = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "FT"
+    });
+    data.fieldType = (0, _primitives.isName)(fieldType) ? fieldType.name : null;
+    const localResources = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "DR"
+    });
+    const acroFormResources = params.acroForm.get("DR");
+    const appearanceResources = this.appearance && this.appearance.dict.get("Resources");
+    this._fieldResources = {
+      localResources,
+      acroFormResources,
+      appearanceResources,
+      mergedResources: _primitives.Dict.merge({
+        xref: params.xref,
+        dictArray: [localResources, appearanceResources, acroFormResources],
+        mergeSubDicts: true
+      })
+    };
+    data.fieldFlags = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "Ff"
+    });
+
+    if (!Number.isInteger(data.fieldFlags) || data.fieldFlags < 0) {
+      data.fieldFlags = 0;
+    }
+
+    data.readOnly = this.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
+    data.hidden = this._hasFlag(data.annotationFlags, _util.AnnotationFlag.HIDDEN);
+
+    if (data.fieldType === "Sig") {
+      data.fieldValue = null;
+      this.setFlags(_util.AnnotationFlag.HIDDEN);
+      data.hidden = true;
+    }
+  }
+
+  _constructFieldName(dict) {
+    if (!dict.has("T") && !dict.has("Parent")) {
+      (0, _util.warn)("Unknown field name, falling back to empty field name.");
+      return "";
+    }
+
+    if (!dict.has("Parent")) {
+      return (0, _util.stringToPDFString)(dict.get("T"));
+    }
+
+    const fieldName = [];
+
+    if (dict.has("T")) {
+      fieldName.unshift((0, _util.stringToPDFString)(dict.get("T")));
+    }
+
+    let loopDict = dict;
+
+    while (loopDict.has("Parent")) {
+      loopDict = loopDict.get("Parent");
+
+      if (!(0, _primitives.isDict)(loopDict)) {
+        break;
+      }
+
+      if (loopDict.has("T")) {
+        fieldName.unshift((0, _util.stringToPDFString)(loopDict.get("T")));
+      }
+    }
+
+    return fieldName.join(".");
+  }
+
+  _decodeFormValue(formValue) {
+    if (Array.isArray(formValue)) {
+      return formValue.filter(item => (0, _util.isString)(item)).map(item => (0, _util.stringToPDFString)(item));
+    } else if ((0, _primitives.isName)(formValue)) {
+      return (0, _util.stringToPDFString)(formValue.name);
+    } else if ((0, _util.isString)(formValue)) {
+      return (0, _util.stringToPDFString)(formValue);
+    }
+
+    return null;
+  }
+
+  hasFieldFlag(flag) {
+    return !!(this.data.fieldFlags & flag);
+  }
+
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
+    if (renderForms) {
+      return Promise.resolve(new _operator_list.OperatorList());
+    }
+
+    if (!this._hasText) {
+      return super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+    }
+
+    return this._getAppearance(evaluator, task, annotationStorage).then(content => {
+      if (this.appearance && content === null) {
+        return super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+      }
+
+      const operatorList = new _operator_list.OperatorList();
+
+      if (!this.data.defaultAppearance || content === null) {
+        return operatorList;
+      }
+
+      const matrix = [1, 0, 0, 1, 0, 0];
+      const bbox = [0, 0, this.data.rect[2] - this.data.rect[0], this.data.rect[3] - this.data.rect[1]];
+      const transform = getTransformMatrix(this.data.rect, bbox, matrix);
+      operatorList.addOp(_util.OPS.beginAnnotation, [this.data.rect, transform, matrix]);
+      const stream = new _stream.StringStream(content);
+      return evaluator.getOperatorList({
+        stream,
+        task,
+        resources: this._fieldResources.mergedResources,
+        operatorList
+      }).then(function () {
+        operatorList.addOp(_util.OPS.endAnnotation, []);
+        return operatorList;
+      });
+    });
+  }
+
+  async save(evaluator, task, annotationStorage) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === this.data.fieldValue || value === undefined) {
+      return null;
+    }
+
+    let appearance = await this._getAppearance(evaluator, task, annotationStorage);
+
+    if (appearance === null) {
+      return null;
+    }
+
+    const {
+      xref
+    } = evaluator;
+    const dict = xref.fetchIfRef(this.ref);
+
+    if (!(0, _primitives.isDict)(dict)) {
+      return null;
+    }
+
+    const bbox = [0, 0, this.data.rect[2] - this.data.rect[0], this.data.rect[3] - this.data.rect[1]];
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value
+    };
+    const newRef = xref.getNewRef();
+    const AP = new _primitives.Dict(xref);
+    AP.set("N", newRef);
+    const encrypt = xref.encrypt;
+    let originalTransform = null;
+    let newTransform = null;
+
+    if (encrypt) {
+      originalTransform = encrypt.createCipherTransform(this.ref.num, this.ref.gen);
+      newTransform = encrypt.createCipherTransform(newRef.num, newRef.gen);
+      appearance = newTransform.encryptString(appearance);
+    }
+
+    dict.set("V", (0, _util.isAscii)(value) ? value : (0, _util.stringToUTF16BEString)(value));
+    dict.set("AP", AP);
+    dict.set("M", `D:${(0, _util.getModificationDate)()}`);
+    const appearanceDict = new _primitives.Dict(xref);
+    appearanceDict.set("Length", appearance.length);
+    appearanceDict.set("Subtype", _primitives.Name.get("Form"));
+    appearanceDict.set("Resources", this._getSaveFieldResources(xref));
+    appearanceDict.set("BBox", bbox);
+    const bufferOriginal = [`${this.ref.num} ${this.ref.gen} obj\n`];
+    (0, _writer.writeDict)(dict, bufferOriginal, originalTransform);
+    bufferOriginal.push("\nendobj\n");
+    const bufferNew = [`${newRef.num} ${newRef.gen} obj\n`];
+    (0, _writer.writeDict)(appearanceDict, bufferNew, newTransform);
+    bufferNew.push(" stream\n");
+    bufferNew.push(appearance);
+    bufferNew.push("\nendstream\nendobj\n");
+    return [{
+      ref: this.ref,
+      data: bufferOriginal.join(""),
+      xfa
+    }, {
+      ref: newRef,
+      data: bufferNew.join(""),
+      xfa: null
+    }];
+  }
+
+  async _getAppearance(evaluator, task, annotationStorage) {
+    this._fontName = null;
+    const isPassword = this.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD);
+
+    if (!annotationStorage || isPassword) {
+      return null;
+    }
+
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
+
+    if (value === "") {
+      return "";
+    }
+
+    const defaultPadding = 2;
+    const hPadding = defaultPadding;
+    const totalHeight = this.data.rect[3] - this.data.rect[1];
+    const totalWidth = this.data.rect[2] - this.data.rect[0];
+
+    if (!this.data.defaultAppearance) {
+      this.data.defaultAppearance = "/Helvetica 0 Tf 0 g";
+    }
+
+    const fontInfo = await this._getFontData(evaluator, task);
+    const [font, fontName] = fontInfo;
+
+    const fontSize = this._computeFontSize(...fontInfo, totalHeight);
+
+    this._fontName = fontName;
+    let descent = font.descent;
+
+    if (isNaN(descent)) {
+      descent = 0;
+    }
+
+    const vPadding = defaultPadding + Math.abs(descent) * fontSize;
+    const defaultAppearance = this.data.defaultAppearance;
+    const alignment = this.data.textAlignment;
+
+    if (this.data.multiLine) {
+      return this._getMultilineAppearance(defaultAppearance, value, font, fontSize, totalWidth, totalHeight, alignment, hPadding, vPadding);
+    }
+
+    const encodedString = font.encodeString(value).join("");
+
+    if (this.data.comb) {
+      return this._getCombAppearance(defaultAppearance, font, encodedString, totalWidth, hPadding, vPadding);
+    }
+
+    if (alignment === 0 || alignment > 2) {
+      return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 ${hPadding} ${vPadding} Tm (${(0, _util.escapeString)(encodedString)}) Tj` + " ET Q EMC";
+    }
+
+    const renderedText = this._renderText(encodedString, font, fontSize, totalWidth, alignment, hPadding, vPadding);
+
+    return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 0 0 Tm ${renderedText}` + " ET Q EMC";
+  }
+
+  async _getFontData(evaluator, task) {
+    const operatorList = new _operator_list.OperatorList();
+    const initialState = {
+      fontSize: 0,
+      font: null,
+      fontName: null,
+
+      clone() {
+        return this;
+      }
+
+    };
+    await evaluator.getOperatorList({
+      stream: new _stream.StringStream(this.data.defaultAppearance),
+      task,
+      resources: this._fieldResources.mergedResources,
+      operatorList,
+      initialState
+    });
+    return [initialState.font, initialState.fontName, initialState.fontSize];
+  }
+
+  _computeFontSize(font, fontName, fontSize, height) {
+    if (fontSize === null || fontSize === 0) {
+      let capHeight;
+
+      if (font.capHeight) {
+        capHeight = font.capHeight;
+      } else {
+        const glyphs = font.charsToGlyphs(font.encodeString("M").join(""));
+
+        if (glyphs.length === 1 && glyphs[0].width) {
+          const em = glyphs[0].width / 1000;
+          capHeight = 0.7 * em;
+        } else {
+          capHeight = 0.7;
+        }
+      }
+
+      fontSize = Math.max(1, Math.floor(height / (1.5 * capHeight)));
+      let fontRegex = new RegExp(`/${fontName}\\s+[0-9.]+\\s+Tf`);
+
+      if (this.data.defaultAppearance.search(fontRegex) === -1) {
+        fontRegex = new RegExp(`/${fontName}\\s+Tf`);
+      }
+
+      this.data.defaultAppearance = this.data.defaultAppearance.replace(fontRegex, `/${fontName} ${fontSize} Tf`);
+    }
+
+    return fontSize;
+  }
+
+  _renderText(text, font, fontSize, totalWidth, alignment, hPadding, vPadding) {
+    const glyphs = font.charsToGlyphs(text);
+    const scale = fontSize / 1000;
+    let width = 0;
+
+    for (const glyph of glyphs) {
+      width += glyph.width * scale;
+    }
+
+    let shift;
+
+    if (alignment === 1) {
+      shift = (totalWidth - width) / 2;
+    } else if (alignment === 2) {
+      shift = totalWidth - width - hPadding;
+    } else {
+      shift = hPadding;
+    }
+
+    shift = shift.toFixed(2);
+    vPadding = vPadding.toFixed(2);
+    return `${shift} ${vPadding} Td (${(0, _util.escapeString)(text)}) Tj`;
+  }
+
+  _getSaveFieldResources(xref) {
+    const {
+      localResources,
+      acroFormResources,
+      appearanceResources
+    } = this._fieldResources;
+
+    if (!this._fontName) {
+      return localResources || _primitives.Dict.empty;
+    }
+
+    for (const resources of [localResources, appearanceResources]) {
+      if (resources instanceof _primitives.Dict) {
+        const localFont = resources.get("Font");
+
+        if (localFont instanceof _primitives.Dict && localFont.has(this._fontName)) {
+          return resources;
+        }
+      }
+    }
+
+    if (acroFormResources instanceof _primitives.Dict) {
+      const acroFormFont = acroFormResources.get("Font");
+
+      if (acroFormFont instanceof _primitives.Dict && acroFormFont.has(this._fontName)) {
+        const subFontDict = new _primitives.Dict(xref);
+        subFontDict.set(this._fontName, acroFormFont.getRaw(this._fontName));
+        const subResourcesDict = new _primitives.Dict(xref);
+        subResourcesDict.set("Font", subFontDict);
+        return _primitives.Dict.merge({
+          xref,
+          dictArray: [subResourcesDict, localResources],
+          mergeSubDicts: true
+        });
+      }
+    }
+
+    return localResources || _primitives.Dict.empty;
+  }
+
+  getFieldObject() {
+    if (this.data.fieldType === "Sig") {
+      return {
+        id: this.data.id,
+        value: null,
+        type: "signature"
+      };
+    }
+
+    return null;
+  }
+
+}
+
+class TextWidgetAnnotation extends WidgetAnnotation {
+  constructor(params) {
+    super(params);
+    this._hasText = true;
+    const dict = params.dict;
+
+    if (!(0, _util.isString)(this.data.fieldValue)) {
+      this.data.fieldValue = "";
+    }
+
+    let alignment = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "Q"
+    });
+
+    if (!Number.isInteger(alignment) || alignment < 0 || alignment > 2) {
+      alignment = null;
+    }
+
+    this.data.textAlignment = alignment;
+    let maximumLength = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "MaxLen"
+    });
+
+    if (!Number.isInteger(maximumLength) || maximumLength < 0) {
+      maximumLength = null;
+    }
+
+    this.data.maxLen = maximumLength;
+    this.data.multiLine = this.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE);
+    this.data.comb = this.hasFieldFlag(_util.AnnotationFieldFlag.COMB) && !this.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD) && !this.hasFieldFlag(_util.AnnotationFieldFlag.FILESELECT) && this.data.maxLen !== null;
+  }
+
+  _getCombAppearance(defaultAppearance, font, text, width, hPadding, vPadding) {
+    const combWidth = (width / this.data.maxLen).toFixed(2);
+    const buf = [];
+    const positions = font.getCharPositions(text);
+
+    for (const [start, end] of positions) {
+      buf.push(`(${(0, _util.escapeString)(text.substring(start, end))}) Tj`);
+    }
+
+    const renderedComb = buf.join(` ${combWidth} 0 Td `);
+    return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 ${hPadding} ${vPadding} Tm ${renderedComb}` + " ET Q EMC";
+  }
+
+  _getMultilineAppearance(defaultAppearance, text, font, fontSize, width, height, alignment, hPadding, vPadding) {
+    const lines = text.split(/\r\n|\r|\n/);
+    const buf = [];
+    const totalWidth = width - 2 * hPadding;
+
+    for (const line of lines) {
+      const chunks = this._splitLine(line, font, fontSize, totalWidth);
+
+      for (const chunk of chunks) {
+        const padding = buf.length === 0 ? hPadding : 0;
+        buf.push(this._renderText(chunk, font, fontSize, width, alignment, padding, -fontSize));
+      }
+    }
+
+    const renderedText = buf.join("\n");
+    return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 0 ${height} Tm ${renderedText}` + " ET Q EMC";
+  }
+
+  _splitLine(line, font, fontSize, width) {
+    line = font.encodeString(line).join("");
+    const glyphs = font.charsToGlyphs(line);
+
+    if (glyphs.length <= 1) {
+      return [line];
+    }
+
+    const positions = font.getCharPositions(line);
+    const scale = fontSize / 1000;
+    const chunks = [];
+    let lastSpacePosInStringStart = -1,
+        lastSpacePosInStringEnd = -1,
+        lastSpacePos = -1,
+        startChunk = 0,
+        currentWidth = 0;
+
+    for (let i = 0, ii = glyphs.length; i < ii; i++) {
+      const [start, end] = positions[i];
+      const glyph = glyphs[i];
+      const glyphWidth = glyph.width * scale;
+
+      if (glyph.unicode === " ") {
+        if (currentWidth + glyphWidth > width) {
+          chunks.push(line.substring(startChunk, start));
+          startChunk = start;
+          currentWidth = glyphWidth;
+          lastSpacePosInStringStart = -1;
+          lastSpacePos = -1;
+        } else {
+          currentWidth += glyphWidth;
+          lastSpacePosInStringStart = start;
+          lastSpacePosInStringEnd = end;
+          lastSpacePos = i;
+        }
+      } else {
+        if (currentWidth + glyphWidth > width) {
+          if (lastSpacePosInStringStart !== -1) {
+            chunks.push(line.substring(startChunk, lastSpacePosInStringEnd));
+            startChunk = lastSpacePosInStringEnd;
+            i = lastSpacePos + 1;
+            lastSpacePosInStringStart = -1;
+            currentWidth = 0;
+          } else {
+            chunks.push(line.substring(startChunk, start));
+            startChunk = start;
+            currentWidth = glyphWidth;
+          }
+        } else {
+          currentWidth += glyphWidth;
+        }
+      }
+    }
+
+    if (startChunk < line.length) {
+      chunks.push(line.substring(startChunk, line.length));
+    }
+
+    return chunks;
+  }
+
+  getFieldObject() {
+    return {
+      id: this.data.id,
+      value: this.data.fieldValue,
+      defaultValue: this.data.defaultFieldValue,
+      multiline: this.data.multiLine,
+      password: this.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD),
+      charLimit: this.data.maxLen,
+      comb: this.data.comb,
+      editable: !this.data.readOnly,
+      hidden: this.data.hidden,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      actions: this.data.actions,
+      type: "text"
+    };
+  }
+
+}
+
+class ButtonWidgetAnnotation extends WidgetAnnotation {
+  constructor(params) {
+    super(params);
+    this.checkedAppearance = null;
+    this.uncheckedAppearance = null;
+    this.data.checkBox = !this.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    this.data.radioButton = this.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    this.data.pushButton = this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    this.data.isTooltipOnly = false;
+
+    if (this.data.checkBox) {
+      this._processCheckBox(params);
+    } else if (this.data.radioButton) {
+      this._processRadioButton(params);
+    } else if (this.data.pushButton) {
+      this._processPushButton(params);
+    } else {
+      (0, _util.warn)("Invalid field flags for button widget annotation");
+    }
+  }
+
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
+    if (this.data.pushButton) {
+      return super.getOperatorList(evaluator, task, false, annotationStorage);
+    }
+
+    if (annotationStorage) {
+      const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+      if (value === undefined) {
+        return super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+      }
+
+      let appearance;
+
+      if (value) {
+        appearance = this.checkedAppearance;
+      } else {
+        appearance = this.uncheckedAppearance;
+      }
+
+      if (appearance) {
+        const savedAppearance = this.appearance;
+        this.appearance = appearance;
+        const operatorList = super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+        this.appearance = savedAppearance;
+        return operatorList;
+      }
+
+      return Promise.resolve(new _operator_list.OperatorList());
+    }
+
+    return super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+  }
+
+  async save(evaluator, task, annotationStorage) {
+    if (this.data.checkBox) {
+      return this._saveCheckbox(evaluator, task, annotationStorage);
+    }
+
+    if (this.data.radioButton) {
+      return this._saveRadioButton(evaluator, task, annotationStorage);
+    }
+
+    return null;
+  }
+
+  async _saveCheckbox(evaluator, task, annotationStorage) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
+
+    const defaultValue = this.data.fieldValue && this.data.fieldValue !== "Off";
+
+    if (defaultValue === value) {
+      return null;
+    }
+
+    const dict = evaluator.xref.fetchIfRef(this.ref);
+
+    if (!(0, _primitives.isDict)(dict)) {
+      return null;
+    }
+
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value: value ? this.data.exportValue : ""
+    };
+
+    const name = _primitives.Name.get(value ? this.data.exportValue : "Off");
+
+    dict.set("V", name);
+    dict.set("AS", name);
+    dict.set("M", `D:${(0, _util.getModificationDate)()}`);
+    const encrypt = evaluator.xref.encrypt;
+    let originalTransform = null;
+
+    if (encrypt) {
+      originalTransform = encrypt.createCipherTransform(this.ref.num, this.ref.gen);
+    }
+
+    const buffer = [`${this.ref.num} ${this.ref.gen} obj\n`];
+    (0, _writer.writeDict)(dict, buffer, originalTransform);
+    buffer.push("\nendobj\n");
+    return [{
+      ref: this.ref,
+      data: buffer.join(""),
+      xfa
+    }];
+  }
+
+  async _saveRadioButton(evaluator, task, annotationStorage) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
+
+    const defaultValue = this.data.fieldValue === this.data.buttonValue;
+
+    if (defaultValue === value) {
+      return null;
+    }
+
+    const dict = evaluator.xref.fetchIfRef(this.ref);
+
+    if (!(0, _primitives.isDict)(dict)) {
+      return null;
+    }
+
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value: value ? this.data.buttonValue : ""
+    };
+
+    const name = _primitives.Name.get(value ? this.data.buttonValue : "Off");
+
+    let parentBuffer = null;
+    const encrypt = evaluator.xref.encrypt;
+
+    if (value) {
+      if ((0, _primitives.isRef)(this.parent)) {
+        const parent = evaluator.xref.fetch(this.parent);
+        let parentTransform = null;
+
+        if (encrypt) {
+          parentTransform = encrypt.createCipherTransform(this.parent.num, this.parent.gen);
+        }
+
+        parent.set("V", name);
+        parentBuffer = [`${this.parent.num} ${this.parent.gen} obj\n`];
+        (0, _writer.writeDict)(parent, parentBuffer, parentTransform);
+        parentBuffer.push("\nendobj\n");
+      } else if ((0, _primitives.isDict)(this.parent)) {
+        this.parent.set("V", name);
+      }
+    }
+
+    dict.set("AS", name);
+    dict.set("M", `D:${(0, _util.getModificationDate)()}`);
+    let originalTransform = null;
+
+    if (encrypt) {
+      originalTransform = encrypt.createCipherTransform(this.ref.num, this.ref.gen);
+    }
+
+    const buffer = [`${this.ref.num} ${this.ref.gen} obj\n`];
+    (0, _writer.writeDict)(dict, buffer, originalTransform);
+    buffer.push("\nendobj\n");
+    const newRefs = [{
+      ref: this.ref,
+      data: buffer.join(""),
+      xfa
+    }];
+
+    if (parentBuffer !== null) {
+      newRefs.push({
+        ref: this.parent,
+        data: parentBuffer.join(""),
+        xfa: null
+      });
+    }
+
+    return newRefs;
+  }
+
+  _processCheckBox(params) {
+    const customAppearance = params.dict.get("AP");
+
+    if (!(0, _primitives.isDict)(customAppearance)) {
+      return;
+    }
+
+    const normalAppearance = customAppearance.get("N");
+
+    if (!(0, _primitives.isDict)(normalAppearance)) {
+      return;
+    }
+
+    const exportValues = normalAppearance.getKeys();
+
+    if (!exportValues.includes("Off")) {
+      exportValues.push("Off");
+    }
+
+    if (exportValues.length !== 2) {
+      return;
+    }
+
+    this.data.exportValue = exportValues[0] === "Off" ? exportValues[1] : exportValues[0];
+    this.checkedAppearance = normalAppearance.get(this.data.exportValue);
+    this.uncheckedAppearance = normalAppearance.get("Off") || null;
+
+    this._streams.push(this.checkedAppearance);
+
+    if (this.uncheckedAppearance) {
+      this._streams.push(this.uncheckedAppearance);
+    }
+
+    this._fallbackFontDict = this.fallbackFontDict;
+  }
+
+  _processRadioButton(params) {
+    this.data.fieldValue = this.data.buttonValue = null;
+    const fieldParent = params.dict.get("Parent");
+
+    if ((0, _primitives.isDict)(fieldParent)) {
+      this.parent = params.dict.getRaw("Parent");
+      const fieldParentValue = fieldParent.get("V");
+
+      if ((0, _primitives.isName)(fieldParentValue)) {
+        this.data.fieldValue = this._decodeFormValue(fieldParentValue);
+      }
+    }
+
+    const appearanceStates = params.dict.get("AP");
+
+    if (!(0, _primitives.isDict)(appearanceStates)) {
+      return;
+    }
+
+    const normalAppearance = appearanceStates.get("N");
+
+    if (!(0, _primitives.isDict)(normalAppearance)) {
+      return;
+    }
+
+    for (const key of normalAppearance.getKeys()) {
+      if (key !== "Off") {
+        this.data.buttonValue = this._decodeFormValue(key);
+        break;
+      }
+    }
+
+    this.checkedAppearance = normalAppearance.get(this.data.buttonValue);
+    this.uncheckedAppearance = normalAppearance.get("Off") || null;
+
+    this._streams.push(this.checkedAppearance);
+
+    if (this.uncheckedAppearance) {
+      this._streams.push(this.uncheckedAppearance);
+    }
+
+    this._fallbackFontDict = this.fallbackFontDict;
+  }
+
+  _processPushButton(params) {
+    if (!params.dict.has("A") && !params.dict.has("AA") && !this.data.alternativeText) {
+      (0, _util.warn)("Push buttons without action dictionaries are not supported");
+      return;
+    }
+
+    this.data.isTooltipOnly = !params.dict.has("A") && !params.dict.has("AA");
+
+    _obj.Catalog.parseDestDictionary({
+      destDict: params.dict,
+      resultObj: this.data,
+      docBaseUrl: params.pdfManager.docBaseUrl
+    });
+  }
+
+  getFieldObject() {
+    let type = "button";
+    let exportValues;
+
+    if (this.data.checkBox) {
+      type = "checkbox";
+      exportValues = this.data.exportValue;
+    } else if (this.data.radioButton) {
+      type = "radiobutton";
+      exportValues = this.data.buttonValue;
+    }
+
+    return {
+      id: this.data.id,
+      value: this.data.fieldValue || null,
+      defaultValue: this.data.defaultFieldValue,
+      exportValues,
+      editable: !this.data.readOnly,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      hidden: this.data.hidden,
+      actions: this.data.actions,
+      type
+    };
+  }
+
+  get fallbackFontDict() {
+    const dict = new _primitives.Dict();
+    dict.set("BaseFont", _primitives.Name.get("ZapfDingbats"));
+    dict.set("Type", _primitives.Name.get("FallbackType"));
+    dict.set("Subtype", _primitives.Name.get("FallbackType"));
+    dict.set("Encoding", _primitives.Name.get("ZapfDingbatsEncoding"));
+    return (0, _util.shadow)(this, "fallbackFontDict", dict);
+  }
+
+}
+
+class ChoiceWidgetAnnotation extends WidgetAnnotation {
+  constructor(params) {
+    super(params);
+    this.data.options = [];
+    const options = (0, _core_utils.getInheritableProperty)({
+      dict: params.dict,
+      key: "Opt"
+    });
+
+    if (Array.isArray(options)) {
+      const xref = params.xref;
+
+      for (let i = 0, ii = options.length; i < ii; i++) {
+        const option = xref.fetchIfRef(options[i]);
+        const isOptionArray = Array.isArray(option);
+        this.data.options[i] = {
+          exportValue: this._decodeFormValue(isOptionArray ? xref.fetchIfRef(option[0]) : option),
+          displayValue: this._decodeFormValue(isOptionArray ? xref.fetchIfRef(option[1]) : option)
+        };
+      }
+    }
+
+    if ((0, _util.isString)(this.data.fieldValue)) {
+      this.data.fieldValue = [this.data.fieldValue];
+    } else if (!this.data.fieldValue) {
+      this.data.fieldValue = [];
+    }
+
+    this.data.combo = this.hasFieldFlag(_util.AnnotationFieldFlag.COMBO);
+    this.data.multiSelect = this.hasFieldFlag(_util.AnnotationFieldFlag.MULTISELECT);
+    this._hasText = true;
+  }
+
+  getFieldObject() {
+    const type = this.data.combo ? "combobox" : "listbox";
+    const value = this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : null;
+    return {
+      id: this.data.id,
+      value,
+      defaultValue: this.data.defaultFieldValue,
+      editable: !this.data.readOnly,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      numItems: this.data.fieldValue.length,
+      multipleSelection: this.data.multiSelect,
+      hidden: this.data.hidden,
+      actions: this.data.actions,
+      type
+    };
+  }
+
+}
+
+class TextAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    const DEFAULT_ICON_SIZE = 22;
+    super(parameters);
+    const dict = parameters.dict;
+    this.data.annotationType = _util.AnnotationType.TEXT;
+
+    if (this.data.hasAppearance) {
+      this.data.name = "NoIcon";
+    } else {
+      this.data.rect[1] = this.data.rect[3] - DEFAULT_ICON_SIZE;
+      this.data.rect[2] = this.data.rect[0] + DEFAULT_ICON_SIZE;
+      this.data.name = dict.has("Name") ? dict.get("Name").name : "Note";
+    }
+
+    if (dict.has("State")) {
+      this.data.state = dict.get("State") || null;
+      this.data.stateModel = dict.get("StateModel") || null;
+    } else {
+      this.data.state = null;
+      this.data.stateModel = null;
+    }
+  }
+
+}
+
+class LinkAnnotation extends Annotation {
+  constructor(params) {
+    super(params);
+    this.data.annotationType = _util.AnnotationType.LINK;
+    const quadPoints = getQuadPoints(params.dict, this.rectangle);
+
+    if (quadPoints) {
+      this.data.quadPoints = quadPoints;
+    }
+
+    _obj.Catalog.parseDestDictionary({
+      destDict: params.dict,
+      resultObj: this.data,
+      docBaseUrl: params.pdfManager.docBaseUrl
+    });
+  }
+
+}
+
+class PopupAnnotation extends Annotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.POPUP;
+    let parentItem = parameters.dict.get("Parent");
+
+    if (!parentItem) {
+      (0, _util.warn)("Popup annotation has a missing or invalid parent annotation.");
+      return;
+    }
+
+    const parentSubtype = parentItem.get("Subtype");
+    this.data.parentType = (0, _primitives.isName)(parentSubtype) ? parentSubtype.name : null;
+    const rawParent = parameters.dict.getRaw("Parent");
+    this.data.parentId = (0, _primitives.isRef)(rawParent) ? rawParent.toString() : null;
+    const parentRect = parentItem.getArray("Rect");
+
+    if (Array.isArray(parentRect) && parentRect.length === 4) {
+      this.data.parentRect = _util.Util.normalizeRect(parentRect);
+    } else {
+      this.data.parentRect = [0, 0, 0, 0];
+    }
+
+    const rt = parentItem.get("RT");
+
+    if ((0, _primitives.isName)(rt, _util.AnnotationReplyType.GROUP)) {
+      parentItem = parentItem.get("IRT");
+    }
+
+    if (!parentItem.has("M")) {
+      this.data.modificationDate = null;
+    } else {
+      this.setModificationDate(parentItem.get("M"));
+      this.data.modificationDate = this.modificationDate;
+    }
+
+    if (!parentItem.has("C")) {
+      this.data.color = null;
+    } else {
+      this.setColor(parentItem.getArray("C"));
+      this.data.color = this.color;
+    }
+
+    if (!this.viewable) {
+      const parentFlags = parentItem.get("F");
+
+      if (this._isViewable(parentFlags)) {
+        this.setFlags(parentFlags);
+      }
+    }
+
+    this.data.title = (0, _util.stringToPDFString)(parentItem.get("T") || "");
+    this.data.contents = (0, _util.stringToPDFString)(parentItem.get("Contents") || "");
+  }
+
+}
+
+class FreeTextAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.FREETEXT;
+  }
+
+}
+
+class LineAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.LINE;
+    this.data.lineCoordinates = _util.Util.normalizeRect(parameters.dict.getArray("L"));
+  }
+
+}
+
+class SquareAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.SQUARE;
+  }
+
+}
+
+class CircleAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.CIRCLE;
+  }
+
+}
+
+class PolylineAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.POLYLINE;
+    this.data.vertices = [];
+    const rawVertices = parameters.dict.getArray("Vertices");
+
+    if (!Array.isArray(rawVertices)) {
+      return;
+    }
+
+    for (let i = 0, ii = rawVertices.length; i < ii; i += 2) {
+      this.data.vertices.push({
+        x: rawVertices[i],
+        y: rawVertices[i + 1]
+      });
+    }
+  }
+
+}
+
+class PolygonAnnotation extends PolylineAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.POLYGON;
+  }
+
+}
+
+class CaretAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.CARET;
+  }
+
+}
+
+class InkAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.INK;
+    this.data.inkLists = [];
+    const rawInkLists = parameters.dict.getArray("InkList");
+
+    if (!Array.isArray(rawInkLists)) {
+      return;
+    }
+
+    const xref = parameters.xref;
+
+    for (let i = 0, ii = rawInkLists.length; i < ii; ++i) {
+      this.data.inkLists.push([]);
+
+      for (let j = 0, jj = rawInkLists[i].length; j < jj; j += 2) {
+        this.data.inkLists[i].push({
+          x: xref.fetchIfRef(rawInkLists[i][j]),
+          y: xref.fetchIfRef(rawInkLists[i][j + 1])
+        });
+      }
+    }
+  }
+
+}
+
+class HighlightAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.HIGHLIGHT;
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
+
+    if (quadPoints) {
+      if (!this.appearance) {
+        const fillColor = this.color ? Array.from(this.color).map(c => c / 255) : [1, 1, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          fillColor,
+          blendMode: "Multiply",
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${points[0].x} ${points[0].y} m`);
+            buffer.push(`${points[1].x} ${points[1].y} l`);
+            buffer.push(`${points[3].x} ${points[3].y} l`);
+            buffer.push(`${points[2].x} ${points[2].y} l`);
+            buffer.push("f");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
+    }
+  }
+
+}
+
+class UnderlineAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.UNDERLINE;
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
+
+    if (quadPoints) {
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${points[2].x} ${points[2].y} m`);
+            buffer.push(`${points[3].x} ${points[3].y} l`);
+            buffer.push("S");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
+    }
+  }
+
+}
+
+class SquigglyAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.SQUIGGLY;
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
+
+    if (quadPoints) {
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            const dy = (points[0].y - points[2].y) / 6;
+            let shift = dy;
+            let x = points[2].x;
+            const y = points[2].y;
+            const xEnd = points[3].x;
+            buffer.push(`${x} ${y + shift} m`);
+
+            do {
+              x += 2;
+              shift = shift === 0 ? dy : 0;
+              buffer.push(`${x} ${y + shift} l`);
+            } while (x < xEnd);
+
+            buffer.push("S");
+            return [points[2].x, xEnd, y - 2 * dy, y + 2 * dy];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
+    }
+  }
+
+}
+
+class StrikeOutAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.STRIKEOUT;
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
+
+    if (quadPoints) {
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${(points[0].x + points[2].x) / 2}` + ` ${(points[0].y + points[2].y) / 2} m`);
+            buffer.push(`${(points[1].x + points[3].x) / 2}` + ` ${(points[1].y + points[3].y) / 2} l`);
+            buffer.push("S");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
+    }
+  }
+
+}
+
+class StampAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    this.data.annotationType = _util.AnnotationType.STAMP;
+  }
+
+}
+
+class FileAttachmentAnnotation extends MarkupAnnotation {
+  constructor(parameters) {
+    super(parameters);
+    const file = new _obj.FileSpec(parameters.dict.get("FS"), parameters.xref);
+    this.data.annotationType = _util.AnnotationType.FILEATTACHMENT;
+    this.data.file = file.serializable;
+  }
+
+}
+
+/***/ }),
+/* 26 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.OperatorList = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var QueueOptimizer = function QueueOptimizerClosure() {
+  function addState(parentState, pattern, checkFn, iterateFn, processFn) {
+    var state = parentState;
+
+    for (var i = 0, ii = pattern.length - 1; i < ii; i++) {
+      var item = pattern[i];
+      state = state[item] || (state[item] = []);
+    }
+
+    state[pattern[pattern.length - 1]] = {
+      checkFn,
+      iterateFn,
+      processFn
+    };
+  }
+
+  function handlePaintSolidColorImageMask(iFirstSave, count, fnArray, argsArray) {
+    var iFirstPIMXO = iFirstSave + 2;
+
+    for (var i = 0; i < count; i++) {
+      var arg = argsArray[iFirstPIMXO + 4 * i];
+      var imageMask = arg.length === 1 && arg[0];
+
+      if (imageMask && imageMask.width === 1 && imageMask.height === 1 && (!imageMask.data.length || imageMask.data.length === 1 && imageMask.data[0] === 0)) {
+        fnArray[iFirstPIMXO + 4 * i] = _util.OPS.paintSolidColorImageMask;
+        continue;
+      }
+
+      break;
+    }
+
+    return count - i;
+  }
+
+  var InitialState = [];
+  addState(InitialState, [_util.OPS.save, _util.OPS.transform, _util.OPS.paintInlineImageXObject, _util.OPS.restore], null, function iterateInlineImageGroup(context, i) {
+    var fnArray = context.fnArray;
+    var iFirstSave = context.iCurr - 3;
+    var pos = (i - iFirstSave) % 4;
+
+    switch (pos) {
+      case 0:
+        return fnArray[i] === _util.OPS.save;
+
+      case 1:
+        return fnArray[i] === _util.OPS.transform;
+
+      case 2:
+        return fnArray[i] === _util.OPS.paintInlineImageXObject;
+
+      case 3:
+        return fnArray[i] === _util.OPS.restore;
+    }
+
+    throw new Error(`iterateInlineImageGroup - invalid pos: ${pos}`);
+  }, function foundInlineImageGroup(context, i) {
+    var MIN_IMAGES_IN_INLINE_IMAGES_BLOCK = 10;
+    var MAX_IMAGES_IN_INLINE_IMAGES_BLOCK = 200;
+    var MAX_WIDTH = 1000;
+    var IMAGE_PADDING = 1;
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var curr = context.iCurr;
+    var iFirstSave = curr - 3;
+    var iFirstTransform = curr - 2;
+    var iFirstPIIXO = curr - 1;
+    var count = Math.min(Math.floor((i - iFirstSave) / 4), MAX_IMAGES_IN_INLINE_IMAGES_BLOCK);
+
+    if (count < MIN_IMAGES_IN_INLINE_IMAGES_BLOCK) {
+      return i - (i - iFirstSave) % 4;
+    }
+
+    var maxX = 0;
+    var map = [],
+        maxLineHeight = 0;
+    var currentX = IMAGE_PADDING,
+        currentY = IMAGE_PADDING;
+    var q;
+
+    for (q = 0; q < count; q++) {
+      var transform = argsArray[iFirstTransform + (q << 2)];
+      var img = argsArray[iFirstPIIXO + (q << 2)][0];
+
+      if (currentX + img.width > MAX_WIDTH) {
+        maxX = Math.max(maxX, currentX);
+        currentY += maxLineHeight + 2 * IMAGE_PADDING;
+        currentX = 0;
+        maxLineHeight = 0;
+      }
+
+      map.push({
+        transform,
+        x: currentX,
+        y: currentY,
+        w: img.width,
+        h: img.height
+      });
+      currentX += img.width + 2 * IMAGE_PADDING;
+      maxLineHeight = Math.max(maxLineHeight, img.height);
+    }
+
+    var imgWidth = Math.max(maxX, currentX) + IMAGE_PADDING;
+    var imgHeight = currentY + maxLineHeight + IMAGE_PADDING;
+    var imgData = new Uint8ClampedArray(imgWidth * imgHeight * 4);
+    var imgRowSize = imgWidth << 2;
+
+    for (q = 0; q < count; q++) {
+      var data = argsArray[iFirstPIIXO + (q << 2)][0].data;
+      var rowSize = map[q].w << 2;
+      var dataOffset = 0;
+      var offset = map[q].x + map[q].y * imgWidth << 2;
+      imgData.set(data.subarray(0, rowSize), offset - imgRowSize);
+
+      for (var k = 0, kk = map[q].h; k < kk; k++) {
+        imgData.set(data.subarray(dataOffset, dataOffset + rowSize), offset);
+        dataOffset += rowSize;
+        offset += imgRowSize;
+      }
+
+      imgData.set(data.subarray(dataOffset - rowSize, dataOffset), offset);
+
+      while (offset >= 0) {
+        data[offset - 4] = data[offset];
+        data[offset - 3] = data[offset + 1];
+        data[offset - 2] = data[offset + 2];
+        data[offset - 1] = data[offset + 3];
+        data[offset + rowSize] = data[offset + rowSize - 4];
+        data[offset + rowSize + 1] = data[offset + rowSize - 3];
+        data[offset + rowSize + 2] = data[offset + rowSize - 2];
+        data[offset + rowSize + 3] = data[offset + rowSize - 1];
+        offset -= imgRowSize;
+      }
+    }
+
+    fnArray.splice(iFirstSave, count * 4, _util.OPS.paintInlineImageXObjectGroup);
+    argsArray.splice(iFirstSave, count * 4, [{
+      width: imgWidth,
+      height: imgHeight,
+      kind: _util.ImageKind.RGBA_32BPP,
+      data: imgData
+    }, map]);
+    return iFirstSave + 1;
+  });
+  addState(InitialState, [_util.OPS.save, _util.OPS.transform, _util.OPS.paintImageMaskXObject, _util.OPS.restore], null, function iterateImageMaskGroup(context, i) {
+    var fnArray = context.fnArray;
+    var iFirstSave = context.iCurr - 3;
+    var pos = (i - iFirstSave) % 4;
+
+    switch (pos) {
+      case 0:
+        return fnArray[i] === _util.OPS.save;
+
+      case 1:
+        return fnArray[i] === _util.OPS.transform;
+
+      case 2:
+        return fnArray[i] === _util.OPS.paintImageMaskXObject;
+
+      case 3:
+        return fnArray[i] === _util.OPS.restore;
+    }
+
+    throw new Error(`iterateImageMaskGroup - invalid pos: ${pos}`);
+  }, function foundImageMaskGroup(context, i) {
+    var MIN_IMAGES_IN_MASKS_BLOCK = 10;
+    var MAX_IMAGES_IN_MASKS_BLOCK = 100;
+    var MAX_SAME_IMAGES_IN_MASKS_BLOCK = 1000;
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var curr = context.iCurr;
+    var iFirstSave = curr - 3;
+    var iFirstTransform = curr - 2;
+    var iFirstPIMXO = curr - 1;
+    var count = Math.floor((i - iFirstSave) / 4);
+    count = handlePaintSolidColorImageMask(iFirstSave, count, fnArray, argsArray);
+
+    if (count < MIN_IMAGES_IN_MASKS_BLOCK) {
+      return i - (i - iFirstSave) % 4;
+    }
+
+    var q;
+    var isSameImage = false;
+    var iTransform, transformArgs;
+    var firstPIMXOArg0 = argsArray[iFirstPIMXO][0];
+    const firstTransformArg0 = argsArray[iFirstTransform][0],
+          firstTransformArg1 = argsArray[iFirstTransform][1],
+          firstTransformArg2 = argsArray[iFirstTransform][2],
+          firstTransformArg3 = argsArray[iFirstTransform][3];
+
+    if (firstTransformArg1 === firstTransformArg2) {
+      isSameImage = true;
+      iTransform = iFirstTransform + 4;
+      var iPIMXO = iFirstPIMXO + 4;
+
+      for (q = 1; q < count; q++, iTransform += 4, iPIMXO += 4) {
+        transformArgs = argsArray[iTransform];
+
+        if (argsArray[iPIMXO][0] !== firstPIMXOArg0 || transformArgs[0] !== firstTransformArg0 || transformArgs[1] !== firstTransformArg1 || transformArgs[2] !== firstTransformArg2 || transformArgs[3] !== firstTransformArg3) {
+          if (q < MIN_IMAGES_IN_MASKS_BLOCK) {
+            isSameImage = false;
+          } else {
+            count = q;
+          }
+
+          break;
+        }
+      }
+    }
+
+    if (isSameImage) {
+      count = Math.min(count, MAX_SAME_IMAGES_IN_MASKS_BLOCK);
+      var positions = new Float32Array(count * 2);
+      iTransform = iFirstTransform;
+
+      for (q = 0; q < count; q++, iTransform += 4) {
+        transformArgs = argsArray[iTransform];
+        positions[q << 1] = transformArgs[4];
+        positions[(q << 1) + 1] = transformArgs[5];
+      }
+
+      fnArray.splice(iFirstSave, count * 4, _util.OPS.paintImageMaskXObjectRepeat);
+      argsArray.splice(iFirstSave, count * 4, [firstPIMXOArg0, firstTransformArg0, firstTransformArg1, firstTransformArg2, firstTransformArg3, positions]);
+    } else {
+      count = Math.min(count, MAX_IMAGES_IN_MASKS_BLOCK);
+      var images = [];
+
+      for (q = 0; q < count; q++) {
+        transformArgs = argsArray[iFirstTransform + (q << 2)];
+        var maskParams = argsArray[iFirstPIMXO + (q << 2)][0];
+        images.push({
+          data: maskParams.data,
+          width: maskParams.width,
+          height: maskParams.height,
+          transform: transformArgs
+        });
+      }
+
+      fnArray.splice(iFirstSave, count * 4, _util.OPS.paintImageMaskXObjectGroup);
+      argsArray.splice(iFirstSave, count * 4, [images]);
+    }
+
+    return iFirstSave + 1;
+  });
+  addState(InitialState, [_util.OPS.save, _util.OPS.transform, _util.OPS.paintImageXObject, _util.OPS.restore], function (context) {
+    var argsArray = context.argsArray;
+    var iFirstTransform = context.iCurr - 2;
+    return argsArray[iFirstTransform][1] === 0 && argsArray[iFirstTransform][2] === 0;
+  }, function iterateImageGroup(context, i) {
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var iFirstSave = context.iCurr - 3;
+    var pos = (i - iFirstSave) % 4;
+
+    switch (pos) {
+      case 0:
+        return fnArray[i] === _util.OPS.save;
+
+      case 1:
+        if (fnArray[i] !== _util.OPS.transform) {
+          return false;
+        }
+
+        var iFirstTransform = context.iCurr - 2;
+        var firstTransformArg0 = argsArray[iFirstTransform][0];
+        var firstTransformArg3 = argsArray[iFirstTransform][3];
+
+        if (argsArray[i][0] !== firstTransformArg0 || argsArray[i][1] !== 0 || argsArray[i][2] !== 0 || argsArray[i][3] !== firstTransformArg3) {
+          return false;
+        }
+
+        return true;
+
+      case 2:
+        if (fnArray[i] !== _util.OPS.paintImageXObject) {
+          return false;
+        }
+
+        var iFirstPIXO = context.iCurr - 1;
+        var firstPIXOArg0 = argsArray[iFirstPIXO][0];
+
+        if (argsArray[i][0] !== firstPIXOArg0) {
+          return false;
+        }
+
+        return true;
+
+      case 3:
+        return fnArray[i] === _util.OPS.restore;
+    }
+
+    throw new Error(`iterateImageGroup - invalid pos: ${pos}`);
+  }, function (context, i) {
+    var MIN_IMAGES_IN_BLOCK = 3;
+    var MAX_IMAGES_IN_BLOCK = 1000;
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var curr = context.iCurr;
+    var iFirstSave = curr - 3;
+    var iFirstTransform = curr - 2;
+    var iFirstPIXO = curr - 1;
+    var firstPIXOArg0 = argsArray[iFirstPIXO][0];
+    var firstTransformArg0 = argsArray[iFirstTransform][0];
+    var firstTransformArg3 = argsArray[iFirstTransform][3];
+    var count = Math.min(Math.floor((i - iFirstSave) / 4), MAX_IMAGES_IN_BLOCK);
+
+    if (count < MIN_IMAGES_IN_BLOCK) {
+      return i - (i - iFirstSave) % 4;
+    }
+
+    var positions = new Float32Array(count * 2);
+    var iTransform = iFirstTransform;
+
+    for (var q = 0; q < count; q++, iTransform += 4) {
+      var transformArgs = argsArray[iTransform];
+      positions[q << 1] = transformArgs[4];
+      positions[(q << 1) + 1] = transformArgs[5];
+    }
+
+    var args = [firstPIXOArg0, firstTransformArg0, firstTransformArg3, positions];
+    fnArray.splice(iFirstSave, count * 4, _util.OPS.paintImageXObjectRepeat);
+    argsArray.splice(iFirstSave, count * 4, args);
+    return iFirstSave + 1;
+  });
+  addState(InitialState, [_util.OPS.beginText, _util.OPS.setFont, _util.OPS.setTextMatrix, _util.OPS.showText, _util.OPS.endText], null, function iterateShowTextGroup(context, i) {
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var iFirstSave = context.iCurr - 4;
+    var pos = (i - iFirstSave) % 5;
+
+    switch (pos) {
+      case 0:
+        return fnArray[i] === _util.OPS.beginText;
+
+      case 1:
+        return fnArray[i] === _util.OPS.setFont;
+
+      case 2:
+        return fnArray[i] === _util.OPS.setTextMatrix;
+
+      case 3:
+        if (fnArray[i] !== _util.OPS.showText) {
+          return false;
+        }
+
+        var iFirstSetFont = context.iCurr - 3;
+        var firstSetFontArg0 = argsArray[iFirstSetFont][0];
+        var firstSetFontArg1 = argsArray[iFirstSetFont][1];
+
+        if (argsArray[i][0] !== firstSetFontArg0 || argsArray[i][1] !== firstSetFontArg1) {
+          return false;
+        }
+
+        return true;
+
+      case 4:
+        return fnArray[i] === _util.OPS.endText;
+    }
+
+    throw new Error(`iterateShowTextGroup - invalid pos: ${pos}`);
+  }, function (context, i) {
+    var MIN_CHARS_IN_BLOCK = 3;
+    var MAX_CHARS_IN_BLOCK = 1000;
+    var fnArray = context.fnArray,
+        argsArray = context.argsArray;
+    var curr = context.iCurr;
+    var iFirstBeginText = curr - 4;
+    var iFirstSetFont = curr - 3;
+    var iFirstSetTextMatrix = curr - 2;
+    var iFirstShowText = curr - 1;
+    var iFirstEndText = curr;
+    var firstSetFontArg0 = argsArray[iFirstSetFont][0];
+    var firstSetFontArg1 = argsArray[iFirstSetFont][1];
+    var count = Math.min(Math.floor((i - iFirstBeginText) / 5), MAX_CHARS_IN_BLOCK);
+
+    if (count < MIN_CHARS_IN_BLOCK) {
+      return i - (i - iFirstBeginText) % 5;
+    }
+
+    var iFirst = iFirstBeginText;
+
+    if (iFirstBeginText >= 4 && fnArray[iFirstBeginText - 4] === fnArray[iFirstSetFont] && fnArray[iFirstBeginText - 3] === fnArray[iFirstSetTextMatrix] && fnArray[iFirstBeginText - 2] === fnArray[iFirstShowText] && fnArray[iFirstBeginText - 1] === fnArray[iFirstEndText] && argsArray[iFirstBeginText - 4][0] === firstSetFontArg0 && argsArray[iFirstBeginText - 4][1] === firstSetFontArg1) {
+      count++;
+      iFirst -= 5;
+    }
+
+    var iEndText = iFirst + 4;
+
+    for (var q = 1; q < count; q++) {
+      fnArray.splice(iEndText, 3);
+      argsArray.splice(iEndText, 3);
+      iEndText += 2;
+    }
+
+    return iEndText + 1;
+  });
+
+  function QueueOptimizer(queue) {
+    this.queue = queue;
+    this.state = null;
+    this.context = {
+      iCurr: 0,
+      fnArray: queue.fnArray,
+      argsArray: queue.argsArray
+    };
+    this.match = null;
+    this.lastProcessed = 0;
+  }
+
+  QueueOptimizer.prototype = {
+    _optimize() {
+      const fnArray = this.queue.fnArray;
+      let i = this.lastProcessed,
+          ii = fnArray.length;
+      let state = this.state;
+      let match = this.match;
+
+      if (!state && !match && i + 1 === ii && !InitialState[fnArray[i]]) {
+        this.lastProcessed = ii;
+        return;
+      }
+
+      const context = this.context;
+
+      while (i < ii) {
+        if (match) {
+          const iterate = (0, match.iterateFn)(context, i);
+
+          if (iterate) {
+            i++;
+            continue;
+          }
+
+          i = (0, match.processFn)(context, i + 1);
+          ii = fnArray.length;
+          match = null;
+          state = null;
+
+          if (i >= ii) {
+            break;
+          }
+        }
+
+        state = (state || InitialState)[fnArray[i]];
+
+        if (!state || Array.isArray(state)) {
+          i++;
+          continue;
+        }
+
+        context.iCurr = i;
+        i++;
+
+        if (state.checkFn && !(0, state.checkFn)(context)) {
+          state = null;
+          continue;
+        }
+
+        match = state;
+        state = null;
+      }
+
+      this.state = state;
+      this.match = match;
+      this.lastProcessed = i;
+    },
+
+    push(fn, args) {
+      this.queue.fnArray.push(fn);
+      this.queue.argsArray.push(args);
+
+      this._optimize();
+    },
+
+    flush() {
+      while (this.match) {
+        const length = this.queue.fnArray.length;
+        this.lastProcessed = (0, this.match.processFn)(this.context, length);
+        this.match = null;
+        this.state = null;
+
+        this._optimize();
+      }
+    },
+
+    reset() {
+      this.state = null;
+      this.match = null;
+      this.lastProcessed = 0;
+    }
+
+  };
+  return QueueOptimizer;
+}();
+
+var NullOptimizer = function NullOptimizerClosure() {
+  function NullOptimizer(queue) {
+    this.queue = queue;
+  }
+
+  NullOptimizer.prototype = {
+    push(fn, args) {
+      this.queue.fnArray.push(fn);
+      this.queue.argsArray.push(args);
+    },
+
+    flush() {},
+
+    reset() {}
+
+  };
+  return NullOptimizer;
+}();
+
+var OperatorList = function OperatorListClosure() {
+  var CHUNK_SIZE = 1000;
+  var CHUNK_SIZE_ABOUT = CHUNK_SIZE - 5;
+
+  function OperatorList(intent, streamSink) {
+    this._streamSink = streamSink;
+    this.fnArray = [];
+    this.argsArray = [];
+
+    if (streamSink && intent !== "oplist") {
+      this.optimizer = new QueueOptimizer(this);
+    } else {
+      this.optimizer = new NullOptimizer(this);
+    }
+
+    this.dependencies = new Set();
+    this._totalLength = 0;
+    this.weight = 0;
+    this._resolved = streamSink ? null : Promise.resolve();
+  }
+
+  OperatorList.prototype = {
+    get length() {
+      return this.argsArray.length;
+    },
+
+    get ready() {
+      return this._resolved || this._streamSink.ready;
+    },
+
+    get totalLength() {
+      return this._totalLength + this.length;
+    },
+
+    addOp(fn, args) {
+      this.optimizer.push(fn, args);
+      this.weight++;
+
+      if (this._streamSink) {
+        if (this.weight >= CHUNK_SIZE) {
+          this.flush();
+        } else if (this.weight >= CHUNK_SIZE_ABOUT && (fn === _util.OPS.restore || fn === _util.OPS.endText)) {
+          this.flush();
+        }
+      }
+    },
+
+    addDependency(dependency) {
+      if (this.dependencies.has(dependency)) {
+        return;
+      }
+
+      this.dependencies.add(dependency);
+      this.addOp(_util.OPS.dependency, [dependency]);
+    },
+
+    addDependencies(dependencies) {
+      for (const dependency of dependencies) {
+        this.addDependency(dependency);
+      }
+    },
+
+    addOpList(opList) {
+      if (!(opList instanceof OperatorList)) {
+        (0, _util.warn)('addOpList - ignoring invalid "opList" parameter.');
+        return;
+      }
+
+      for (const dependency of opList.dependencies) {
+        this.dependencies.add(dependency);
+      }
+
+      for (var i = 0, ii = opList.length; i < ii; i++) {
+        this.addOp(opList.fnArray[i], opList.argsArray[i]);
+      }
+    },
+
+    getIR() {
+      return {
+        fnArray: this.fnArray,
+        argsArray: this.argsArray,
+        length: this.length
+      };
+    },
+
+    get _transfers() {
+      const transfers = [];
+      const {
+        fnArray,
+        argsArray,
+        length
+      } = this;
+
+      for (let i = 0; i < length; i++) {
+        switch (fnArray[i]) {
+          case _util.OPS.paintInlineImageXObject:
+          case _util.OPS.paintInlineImageXObjectGroup:
+          case _util.OPS.paintImageMaskXObject:
+            const arg = argsArray[i][0];
+            ;
+
+            if (!arg.cached) {
+              transfers.push(arg.data.buffer);
+            }
+
+            break;
+        }
+      }
+
+      return transfers;
+    },
+
+    flush(lastChunk = false) {
+      this.optimizer.flush();
+      const length = this.length;
+      this._totalLength += length;
+
+      this._streamSink.enqueue({
+        fnArray: this.fnArray,
+        argsArray: this.argsArray,
+        lastChunk,
+        length
+      }, 1, this._transfers);
+
+      this.dependencies.clear();
+      this.fnArray.length = 0;
+      this.argsArray.length = 0;
+      this.weight = 0;
+      this.optimizer.reset();
+    }
+
+  };
+  return OperatorList;
+}();
+
+exports.OperatorList = OperatorList;
+
+/***/ }),
+/* 27 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.incrementalUpdate = incrementalUpdate;
+exports.writeDict = writeDict;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _xml_parser = __w_pdfjs_require__(28);
+
+var _crypto = __w_pdfjs_require__(22);
+
+function writeDict(dict, buffer, transform) {
+  buffer.push("<<");
+
+  for (const key of dict.getKeys()) {
+    buffer.push(` /${(0, _core_utils.escapePDFName)(key)} `);
+    writeValue(dict.getRaw(key), buffer, transform);
+  }
+
+  buffer.push(">>");
+}
+
+function writeStream(stream, buffer, transform) {
+  writeDict(stream.dict, buffer, transform);
+  buffer.push(" stream\n");
+  let string = (0, _util.bytesToString)(stream.getBytes());
+
+  if (transform !== null) {
+    string = transform.encryptString(string);
+  }
+
+  buffer.push(string);
+  buffer.push("\nendstream\n");
+}
+
+function writeArray(array, buffer, transform) {
+  buffer.push("[");
+  let first = true;
+
+  for (const val of array) {
+    if (!first) {
+      buffer.push(" ");
+    } else {
+      first = false;
+    }
+
+    writeValue(val, buffer, transform);
+  }
+
+  buffer.push("]");
+}
+
+function numberToString(value) {
+  if (Number.isInteger(value)) {
+    return value.toString();
+  }
+
+  const roundedValue = Math.round(value * 100);
+
+  if (roundedValue % 100 === 0) {
+    return (roundedValue / 100).toString();
+  }
+
+  if (roundedValue % 10 === 0) {
+    return value.toFixed(1);
+  }
+
+  return value.toFixed(2);
+}
+
+function writeValue(value, buffer, transform) {
+  if ((0, _primitives.isName)(value)) {
+    buffer.push(`/${(0, _core_utils.escapePDFName)(value.name)}`);
+  } else if ((0, _primitives.isRef)(value)) {
+    buffer.push(`${value.num} ${value.gen} R`);
+  } else if (Array.isArray(value)) {
+    writeArray(value, buffer, transform);
+  } else if (typeof value === "string") {
+    if (transform !== null) {
+      value = transform.encryptString(value);
+    }
+
+    buffer.push(`(${(0, _util.escapeString)(value)})`);
+  } else if (typeof value === "number") {
+    buffer.push(numberToString(value));
+  } else if ((0, _primitives.isDict)(value)) {
+    writeDict(value, buffer, transform);
+  } else if ((0, _primitives.isStream)(value)) {
+    writeStream(value, buffer, transform);
+  }
+}
+
+function writeInt(number, size, offset, buffer) {
+  for (let i = size + offset - 1; i > offset - 1; i--) {
+    buffer[i] = number & 0xff;
+    number >>= 8;
+  }
+
+  return offset + size;
+}
+
+function writeString(string, offset, buffer) {
+  for (let i = 0, len = string.length; i < len; i++) {
+    buffer[offset + i] = string.charCodeAt(i) & 0xff;
+  }
+}
+
+function computeMD5(filesize, xrefInfo) {
+  const time = Math.floor(Date.now() / 1000);
+  const filename = xrefInfo.filename || "";
+  const md5Buffer = [time.toString(), filename, filesize.toString()];
+  let md5BufferLen = md5Buffer.reduce((a, str) => a + str.length, 0);
+
+  for (const value of Object.values(xrefInfo.info)) {
+    md5Buffer.push(value);
+    md5BufferLen += value.length;
+  }
+
+  const array = new Uint8Array(md5BufferLen);
+  let offset = 0;
+
+  for (const str of md5Buffer) {
+    writeString(str, offset, array);
+    offset += str.length;
+  }
+
+  return (0, _util.bytesToString)((0, _crypto.calculateMD5)(array));
+}
+
+function updateXFA(datasetsRef, newRefs, xref) {
+  if (datasetsRef === null || xref === null) {
+    return;
+  }
+
+  const datasets = xref.fetchIfRef(datasetsRef);
+  const str = (0, _util.bytesToString)(datasets.getBytes());
+  const xml = new _xml_parser.SimpleXMLParser(true).parseFromString(str);
+
+  for (const {
+    xfa
+  } of newRefs) {
+    if (!xfa) {
+      continue;
+    }
+
+    const {
+      path,
+      value
+    } = xfa;
+
+    if (!path) {
+      continue;
+    }
+
+    const node = xml.documentElement.searchNode((0, _core_utils.parseXFAPath)(path), 0);
+
+    if (node) {
+      node.childNodes = [new _xml_parser.SimpleDOMNode("#text", value)];
+    } else {
+      (0, _util.warn)(`Node not found for path: ${path}`);
+    }
+  }
+
+  const buffer = [];
+  xml.documentElement.dump(buffer);
+  let updatedXml = buffer.join("");
+  const encrypt = xref.encrypt;
+
+  if (encrypt) {
+    const transform = encrypt.createCipherTransform(datasetsRef.num, datasetsRef.gen);
+    updatedXml = transform.encryptString(updatedXml);
+  }
+
+  const data = `${datasetsRef.num} ${datasetsRef.gen} obj\n` + `<< /Type /EmbeddedFile /Length ${updatedXml.length}>>\nstream\n` + updatedXml + "\nendstream\nendobj\n";
+  newRefs.push({
+    ref: datasetsRef,
+    data
+  });
+}
+
+function incrementalUpdate({
+  originalData,
+  xrefInfo,
+  newRefs,
+  xref = null,
+  datasetsRef = null
+}) {
+  updateXFA(datasetsRef, newRefs, xref);
+  const newXref = new _primitives.Dict(null);
+  const refForXrefTable = xrefInfo.newRef;
+  let buffer, baseOffset;
+  const lastByte = originalData[originalData.length - 1];
+
+  if (lastByte === 0x0a || lastByte === 0x0d) {
+    buffer = [];
+    baseOffset = originalData.length;
+  } else {
+    buffer = ["\n"];
+    baseOffset = originalData.length + 1;
+  }
+
+  newXref.set("Size", refForXrefTable.num + 1);
+  newXref.set("Prev", xrefInfo.startXRef);
+  newXref.set("Type", _primitives.Name.get("XRef"));
+
+  if (xrefInfo.rootRef !== null) {
+    newXref.set("Root", xrefInfo.rootRef);
+  }
+
+  if (xrefInfo.infoRef !== null) {
+    newXref.set("Info", xrefInfo.infoRef);
+  }
+
+  if (xrefInfo.encrypt !== null) {
+    newXref.set("Encrypt", xrefInfo.encrypt);
+  }
+
+  newRefs.push({
+    ref: refForXrefTable,
+    data: ""
+  });
+  newRefs = newRefs.sort((a, b) => {
+    return a.ref.num - b.ref.num;
+  });
+  const xrefTableData = [[0, 1, 0xffff]];
+  const indexes = [0, 1];
+  let maxOffset = 0;
+
+  for (const {
+    ref,
+    data
+  } of newRefs) {
+    maxOffset = Math.max(maxOffset, baseOffset);
+    xrefTableData.push([1, baseOffset, Math.min(ref.gen, 0xffff)]);
+    baseOffset += data.length;
+    indexes.push(ref.num);
+    indexes.push(1);
+    buffer.push(data);
+  }
+
+  newXref.set("Index", indexes);
+
+  if (xrefInfo.fileIds.length !== 0) {
+    const md5 = computeMD5(baseOffset, xrefInfo);
+    newXref.set("ID", [xrefInfo.fileIds[0], md5]);
+  }
+
+  const offsetSize = Math.ceil(Math.log2(maxOffset) / 8);
+  const sizes = [1, offsetSize, 2];
+  const structSize = sizes[0] + sizes[1] + sizes[2];
+  const tableLength = structSize * xrefTableData.length;
+  newXref.set("W", sizes);
+  newXref.set("Length", tableLength);
+  buffer.push(`${refForXrefTable.num} ${refForXrefTable.gen} obj\n`);
+  writeDict(newXref, buffer, null);
+  buffer.push(" stream\n");
+  const bufferLen = buffer.reduce((a, str) => a + str.length, 0);
+  const footer = `\nendstream\nendobj\nstartxref\n${baseOffset}\n%%EOF\n`;
+  const array = new Uint8Array(originalData.length + bufferLen + tableLength + footer.length);
+  array.set(originalData);
+  let offset = originalData.length;
+
+  for (const str of buffer) {
+    writeString(str, offset, array);
+    offset += str.length;
+  }
+
+  for (const [type, objOffset, gen] of xrefTableData) {
+    offset = writeInt(type, sizes[0], offset, array);
+    offset = writeInt(objOffset, sizes[1], offset, array);
+    offset = writeInt(gen, sizes[2], offset, array);
+  }
+
+  writeString(footer, offset, array);
+  return array;
+}
+
+/***/ }),
+/* 28 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SimpleXMLParser = exports.SimpleDOMNode = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const XMLParserErrorCode = {
+  NoError: 0,
+  EndOfDocument: -1,
+  UnterminatedCdat: -2,
+  UnterminatedXmlDeclaration: -3,
+  UnterminatedDoctypeDeclaration: -4,
+  UnterminatedComment: -5,
+  MalformedElement: -6,
+  OutOfMemory: -7,
+  UnterminatedAttributeValue: -8,
+  UnterminatedElement: -9,
+  ElementNeverBegun: -10
+};
+
+function isWhitespace(s, index) {
+  const ch = s[index];
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "\t";
+}
+
+function isWhitespaceString(s) {
+  for (let i = 0, ii = s.length; i < ii; i++) {
+    if (!isWhitespace(s, i)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+class XMLParserBase {
+  _resolveEntities(s) {
+    return s.replace(/&([^;]+);/g, (all, entity) => {
+      if (entity.substring(0, 2) === "#x") {
+        return String.fromCodePoint(parseInt(entity.substring(2), 16));
+      } else if (entity.substring(0, 1) === "#") {
+        return String.fromCodePoint(parseInt(entity.substring(1), 10));
+      }
+
+      switch (entity) {
+        case "lt":
+          return "<";
+
+        case "gt":
+          return ">";
+
+        case "amp":
+          return "&";
+
+        case "quot":
+          return '"';
+      }
+
+      return this.onResolveEntity(entity);
+    });
+  }
+
+  _parseContent(s, start) {
+    const attributes = [];
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
+        ++pos;
+      }
+    }
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+
+    while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") {
+      skipWs();
+      let attrName = "",
+          attrValue = "";
+
+      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
+        attrName += s[pos];
+        ++pos;
+      }
+
+      skipWs();
+
+      if (s[pos] !== "=") {
+        return null;
+      }
+
+      ++pos;
+      skipWs();
+      const attrEndChar = s[pos];
+
+      if (attrEndChar !== '"' && attrEndChar !== "'") {
+        return null;
+      }
+
+      const attrEndIndex = s.indexOf(attrEndChar, ++pos);
+
+      if (attrEndIndex < 0) {
+        return null;
+      }
+
+      attrValue = s.substring(pos, attrEndIndex);
+      attributes.push({
+        name: attrName,
+        value: this._resolveEntities(attrValue)
+      });
+      pos = attrEndIndex + 1;
+      skipWs();
+    }
+
+    return {
+      name,
+      attributes,
+      parsed: pos - start
+    };
+  }
+
+  _parseProcessingInstruction(s, start) {
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
+        ++pos;
+      }
+    }
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+    const attrStart = pos;
+
+    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
+      ++pos;
+    }
+
+    const value = s.substring(attrStart, pos);
+    return {
+      name,
+      value,
+      parsed: pos - start
+    };
+  }
+
+  parseXml(s) {
+    let i = 0;
+
+    while (i < s.length) {
+      const ch = s[i];
+      let j = i;
+
+      if (ch === "<") {
+        ++j;
+        const ch2 = s[j];
+        let q;
+
+        switch (ch2) {
+          case "/":
+            ++j;
+            q = s.indexOf(">", j);
+
+            if (q < 0) {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
+
+            this.onEndElement(s.substring(j, q));
+            j = q + 1;
+            break;
+
+          case "?":
+            ++j;
+
+            const pi = this._parseProcessingInstruction(s, j);
+
+            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
+              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
+              return;
+            }
+
+            this.onPi(pi.name, pi.value);
+            j += pi.parsed + 2;
+            break;
+
+          case "!":
+            if (s.substring(j + 1, j + 3) === "--") {
+              q = s.indexOf("-->", j + 3);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedComment);
+                return;
+              }
+
+              this.onComment(s.substring(j + 3, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
+              q = s.indexOf("]]>", j + 8);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedCdat);
+                return;
+              }
+
+              this.onCdata(s.substring(j + 8, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
+              const q2 = s.indexOf("[", j + 8);
+              let complexDoctype = false;
+              q = s.indexOf(">", j + 8);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                return;
+              }
+
+              if (q2 > 0 && q > q2) {
+                q = s.indexOf("]>", j + 8);
+
+                if (q < 0) {
+                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                  return;
+                }
+
+                complexDoctype = true;
+              }
+
+              const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
+              this.onDoctype(doctypeContent);
+              j = q + (complexDoctype ? 2 : 1);
+            } else {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            break;
+
+          default:
+            const content = this._parseContent(s, j);
+
+            if (content === null) {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            let isClosed = false;
+
+            if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") {
+              isClosed = true;
+            } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
+
+            this.onBeginElement(content.name, content.attributes, isClosed);
+            j += content.parsed + (isClosed ? 2 : 1);
+            break;
+        }
+      } else {
+        while (j < s.length && s[j] !== "<") {
+          j++;
+        }
+
+        const text = s.substring(i, j);
+        this.onText(this._resolveEntities(text));
+      }
+
+      i = j;
+    }
+  }
+
+  onResolveEntity(name) {
+    return `&${name};`;
+  }
+
+  onPi(name, value) {}
+
+  onComment(text) {}
+
+  onCdata(text) {}
+
+  onDoctype(doctypeContent) {}
+
+  onText(text) {}
+
+  onBeginElement(name, attributes, isEmpty) {}
+
+  onEndElement(name) {}
+
+  onError(code) {}
+
+}
+
+class SimpleDOMNode {
+  constructor(nodeName, nodeValue) {
+    this.nodeName = nodeName;
+    this.nodeValue = nodeValue;
+    Object.defineProperty(this, "parentNode", {
+      value: null,
+      writable: true
+    });
+  }
+
+  get firstChild() {
+    return this.childNodes && this.childNodes[0];
+  }
+
+  get nextSibling() {
+    const childNodes = this.parentNode.childNodes;
+
+    if (!childNodes) {
+      return undefined;
+    }
+
+    const index = childNodes.indexOf(this);
+
+    if (index === -1) {
+      return undefined;
+    }
+
+    return childNodes[index + 1];
+  }
+
+  get textContent() {
+    if (!this.childNodes) {
+      return this.nodeValue || "";
+    }
+
+    return this.childNodes.map(function (child) {
+      return child.textContent;
+    }).join("");
+  }
+
+  hasChildNodes() {
+    return this.childNodes && this.childNodes.length > 0;
+  }
+
+  searchNode(paths, pos) {
+    if (pos >= paths.length) {
+      return this;
+    }
+
+    const component = paths[pos];
+    const stack = [];
+    let node = this;
+
+    while (true) {
+      if (component.name === node.nodeName) {
+        if (component.pos === 0) {
+          const res = node.searchNode(paths, pos + 1);
+
+          if (res !== null) {
+            return res;
+          }
+        } else if (stack.length === 0) {
+          return null;
+        } else {
+          const [parent] = stack.pop();
+          let siblingPos = 0;
+
+          for (const child of parent.childNodes) {
+            if (component.name === child.nodeName) {
+              if (siblingPos === component.pos) {
+                return child.searchNode(paths, pos + 1);
+              }
+
+              siblingPos++;
+            }
+          }
+
+          return node.searchNode(paths, pos + 1);
+        }
+      }
+
+      if (node.childNodes && node.childNodes.length !== 0) {
+        stack.push([node, 0]);
+        node = node.childNodes[0];
+      } else if (stack.length === 0) {
+        return null;
+      } else {
+        while (stack.length !== 0) {
+          const [parent, currentPos] = stack.pop();
+          const newPos = currentPos + 1;
+
+          if (newPos < parent.childNodes.length) {
+            stack.push([parent, newPos]);
+            node = parent.childNodes[newPos];
+            break;
+          }
+        }
+
+        if (stack.length === 0) {
+          return null;
+        }
+      }
+    }
+  }
+
+  dump(buffer) {
+    if (this.nodeName === "#text") {
+      buffer.push((0, _util.encodeToXmlString)(this.nodeValue));
+      return;
+    }
+
+    buffer.push(`<${this.nodeName}`);
+
+    if (this.attributes) {
+      for (const attribute of this.attributes) {
+        buffer.push(` ${attribute.name}="${(0, _util.encodeToXmlString)(attribute.value)}"`);
+      }
+    }
+
+    if (this.hasChildNodes()) {
+      buffer.push(">");
+
+      for (const child of this.childNodes) {
+        child.dump(buffer);
+      }
+
+      buffer.push(`</${this.nodeName}>`);
+    } else if (this.nodeValue) {
+      buffer.push(`>${(0, _util.encodeToXmlString)(this.nodeValue)}</${this.nodeName}>`);
+    } else {
+      buffer.push("/>");
+    }
+  }
+
+}
+
+exports.SimpleDOMNode = SimpleDOMNode;
+
+class SimpleXMLParser extends XMLParserBase {
+  constructor(hasAttributes = false) {
+    super();
+    this._currentFragment = null;
+    this._stack = null;
+    this._errorCode = XMLParserErrorCode.NoError;
+    this._hasAttributes = hasAttributes;
+  }
+
+  parseFromString(data) {
+    this._currentFragment = [];
+    this._stack = [];
+    this._errorCode = XMLParserErrorCode.NoError;
+    this.parseXml(data);
+
+    if (this._errorCode !== XMLParserErrorCode.NoError) {
+      return undefined;
+    }
+
+    const [documentElement] = this._currentFragment;
+
+    if (!documentElement) {
+      return undefined;
+    }
+
+    return {
+      documentElement
+    };
+  }
+
+  onResolveEntity(name) {
+    switch (name) {
+      case "apos":
+        return "'";
+    }
+
+    return super.onResolveEntity(name);
+  }
+
+  onText(text) {
+    if (isWhitespaceString(text)) {
+      return;
+    }
+
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onCdata(text) {
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onBeginElement(name, attributes, isEmpty) {
+    const node = new SimpleDOMNode(name);
+    node.childNodes = [];
+
+    if (this._hasAttributes) {
+      node.attributes = attributes;
+    }
+
+    this._currentFragment.push(node);
+
+    if (isEmpty) {
+      return;
+    }
+
+    this._stack.push(this._currentFragment);
+
+    this._currentFragment = node.childNodes;
+  }
+
+  onEndElement(name) {
+    this._currentFragment = this._stack.pop() || [];
+    const lastElement = this._currentFragment[this._currentFragment.length - 1];
+
+    if (!lastElement) {
+      return;
+    }
+
+    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
+      lastElement.childNodes[i].parentNode = lastElement;
+    }
+  }
+
+  onError(code) {
+    this._errorCode = code;
+  }
+
+}
+
+exports.SimpleXMLParser = SimpleXMLParser;
+
+/***/ }),
+/* 29 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PartialEvaluator = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _cmap = __w_pdfjs_require__(30);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _fonts = __w_pdfjs_require__(31);
+
+var _encodings = __w_pdfjs_require__(34);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _unicode = __w_pdfjs_require__(37);
+
+var _standard_fonts = __w_pdfjs_require__(36);
+
+var _pattern = __w_pdfjs_require__(40);
+
+var _function = __w_pdfjs_require__(41);
+
+var _parser = __w_pdfjs_require__(11);
+
+var _image_utils = __w_pdfjs_require__(24);
+
+var _bidi = __w_pdfjs_require__(43);
+
+var _colorspace = __w_pdfjs_require__(23);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _glyphlist = __w_pdfjs_require__(35);
+
+var _metrics = __w_pdfjs_require__(44);
+
+var _murmurhash = __w_pdfjs_require__(45);
+
+var _operator_list = __w_pdfjs_require__(26);
+
+var _image = __w_pdfjs_require__(46);
+
+const DefaultPartialEvaluatorOptions = Object.freeze({
+  maxImageSize: -1,
+  disableFontFace: false,
+  ignoreErrors: false,
+  isEvalSupported: true,
+  fontExtraProperties: false
+});
+const PatternType = {
+  TILING: 1,
+  SHADING: 2
+};
+const deferred = Promise.resolve();
+
+function normalizeBlendMode(value, parsingArray = false) {
+  if (Array.isArray(value)) {
+    for (let i = 0, ii = value.length; i < ii; i++) {
+      const maybeBM = normalizeBlendMode(value[i], true);
+
+      if (maybeBM) {
+        return maybeBM;
+      }
+    }
+
+    (0, _util.warn)(`Unsupported blend mode Array: ${value}`);
+    return "source-over";
+  }
+
+  if (!(0, _primitives.isName)(value)) {
+    if (parsingArray) {
+      return null;
+    }
+
+    return "source-over";
+  }
+
+  switch (value.name) {
+    case "Normal":
+    case "Compatible":
+      return "source-over";
+
+    case "Multiply":
+      return "multiply";
+
+    case "Screen":
+      return "screen";
+
+    case "Overlay":
+      return "overlay";
+
+    case "Darken":
+      return "darken";
+
+    case "Lighten":
+      return "lighten";
+
+    case "ColorDodge":
+      return "color-dodge";
+
+    case "ColorBurn":
+      return "color-burn";
+
+    case "HardLight":
+      return "hard-light";
+
+    case "SoftLight":
+      return "soft-light";
+
+    case "Difference":
+      return "difference";
+
+    case "Exclusion":
+      return "exclusion";
+
+    case "Hue":
+      return "hue";
+
+    case "Saturation":
+      return "saturation";
+
+    case "Color":
+      return "color";
+
+    case "Luminosity":
+      return "luminosity";
+  }
+
+  if (parsingArray) {
+    return null;
+  }
+
+  (0, _util.warn)(`Unsupported blend mode: ${value.name}`);
+  return "source-over";
+}
+
+class TimeSlotManager {
+  static get TIME_SLOT_DURATION_MS() {
+    return (0, _util.shadow)(this, "TIME_SLOT_DURATION_MS", 20);
+  }
+
+  static get CHECK_TIME_EVERY() {
+    return (0, _util.shadow)(this, "CHECK_TIME_EVERY", 100);
+  }
+
+  constructor() {
+    this.reset();
+  }
+
+  check() {
+    if (++this.checked < TimeSlotManager.CHECK_TIME_EVERY) {
+      return false;
+    }
+
+    this.checked = 0;
+    return this.endTime <= Date.now();
+  }
+
+  reset() {
+    this.endTime = Date.now() + TimeSlotManager.TIME_SLOT_DURATION_MS;
+    this.checked = 0;
+  }
+
+}
+
+class PartialEvaluator {
+  constructor({
+    xref,
+    handler,
+    pageIndex,
+    idFactory,
+    fontCache,
+    builtInCMapCache,
+    globalImageCache,
+    options = null
+  }) {
+    this.xref = xref;
+    this.handler = handler;
+    this.pageIndex = pageIndex;
+    this.idFactory = idFactory;
+    this.fontCache = fontCache;
+    this.builtInCMapCache = builtInCMapCache;
+    this.globalImageCache = globalImageCache;
+    this.options = options || DefaultPartialEvaluatorOptions;
+    this.parsingType3Font = false;
+    this._fetchBuiltInCMapBound = this.fetchBuiltInCMap.bind(this);
+  }
+
+  get _pdfFunctionFactory() {
+    const pdfFunctionFactory = new _function.PDFFunctionFactory({
+      xref: this.xref,
+      isEvalSupported: this.options.isEvalSupported
+    });
+    return (0, _util.shadow)(this, "_pdfFunctionFactory", pdfFunctionFactory);
+  }
+
+  clone(newOptions = DefaultPartialEvaluatorOptions) {
+    var newEvaluator = Object.create(this);
+    newEvaluator.options = newOptions;
+    return newEvaluator;
+  }
+
+  hasBlendModes(resources, nonBlendModesSet) {
+    if (!(resources instanceof _primitives.Dict)) {
+      return false;
+    }
+
+    if (resources.objId && nonBlendModesSet.has(resources.objId)) {
+      return false;
+    }
+
+    const processed = new _primitives.RefSet(nonBlendModesSet);
+
+    if (resources.objId) {
+      processed.put(resources.objId);
+    }
+
+    var nodes = [resources],
+        xref = this.xref;
+
+    while (nodes.length) {
+      var node = nodes.shift();
+      var graphicStates = node.get("ExtGState");
+
+      if (graphicStates instanceof _primitives.Dict) {
+        for (let graphicState of graphicStates.getRawValues()) {
+          if (graphicState instanceof _primitives.Ref) {
+            if (processed.has(graphicState)) {
+              continue;
+            }
+
+            try {
+              graphicState = xref.fetch(graphicState);
+            } catch (ex) {
+              if (ex instanceof _core_utils.MissingDataException) {
+                throw ex;
+              }
+
+              processed.put(graphicState);
+              (0, _util.info)(`hasBlendModes - ignoring ExtGState: "${ex}".`);
+              continue;
+            }
+          }
+
+          if (!(graphicState instanceof _primitives.Dict)) {
+            continue;
+          }
+
+          if (graphicState.objId) {
+            processed.put(graphicState.objId);
+          }
+
+          const bm = graphicState.get("BM");
+
+          if (bm instanceof _primitives.Name) {
+            if (bm.name !== "Normal") {
+              return true;
+            }
+
+            continue;
+          }
+
+          if (bm !== undefined && Array.isArray(bm)) {
+            for (const element of bm) {
+              if (element instanceof _primitives.Name && element.name !== "Normal") {
+                return true;
+              }
+            }
+          }
+        }
+      }
+
+      var xObjects = node.get("XObject");
+
+      if (!(xObjects instanceof _primitives.Dict)) {
+        continue;
+      }
+
+      for (let xObject of xObjects.getRawValues()) {
+        if (xObject instanceof _primitives.Ref) {
+          if (processed.has(xObject)) {
+            continue;
+          }
+
+          try {
+            xObject = xref.fetch(xObject);
+          } catch (ex) {
+            if (ex instanceof _core_utils.MissingDataException) {
+              throw ex;
+            }
+
+            processed.put(xObject);
+            (0, _util.info)(`hasBlendModes - ignoring XObject: "${ex}".`);
+            continue;
+          }
+        }
+
+        if (!(0, _primitives.isStream)(xObject)) {
+          continue;
+        }
+
+        if (xObject.dict.objId) {
+          processed.put(xObject.dict.objId);
+        }
+
+        var xResources = xObject.dict.get("Resources");
+
+        if (!(xResources instanceof _primitives.Dict)) {
+          continue;
+        }
+
+        if (xResources.objId && processed.has(xResources.objId)) {
+          continue;
+        }
+
+        nodes.push(xResources);
+
+        if (xResources.objId) {
+          processed.put(xResources.objId);
+        }
+      }
+    }
+
+    processed.forEach(ref => {
+      nonBlendModesSet.put(ref);
+    });
+    return false;
+  }
+
+  async fetchBuiltInCMap(name) {
+    const cachedData = this.builtInCMapCache.get(name);
+
+    if (cachedData) {
+      return cachedData;
+    }
+
+    const readableStream = this.handler.sendWithStream("FetchBuiltInCMap", {
+      name
+    });
+    const reader = readableStream.getReader();
+    const data = await new Promise(function (resolve, reject) {
+      function pump() {
+        reader.read().then(function ({
+          value,
+          done
+        }) {
+          if (done) {
+            return;
+          }
+
+          resolve(value);
+          pump();
+        }, reject);
+      }
+
+      pump();
+    });
+
+    if (data.compressionType !== _util.CMapCompressionType.NONE) {
+      this.builtInCMapCache.set(name, data);
+    }
+
+    return data;
+  }
+
+  async buildFormXObject(resources, xobj, smask, operatorList, task, initialState, localColorSpaceCache) {
+    var dict = xobj.dict;
+    var matrix = dict.getArray("Matrix");
+    var bbox = dict.getArray("BBox");
+
+    if (Array.isArray(bbox) && bbox.length === 4) {
+      bbox = _util.Util.normalizeRect(bbox);
+    } else {
+      bbox = null;
+    }
+
+    let optionalContent = null;
+
+    if (dict.has("OC")) {
+      optionalContent = await this.parseMarkedContentProps(dict.get("OC"), resources);
+      operatorList.addOp(_util.OPS.beginMarkedContentProps, ["OC", optionalContent]);
+    }
+
+    var group = dict.get("Group");
+
+    if (group) {
+      var groupOptions = {
+        matrix,
+        bbox,
+        smask,
+        isolated: false,
+        knockout: false
+      };
+      var groupSubtype = group.get("S");
+      var colorSpace = null;
+
+      if ((0, _primitives.isName)(groupSubtype, "Transparency")) {
+        groupOptions.isolated = group.get("I") || false;
+        groupOptions.knockout = group.get("K") || false;
+
+        if (group.has("CS")) {
+          const cs = group.getRaw("CS");
+
+          const cachedColorSpace = _colorspace.ColorSpace.getCached(cs, this.xref, localColorSpaceCache);
+
+          if (cachedColorSpace) {
+            colorSpace = cachedColorSpace;
+          } else {
+            colorSpace = await this.parseColorSpace({
+              cs,
+              resources,
+              localColorSpaceCache
+            });
+          }
+        }
+      }
+
+      if (smask && smask.backdrop) {
+        colorSpace = colorSpace || _colorspace.ColorSpace.singletons.rgb;
+        smask.backdrop = colorSpace.getRgb(smask.backdrop, 0);
+      }
+
+      operatorList.addOp(_util.OPS.beginGroup, [groupOptions]);
+    }
+
+    operatorList.addOp(_util.OPS.paintFormXObjectBegin, [matrix, bbox]);
+    return this.getOperatorList({
+      stream: xobj,
+      task,
+      resources: dict.get("Resources") || resources,
+      operatorList,
+      initialState
+    }).then(function () {
+      operatorList.addOp(_util.OPS.paintFormXObjectEnd, []);
+
+      if (group) {
+        operatorList.addOp(_util.OPS.endGroup, [groupOptions]);
+      }
+
+      if (optionalContent) {
+        operatorList.addOp(_util.OPS.endMarkedContent, []);
+      }
+    });
+  }
+
+  _sendImgData(objId, imgData, cacheGlobally = false) {
+    const transfers = imgData ? [imgData.data.buffer] : null;
+
+    if (this.parsingType3Font || cacheGlobally) {
+      return this.handler.send("commonobj", [objId, "Image", imgData], transfers);
+    }
+
+    return this.handler.send("obj", [objId, this.pageIndex, "Image", imgData], transfers);
+  }
+
+  async buildPaintImageXObject({
+    resources,
+    image,
+    isInline = false,
+    operatorList,
+    cacheKey,
+    localImageCache,
+    localColorSpaceCache
+  }) {
+    var dict = image.dict;
+    const imageRef = dict.objId;
+    var w = dict.get("Width", "W");
+    var h = dict.get("Height", "H");
+
+    if (!(w && (0, _util.isNum)(w)) || !(h && (0, _util.isNum)(h))) {
+      (0, _util.warn)("Image dimensions are missing, or not numbers.");
+      return undefined;
+    }
+
+    var maxImageSize = this.options.maxImageSize;
+
+    if (maxImageSize !== -1 && w * h > maxImageSize) {
+      (0, _util.warn)("Image exceeded maximum allowed size and was removed.");
+      return undefined;
+    }
+
+    var imageMask = dict.get("ImageMask", "IM") || false;
+    var imgData, args;
+
+    if (imageMask) {
+      var width = dict.get("Width", "W");
+      var height = dict.get("Height", "H");
+      var bitStrideLength = width + 7 >> 3;
+      var imgArray = image.getBytes(bitStrideLength * height, true);
+      var decode = dict.getArray("Decode", "D");
+      imgData = _image.PDFImage.createMask({
+        imgArray,
+        width,
+        height,
+        imageIsFromDecodeStream: image instanceof _stream.DecodeStream,
+        inverseDecode: !!decode && decode[0] > 0
+      });
+      imgData.cached = !!cacheKey;
+      args = [imgData];
+      operatorList.addOp(_util.OPS.paintImageMaskXObject, args);
+
+      if (cacheKey) {
+        localImageCache.set(cacheKey, imageRef, {
+          fn: _util.OPS.paintImageMaskXObject,
+          args
+        });
+      }
+
+      return undefined;
+    }
+
+    var softMask = dict.get("SMask", "SM") || false;
+    var mask = dict.get("Mask") || false;
+    var SMALL_IMAGE_DIMENSIONS = 200;
+
+    if (isInline && !softMask && !mask && w + h < SMALL_IMAGE_DIMENSIONS) {
+      const imageObj = new _image.PDFImage({
+        xref: this.xref,
+        res: resources,
+        image,
+        isInline,
+        pdfFunctionFactory: this._pdfFunctionFactory,
+        localColorSpaceCache
+      });
+      imgData = imageObj.createImageData(true);
+      operatorList.addOp(_util.OPS.paintInlineImageXObject, [imgData]);
+      return undefined;
+    }
+
+    let objId = `img_${this.idFactory.createObjId()}`,
+        cacheGlobally = false;
+
+    if (this.parsingType3Font) {
+      objId = `${this.idFactory.getDocId()}_type3_${objId}`;
+    } else if (imageRef) {
+      cacheGlobally = this.globalImageCache.shouldCache(imageRef, this.pageIndex);
+
+      if (cacheGlobally) {
+        objId = `${this.idFactory.getDocId()}_${objId}`;
+      }
+    }
+
+    operatorList.addDependency(objId);
+    args = [objId, w, h];
+
+    _image.PDFImage.buildImage({
+      xref: this.xref,
+      res: resources,
+      image,
+      isInline,
+      pdfFunctionFactory: this._pdfFunctionFactory,
+      localColorSpaceCache
+    }).then(imageObj => {
+      imgData = imageObj.createImageData(false);
+      return this._sendImgData(objId, imgData, cacheGlobally);
+    }).catch(reason => {
+      (0, _util.warn)(`Unable to decode image "${objId}": "${reason}".`);
+      return this._sendImgData(objId, null, cacheGlobally);
+    });
+
+    operatorList.addOp(_util.OPS.paintImageXObject, args);
+
+    if (cacheKey) {
+      localImageCache.set(cacheKey, imageRef, {
+        fn: _util.OPS.paintImageXObject,
+        args
+      });
+
+      if (imageRef) {
+        (0, _util.assert)(!isInline, "Cannot cache an inline image globally.");
+        this.globalImageCache.addPageIndex(imageRef, this.pageIndex);
+
+        if (cacheGlobally) {
+          this.globalImageCache.setData(imageRef, {
+            objId,
+            fn: _util.OPS.paintImageXObject,
+            args
+          });
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  handleSMask(smask, resources, operatorList, task, stateManager, localColorSpaceCache) {
+    var smaskContent = smask.get("G");
+    var smaskOptions = {
+      subtype: smask.get("S").name,
+      backdrop: smask.get("BC")
+    };
+    var transferObj = smask.get("TR");
+
+    if ((0, _function.isPDFFunction)(transferObj)) {
+      const transferFn = this._pdfFunctionFactory.create(transferObj);
+
+      var transferMap = new Uint8Array(256);
+      var tmp = new Float32Array(1);
+
+      for (var i = 0; i < 256; i++) {
+        tmp[0] = i / 255;
+        transferFn(tmp, 0, tmp, 0);
+        transferMap[i] = tmp[0] * 255 | 0;
+      }
+
+      smaskOptions.transferMap = transferMap;
+    }
+
+    return this.buildFormXObject(resources, smaskContent, smaskOptions, operatorList, task, stateManager.state.clone(), localColorSpaceCache);
+  }
+
+  handleTransferFunction(tr) {
+    let transferArray;
+
+    if (Array.isArray(tr)) {
+      transferArray = tr;
+    } else if ((0, _function.isPDFFunction)(tr)) {
+      transferArray = [tr];
+    } else {
+      return null;
+    }
+
+    const transferMaps = [];
+    let numFns = 0,
+        numEffectfulFns = 0;
+
+    for (const entry of transferArray) {
+      const transferObj = this.xref.fetchIfRef(entry);
+      numFns++;
+
+      if ((0, _primitives.isName)(transferObj, "Identity")) {
+        transferMaps.push(null);
+        continue;
+      } else if (!(0, _function.isPDFFunction)(transferObj)) {
+        return null;
+      }
+
+      const transferFn = this._pdfFunctionFactory.create(transferObj);
+
+      const transferMap = new Uint8Array(256),
+            tmp = new Float32Array(1);
+
+      for (let j = 0; j < 256; j++) {
+        tmp[0] = j / 255;
+        transferFn(tmp, 0, tmp, 0);
+        transferMap[j] = tmp[0] * 255 | 0;
+      }
+
+      transferMaps.push(transferMap);
+      numEffectfulFns++;
+    }
+
+    if (!(numFns === 1 || numFns === 4)) {
+      return null;
+    }
+
+    if (numEffectfulFns === 0) {
+      return null;
+    }
+
+    return transferMaps;
+  }
+
+  handleTilingType(fn, color, resources, pattern, patternDict, operatorList, task, cacheKey, localTilingPatternCache) {
+    const tilingOpList = new _operator_list.OperatorList();
+
+    const patternResources = _primitives.Dict.merge({
+      xref: this.xref,
+      dictArray: [patternDict.get("Resources"), resources]
+    });
+
+    return this.getOperatorList({
+      stream: pattern,
+      task,
+      resources: patternResources,
+      operatorList: tilingOpList
+    }).then(function () {
+      const operatorListIR = tilingOpList.getIR();
+      const tilingPatternIR = (0, _pattern.getTilingPatternIR)(operatorListIR, patternDict, color);
+      operatorList.addDependencies(tilingOpList.dependencies);
+      operatorList.addOp(fn, tilingPatternIR);
+
+      if (cacheKey) {
+        localTilingPatternCache.set(cacheKey, patternDict.objId, {
+          operatorListIR,
+          dict: patternDict
+        });
+      }
+    }).catch(reason => {
+      if (reason instanceof _util.AbortException) {
+        return;
+      }
+
+      if (this.options.ignoreErrors) {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.errorTilingPattern
+        });
+        (0, _util.warn)(`handleTilingType - ignoring pattern: "${reason}".`);
+        return;
+      }
+
+      throw reason;
+    });
+  }
+
+  handleSetFont(resources, fontArgs, fontRef, operatorList, task, state, fallbackFontDict = null) {
+    var fontName,
+        fontSize = 0;
+
+    if (fontArgs) {
+      fontArgs = fontArgs.slice();
+      fontName = fontArgs[0].name;
+      fontSize = fontArgs[1];
+    }
+
+    return this.loadFont(fontName, fontRef, resources, fallbackFontDict).then(translated => {
+      if (!translated.font.isType3Font) {
+        return translated;
+      }
+
+      return translated.loadType3Data(this, resources, task).then(function () {
+        operatorList.addDependencies(translated.type3Dependencies);
+        return translated;
+      }).catch(reason => {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadType3
+        });
+        return new TranslatedFont({
+          loadedName: "g_font_error",
+          font: new _fonts.ErrorFont(`Type3 font load error: ${reason}`),
+          dict: translated.font,
+          extraProperties: this.options.fontExtraProperties
+        });
+      });
+    }).then(translated => {
+      state.font = translated.font;
+      state.fontSize = fontSize;
+      state.fontName = fontName;
+      translated.send(this.handler);
+      return translated.loadedName;
+    });
+  }
+
+  handleText(chars, state) {
+    const font = state.font;
+    const glyphs = font.charsToGlyphs(chars);
+
+    if (font.data) {
+      const isAddToPathSet = !!(state.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
+
+      if (isAddToPathSet || state.fillColorSpace.name === "Pattern" || font.disableFontFace || this.options.disableFontFace) {
+        PartialEvaluator.buildFontPaths(font, glyphs, this.handler);
+      }
+    }
+
+    return glyphs;
+  }
+
+  ensureStateFont(state) {
+    if (state.font) {
+      return;
+    }
+
+    const reason = new _util.FormatError("Missing setFont (Tf) operator before text rendering operator.");
+
+    if (this.options.ignoreErrors) {
+      this.handler.send("UnsupportedFeature", {
+        featureId: _util.UNSUPPORTED_FEATURES.errorFontState
+      });
+      (0, _util.warn)(`ensureStateFont: "${reason}".`);
+      return;
+    }
+
+    throw reason;
+  }
+
+  async setGState({
+    resources,
+    gState,
+    operatorList,
+    cacheKey,
+    task,
+    stateManager,
+    localGStateCache,
+    localColorSpaceCache
+  }) {
+    const gStateRef = gState.objId;
+    let isSimpleGState = true;
+    var gStateObj = [];
+    var gStateKeys = gState.getKeys();
+    var promise = Promise.resolve();
+
+    for (var i = 0, ii = gStateKeys.length; i < ii; i++) {
+      const key = gStateKeys[i];
+      const value = gState.get(key);
+
+      switch (key) {
+        case "Type":
+          break;
+
+        case "LW":
+        case "LC":
+        case "LJ":
+        case "ML":
+        case "D":
+        case "RI":
+        case "FL":
+        case "CA":
+        case "ca":
+          gStateObj.push([key, value]);
+          break;
+
+        case "Font":
+          isSimpleGState = false;
+          promise = promise.then(() => {
+            return this.handleSetFont(resources, null, value[0], operatorList, task, stateManager.state).then(function (loadedName) {
+              operatorList.addDependency(loadedName);
+              gStateObj.push([key, [loadedName, value[1]]]);
+            });
+          });
+          break;
+
+        case "BM":
+          gStateObj.push([key, normalizeBlendMode(value)]);
+          break;
+
+        case "SMask":
+          if ((0, _primitives.isName)(value, "None")) {
+            gStateObj.push([key, false]);
+            break;
+          }
+
+          if ((0, _primitives.isDict)(value)) {
+            isSimpleGState = false;
+            promise = promise.then(() => {
+              return this.handleSMask(value, resources, operatorList, task, stateManager, localColorSpaceCache);
+            });
+            gStateObj.push([key, true]);
+          } else {
+            (0, _util.warn)("Unsupported SMask type");
+          }
+
+          break;
+
+        case "TR":
+          const transferMaps = this.handleTransferFunction(value);
+          gStateObj.push([key, transferMaps]);
+          break;
+
+        case "OP":
+        case "op":
+        case "OPM":
+        case "BG":
+        case "BG2":
+        case "UCR":
+        case "UCR2":
+        case "TR2":
+        case "HT":
+        case "SM":
+        case "SA":
+        case "AIS":
+        case "TK":
+          (0, _util.info)("graphic state operator " + key);
+          break;
+
+        default:
+          (0, _util.info)("Unknown graphic state operator " + key);
+          break;
+      }
+    }
+
+    return promise.then(function () {
+      if (gStateObj.length > 0) {
+        operatorList.addOp(_util.OPS.setGState, [gStateObj]);
+      }
+
+      if (isSimpleGState) {
+        localGStateCache.set(cacheKey, gStateRef, gStateObj);
+      }
+    });
+  }
+
+  loadFont(fontName, font, resources, fallbackFontDict = null) {
+    const errorFont = async () => {
+      return new TranslatedFont({
+        loadedName: "g_font_error",
+        font: new _fonts.ErrorFont(`Font "${fontName}" is not available.`),
+        dict: font,
+        extraProperties: this.options.fontExtraProperties
+      });
+    };
+
+    var fontRef,
+        xref = this.xref;
+
+    if (font) {
+      if (!(0, _primitives.isRef)(font)) {
+        throw new _util.FormatError('The "font" object should be a reference.');
+      }
+
+      fontRef = font;
+    } else {
+      var fontRes = resources.get("Font");
+
+      if (fontRes) {
+        fontRef = fontRes.getRaw(fontName);
+      }
+    }
+
+    if (!fontRef) {
+      const partialMsg = `Font "${fontName || font && font.toString()}" is not available`;
+
+      if (!this.options.ignoreErrors && !this.parsingType3Font) {
+        (0, _util.warn)(`${partialMsg}.`);
+        return errorFont();
+      }
+
+      this.handler.send("UnsupportedFeature", {
+        featureId: _util.UNSUPPORTED_FEATURES.errorFontMissing
+      });
+      (0, _util.warn)(`${partialMsg} -- attempting to fallback to a default font.`);
+
+      if (fallbackFontDict) {
+        fontRef = fallbackFontDict;
+      } else {
+        fontRef = PartialEvaluator.fallbackFontDict;
+      }
+    }
+
+    if (this.fontCache.has(fontRef)) {
+      return this.fontCache.get(fontRef);
+    }
+
+    font = xref.fetchIfRef(fontRef);
+
+    if (!(0, _primitives.isDict)(font)) {
+      return errorFont();
+    }
+
+    if (font.cacheKey && this.fontCache.has(font.cacheKey)) {
+      return this.fontCache.get(font.cacheKey);
+    }
+
+    var fontCapability = (0, _util.createPromiseCapability)();
+    let preEvaluatedFont;
+
+    try {
+      preEvaluatedFont = this.preEvaluateFont(font);
+    } catch (reason) {
+      (0, _util.warn)(`loadFont - ignoring preEvaluateFont errors: "${reason}".`);
+      return errorFont();
+    }
+
+    const {
+      descriptor,
+      hash
+    } = preEvaluatedFont;
+    var fontRefIsRef = (0, _primitives.isRef)(fontRef),
+        fontID;
+
+    if (fontRefIsRef) {
+      fontID = `f${fontRef.toString()}`;
+    }
+
+    if (hash && (0, _primitives.isDict)(descriptor)) {
+      if (!descriptor.fontAliases) {
+        descriptor.fontAliases = Object.create(null);
+      }
+
+      var fontAliases = descriptor.fontAliases;
+
+      if (fontAliases[hash]) {
+        var aliasFontRef = fontAliases[hash].aliasRef;
+
+        if (fontRefIsRef && aliasFontRef && this.fontCache.has(aliasFontRef)) {
+          this.fontCache.putAlias(fontRef, aliasFontRef);
+          return this.fontCache.get(fontRef);
+        }
+      } else {
+        fontAliases[hash] = {
+          fontID: this.idFactory.createFontId()
+        };
+      }
+
+      if (fontRefIsRef) {
+        fontAliases[hash].aliasRef = fontRef;
+      }
+
+      fontID = fontAliases[hash].fontID;
+    }
+
+    if (fontRefIsRef) {
+      this.fontCache.put(fontRef, fontCapability.promise);
+    } else {
+      if (!fontID) {
+        fontID = this.idFactory.createFontId();
+      }
+
+      font.cacheKey = `cacheKey_${fontID}`;
+      this.fontCache.put(font.cacheKey, fontCapability.promise);
+    }
+
+    (0, _util.assert)(fontID && fontID.startsWith("f"), 'The "fontID" must be (correctly) defined.');
+    font.loadedName = `${this.idFactory.getDocId()}_${fontID}`;
+    this.translateFont(preEvaluatedFont).then(translatedFont => {
+      if (translatedFont.fontType !== undefined) {
+        var xrefFontStats = xref.stats.fontTypes;
+        xrefFontStats[translatedFont.fontType] = true;
+      }
+
+      fontCapability.resolve(new TranslatedFont({
+        loadedName: font.loadedName,
+        font: translatedFont,
+        dict: font,
+        extraProperties: this.options.fontExtraProperties
+      }));
+    }).catch(reason => {
+      this.handler.send("UnsupportedFeature", {
+        featureId: _util.UNSUPPORTED_FEATURES.errorFontTranslate
+      });
+
+      try {
+        var fontFile3 = descriptor && descriptor.get("FontFile3");
+        var subtype = fontFile3 && fontFile3.get("Subtype");
+        var fontType = (0, _fonts.getFontType)(preEvaluatedFont.type, subtype && subtype.name);
+        var xrefFontStats = xref.stats.fontTypes;
+        xrefFontStats[fontType] = true;
+      } catch (ex) {}
+
+      fontCapability.resolve(new TranslatedFont({
+        loadedName: font.loadedName,
+        font: new _fonts.ErrorFont(reason instanceof Error ? reason.message : reason),
+        dict: font,
+        extraProperties: this.options.fontExtraProperties
+      }));
+    });
+    return fontCapability.promise;
+  }
+
+  buildPath(operatorList, fn, args, parsingText = false) {
+    var lastIndex = operatorList.length - 1;
+
+    if (!args) {
+      args = [];
+    }
+
+    if (lastIndex < 0 || operatorList.fnArray[lastIndex] !== _util.OPS.constructPath) {
+      if (parsingText) {
+        (0, _util.warn)(`Encountered path operator "${fn}" inside of a text object.`);
+        operatorList.addOp(_util.OPS.save, null);
+      }
+
+      operatorList.addOp(_util.OPS.constructPath, [[fn], args]);
+
+      if (parsingText) {
+        operatorList.addOp(_util.OPS.restore, null);
+      }
+    } else {
+      var opArgs = operatorList.argsArray[lastIndex];
+      opArgs[0].push(fn);
+      Array.prototype.push.apply(opArgs[1], args);
+    }
+  }
+
+  parseColorSpace({
+    cs,
+    resources,
+    localColorSpaceCache
+  }) {
+    return _colorspace.ColorSpace.parseAsync({
+      cs,
+      xref: this.xref,
+      resources,
+      pdfFunctionFactory: this._pdfFunctionFactory,
+      localColorSpaceCache
+    }).catch(reason => {
+      if (reason instanceof _util.AbortException) {
+        return null;
+      }
+
+      if (this.options.ignoreErrors) {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.errorColorSpace
+        });
+        (0, _util.warn)(`parseColorSpace - ignoring ColorSpace: "${reason}".`);
+        return null;
+      }
+
+      throw reason;
+    });
+  }
+
+  handleColorN(operatorList, fn, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache) {
+    const patternName = args.pop();
+
+    if (patternName instanceof _primitives.Name) {
+      const name = patternName.name;
+      const localTilingPattern = localTilingPatternCache.getByName(name);
+
+      if (localTilingPattern) {
+        try {
+          const color = cs.base ? cs.base.getRgb(args, 0) : null;
+          const tilingPatternIR = (0, _pattern.getTilingPatternIR)(localTilingPattern.operatorListIR, localTilingPattern.dict, color);
+          operatorList.addOp(fn, tilingPatternIR);
+          return undefined;
+        } catch (ex) {
+          if (ex instanceof _core_utils.MissingDataException) {
+            throw ex;
+          }
+        }
+      }
+
+      let pattern = patterns.get(name);
+
+      if (pattern) {
+        var dict = (0, _primitives.isStream)(pattern) ? pattern.dict : pattern;
+        var typeNum = dict.get("PatternType");
+
+        if (typeNum === PatternType.TILING) {
+          const color = cs.base ? cs.base.getRgb(args, 0) : null;
+          return this.handleTilingType(fn, color, resources, pattern, dict, operatorList, task, name, localTilingPatternCache);
+        } else if (typeNum === PatternType.SHADING) {
+          var shading = dict.get("Shading");
+          var matrix = dict.getArray("Matrix");
+          pattern = _pattern.Pattern.parseShading(shading, matrix, this.xref, resources, this.handler, this._pdfFunctionFactory, localColorSpaceCache);
+          operatorList.addOp(fn, pattern.getIR());
+          return undefined;
+        }
+
+        throw new _util.FormatError(`Unknown PatternType: ${typeNum}`);
+      }
+    }
+
+    throw new _util.FormatError(`Unknown PatternName: ${patternName}`);
+  }
+
+  async parseMarkedContentProps(contentProperties, resources) {
+    let optionalContent;
+
+    if ((0, _primitives.isName)(contentProperties)) {
+      const properties = resources.get("Properties");
+      optionalContent = properties.get(contentProperties.name);
+    } else if ((0, _primitives.isDict)(contentProperties)) {
+      optionalContent = contentProperties;
+    } else {
+      throw new _util.FormatError("Optional content properties malformed.");
+    }
+
+    const optionalContentType = optionalContent.get("Type").name;
+
+    if (optionalContentType === "OCG") {
+      return {
+        type: optionalContentType,
+        id: optionalContent.objId
+      };
+    } else if (optionalContentType === "OCMD") {
+      const optionalContentGroups = optionalContent.get("OCGs");
+
+      if (Array.isArray(optionalContentGroups) || (0, _primitives.isDict)(optionalContentGroups)) {
+        const groupIds = [];
+
+        if (Array.isArray(optionalContentGroups)) {
+          optionalContent.get("OCGs").forEach(ocg => {
+            groupIds.push(ocg.toString());
+          });
+        } else {
+          groupIds.push(optionalContentGroups.objId);
+        }
+
+        let expression = null;
+
+        if (optionalContent.get("VE")) {
+          expression = true;
+        }
+
+        return {
+          type: optionalContentType,
+          ids: groupIds,
+          policy: (0, _primitives.isName)(optionalContent.get("P")) ? optionalContent.get("P").name : null,
+          expression
+        };
+      } else if ((0, _primitives.isRef)(optionalContentGroups)) {
+        return {
+          type: optionalContentType,
+          id: optionalContentGroups.toString()
+        };
+      }
+    }
+
+    return null;
+  }
+
+  getOperatorList({
+    stream,
+    task,
+    resources,
+    operatorList,
+    initialState = null,
+    fallbackFontDict = null
+  }) {
+    resources = resources || _primitives.Dict.empty;
+    initialState = initialState || new EvalState();
+
+    if (!operatorList) {
+      throw new Error('getOperatorList: missing "operatorList" parameter');
+    }
+
+    var self = this;
+    var xref = this.xref;
+    let parsingText = false;
+    const localImageCache = new _image_utils.LocalImageCache();
+    const localColorSpaceCache = new _image_utils.LocalColorSpaceCache();
+    const localGStateCache = new _image_utils.LocalGStateCache();
+    const localTilingPatternCache = new _image_utils.LocalTilingPatternCache();
+
+    var xobjs = resources.get("XObject") || _primitives.Dict.empty;
+
+    var patterns = resources.get("Pattern") || _primitives.Dict.empty;
+
+    var stateManager = new StateManager(initialState);
+    var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
+    var timeSlotManager = new TimeSlotManager();
+
+    function closePendingRestoreOPS(argument) {
+      for (var i = 0, ii = preprocessor.savedStatesDepth; i < ii; i++) {
+        operatorList.addOp(_util.OPS.restore, []);
+      }
+    }
+
+    return new Promise(function promiseBody(resolve, reject) {
+      const next = function (promise) {
+        Promise.all([promise, operatorList.ready]).then(function () {
+          try {
+            promiseBody(resolve, reject);
+          } catch (ex) {
+            reject(ex);
+          }
+        }, reject);
+      };
+
+      task.ensureNotTerminated();
+      timeSlotManager.reset();
+      var stop,
+          operation = {},
+          i,
+          ii,
+          cs,
+          name;
+
+      while (!(stop = timeSlotManager.check())) {
+        operation.args = null;
+
+        if (!preprocessor.read(operation)) {
+          break;
+        }
+
+        var args = operation.args;
+        var fn = operation.fn;
+
+        switch (fn | 0) {
+          case _util.OPS.paintXObject:
+            name = args[0].name;
+
+            if (name) {
+              const localImage = localImageCache.getByName(name);
+
+              if (localImage) {
+                operatorList.addOp(localImage.fn, localImage.args);
+                args = null;
+                continue;
+              }
+            }
+
+            next(new Promise(function (resolveXObject, rejectXObject) {
+              if (!name) {
+                throw new _util.FormatError("XObject must be referred to by name.");
+              }
+
+              let xobj = xobjs.getRaw(name);
+
+              if (xobj instanceof _primitives.Ref) {
+                const localImage = localImageCache.getByRef(xobj);
+
+                if (localImage) {
+                  operatorList.addOp(localImage.fn, localImage.args);
+                  resolveXObject();
+                  return;
+                }
+
+                const globalImage = self.globalImageCache.getData(xobj, self.pageIndex);
+
+                if (globalImage) {
+                  operatorList.addDependency(globalImage.objId);
+                  operatorList.addOp(globalImage.fn, globalImage.args);
+                  resolveXObject();
+                  return;
+                }
+
+                xobj = xref.fetch(xobj);
+              }
+
+              if (!(0, _primitives.isStream)(xobj)) {
+                throw new _util.FormatError("XObject should be a stream");
+              }
+
+              const type = xobj.dict.get("Subtype");
+
+              if (!(0, _primitives.isName)(type)) {
+                throw new _util.FormatError("XObject should have a Name subtype");
+              }
+
+              if (type.name === "Form") {
+                stateManager.save();
+                self.buildFormXObject(resources, xobj, null, operatorList, task, stateManager.state.clone(), localColorSpaceCache).then(function () {
+                  stateManager.restore();
+                  resolveXObject();
+                }, rejectXObject);
+                return;
+              } else if (type.name === "Image") {
+                self.buildPaintImageXObject({
+                  resources,
+                  image: xobj,
+                  operatorList,
+                  cacheKey: name,
+                  localImageCache,
+                  localColorSpaceCache
+                }).then(resolveXObject, rejectXObject);
+                return;
+              } else if (type.name === "PS") {
+                (0, _util.info)("Ignored XObject subtype PS");
+              } else {
+                throw new _util.FormatError(`Unhandled XObject subtype ${type.name}`);
+              }
+
+              resolveXObject();
+            }).catch(function (reason) {
+              if (reason instanceof _util.AbortException) {
+                return;
+              }
+
+              if (self.options.ignoreErrors) {
+                self.handler.send("UnsupportedFeature", {
+                  featureId: _util.UNSUPPORTED_FEATURES.errorXObject
+                });
+                (0, _util.warn)(`getOperatorList - ignoring XObject: "${reason}".`);
+                return;
+              }
+
+              throw reason;
+            }));
+            return;
+
+          case _util.OPS.setFont:
+            var fontSize = args[1];
+            next(self.handleSetFont(resources, args, null, operatorList, task, stateManager.state, fallbackFontDict).then(function (loadedName) {
+              operatorList.addDependency(loadedName);
+              operatorList.addOp(_util.OPS.setFont, [loadedName, fontSize]);
+            }));
+            return;
+
+          case _util.OPS.beginText:
+            parsingText = true;
+            break;
+
+          case _util.OPS.endText:
+            parsingText = false;
+            break;
+
+          case _util.OPS.endInlineImage:
+            var cacheKey = args[0].cacheKey;
+
+            if (cacheKey) {
+              const localImage = localImageCache.getByName(cacheKey);
+
+              if (localImage) {
+                operatorList.addOp(localImage.fn, localImage.args);
+                args = null;
+                continue;
+              }
+            }
+
+            next(self.buildPaintImageXObject({
+              resources,
+              image: args[0],
+              isInline: true,
+              operatorList,
+              cacheKey,
+              localImageCache,
+              localColorSpaceCache
+            }));
+            return;
+
+          case _util.OPS.showText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            args[0] = self.handleText(args[0], stateManager.state);
+            break;
+
+          case _util.OPS.showSpacedText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            var arr = args[0];
+            var combinedGlyphs = [];
+            var arrLength = arr.length;
+            var state = stateManager.state;
+
+            for (i = 0; i < arrLength; ++i) {
+              var arrItem = arr[i];
+
+              if ((0, _util.isString)(arrItem)) {
+                Array.prototype.push.apply(combinedGlyphs, self.handleText(arrItem, state));
+              } else if ((0, _util.isNum)(arrItem)) {
+                combinedGlyphs.push(arrItem);
+              }
+            }
+
+            args[0] = combinedGlyphs;
+            fn = _util.OPS.showText;
+            break;
+
+          case _util.OPS.nextLineShowText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            operatorList.addOp(_util.OPS.nextLine);
+            args[0] = self.handleText(args[0], stateManager.state);
+            fn = _util.OPS.showText;
+            break;
+
+          case _util.OPS.nextLineSetSpacingShowText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            operatorList.addOp(_util.OPS.nextLine);
+            operatorList.addOp(_util.OPS.setWordSpacing, [args.shift()]);
+            operatorList.addOp(_util.OPS.setCharSpacing, [args.shift()]);
+            args[0] = self.handleText(args[0], stateManager.state);
+            fn = _util.OPS.showText;
+            break;
+
+          case _util.OPS.setTextRenderingMode:
+            stateManager.state.textRenderingMode = args[0];
+            break;
+
+          case _util.OPS.setFillColorSpace:
+            {
+              const cachedColorSpace = _colorspace.ColorSpace.getCached(args[0], xref, localColorSpaceCache);
+
+              if (cachedColorSpace) {
+                stateManager.state.fillColorSpace = cachedColorSpace;
+                continue;
+              }
+
+              next(self.parseColorSpace({
+                cs: args[0],
+                resources,
+                localColorSpaceCache
+              }).then(function (colorSpace) {
+                if (colorSpace) {
+                  stateManager.state.fillColorSpace = colorSpace;
+                }
+              }));
+              return;
+            }
+
+          case _util.OPS.setStrokeColorSpace:
+            {
+              const cachedColorSpace = _colorspace.ColorSpace.getCached(args[0], xref, localColorSpaceCache);
+
+              if (cachedColorSpace) {
+                stateManager.state.strokeColorSpace = cachedColorSpace;
+                continue;
+              }
+
+              next(self.parseColorSpace({
+                cs: args[0],
+                resources,
+                localColorSpaceCache
+              }).then(function (colorSpace) {
+                if (colorSpace) {
+                  stateManager.state.strokeColorSpace = colorSpace;
+                }
+              }));
+              return;
+            }
+
+          case _util.OPS.setFillColor:
+            cs = stateManager.state.fillColorSpace;
+            args = cs.getRgb(args, 0);
+            fn = _util.OPS.setFillRGBColor;
+            break;
+
+          case _util.OPS.setStrokeColor:
+            cs = stateManager.state.strokeColorSpace;
+            args = cs.getRgb(args, 0);
+            fn = _util.OPS.setStrokeRGBColor;
+            break;
+
+          case _util.OPS.setFillGray:
+            stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.gray;
+            args = _colorspace.ColorSpace.singletons.gray.getRgb(args, 0);
+            fn = _util.OPS.setFillRGBColor;
+            break;
+
+          case _util.OPS.setStrokeGray:
+            stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.gray;
+            args = _colorspace.ColorSpace.singletons.gray.getRgb(args, 0);
+            fn = _util.OPS.setStrokeRGBColor;
+            break;
+
+          case _util.OPS.setFillCMYKColor:
+            stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.cmyk;
+            args = _colorspace.ColorSpace.singletons.cmyk.getRgb(args, 0);
+            fn = _util.OPS.setFillRGBColor;
+            break;
+
+          case _util.OPS.setStrokeCMYKColor:
+            stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.cmyk;
+            args = _colorspace.ColorSpace.singletons.cmyk.getRgb(args, 0);
+            fn = _util.OPS.setStrokeRGBColor;
+            break;
+
+          case _util.OPS.setFillRGBColor:
+            stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.rgb;
+            args = _colorspace.ColorSpace.singletons.rgb.getRgb(args, 0);
+            break;
+
+          case _util.OPS.setStrokeRGBColor:
+            stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.rgb;
+            args = _colorspace.ColorSpace.singletons.rgb.getRgb(args, 0);
+            break;
+
+          case _util.OPS.setFillColorN:
+            cs = stateManager.state.fillColorSpace;
+
+            if (cs.name === "Pattern") {
+              next(self.handleColorN(operatorList, _util.OPS.setFillColorN, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache));
+              return;
+            }
+
+            args = cs.getRgb(args, 0);
+            fn = _util.OPS.setFillRGBColor;
+            break;
+
+          case _util.OPS.setStrokeColorN:
+            cs = stateManager.state.strokeColorSpace;
+
+            if (cs.name === "Pattern") {
+              next(self.handleColorN(operatorList, _util.OPS.setStrokeColorN, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache));
+              return;
+            }
+
+            args = cs.getRgb(args, 0);
+            fn = _util.OPS.setStrokeRGBColor;
+            break;
+
+          case _util.OPS.shadingFill:
+            var shadingRes = resources.get("Shading");
+
+            if (!shadingRes) {
+              throw new _util.FormatError("No shading resource found");
+            }
+
+            var shading = shadingRes.get(args[0].name);
+
+            if (!shading) {
+              throw new _util.FormatError("No shading object found");
+            }
+
+            var shadingFill = _pattern.Pattern.parseShading(shading, null, xref, resources, self.handler, self._pdfFunctionFactory, localColorSpaceCache);
+
+            var patternIR = shadingFill.getIR();
+            args = [patternIR];
+            fn = _util.OPS.shadingFill;
+            break;
+
+          case _util.OPS.setGState:
+            name = args[0].name;
+
+            if (name) {
+              const localGStateObj = localGStateCache.getByName(name);
+
+              if (localGStateObj) {
+                if (localGStateObj.length > 0) {
+                  operatorList.addOp(_util.OPS.setGState, [localGStateObj]);
+                }
+
+                args = null;
+                continue;
+              }
+            }
+
+            next(new Promise(function (resolveGState, rejectGState) {
+              if (!name) {
+                throw new _util.FormatError("GState must be referred to by name.");
+              }
+
+              const extGState = resources.get("ExtGState");
+
+              if (!(extGState instanceof _primitives.Dict)) {
+                throw new _util.FormatError("ExtGState should be a dictionary.");
+              }
+
+              const gState = extGState.get(name);
+
+              if (!(gState instanceof _primitives.Dict)) {
+                throw new _util.FormatError("GState should be a dictionary.");
+              }
+
+              self.setGState({
+                resources,
+                gState,
+                operatorList,
+                cacheKey: name,
+                task,
+                stateManager,
+                localGStateCache,
+                localColorSpaceCache
+              }).then(resolveGState, rejectGState);
+            }).catch(function (reason) {
+              if (reason instanceof _util.AbortException) {
+                return;
+              }
+
+              if (self.options.ignoreErrors) {
+                self.handler.send("UnsupportedFeature", {
+                  featureId: _util.UNSUPPORTED_FEATURES.errorExtGState
+                });
+                (0, _util.warn)(`getOperatorList - ignoring ExtGState: "${reason}".`);
+                return;
+              }
+
+              throw reason;
+            }));
+            return;
+
+          case _util.OPS.moveTo:
+          case _util.OPS.lineTo:
+          case _util.OPS.curveTo:
+          case _util.OPS.curveTo2:
+          case _util.OPS.curveTo3:
+          case _util.OPS.closePath:
+          case _util.OPS.rectangle:
+            self.buildPath(operatorList, fn, args, parsingText);
+            continue;
+
+          case _util.OPS.markPoint:
+          case _util.OPS.markPointProps:
+          case _util.OPS.beginCompat:
+          case _util.OPS.endCompat:
+            continue;
+
+          case _util.OPS.beginMarkedContentProps:
+            if (!(0, _primitives.isName)(args[0])) {
+              (0, _util.warn)(`Expected name for beginMarkedContentProps arg0=${args[0]}`);
+              continue;
+            }
+
+            if (args[0].name === "OC") {
+              next(self.parseMarkedContentProps(args[1], resources).then(data => {
+                operatorList.addOp(_util.OPS.beginMarkedContentProps, ["OC", data]);
+              }).catch(reason => {
+                if (reason instanceof _util.AbortException) {
+                  return;
+                }
+
+                if (self.options.ignoreErrors) {
+                  self.handler.send("UnsupportedFeature", {
+                    featureId: _util.UNSUPPORTED_FEATURES.errorMarkedContent
+                  });
+                  (0, _util.warn)(`getOperatorList - ignoring beginMarkedContentProps: "${reason}".`);
+                  return;
+                }
+
+                throw reason;
+              }));
+              return;
+            }
+
+            args = [args[0].name];
+            break;
+
+          case _util.OPS.beginMarkedContent:
+          case _util.OPS.endMarkedContent:
+          default:
+            if (args !== null) {
+              for (i = 0, ii = args.length; i < ii; i++) {
+                if (args[i] instanceof _primitives.Dict) {
+                  break;
+                }
+              }
+
+              if (i < ii) {
+                (0, _util.warn)("getOperatorList - ignoring operator: " + fn);
+                continue;
+              }
+            }
+
+        }
+
+        operatorList.addOp(fn, args);
+      }
+
+      if (stop) {
+        next(deferred);
+        return;
+      }
+
+      closePendingRestoreOPS();
+      resolve();
+    }).catch(reason => {
+      if (reason instanceof _util.AbortException) {
+        return;
+      }
+
+      if (this.options.ignoreErrors) {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.errorOperatorList
+        });
+        (0, _util.warn)(`getOperatorList - ignoring errors during "${task.name}" ` + `task: "${reason}".`);
+        closePendingRestoreOPS();
+        return;
+      }
+
+      throw reason;
+    });
+  }
+
+  getTextContent({
+    stream,
+    task,
+    resources,
+    stateManager = null,
+    normalizeWhitespace = false,
+    combineTextItems = false,
+    sink,
+    seenStyles = Object.create(null)
+  }) {
+    resources = resources || _primitives.Dict.empty;
+    stateManager = stateManager || new StateManager(new TextState());
+    var WhitespaceRegexp = /\s/g;
+    var textContent = {
+      items: [],
+      styles: Object.create(null)
+    };
+    var textContentItem = {
+      initialized: false,
+      str: [],
+      width: 0,
+      height: 0,
+      vertical: false,
+      lastAdvanceWidth: 0,
+      lastAdvanceHeight: 0,
+      textAdvanceScale: 0,
+      spaceWidth: 0,
+      fakeSpaceMin: Infinity,
+      fakeMultiSpaceMin: Infinity,
+      fakeMultiSpaceMax: -0,
+      textRunBreakAllowed: false,
+      transform: null,
+      fontName: null
+    };
+    var SPACE_FACTOR = 0.3;
+    var MULTI_SPACE_FACTOR = 1.5;
+    var MULTI_SPACE_FACTOR_MAX = 4;
+    var self = this;
+    var xref = this.xref;
+    var xobjs = null;
+    const emptyXObjectCache = new _image_utils.LocalImageCache();
+    const emptyGStateCache = new _image_utils.LocalGStateCache();
+    var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
+    var textState;
+
+    function ensureTextContentItem() {
+      if (textContentItem.initialized) {
+        return textContentItem;
+      }
+
+      var font = textState.font;
+
+      if (!(font.loadedName in seenStyles)) {
+        seenStyles[font.loadedName] = true;
+        textContent.styles[font.loadedName] = {
+          fontFamily: font.fallbackName,
+          ascent: font.ascent,
+          descent: font.descent,
+          vertical: font.vertical
+        };
+      }
+
+      textContentItem.fontName = font.loadedName;
+      var tsm = [textState.fontSize * textState.textHScale, 0, 0, textState.fontSize, 0, textState.textRise];
+
+      if (font.isType3Font && textState.fontSize <= 1 && !(0, _util.isArrayEqual)(textState.fontMatrix, _util.FONT_IDENTITY_MATRIX)) {
+        const glyphHeight = font.bbox[3] - font.bbox[1];
+
+        if (glyphHeight > 0) {
+          tsm[3] *= glyphHeight * textState.fontMatrix[3];
+        }
+      }
+
+      var trm = _util.Util.transform(textState.ctm, _util.Util.transform(textState.textMatrix, tsm));
+
+      textContentItem.transform = trm;
+
+      if (!font.vertical) {
+        textContentItem.width = 0;
+        textContentItem.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]);
+        textContentItem.vertical = false;
+      } else {
+        textContentItem.width = Math.sqrt(trm[0] * trm[0] + trm[1] * trm[1]);
+        textContentItem.height = 0;
+        textContentItem.vertical = true;
+      }
+
+      var a = textState.textLineMatrix[0];
+      var b = textState.textLineMatrix[1];
+      var scaleLineX = Math.sqrt(a * a + b * b);
+      a = textState.ctm[0];
+      b = textState.ctm[1];
+      var scaleCtmX = Math.sqrt(a * a + b * b);
+      textContentItem.textAdvanceScale = scaleCtmX * scaleLineX;
+      textContentItem.lastAdvanceWidth = 0;
+      textContentItem.lastAdvanceHeight = 0;
+      var spaceWidth = font.spaceWidth / 1000 * textState.fontSize;
+
+      if (spaceWidth) {
+        textContentItem.spaceWidth = spaceWidth;
+        textContentItem.fakeSpaceMin = spaceWidth * SPACE_FACTOR;
+        textContentItem.fakeMultiSpaceMin = spaceWidth * MULTI_SPACE_FACTOR;
+        textContentItem.fakeMultiSpaceMax = spaceWidth * MULTI_SPACE_FACTOR_MAX;
+        textContentItem.textRunBreakAllowed = !font.isMonospace;
+      } else {
+        textContentItem.spaceWidth = 0;
+        textContentItem.fakeSpaceMin = Infinity;
+        textContentItem.fakeMultiSpaceMin = Infinity;
+        textContentItem.fakeMultiSpaceMax = 0;
+        textContentItem.textRunBreakAllowed = false;
+      }
+
+      textContentItem.initialized = true;
+      return textContentItem;
+    }
+
+    function replaceWhitespace(str) {
+      var i = 0,
+          ii = str.length,
+          code;
+
+      while (i < ii && (code = str.charCodeAt(i)) >= 0x20 && code <= 0x7f) {
+        i++;
+      }
+
+      return i < ii ? str.replace(WhitespaceRegexp, " ") : str;
+    }
+
+    function runBidiTransform(textChunk) {
+      var str = textChunk.str.join("");
+      var bidiResult = (0, _bidi.bidi)(str, -1, textChunk.vertical);
+      return {
+        str: normalizeWhitespace ? replaceWhitespace(bidiResult.str) : bidiResult.str,
+        dir: bidiResult.dir,
+        width: textChunk.width,
+        height: textChunk.height,
+        transform: textChunk.transform,
+        fontName: textChunk.fontName
+      };
+    }
+
+    function handleSetFont(fontName, fontRef) {
+      return self.loadFont(fontName, fontRef, resources).then(function (translated) {
+        textState.font = translated.font;
+        textState.fontMatrix = translated.font.fontMatrix || _util.FONT_IDENTITY_MATRIX;
+      });
+    }
+
+    function buildTextContentItem(chars) {
+      var font = textState.font;
+      var textChunk = ensureTextContentItem();
+      var width = 0;
+      var height = 0;
+      var glyphs = font.charsToGlyphs(chars);
+
+      for (var i = 0; i < glyphs.length; i++) {
+        var glyph = glyphs[i];
+        var glyphWidth = null;
+
+        if (font.vertical && glyph.vmetric) {
+          glyphWidth = glyph.vmetric[0];
+        } else {
+          glyphWidth = glyph.width;
+        }
+
+        var glyphUnicode = glyph.unicode;
+        var NormalizedUnicodes = (0, _unicode.getNormalizedUnicodes)();
+
+        if (NormalizedUnicodes[glyphUnicode] !== undefined) {
+          glyphUnicode = NormalizedUnicodes[glyphUnicode];
+        }
+
+        glyphUnicode = (0, _unicode.reverseIfRtl)(glyphUnicode);
+        var charSpacing = textState.charSpacing;
+
+        if (glyph.isSpace) {
+          var wordSpacing = textState.wordSpacing;
+          charSpacing += wordSpacing;
+
+          if (wordSpacing > 0) {
+            addFakeSpaces(wordSpacing, textChunk.str);
+          }
+        }
+
+        var tx = 0;
+        var ty = 0;
+
+        if (!font.vertical) {
+          var w0 = glyphWidth * textState.fontMatrix[0];
+          tx = (w0 * textState.fontSize + charSpacing) * textState.textHScale;
+          width += tx;
+        } else {
+          var w1 = glyphWidth * textState.fontMatrix[0];
+          ty = w1 * textState.fontSize + charSpacing;
+          height += ty;
+        }
+
+        textState.translateTextMatrix(tx, ty);
+        textChunk.str.push(glyphUnicode);
+      }
+
+      if (!font.vertical) {
+        textChunk.lastAdvanceWidth = width;
+        textChunk.width += width;
+      } else {
+        textChunk.lastAdvanceHeight = height;
+        textChunk.height += Math.abs(height);
+      }
+
+      return textChunk;
+    }
+
+    function addFakeSpaces(width, strBuf) {
+      if (width < textContentItem.fakeSpaceMin) {
+        return;
+      }
+
+      if (width < textContentItem.fakeMultiSpaceMin) {
+        strBuf.push(" ");
+        return;
+      }
+
+      var fakeSpaces = Math.round(width / textContentItem.spaceWidth);
+
+      while (fakeSpaces-- > 0) {
+        strBuf.push(" ");
+      }
+    }
+
+    function flushTextContentItem() {
+      if (!textContentItem.initialized) {
+        return;
+      }
+
+      if (!textContentItem.vertical) {
+        textContentItem.width *= textContentItem.textAdvanceScale;
+      } else {
+        textContentItem.height *= textContentItem.textAdvanceScale;
+      }
+
+      textContent.items.push(runBidiTransform(textContentItem));
+      textContentItem.initialized = false;
+      textContentItem.str.length = 0;
+    }
+
+    function enqueueChunk() {
+      const length = textContent.items.length;
+
+      if (length > 0) {
+        sink.enqueue(textContent, length);
+        textContent.items = [];
+        textContent.styles = Object.create(null);
+      }
+    }
+
+    var timeSlotManager = new TimeSlotManager();
+    return new Promise(function promiseBody(resolve, reject) {
+      const next = function (promise) {
+        enqueueChunk();
+        Promise.all([promise, sink.ready]).then(function () {
+          try {
+            promiseBody(resolve, reject);
+          } catch (ex) {
+            reject(ex);
+          }
+        }, reject);
+      };
+
+      task.ensureNotTerminated();
+      timeSlotManager.reset();
+      var stop,
+          operation = {},
+          args = [];
+
+      while (!(stop = timeSlotManager.check())) {
+        args.length = 0;
+        operation.args = args;
+
+        if (!preprocessor.read(operation)) {
+          break;
+        }
+
+        textState = stateManager.state;
+        var fn = operation.fn;
+        args = operation.args;
+        var advance, diff;
+
+        switch (fn | 0) {
+          case _util.OPS.setFont:
+            var fontNameArg = args[0].name,
+                fontSizeArg = args[1];
+
+            if (textState.font && fontNameArg === textState.fontName && fontSizeArg === textState.fontSize) {
+              break;
+            }
+
+            flushTextContentItem();
+            textState.fontName = fontNameArg;
+            textState.fontSize = fontSizeArg;
+            next(handleSetFont(fontNameArg, null));
+            return;
+
+          case _util.OPS.setTextRise:
+            flushTextContentItem();
+            textState.textRise = args[0];
+            break;
+
+          case _util.OPS.setHScale:
+            flushTextContentItem();
+            textState.textHScale = args[0] / 100;
+            break;
+
+          case _util.OPS.setLeading:
+            flushTextContentItem();
+            textState.leading = args[0];
+            break;
+
+          case _util.OPS.moveText:
+            var isSameTextLine = !textState.font ? false : (textState.font.vertical ? args[0] : args[1]) === 0;
+            advance = args[0] - args[1];
+
+            if (combineTextItems && isSameTextLine && textContentItem.initialized && advance > 0 && advance <= textContentItem.fakeMultiSpaceMax) {
+              textState.translateTextLineMatrix(args[0], args[1]);
+              textContentItem.width += args[0] - textContentItem.lastAdvanceWidth;
+              textContentItem.height += args[1] - textContentItem.lastAdvanceHeight;
+              diff = args[0] - textContentItem.lastAdvanceWidth - (args[1] - textContentItem.lastAdvanceHeight);
+              addFakeSpaces(diff, textContentItem.str);
+              break;
+            }
+
+            flushTextContentItem();
+            textState.translateTextLineMatrix(args[0], args[1]);
+            textState.textMatrix = textState.textLineMatrix.slice();
+            break;
+
+          case _util.OPS.setLeadingMoveText:
+            flushTextContentItem();
+            textState.leading = -args[1];
+            textState.translateTextLineMatrix(args[0], args[1]);
+            textState.textMatrix = textState.textLineMatrix.slice();
+            break;
+
+          case _util.OPS.nextLine:
+            flushTextContentItem();
+            textState.carriageReturn();
+            break;
+
+          case _util.OPS.setTextMatrix:
+            advance = textState.calcTextLineMatrixAdvance(args[0], args[1], args[2], args[3], args[4], args[5]);
+
+            if (combineTextItems && advance !== null && textContentItem.initialized && advance.value > 0 && advance.value <= textContentItem.fakeMultiSpaceMax) {
+              textState.translateTextLineMatrix(advance.width, advance.height);
+              textContentItem.width += advance.width - textContentItem.lastAdvanceWidth;
+              textContentItem.height += advance.height - textContentItem.lastAdvanceHeight;
+              diff = advance.width - textContentItem.lastAdvanceWidth - (advance.height - textContentItem.lastAdvanceHeight);
+              addFakeSpaces(diff, textContentItem.str);
+              break;
+            }
+
+            flushTextContentItem();
+            textState.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+            textState.setTextLineMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+            break;
+
+          case _util.OPS.setCharSpacing:
+            textState.charSpacing = args[0];
+            break;
+
+          case _util.OPS.setWordSpacing:
+            textState.wordSpacing = args[0];
+            break;
+
+          case _util.OPS.beginText:
+            flushTextContentItem();
+            textState.textMatrix = _util.IDENTITY_MATRIX.slice();
+            textState.textLineMatrix = _util.IDENTITY_MATRIX.slice();
+            break;
+
+          case _util.OPS.showSpacedText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            var items = args[0];
+            var offset;
+
+            for (var j = 0, jj = items.length; j < jj; j++) {
+              if (typeof items[j] === "string") {
+                buildTextContentItem(items[j]);
+              } else if ((0, _util.isNum)(items[j])) {
+                ensureTextContentItem();
+                advance = items[j] * textState.fontSize / 1000;
+                var breakTextRun = false;
+
+                if (textState.font.vertical) {
+                  offset = advance;
+                  textState.translateTextMatrix(0, offset);
+                  breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+
+                  if (!breakTextRun) {
+                    textContentItem.height += offset;
+                  }
+                } else {
+                  advance = -advance;
+                  offset = advance * textState.textHScale;
+                  textState.translateTextMatrix(offset, 0);
+                  breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+
+                  if (!breakTextRun) {
+                    textContentItem.width += offset;
+                  }
+                }
+
+                if (breakTextRun) {
+                  flushTextContentItem();
+                } else if (advance > 0) {
+                  addFakeSpaces(advance, textContentItem.str);
+                }
+              }
+            }
+
+            break;
+
+          case _util.OPS.showText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            buildTextContentItem(args[0]);
+            break;
+
+          case _util.OPS.nextLineShowText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            flushTextContentItem();
+            textState.carriageReturn();
+            buildTextContentItem(args[0]);
+            break;
+
+          case _util.OPS.nextLineSetSpacingShowText:
+            if (!stateManager.state.font) {
+              self.ensureStateFont(stateManager.state);
+              continue;
+            }
+
+            flushTextContentItem();
+            textState.wordSpacing = args[0];
+            textState.charSpacing = args[1];
+            textState.carriageReturn();
+            buildTextContentItem(args[2]);
+            break;
+
+          case _util.OPS.paintXObject:
+            flushTextContentItem();
+
+            if (!xobjs) {
+              xobjs = resources.get("XObject") || _primitives.Dict.empty;
+            }
+
+            var name = args[0].name;
+
+            if (name && emptyXObjectCache.getByName(name)) {
+              break;
+            }
+
+            next(new Promise(function (resolveXObject, rejectXObject) {
+              if (!name) {
+                throw new _util.FormatError("XObject must be referred to by name.");
+              }
+
+              let xobj = xobjs.getRaw(name);
+
+              if (xobj instanceof _primitives.Ref) {
+                if (emptyXObjectCache.getByRef(xobj)) {
+                  resolveXObject();
+                  return;
+                }
+
+                xobj = xref.fetch(xobj);
+              }
+
+              if (!(0, _primitives.isStream)(xobj)) {
+                throw new _util.FormatError("XObject should be a stream");
+              }
+
+              const type = xobj.dict.get("Subtype");
+
+              if (!(0, _primitives.isName)(type)) {
+                throw new _util.FormatError("XObject should have a Name subtype");
+              }
+
+              if (type.name !== "Form") {
+                emptyXObjectCache.set(name, xobj.dict.objId, true);
+                resolveXObject();
+                return;
+              }
+
+              const currentState = stateManager.state.clone();
+              const xObjStateManager = new StateManager(currentState);
+              const matrix = xobj.dict.getArray("Matrix");
+
+              if (Array.isArray(matrix) && matrix.length === 6) {
+                xObjStateManager.transform(matrix);
+              }
+
+              enqueueChunk();
+              const sinkWrapper = {
+                enqueueInvoked: false,
+
+                enqueue(chunk, size) {
+                  this.enqueueInvoked = true;
+                  sink.enqueue(chunk, size);
+                },
+
+                get desiredSize() {
+                  return sink.desiredSize;
+                },
+
+                get ready() {
+                  return sink.ready;
+                }
+
+              };
+              self.getTextContent({
+                stream: xobj,
+                task,
+                resources: xobj.dict.get("Resources") || resources,
+                stateManager: xObjStateManager,
+                normalizeWhitespace,
+                combineTextItems,
+                sink: sinkWrapper,
+                seenStyles
+              }).then(function () {
+                if (!sinkWrapper.enqueueInvoked) {
+                  emptyXObjectCache.set(name, xobj.dict.objId, true);
+                }
+
+                resolveXObject();
+              }, rejectXObject);
+            }).catch(function (reason) {
+              if (reason instanceof _util.AbortException) {
+                return;
+              }
+
+              if (self.options.ignoreErrors) {
+                (0, _util.warn)(`getTextContent - ignoring XObject: "${reason}".`);
+                return;
+              }
+
+              throw reason;
+            }));
+            return;
+
+          case _util.OPS.setGState:
+            name = args[0].name;
+
+            if (name && emptyGStateCache.getByName(name)) {
+              break;
+            }
+
+            next(new Promise(function (resolveGState, rejectGState) {
+              if (!name) {
+                throw new _util.FormatError("GState must be referred to by name.");
+              }
+
+              const extGState = resources.get("ExtGState");
+
+              if (!(extGState instanceof _primitives.Dict)) {
+                throw new _util.FormatError("ExtGState should be a dictionary.");
+              }
+
+              const gState = extGState.get(name);
+
+              if (!(gState instanceof _primitives.Dict)) {
+                throw new _util.FormatError("GState should be a dictionary.");
+              }
+
+              const gStateFont = gState.get("Font");
+
+              if (!gStateFont) {
+                emptyGStateCache.set(name, gState.objId, true);
+                resolveGState();
+                return;
+              }
+
+              flushTextContentItem();
+              textState.fontName = null;
+              textState.fontSize = gStateFont[1];
+              handleSetFont(null, gStateFont[0]).then(resolveGState, rejectGState);
+            }).catch(function (reason) {
+              if (reason instanceof _util.AbortException) {
+                return;
+              }
+
+              if (self.options.ignoreErrors) {
+                (0, _util.warn)(`getTextContent - ignoring ExtGState: "${reason}".`);
+                return;
+              }
+
+              throw reason;
+            }));
+            return;
+        }
+
+        if (textContent.items.length >= sink.desiredSize) {
+          stop = true;
+          break;
+        }
+      }
+
+      if (stop) {
+        next(deferred);
+        return;
+      }
+
+      flushTextContentItem();
+      enqueueChunk();
+      resolve();
+    }).catch(reason => {
+      if (reason instanceof _util.AbortException) {
+        return;
+      }
+
+      if (this.options.ignoreErrors) {
+        (0, _util.warn)(`getTextContent - ignoring errors during "${task.name}" ` + `task: "${reason}".`);
+        flushTextContentItem();
+        enqueueChunk();
+        return;
+      }
+
+      throw reason;
+    });
+  }
+
+  extractDataStructures(dict, baseDict, properties) {
+    const xref = this.xref;
+    let cidToGidBytes;
+    var toUnicode = dict.get("ToUnicode") || baseDict.get("ToUnicode");
+    var toUnicodePromise = toUnicode ? this.readToUnicode(toUnicode) : Promise.resolve(undefined);
+
+    if (properties.composite) {
+      var cidSystemInfo = dict.get("CIDSystemInfo");
+
+      if ((0, _primitives.isDict)(cidSystemInfo)) {
+        properties.cidSystemInfo = {
+          registry: (0, _util.stringToPDFString)(cidSystemInfo.get("Registry")),
+          ordering: (0, _util.stringToPDFString)(cidSystemInfo.get("Ordering")),
+          supplement: cidSystemInfo.get("Supplement")
+        };
+      }
+
+      var cidToGidMap = dict.get("CIDToGIDMap");
+
+      if ((0, _primitives.isStream)(cidToGidMap)) {
+        cidToGidBytes = cidToGidMap.getBytes();
+      }
+    }
+
+    var differences = [];
+    var baseEncodingName = null;
+    var encoding;
+
+    if (dict.has("Encoding")) {
+      encoding = dict.get("Encoding");
+
+      if ((0, _primitives.isDict)(encoding)) {
+        baseEncodingName = encoding.get("BaseEncoding");
+        baseEncodingName = (0, _primitives.isName)(baseEncodingName) ? baseEncodingName.name : null;
+
+        if (encoding.has("Differences")) {
+          var diffEncoding = encoding.get("Differences");
+          var index = 0;
+
+          for (var j = 0, jj = diffEncoding.length; j < jj; j++) {
+            var data = xref.fetchIfRef(diffEncoding[j]);
+
+            if ((0, _util.isNum)(data)) {
+              index = data;
+            } else if ((0, _primitives.isName)(data)) {
+              differences[index++] = data.name;
+            } else {
+              throw new _util.FormatError(`Invalid entry in 'Differences' array: ${data}`);
+            }
+          }
+        }
+      } else if ((0, _primitives.isName)(encoding)) {
+        baseEncodingName = encoding.name;
+      } else {
+        throw new _util.FormatError("Encoding is not a Name nor a Dict");
+      }
+
+      if (baseEncodingName !== "MacRomanEncoding" && baseEncodingName !== "MacExpertEncoding" && baseEncodingName !== "WinAnsiEncoding") {
+        baseEncodingName = null;
+      }
+    }
+
+    if (baseEncodingName) {
+      properties.defaultEncoding = (0, _encodings.getEncoding)(baseEncodingName).slice();
+    } else {
+      var isSymbolicFont = !!(properties.flags & _fonts.FontFlags.Symbolic);
+      var isNonsymbolicFont = !!(properties.flags & _fonts.FontFlags.Nonsymbolic);
+      encoding = _encodings.StandardEncoding;
+
+      if (properties.type === "TrueType" && !isNonsymbolicFont) {
+        encoding = _encodings.WinAnsiEncoding;
+      }
+
+      if (isSymbolicFont) {
+        encoding = _encodings.MacRomanEncoding;
+
+        if (!properties.file) {
+          if (/Symbol/i.test(properties.name)) {
+            encoding = _encodings.SymbolSetEncoding;
+          } else if (/Dingbats|Wingdings/i.test(properties.name)) {
+            encoding = _encodings.ZapfDingbatsEncoding;
+          }
+        }
+      }
+
+      properties.defaultEncoding = encoding;
+    }
+
+    properties.differences = differences;
+    properties.baseEncodingName = baseEncodingName;
+    properties.hasEncoding = !!baseEncodingName || differences.length > 0;
+    properties.dict = dict;
+    return toUnicodePromise.then(readToUnicode => {
+      properties.toUnicode = readToUnicode;
+      return this.buildToUnicode(properties);
+    }).then(builtToUnicode => {
+      properties.toUnicode = builtToUnicode;
+
+      if (cidToGidBytes) {
+        properties.cidToGidMap = this.readCidToGidMap(cidToGidBytes, builtToUnicode);
+      }
+
+      return properties;
+    });
+  }
+
+  _buildSimpleFontToUnicode(properties, forceGlyphs = false) {
+    (0, _util.assert)(!properties.composite, "Must be a simple font.");
+    const toUnicode = [];
+    const encoding = properties.defaultEncoding.slice();
+    const baseEncodingName = properties.baseEncodingName;
+    const differences = properties.differences;
+
+    for (const charcode in differences) {
+      const glyphName = differences[charcode];
+
+      if (glyphName === ".notdef") {
+        continue;
+      }
+
+      encoding[charcode] = glyphName;
+    }
+
+    const glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+
+    for (const charcode in encoding) {
+      let glyphName = encoding[charcode];
+
+      if (glyphName === "") {
+        continue;
+      } else if (glyphsUnicodeMap[glyphName] === undefined) {
+        let code = 0;
+
+        switch (glyphName[0]) {
+          case "G":
+            if (glyphName.length === 3) {
+              code = parseInt(glyphName.substring(1), 16);
+            }
+
+            break;
+
+          case "g":
+            if (glyphName.length === 5) {
+              code = parseInt(glyphName.substring(1), 16);
+            }
+
+            break;
+
+          case "C":
+          case "c":
+            if (glyphName.length >= 3 && glyphName.length <= 4) {
+              const codeStr = glyphName.substring(1);
+
+              if (forceGlyphs) {
+                code = parseInt(codeStr, 16);
+                break;
+              }
+
+              code = +codeStr;
+
+              if (Number.isNaN(code) && Number.isInteger(parseInt(codeStr, 16))) {
+                return this._buildSimpleFontToUnicode(properties, true);
+              }
+            }
+
+            break;
+
+          default:
+            const unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+
+            if (unicode !== -1) {
+              code = unicode;
+            }
+
+        }
+
+        if (code > 0 && code <= 0x10ffff && Number.isInteger(code)) {
+          if (baseEncodingName && code === +charcode) {
+            const baseEncoding = (0, _encodings.getEncoding)(baseEncodingName);
+
+            if (baseEncoding && (glyphName = baseEncoding[charcode])) {
+              toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
+              continue;
+            }
+          }
+
+          toUnicode[charcode] = String.fromCodePoint(code);
+        }
+
+        continue;
+      }
+
+      toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
+    }
+
+    return new _fonts.ToUnicodeMap(toUnicode);
+  }
+
+  buildToUnicode(properties) {
+    properties.hasIncludedToUnicodeMap = !!properties.toUnicode && properties.toUnicode.length > 0;
+
+    if (properties.hasIncludedToUnicodeMap) {
+      if (!properties.composite && properties.hasEncoding) {
+        properties.fallbackToUnicode = this._buildSimpleFontToUnicode(properties);
+      }
+
+      return Promise.resolve(properties.toUnicode);
+    }
+
+    if (!properties.composite) {
+      return Promise.resolve(this._buildSimpleFontToUnicode(properties));
+    }
+
+    if (properties.composite && (properties.cMap.builtInCMap && !(properties.cMap instanceof _cmap.IdentityCMap) || properties.cidSystemInfo.registry === "Adobe" && (properties.cidSystemInfo.ordering === "GB1" || properties.cidSystemInfo.ordering === "CNS1" || properties.cidSystemInfo.ordering === "Japan1" || properties.cidSystemInfo.ordering === "Korea1"))) {
+      const registry = properties.cidSystemInfo.registry;
+      const ordering = properties.cidSystemInfo.ordering;
+
+      const ucs2CMapName = _primitives.Name.get(registry + "-" + ordering + "-UCS2");
+
+      return _cmap.CMapFactory.create({
+        encoding: ucs2CMapName,
+        fetchBuiltInCMap: this._fetchBuiltInCMapBound,
+        useCMap: null
+      }).then(function (ucs2CMap) {
+        const cMap = properties.cMap;
+        const toUnicode = [];
+        cMap.forEach(function (charcode, cid) {
+          if (cid > 0xffff) {
+            throw new _util.FormatError("Max size of CID is 65,535");
+          }
+
+          const ucs2 = ucs2CMap.lookup(cid);
+
+          if (ucs2) {
+            toUnicode[charcode] = String.fromCharCode((ucs2.charCodeAt(0) << 8) + ucs2.charCodeAt(1));
+          }
+        });
+        return new _fonts.ToUnicodeMap(toUnicode);
+      });
+    }
+
+    return Promise.resolve(new _fonts.IdentityToUnicodeMap(properties.firstChar, properties.lastChar));
+  }
+
+  readToUnicode(toUnicode) {
+    var cmapObj = toUnicode;
+
+    if ((0, _primitives.isName)(cmapObj)) {
+      return _cmap.CMapFactory.create({
+        encoding: cmapObj,
+        fetchBuiltInCMap: this._fetchBuiltInCMapBound,
+        useCMap: null
+      }).then(function (cmap) {
+        if (cmap instanceof _cmap.IdentityCMap) {
+          return new _fonts.IdentityToUnicodeMap(0, 0xffff);
+        }
+
+        return new _fonts.ToUnicodeMap(cmap.getMap());
+      });
+    } else if ((0, _primitives.isStream)(cmapObj)) {
+      return _cmap.CMapFactory.create({
+        encoding: cmapObj,
+        fetchBuiltInCMap: this._fetchBuiltInCMapBound,
+        useCMap: null
+      }).then(function (cmap) {
+        if (cmap instanceof _cmap.IdentityCMap) {
+          return new _fonts.IdentityToUnicodeMap(0, 0xffff);
+        }
+
+        var map = new Array(cmap.length);
+        cmap.forEach(function (charCode, token) {
+          var str = [];
+
+          for (var k = 0; k < token.length; k += 2) {
+            var w1 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
+
+            if ((w1 & 0xf800) !== 0xd800) {
+              str.push(w1);
+              continue;
+            }
+
+            k += 2;
+            var w2 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
+            str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000);
+          }
+
+          map[charCode] = String.fromCodePoint.apply(String, str);
+        });
+        return new _fonts.ToUnicodeMap(map);
+      }, reason => {
+        if (reason instanceof _util.AbortException) {
+          return null;
+        }
+
+        if (this.options.ignoreErrors) {
+          this.handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.errorFontToUnicode
+          });
+          (0, _util.warn)(`readToUnicode - ignoring ToUnicode data: "${reason}".`);
+          return null;
+        }
+
+        throw reason;
+      });
+    }
+
+    return Promise.resolve(null);
+  }
+
+  readCidToGidMap(glyphsData, toUnicode) {
+    var result = [];
+
+    for (var j = 0, jj = glyphsData.length; j < jj; j++) {
+      var glyphID = glyphsData[j++] << 8 | glyphsData[j];
+      const code = j >> 1;
+
+      if (glyphID === 0 && !toUnicode.has(code)) {
+        continue;
+      }
+
+      result[code] = glyphID;
+    }
+
+    return result;
+  }
+
+  extractWidths(dict, descriptor, properties) {
+    var xref = this.xref;
+    var glyphsWidths = [];
+    var defaultWidth = 0;
+    var glyphsVMetrics = [];
+    var defaultVMetrics;
+    var i, ii, j, jj, start, code, widths;
+
+    if (properties.composite) {
+      defaultWidth = dict.has("DW") ? dict.get("DW") : 1000;
+      widths = dict.get("W");
+
+      if (widths) {
+        for (i = 0, ii = widths.length; i < ii; i++) {
+          start = xref.fetchIfRef(widths[i++]);
+          code = xref.fetchIfRef(widths[i]);
+
+          if (Array.isArray(code)) {
+            for (j = 0, jj = code.length; j < jj; j++) {
+              glyphsWidths[start++] = xref.fetchIfRef(code[j]);
+            }
+          } else {
+            var width = xref.fetchIfRef(widths[++i]);
+
+            for (j = start; j <= code; j++) {
+              glyphsWidths[j] = width;
+            }
+          }
+        }
+      }
+
+      if (properties.vertical) {
+        var vmetrics = dict.getArray("DW2") || [880, -1000];
+        defaultVMetrics = [vmetrics[1], defaultWidth * 0.5, vmetrics[0]];
+        vmetrics = dict.get("W2");
+
+        if (vmetrics) {
+          for (i = 0, ii = vmetrics.length; i < ii; i++) {
+            start = xref.fetchIfRef(vmetrics[i++]);
+            code = xref.fetchIfRef(vmetrics[i]);
+
+            if (Array.isArray(code)) {
+              for (j = 0, jj = code.length; j < jj; j++) {
+                glyphsVMetrics[start++] = [xref.fetchIfRef(code[j++]), xref.fetchIfRef(code[j++]), xref.fetchIfRef(code[j])];
+              }
+            } else {
+              var vmetric = [xref.fetchIfRef(vmetrics[++i]), xref.fetchIfRef(vmetrics[++i]), xref.fetchIfRef(vmetrics[++i])];
+
+              for (j = start; j <= code; j++) {
+                glyphsVMetrics[j] = vmetric;
+              }
+            }
+          }
+        }
+      }
+    } else {
+      var firstChar = properties.firstChar;
+      widths = dict.get("Widths");
+
+      if (widths) {
+        j = firstChar;
+
+        for (i = 0, ii = widths.length; i < ii; i++) {
+          glyphsWidths[j++] = xref.fetchIfRef(widths[i]);
+        }
+
+        defaultWidth = parseFloat(descriptor.get("MissingWidth")) || 0;
+      } else {
+        var baseFontName = dict.get("BaseFont");
+
+        if ((0, _primitives.isName)(baseFontName)) {
+          var metrics = this.getBaseFontMetrics(baseFontName.name);
+          glyphsWidths = this.buildCharCodeToWidth(metrics.widths, properties);
+          defaultWidth = metrics.defaultWidth;
+        }
+      }
+    }
+
+    var isMonospace = true;
+    var firstWidth = defaultWidth;
+
+    for (var glyph in glyphsWidths) {
+      var glyphWidth = glyphsWidths[glyph];
+
+      if (!glyphWidth) {
+        continue;
+      }
+
+      if (!firstWidth) {
+        firstWidth = glyphWidth;
+        continue;
+      }
+
+      if (firstWidth !== glyphWidth) {
+        isMonospace = false;
+        break;
+      }
+    }
+
+    if (isMonospace) {
+      properties.flags |= _fonts.FontFlags.FixedPitch;
+    }
+
+    properties.defaultWidth = defaultWidth;
+    properties.widths = glyphsWidths;
+    properties.defaultVMetrics = defaultVMetrics;
+    properties.vmetrics = glyphsVMetrics;
+  }
+
+  isSerifFont(baseFontName) {
+    var fontNameWoStyle = baseFontName.split("-")[0];
+    return fontNameWoStyle in (0, _standard_fonts.getSerifFonts)() || fontNameWoStyle.search(/serif/gi) !== -1;
+  }
+
+  getBaseFontMetrics(name) {
+    var defaultWidth = 0;
+    var widths = [];
+    var monospace = false;
+    var stdFontMap = (0, _standard_fonts.getStdFontMap)();
+    var lookupName = stdFontMap[name] || name;
+    var Metrics = (0, _metrics.getMetrics)();
+
+    if (!(lookupName in Metrics)) {
+      if (this.isSerifFont(name)) {
+        lookupName = "Times-Roman";
+      } else {
+        lookupName = "Helvetica";
+      }
+    }
+
+    var glyphWidths = Metrics[lookupName];
+
+    if ((0, _util.isNum)(glyphWidths)) {
+      defaultWidth = glyphWidths;
+      monospace = true;
+    } else {
+      widths = glyphWidths();
+    }
+
+    return {
+      defaultWidth,
+      monospace,
+      widths
+    };
+  }
+
+  buildCharCodeToWidth(widthsByGlyphName, properties) {
+    var widths = Object.create(null);
+    var differences = properties.differences;
+    var encoding = properties.defaultEncoding;
+
+    for (var charCode = 0; charCode < 256; charCode++) {
+      if (charCode in differences && widthsByGlyphName[differences[charCode]]) {
+        widths[charCode] = widthsByGlyphName[differences[charCode]];
+        continue;
+      }
+
+      if (charCode in encoding && widthsByGlyphName[encoding[charCode]]) {
+        widths[charCode] = widthsByGlyphName[encoding[charCode]];
+        continue;
+      }
+    }
+
+    return widths;
+  }
+
+  preEvaluateFont(dict) {
+    var baseDict = dict;
+    var type = dict.get("Subtype");
+
+    if (!(0, _primitives.isName)(type)) {
+      throw new _util.FormatError("invalid font Subtype");
+    }
+
+    var composite = false;
+    var uint8array;
+
+    if (type.name === "Type0") {
+      var df = dict.get("DescendantFonts");
+
+      if (!df) {
+        throw new _util.FormatError("Descendant fonts are not specified");
+      }
+
+      dict = Array.isArray(df) ? this.xref.fetchIfRef(df[0]) : df;
+
+      if (!(dict instanceof _primitives.Dict)) {
+        throw new _util.FormatError("Descendant font is not a dictionary.");
+      }
+
+      type = dict.get("Subtype");
+
+      if (!(0, _primitives.isName)(type)) {
+        throw new _util.FormatError("invalid font Subtype");
+      }
+
+      composite = true;
+    }
+
+    var descriptor = dict.get("FontDescriptor");
+
+    if (descriptor) {
+      var hash = new _murmurhash.MurmurHash3_64();
+      var encoding = baseDict.getRaw("Encoding");
+
+      if ((0, _primitives.isName)(encoding)) {
+        hash.update(encoding.name);
+      } else if ((0, _primitives.isRef)(encoding)) {
+        hash.update(encoding.toString());
+      } else if ((0, _primitives.isDict)(encoding)) {
+        for (const entry of encoding.getRawValues()) {
+          if ((0, _primitives.isName)(entry)) {
+            hash.update(entry.name);
+          } else if ((0, _primitives.isRef)(entry)) {
+            hash.update(entry.toString());
+          } else if (Array.isArray(entry)) {
+            var diffLength = entry.length,
+                diffBuf = new Array(diffLength);
+
+            for (var j = 0; j < diffLength; j++) {
+              var diffEntry = entry[j];
+
+              if ((0, _primitives.isName)(diffEntry)) {
+                diffBuf[j] = diffEntry.name;
+              } else if ((0, _util.isNum)(diffEntry) || (0, _primitives.isRef)(diffEntry)) {
+                diffBuf[j] = diffEntry.toString();
+              }
+            }
+
+            hash.update(diffBuf.join());
+          }
+        }
+      }
+
+      const firstChar = dict.get("FirstChar") || 0;
+      const lastChar = dict.get("LastChar") || (composite ? 0xffff : 0xff);
+      hash.update(`${firstChar}-${lastChar}`);
+      var toUnicode = dict.get("ToUnicode") || baseDict.get("ToUnicode");
+
+      if ((0, _primitives.isStream)(toUnicode)) {
+        var stream = toUnicode.str || toUnicode;
+        uint8array = stream.buffer ? new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) : new Uint8Array(stream.bytes.buffer, stream.start, stream.end - stream.start);
+        hash.update(uint8array);
+      } else if ((0, _primitives.isName)(toUnicode)) {
+        hash.update(toUnicode.name);
+      }
+
+      var widths = dict.get("Widths") || baseDict.get("Widths");
+
+      if (widths) {
+        uint8array = new Uint8Array(new Uint32Array(widths).buffer);
+        hash.update(uint8array);
+      }
+    }
+
+    return {
+      descriptor,
+      dict,
+      baseDict,
+      composite,
+      type: type.name,
+      hash: hash ? hash.hexdigest() : ""
+    };
+  }
+
+  async translateFont(preEvaluatedFont) {
+    var baseDict = preEvaluatedFont.baseDict;
+    var dict = preEvaluatedFont.dict;
+    var composite = preEvaluatedFont.composite;
+    var descriptor = preEvaluatedFont.descriptor;
+    var type = preEvaluatedFont.type;
+    var maxCharIndex = composite ? 0xffff : 0xff;
+    var properties;
+    const firstChar = dict.get("FirstChar") || 0;
+    const lastChar = dict.get("LastChar") || maxCharIndex;
+
+    if (!descriptor) {
+      if (type === "Type3") {
+        descriptor = new _primitives.Dict(null);
+        descriptor.set("FontName", _primitives.Name.get(type));
+        descriptor.set("FontBBox", dict.getArray("FontBBox") || [0, 0, 0, 0]);
+      } else {
+        var baseFontName = dict.get("BaseFont");
+
+        if (!(0, _primitives.isName)(baseFontName)) {
+          throw new _util.FormatError("Base font is not specified");
+        }
+
+        baseFontName = baseFontName.name.replace(/[,_]/g, "-");
+        var metrics = this.getBaseFontMetrics(baseFontName);
+        var fontNameWoStyle = baseFontName.split("-")[0];
+        var flags = (this.isSerifFont(fontNameWoStyle) ? _fonts.FontFlags.Serif : 0) | (metrics.monospace ? _fonts.FontFlags.FixedPitch : 0) | ((0, _standard_fonts.getSymbolsFonts)()[fontNameWoStyle] ? _fonts.FontFlags.Symbolic : _fonts.FontFlags.Nonsymbolic);
+        properties = {
+          type,
+          name: baseFontName,
+          widths: metrics.widths,
+          defaultWidth: metrics.defaultWidth,
+          flags,
+          firstChar,
+          lastChar
+        };
+        const widths = dict.get("Widths");
+        return this.extractDataStructures(dict, dict, properties).then(newProperties => {
+          if (widths) {
+            const glyphWidths = [];
+            let j = firstChar;
+
+            for (let i = 0, ii = widths.length; i < ii; i++) {
+              glyphWidths[j++] = this.xref.fetchIfRef(widths[i]);
+            }
+
+            newProperties.widths = glyphWidths;
+          } else {
+            newProperties.widths = this.buildCharCodeToWidth(metrics.widths, newProperties);
+          }
+
+          return new _fonts.Font(baseFontName, null, newProperties);
+        });
+      }
+    }
+
+    var fontName = descriptor.get("FontName");
+    var baseFont = dict.get("BaseFont");
+
+    if ((0, _util.isString)(fontName)) {
+      fontName = _primitives.Name.get(fontName);
+    }
+
+    if ((0, _util.isString)(baseFont)) {
+      baseFont = _primitives.Name.get(baseFont);
+    }
+
+    if (type !== "Type3") {
+      var fontNameStr = fontName && fontName.name;
+      var baseFontStr = baseFont && baseFont.name;
+
+      if (fontNameStr !== baseFontStr) {
+        (0, _util.info)(`The FontDescriptor's FontName is "${fontNameStr}" but ` + `should be the same as the Font's BaseFont "${baseFontStr}".`);
+
+        if (fontNameStr && baseFontStr && baseFontStr.startsWith(fontNameStr)) {
+          fontName = baseFont;
+        }
+      }
+    }
+
+    fontName = fontName || baseFont;
+
+    if (!(0, _primitives.isName)(fontName)) {
+      throw new _util.FormatError("invalid font name");
+    }
+
+    var fontFile = descriptor.get("FontFile", "FontFile2", "FontFile3");
+
+    if (fontFile) {
+      if (fontFile.dict) {
+        var subtype = fontFile.dict.get("Subtype");
+
+        if (subtype) {
+          subtype = subtype.name;
+        }
+
+        var length1 = fontFile.dict.get("Length1");
+        var length2 = fontFile.dict.get("Length2");
+        var length3 = fontFile.dict.get("Length3");
+      }
+    }
+
+    properties = {
+      type,
+      name: fontName.name,
+      subtype,
+      file: fontFile,
+      length1,
+      length2,
+      length3,
+      loadedName: baseDict.loadedName,
+      composite,
+      fixedPitch: false,
+      fontMatrix: dict.getArray("FontMatrix") || _util.FONT_IDENTITY_MATRIX,
+      firstChar: firstChar || 0,
+      lastChar: lastChar || maxCharIndex,
+      bbox: descriptor.getArray("FontBBox"),
+      ascent: descriptor.get("Ascent"),
+      descent: descriptor.get("Descent"),
+      xHeight: descriptor.get("XHeight"),
+      capHeight: descriptor.get("CapHeight"),
+      flags: descriptor.get("Flags"),
+      italicAngle: descriptor.get("ItalicAngle"),
+      isType3Font: false
+    };
+
+    if (composite) {
+      const cidEncoding = baseDict.get("Encoding");
+
+      if ((0, _primitives.isName)(cidEncoding)) {
+        properties.cidEncoding = cidEncoding.name;
+      }
+
+      const cMap = await _cmap.CMapFactory.create({
+        encoding: cidEncoding,
+        fetchBuiltInCMap: this._fetchBuiltInCMapBound,
+        useCMap: null
+      });
+      properties.cMap = cMap;
+      properties.vertical = properties.cMap.vertical;
+    }
+
+    return this.extractDataStructures(dict, baseDict, properties).then(newProperties => {
+      this.extractWidths(dict, descriptor, newProperties);
+
+      if (type === "Type3") {
+        newProperties.isType3Font = true;
+      }
+
+      return new _fonts.Font(fontName.name, fontFile, newProperties);
+    });
+  }
+
+  static buildFontPaths(font, glyphs, handler) {
+    function buildPath(fontChar) {
+      if (font.renderer.hasBuiltPath(fontChar)) {
+        return;
+      }
+
+      handler.send("commonobj", [`${font.loadedName}_path_${fontChar}`, "FontPath", font.renderer.getPathJs(fontChar)]);
+    }
+
+    for (const glyph of glyphs) {
+      buildPath(glyph.fontChar);
+      const accent = glyph.accent;
+
+      if (accent && accent.fontChar) {
+        buildPath(accent.fontChar);
+      }
+    }
+  }
+
+  static get fallbackFontDict() {
+    const dict = new _primitives.Dict();
+    dict.set("BaseFont", _primitives.Name.get("PDFJS-FallbackFont"));
+    dict.set("Type", _primitives.Name.get("FallbackType"));
+    dict.set("Subtype", _primitives.Name.get("FallbackType"));
+    dict.set("Encoding", _primitives.Name.get("WinAnsiEncoding"));
+    return (0, _util.shadow)(this, "fallbackFontDict", dict);
+  }
+
+}
+
+exports.PartialEvaluator = PartialEvaluator;
+
+class TranslatedFont {
+  constructor({
+    loadedName,
+    font,
+    dict,
+    extraProperties = false
+  }) {
+    this.loadedName = loadedName;
+    this.font = font;
+    this.dict = dict;
+    this._extraProperties = extraProperties;
+    this.type3Loaded = null;
+    this.type3Dependencies = font.isType3Font ? new Set() : null;
+    this.sent = false;
+  }
+
+  send(handler) {
+    if (this.sent) {
+      return;
+    }
+
+    this.sent = true;
+    handler.send("commonobj", [this.loadedName, "Font", this.font.exportData(this._extraProperties)]);
+  }
+
+  fallback(handler) {
+    if (!this.font.data) {
+      return;
+    }
+
+    this.font.disableFontFace = true;
+    const glyphs = this.font.glyphCacheValues;
+    PartialEvaluator.buildFontPaths(this.font, glyphs, handler);
+  }
+
+  loadType3Data(evaluator, resources, task) {
+    if (this.type3Loaded) {
+      return this.type3Loaded;
+    }
+
+    if (!this.font.isType3Font) {
+      throw new Error("Must be a Type3 font.");
+    }
+
+    var type3Options = Object.create(evaluator.options);
+    type3Options.ignoreErrors = false;
+    var type3Evaluator = evaluator.clone(type3Options);
+    type3Evaluator.parsingType3Font = true;
+    const translatedFont = this.font,
+          type3Dependencies = this.type3Dependencies;
+    var loadCharProcsPromise = Promise.resolve();
+    var charProcs = this.dict.get("CharProcs");
+    var fontResources = this.dict.get("Resources") || resources;
+    var charProcOperatorList = Object.create(null);
+
+    for (const key of charProcs.getKeys()) {
+      loadCharProcsPromise = loadCharProcsPromise.then(() => {
+        var glyphStream = charProcs.get(key);
+        var operatorList = new _operator_list.OperatorList();
+        return type3Evaluator.getOperatorList({
+          stream: glyphStream,
+          task,
+          resources: fontResources,
+          operatorList
+        }).then(() => {
+          if (operatorList.fnArray[0] === _util.OPS.setCharWidthAndBounds) {
+            this._removeType3ColorOperators(operatorList);
+          }
+
+          charProcOperatorList[key] = operatorList.getIR();
+
+          for (const dependency of operatorList.dependencies) {
+            type3Dependencies.add(dependency);
+          }
+        }).catch(function (reason) {
+          (0, _util.warn)(`Type3 font resource "${key}" is not available.`);
+          const dummyOperatorList = new _operator_list.OperatorList();
+          charProcOperatorList[key] = dummyOperatorList.getIR();
+        });
+      });
+    }
+
+    this.type3Loaded = loadCharProcsPromise.then(function () {
+      translatedFont.charProcOperatorList = charProcOperatorList;
+    });
+    return this.type3Loaded;
+  }
+
+  _removeType3ColorOperators(operatorList) {
+    let i = 1,
+        ii = operatorList.length;
+
+    while (i < ii) {
+      switch (operatorList.fnArray[i]) {
+        case _util.OPS.setStrokeColorSpace:
+        case _util.OPS.setFillColorSpace:
+        case _util.OPS.setStrokeColor:
+        case _util.OPS.setStrokeColorN:
+        case _util.OPS.setFillColor:
+        case _util.OPS.setFillColorN:
+        case _util.OPS.setStrokeGray:
+        case _util.OPS.setFillGray:
+        case _util.OPS.setStrokeRGBColor:
+        case _util.OPS.setFillRGBColor:
+        case _util.OPS.setStrokeCMYKColor:
+        case _util.OPS.setFillCMYKColor:
+        case _util.OPS.shadingFill:
+        case _util.OPS.setRenderingIntent:
+          operatorList.fnArray.splice(i, 1);
+          operatorList.argsArray.splice(i, 1);
+          ii--;
+          continue;
+
+        case _util.OPS.setGState:
+          const gStateObj = operatorList.argsArray[i];
+          let j = 0,
+              jj = gStateObj.length;
+
+          while (j < jj) {
+            const [gStateKey] = gStateObj[j];
+
+            switch (gStateKey) {
+              case "TR":
+              case "TR2":
+              case "HT":
+              case "BG":
+              case "BG2":
+              case "UCR":
+              case "UCR2":
+                gStateObj.splice(j, 1);
+                jj--;
+                continue;
+            }
+
+            j++;
+          }
+
+          break;
+      }
+
+      i++;
+    }
+  }
+
+}
+
+class StateManager {
+  constructor(initialState) {
+    this.state = initialState;
+    this.stateStack = [];
+  }
+
+  save() {
+    var old = this.state;
+    this.stateStack.push(this.state);
+    this.state = old.clone();
+  }
+
+  restore() {
+    var prev = this.stateStack.pop();
+
+    if (prev) {
+      this.state = prev;
+    }
+  }
+
+  transform(args) {
+    this.state.ctm = _util.Util.transform(this.state.ctm, args);
+  }
+
+}
+
+class TextState {
+  constructor() {
+    this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
+    this.fontName = null;
+    this.fontSize = 0;
+    this.font = null;
+    this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
+    this.textMatrix = _util.IDENTITY_MATRIX.slice();
+    this.textLineMatrix = _util.IDENTITY_MATRIX.slice();
+    this.charSpacing = 0;
+    this.wordSpacing = 0;
+    this.leading = 0;
+    this.textHScale = 1;
+    this.textRise = 0;
+  }
+
+  setTextMatrix(a, b, c, d, e, f) {
+    var m = this.textMatrix;
+    m[0] = a;
+    m[1] = b;
+    m[2] = c;
+    m[3] = d;
+    m[4] = e;
+    m[5] = f;
+  }
+
+  setTextLineMatrix(a, b, c, d, e, f) {
+    var m = this.textLineMatrix;
+    m[0] = a;
+    m[1] = b;
+    m[2] = c;
+    m[3] = d;
+    m[4] = e;
+    m[5] = f;
+  }
+
+  translateTextMatrix(x, y) {
+    var m = this.textMatrix;
+    m[4] = m[0] * x + m[2] * y + m[4];
+    m[5] = m[1] * x + m[3] * y + m[5];
+  }
+
+  translateTextLineMatrix(x, y) {
+    var m = this.textLineMatrix;
+    m[4] = m[0] * x + m[2] * y + m[4];
+    m[5] = m[1] * x + m[3] * y + m[5];
+  }
+
+  calcTextLineMatrixAdvance(a, b, c, d, e, f) {
+    var font = this.font;
+
+    if (!font) {
+      return null;
+    }
+
+    var m = this.textLineMatrix;
+
+    if (!(a === m[0] && b === m[1] && c === m[2] && d === m[3])) {
+      return null;
+    }
+
+    var txDiff = e - m[4],
+        tyDiff = f - m[5];
+
+    if (font.vertical && txDiff !== 0 || !font.vertical && tyDiff !== 0) {
+      return null;
+    }
+
+    var tx,
+        ty,
+        denominator = a * d - b * c;
+
+    if (font.vertical) {
+      tx = -tyDiff * c / denominator;
+      ty = tyDiff * a / denominator;
+    } else {
+      tx = txDiff * d / denominator;
+      ty = -txDiff * b / denominator;
+    }
+
+    return {
+      width: tx,
+      height: ty,
+      value: font.vertical ? ty : tx
+    };
+  }
+
+  calcRenderMatrix(ctm) {
+    var tsm = [this.fontSize * this.textHScale, 0, 0, this.fontSize, 0, this.textRise];
+    return _util.Util.transform(ctm, _util.Util.transform(this.textMatrix, tsm));
+  }
+
+  carriageReturn() {
+    this.translateTextLineMatrix(0, -this.leading);
+    this.textMatrix = this.textLineMatrix.slice();
+  }
+
+  clone() {
+    var clone = Object.create(this);
+    clone.textMatrix = this.textMatrix.slice();
+    clone.textLineMatrix = this.textLineMatrix.slice();
+    clone.fontMatrix = this.fontMatrix.slice();
+    return clone;
+  }
+
+}
+
+class EvalState {
+  constructor() {
+    this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
+    this.font = null;
+    this.textRenderingMode = _util.TextRenderingMode.FILL;
+    this.fillColorSpace = _colorspace.ColorSpace.singletons.gray;
+    this.strokeColorSpace = _colorspace.ColorSpace.singletons.gray;
+  }
+
+  clone() {
+    return Object.create(this);
+  }
+
+}
+
+class EvaluatorPreprocessor {
+  static get opMap() {
+    const getOPMap = (0, _core_utils.getLookupTableFactory)(function (t) {
+      t.w = {
+        id: _util.OPS.setLineWidth,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.J = {
+        id: _util.OPS.setLineCap,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.j = {
+        id: _util.OPS.setLineJoin,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.M = {
+        id: _util.OPS.setMiterLimit,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.d = {
+        id: _util.OPS.setDash,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.ri = {
+        id: _util.OPS.setRenderingIntent,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.i = {
+        id: _util.OPS.setFlatness,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.gs = {
+        id: _util.OPS.setGState,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.q = {
+        id: _util.OPS.save,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.Q = {
+        id: _util.OPS.restore,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.cm = {
+        id: _util.OPS.transform,
+        numArgs: 6,
+        variableArgs: false
+      };
+      t.m = {
+        id: _util.OPS.moveTo,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.l = {
+        id: _util.OPS.lineTo,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.c = {
+        id: _util.OPS.curveTo,
+        numArgs: 6,
+        variableArgs: false
+      };
+      t.v = {
+        id: _util.OPS.curveTo2,
+        numArgs: 4,
+        variableArgs: false
+      };
+      t.y = {
+        id: _util.OPS.curveTo3,
+        numArgs: 4,
+        variableArgs: false
+      };
+      t.h = {
+        id: _util.OPS.closePath,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.re = {
+        id: _util.OPS.rectangle,
+        numArgs: 4,
+        variableArgs: false
+      };
+      t.S = {
+        id: _util.OPS.stroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.s = {
+        id: _util.OPS.closeStroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.f = {
+        id: _util.OPS.fill,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.F = {
+        id: _util.OPS.fill,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t["f*"] = {
+        id: _util.OPS.eoFill,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.B = {
+        id: _util.OPS.fillStroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t["B*"] = {
+        id: _util.OPS.eoFillStroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.b = {
+        id: _util.OPS.closeFillStroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t["b*"] = {
+        id: _util.OPS.closeEOFillStroke,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.n = {
+        id: _util.OPS.endPath,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.W = {
+        id: _util.OPS.clip,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t["W*"] = {
+        id: _util.OPS.eoClip,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.BT = {
+        id: _util.OPS.beginText,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.ET = {
+        id: _util.OPS.endText,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.Tc = {
+        id: _util.OPS.setCharSpacing,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Tw = {
+        id: _util.OPS.setWordSpacing,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Tz = {
+        id: _util.OPS.setHScale,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.TL = {
+        id: _util.OPS.setLeading,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Tf = {
+        id: _util.OPS.setFont,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.Tr = {
+        id: _util.OPS.setTextRenderingMode,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Ts = {
+        id: _util.OPS.setTextRise,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Td = {
+        id: _util.OPS.moveText,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.TD = {
+        id: _util.OPS.setLeadingMoveText,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.Tm = {
+        id: _util.OPS.setTextMatrix,
+        numArgs: 6,
+        variableArgs: false
+      };
+      t["T*"] = {
+        id: _util.OPS.nextLine,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.Tj = {
+        id: _util.OPS.showText,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.TJ = {
+        id: _util.OPS.showSpacedText,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t["'"] = {
+        id: _util.OPS.nextLineShowText,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t['"'] = {
+        id: _util.OPS.nextLineSetSpacingShowText,
+        numArgs: 3,
+        variableArgs: false
+      };
+      t.d0 = {
+        id: _util.OPS.setCharWidth,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.d1 = {
+        id: _util.OPS.setCharWidthAndBounds,
+        numArgs: 6,
+        variableArgs: false
+      };
+      t.CS = {
+        id: _util.OPS.setStrokeColorSpace,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.cs = {
+        id: _util.OPS.setFillColorSpace,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.SC = {
+        id: _util.OPS.setStrokeColor,
+        numArgs: 4,
+        variableArgs: true
+      };
+      t.SCN = {
+        id: _util.OPS.setStrokeColorN,
+        numArgs: 33,
+        variableArgs: true
+      };
+      t.sc = {
+        id: _util.OPS.setFillColor,
+        numArgs: 4,
+        variableArgs: true
+      };
+      t.scn = {
+        id: _util.OPS.setFillColorN,
+        numArgs: 33,
+        variableArgs: true
+      };
+      t.G = {
+        id: _util.OPS.setStrokeGray,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.g = {
+        id: _util.OPS.setFillGray,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.RG = {
+        id: _util.OPS.setStrokeRGBColor,
+        numArgs: 3,
+        variableArgs: false
+      };
+      t.rg = {
+        id: _util.OPS.setFillRGBColor,
+        numArgs: 3,
+        variableArgs: false
+      };
+      t.K = {
+        id: _util.OPS.setStrokeCMYKColor,
+        numArgs: 4,
+        variableArgs: false
+      };
+      t.k = {
+        id: _util.OPS.setFillCMYKColor,
+        numArgs: 4,
+        variableArgs: false
+      };
+      t.sh = {
+        id: _util.OPS.shadingFill,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.BI = {
+        id: _util.OPS.beginInlineImage,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.ID = {
+        id: _util.OPS.beginImageData,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.EI = {
+        id: _util.OPS.endInlineImage,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.Do = {
+        id: _util.OPS.paintXObject,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.MP = {
+        id: _util.OPS.markPoint,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.DP = {
+        id: _util.OPS.markPointProps,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.BMC = {
+        id: _util.OPS.beginMarkedContent,
+        numArgs: 1,
+        variableArgs: false
+      };
+      t.BDC = {
+        id: _util.OPS.beginMarkedContentProps,
+        numArgs: 2,
+        variableArgs: false
+      };
+      t.EMC = {
+        id: _util.OPS.endMarkedContent,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.BX = {
+        id: _util.OPS.beginCompat,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.EX = {
+        id: _util.OPS.endCompat,
+        numArgs: 0,
+        variableArgs: false
+      };
+      t.BM = null;
+      t.BD = null;
+      t.true = null;
+      t.fa = null;
+      t.fal = null;
+      t.fals = null;
+      t.false = null;
+      t.nu = null;
+      t.nul = null;
+      t.null = null;
+    });
+    return (0, _util.shadow)(this, "opMap", getOPMap());
+  }
+
+  static get MAX_INVALID_PATH_OPS() {
+    return (0, _util.shadow)(this, "MAX_INVALID_PATH_OPS", 20);
+  }
+
+  constructor(stream, xref, stateManager) {
+    this.parser = new _parser.Parser({
+      lexer: new _parser.Lexer(stream, EvaluatorPreprocessor.opMap),
+      xref
+    });
+    this.stateManager = stateManager;
+    this.nonProcessedArgs = [];
+    this._numInvalidPathOPS = 0;
+  }
+
+  get savedStatesDepth() {
+    return this.stateManager.stateStack.length;
+  }
+
+  read(operation) {
+    var args = operation.args;
+
+    while (true) {
+      var obj = this.parser.getObj();
+
+      if (obj instanceof _primitives.Cmd) {
+        var cmd = obj.cmd;
+        var opSpec = EvaluatorPreprocessor.opMap[cmd];
+
+        if (!opSpec) {
+          (0, _util.warn)(`Unknown command "${cmd}".`);
+          continue;
+        }
+
+        var fn = opSpec.id;
+        var numArgs = opSpec.numArgs;
+        var argsLength = args !== null ? args.length : 0;
+
+        if (!opSpec.variableArgs) {
+          if (argsLength !== numArgs) {
+            var nonProcessedArgs = this.nonProcessedArgs;
+
+            while (argsLength > numArgs) {
+              nonProcessedArgs.push(args.shift());
+              argsLength--;
+            }
+
+            while (argsLength < numArgs && nonProcessedArgs.length !== 0) {
+              if (args === null) {
+                args = [];
+              }
+
+              args.unshift(nonProcessedArgs.pop());
+              argsLength++;
+            }
+          }
+
+          if (argsLength < numArgs) {
+            const partialMsg = `command ${cmd}: expected ${numArgs} args, ` + `but received ${argsLength} args.`;
+
+            if (fn >= _util.OPS.moveTo && fn <= _util.OPS.endPath && ++this._numInvalidPathOPS > EvaluatorPreprocessor.MAX_INVALID_PATH_OPS) {
+              throw new _util.FormatError(`Invalid ${partialMsg}`);
+            }
+
+            (0, _util.warn)(`Skipping ${partialMsg}`);
+
+            if (args !== null) {
+              args.length = 0;
+            }
+
+            continue;
+          }
+        } else if (argsLength > numArgs) {
+          (0, _util.info)(`Command ${cmd}: expected [0, ${numArgs}] args, ` + `but received ${argsLength} args.`);
+        }
+
+        this.preprocessCommand(fn, args);
+        operation.fn = fn;
+        operation.args = args;
+        return true;
+      }
+
+      if (obj === _primitives.EOF) {
+        return false;
+      }
+
+      if (obj !== null) {
+        if (args === null) {
+          args = [];
+        }
+
+        args.push(obj);
+
+        if (args.length > 33) {
+          throw new _util.FormatError("Too many arguments");
+        }
+      }
+    }
+  }
+
+  preprocessCommand(fn, args) {
+    switch (fn | 0) {
+      case _util.OPS.save:
+        this.stateManager.save();
+        break;
+
+      case _util.OPS.restore:
+        this.stateManager.restore();
+        break;
+
+      case _util.OPS.transform:
+        this.stateManager.transform(args);
+        break;
+    }
+  }
+
+}
+
+/***/ }),
+/* 30 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.IdentityCMap = exports.CMapFactory = exports.CMap = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _parser = __w_pdfjs_require__(11);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _stream = __w_pdfjs_require__(12);
+
+var BUILT_IN_CMAPS = ["Adobe-GB1-UCS2", "Adobe-CNS1-UCS2", "Adobe-Japan1-UCS2", "Adobe-Korea1-UCS2", "78-EUC-H", "78-EUC-V", "78-H", "78-RKSJ-H", "78-RKSJ-V", "78-V", "78ms-RKSJ-H", "78ms-RKSJ-V", "83pv-RKSJ-H", "90ms-RKSJ-H", "90ms-RKSJ-V", "90msp-RKSJ-H", "90msp-RKSJ-V", "90pv-RKSJ-H", "90pv-RKSJ-V", "Add-H", "Add-RKSJ-H", "Add-RKSJ-V", "Add-V", "Adobe-CNS1-0", "Adobe-CNS1-1", "Adobe-CNS1-2", "Adobe-CNS1-3", "Adobe-CNS1-4", "Adobe-CNS1-5", "Adobe-CNS1-6", "Adobe-GB1-0", "Adobe-GB1-1", "Adobe-GB1-2", "Adobe-GB1-3", "Adobe-GB1-4", "Adobe-GB1-5", "Adobe-Japan1-0", "Adobe-Japan1-1", "Adobe-Japan1-2", "Adobe-Japan1-3", "Adobe-Japan1-4", "Adobe-Japan1-5", "Adobe-Japan1-6", "Adobe-Korea1-0", "Adobe-Korea1-1", "Adobe-Korea1-2", "B5-H", "B5-V", "B5pc-H", "B5pc-V", "CNS-EUC-H", "CNS-EUC-V", "CNS1-H", "CNS1-V", "CNS2-H", "CNS2-V", "ETHK-B5-H", "ETHK-B5-V", "ETen-B5-H", "ETen-B5-V", "ETenms-B5-H", "ETenms-B5-V", "EUC-H", "EUC-V", "Ext-H", "Ext-RKSJ-H", "Ext-RKSJ-V", "Ext-V", "GB-EUC-H", "GB-EUC-V", "GB-H", "GB-V", "GBK-EUC-H", "GBK-EUC-V", "GBK2K-H", "GBK2K-V", "GBKp-EUC-H", "GBKp-EUC-V", "GBT-EUC-H", "GBT-EUC-V", "GBT-H", "GBT-V", "GBTpc-EUC-H", "GBTpc-EUC-V", "GBpc-EUC-H", "GBpc-EUC-V", "H", "HKdla-B5-H", "HKdla-B5-V", "HKdlb-B5-H", "HKdlb-B5-V", "HKgccs-B5-H", "HKgccs-B5-V", "HKm314-B5-H", "HKm314-B5-V", "HKm471-B5-H", "HKm471-B5-V", "HKscs-B5-H", "HKscs-B5-V", "Hankaku", "Hiragana", "KSC-EUC-H", "KSC-EUC-V", "KSC-H", "KSC-Johab-H", "KSC-Johab-V", "KSC-V", "KSCms-UHC-H", "KSCms-UHC-HW-H", "KSCms-UHC-HW-V", "KSCms-UHC-V", "KSCpc-EUC-H", "KSCpc-EUC-V", "Katakana", "NWP-H", "NWP-V", "RKSJ-H", "RKSJ-V", "Roman", "UniCNS-UCS2-H", "UniCNS-UCS2-V", "UniCNS-UTF16-H", "UniCNS-UTF16-V", "UniCNS-UTF32-H", "UniCNS-UTF32-V", "UniCNS-UTF8-H", "UniCNS-UTF8-V", "UniGB-UCS2-H", "UniGB-UCS2-V", "UniGB-UTF16-H", "UniGB-UTF16-V", "UniGB-UTF32-H", "UniGB-UTF32-V", "UniGB-UTF8-H", "UniGB-UTF8-V", "UniJIS-UCS2-H", "UniJIS-UCS2-HW-H", "UniJIS-UCS2-HW-V", "UniJIS-UCS2-V", "UniJIS-UTF16-H", "UniJIS-UTF16-V", "UniJIS-UTF32-H", "UniJIS-UTF32-V", "UniJIS-UTF8-H", "UniJIS-UTF8-V", "UniJIS2004-UTF16-H", "UniJIS2004-UTF16-V", "UniJIS2004-UTF32-H", "UniJIS2004-UTF32-V", "UniJIS2004-UTF8-H", "UniJIS2004-UTF8-V", "UniJISPro-UCS2-HW-V", "UniJISPro-UCS2-V", "UniJISPro-UTF8-V", "UniJISX0213-UTF32-H", "UniJISX0213-UTF32-V", "UniJISX02132004-UTF32-H", "UniJISX02132004-UTF32-V", "UniKS-UCS2-H", "UniKS-UCS2-V", "UniKS-UTF16-H", "UniKS-UTF16-V", "UniKS-UTF32-H", "UniKS-UTF32-V", "UniKS-UTF8-H", "UniKS-UTF8-V", "V", "WP-Symbol"];
+const MAX_MAP_RANGE = 2 ** 24 - 1;
+
+class CMap {
+  constructor(builtInCMap = false) {
+    this.codespaceRanges = [[], [], [], []];
+    this.numCodespaceRanges = 0;
+    this._map = [];
+    this.name = "";
+    this.vertical = false;
+    this.useCMap = null;
+    this.builtInCMap = builtInCMap;
+  }
+
+  addCodespaceRange(n, low, high) {
+    this.codespaceRanges[n - 1].push(low, high);
+    this.numCodespaceRanges++;
+  }
+
+  mapCidRange(low, high, dstLow) {
+    if (high - low > MAX_MAP_RANGE) {
+      throw new Error("mapCidRange - ignoring data above MAX_MAP_RANGE.");
+    }
+
+    while (low <= high) {
+      this._map[low++] = dstLow++;
+    }
+  }
+
+  mapBfRange(low, high, dstLow) {
+    if (high - low > MAX_MAP_RANGE) {
+      throw new Error("mapBfRange - ignoring data above MAX_MAP_RANGE.");
+    }
+
+    var lastByte = dstLow.length - 1;
+
+    while (low <= high) {
+      this._map[low++] = dstLow;
+      dstLow = dstLow.substring(0, lastByte) + String.fromCharCode(dstLow.charCodeAt(lastByte) + 1);
+    }
+  }
+
+  mapBfRangeToArray(low, high, array) {
+    if (high - low > MAX_MAP_RANGE) {
+      throw new Error("mapBfRangeToArray - ignoring data above MAX_MAP_RANGE.");
+    }
+
+    const ii = array.length;
+    let i = 0;
+
+    while (low <= high && i < ii) {
+      this._map[low] = array[i++];
+      ++low;
+    }
+  }
+
+  mapOne(src, dst) {
+    this._map[src] = dst;
+  }
+
+  lookup(code) {
+    return this._map[code];
+  }
+
+  contains(code) {
+    return this._map[code] !== undefined;
+  }
+
+  forEach(callback) {
+    const map = this._map;
+    const length = map.length;
+
+    if (length <= 0x10000) {
+      for (let i = 0; i < length; i++) {
+        if (map[i] !== undefined) {
+          callback(i, map[i]);
+        }
+      }
+    } else {
+      for (const i in map) {
+        callback(i, map[i]);
+      }
+    }
+  }
+
+  charCodeOf(value) {
+    const map = this._map;
+
+    if (map.length <= 0x10000) {
+      return map.indexOf(value);
+    }
+
+    for (const charCode in map) {
+      if (map[charCode] === value) {
+        return charCode | 0;
+      }
+    }
+
+    return -1;
+  }
+
+  getMap() {
+    return this._map;
+  }
+
+  readCharCode(str, offset, out) {
+    let c = 0;
+    const codespaceRanges = this.codespaceRanges;
+
+    for (let n = 0, nn = codespaceRanges.length; n < nn; n++) {
+      c = (c << 8 | str.charCodeAt(offset + n)) >>> 0;
+      const codespaceRange = codespaceRanges[n];
+
+      for (let k = 0, kk = codespaceRange.length; k < kk;) {
+        const low = codespaceRange[k++];
+        const high = codespaceRange[k++];
+
+        if (c >= low && c <= high) {
+          out.charcode = c;
+          out.length = n + 1;
+          return;
+        }
+      }
+    }
+
+    out.charcode = 0;
+    out.length = 1;
+  }
+
+  getCharCodeLength(charCode) {
+    const codespaceRanges = this.codespaceRanges;
+
+    for (let n = 0, nn = codespaceRanges.length; n < nn; n++) {
+      const codespaceRange = codespaceRanges[n];
+
+      for (let k = 0, kk = codespaceRange.length; k < kk;) {
+        const low = codespaceRange[k++];
+        const high = codespaceRange[k++];
+
+        if (charCode >= low && charCode <= high) {
+          return n + 1;
+        }
+      }
+    }
+
+    return 1;
+  }
+
+  get length() {
+    return this._map.length;
+  }
+
+  get isIdentityCMap() {
+    if (!(this.name === "Identity-H" || this.name === "Identity-V")) {
+      return false;
+    }
+
+    if (this._map.length !== 0x10000) {
+      return false;
+    }
+
+    for (let i = 0; i < 0x10000; i++) {
+      if (this._map[i] !== i) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+}
+
+exports.CMap = CMap;
+
+class IdentityCMap extends CMap {
+  constructor(vertical, n) {
+    super();
+    this.vertical = vertical;
+    this.addCodespaceRange(n, 0, 0xffff);
+  }
+
+  mapCidRange(low, high, dstLow) {
+    (0, _util.unreachable)("should not call mapCidRange");
+  }
+
+  mapBfRange(low, high, dstLow) {
+    (0, _util.unreachable)("should not call mapBfRange");
+  }
+
+  mapBfRangeToArray(low, high, array) {
+    (0, _util.unreachable)("should not call mapBfRangeToArray");
+  }
+
+  mapOne(src, dst) {
+    (0, _util.unreachable)("should not call mapCidOne");
+  }
+
+  lookup(code) {
+    return Number.isInteger(code) && code <= 0xffff ? code : undefined;
+  }
+
+  contains(code) {
+    return Number.isInteger(code) && code <= 0xffff;
+  }
+
+  forEach(callback) {
+    for (let i = 0; i <= 0xffff; i++) {
+      callback(i, i);
+    }
+  }
+
+  charCodeOf(value) {
+    return Number.isInteger(value) && value <= 0xffff ? value : -1;
+  }
+
+  getMap() {
+    const map = new Array(0x10000);
+
+    for (let i = 0; i <= 0xffff; i++) {
+      map[i] = i;
+    }
+
+    return map;
+  }
+
+  get length() {
+    return 0x10000;
+  }
+
+  get isIdentityCMap() {
+    (0, _util.unreachable)("should not access .isIdentityCMap");
+  }
+
+}
+
+exports.IdentityCMap = IdentityCMap;
+
+var BinaryCMapReader = function BinaryCMapReaderClosure() {
+  function hexToInt(a, size) {
+    var n = 0;
+
+    for (var i = 0; i <= size; i++) {
+      n = n << 8 | a[i];
+    }
+
+    return n >>> 0;
+  }
+
+  function hexToStr(a, size) {
+    if (size === 1) {
+      return String.fromCharCode(a[0], a[1]);
+    }
+
+    if (size === 3) {
+      return String.fromCharCode(a[0], a[1], a[2], a[3]);
+    }
+
+    return String.fromCharCode.apply(null, a.subarray(0, size + 1));
+  }
+
+  function addHex(a, b, size) {
+    var c = 0;
+
+    for (var i = size; i >= 0; i--) {
+      c += a[i] + b[i];
+      a[i] = c & 255;
+      c >>= 8;
+    }
+  }
+
+  function incHex(a, size) {
+    var c = 1;
+
+    for (var i = size; i >= 0 && c > 0; i--) {
+      c += a[i];
+      a[i] = c & 255;
+      c >>= 8;
+    }
+  }
+
+  var MAX_NUM_SIZE = 16;
+  var MAX_ENCODED_NUM_SIZE = 19;
+
+  function BinaryCMapStream(data) {
+    this.buffer = data;
+    this.pos = 0;
+    this.end = data.length;
+    this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
+  }
+
+  BinaryCMapStream.prototype = {
+    readByte() {
+      if (this.pos >= this.end) {
+        return -1;
+      }
+
+      return this.buffer[this.pos++];
+    },
+
+    readNumber() {
+      var n = 0;
+      var last;
+
+      do {
+        var b = this.readByte();
+
+        if (b < 0) {
+          throw new _util.FormatError("unexpected EOF in bcmap");
+        }
+
+        last = !(b & 0x80);
+        n = n << 7 | b & 0x7f;
+      } while (!last);
+
+      return n;
+    },
+
+    readSigned() {
+      var n = this.readNumber();
+      return n & 1 ? ~(n >>> 1) : n >>> 1;
+    },
+
+    readHex(num, size) {
+      num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
+      this.pos += size + 1;
+    },
+
+    readHexNumber(num, size) {
+      var last;
+      var stack = this.tmpBuf,
+          sp = 0;
+
+      do {
+        var b = this.readByte();
+
+        if (b < 0) {
+          throw new _util.FormatError("unexpected EOF in bcmap");
+        }
+
+        last = !(b & 0x80);
+        stack[sp++] = b & 0x7f;
+      } while (!last);
+
+      var i = size,
+          buffer = 0,
+          bufferSize = 0;
+
+      while (i >= 0) {
+        while (bufferSize < 8 && stack.length > 0) {
+          buffer = stack[--sp] << bufferSize | buffer;
+          bufferSize += 7;
+        }
+
+        num[i] = buffer & 255;
+        i--;
+        buffer >>= 8;
+        bufferSize -= 8;
+      }
+    },
+
+    readHexSigned(num, size) {
+      this.readHexNumber(num, size);
+      var sign = num[size] & 1 ? 255 : 0;
+      var c = 0;
+
+      for (var i = 0; i <= size; i++) {
+        c = (c & 1) << 8 | num[i];
+        num[i] = c >> 1 ^ sign;
+      }
+    },
+
+    readString() {
+      var len = this.readNumber();
+      var s = "";
+
+      for (var i = 0; i < len; i++) {
+        s += String.fromCharCode(this.readNumber());
+      }
+
+      return s;
+    }
+
+  };
+
+  function processBinaryCMap(data, cMap, extend) {
+    return new Promise(function (resolve, reject) {
+      var stream = new BinaryCMapStream(data);
+      var header = stream.readByte();
+      cMap.vertical = !!(header & 1);
+      var useCMap = null;
+      var start = new Uint8Array(MAX_NUM_SIZE);
+      var end = new Uint8Array(MAX_NUM_SIZE);
+      var char = new Uint8Array(MAX_NUM_SIZE);
+      var charCode = new Uint8Array(MAX_NUM_SIZE);
+      var tmp = new Uint8Array(MAX_NUM_SIZE);
+      var code;
+      var b;
+
+      while ((b = stream.readByte()) >= 0) {
+        var type = b >> 5;
+
+        if (type === 7) {
+          switch (b & 0x1f) {
+            case 0:
+              stream.readString();
+              break;
+
+            case 1:
+              useCMap = stream.readString();
+              break;
+          }
+
+          continue;
+        }
+
+        var sequence = !!(b & 0x10);
+        var dataSize = b & 15;
+
+        if (dataSize + 1 > MAX_NUM_SIZE) {
+          throw new Error("processBinaryCMap: Invalid dataSize.");
+        }
+
+        var ucs2DataSize = 1;
+        var subitemsCount = stream.readNumber();
+        var i;
+
+        switch (type) {
+          case 0:
+            stream.readHex(start, dataSize);
+            stream.readHexNumber(end, dataSize);
+            addHex(end, start, dataSize);
+            cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(end, dataSize);
+              stream.readHexNumber(start, dataSize);
+              addHex(start, end, dataSize);
+              stream.readHexNumber(end, dataSize);
+              addHex(end, start, dataSize);
+              cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
+            }
+
+            break;
+
+          case 1:
+            stream.readHex(start, dataSize);
+            stream.readHexNumber(end, dataSize);
+            addHex(end, start, dataSize);
+            stream.readNumber();
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(end, dataSize);
+              stream.readHexNumber(start, dataSize);
+              addHex(start, end, dataSize);
+              stream.readHexNumber(end, dataSize);
+              addHex(end, start, dataSize);
+              stream.readNumber();
+            }
+
+            break;
+
+          case 2:
+            stream.readHex(char, dataSize);
+            code = stream.readNumber();
+            cMap.mapOne(hexToInt(char, dataSize), code);
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(char, dataSize);
+
+              if (!sequence) {
+                stream.readHexNumber(tmp, dataSize);
+                addHex(char, tmp, dataSize);
+              }
+
+              code = stream.readSigned() + (code + 1);
+              cMap.mapOne(hexToInt(char, dataSize), code);
+            }
+
+            break;
+
+          case 3:
+            stream.readHex(start, dataSize);
+            stream.readHexNumber(end, dataSize);
+            addHex(end, start, dataSize);
+            code = stream.readNumber();
+            cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(end, dataSize);
+
+              if (!sequence) {
+                stream.readHexNumber(start, dataSize);
+                addHex(start, end, dataSize);
+              } else {
+                start.set(end);
+              }
+
+              stream.readHexNumber(end, dataSize);
+              addHex(end, start, dataSize);
+              code = stream.readNumber();
+              cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
+            }
+
+            break;
+
+          case 4:
+            stream.readHex(char, ucs2DataSize);
+            stream.readHex(charCode, dataSize);
+            cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(char, ucs2DataSize);
+
+              if (!sequence) {
+                stream.readHexNumber(tmp, ucs2DataSize);
+                addHex(char, tmp, ucs2DataSize);
+              }
+
+              incHex(charCode, dataSize);
+              stream.readHexSigned(tmp, dataSize);
+              addHex(charCode, tmp, dataSize);
+              cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
+            }
+
+            break;
+
+          case 5:
+            stream.readHex(start, ucs2DataSize);
+            stream.readHexNumber(end, ucs2DataSize);
+            addHex(end, start, ucs2DataSize);
+            stream.readHex(charCode, dataSize);
+            cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
+
+            for (i = 1; i < subitemsCount; i++) {
+              incHex(end, ucs2DataSize);
+
+              if (!sequence) {
+                stream.readHexNumber(start, ucs2DataSize);
+                addHex(start, end, ucs2DataSize);
+              } else {
+                start.set(end);
+              }
+
+              stream.readHexNumber(end, ucs2DataSize);
+              addHex(end, start, ucs2DataSize);
+              stream.readHex(charCode, dataSize);
+              cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
+            }
+
+            break;
+
+          default:
+            reject(new Error("processBinaryCMap: Unknown type: " + type));
+            return;
+        }
+      }
+
+      if (useCMap) {
+        resolve(extend(useCMap));
+        return;
+      }
+
+      resolve(cMap);
+    });
+  }
+
+  function BinaryCMapReader() {}
+
+  BinaryCMapReader.prototype = {
+    process: processBinaryCMap
+  };
+  return BinaryCMapReader;
+}();
+
+var CMapFactory = function CMapFactoryClosure() {
+  function strToInt(str) {
+    var a = 0;
+
+    for (var i = 0; i < str.length; i++) {
+      a = a << 8 | str.charCodeAt(i);
+    }
+
+    return a >>> 0;
+  }
+
+  function expectString(obj) {
+    if (!(0, _util.isString)(obj)) {
+      throw new _util.FormatError("Malformed CMap: expected string.");
+    }
+  }
+
+  function expectInt(obj) {
+    if (!Number.isInteger(obj)) {
+      throw new _util.FormatError("Malformed CMap: expected int.");
+    }
+  }
+
+  function parseBfChar(cMap, lexer) {
+    while (true) {
+      var obj = lexer.getObj();
+
+      if ((0, _primitives.isEOF)(obj)) {
+        break;
+      }
+
+      if ((0, _primitives.isCmd)(obj, "endbfchar")) {
+        return;
+      }
+
+      expectString(obj);
+      var src = strToInt(obj);
+      obj = lexer.getObj();
+      expectString(obj);
+      var dst = obj;
+      cMap.mapOne(src, dst);
+    }
+  }
+
+  function parseBfRange(cMap, lexer) {
+    while (true) {
+      var obj = lexer.getObj();
+
+      if ((0, _primitives.isEOF)(obj)) {
+        break;
+      }
+
+      if ((0, _primitives.isCmd)(obj, "endbfrange")) {
+        return;
+      }
+
+      expectString(obj);
+      var low = strToInt(obj);
+      obj = lexer.getObj();
+      expectString(obj);
+      var high = strToInt(obj);
+      obj = lexer.getObj();
+
+      if (Number.isInteger(obj) || (0, _util.isString)(obj)) {
+        var dstLow = Number.isInteger(obj) ? String.fromCharCode(obj) : obj;
+        cMap.mapBfRange(low, high, dstLow);
+      } else if ((0, _primitives.isCmd)(obj, "[")) {
+        obj = lexer.getObj();
+        var array = [];
+
+        while (!(0, _primitives.isCmd)(obj, "]") && !(0, _primitives.isEOF)(obj)) {
+          array.push(obj);
+          obj = lexer.getObj();
+        }
+
+        cMap.mapBfRangeToArray(low, high, array);
+      } else {
+        break;
+      }
+    }
+
+    throw new _util.FormatError("Invalid bf range.");
+  }
+
+  function parseCidChar(cMap, lexer) {
+    while (true) {
+      var obj = lexer.getObj();
+
+      if ((0, _primitives.isEOF)(obj)) {
+        break;
+      }
+
+      if ((0, _primitives.isCmd)(obj, "endcidchar")) {
+        return;
+      }
+
+      expectString(obj);
+      var src = strToInt(obj);
+      obj = lexer.getObj();
+      expectInt(obj);
+      var dst = obj;
+      cMap.mapOne(src, dst);
+    }
+  }
+
+  function parseCidRange(cMap, lexer) {
+    while (true) {
+      var obj = lexer.getObj();
+
+      if ((0, _primitives.isEOF)(obj)) {
+        break;
+      }
+
+      if ((0, _primitives.isCmd)(obj, "endcidrange")) {
+        return;
+      }
+
+      expectString(obj);
+      var low = strToInt(obj);
+      obj = lexer.getObj();
+      expectString(obj);
+      var high = strToInt(obj);
+      obj = lexer.getObj();
+      expectInt(obj);
+      var dstLow = obj;
+      cMap.mapCidRange(low, high, dstLow);
+    }
+  }
+
+  function parseCodespaceRange(cMap, lexer) {
+    while (true) {
+      var obj = lexer.getObj();
+
+      if ((0, _primitives.isEOF)(obj)) {
+        break;
+      }
+
+      if ((0, _primitives.isCmd)(obj, "endcodespacerange")) {
+        return;
+      }
+
+      if (!(0, _util.isString)(obj)) {
+        break;
+      }
+
+      var low = strToInt(obj);
+      obj = lexer.getObj();
+
+      if (!(0, _util.isString)(obj)) {
+        break;
+      }
+
+      var high = strToInt(obj);
+      cMap.addCodespaceRange(obj.length, low, high);
+    }
+
+    throw new _util.FormatError("Invalid codespace range.");
+  }
+
+  function parseWMode(cMap, lexer) {
+    var obj = lexer.getObj();
+
+    if (Number.isInteger(obj)) {
+      cMap.vertical = !!obj;
+    }
+  }
+
+  function parseCMapName(cMap, lexer) {
+    var obj = lexer.getObj();
+
+    if ((0, _primitives.isName)(obj) && (0, _util.isString)(obj.name)) {
+      cMap.name = obj.name;
+    }
+  }
+
+  function parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap) {
+    var previous;
+    var embeddedUseCMap;
+
+    objLoop: while (true) {
+      try {
+        var obj = lexer.getObj();
+
+        if ((0, _primitives.isEOF)(obj)) {
+          break;
+        } else if ((0, _primitives.isName)(obj)) {
+          if (obj.name === "WMode") {
+            parseWMode(cMap, lexer);
+          } else if (obj.name === "CMapName") {
+            parseCMapName(cMap, lexer);
+          }
+
+          previous = obj;
+        } else if ((0, _primitives.isCmd)(obj)) {
+          switch (obj.cmd) {
+            case "endcmap":
+              break objLoop;
+
+            case "usecmap":
+              if ((0, _primitives.isName)(previous)) {
+                embeddedUseCMap = previous.name;
+              }
+
+              break;
+
+            case "begincodespacerange":
+              parseCodespaceRange(cMap, lexer);
+              break;
+
+            case "beginbfchar":
+              parseBfChar(cMap, lexer);
+              break;
+
+            case "begincidchar":
+              parseCidChar(cMap, lexer);
+              break;
+
+            case "beginbfrange":
+              parseBfRange(cMap, lexer);
+              break;
+
+            case "begincidrange":
+              parseCidRange(cMap, lexer);
+              break;
+          }
+        }
+      } catch (ex) {
+        if (ex instanceof _core_utils.MissingDataException) {
+          throw ex;
+        }
+
+        (0, _util.warn)("Invalid cMap data: " + ex);
+        continue;
+      }
+    }
+
+    if (!useCMap && embeddedUseCMap) {
+      useCMap = embeddedUseCMap;
+    }
+
+    if (useCMap) {
+      return extendCMap(cMap, fetchBuiltInCMap, useCMap);
+    }
+
+    return Promise.resolve(cMap);
+  }
+
+  function extendCMap(cMap, fetchBuiltInCMap, useCMap) {
+    return createBuiltInCMap(useCMap, fetchBuiltInCMap).then(function (newCMap) {
+      cMap.useCMap = newCMap;
+
+      if (cMap.numCodespaceRanges === 0) {
+        var useCodespaceRanges = cMap.useCMap.codespaceRanges;
+
+        for (var i = 0; i < useCodespaceRanges.length; i++) {
+          cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();
+        }
+
+        cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;
+      }
+
+      cMap.useCMap.forEach(function (key, value) {
+        if (!cMap.contains(key)) {
+          cMap.mapOne(key, cMap.useCMap.lookup(key));
+        }
+      });
+      return cMap;
+    });
+  }
+
+  function createBuiltInCMap(name, fetchBuiltInCMap) {
+    if (name === "Identity-H") {
+      return Promise.resolve(new IdentityCMap(false, 2));
+    } else if (name === "Identity-V") {
+      return Promise.resolve(new IdentityCMap(true, 2));
+    }
+
+    if (!BUILT_IN_CMAPS.includes(name)) {
+      return Promise.reject(new Error("Unknown CMap name: " + name));
+    }
+
+    if (!fetchBuiltInCMap) {
+      return Promise.reject(new Error("Built-in CMap parameters are not provided."));
+    }
+
+    return fetchBuiltInCMap(name).then(function (data) {
+      var cMapData = data.cMapData,
+          compressionType = data.compressionType;
+      var cMap = new CMap(true);
+
+      if (compressionType === _util.CMapCompressionType.BINARY) {
+        return new BinaryCMapReader().process(cMapData, cMap, function (useCMap) {
+          return extendCMap(cMap, fetchBuiltInCMap, useCMap);
+        });
+      }
+
+      if (compressionType === _util.CMapCompressionType.NONE) {
+        var lexer = new _parser.Lexer(new _stream.Stream(cMapData));
+        return parseCMap(cMap, lexer, fetchBuiltInCMap, null);
+      }
+
+      return Promise.reject(new Error("TODO: Only BINARY/NONE CMap compression is currently supported."));
+    });
+  }
+
+  return {
+    async create(params) {
+      var encoding = params.encoding;
+      var fetchBuiltInCMap = params.fetchBuiltInCMap;
+      var useCMap = params.useCMap;
+
+      if ((0, _primitives.isName)(encoding)) {
+        return createBuiltInCMap(encoding.name, fetchBuiltInCMap);
+      } else if ((0, _primitives.isStream)(encoding)) {
+        var cMap = new CMap();
+        var lexer = new _parser.Lexer(encoding);
+        return parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap).then(function (parsedCMap) {
+          if (parsedCMap.isIdentityCMap) {
+            return createBuiltInCMap(parsedCMap.name, fetchBuiltInCMap);
+          }
+
+          return parsedCMap;
+        });
+      }
+
+      throw new Error("Encoding required.");
+    }
+
+  };
+}();
+
+exports.CMapFactory = CMapFactory;
+
+/***/ }),
+/* 31 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getFontType = getFontType;
+exports.ToUnicodeMap = exports.SEAC_ANALYSIS_ENABLED = exports.IdentityToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _cff_parser = __w_pdfjs_require__(32);
+
+var _glyphlist = __w_pdfjs_require__(35);
+
+var _encodings = __w_pdfjs_require__(34);
+
+var _standard_fonts = __w_pdfjs_require__(36);
+
+var _unicode = __w_pdfjs_require__(37);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _font_renderer = __w_pdfjs_require__(38);
+
+var _cmap = __w_pdfjs_require__(30);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _type1_parser = __w_pdfjs_require__(39);
+
+const PRIVATE_USE_AREAS = [[0xe000, 0xf8ff], [0x100000, 0x10fffd]];
+var PDF_GLYPH_SPACE_UNITS = 1000;
+var SEAC_ANALYSIS_ENABLED = true;
+exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED;
+const EXPORT_DATA_PROPERTIES = ["ascent", "bbox", "black", "bold", "charProcOperatorList", "composite", "data", "defaultVMetrics", "defaultWidth", "descent", "fallbackName", "fontMatrix", "fontType", "isMonospace", "isSerifFont", "isType3Font", "italic", "loadedName", "mimetype", "missingFile", "name", "remeasure", "subtype", "type", "vertical"];
+const EXPORT_DATA_EXTRA_PROPERTIES = ["cMap", "defaultEncoding", "differences", "isSymbolicFont", "seacMap", "toFontChar", "toUnicode", "vmetrics", "widths"];
+var FontFlags = {
+  FixedPitch: 1,
+  Serif: 2,
+  Symbolic: 4,
+  Script: 8,
+  Nonsymbolic: 32,
+  Italic: 64,
+  AllCap: 65536,
+  SmallCap: 131072,
+  ForceBold: 262144
+};
+exports.FontFlags = FontFlags;
+var MacStandardGlyphOrdering = [".notdef", ".null", "nonmarkingreturn", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quotesingle", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "grave", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "Adieresis", "Aring", "Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis", "aacute", "agrave", "acircumflex", "adieresis", "atilde", "aring", "ccedilla", "eacute", "egrave", "ecircumflex", "edieresis", "iacute", "igrave", "icircumflex", "idieresis", "ntilde", "oacute", "ograve", "ocircumflex", "odieresis", "otilde", "uacute", "ugrave", "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling", "section", "bullet", "paragraph", "germandbls", "registered", "copyright", "trademark", "acute", "dieresis", "notequal", "AE", "Oslash", "infinity", "plusminus", "lessequal", "greaterequal", "yen", "mu", "partialdiff", "summation", "product", "pi", "integral", "ordfeminine", "ordmasculine", "Omega", "ae", "oslash", "questiondown", "exclamdown", "logicalnot", "radical", "florin", "approxequal", "Delta", "guillemotleft", "guillemotright", "ellipsis", "nonbreakingspace", "Agrave", "Atilde", "Otilde", "OE", "oe", "endash", "emdash", "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide", "lozenge", "ydieresis", "Ydieresis", "fraction", "currency", "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl", "periodcentered", "quotesinglbase", "quotedblbase", "perthousand", "Acircumflex", "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex", "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi", "circumflex", "tilde", "macron", "breve", "dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "Lslash", "lslash", "Scaron", "scaron", "Zcaron", "zcaron", "brokenbar", "Eth", "eth", "Yacute", "yacute", "Thorn", "thorn", "minus", "multiply", "onesuperior", "twosuperior", "threesuperior", "onehalf", "onequarter", "threequarters", "franc", "Gbreve", "gbreve", "Idotaccent", "Scedilla", "scedilla", "Cacute", "cacute", "Ccaron", "ccaron", "dcroat"];
+
+function adjustWidths(properties) {
+  if (!properties.fontMatrix) {
+    return;
+  }
+
+  if (properties.fontMatrix[0] === _util.FONT_IDENTITY_MATRIX[0]) {
+    return;
+  }
+
+  var scale = 0.001 / properties.fontMatrix[0];
+  var glyphsWidths = properties.widths;
+
+  for (var glyph in glyphsWidths) {
+    glyphsWidths[glyph] *= scale;
+  }
+
+  properties.defaultWidth *= scale;
+}
+
+function adjustToUnicode(properties, builtInEncoding) {
+  if (properties.hasIncludedToUnicodeMap) {
+    return;
+  }
+
+  if (properties.hasEncoding) {
+    return;
+  }
+
+  if (builtInEncoding === properties.defaultEncoding) {
+    return;
+  }
+
+  if (properties.toUnicode instanceof IdentityToUnicodeMap) {
+    return;
+  }
+
+  var toUnicode = [],
+      glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+
+  for (var charCode in builtInEncoding) {
+    var glyphName = builtInEncoding[charCode];
+    var unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+
+    if (unicode !== -1) {
+      toUnicode[charCode] = String.fromCharCode(unicode);
+    }
+  }
+
+  properties.toUnicode.amend(toUnicode);
+}
+
+function getFontType(type, subtype) {
+  switch (type) {
+    case "Type1":
+      return subtype === "Type1C" ? _util.FontType.TYPE1C : _util.FontType.TYPE1;
+
+    case "CIDFontType0":
+      return subtype === "CIDFontType0C" ? _util.FontType.CIDFONTTYPE0C : _util.FontType.CIDFONTTYPE0;
+
+    case "OpenType":
+      return _util.FontType.OPENTYPE;
+
+    case "TrueType":
+      return _util.FontType.TRUETYPE;
+
+    case "CIDFontType2":
+      return _util.FontType.CIDFONTTYPE2;
+
+    case "MMType1":
+      return _util.FontType.MMTYPE1;
+
+    case "Type0":
+      return _util.FontType.TYPE0;
+
+    default:
+      return _util.FontType.UNKNOWN;
+  }
+}
+
+function recoverGlyphName(name, glyphsUnicodeMap) {
+  if (glyphsUnicodeMap[name] !== undefined) {
+    return name;
+  }
+
+  var unicode = (0, _unicode.getUnicodeForGlyph)(name, glyphsUnicodeMap);
+
+  if (unicode !== -1) {
+    for (var key in glyphsUnicodeMap) {
+      if (glyphsUnicodeMap[key] === unicode) {
+        return key;
+      }
+    }
+  }
+
+  (0, _util.info)("Unable to recover a standard glyph name for: " + name);
+  return name;
+}
+
+var Glyph = function GlyphClosure() {
+  function Glyph(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont) {
+    this.fontChar = fontChar;
+    this.unicode = unicode;
+    this.accent = accent;
+    this.width = width;
+    this.vmetric = vmetric;
+    this.operatorListId = operatorListId;
+    this.isSpace = isSpace;
+    this.isInFont = isInFont;
+  }
+
+  Glyph.prototype.matchesForCache = function (fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont) {
+    return this.fontChar === fontChar && this.unicode === unicode && this.accent === accent && this.width === width && this.vmetric === vmetric && this.operatorListId === operatorListId && this.isSpace === isSpace && this.isInFont === isInFont;
+  };
+
+  return Glyph;
+}();
+
+var ToUnicodeMap = function ToUnicodeMapClosure() {
+  function ToUnicodeMap(cmap = []) {
+    this._map = cmap;
+  }
+
+  ToUnicodeMap.prototype = {
+    get length() {
+      return this._map.length;
+    },
+
+    forEach(callback) {
+      for (var charCode in this._map) {
+        callback(charCode, this._map[charCode].charCodeAt(0));
+      }
+    },
+
+    has(i) {
+      return this._map[i] !== undefined;
+    },
+
+    get(i) {
+      return this._map[i];
+    },
+
+    charCodeOf(value) {
+      const map = this._map;
+
+      if (map.length <= 0x10000) {
+        return map.indexOf(value);
+      }
+
+      for (const charCode in map) {
+        if (map[charCode] === value) {
+          return charCode | 0;
+        }
+      }
+
+      return -1;
+    },
+
+    amend(map) {
+      for (var charCode in map) {
+        this._map[charCode] = map[charCode];
+      }
+    }
+
+  };
+  return ToUnicodeMap;
+}();
+
+exports.ToUnicodeMap = ToUnicodeMap;
+
+var IdentityToUnicodeMap = function IdentityToUnicodeMapClosure() {
+  function IdentityToUnicodeMap(firstChar, lastChar) {
+    this.firstChar = firstChar;
+    this.lastChar = lastChar;
+  }
+
+  IdentityToUnicodeMap.prototype = {
+    get length() {
+      return this.lastChar + 1 - this.firstChar;
+    },
+
+    forEach(callback) {
+      for (var i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
+        callback(i, i);
+      }
+    },
+
+    has(i) {
+      return this.firstChar <= i && i <= this.lastChar;
+    },
+
+    get(i) {
+      if (this.firstChar <= i && i <= this.lastChar) {
+        return String.fromCharCode(i);
+      }
+
+      return undefined;
+    },
+
+    charCodeOf(v) {
+      return Number.isInteger(v) && v >= this.firstChar && v <= this.lastChar ? v : -1;
+    },
+
+    amend(map) {
+      (0, _util.unreachable)("Should not call amend()");
+    }
+
+  };
+  return IdentityToUnicodeMap;
+}();
+
+exports.IdentityToUnicodeMap = IdentityToUnicodeMap;
+
+var OpenTypeFileBuilder = function OpenTypeFileBuilderClosure() {
+  function writeInt16(dest, offset, num) {
+    dest[offset] = num >> 8 & 0xff;
+    dest[offset + 1] = num & 0xff;
+  }
+
+  function writeInt32(dest, offset, num) {
+    dest[offset] = num >> 24 & 0xff;
+    dest[offset + 1] = num >> 16 & 0xff;
+    dest[offset + 2] = num >> 8 & 0xff;
+    dest[offset + 3] = num & 0xff;
+  }
+
+  function writeData(dest, offset, data) {
+    var i, ii;
+
+    if (data instanceof Uint8Array) {
+      dest.set(data, offset);
+    } else if (typeof data === "string") {
+      for (i = 0, ii = data.length; i < ii; i++) {
+        dest[offset++] = data.charCodeAt(i) & 0xff;
+      }
+    } else {
+      for (i = 0, ii = data.length; i < ii; i++) {
+        dest[offset++] = data[i] & 0xff;
+      }
+    }
+  }
+
+  function OpenTypeFileBuilder(sfnt) {
+    this.sfnt = sfnt;
+    this.tables = Object.create(null);
+  }
+
+  OpenTypeFileBuilder.getSearchParams = function OpenTypeFileBuilder_getSearchParams(entriesCount, entrySize) {
+    var maxPower2 = 1,
+        log2 = 0;
+
+    while ((maxPower2 ^ entriesCount) > maxPower2) {
+      maxPower2 <<= 1;
+      log2++;
+    }
+
+    var searchRange = maxPower2 * entrySize;
+    return {
+      range: searchRange,
+      entry: log2,
+      rangeShift: entrySize * entriesCount - searchRange
+    };
+  };
+
+  var OTF_HEADER_SIZE = 12;
+  var OTF_TABLE_ENTRY_SIZE = 16;
+  OpenTypeFileBuilder.prototype = {
+    toArray: function OpenTypeFileBuilder_toArray() {
+      var sfnt = this.sfnt;
+      var tables = this.tables;
+      var tablesNames = Object.keys(tables);
+      tablesNames.sort();
+      var numTables = tablesNames.length;
+      var i, j, jj, table, tableName;
+      var offset = OTF_HEADER_SIZE + numTables * OTF_TABLE_ENTRY_SIZE;
+      var tableOffsets = [offset];
+
+      for (i = 0; i < numTables; i++) {
+        table = tables[tablesNames[i]];
+        var paddedLength = (table.length + 3 & ~3) >>> 0;
+        offset += paddedLength;
+        tableOffsets.push(offset);
+      }
+
+      var file = new Uint8Array(offset);
+
+      for (i = 0; i < numTables; i++) {
+        table = tables[tablesNames[i]];
+        writeData(file, tableOffsets[i], table);
+      }
+
+      if (sfnt === "true") {
+        sfnt = (0, _util.string32)(0x00010000);
+      }
+
+      file[0] = sfnt.charCodeAt(0) & 0xff;
+      file[1] = sfnt.charCodeAt(1) & 0xff;
+      file[2] = sfnt.charCodeAt(2) & 0xff;
+      file[3] = sfnt.charCodeAt(3) & 0xff;
+      writeInt16(file, 4, numTables);
+      var searchParams = OpenTypeFileBuilder.getSearchParams(numTables, 16);
+      writeInt16(file, 6, searchParams.range);
+      writeInt16(file, 8, searchParams.entry);
+      writeInt16(file, 10, searchParams.rangeShift);
+      offset = OTF_HEADER_SIZE;
+
+      for (i = 0; i < numTables; i++) {
+        tableName = tablesNames[i];
+        file[offset] = tableName.charCodeAt(0) & 0xff;
+        file[offset + 1] = tableName.charCodeAt(1) & 0xff;
+        file[offset + 2] = tableName.charCodeAt(2) & 0xff;
+        file[offset + 3] = tableName.charCodeAt(3) & 0xff;
+        var checksum = 0;
+
+        for (j = tableOffsets[i], jj = tableOffsets[i + 1]; j < jj; j += 4) {
+          var quad = (0, _core_utils.readUint32)(file, j);
+          checksum = checksum + quad >>> 0;
+        }
+
+        writeInt32(file, offset + 4, checksum);
+        writeInt32(file, offset + 8, tableOffsets[i]);
+        writeInt32(file, offset + 12, tables[tableName].length);
+        offset += OTF_TABLE_ENTRY_SIZE;
+      }
+
+      return file;
+    },
+    addTable: function OpenTypeFileBuilder_addTable(tag, data) {
+      if (tag in this.tables) {
+        throw new Error("Table " + tag + " already exists");
+      }
+
+      this.tables[tag] = data;
+    }
+  };
+  return OpenTypeFileBuilder;
+}();
+
+var Font = function FontClosure() {
+  function Font(name, file, properties) {
+    var charCode;
+    this.name = name;
+    this.loadedName = properties.loadedName;
+    this.isType3Font = properties.isType3Font;
+    this.missingFile = false;
+    this.glyphCache = Object.create(null);
+    this.isSerifFont = !!(properties.flags & FontFlags.Serif);
+    this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
+    this.isMonospace = !!(properties.flags & FontFlags.FixedPitch);
+    var type = properties.type;
+    var subtype = properties.subtype;
+    this.type = type;
+    this.subtype = subtype;
+    let fallbackName = "sans-serif";
+
+    if (this.isMonospace) {
+      fallbackName = "monospace";
+    } else if (this.isSerifFont) {
+      fallbackName = "serif";
+    }
+
+    this.fallbackName = fallbackName;
+    this.differences = properties.differences;
+    this.widths = properties.widths;
+    this.defaultWidth = properties.defaultWidth;
+    this.composite = properties.composite;
+    this.cMap = properties.cMap;
+    this.capHeight = properties.capHeight / PDF_GLYPH_SPACE_UNITS;
+    this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS;
+    this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS;
+    this.fontMatrix = properties.fontMatrix;
+    this.bbox = properties.bbox;
+    this.defaultEncoding = properties.defaultEncoding;
+    this.toUnicode = properties.toUnicode;
+    this.fallbackToUnicode = properties.fallbackToUnicode || new ToUnicodeMap();
+    this.toFontChar = [];
+
+    if (properties.type === "Type3") {
+      for (charCode = 0; charCode < 256; charCode++) {
+        this.toFontChar[charCode] = this.differences[charCode] || properties.defaultEncoding[charCode];
+      }
+
+      this.fontType = _util.FontType.TYPE3;
+      return;
+    }
+
+    this.cidEncoding = properties.cidEncoding;
+    this.vertical = !!properties.vertical;
+
+    if (this.vertical) {
+      this.vmetrics = properties.vmetrics;
+      this.defaultVMetrics = properties.defaultVMetrics;
+    }
+
+    if (!file || file.isEmpty) {
+      if (file) {
+        (0, _util.warn)('Font file is empty in "' + name + '" (' + this.loadedName + ")");
+      }
+
+      this.fallbackToSystemFont(properties);
+      return;
+    }
+
+    [type, subtype] = getFontFileType(file, properties);
+
+    if (type !== this.type || subtype !== this.subtype) {
+      (0, _util.info)("Inconsistent font file Type/SubType, expected: " + `${this.type}/${this.subtype} but found: ${type}/${subtype}.`);
+    }
+
+    try {
+      var data;
+
+      switch (type) {
+        case "MMType1":
+          (0, _util.info)("MMType1 font (" + name + "), falling back to Type1.");
+
+        case "Type1":
+        case "CIDFontType0":
+          this.mimetype = "font/opentype";
+          var cff = subtype === "Type1C" || subtype === "CIDFontType0C" ? new CFFFont(file, properties) : new Type1Font(name, file, properties);
+          adjustWidths(properties);
+          data = this.convert(name, cff, properties);
+          break;
+
+        case "OpenType":
+        case "TrueType":
+        case "CIDFontType2":
+          this.mimetype = "font/opentype";
+          data = this.checkAndRepair(name, file, properties);
+
+          if (this.isOpenType) {
+            adjustWidths(properties);
+            type = "OpenType";
+          }
+
+          break;
+
+        default:
+          throw new _util.FormatError(`Font ${type} is not supported`);
+      }
+    } catch (e) {
+      (0, _util.warn)(e);
+      this.fallbackToSystemFont(properties);
+      return;
+    }
+
+    this.data = data;
+    this.fontType = getFontType(type, subtype);
+    this.fontMatrix = properties.fontMatrix;
+    this.widths = properties.widths;
+    this.defaultWidth = properties.defaultWidth;
+    this.toUnicode = properties.toUnicode;
+    this.seacMap = properties.seacMap;
+  }
+
+  function int16(b0, b1) {
+    return (b0 << 8) + b1;
+  }
+
+  function writeSignedInt16(bytes, index, value) {
+    bytes[index + 1] = value;
+    bytes[index] = value >>> 8;
+  }
+
+  function signedInt16(b0, b1) {
+    var value = (b0 << 8) + b1;
+    return value & 1 << 15 ? value - 0x10000 : value;
+  }
+
+  function int32(b0, b1, b2, b3) {
+    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+  }
+
+  function string16(value) {
+    return String.fromCharCode(value >> 8 & 0xff, value & 0xff);
+  }
+
+  function safeString16(value) {
+    if (value > 0x7fff) {
+      value = 0x7fff;
+    } else if (value < -0x8000) {
+      value = -0x8000;
+    }
+
+    return String.fromCharCode(value >> 8 & 0xff, value & 0xff);
+  }
+
+  function isTrueTypeFile(file) {
+    var header = file.peekBytes(4);
+    return (0, _core_utils.readUint32)(header, 0) === 0x00010000 || (0, _util.bytesToString)(header) === "true";
+  }
+
+  function isTrueTypeCollectionFile(file) {
+    const header = file.peekBytes(4);
+    return (0, _util.bytesToString)(header) === "ttcf";
+  }
+
+  function isOpenTypeFile(file) {
+    var header = file.peekBytes(4);
+    return (0, _util.bytesToString)(header) === "OTTO";
+  }
+
+  function isType1File(file) {
+    var header = file.peekBytes(2);
+
+    if (header[0] === 0x25 && header[1] === 0x21) {
+      return true;
+    }
+
+    if (header[0] === 0x80 && header[1] === 0x01) {
+      return true;
+    }
+
+    return false;
+  }
+
+  function isCFFFile(file) {
+    const header = file.peekBytes(4);
+
+    if (header[0] >= 1 && header[3] >= 1 && header[3] <= 4) {
+      return true;
+    }
+
+    return false;
+  }
+
+  function getFontFileType(file, {
+    type,
+    subtype,
+    composite
+  }) {
+    let fileType, fileSubtype;
+
+    if (isTrueTypeFile(file) || isTrueTypeCollectionFile(file)) {
+      if (composite) {
+        fileType = "CIDFontType2";
+      } else {
+        fileType = "TrueType";
+      }
+    } else if (isOpenTypeFile(file)) {
+      if (composite) {
+        fileType = "CIDFontType2";
+      } else {
+        fileType = "OpenType";
+      }
+    } else if (isType1File(file)) {
+      if (composite) {
+        fileType = "CIDFontType0";
+      } else {
+        fileType = type === "MMType1" ? "MMType1" : "Type1";
+      }
+    } else if (isCFFFile(file)) {
+      if (composite) {
+        fileType = "CIDFontType0";
+        fileSubtype = "CIDFontType0C";
+      } else {
+        fileType = type === "MMType1" ? "MMType1" : "Type1";
+        fileSubtype = "Type1C";
+      }
+    } else {
+      (0, _util.warn)("getFontFileType: Unable to detect correct font file Type/Subtype.");
+      fileType = type;
+      fileSubtype = subtype;
+    }
+
+    return [fileType, fileSubtype];
+  }
+
+  function buildToFontChar(encoding, glyphsUnicodeMap, differences) {
+    var toFontChar = [],
+        unicode;
+
+    for (var i = 0, ii = encoding.length; i < ii; i++) {
+      unicode = (0, _unicode.getUnicodeForGlyph)(encoding[i], glyphsUnicodeMap);
+
+      if (unicode !== -1) {
+        toFontChar[i] = unicode;
+      }
+    }
+
+    for (var charCode in differences) {
+      unicode = (0, _unicode.getUnicodeForGlyph)(differences[charCode], glyphsUnicodeMap);
+
+      if (unicode !== -1) {
+        toFontChar[+charCode] = unicode;
+      }
+    }
+
+    return toFontChar;
+  }
+
+  function adjustMapping(charCodeToGlyphId, hasGlyph, newGlyphZeroId) {
+    var newMap = Object.create(null);
+    var toFontChar = [];
+    var privateUseAreaIndex = 0;
+    var nextAvailableFontCharCode = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
+    var privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
+
+    for (var originalCharCode in charCodeToGlyphId) {
+      originalCharCode |= 0;
+      var glyphId = charCodeToGlyphId[originalCharCode];
+
+      if (!hasGlyph(glyphId)) {
+        continue;
+      }
+
+      if (nextAvailableFontCharCode > privateUseOffetEnd) {
+        privateUseAreaIndex++;
+
+        if (privateUseAreaIndex >= PRIVATE_USE_AREAS.length) {
+          (0, _util.warn)("Ran out of space in font private use area.");
+          break;
+        }
+
+        nextAvailableFontCharCode = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
+        privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
+      }
+
+      var fontCharCode = nextAvailableFontCharCode++;
+
+      if (glyphId === 0) {
+        glyphId = newGlyphZeroId;
+      }
+
+      newMap[fontCharCode] = glyphId;
+      toFontChar[originalCharCode] = fontCharCode;
+    }
+
+    return {
+      toFontChar,
+      charCodeToGlyphId: newMap,
+      nextAvailableFontCharCode
+    };
+  }
+
+  function getRanges(glyphs, numGlyphs) {
+    var codes = [];
+
+    for (var charCode in glyphs) {
+      if (glyphs[charCode] >= numGlyphs) {
+        continue;
+      }
+
+      codes.push({
+        fontCharCode: charCode | 0,
+        glyphId: glyphs[charCode]
+      });
+    }
+
+    if (codes.length === 0) {
+      codes.push({
+        fontCharCode: 0,
+        glyphId: 0
+      });
+    }
+
+    codes.sort(function fontGetRangesSort(a, b) {
+      return a.fontCharCode - b.fontCharCode;
+    });
+    var ranges = [];
+    var length = codes.length;
+
+    for (var n = 0; n < length;) {
+      var start = codes[n].fontCharCode;
+      var codeIndices = [codes[n].glyphId];
+      ++n;
+      var end = start;
+
+      while (n < length && end + 1 === codes[n].fontCharCode) {
+        codeIndices.push(codes[n].glyphId);
+        ++end;
+        ++n;
+
+        if (end === 0xffff) {
+          break;
+        }
+      }
+
+      ranges.push([start, end, codeIndices]);
+    }
+
+    return ranges;
+  }
+
+  function createCmapTable(glyphs, numGlyphs) {
+    var ranges = getRanges(glyphs, numGlyphs);
+    var numTables = ranges[ranges.length - 1][1] > 0xffff ? 2 : 1;
+    var cmap = "\x00\x00" + string16(numTables) + "\x00\x03" + "\x00\x01" + (0, _util.string32)(4 + numTables * 8);
+    var i, ii, j, jj;
+
+    for (i = ranges.length - 1; i >= 0; --i) {
+      if (ranges[i][0] <= 0xffff) {
+        break;
+      }
+    }
+
+    var bmpLength = i + 1;
+
+    if (ranges[i][0] < 0xffff && ranges[i][1] === 0xffff) {
+      ranges[i][1] = 0xfffe;
+    }
+
+    var trailingRangesCount = ranges[i][1] < 0xffff ? 1 : 0;
+    var segCount = bmpLength + trailingRangesCount;
+    var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2);
+    var startCount = "";
+    var endCount = "";
+    var idDeltas = "";
+    var idRangeOffsets = "";
+    var glyphsIds = "";
+    var bias = 0;
+    var range, start, end, codes;
+
+    for (i = 0, ii = bmpLength; i < ii; i++) {
+      range = ranges[i];
+      start = range[0];
+      end = range[1];
+      startCount += string16(start);
+      endCount += string16(end);
+      codes = range[2];
+      var contiguous = true;
+
+      for (j = 1, jj = codes.length; j < jj; ++j) {
+        if (codes[j] !== codes[j - 1] + 1) {
+          contiguous = false;
+          break;
+        }
+      }
+
+      if (!contiguous) {
+        var offset = (segCount - i) * 2 + bias * 2;
+        bias += end - start + 1;
+        idDeltas += string16(0);
+        idRangeOffsets += string16(offset);
+
+        for (j = 0, jj = codes.length; j < jj; ++j) {
+          glyphsIds += string16(codes[j]);
+        }
+      } else {
+        var startCode = codes[0];
+        idDeltas += string16(startCode - start & 0xffff);
+        idRangeOffsets += string16(0);
+      }
+    }
+
+    if (trailingRangesCount > 0) {
+      endCount += "\xFF\xFF";
+      startCount += "\xFF\xFF";
+      idDeltas += "\x00\x01";
+      idRangeOffsets += "\x00\x00";
+    }
+
+    var format314 = "\x00\x00" + string16(2 * segCount) + string16(searchParams.range) + string16(searchParams.entry) + string16(searchParams.rangeShift) + endCount + "\x00\x00" + startCount + idDeltas + idRangeOffsets + glyphsIds;
+    var format31012 = "";
+    var header31012 = "";
+
+    if (numTables > 1) {
+      cmap += "\x00\x03" + "\x00\x0A" + (0, _util.string32)(4 + numTables * 8 + 4 + format314.length);
+      format31012 = "";
+
+      for (i = 0, ii = ranges.length; i < ii; i++) {
+        range = ranges[i];
+        start = range[0];
+        codes = range[2];
+        var code = codes[0];
+
+        for (j = 1, jj = codes.length; j < jj; ++j) {
+          if (codes[j] !== codes[j - 1] + 1) {
+            end = range[0] + j - 1;
+            format31012 += (0, _util.string32)(start) + (0, _util.string32)(end) + (0, _util.string32)(code);
+            start = end + 1;
+            code = codes[j];
+          }
+        }
+
+        format31012 += (0, _util.string32)(start) + (0, _util.string32)(range[1]) + (0, _util.string32)(code);
+      }
+
+      header31012 = "\x00\x0C" + "\x00\x00" + (0, _util.string32)(format31012.length + 16) + "\x00\x00\x00\x00" + (0, _util.string32)(format31012.length / 12);
+    }
+
+    return cmap + "\x00\x04" + string16(format314.length + 4) + format314 + header31012 + format31012;
+  }
+
+  function validateOS2Table(os2, file) {
+    file.pos = (file.start || 0) + os2.offset;
+    var version = file.getUint16();
+    file.skip(60);
+    var selection = file.getUint16();
+
+    if (version < 4 && selection & 0x0300) {
+      return false;
+    }
+
+    var firstChar = file.getUint16();
+    var lastChar = file.getUint16();
+
+    if (firstChar > lastChar) {
+      return false;
+    }
+
+    file.skip(6);
+    var usWinAscent = file.getUint16();
+
+    if (usWinAscent === 0) {
+      return false;
+    }
+
+    os2.data[8] = os2.data[9] = 0;
+    return true;
+  }
+
+  function createOS2Table(properties, charstrings, override) {
+    override = override || {
+      unitsPerEm: 0,
+      yMax: 0,
+      yMin: 0,
+      ascent: 0,
+      descent: 0
+    };
+    var ulUnicodeRange1 = 0;
+    var ulUnicodeRange2 = 0;
+    var ulUnicodeRange3 = 0;
+    var ulUnicodeRange4 = 0;
+    var firstCharIndex = null;
+    var lastCharIndex = 0;
+
+    if (charstrings) {
+      for (var code in charstrings) {
+        code |= 0;
+
+        if (firstCharIndex > code || !firstCharIndex) {
+          firstCharIndex = code;
+        }
+
+        if (lastCharIndex < code) {
+          lastCharIndex = code;
+        }
+
+        var position = (0, _unicode.getUnicodeRangeFor)(code);
+
+        if (position < 32) {
+          ulUnicodeRange1 |= 1 << position;
+        } else if (position < 64) {
+          ulUnicodeRange2 |= 1 << position - 32;
+        } else if (position < 96) {
+          ulUnicodeRange3 |= 1 << position - 64;
+        } else if (position < 123) {
+          ulUnicodeRange4 |= 1 << position - 96;
+        } else {
+          throw new _util.FormatError("Unicode ranges Bits > 123 are reserved for internal usage");
+        }
+      }
+
+      if (lastCharIndex > 0xffff) {
+        lastCharIndex = 0xffff;
+      }
+    } else {
+      firstCharIndex = 0;
+      lastCharIndex = 255;
+    }
+
+    var bbox = properties.bbox || [0, 0, 0, 0];
+    var unitsPerEm = override.unitsPerEm || 1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
+    var scale = properties.ascentScaled ? 1.0 : unitsPerEm / PDF_GLYPH_SPACE_UNITS;
+    var typoAscent = override.ascent || Math.round(scale * (properties.ascent || bbox[3]));
+    var typoDescent = override.descent || Math.round(scale * (properties.descent || bbox[1]));
+
+    if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) {
+      typoDescent = -typoDescent;
+    }
+
+    var winAscent = override.yMax || typoAscent;
+    var winDescent = -override.yMin || -typoDescent;
+    return "\x00\x03" + "\x02\x24" + "\x01\xF4" + "\x00\x05" + "\x00\x00" + "\x02\x8A" + "\x02\xBB" + "\x00\x00" + "\x00\x8C" + "\x02\x8A" + "\x02\xBB" + "\x00\x00" + "\x01\xDF" + "\x00\x31" + "\x01\x02" + "\x00\x00" + "\x00\x00\x06" + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + "\x00\x00\x00\x00\x00\x00" + (0, _util.string32)(ulUnicodeRange1) + (0, _util.string32)(ulUnicodeRange2) + (0, _util.string32)(ulUnicodeRange3) + (0, _util.string32)(ulUnicodeRange4) + "\x2A\x32\x31\x2A" + string16(properties.italicAngle ? 1 : 0) + string16(firstCharIndex || properties.firstChar) + string16(lastCharIndex || properties.lastChar) + string16(typoAscent) + string16(typoDescent) + "\x00\x64" + string16(winAscent) + string16(winDescent) + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + string16(properties.xHeight) + string16(properties.capHeight) + string16(0) + string16(firstCharIndex || properties.firstChar) + "\x00\x03";
+  }
+
+  function createPostTable(properties) {
+    var angle = Math.floor(properties.italicAngle * 2 ** 16);
+    return "\x00\x03\x00\x00" + (0, _util.string32)(angle) + "\x00\x00" + "\x00\x00" + (0, _util.string32)(properties.fixedPitch) + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + "\x00\x00\x00\x00";
+  }
+
+  function createNameTable(name, proto) {
+    if (!proto) {
+      proto = [[], []];
+    }
+
+    var strings = [proto[0][0] || "Original licence", proto[0][1] || name, proto[0][2] || "Unknown", proto[0][3] || "uniqueID", proto[0][4] || name, proto[0][5] || "Version 0.11", proto[0][6] || "", proto[0][7] || "Unknown", proto[0][8] || "Unknown", proto[0][9] || "Unknown"];
+    var stringsUnicode = [];
+    var i, ii, j, jj, str;
+
+    for (i = 0, ii = strings.length; i < ii; i++) {
+      str = proto[1][i] || strings[i];
+      var strBufUnicode = [];
+
+      for (j = 0, jj = str.length; j < jj; j++) {
+        strBufUnicode.push(string16(str.charCodeAt(j)));
+      }
+
+      stringsUnicode.push(strBufUnicode.join(""));
+    }
+
+    var names = [strings, stringsUnicode];
+    var platforms = ["\x00\x01", "\x00\x03"];
+    var encodings = ["\x00\x00", "\x00\x01"];
+    var languages = ["\x00\x00", "\x04\x09"];
+    var namesRecordCount = strings.length * platforms.length;
+    var nameTable = "\x00\x00" + string16(namesRecordCount) + string16(namesRecordCount * 12 + 6);
+    var strOffset = 0;
+
+    for (i = 0, ii = platforms.length; i < ii; i++) {
+      var strs = names[i];
+
+      for (j = 0, jj = strs.length; j < jj; j++) {
+        str = strs[j];
+        var nameRecord = platforms[i] + encodings[i] + languages[i] + string16(j) + string16(str.length) + string16(strOffset);
+        nameTable += nameRecord;
+        strOffset += str.length;
+      }
+    }
+
+    nameTable += strings.join("") + stringsUnicode.join("");
+    return nameTable;
+  }
+
+  Font.prototype = {
+    name: null,
+    font: null,
+    mimetype: null,
+    disableFontFace: false,
+
+    get renderer() {
+      var renderer = _font_renderer.FontRendererFactory.create(this, SEAC_ANALYSIS_ENABLED);
+
+      return (0, _util.shadow)(this, "renderer", renderer);
+    },
+
+    exportData(extraProperties = false) {
+      const exportDataProperties = extraProperties ? [...EXPORT_DATA_PROPERTIES, ...EXPORT_DATA_EXTRA_PROPERTIES] : EXPORT_DATA_PROPERTIES;
+      const data = Object.create(null);
+      let property, value;
+
+      for (property of exportDataProperties) {
+        value = this[property];
+
+        if (value !== undefined) {
+          data[property] = value;
+        }
+      }
+
+      return data;
+    },
+
+    fallbackToSystemFont(properties) {
+      this.missingFile = true;
+      var name = this.name;
+      var type = this.type;
+      var subtype = this.subtype;
+      let fontName = name.replace(/[,_]/g, "-").replace(/\s/g, "");
+      var stdFontMap = (0, _standard_fonts.getStdFontMap)(),
+          nonStdFontMap = (0, _standard_fonts.getNonStdFontMap)();
+      const isStandardFont = !!stdFontMap[fontName];
+      const isMappedToStandardFont = !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]);
+      fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;
+      this.bold = fontName.search(/bold/gi) !== -1;
+      this.italic = fontName.search(/oblique/gi) !== -1 || fontName.search(/italic/gi) !== -1;
+      this.black = name.search(/Black/g) !== -1;
+      this.remeasure = !isStandardFont && Object.keys(this.widths).length > 0;
+
+      if ((isStandardFont || isMappedToStandardFont) && type === "CIDFontType2" && this.cidEncoding.startsWith("Identity-")) {
+        const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)(),
+              cidToGidMap = properties.cidToGidMap;
+        const map = [];
+
+        for (const charCode in GlyphMapForStandardFonts) {
+          map[+charCode] = GlyphMapForStandardFonts[charCode];
+        }
+
+        if (/Arial-?Black/i.test(name)) {
+          var SupplementalGlyphMapForArialBlack = (0, _standard_fonts.getSupplementalGlyphMapForArialBlack)();
+
+          for (const charCode in SupplementalGlyphMapForArialBlack) {
+            map[+charCode] = SupplementalGlyphMapForArialBlack[charCode];
+          }
+        } else if (/Calibri/i.test(name)) {
+          const SupplementalGlyphMapForCalibri = (0, _standard_fonts.getSupplementalGlyphMapForCalibri)();
+
+          for (const charCode in SupplementalGlyphMapForCalibri) {
+            map[+charCode] = SupplementalGlyphMapForCalibri[charCode];
+          }
+        }
+
+        if (cidToGidMap) {
+          for (const charCode in map) {
+            const cid = map[charCode];
+
+            if (cidToGidMap[cid] !== undefined) {
+              map[+charCode] = cidToGidMap[cid];
+            }
+          }
+        }
+
+        var isIdentityUnicode = this.toUnicode instanceof IdentityToUnicodeMap;
+
+        if (!isIdentityUnicode) {
+          this.toUnicode.forEach(function (charCode, unicodeCharCode) {
+            map[+charCode] = unicodeCharCode;
+          });
+        }
+
+        this.toFontChar = map;
+        this.toUnicode = new ToUnicodeMap(map);
+      } else if (/Symbol/i.test(fontName)) {
+        this.toFontChar = buildToFontChar(_encodings.SymbolSetEncoding, (0, _glyphlist.getGlyphsUnicode)(), this.differences);
+      } else if (/Dingbats/i.test(fontName)) {
+        if (/Wingdings/i.test(name)) {
+          (0, _util.warn)("Non-embedded Wingdings font, falling back to ZapfDingbats.");
+        }
+
+        this.toFontChar = buildToFontChar(_encodings.ZapfDingbatsEncoding, (0, _glyphlist.getDingbatsGlyphsUnicode)(), this.differences);
+      } else if (isStandardFont) {
+        this.toFontChar = buildToFontChar(this.defaultEncoding, (0, _glyphlist.getGlyphsUnicode)(), this.differences);
+      } else {
+        const glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+        const map = [];
+        this.toUnicode.forEach((charCode, unicodeCharCode) => {
+          if (!this.composite) {
+            var glyphName = this.differences[charCode] || this.defaultEncoding[charCode];
+            const unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+
+            if (unicode !== -1) {
+              unicodeCharCode = unicode;
+            }
+          }
+
+          map[+charCode] = unicodeCharCode;
+        });
+
+        if (this.composite && this.toUnicode instanceof IdentityToUnicodeMap) {
+          if (/Verdana/i.test(name)) {
+            const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)();
+
+            for (const charCode in GlyphMapForStandardFonts) {
+              map[+charCode] = GlyphMapForStandardFonts[charCode];
+            }
+          }
+        }
+
+        this.toFontChar = map;
+      }
+
+      this.loadedName = fontName.split("-")[0];
+      this.fontType = getFontType(type, subtype);
+    },
+
+    checkAndRepair: function Font_checkAndRepair(name, font, properties) {
+      const VALID_TABLES = ["OS/2", "cmap", "head", "hhea", "hmtx", "maxp", "name", "post", "loca", "glyf", "fpgm", "prep", "cvt ", "CFF "];
+
+      function readTables(file, numTables) {
+        const tables = Object.create(null);
+        tables["OS/2"] = null;
+        tables.cmap = null;
+        tables.head = null;
+        tables.hhea = null;
+        tables.hmtx = null;
+        tables.maxp = null;
+        tables.name = null;
+        tables.post = null;
+
+        for (let i = 0; i < numTables; i++) {
+          const table = readTableEntry(file);
+
+          if (!VALID_TABLES.includes(table.tag)) {
+            continue;
+          }
+
+          if (table.length === 0) {
+            continue;
+          }
+
+          tables[table.tag] = table;
+        }
+
+        return tables;
+      }
+
+      function readTableEntry(file) {
+        var tag = (0, _util.bytesToString)(file.getBytes(4));
+        var checksum = file.getInt32() >>> 0;
+        var offset = file.getInt32() >>> 0;
+        var length = file.getInt32() >>> 0;
+        var previousPosition = file.pos;
+        file.pos = file.start ? file.start : 0;
+        file.skip(offset);
+        var data = file.getBytes(length);
+        file.pos = previousPosition;
+
+        if (tag === "head") {
+          data[8] = data[9] = data[10] = data[11] = 0;
+          data[17] |= 0x20;
+        }
+
+        return {
+          tag,
+          checksum,
+          length,
+          offset,
+          data
+        };
+      }
+
+      function readOpenTypeHeader(ttf) {
+        return {
+          version: (0, _util.bytesToString)(ttf.getBytes(4)),
+          numTables: ttf.getUint16(),
+          searchRange: ttf.getUint16(),
+          entrySelector: ttf.getUint16(),
+          rangeShift: ttf.getUint16()
+        };
+      }
+
+      function readTrueTypeCollectionHeader(ttc) {
+        const ttcTag = (0, _util.bytesToString)(ttc.getBytes(4));
+        (0, _util.assert)(ttcTag === "ttcf", "Must be a TrueType Collection font.");
+        const majorVersion = ttc.getUint16();
+        const minorVersion = ttc.getUint16();
+        const numFonts = ttc.getInt32() >>> 0;
+        const offsetTable = [];
+
+        for (let i = 0; i < numFonts; i++) {
+          offsetTable.push(ttc.getInt32() >>> 0);
+        }
+
+        const header = {
+          ttcTag,
+          majorVersion,
+          minorVersion,
+          numFonts,
+          offsetTable
+        };
+
+        switch (majorVersion) {
+          case 1:
+            return header;
+
+          case 2:
+            header.dsigTag = ttc.getInt32() >>> 0;
+            header.dsigLength = ttc.getInt32() >>> 0;
+            header.dsigOffset = ttc.getInt32() >>> 0;
+            return header;
+        }
+
+        throw new _util.FormatError(`Invalid TrueType Collection majorVersion: ${majorVersion}.`);
+      }
+
+      function readTrueTypeCollectionData(ttc, fontName) {
+        const {
+          numFonts,
+          offsetTable
+        } = readTrueTypeCollectionHeader(ttc);
+
+        for (let i = 0; i < numFonts; i++) {
+          ttc.pos = (ttc.start || 0) + offsetTable[i];
+          const potentialHeader = readOpenTypeHeader(ttc);
+          const potentialTables = readTables(ttc, potentialHeader.numTables);
+
+          if (!potentialTables.name) {
+            throw new _util.FormatError('TrueType Collection font must contain a "name" table.');
+          }
+
+          const nameTable = readNameTable(potentialTables.name);
+
+          for (let j = 0, jj = nameTable.length; j < jj; j++) {
+            for (let k = 0, kk = nameTable[j].length; k < kk; k++) {
+              const nameEntry = nameTable[j][k];
+
+              if (nameEntry && nameEntry.replace(/\s/g, "") === fontName) {
+                return {
+                  header: potentialHeader,
+                  tables: potentialTables
+                };
+              }
+            }
+          }
+        }
+
+        throw new _util.FormatError(`TrueType Collection does not contain "${fontName}" font.`);
+      }
+
+      function readCmapTable(cmap, file, isSymbolicFont, hasEncoding) {
+        if (!cmap) {
+          (0, _util.warn)("No cmap table available.");
+          return {
+            platformId: -1,
+            encodingId: -1,
+            mappings: [],
+            hasShortCmap: false
+          };
+        }
+
+        var segment;
+        var start = (file.start ? file.start : 0) + cmap.offset;
+        file.pos = start;
+        file.skip(2);
+        var numTables = file.getUint16();
+        var potentialTable;
+        var canBreak = false;
+
+        for (var i = 0; i < numTables; i++) {
+          var platformId = file.getUint16();
+          var encodingId = file.getUint16();
+          var offset = file.getInt32() >>> 0;
+          var useTable = false;
+
+          if (potentialTable && potentialTable.platformId === platformId && potentialTable.encodingId === encodingId) {
+            continue;
+          }
+
+          if (platformId === 0 && (encodingId === 0 || encodingId === 1 || encodingId === 3)) {
+            useTable = true;
+          } else if (platformId === 1 && encodingId === 0) {
+            useTable = true;
+          } else if (platformId === 3 && encodingId === 1 && (hasEncoding || !potentialTable)) {
+            useTable = true;
+
+            if (!isSymbolicFont) {
+              canBreak = true;
+            }
+          } else if (isSymbolicFont && platformId === 3 && encodingId === 0) {
+            useTable = true;
+            canBreak = true;
+          }
+
+          if (useTable) {
+            potentialTable = {
+              platformId,
+              encodingId,
+              offset
+            };
+          }
+
+          if (canBreak) {
+            break;
+          }
+        }
+
+        if (potentialTable) {
+          file.pos = start + potentialTable.offset;
+        }
+
+        if (!potentialTable || file.peekByte() === -1) {
+          (0, _util.warn)("Could not find a preferred cmap table.");
+          return {
+            platformId: -1,
+            encodingId: -1,
+            mappings: [],
+            hasShortCmap: false
+          };
+        }
+
+        var format = file.getUint16();
+        file.skip(2 + 2);
+        var hasShortCmap = false;
+        var mappings = [];
+        var j, glyphId;
+
+        if (format === 0) {
+          for (j = 0; j < 256; j++) {
+            var index = file.getByte();
+
+            if (!index) {
+              continue;
+            }
+
+            mappings.push({
+              charCode: j,
+              glyphId: index
+            });
+          }
+
+          hasShortCmap = true;
+        } else if (format === 4) {
+          var segCount = file.getUint16() >> 1;
+          file.skip(6);
+          var segIndex,
+              segments = [];
+
+          for (segIndex = 0; segIndex < segCount; segIndex++) {
+            segments.push({
+              end: file.getUint16()
+            });
+          }
+
+          file.skip(2);
+
+          for (segIndex = 0; segIndex < segCount; segIndex++) {
+            segments[segIndex].start = file.getUint16();
+          }
+
+          for (segIndex = 0; segIndex < segCount; segIndex++) {
+            segments[segIndex].delta = file.getUint16();
+          }
+
+          var offsetsCount = 0;
+
+          for (segIndex = 0; segIndex < segCount; segIndex++) {
+            segment = segments[segIndex];
+            var rangeOffset = file.getUint16();
+
+            if (!rangeOffset) {
+              segment.offsetIndex = -1;
+              continue;
+            }
+
+            var offsetIndex = (rangeOffset >> 1) - (segCount - segIndex);
+            segment.offsetIndex = offsetIndex;
+            offsetsCount = Math.max(offsetsCount, offsetIndex + segment.end - segment.start + 1);
+          }
+
+          var offsets = [];
+
+          for (j = 0; j < offsetsCount; j++) {
+            offsets.push(file.getUint16());
+          }
+
+          for (segIndex = 0; segIndex < segCount; segIndex++) {
+            segment = segments[segIndex];
+            start = segment.start;
+            var end = segment.end;
+            var delta = segment.delta;
+            offsetIndex = segment.offsetIndex;
+
+            for (j = start; j <= end; j++) {
+              if (j === 0xffff) {
+                continue;
+              }
+
+              glyphId = offsetIndex < 0 ? j : offsets[offsetIndex + j - start];
+              glyphId = glyphId + delta & 0xffff;
+              mappings.push({
+                charCode: j,
+                glyphId
+              });
+            }
+          }
+        } else if (format === 6) {
+          var firstCode = file.getUint16();
+          var entryCount = file.getUint16();
+
+          for (j = 0; j < entryCount; j++) {
+            glyphId = file.getUint16();
+            var charCode = firstCode + j;
+            mappings.push({
+              charCode,
+              glyphId
+            });
+          }
+        } else {
+          (0, _util.warn)("cmap table has unsupported format: " + format);
+          return {
+            platformId: -1,
+            encodingId: -1,
+            mappings: [],
+            hasShortCmap: false
+          };
+        }
+
+        mappings.sort(function (a, b) {
+          return a.charCode - b.charCode;
+        });
+
+        for (i = 1; i < mappings.length; i++) {
+          if (mappings[i - 1].charCode === mappings[i].charCode) {
+            mappings.splice(i, 1);
+            i--;
+          }
+        }
+
+        return {
+          platformId: potentialTable.platformId,
+          encodingId: potentialTable.encodingId,
+          mappings,
+          hasShortCmap
+        };
+      }
+
+      function sanitizeMetrics(file, header, metrics, numGlyphs, dupFirstEntry) {
+        if (!header) {
+          if (metrics) {
+            metrics.data = null;
+          }
+
+          return;
+        }
+
+        file.pos = (file.start ? file.start : 0) + header.offset;
+        file.pos += 4;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 2;
+        file.pos += 8;
+        file.pos += 2;
+        var numOfMetrics = file.getUint16();
+
+        if (numOfMetrics > numGlyphs) {
+          (0, _util.info)("The numOfMetrics (" + numOfMetrics + ") should not be " + "greater than the numGlyphs (" + numGlyphs + ")");
+          numOfMetrics = numGlyphs;
+          header.data[34] = (numOfMetrics & 0xff00) >> 8;
+          header.data[35] = numOfMetrics & 0x00ff;
+        }
+
+        var numOfSidebearings = numGlyphs - numOfMetrics;
+        var numMissing = numOfSidebearings - (metrics.length - numOfMetrics * 4 >> 1);
+
+        if (numMissing > 0) {
+          var entries = new Uint8Array(metrics.length + numMissing * 2);
+          entries.set(metrics.data);
+
+          if (dupFirstEntry) {
+            entries[metrics.length] = metrics.data[2];
+            entries[metrics.length + 1] = metrics.data[3];
+          }
+
+          metrics.data = entries;
+        }
+      }
+
+      function sanitizeGlyph(source, sourceStart, sourceEnd, dest, destStart, hintsValid) {
+        var glyphProfile = {
+          length: 0,
+          sizeOfInstructions: 0
+        };
+
+        if (sourceEnd - sourceStart <= 12) {
+          return glyphProfile;
+        }
+
+        var glyf = source.subarray(sourceStart, sourceEnd);
+        var contoursCount = signedInt16(glyf[0], glyf[1]);
+
+        if (contoursCount < 0) {
+          contoursCount = -1;
+          writeSignedInt16(glyf, 0, contoursCount);
+          dest.set(glyf, destStart);
+          glyphProfile.length = glyf.length;
+          return glyphProfile;
+        }
+
+        var i,
+            j = 10,
+            flagsCount = 0;
+
+        for (i = 0; i < contoursCount; i++) {
+          var endPoint = glyf[j] << 8 | glyf[j + 1];
+          flagsCount = endPoint + 1;
+          j += 2;
+        }
+
+        var instructionsStart = j;
+        var instructionsLength = glyf[j] << 8 | glyf[j + 1];
+        glyphProfile.sizeOfInstructions = instructionsLength;
+        j += 2 + instructionsLength;
+        var instructionsEnd = j;
+        var coordinatesLength = 0;
+
+        for (i = 0; i < flagsCount; i++) {
+          var flag = glyf[j++];
+
+          if (flag & 0xc0) {
+            glyf[j - 1] = flag & 0x3f;
+          }
+
+          let xLength = 2;
+
+          if (flag & 2) {
+            xLength = 1;
+          } else if (flag & 16) {
+            xLength = 0;
+          }
+
+          let yLength = 2;
+
+          if (flag & 4) {
+            yLength = 1;
+          } else if (flag & 32) {
+            yLength = 0;
+          }
+
+          const xyLength = xLength + yLength;
+          coordinatesLength += xyLength;
+
+          if (flag & 8) {
+            var repeat = glyf[j++];
+            i += repeat;
+            coordinatesLength += repeat * xyLength;
+          }
+        }
+
+        if (coordinatesLength === 0) {
+          return glyphProfile;
+        }
+
+        var glyphDataLength = j + coordinatesLength;
+
+        if (glyphDataLength > glyf.length) {
+          return glyphProfile;
+        }
+
+        if (!hintsValid && instructionsLength > 0) {
+          dest.set(glyf.subarray(0, instructionsStart), destStart);
+          dest.set([0, 0], destStart + instructionsStart);
+          dest.set(glyf.subarray(instructionsEnd, glyphDataLength), destStart + instructionsStart + 2);
+          glyphDataLength -= instructionsLength;
+
+          if (glyf.length - glyphDataLength > 3) {
+            glyphDataLength = glyphDataLength + 3 & ~3;
+          }
+
+          glyphProfile.length = glyphDataLength;
+          return glyphProfile;
+        }
+
+        if (glyf.length - glyphDataLength > 3) {
+          glyphDataLength = glyphDataLength + 3 & ~3;
+          dest.set(glyf.subarray(0, glyphDataLength), destStart);
+          glyphProfile.length = glyphDataLength;
+          return glyphProfile;
+        }
+
+        dest.set(glyf, destStart);
+        glyphProfile.length = glyf.length;
+        return glyphProfile;
+      }
+
+      function sanitizeHead(head, numGlyphs, locaLength) {
+        var data = head.data;
+        var version = int32(data[0], data[1], data[2], data[3]);
+
+        if (version >> 16 !== 1) {
+          (0, _util.info)("Attempting to fix invalid version in head table: " + version);
+          data[0] = 0;
+          data[1] = 1;
+          data[2] = 0;
+          data[3] = 0;
+        }
+
+        var indexToLocFormat = int16(data[50], data[51]);
+
+        if (indexToLocFormat < 0 || indexToLocFormat > 1) {
+          (0, _util.info)("Attempting to fix invalid indexToLocFormat in head table: " + indexToLocFormat);
+          var numGlyphsPlusOne = numGlyphs + 1;
+
+          if (locaLength === numGlyphsPlusOne << 1) {
+            data[50] = 0;
+            data[51] = 0;
+          } else if (locaLength === numGlyphsPlusOne << 2) {
+            data[50] = 0;
+            data[51] = 1;
+          } else {
+            throw new _util.FormatError("Could not fix indexToLocFormat: " + indexToLocFormat);
+          }
+        }
+      }
+
+      function sanitizeGlyphLocations(loca, glyf, numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry, maxSizeOfInstructions) {
+        var itemSize, itemDecode, itemEncode;
+
+        if (isGlyphLocationsLong) {
+          itemSize = 4;
+
+          itemDecode = function fontItemDecodeLong(data, offset) {
+            return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+          };
+
+          itemEncode = function fontItemEncodeLong(data, offset, value) {
+            data[offset] = value >>> 24 & 0xff;
+            data[offset + 1] = value >> 16 & 0xff;
+            data[offset + 2] = value >> 8 & 0xff;
+            data[offset + 3] = value & 0xff;
+          };
+        } else {
+          itemSize = 2;
+
+          itemDecode = function fontItemDecode(data, offset) {
+            return data[offset] << 9 | data[offset + 1] << 1;
+          };
+
+          itemEncode = function fontItemEncode(data, offset, value) {
+            data[offset] = value >> 9 & 0xff;
+            data[offset + 1] = value >> 1 & 0xff;
+          };
+        }
+
+        var numGlyphsOut = dupFirstEntry ? numGlyphs + 1 : numGlyphs;
+        var locaDataSize = itemSize * (1 + numGlyphsOut);
+        var locaData = new Uint8Array(locaDataSize);
+        locaData.set(loca.data.subarray(0, locaDataSize));
+        loca.data = locaData;
+        var oldGlyfData = glyf.data;
+        var oldGlyfDataLength = oldGlyfData.length;
+        var newGlyfData = new Uint8Array(oldGlyfDataLength);
+        var i, j;
+        const locaEntries = [];
+
+        for (i = 0, j = 0; i < numGlyphs + 1; i++, j += itemSize) {
+          let offset = itemDecode(locaData, j);
+
+          if (offset > oldGlyfDataLength) {
+            offset = oldGlyfDataLength;
+          }
+
+          locaEntries.push({
+            index: i,
+            offset,
+            endOffset: 0
+          });
+        }
+
+        locaEntries.sort((a, b) => {
+          return a.offset - b.offset;
+        });
+
+        for (i = 0; i < numGlyphs; i++) {
+          locaEntries[i].endOffset = locaEntries[i + 1].offset;
+        }
+
+        locaEntries.sort((a, b) => {
+          return a.index - b.index;
+        });
+        var missingGlyphs = Object.create(null);
+        var writeOffset = 0;
+        itemEncode(locaData, 0, writeOffset);
+
+        for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
+          var glyphProfile = sanitizeGlyph(oldGlyfData, locaEntries[i].offset, locaEntries[i].endOffset, newGlyfData, writeOffset, hintsValid);
+          var newLength = glyphProfile.length;
+
+          if (newLength === 0) {
+            missingGlyphs[i] = true;
+          }
+
+          if (glyphProfile.sizeOfInstructions > maxSizeOfInstructions) {
+            maxSizeOfInstructions = glyphProfile.sizeOfInstructions;
+          }
+
+          writeOffset += newLength;
+          itemEncode(locaData, j, writeOffset);
+        }
+
+        if (writeOffset === 0) {
+          var simpleGlyph = new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0]);
+
+          for (i = 0, j = itemSize; i < numGlyphsOut; i++, j += itemSize) {
+            itemEncode(locaData, j, simpleGlyph.length);
+          }
+
+          glyf.data = simpleGlyph;
+        } else if (dupFirstEntry) {
+          var firstEntryLength = itemDecode(locaData, itemSize);
+
+          if (newGlyfData.length > firstEntryLength + writeOffset) {
+            glyf.data = newGlyfData.subarray(0, firstEntryLength + writeOffset);
+          } else {
+            glyf.data = new Uint8Array(firstEntryLength + writeOffset);
+            glyf.data.set(newGlyfData.subarray(0, writeOffset));
+          }
+
+          glyf.data.set(newGlyfData.subarray(0, firstEntryLength), writeOffset);
+          itemEncode(loca.data, locaData.length - itemSize, writeOffset + firstEntryLength);
+        } else {
+          glyf.data = newGlyfData.subarray(0, writeOffset);
+        }
+
+        return {
+          missingGlyphs,
+          maxSizeOfInstructions
+        };
+      }
+
+      function readPostScriptTable(post, propertiesObj, maxpNumGlyphs) {
+        var start = (font.start ? font.start : 0) + post.offset;
+        font.pos = start;
+        var length = post.length,
+            end = start + length;
+        var version = font.getInt32();
+        font.skip(28);
+        var glyphNames;
+        var valid = true;
+        var i;
+
+        switch (version) {
+          case 0x00010000:
+            glyphNames = MacStandardGlyphOrdering;
+            break;
+
+          case 0x00020000:
+            var numGlyphs = font.getUint16();
+
+            if (numGlyphs !== maxpNumGlyphs) {
+              valid = false;
+              break;
+            }
+
+            var glyphNameIndexes = [];
+
+            for (i = 0; i < numGlyphs; ++i) {
+              var index = font.getUint16();
+
+              if (index >= 32768) {
+                valid = false;
+                break;
+              }
+
+              glyphNameIndexes.push(index);
+            }
+
+            if (!valid) {
+              break;
+            }
+
+            var customNames = [];
+            var strBuf = [];
+
+            while (font.pos < end) {
+              var stringLength = font.getByte();
+              strBuf.length = stringLength;
+
+              for (i = 0; i < stringLength; ++i) {
+                strBuf[i] = String.fromCharCode(font.getByte());
+              }
+
+              customNames.push(strBuf.join(""));
+            }
+
+            glyphNames = [];
+
+            for (i = 0; i < numGlyphs; ++i) {
+              var j = glyphNameIndexes[i];
+
+              if (j < 258) {
+                glyphNames.push(MacStandardGlyphOrdering[j]);
+                continue;
+              }
+
+              glyphNames.push(customNames[j - 258]);
+            }
+
+            break;
+
+          case 0x00030000:
+            break;
+
+          default:
+            (0, _util.warn)("Unknown/unsupported post table version " + version);
+            valid = false;
+
+            if (propertiesObj.defaultEncoding) {
+              glyphNames = propertiesObj.defaultEncoding;
+            }
+
+            break;
+        }
+
+        propertiesObj.glyphNames = glyphNames;
+        return valid;
+      }
+
+      function readNameTable(nameTable) {
+        var start = (font.start ? font.start : 0) + nameTable.offset;
+        font.pos = start;
+        var names = [[], []];
+        var length = nameTable.length,
+            end = start + length;
+        var format = font.getUint16();
+        var FORMAT_0_HEADER_LENGTH = 6;
+
+        if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) {
+          return names;
+        }
+
+        var numRecords = font.getUint16();
+        var stringsStart = font.getUint16();
+        var records = [];
+        var NAME_RECORD_LENGTH = 12;
+        var i, ii;
+
+        for (i = 0; i < numRecords && font.pos + NAME_RECORD_LENGTH <= end; i++) {
+          var r = {
+            platform: font.getUint16(),
+            encoding: font.getUint16(),
+            language: font.getUint16(),
+            name: font.getUint16(),
+            length: font.getUint16(),
+            offset: font.getUint16()
+          };
+
+          if (r.platform === 1 && r.encoding === 0 && r.language === 0 || r.platform === 3 && r.encoding === 1 && r.language === 0x409) {
+            records.push(r);
+          }
+        }
+
+        for (i = 0, ii = records.length; i < ii; i++) {
+          var record = records[i];
+
+          if (record.length <= 0) {
+            continue;
+          }
+
+          var pos = start + stringsStart + record.offset;
+
+          if (pos + record.length > end) {
+            continue;
+          }
+
+          font.pos = pos;
+          var nameIndex = record.name;
+
+          if (record.encoding) {
+            var str = "";
+
+            for (var j = 0, jj = record.length; j < jj; j += 2) {
+              str += String.fromCharCode(font.getUint16());
+            }
+
+            names[1][nameIndex] = str;
+          } else {
+            names[0][nameIndex] = (0, _util.bytesToString)(font.getBytes(record.length));
+          }
+        }
+
+        return names;
+      }
+
+      var TTOpsStackDeltas = [0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, -2, 0, 0, -2, -5, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, -1, -1, 1, -1, -999, 0, 1, 0, -1, -2, 0, -1, -2, -1, -1, 0, -1, -1, 0, 0, -999, -999, -1, -1, -1, -1, -2, -999, -2, -2, -999, 0, -2, -2, 0, 0, -2, 0, -2, 0, 0, 0, -2, -1, -1, 1, 1, 0, 0, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, 0, -999, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -999, -999, -999, -999, -999, -1, -1, -2, -2, 0, 0, 0, 0, -1, -1, -999, -2, -2, 0, 0, -1, -2, -2, 0, 0, 0, -1, -1, -1, -2];
+
+      function sanitizeTTProgram(table, ttContext) {
+        var data = table.data;
+        var i = 0,
+            j,
+            n,
+            b,
+            funcId,
+            pc,
+            lastEndf = 0,
+            lastDeff = 0;
+        var stack = [];
+        var callstack = [];
+        var functionsCalled = [];
+        var tooComplexToFollowFunctions = ttContext.tooComplexToFollowFunctions;
+        var inFDEF = false,
+            ifLevel = 0,
+            inELSE = 0;
+
+        for (var ii = data.length; i < ii;) {
+          var op = data[i++];
+
+          if (op === 0x40) {
+            n = data[i++];
+
+            if (inFDEF || inELSE) {
+              i += n;
+            } else {
+              for (j = 0; j < n; j++) {
+                stack.push(data[i++]);
+              }
+            }
+          } else if (op === 0x41) {
+            n = data[i++];
+
+            if (inFDEF || inELSE) {
+              i += n * 2;
+            } else {
+              for (j = 0; j < n; j++) {
+                b = data[i++];
+                stack.push(b << 8 | data[i++]);
+              }
+            }
+          } else if ((op & 0xf8) === 0xb0) {
+            n = op - 0xb0 + 1;
+
+            if (inFDEF || inELSE) {
+              i += n;
+            } else {
+              for (j = 0; j < n; j++) {
+                stack.push(data[i++]);
+              }
+            }
+          } else if ((op & 0xf8) === 0xb8) {
+            n = op - 0xb8 + 1;
+
+            if (inFDEF || inELSE) {
+              i += n * 2;
+            } else {
+              for (j = 0; j < n; j++) {
+                b = data[i++];
+                stack.push(b << 8 | data[i++]);
+              }
+            }
+          } else if (op === 0x2b && !tooComplexToFollowFunctions) {
+            if (!inFDEF && !inELSE) {
+              funcId = stack[stack.length - 1];
+
+              if (isNaN(funcId)) {
+                (0, _util.info)("TT: CALL empty stack (or invalid entry).");
+              } else {
+                ttContext.functionsUsed[funcId] = true;
+
+                if (funcId in ttContext.functionsStackDeltas) {
+                  const newStackLength = stack.length + ttContext.functionsStackDeltas[funcId];
+
+                  if (newStackLength < 0) {
+                    (0, _util.warn)("TT: CALL invalid functions stack delta.");
+                    ttContext.hintsValid = false;
+                    return;
+                  }
+
+                  stack.length = newStackLength;
+                } else if (funcId in ttContext.functionsDefined && !functionsCalled.includes(funcId)) {
+                  callstack.push({
+                    data,
+                    i,
+                    stackTop: stack.length - 1
+                  });
+                  functionsCalled.push(funcId);
+                  pc = ttContext.functionsDefined[funcId];
+
+                  if (!pc) {
+                    (0, _util.warn)("TT: CALL non-existent function");
+                    ttContext.hintsValid = false;
+                    return;
+                  }
+
+                  data = pc.data;
+                  i = pc.i;
+                }
+              }
+            }
+          } else if (op === 0x2c && !tooComplexToFollowFunctions) {
+            if (inFDEF || inELSE) {
+              (0, _util.warn)("TT: nested FDEFs not allowed");
+              tooComplexToFollowFunctions = true;
+            }
+
+            inFDEF = true;
+            lastDeff = i;
+            funcId = stack.pop();
+            ttContext.functionsDefined[funcId] = {
+              data,
+              i
+            };
+          } else if (op === 0x2d) {
+            if (inFDEF) {
+              inFDEF = false;
+              lastEndf = i;
+            } else {
+              pc = callstack.pop();
+
+              if (!pc) {
+                (0, _util.warn)("TT: ENDF bad stack");
+                ttContext.hintsValid = false;
+                return;
+              }
+
+              funcId = functionsCalled.pop();
+              data = pc.data;
+              i = pc.i;
+              ttContext.functionsStackDeltas[funcId] = stack.length - pc.stackTop;
+            }
+          } else if (op === 0x89) {
+            if (inFDEF || inELSE) {
+              (0, _util.warn)("TT: nested IDEFs not allowed");
+              tooComplexToFollowFunctions = true;
+            }
+
+            inFDEF = true;
+            lastDeff = i;
+          } else if (op === 0x58) {
+            ++ifLevel;
+          } else if (op === 0x1b) {
+            inELSE = ifLevel;
+          } else if (op === 0x59) {
+            if (inELSE === ifLevel) {
+              inELSE = 0;
+            }
+
+            --ifLevel;
+          } else if (op === 0x1c) {
+            if (!inFDEF && !inELSE) {
+              var offset = stack[stack.length - 1];
+
+              if (offset > 0) {
+                i += offset - 1;
+              }
+            }
+          }
+
+          if (!inFDEF && !inELSE) {
+            let stackDelta = 0;
+
+            if (op <= 0x8e) {
+              stackDelta = TTOpsStackDeltas[op];
+            } else if (op >= 0xc0 && op <= 0xdf) {
+              stackDelta = -1;
+            } else if (op >= 0xe0) {
+              stackDelta = -2;
+            }
+
+            if (op >= 0x71 && op <= 0x75) {
+              n = stack.pop();
+
+              if (!isNaN(n)) {
+                stackDelta = -n * 2;
+              }
+            }
+
+            while (stackDelta < 0 && stack.length > 0) {
+              stack.pop();
+              stackDelta++;
+            }
+
+            while (stackDelta > 0) {
+              stack.push(NaN);
+              stackDelta--;
+            }
+          }
+        }
+
+        ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions;
+        var content = [data];
+
+        if (i > data.length) {
+          content.push(new Uint8Array(i - data.length));
+        }
+
+        if (lastDeff > lastEndf) {
+          (0, _util.warn)("TT: complementing a missing function tail");
+          content.push(new Uint8Array([0x22, 0x2d]));
+        }
+
+        foldTTTable(table, content);
+      }
+
+      function checkInvalidFunctions(ttContext, maxFunctionDefs) {
+        if (ttContext.tooComplexToFollowFunctions) {
+          return;
+        }
+
+        if (ttContext.functionsDefined.length > maxFunctionDefs) {
+          (0, _util.warn)("TT: more functions defined than expected");
+          ttContext.hintsValid = false;
+          return;
+        }
+
+        for (var j = 0, jj = ttContext.functionsUsed.length; j < jj; j++) {
+          if (j > maxFunctionDefs) {
+            (0, _util.warn)("TT: invalid function id: " + j);
+            ttContext.hintsValid = false;
+            return;
+          }
+
+          if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) {
+            (0, _util.warn)("TT: undefined function: " + j);
+            ttContext.hintsValid = false;
+            return;
+          }
+        }
+      }
+
+      function foldTTTable(table, content) {
+        if (content.length > 1) {
+          var newLength = 0;
+          var j, jj;
+
+          for (j = 0, jj = content.length; j < jj; j++) {
+            newLength += content[j].length;
+          }
+
+          newLength = newLength + 3 & ~3;
+          var result = new Uint8Array(newLength);
+          var pos = 0;
+
+          for (j = 0, jj = content.length; j < jj; j++) {
+            result.set(content[j], pos);
+            pos += content[j].length;
+          }
+
+          table.data = result;
+          table.length = newLength;
+        }
+      }
+
+      function sanitizeTTPrograms(fpgm, prep, cvt, maxFunctionDefs) {
+        var ttContext = {
+          functionsDefined: [],
+          functionsUsed: [],
+          functionsStackDeltas: [],
+          tooComplexToFollowFunctions: false,
+          hintsValid: true
+        };
+
+        if (fpgm) {
+          sanitizeTTProgram(fpgm, ttContext);
+        }
+
+        if (prep) {
+          sanitizeTTProgram(prep, ttContext);
+        }
+
+        if (fpgm) {
+          checkInvalidFunctions(ttContext, maxFunctionDefs);
+        }
+
+        if (cvt && cvt.length & 1) {
+          var cvtData = new Uint8Array(cvt.length + 1);
+          cvtData.set(cvt.data);
+          cvt.data = cvtData;
+        }
+
+        return ttContext.hintsValid;
+      }
+
+      font = new _stream.Stream(new Uint8Array(font.getBytes()));
+      let header, tables;
+
+      if (isTrueTypeCollectionFile(font)) {
+        const ttcData = readTrueTypeCollectionData(font, this.name);
+        header = ttcData.header;
+        tables = ttcData.tables;
+      } else {
+        header = readOpenTypeHeader(font);
+        tables = readTables(font, header.numTables);
+      }
+
+      let cff, cffFile;
+      var isTrueType = !tables["CFF "];
+
+      if (!isTrueType) {
+        const isComposite = properties.composite && ((properties.cidToGidMap || []).length > 0 || !(properties.cMap instanceof _cmap.IdentityCMap));
+
+        if (header.version === "OTTO" && !isComposite || !tables.head || !tables.hhea || !tables.maxp || !tables.post) {
+          cffFile = new _stream.Stream(tables["CFF "].data);
+          cff = new CFFFont(cffFile, properties);
+          adjustWidths(properties);
+          return this.convert(name, cff, properties);
+        }
+
+        delete tables.glyf;
+        delete tables.loca;
+        delete tables.fpgm;
+        delete tables.prep;
+        delete tables["cvt "];
+        this.isOpenType = true;
+      } else {
+        if (!tables.loca) {
+          throw new _util.FormatError('Required "loca" table is not found');
+        }
+
+        if (!tables.glyf) {
+          (0, _util.warn)('Required "glyf" table is not found -- trying to recover.');
+          tables.glyf = {
+            tag: "glyf",
+            data: new Uint8Array(0)
+          };
+        }
+
+        this.isOpenType = false;
+      }
+
+      if (!tables.maxp) {
+        throw new _util.FormatError('Required "maxp" table is not found');
+      }
+
+      font.pos = (font.start || 0) + tables.maxp.offset;
+      var version = font.getInt32();
+      const numGlyphs = font.getUint16();
+      let numGlyphsOut = numGlyphs + 1;
+      let dupFirstEntry = true;
+
+      if (numGlyphsOut > 0xffff) {
+        dupFirstEntry = false;
+        numGlyphsOut = numGlyphs;
+        (0, _util.warn)("Not enough space in glyfs to duplicate first glyph.");
+      }
+
+      var maxFunctionDefs = 0;
+      var maxSizeOfInstructions = 0;
+
+      if (version >= 0x00010000 && tables.maxp.length >= 22) {
+        font.pos += 8;
+        var maxZones = font.getUint16();
+
+        if (maxZones > 2) {
+          tables.maxp.data[14] = 0;
+          tables.maxp.data[15] = 2;
+        }
+
+        font.pos += 4;
+        maxFunctionDefs = font.getUint16();
+        font.pos += 4;
+        maxSizeOfInstructions = font.getUint16();
+      }
+
+      tables.maxp.data[4] = numGlyphsOut >> 8;
+      tables.maxp.data[5] = numGlyphsOut & 255;
+      var hintsValid = sanitizeTTPrograms(tables.fpgm, tables.prep, tables["cvt "], maxFunctionDefs);
+
+      if (!hintsValid) {
+        delete tables.fpgm;
+        delete tables.prep;
+        delete tables["cvt "];
+      }
+
+      sanitizeMetrics(font, tables.hhea, tables.hmtx, numGlyphsOut, dupFirstEntry);
+
+      if (!tables.head) {
+        throw new _util.FormatError('Required "head" table is not found');
+      }
+
+      sanitizeHead(tables.head, numGlyphs, isTrueType ? tables.loca.length : 0);
+      var missingGlyphs = Object.create(null);
+
+      if (isTrueType) {
+        var isGlyphLocationsLong = int16(tables.head.data[50], tables.head.data[51]);
+        var glyphsInfo = sanitizeGlyphLocations(tables.loca, tables.glyf, numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry, maxSizeOfInstructions);
+        missingGlyphs = glyphsInfo.missingGlyphs;
+
+        if (version >= 0x00010000 && tables.maxp.length >= 22) {
+          tables.maxp.data[26] = glyphsInfo.maxSizeOfInstructions >> 8;
+          tables.maxp.data[27] = glyphsInfo.maxSizeOfInstructions & 255;
+        }
+      }
+
+      if (!tables.hhea) {
+        throw new _util.FormatError('Required "hhea" table is not found');
+      }
+
+      if (tables.hhea.data[10] === 0 && tables.hhea.data[11] === 0) {
+        tables.hhea.data[10] = 0xff;
+        tables.hhea.data[11] = 0xff;
+      }
+
+      var metricsOverride = {
+        unitsPerEm: int16(tables.head.data[18], tables.head.data[19]),
+        yMax: int16(tables.head.data[42], tables.head.data[43]),
+        yMin: signedInt16(tables.head.data[38], tables.head.data[39]),
+        ascent: int16(tables.hhea.data[4], tables.hhea.data[5]),
+        descent: signedInt16(tables.hhea.data[6], tables.hhea.data[7])
+      };
+      this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm;
+      this.descent = metricsOverride.descent / metricsOverride.unitsPerEm;
+
+      if (tables.post) {
+        readPostScriptTable(tables.post, properties, numGlyphs);
+      }
+
+      tables.post = {
+        tag: "post",
+        data: createPostTable(properties)
+      };
+      const charCodeToGlyphId = [];
+
+      function hasGlyph(glyphId) {
+        return !missingGlyphs[glyphId];
+      }
+
+      if (properties.composite) {
+        var cidToGidMap = properties.cidToGidMap || [];
+        var isCidToGidMapEmpty = cidToGidMap.length === 0;
+        properties.cMap.forEach(function (charCode, cid) {
+          if (cid > 0xffff) {
+            throw new _util.FormatError("Max size of CID is 65,535");
+          }
+
+          var glyphId = -1;
+
+          if (isCidToGidMapEmpty) {
+            glyphId = cid;
+          } else if (cidToGidMap[cid] !== undefined) {
+            glyphId = cidToGidMap[cid];
+          }
+
+          if (glyphId >= 0 && glyphId < numGlyphs && hasGlyph(glyphId)) {
+            charCodeToGlyphId[charCode] = glyphId;
+          }
+        });
+      } else {
+        var cmapTable = readCmapTable(tables.cmap, font, this.isSymbolicFont, properties.hasEncoding);
+        var cmapPlatformId = cmapTable.platformId;
+        var cmapEncodingId = cmapTable.encodingId;
+        var cmapMappings = cmapTable.mappings;
+        var cmapMappingsLength = cmapMappings.length;
+        let baseEncoding = [];
+
+        if (properties.hasEncoding && (properties.baseEncodingName === "MacRomanEncoding" || properties.baseEncodingName === "WinAnsiEncoding")) {
+          baseEncoding = (0, _encodings.getEncoding)(properties.baseEncodingName);
+        }
+
+        if (properties.hasEncoding && !this.isSymbolicFont && (cmapPlatformId === 3 && cmapEncodingId === 1 || cmapPlatformId === 1 && cmapEncodingId === 0)) {
+          var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+
+          for (let charCode = 0; charCode < 256; charCode++) {
+            var glyphName, standardGlyphName;
+
+            if (this.differences && charCode in this.differences) {
+              glyphName = this.differences[charCode];
+            } else if (charCode in baseEncoding && baseEncoding[charCode] !== "") {
+              glyphName = baseEncoding[charCode];
+            } else {
+              glyphName = _encodings.StandardEncoding[charCode];
+            }
+
+            if (!glyphName) {
+              continue;
+            }
+
+            standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
+            var unicodeOrCharCode;
+
+            if (cmapPlatformId === 3 && cmapEncodingId === 1) {
+              unicodeOrCharCode = glyphsUnicodeMap[standardGlyphName];
+            } else if (cmapPlatformId === 1 && cmapEncodingId === 0) {
+              unicodeOrCharCode = _encodings.MacRomanEncoding.indexOf(standardGlyphName);
+            }
+
+            for (let i = 0; i < cmapMappingsLength; ++i) {
+              if (cmapMappings[i].charCode !== unicodeOrCharCode) {
+                continue;
+              }
+
+              charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
+              break;
+            }
+          }
+        } else if (cmapPlatformId === 0) {
+          for (let i = 0; i < cmapMappingsLength; ++i) {
+            charCodeToGlyphId[cmapMappings[i].charCode] = cmapMappings[i].glyphId;
+          }
+        } else {
+          for (let i = 0; i < cmapMappingsLength; ++i) {
+            let charCode = cmapMappings[i].charCode;
+
+            if (cmapPlatformId === 3 && charCode >= 0xf000 && charCode <= 0xf0ff) {
+              charCode &= 0xff;
+            }
+
+            charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
+          }
+        }
+
+        if (properties.glyphNames && baseEncoding.length) {
+          for (let i = 0; i < 256; ++i) {
+            if (charCodeToGlyphId[i] === undefined && baseEncoding[i]) {
+              glyphName = baseEncoding[i];
+              const glyphId = properties.glyphNames.indexOf(glyphName);
+
+              if (glyphId > 0 && hasGlyph(glyphId)) {
+                charCodeToGlyphId[i] = glyphId;
+              }
+            }
+          }
+        }
+      }
+
+      if (charCodeToGlyphId.length === 0) {
+        charCodeToGlyphId[0] = 0;
+      }
+
+      let glyphZeroId = numGlyphsOut - 1;
+
+      if (!dupFirstEntry) {
+        glyphZeroId = 0;
+      }
+
+      var newMapping = adjustMapping(charCodeToGlyphId, hasGlyph, glyphZeroId);
+      this.toFontChar = newMapping.toFontChar;
+      tables.cmap = {
+        tag: "cmap",
+        data: createCmapTable(newMapping.charCodeToGlyphId, numGlyphsOut)
+      };
+
+      if (!tables["OS/2"] || !validateOS2Table(tables["OS/2"], font)) {
+        tables["OS/2"] = {
+          tag: "OS/2",
+          data: createOS2Table(properties, newMapping.charCodeToGlyphId, metricsOverride)
+        };
+      }
+
+      if (!isTrueType) {
+        try {
+          cffFile = new _stream.Stream(tables["CFF "].data);
+          var parser = new _cff_parser.CFFParser(cffFile, properties, SEAC_ANALYSIS_ENABLED);
+          cff = parser.parse();
+          cff.duplicateFirstGlyph();
+          var compiler = new _cff_parser.CFFCompiler(cff);
+          tables["CFF "].data = compiler.compile();
+        } catch (e) {
+          (0, _util.warn)("Failed to compile font " + properties.loadedName);
+        }
+      }
+
+      if (!tables.name) {
+        tables.name = {
+          tag: "name",
+          data: createNameTable(this.name)
+        };
+      } else {
+        var namePrototype = readNameTable(tables.name);
+        tables.name.data = createNameTable(name, namePrototype);
+      }
+
+      var builder = new OpenTypeFileBuilder(header.version);
+
+      for (var tableTag in tables) {
+        builder.addTable(tableTag, tables[tableTag].data);
+      }
+
+      return builder.toArray();
+    },
+    convert: function Font_convert(fontName, font, properties) {
+      properties.fixedPitch = false;
+
+      if (properties.builtInEncoding) {
+        adjustToUnicode(properties, properties.builtInEncoding);
+      }
+
+      let glyphZeroId = 1;
+
+      if (font instanceof CFFFont) {
+        glyphZeroId = font.numGlyphs - 1;
+      }
+
+      var mapping = font.getGlyphMapping(properties);
+      var newMapping = adjustMapping(mapping, font.hasGlyphId.bind(font), glyphZeroId);
+      this.toFontChar = newMapping.toFontChar;
+      var numGlyphs = font.numGlyphs;
+
+      function getCharCodes(charCodeToGlyphId, glyphId) {
+        var charCodes = null;
+
+        for (var charCode in charCodeToGlyphId) {
+          if (glyphId === charCodeToGlyphId[charCode]) {
+            if (!charCodes) {
+              charCodes = [];
+            }
+
+            charCodes.push(charCode | 0);
+          }
+        }
+
+        return charCodes;
+      }
+
+      function createCharCode(charCodeToGlyphId, glyphId) {
+        for (var charCode in charCodeToGlyphId) {
+          if (glyphId === charCodeToGlyphId[charCode]) {
+            return charCode | 0;
+          }
+        }
+
+        newMapping.charCodeToGlyphId[newMapping.nextAvailableFontCharCode] = glyphId;
+        return newMapping.nextAvailableFontCharCode++;
+      }
+
+      var seacs = font.seacs;
+
+      if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) {
+        var matrix = properties.fontMatrix || _util.FONT_IDENTITY_MATRIX;
+        var charset = font.getCharset();
+        var seacMap = Object.create(null);
+
+        for (var glyphId in seacs) {
+          glyphId |= 0;
+          var seac = seacs[glyphId];
+          var baseGlyphName = _encodings.StandardEncoding[seac[2]];
+          var accentGlyphName = _encodings.StandardEncoding[seac[3]];
+          var baseGlyphId = charset.indexOf(baseGlyphName);
+          var accentGlyphId = charset.indexOf(accentGlyphName);
+
+          if (baseGlyphId < 0 || accentGlyphId < 0) {
+            continue;
+          }
+
+          var accentOffset = {
+            x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4],
+            y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5]
+          };
+          var charCodes = getCharCodes(mapping, glyphId);
+
+          if (!charCodes) {
+            continue;
+          }
+
+          for (let i = 0, ii = charCodes.length; i < ii; i++) {
+            var charCode = charCodes[i];
+            var charCodeToGlyphId = newMapping.charCodeToGlyphId;
+            var baseFontCharCode = createCharCode(charCodeToGlyphId, baseGlyphId);
+            var accentFontCharCode = createCharCode(charCodeToGlyphId, accentGlyphId);
+            seacMap[charCode] = {
+              baseFontCharCode,
+              accentFontCharCode,
+              accentOffset
+            };
+          }
+        }
+
+        properties.seacMap = seacMap;
+      }
+
+      var unitsPerEm = 1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
+      var builder = new OpenTypeFileBuilder("\x4F\x54\x54\x4F");
+      builder.addTable("CFF ", font.data);
+      builder.addTable("OS/2", createOS2Table(properties, newMapping.charCodeToGlyphId));
+      builder.addTable("cmap", createCmapTable(newMapping.charCodeToGlyphId, numGlyphs));
+      builder.addTable("head", "\x00\x01\x00\x00" + "\x00\x00\x10\x00" + "\x00\x00\x00\x00" + "\x5F\x0F\x3C\xF5" + "\x00\x00" + safeString16(unitsPerEm) + "\x00\x00\x00\x00\x9e\x0b\x7e\x27" + "\x00\x00\x00\x00\x9e\x0b\x7e\x27" + "\x00\x00" + safeString16(properties.descent) + "\x0F\xFF" + safeString16(properties.ascent) + string16(properties.italicAngle ? 2 : 0) + "\x00\x11" + "\x00\x00" + "\x00\x00" + "\x00\x00");
+      builder.addTable("hhea", "\x00\x01\x00\x00" + safeString16(properties.ascent) + safeString16(properties.descent) + "\x00\x00" + "\xFF\xFF" + "\x00\x00" + "\x00\x00" + "\x00\x00" + safeString16(properties.capHeight) + safeString16(Math.tan(properties.italicAngle) * properties.xHeight) + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + string16(numGlyphs));
+      builder.addTable("hmtx", function fontFieldsHmtx() {
+        var charstrings = font.charstrings;
+        var cffWidths = font.cff ? font.cff.widths : null;
+        var hmtx = "\x00\x00\x00\x00";
+
+        for (let i = 1, ii = numGlyphs; i < ii; i++) {
+          var width = 0;
+
+          if (charstrings) {
+            var charstring = charstrings[i - 1];
+            width = "width" in charstring ? charstring.width : 0;
+          } else if (cffWidths) {
+            width = Math.ceil(cffWidths[i] || 0);
+          }
+
+          hmtx += string16(width) + string16(0);
+        }
+
+        return hmtx;
+      }());
+      builder.addTable("maxp", "\x00\x00\x50\x00" + string16(numGlyphs));
+      builder.addTable("name", createNameTable(fontName));
+      builder.addTable("post", createPostTable(properties));
+      return builder.toArray();
+    },
+
+    get spaceWidth() {
+      var possibleSpaceReplacements = ["space", "minus", "one", "i", "I"];
+      var width;
+
+      for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) {
+        var glyphName = possibleSpaceReplacements[i];
+
+        if (glyphName in this.widths) {
+          width = this.widths[glyphName];
+          break;
+        }
+
+        var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+        var glyphUnicode = glyphsUnicodeMap[glyphName];
+        var charcode = 0;
+
+        if (this.composite && this.cMap.contains(glyphUnicode)) {
+          charcode = this.cMap.lookup(glyphUnicode);
+        }
+
+        if (!charcode && this.toUnicode) {
+          charcode = this.toUnicode.charCodeOf(glyphUnicode);
+        }
+
+        if (charcode <= 0) {
+          charcode = glyphUnicode;
+        }
+
+        width = this.widths[charcode];
+
+        if (width) {
+          break;
+        }
+      }
+
+      width = width || this.defaultWidth;
+      return (0, _util.shadow)(this, "spaceWidth", width);
+    },
+
+    _charToGlyph(charcode, isSpace = false) {
+      var fontCharCode, width, operatorListId;
+      var widthCode = charcode;
+
+      if (this.cMap && this.cMap.contains(charcode)) {
+        widthCode = this.cMap.lookup(charcode);
+      }
+
+      width = this.widths[widthCode];
+      width = (0, _util.isNum)(width) ? width : this.defaultWidth;
+      var vmetric = this.vmetrics && this.vmetrics[widthCode];
+      let unicode = this.toUnicode.get(charcode) || this.fallbackToUnicode.get(charcode) || charcode;
+
+      if (typeof unicode === "number") {
+        unicode = String.fromCharCode(unicode);
+      }
+
+      var isInFont = (charcode in this.toFontChar);
+      fontCharCode = this.toFontChar[charcode] || charcode;
+
+      if (this.missingFile) {
+        const glyphName = this.differences[charcode] || this.defaultEncoding[charcode];
+
+        if ((glyphName === ".notdef" || glyphName === "") && this.type === "Type1") {
+          fontCharCode = 0x20;
+        }
+
+        fontCharCode = (0, _unicode.mapSpecialUnicodeValues)(fontCharCode);
+      }
+
+      if (this.isType3Font) {
+        operatorListId = fontCharCode;
+      }
+
+      var accent = null;
+
+      if (this.seacMap && this.seacMap[charcode]) {
+        isInFont = true;
+        var seac = this.seacMap[charcode];
+        fontCharCode = seac.baseFontCharCode;
+        accent = {
+          fontChar: String.fromCodePoint(seac.accentFontCharCode),
+          offset: seac.accentOffset
+        };
+      }
+
+      let fontChar = "";
+
+      if (typeof fontCharCode === "number") {
+        if (fontCharCode <= 0x10ffff) {
+          fontChar = String.fromCodePoint(fontCharCode);
+        } else {
+          (0, _util.warn)(`charToGlyph - invalid fontCharCode: ${fontCharCode}`);
+        }
+      }
+
+      var glyph = this.glyphCache[charcode];
+
+      if (!glyph || !glyph.matchesForCache(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont)) {
+        glyph = new Glyph(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont);
+        this.glyphCache[charcode] = glyph;
+      }
+
+      return glyph;
+    },
+
+    charsToGlyphs: function Font_charsToGlyphs(chars) {
+      var charsCache = this.charsCache;
+      var glyphs, glyph, charcode;
+
+      if (charsCache) {
+        glyphs = charsCache[chars];
+
+        if (glyphs) {
+          return glyphs;
+        }
+      }
+
+      if (!charsCache) {
+        charsCache = this.charsCache = Object.create(null);
+      }
+
+      glyphs = [];
+      var charsCacheKey = chars;
+      var i = 0,
+          ii;
+
+      if (this.cMap) {
+        var c = Object.create(null);
+
+        while (i < chars.length) {
+          this.cMap.readCharCode(chars, i, c);
+          charcode = c.charcode;
+          var length = c.length;
+          i += length;
+          var isSpace = length === 1 && chars.charCodeAt(i - 1) === 0x20;
+          glyph = this._charToGlyph(charcode, isSpace);
+          glyphs.push(glyph);
+        }
+      } else {
+        for (i = 0, ii = chars.length; i < ii; ++i) {
+          charcode = chars.charCodeAt(i);
+          glyph = this._charToGlyph(charcode, charcode === 0x20);
+          glyphs.push(glyph);
+        }
+      }
+
+      return charsCache[charsCacheKey] = glyphs;
+    },
+
+    getCharPositions(chars) {
+      const positions = [];
+
+      if (this.cMap) {
+        const c = Object.create(null);
+        let i = 0;
+
+        while (i < chars.length) {
+          this.cMap.readCharCode(chars, i, c);
+          const length = c.length;
+          positions.push([i, i + length]);
+          i += length;
+        }
+      } else {
+        for (let i = 0, ii = chars.length; i < ii; ++i) {
+          positions.push([i, i + 1]);
+        }
+      }
+
+      return positions;
+    },
+
+    get glyphCacheValues() {
+      return Object.values(this.glyphCache);
+    },
+
+    encodeString(str) {
+      const buffers = [];
+      const currentBuf = [];
+
+      const hasCurrentBufErrors = () => buffers.length % 2 === 1;
+
+      for (let i = 0, ii = str.length; i < ii; i++) {
+        const unicode = str.codePointAt(i);
+
+        if (unicode > 0xd7ff && (unicode < 0xe000 || unicode > 0xfffd)) {
+          i++;
+        }
+
+        if (this.toUnicode) {
+          const char = String.fromCodePoint(unicode);
+          const charCode = this.toUnicode.charCodeOf(char);
+
+          if (charCode !== -1) {
+            if (hasCurrentBufErrors()) {
+              buffers.push(currentBuf.join(""));
+              currentBuf.length = 0;
+            }
+
+            const charCodeLength = this.cMap ? this.cMap.getCharCodeLength(charCode) : 1;
+
+            for (let j = charCodeLength - 1; j >= 0; j--) {
+              currentBuf.push(String.fromCharCode(charCode >> 8 * j & 0xff));
+            }
+
+            continue;
+          }
+        }
+
+        if (!hasCurrentBufErrors()) {
+          buffers.push(currentBuf.join(""));
+          currentBuf.length = 0;
+        }
+
+        currentBuf.push(String.fromCodePoint(unicode));
+      }
+
+      buffers.push(currentBuf.join(""));
+      return buffers;
+    }
+
+  };
+  return Font;
+}();
+
+exports.Font = Font;
+
+var ErrorFont = function ErrorFontClosure() {
+  function ErrorFont(error) {
+    this.error = error;
+    this.loadedName = "g_font_error";
+    this.missingFile = true;
+  }
+
+  ErrorFont.prototype = {
+    charsToGlyphs: function ErrorFont_charsToGlyphs() {
+      return [];
+    },
+    encodeString: function ErrorFont_encodeString(chars) {
+      return [chars];
+    },
+
+    exportData(extraProperties = false) {
+      return {
+        error: this.error
+      };
+    }
+
+  };
+  return ErrorFont;
+}();
+
+exports.ErrorFont = ErrorFont;
+
+function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
+  var charCodeToGlyphId = Object.create(null);
+  var glyphId, charCode, baseEncoding;
+  var isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
+
+  if (properties.baseEncodingName) {
+    baseEncoding = (0, _encodings.getEncoding)(properties.baseEncodingName);
+
+    for (charCode = 0; charCode < baseEncoding.length; charCode++) {
+      glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+
+      if (glyphId >= 0) {
+        charCodeToGlyphId[charCode] = glyphId;
+      } else {
+        charCodeToGlyphId[charCode] = 0;
+      }
+    }
+  } else if (isSymbolicFont) {
+    for (charCode in builtInEncoding) {
+      charCodeToGlyphId[charCode] = builtInEncoding[charCode];
+    }
+  } else {
+    baseEncoding = _encodings.StandardEncoding;
+
+    for (charCode = 0; charCode < baseEncoding.length; charCode++) {
+      glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+
+      if (glyphId >= 0) {
+        charCodeToGlyphId[charCode] = glyphId;
+      } else {
+        charCodeToGlyphId[charCode] = 0;
+      }
+    }
+  }
+
+  var differences = properties.differences,
+      glyphsUnicodeMap;
+
+  if (differences) {
+    for (charCode in differences) {
+      var glyphName = differences[charCode];
+      glyphId = glyphNames.indexOf(glyphName);
+
+      if (glyphId === -1) {
+        if (!glyphsUnicodeMap) {
+          glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+        }
+
+        var standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
+
+        if (standardGlyphName !== glyphName) {
+          glyphId = glyphNames.indexOf(standardGlyphName);
+        }
+      }
+
+      if (glyphId >= 0) {
+        charCodeToGlyphId[charCode] = glyphId;
+      } else {
+        charCodeToGlyphId[charCode] = 0;
+      }
+    }
+  }
+
+  return charCodeToGlyphId;
+}
+
+var Type1Font = function Type1FontClosure() {
+  function findBlock(streamBytes, signature, startIndex) {
+    var streamBytesLength = streamBytes.length;
+    var signatureLength = signature.length;
+    var scanLength = streamBytesLength - signatureLength;
+    var i = startIndex,
+        j,
+        found = false;
+
+    while (i < scanLength) {
+      j = 0;
+
+      while (j < signatureLength && streamBytes[i + j] === signature[j]) {
+        j++;
+      }
+
+      if (j >= signatureLength) {
+        i += j;
+
+        while (i < streamBytesLength && (0, _core_utils.isWhiteSpace)(streamBytes[i])) {
+          i++;
+        }
+
+        found = true;
+        break;
+      }
+
+      i++;
+    }
+
+    return {
+      found,
+      length: i
+    };
+  }
+
+  function getHeaderBlock(stream, suggestedLength) {
+    var EEXEC_SIGNATURE = [0x65, 0x65, 0x78, 0x65, 0x63];
+    var streamStartPos = stream.pos;
+    var headerBytes, headerBytesLength, block;
+
+    try {
+      headerBytes = stream.getBytes(suggestedLength);
+      headerBytesLength = headerBytes.length;
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+    }
+
+    if (headerBytesLength === suggestedLength) {
+      block = findBlock(headerBytes, EEXEC_SIGNATURE, suggestedLength - 2 * EEXEC_SIGNATURE.length);
+
+      if (block.found && block.length === suggestedLength) {
+        return {
+          stream: new _stream.Stream(headerBytes),
+          length: suggestedLength
+        };
+      }
+    }
+
+    (0, _util.warn)('Invalid "Length1" property in Type1 font -- trying to recover.');
+    stream.pos = streamStartPos;
+    var SCAN_BLOCK_LENGTH = 2048;
+    var actualLength;
+
+    while (true) {
+      var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
+      block = findBlock(scanBytes, EEXEC_SIGNATURE, 0);
+
+      if (block.length === 0) {
+        break;
+      }
+
+      stream.pos += block.length;
+
+      if (block.found) {
+        actualLength = stream.pos - streamStartPos;
+        break;
+      }
+    }
+
+    stream.pos = streamStartPos;
+
+    if (actualLength) {
+      return {
+        stream: new _stream.Stream(stream.getBytes(actualLength)),
+        length: actualLength
+      };
+    }
+
+    (0, _util.warn)('Unable to recover "Length1" property in Type1 font -- using as is.');
+    return {
+      stream: new _stream.Stream(stream.getBytes(suggestedLength)),
+      length: suggestedLength
+    };
+  }
+
+  function getEexecBlock(stream, suggestedLength) {
+    var eexecBytes = stream.getBytes();
+    return {
+      stream: new _stream.Stream(eexecBytes),
+      length: eexecBytes.length
+    };
+  }
+
+  function Type1Font(name, file, properties) {
+    var PFB_HEADER_SIZE = 6;
+    var headerBlockLength = properties.length1;
+    var eexecBlockLength = properties.length2;
+    var pfbHeader = file.peekBytes(PFB_HEADER_SIZE);
+    var pfbHeaderPresent = pfbHeader[0] === 0x80 && pfbHeader[1] === 0x01;
+
+    if (pfbHeaderPresent) {
+      file.skip(PFB_HEADER_SIZE);
+      headerBlockLength = pfbHeader[5] << 24 | pfbHeader[4] << 16 | pfbHeader[3] << 8 | pfbHeader[2];
+    }
+
+    var headerBlock = getHeaderBlock(file, headerBlockLength);
+    var headerBlockParser = new _type1_parser.Type1Parser(headerBlock.stream, false, SEAC_ANALYSIS_ENABLED);
+    headerBlockParser.extractFontHeader(properties);
+
+    if (pfbHeaderPresent) {
+      pfbHeader = file.getBytes(PFB_HEADER_SIZE);
+      eexecBlockLength = pfbHeader[5] << 24 | pfbHeader[4] << 16 | pfbHeader[3] << 8 | pfbHeader[2];
+    }
+
+    var eexecBlock = getEexecBlock(file, eexecBlockLength);
+    var eexecBlockParser = new _type1_parser.Type1Parser(eexecBlock.stream, true, SEAC_ANALYSIS_ENABLED);
+    var data = eexecBlockParser.extractFontProgram(properties);
+
+    for (const key in data.properties) {
+      properties[key] = data.properties[key];
+    }
+
+    var charstrings = data.charstrings;
+    var type2Charstrings = this.getType2Charstrings(charstrings);
+    var subrs = this.getType2Subrs(data.subrs);
+    this.charstrings = charstrings;
+    this.data = this.wrap(name, type2Charstrings, this.charstrings, subrs, properties);
+    this.seacs = this.getSeacs(data.charstrings);
+  }
+
+  Type1Font.prototype = {
+    get numGlyphs() {
+      return this.charstrings.length + 1;
+    },
+
+    getCharset: function Type1Font_getCharset() {
+      var charset = [".notdef"];
+      var charstrings = this.charstrings;
+
+      for (var glyphId = 0; glyphId < charstrings.length; glyphId++) {
+        charset.push(charstrings[glyphId].glyphName);
+      }
+
+      return charset;
+    },
+    getGlyphMapping: function Type1Font_getGlyphMapping(properties) {
+      var charstrings = this.charstrings;
+
+      if (properties.composite) {
+        const charCodeToGlyphId = Object.create(null);
+
+        for (let glyphId = 0, charstringsLen = charstrings.length; glyphId < charstringsLen; glyphId++) {
+          const charCode = properties.cMap.charCodeOf(glyphId);
+          charCodeToGlyphId[charCode] = glyphId + 1;
+        }
+
+        return charCodeToGlyphId;
+      }
+
+      var glyphNames = [".notdef"],
+          glyphId;
+
+      for (glyphId = 0; glyphId < charstrings.length; glyphId++) {
+        glyphNames.push(charstrings[glyphId].glyphName);
+      }
+
+      var encoding = properties.builtInEncoding;
+
+      if (encoding) {
+        var builtInEncoding = Object.create(null);
+
+        for (var charCode in encoding) {
+          glyphId = glyphNames.indexOf(encoding[charCode]);
+
+          if (glyphId >= 0) {
+            builtInEncoding[charCode] = glyphId;
+          }
+        }
+      }
+
+      return type1FontGlyphMapping(properties, builtInEncoding, glyphNames);
+    },
+    hasGlyphId: function Type1Font_hasGlyphID(id) {
+      if (id < 0 || id >= this.numGlyphs) {
+        return false;
+      }
+
+      if (id === 0) {
+        return true;
+      }
+
+      var glyph = this.charstrings[id - 1];
+      return glyph.charstring.length > 0;
+    },
+    getSeacs: function Type1Font_getSeacs(charstrings) {
+      var i, ii;
+      var seacMap = [];
+
+      for (i = 0, ii = charstrings.length; i < ii; i++) {
+        var charstring = charstrings[i];
+
+        if (charstring.seac) {
+          seacMap[i + 1] = charstring.seac;
+        }
+      }
+
+      return seacMap;
+    },
+    getType2Charstrings: function Type1Font_getType2Charstrings(type1Charstrings) {
+      var type2Charstrings = [];
+
+      for (var i = 0, ii = type1Charstrings.length; i < ii; i++) {
+        type2Charstrings.push(type1Charstrings[i].charstring);
+      }
+
+      return type2Charstrings;
+    },
+    getType2Subrs: function Type1Font_getType2Subrs(type1Subrs) {
+      var bias = 0;
+      var count = type1Subrs.length;
+
+      if (count < 1133) {
+        bias = 107;
+      } else if (count < 33769) {
+        bias = 1131;
+      } else {
+        bias = 32768;
+      }
+
+      var type2Subrs = [];
+      var i;
+
+      for (i = 0; i < bias; i++) {
+        type2Subrs.push([0x0b]);
+      }
+
+      for (i = 0; i < count; i++) {
+        type2Subrs.push(type1Subrs[i]);
+      }
+
+      return type2Subrs;
+    },
+    wrap: function Type1Font_wrap(name, glyphs, charstrings, subrs, properties) {
+      var cff = new _cff_parser.CFF();
+      cff.header = new _cff_parser.CFFHeader(1, 0, 4, 4);
+      cff.names = [name];
+      var topDict = new _cff_parser.CFFTopDict();
+      topDict.setByName("version", 391);
+      topDict.setByName("Notice", 392);
+      topDict.setByName("FullName", 393);
+      topDict.setByName("FamilyName", 394);
+      topDict.setByName("Weight", 395);
+      topDict.setByName("Encoding", null);
+      topDict.setByName("FontMatrix", properties.fontMatrix);
+      topDict.setByName("FontBBox", properties.bbox);
+      topDict.setByName("charset", null);
+      topDict.setByName("CharStrings", null);
+      topDict.setByName("Private", null);
+      cff.topDict = topDict;
+      var strings = new _cff_parser.CFFStrings();
+      strings.add("Version 0.11");
+      strings.add("See original notice");
+      strings.add(name);
+      strings.add(name);
+      strings.add("Medium");
+      cff.strings = strings;
+      cff.globalSubrIndex = new _cff_parser.CFFIndex();
+      var count = glyphs.length;
+      var charsetArray = [".notdef"];
+      var i, ii;
+
+      for (i = 0; i < count; i++) {
+        const glyphName = charstrings[i].glyphName;
+
+        const index = _cff_parser.CFFStandardStrings.indexOf(glyphName);
+
+        if (index === -1) {
+          strings.add(glyphName);
+        }
+
+        charsetArray.push(glyphName);
+      }
+
+      cff.charset = new _cff_parser.CFFCharset(false, 0, charsetArray);
+      var charStringsIndex = new _cff_parser.CFFIndex();
+      charStringsIndex.add([0x8b, 0x0e]);
+
+      for (i = 0; i < count; i++) {
+        charStringsIndex.add(glyphs[i]);
+      }
+
+      cff.charStrings = charStringsIndex;
+      var privateDict = new _cff_parser.CFFPrivateDict();
+      privateDict.setByName("Subrs", null);
+      var fields = ["BlueValues", "OtherBlues", "FamilyBlues", "FamilyOtherBlues", "StemSnapH", "StemSnapV", "BlueShift", "BlueFuzz", "BlueScale", "LanguageGroup", "ExpansionFactor", "ForceBold", "StdHW", "StdVW"];
+
+      for (i = 0, ii = fields.length; i < ii; i++) {
+        var field = fields[i];
+
+        if (!(field in properties.privateData)) {
+          continue;
+        }
+
+        var value = properties.privateData[field];
+
+        if (Array.isArray(value)) {
+          for (var j = value.length - 1; j > 0; j--) {
+            value[j] -= value[j - 1];
+          }
+        }
+
+        privateDict.setByName(field, value);
+      }
+
+      cff.topDict.privateDict = privateDict;
+      var subrIndex = new _cff_parser.CFFIndex();
+
+      for (i = 0, ii = subrs.length; i < ii; i++) {
+        subrIndex.add(subrs[i]);
+      }
+
+      privateDict.subrsIndex = subrIndex;
+      var compiler = new _cff_parser.CFFCompiler(cff);
+      return compiler.compile();
+    }
+  };
+  return Type1Font;
+}();
+
+var CFFFont = function CFFFontClosure() {
+  function CFFFont(file, properties) {
+    this.properties = properties;
+    var parser = new _cff_parser.CFFParser(file, properties, SEAC_ANALYSIS_ENABLED);
+    this.cff = parser.parse();
+    this.cff.duplicateFirstGlyph();
+    var compiler = new _cff_parser.CFFCompiler(this.cff);
+    this.seacs = this.cff.seacs;
+
+    try {
+      this.data = compiler.compile();
+    } catch (e) {
+      (0, _util.warn)("Failed to compile font " + properties.loadedName);
+      this.data = file;
+    }
+  }
+
+  CFFFont.prototype = {
+    get numGlyphs() {
+      return this.cff.charStrings.count;
+    },
+
+    getCharset: function CFFFont_getCharset() {
+      return this.cff.charset.charset;
+    },
+    getGlyphMapping: function CFFFont_getGlyphMapping() {
+      var cff = this.cff;
+      var properties = this.properties;
+      var charsets = cff.charset.charset;
+      var charCodeToGlyphId;
+      var glyphId;
+
+      if (properties.composite) {
+        charCodeToGlyphId = Object.create(null);
+        let charCode;
+
+        if (cff.isCIDFont) {
+          for (glyphId = 0; glyphId < charsets.length; glyphId++) {
+            var cid = charsets[glyphId];
+            charCode = properties.cMap.charCodeOf(cid);
+            charCodeToGlyphId[charCode] = glyphId;
+          }
+        } else {
+          for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) {
+            charCode = properties.cMap.charCodeOf(glyphId);
+            charCodeToGlyphId[charCode] = glyphId;
+          }
+        }
+
+        return charCodeToGlyphId;
+      }
+
+      var encoding = cff.encoding ? cff.encoding.encoding : null;
+      charCodeToGlyphId = type1FontGlyphMapping(properties, encoding, charsets);
+      return charCodeToGlyphId;
+    },
+    hasGlyphId: function CFFFont_hasGlyphID(id) {
+      return this.cff.hasGlyphId(id);
+    }
+  };
+  return CFFFont;
+}();
+
+/***/ }),
+/* 32 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.CFFTopDict = exports.CFFStrings = exports.CFFStandardStrings = exports.CFFPrivateDict = exports.CFFParser = exports.CFFIndex = exports.CFFHeader = exports.CFFFDSelect = exports.CFFCompiler = exports.CFFCharset = exports.CFF = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _charsets = __w_pdfjs_require__(33);
+
+var _encodings = __w_pdfjs_require__(34);
+
+var MAX_SUBR_NESTING = 10;
+var CFFStandardStrings = [".notdef", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quoteright", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section", "currency", "quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi", "fl", "endash", "dagger", "daggerdbl", "periodcentered", "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright", "guillemotright", "ellipsis", "perthousand", "questiondown", "grave", "acute", "circumflex", "tilde", "macron", "breve", "dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "emdash", "AE", "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine", "ae", "dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior", "logicalnot", "mu", "trademark", "Eth", "onehalf", "plusminus", "Thorn", "onequarter", "divide", "brokenbar", "degree", "thorn", "threequarters", "twosuperior", "registered", "minus", "eth", "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave", "Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis", "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex", "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron", "aacute", "acircumflex", "adieresis", "agrave", "aring", "atilde", "ccedilla", "eacute", "ecircumflex", "edieresis", "egrave", "iacute", "icircumflex", "idieresis", "igrave", "ntilde", "oacute", "ocircumflex", "odieresis", "ograve", "otilde", "scaron", "uacute", "ucircumflex", "udieresis", "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall", "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "commasuperior", "threequartersemdash", "periodsuperior", "questionsmall", "asuperior", "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior", "tsuperior", "ff", "ffi", "ffl", "parenleftinferior", "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall", "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall", "questiondownsmall", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "zerosuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior", "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior", "dollarinferior", "periodinferior", "commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall", "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall", "001.000", "001.001", "001.002", "001.003", "Black", "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold"];
+exports.CFFStandardStrings = CFFStandardStrings;
+const NUM_STANDARD_CFF_STRINGS = 391;
+
+var CFFParser = function CFFParserClosure() {
+  var CharstringValidationData = [null, {
+    id: "hstem",
+    min: 2,
+    stackClearing: true,
+    stem: true
+  }, null, {
+    id: "vstem",
+    min: 2,
+    stackClearing: true,
+    stem: true
+  }, {
+    id: "vmoveto",
+    min: 1,
+    stackClearing: true
+  }, {
+    id: "rlineto",
+    min: 2,
+    resetStack: true
+  }, {
+    id: "hlineto",
+    min: 1,
+    resetStack: true
+  }, {
+    id: "vlineto",
+    min: 1,
+    resetStack: true
+  }, {
+    id: "rrcurveto",
+    min: 6,
+    resetStack: true
+  }, null, {
+    id: "callsubr",
+    min: 1,
+    undefStack: true
+  }, {
+    id: "return",
+    min: 0,
+    undefStack: true
+  }, null, null, {
+    id: "endchar",
+    min: 0,
+    stackClearing: true
+  }, null, null, null, {
+    id: "hstemhm",
+    min: 2,
+    stackClearing: true,
+    stem: true
+  }, {
+    id: "hintmask",
+    min: 0,
+    stackClearing: true
+  }, {
+    id: "cntrmask",
+    min: 0,
+    stackClearing: true
+  }, {
+    id: "rmoveto",
+    min: 2,
+    stackClearing: true
+  }, {
+    id: "hmoveto",
+    min: 1,
+    stackClearing: true
+  }, {
+    id: "vstemhm",
+    min: 2,
+    stackClearing: true,
+    stem: true
+  }, {
+    id: "rcurveline",
+    min: 8,
+    resetStack: true
+  }, {
+    id: "rlinecurve",
+    min: 8,
+    resetStack: true
+  }, {
+    id: "vvcurveto",
+    min: 4,
+    resetStack: true
+  }, {
+    id: "hhcurveto",
+    min: 4,
+    resetStack: true
+  }, null, {
+    id: "callgsubr",
+    min: 1,
+    undefStack: true
+  }, {
+    id: "vhcurveto",
+    min: 4,
+    resetStack: true
+  }, {
+    id: "hvcurveto",
+    min: 4,
+    resetStack: true
+  }];
+  var CharstringValidationData12 = [null, null, null, {
+    id: "and",
+    min: 2,
+    stackDelta: -1
+  }, {
+    id: "or",
+    min: 2,
+    stackDelta: -1
+  }, {
+    id: "not",
+    min: 1,
+    stackDelta: 0
+  }, null, null, null, {
+    id: "abs",
+    min: 1,
+    stackDelta: 0
+  }, {
+    id: "add",
+    min: 2,
+    stackDelta: -1,
+    stackFn: function stack_div(stack, index) {
+      stack[index - 2] = stack[index - 2] + stack[index - 1];
+    }
+  }, {
+    id: "sub",
+    min: 2,
+    stackDelta: -1,
+    stackFn: function stack_div(stack, index) {
+      stack[index - 2] = stack[index - 2] - stack[index - 1];
+    }
+  }, {
+    id: "div",
+    min: 2,
+    stackDelta: -1,
+    stackFn: function stack_div(stack, index) {
+      stack[index - 2] = stack[index - 2] / stack[index - 1];
+    }
+  }, null, {
+    id: "neg",
+    min: 1,
+    stackDelta: 0,
+    stackFn: function stack_div(stack, index) {
+      stack[index - 1] = -stack[index - 1];
+    }
+  }, {
+    id: "eq",
+    min: 2,
+    stackDelta: -1
+  }, null, null, {
+    id: "drop",
+    min: 1,
+    stackDelta: -1
+  }, null, {
+    id: "put",
+    min: 2,
+    stackDelta: -2
+  }, {
+    id: "get",
+    min: 1,
+    stackDelta: 0
+  }, {
+    id: "ifelse",
+    min: 4,
+    stackDelta: -3
+  }, {
+    id: "random",
+    min: 0,
+    stackDelta: 1
+  }, {
+    id: "mul",
+    min: 2,
+    stackDelta: -1,
+    stackFn: function stack_div(stack, index) {
+      stack[index - 2] = stack[index - 2] * stack[index - 1];
+    }
+  }, null, {
+    id: "sqrt",
+    min: 1,
+    stackDelta: 0
+  }, {
+    id: "dup",
+    min: 1,
+    stackDelta: 1
+  }, {
+    id: "exch",
+    min: 2,
+    stackDelta: 0
+  }, {
+    id: "index",
+    min: 2,
+    stackDelta: 0
+  }, {
+    id: "roll",
+    min: 3,
+    stackDelta: -2
+  }, null, null, null, {
+    id: "hflex",
+    min: 7,
+    resetStack: true
+  }, {
+    id: "flex",
+    min: 13,
+    resetStack: true
+  }, {
+    id: "hflex1",
+    min: 9,
+    resetStack: true
+  }, {
+    id: "flex1",
+    min: 11,
+    resetStack: true
+  }];
+
+  class CFFParser {
+    constructor(file, properties, seacAnalysisEnabled) {
+      this.bytes = file.getBytes();
+      this.properties = properties;
+      this.seacAnalysisEnabled = !!seacAnalysisEnabled;
+    }
+
+    parse() {
+      var properties = this.properties;
+      var cff = new CFF();
+      this.cff = cff;
+      var header = this.parseHeader();
+      var nameIndex = this.parseIndex(header.endPos);
+      var topDictIndex = this.parseIndex(nameIndex.endPos);
+      var stringIndex = this.parseIndex(topDictIndex.endPos);
+      var globalSubrIndex = this.parseIndex(stringIndex.endPos);
+      var topDictParsed = this.parseDict(topDictIndex.obj.get(0));
+      var topDict = this.createDict(CFFTopDict, topDictParsed, cff.strings);
+      cff.header = header.obj;
+      cff.names = this.parseNameIndex(nameIndex.obj);
+      cff.strings = this.parseStringIndex(stringIndex.obj);
+      cff.topDict = topDict;
+      cff.globalSubrIndex = globalSubrIndex.obj;
+      this.parsePrivateDict(cff.topDict);
+      cff.isCIDFont = topDict.hasName("ROS");
+      var charStringOffset = topDict.getByName("CharStrings");
+      var charStringIndex = this.parseIndex(charStringOffset).obj;
+      var fontMatrix = topDict.getByName("FontMatrix");
+
+      if (fontMatrix) {
+        properties.fontMatrix = fontMatrix;
+      }
+
+      var fontBBox = topDict.getByName("FontBBox");
+
+      if (fontBBox) {
+        properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
+        properties.descent = Math.min(fontBBox[1], fontBBox[3]);
+        properties.ascentScaled = true;
+      }
+
+      var charset, encoding;
+
+      if (cff.isCIDFont) {
+        var fdArrayIndex = this.parseIndex(topDict.getByName("FDArray")).obj;
+
+        for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) {
+          var dictRaw = fdArrayIndex.get(i);
+          var fontDict = this.createDict(CFFTopDict, this.parseDict(dictRaw), cff.strings);
+          this.parsePrivateDict(fontDict);
+          cff.fdArray.push(fontDict);
+        }
+
+        encoding = null;
+        charset = this.parseCharsets(topDict.getByName("charset"), charStringIndex.count, cff.strings, true);
+        cff.fdSelect = this.parseFDSelect(topDict.getByName("FDSelect"), charStringIndex.count);
+      } else {
+        charset = this.parseCharsets(topDict.getByName("charset"), charStringIndex.count, cff.strings, false);
+        encoding = this.parseEncoding(topDict.getByName("Encoding"), properties, cff.strings, charset.charset);
+      }
+
+      cff.charset = charset;
+      cff.encoding = encoding;
+      var charStringsAndSeacs = this.parseCharStrings({
+        charStrings: charStringIndex,
+        localSubrIndex: topDict.privateDict.subrsIndex,
+        globalSubrIndex: globalSubrIndex.obj,
+        fdSelect: cff.fdSelect,
+        fdArray: cff.fdArray,
+        privateDict: topDict.privateDict
+      });
+      cff.charStrings = charStringsAndSeacs.charStrings;
+      cff.seacs = charStringsAndSeacs.seacs;
+      cff.widths = charStringsAndSeacs.widths;
+      return cff;
+    }
+
+    parseHeader() {
+      var bytes = this.bytes;
+      var bytesLength = bytes.length;
+      var offset = 0;
+
+      while (offset < bytesLength && bytes[offset] !== 1) {
+        ++offset;
+      }
+
+      if (offset >= bytesLength) {
+        throw new _util.FormatError("Invalid CFF header");
+      }
+
+      if (offset !== 0) {
+        (0, _util.info)("cff data is shifted");
+        bytes = bytes.subarray(offset);
+        this.bytes = bytes;
+      }
+
+      var major = bytes[0];
+      var minor = bytes[1];
+      var hdrSize = bytes[2];
+      var offSize = bytes[3];
+      var header = new CFFHeader(major, minor, hdrSize, offSize);
+      return {
+        obj: header,
+        endPos: hdrSize
+      };
+    }
+
+    parseDict(dict) {
+      var pos = 0;
+
+      function parseOperand() {
+        var value = dict[pos++];
+
+        if (value === 30) {
+          return parseFloatOperand();
+        } else if (value === 28) {
+          value = dict[pos++];
+          value = (value << 24 | dict[pos++] << 16) >> 16;
+          return value;
+        } else if (value === 29) {
+          value = dict[pos++];
+          value = value << 8 | dict[pos++];
+          value = value << 8 | dict[pos++];
+          value = value << 8 | dict[pos++];
+          return value;
+        } else if (value >= 32 && value <= 246) {
+          return value - 139;
+        } else if (value >= 247 && value <= 250) {
+          return (value - 247) * 256 + dict[pos++] + 108;
+        } else if (value >= 251 && value <= 254) {
+          return -((value - 251) * 256) - dict[pos++] - 108;
+        }
+
+        (0, _util.warn)('CFFParser_parseDict: "' + value + '" is a reserved command.');
+        return NaN;
+      }
+
+      function parseFloatOperand() {
+        var str = "";
+        var eof = 15;
+        const lookup = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "E", "E-", null, "-"];
+        var length = dict.length;
+
+        while (pos < length) {
+          var b = dict[pos++];
+          var b1 = b >> 4;
+          var b2 = b & 15;
+
+          if (b1 === eof) {
+            break;
+          }
+
+          str += lookup[b1];
+
+          if (b2 === eof) {
+            break;
+          }
+
+          str += lookup[b2];
+        }
+
+        return parseFloat(str);
+      }
+
+      var operands = [];
+      var entries = [];
+      pos = 0;
+      var end = dict.length;
+
+      while (pos < end) {
+        var b = dict[pos];
+
+        if (b <= 21) {
+          if (b === 12) {
+            b = b << 8 | dict[++pos];
+          }
+
+          entries.push([b, operands]);
+          operands = [];
+          ++pos;
+        } else {
+          operands.push(parseOperand());
+        }
+      }
+
+      return entries;
+    }
+
+    parseIndex(pos) {
+      var cffIndex = new CFFIndex();
+      var bytes = this.bytes;
+      var count = bytes[pos++] << 8 | bytes[pos++];
+      var offsets = [];
+      var end = pos;
+      var i, ii;
+
+      if (count !== 0) {
+        var offsetSize = bytes[pos++];
+        var startPos = pos + (count + 1) * offsetSize - 1;
+
+        for (i = 0, ii = count + 1; i < ii; ++i) {
+          var offset = 0;
+
+          for (var j = 0; j < offsetSize; ++j) {
+            offset <<= 8;
+            offset += bytes[pos++];
+          }
+
+          offsets.push(startPos + offset);
+        }
+
+        end = offsets[count];
+      }
+
+      for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
+        var offsetStart = offsets[i];
+        var offsetEnd = offsets[i + 1];
+        cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
+      }
+
+      return {
+        obj: cffIndex,
+        endPos: end
+      };
+    }
+
+    parseNameIndex(index) {
+      var names = [];
+
+      for (var i = 0, ii = index.count; i < ii; ++i) {
+        var name = index.get(i);
+        names.push((0, _util.bytesToString)(name));
+      }
+
+      return names;
+    }
+
+    parseStringIndex(index) {
+      var strings = new CFFStrings();
+
+      for (var i = 0, ii = index.count; i < ii; ++i) {
+        var data = index.get(i);
+        strings.add((0, _util.bytesToString)(data));
+      }
+
+      return strings;
+    }
+
+    createDict(Type, dict, strings) {
+      var cffDict = new Type(strings);
+
+      for (var i = 0, ii = dict.length; i < ii; ++i) {
+        var pair = dict[i];
+        var key = pair[0];
+        var value = pair[1];
+        cffDict.setByKey(key, value);
+      }
+
+      return cffDict;
+    }
+
+    parseCharString(state, data, localSubrIndex, globalSubrIndex) {
+      if (!data || state.callDepth > MAX_SUBR_NESTING) {
+        return false;
+      }
+
+      var stackSize = state.stackSize;
+      var stack = state.stack;
+      var length = data.length;
+
+      for (var j = 0; j < length;) {
+        var value = data[j++];
+        var validationCommand = null;
+
+        if (value === 12) {
+          var q = data[j++];
+
+          if (q === 0) {
+            data[j - 2] = 139;
+            data[j - 1] = 22;
+            stackSize = 0;
+          } else {
+            validationCommand = CharstringValidationData12[q];
+          }
+        } else if (value === 28) {
+          stack[stackSize] = (data[j] << 24 | data[j + 1] << 16) >> 16;
+          j += 2;
+          stackSize++;
+        } else if (value === 14) {
+          if (stackSize >= 4) {
+            stackSize -= 4;
+
+            if (this.seacAnalysisEnabled) {
+              state.seac = stack.slice(stackSize, stackSize + 4);
+              return false;
+            }
+          }
+
+          validationCommand = CharstringValidationData[value];
+        } else if (value >= 32 && value <= 246) {
+          stack[stackSize] = value - 139;
+          stackSize++;
+        } else if (value >= 247 && value <= 254) {
+          stack[stackSize] = value < 251 ? (value - 247 << 8) + data[j] + 108 : -(value - 251 << 8) - data[j] - 108;
+          j++;
+          stackSize++;
+        } else if (value === 255) {
+          stack[stackSize] = (data[j] << 24 | data[j + 1] << 16 | data[j + 2] << 8 | data[j + 3]) / 65536;
+          j += 4;
+          stackSize++;
+        } else if (value === 19 || value === 20) {
+          state.hints += stackSize >> 1;
+          j += state.hints + 7 >> 3;
+          stackSize %= 2;
+          validationCommand = CharstringValidationData[value];
+        } else if (value === 10 || value === 29) {
+          var subrsIndex;
+
+          if (value === 10) {
+            subrsIndex = localSubrIndex;
+          } else {
+            subrsIndex = globalSubrIndex;
+          }
+
+          if (!subrsIndex) {
+            validationCommand = CharstringValidationData[value];
+            (0, _util.warn)("Missing subrsIndex for " + validationCommand.id);
+            return false;
+          }
+
+          var bias = 32768;
+
+          if (subrsIndex.count < 1240) {
+            bias = 107;
+          } else if (subrsIndex.count < 33900) {
+            bias = 1131;
+          }
+
+          var subrNumber = stack[--stackSize] + bias;
+
+          if (subrNumber < 0 || subrNumber >= subrsIndex.count || isNaN(subrNumber)) {
+            validationCommand = CharstringValidationData[value];
+            (0, _util.warn)("Out of bounds subrIndex for " + validationCommand.id);
+            return false;
+          }
+
+          state.stackSize = stackSize;
+          state.callDepth++;
+          var valid = this.parseCharString(state, subrsIndex.get(subrNumber), localSubrIndex, globalSubrIndex);
+
+          if (!valid) {
+            return false;
+          }
+
+          state.callDepth--;
+          stackSize = state.stackSize;
+          continue;
+        } else if (value === 11) {
+          state.stackSize = stackSize;
+          return true;
+        } else {
+          validationCommand = CharstringValidationData[value];
+        }
+
+        if (validationCommand) {
+          if (validationCommand.stem) {
+            state.hints += stackSize >> 1;
+
+            if (value === 3 || value === 23) {
+              state.hasVStems = true;
+            } else if (state.hasVStems && (value === 1 || value === 18)) {
+              (0, _util.warn)("CFF stem hints are in wrong order");
+              data[j - 1] = value === 1 ? 3 : 23;
+            }
+          }
+
+          if ("min" in validationCommand) {
+            if (!state.undefStack && stackSize < validationCommand.min) {
+              (0, _util.warn)("Not enough parameters for " + validationCommand.id + "; actual: " + stackSize + ", expected: " + validationCommand.min);
+              return false;
+            }
+          }
+
+          if (state.firstStackClearing && validationCommand.stackClearing) {
+            state.firstStackClearing = false;
+            stackSize -= validationCommand.min;
+
+            if (stackSize >= 2 && validationCommand.stem) {
+              stackSize %= 2;
+            } else if (stackSize > 1) {
+              (0, _util.warn)("Found too many parameters for stack-clearing command");
+            }
+
+            if (stackSize > 0 && stack[stackSize - 1] >= 0) {
+              state.width = stack[stackSize - 1];
+            }
+          }
+
+          if ("stackDelta" in validationCommand) {
+            if ("stackFn" in validationCommand) {
+              validationCommand.stackFn(stack, stackSize);
+            }
+
+            stackSize += validationCommand.stackDelta;
+          } else if (validationCommand.stackClearing) {
+            stackSize = 0;
+          } else if (validationCommand.resetStack) {
+            stackSize = 0;
+            state.undefStack = false;
+          } else if (validationCommand.undefStack) {
+            stackSize = 0;
+            state.undefStack = true;
+            state.firstStackClearing = false;
+          }
+        }
+      }
+
+      state.stackSize = stackSize;
+      return true;
+    }
+
+    parseCharStrings({
+      charStrings,
+      localSubrIndex,
+      globalSubrIndex,
+      fdSelect,
+      fdArray,
+      privateDict
+    }) {
+      var seacs = [];
+      var widths = [];
+      var count = charStrings.count;
+
+      for (var i = 0; i < count; i++) {
+        var charstring = charStrings.get(i);
+        var state = {
+          callDepth: 0,
+          stackSize: 0,
+          stack: [],
+          undefStack: true,
+          hints: 0,
+          firstStackClearing: true,
+          seac: null,
+          width: null,
+          hasVStems: false
+        };
+        var valid = true;
+        var localSubrToUse = null;
+        var privateDictToUse = privateDict;
+
+        if (fdSelect && fdArray.length) {
+          var fdIndex = fdSelect.getFDIndex(i);
+
+          if (fdIndex === -1) {
+            (0, _util.warn)("Glyph index is not in fd select.");
+            valid = false;
+          }
+
+          if (fdIndex >= fdArray.length) {
+            (0, _util.warn)("Invalid fd index for glyph index.");
+            valid = false;
+          }
+
+          if (valid) {
+            privateDictToUse = fdArray[fdIndex].privateDict;
+            localSubrToUse = privateDictToUse.subrsIndex;
+          }
+        } else if (localSubrIndex) {
+          localSubrToUse = localSubrIndex;
+        }
+
+        if (valid) {
+          valid = this.parseCharString(state, charstring, localSubrToUse, globalSubrIndex);
+        }
+
+        if (state.width !== null) {
+          const nominalWidth = privateDictToUse.getByName("nominalWidthX");
+          widths[i] = nominalWidth + state.width;
+        } else {
+          const defaultWidth = privateDictToUse.getByName("defaultWidthX");
+          widths[i] = defaultWidth;
+        }
+
+        if (state.seac !== null) {
+          seacs[i] = state.seac;
+        }
+
+        if (!valid) {
+          charStrings.set(i, new Uint8Array([14]));
+        }
+      }
+
+      return {
+        charStrings,
+        seacs,
+        widths
+      };
+    }
+
+    emptyPrivateDictionary(parentDict) {
+      var privateDict = this.createDict(CFFPrivateDict, [], parentDict.strings);
+      parentDict.setByKey(18, [0, 0]);
+      parentDict.privateDict = privateDict;
+    }
+
+    parsePrivateDict(parentDict) {
+      if (!parentDict.hasName("Private")) {
+        this.emptyPrivateDictionary(parentDict);
+        return;
+      }
+
+      var privateOffset = parentDict.getByName("Private");
+
+      if (!Array.isArray(privateOffset) || privateOffset.length !== 2) {
+        parentDict.removeByName("Private");
+        return;
+      }
+
+      var size = privateOffset[0];
+      var offset = privateOffset[1];
+
+      if (size === 0 || offset >= this.bytes.length) {
+        this.emptyPrivateDictionary(parentDict);
+        return;
+      }
+
+      var privateDictEnd = offset + size;
+      var dictData = this.bytes.subarray(offset, privateDictEnd);
+      var dict = this.parseDict(dictData);
+      var privateDict = this.createDict(CFFPrivateDict, dict, parentDict.strings);
+      parentDict.privateDict = privateDict;
+
+      if (!privateDict.getByName("Subrs")) {
+        return;
+      }
+
+      var subrsOffset = privateDict.getByName("Subrs");
+      var relativeOffset = offset + subrsOffset;
+
+      if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
+        this.emptyPrivateDictionary(parentDict);
+        return;
+      }
+
+      var subrsIndex = this.parseIndex(relativeOffset);
+      privateDict.subrsIndex = subrsIndex.obj;
+    }
+
+    parseCharsets(pos, length, strings, cid) {
+      if (pos === 0) {
+        return new CFFCharset(true, CFFCharsetPredefinedTypes.ISO_ADOBE, _charsets.ISOAdobeCharset);
+      } else if (pos === 1) {
+        return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT, _charsets.ExpertCharset);
+      } else if (pos === 2) {
+        return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT_SUBSET, _charsets.ExpertSubsetCharset);
+      }
+
+      var bytes = this.bytes;
+      var start = pos;
+      var format = bytes[pos++];
+      const charset = [cid ? 0 : ".notdef"];
+      var id, count, i;
+      length -= 1;
+
+      switch (format) {
+        case 0:
+          for (i = 0; i < length; i++) {
+            id = bytes[pos++] << 8 | bytes[pos++];
+            charset.push(cid ? id : strings.get(id));
+          }
+
+          break;
+
+        case 1:
+          while (charset.length <= length) {
+            id = bytes[pos++] << 8 | bytes[pos++];
+            count = bytes[pos++];
+
+            for (i = 0; i <= count; i++) {
+              charset.push(cid ? id++ : strings.get(id++));
+            }
+          }
+
+          break;
+
+        case 2:
+          while (charset.length <= length) {
+            id = bytes[pos++] << 8 | bytes[pos++];
+            count = bytes[pos++] << 8 | bytes[pos++];
+
+            for (i = 0; i <= count; i++) {
+              charset.push(cid ? id++ : strings.get(id++));
+            }
+          }
+
+          break;
+
+        default:
+          throw new _util.FormatError("Unknown charset format");
+      }
+
+      var end = pos;
+      var raw = bytes.subarray(start, end);
+      return new CFFCharset(false, format, charset, raw);
+    }
+
+    parseEncoding(pos, properties, strings, charset) {
+      var encoding = Object.create(null);
+      var bytes = this.bytes;
+      var predefined = false;
+      var format, i, ii;
+      var raw = null;
+
+      function readSupplement() {
+        var supplementsCount = bytes[pos++];
+
+        for (i = 0; i < supplementsCount; i++) {
+          var code = bytes[pos++];
+          var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
+          encoding[code] = charset.indexOf(strings.get(sid));
+        }
+      }
+
+      if (pos === 0 || pos === 1) {
+        predefined = true;
+        format = pos;
+        var baseEncoding = pos ? _encodings.ExpertEncoding : _encodings.StandardEncoding;
+
+        for (i = 0, ii = charset.length; i < ii; i++) {
+          var index = baseEncoding.indexOf(charset[i]);
+
+          if (index !== -1) {
+            encoding[index] = i;
+          }
+        }
+      } else {
+        var dataStart = pos;
+        format = bytes[pos++];
+
+        switch (format & 0x7f) {
+          case 0:
+            var glyphsCount = bytes[pos++];
+
+            for (i = 1; i <= glyphsCount; i++) {
+              encoding[bytes[pos++]] = i;
+            }
+
+            break;
+
+          case 1:
+            var rangesCount = bytes[pos++];
+            var gid = 1;
+
+            for (i = 0; i < rangesCount; i++) {
+              var start = bytes[pos++];
+              var left = bytes[pos++];
+
+              for (var j = start; j <= start + left; j++) {
+                encoding[j] = gid++;
+              }
+            }
+
+            break;
+
+          default:
+            throw new _util.FormatError(`Unknown encoding format: ${format} in CFF`);
+        }
+
+        var dataEnd = pos;
+
+        if (format & 0x80) {
+          bytes[dataStart] &= 0x7f;
+          readSupplement();
+        }
+
+        raw = bytes.subarray(dataStart, dataEnd);
+      }
+
+      format = format & 0x7f;
+      return new CFFEncoding(predefined, format, encoding, raw);
+    }
+
+    parseFDSelect(pos, length) {
+      var bytes = this.bytes;
+      var format = bytes[pos++];
+      var fdSelect = [];
+      var i;
+
+      switch (format) {
+        case 0:
+          for (i = 0; i < length; ++i) {
+            var id = bytes[pos++];
+            fdSelect.push(id);
+          }
+
+          break;
+
+        case 3:
+          var rangesCount = bytes[pos++] << 8 | bytes[pos++];
+
+          for (i = 0; i < rangesCount; ++i) {
+            var first = bytes[pos++] << 8 | bytes[pos++];
+
+            if (i === 0 && first !== 0) {
+              (0, _util.warn)("parseFDSelect: The first range must have a first GID of 0" + " -- trying to recover.");
+              first = 0;
+            }
+
+            var fdIndex = bytes[pos++];
+            var next = bytes[pos] << 8 | bytes[pos + 1];
+
+            for (var j = first; j < next; ++j) {
+              fdSelect.push(fdIndex);
+            }
+          }
+
+          pos += 2;
+          break;
+
+        default:
+          throw new _util.FormatError(`parseFDSelect: Unknown format "${format}".`);
+      }
+
+      if (fdSelect.length !== length) {
+        throw new _util.FormatError("parseFDSelect: Invalid font data.");
+      }
+
+      return new CFFFDSelect(format, fdSelect);
+    }
+
+  }
+
+  return CFFParser;
+}();
+
+exports.CFFParser = CFFParser;
+
+class CFF {
+  constructor() {
+    this.header = null;
+    this.names = [];
+    this.topDict = null;
+    this.strings = new CFFStrings();
+    this.globalSubrIndex = null;
+    this.encoding = null;
+    this.charset = null;
+    this.charStrings = null;
+    this.fdArray = [];
+    this.fdSelect = null;
+    this.isCIDFont = false;
+  }
+
+  duplicateFirstGlyph() {
+    if (this.charStrings.count >= 65535) {
+      (0, _util.warn)("Not enough space in charstrings to duplicate first glyph.");
+      return;
+    }
+
+    var glyphZero = this.charStrings.get(0);
+    this.charStrings.add(glyphZero);
+
+    if (this.isCIDFont) {
+      this.fdSelect.fdSelect.push(this.fdSelect.fdSelect[0]);
+    }
+  }
+
+  hasGlyphId(id) {
+    if (id < 0 || id >= this.charStrings.count) {
+      return false;
+    }
+
+    var glyph = this.charStrings.get(id);
+    return glyph.length > 0;
+  }
+
+}
+
+exports.CFF = CFF;
+
+class CFFHeader {
+  constructor(major, minor, hdrSize, offSize) {
+    this.major = major;
+    this.minor = minor;
+    this.hdrSize = hdrSize;
+    this.offSize = offSize;
+  }
+
+}
+
+exports.CFFHeader = CFFHeader;
+
+class CFFStrings {
+  constructor() {
+    this.strings = [];
+  }
+
+  get(index) {
+    if (index >= 0 && index <= NUM_STANDARD_CFF_STRINGS - 1) {
+      return CFFStandardStrings[index];
+    }
+
+    if (index - NUM_STANDARD_CFF_STRINGS <= this.strings.length) {
+      return this.strings[index - NUM_STANDARD_CFF_STRINGS];
+    }
+
+    return CFFStandardStrings[0];
+  }
+
+  getSID(str) {
+    let index = CFFStandardStrings.indexOf(str);
+
+    if (index !== -1) {
+      return index;
+    }
+
+    index = this.strings.indexOf(str);
+
+    if (index !== -1) {
+      return index + NUM_STANDARD_CFF_STRINGS;
+    }
+
+    return -1;
+  }
+
+  add(value) {
+    this.strings.push(value);
+  }
+
+  get count() {
+    return this.strings.length;
+  }
+
+}
+
+exports.CFFStrings = CFFStrings;
+
+class CFFIndex {
+  constructor() {
+    this.objects = [];
+    this.length = 0;
+  }
+
+  add(data) {
+    this.length += data.length;
+    this.objects.push(data);
+  }
+
+  set(index, data) {
+    this.length += data.length - this.objects[index].length;
+    this.objects[index] = data;
+  }
+
+  get(index) {
+    return this.objects[index];
+  }
+
+  get count() {
+    return this.objects.length;
+  }
+
+}
+
+exports.CFFIndex = CFFIndex;
+
+class CFFDict {
+  constructor(tables, strings) {
+    this.keyToNameMap = tables.keyToNameMap;
+    this.nameToKeyMap = tables.nameToKeyMap;
+    this.defaults = tables.defaults;
+    this.types = tables.types;
+    this.opcodes = tables.opcodes;
+    this.order = tables.order;
+    this.strings = strings;
+    this.values = Object.create(null);
+  }
+
+  setByKey(key, value) {
+    if (!(key in this.keyToNameMap)) {
+      return false;
+    }
+
+    var valueLength = value.length;
+
+    if (valueLength === 0) {
+      return true;
+    }
+
+    for (var i = 0; i < valueLength; i++) {
+      if (isNaN(value[i])) {
+        (0, _util.warn)('Invalid CFFDict value: "' + value + '" for key "' + key + '".');
+        return true;
+      }
+    }
+
+    var type = this.types[key];
+
+    if (type === "num" || type === "sid" || type === "offset") {
+      value = value[0];
+    }
+
+    this.values[key] = value;
+    return true;
+  }
+
+  setByName(name, value) {
+    if (!(name in this.nameToKeyMap)) {
+      throw new _util.FormatError(`Invalid dictionary name "${name}"`);
+    }
+
+    this.values[this.nameToKeyMap[name]] = value;
+  }
+
+  hasName(name) {
+    return this.nameToKeyMap[name] in this.values;
+  }
+
+  getByName(name) {
+    if (!(name in this.nameToKeyMap)) {
+      throw new _util.FormatError(`Invalid dictionary name ${name}"`);
+    }
+
+    var key = this.nameToKeyMap[name];
+
+    if (!(key in this.values)) {
+      return this.defaults[key];
+    }
+
+    return this.values[key];
+  }
+
+  removeByName(name) {
+    delete this.values[this.nameToKeyMap[name]];
+  }
+
+  static createTables(layout) {
+    var tables = {
+      keyToNameMap: {},
+      nameToKeyMap: {},
+      defaults: {},
+      types: {},
+      opcodes: {},
+      order: []
+    };
+
+    for (var i = 0, ii = layout.length; i < ii; ++i) {
+      var entry = layout[i];
+      var key = Array.isArray(entry[0]) ? (entry[0][0] << 8) + entry[0][1] : entry[0];
+      tables.keyToNameMap[key] = entry[1];
+      tables.nameToKeyMap[entry[1]] = key;
+      tables.types[key] = entry[2];
+      tables.defaults[key] = entry[3];
+      tables.opcodes[key] = Array.isArray(entry[0]) ? entry[0] : [entry[0]];
+      tables.order.push(key);
+    }
+
+    return tables;
+  }
+
+}
+
+var CFFTopDict = function CFFTopDictClosure() {
+  var layout = [[[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], [0, "version", "sid", null], [1, "Notice", "sid", null], [[12, 0], "Copyright", "sid", null], [2, "FullName", "sid", null], [3, "FamilyName", "sid", null], [4, "Weight", "sid", null], [[12, 1], "isFixedPitch", "num", 0], [[12, 2], "ItalicAngle", "num", 0], [[12, 3], "UnderlinePosition", "num", -100], [[12, 4], "UnderlineThickness", "num", 50], [[12, 5], "PaintType", "num", 0], [[12, 6], "CharstringType", "num", 2], [[12, 7], "FontMatrix", ["num", "num", "num", "num", "num", "num"], [0.001, 0, 0, 0.001, 0, 0]], [13, "UniqueID", "num", null], [5, "FontBBox", ["num", "num", "num", "num"], [0, 0, 0, 0]], [[12, 8], "StrokeWidth", "num", 0], [14, "XUID", "array", null], [15, "charset", "offset", 0], [16, "Encoding", "offset", 0], [17, "CharStrings", "offset", 0], [18, "Private", ["offset", "offset"], null], [[12, 21], "PostScript", "sid", null], [[12, 22], "BaseFontName", "sid", null], [[12, 23], "BaseFontBlend", "delta", null], [[12, 31], "CIDFontVersion", "num", 0], [[12, 32], "CIDFontRevision", "num", 0], [[12, 33], "CIDFontType", "num", 0], [[12, 34], "CIDCount", "num", 8720], [[12, 35], "UIDBase", "num", null], [[12, 37], "FDSelect", "offset", null], [[12, 36], "FDArray", "offset", null], [[12, 38], "FontName", "sid", null]];
+  var tables = null;
+
+  class CFFTopDict extends CFFDict {
+    constructor(strings) {
+      if (tables === null) {
+        tables = CFFDict.createTables(layout);
+      }
+
+      super(tables, strings);
+      this.privateDict = null;
+    }
+
+  }
+
+  return CFFTopDict;
+}();
+
+exports.CFFTopDict = CFFTopDict;
+
+var CFFPrivateDict = function CFFPrivateDictClosure() {
+  var layout = [[6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], [8, "FamilyBlues", "delta", null], [9, "FamilyOtherBlues", "delta", null], [[12, 9], "BlueScale", "num", 0.039625], [[12, 10], "BlueShift", "num", 7], [[12, 11], "BlueFuzz", "num", 1], [10, "StdHW", "num", null], [11, "StdVW", "num", null], [[12, 12], "StemSnapH", "delta", null], [[12, 13], "StemSnapV", "delta", null], [[12, 14], "ForceBold", "num", 0], [[12, 17], "LanguageGroup", "num", 0], [[12, 18], "ExpansionFactor", "num", 0.06], [[12, 19], "initialRandomSeed", "num", 0], [20, "defaultWidthX", "num", 0], [21, "nominalWidthX", "num", 0], [19, "Subrs", "offset", null]];
+  var tables = null;
+
+  class CFFPrivateDict extends CFFDict {
+    constructor(strings) {
+      if (tables === null) {
+        tables = CFFDict.createTables(layout);
+      }
+
+      super(tables, strings);
+      this.subrsIndex = null;
+    }
+
+  }
+
+  return CFFPrivateDict;
+}();
+
+exports.CFFPrivateDict = CFFPrivateDict;
+var CFFCharsetPredefinedTypes = {
+  ISO_ADOBE: 0,
+  EXPERT: 1,
+  EXPERT_SUBSET: 2
+};
+
+class CFFCharset {
+  constructor(predefined, format, charset, raw) {
+    this.predefined = predefined;
+    this.format = format;
+    this.charset = charset;
+    this.raw = raw;
+  }
+
+}
+
+exports.CFFCharset = CFFCharset;
+
+class CFFEncoding {
+  constructor(predefined, format, encoding, raw) {
+    this.predefined = predefined;
+    this.format = format;
+    this.encoding = encoding;
+    this.raw = raw;
+  }
+
+}
+
+class CFFFDSelect {
+  constructor(format, fdSelect) {
+    this.format = format;
+    this.fdSelect = fdSelect;
+  }
+
+  getFDIndex(glyphIndex) {
+    if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) {
+      return -1;
+    }
+
+    return this.fdSelect[glyphIndex];
+  }
+
+}
+
+exports.CFFFDSelect = CFFFDSelect;
+
+class CFFOffsetTracker {
+  constructor() {
+    this.offsets = Object.create(null);
+  }
+
+  isTracking(key) {
+    return key in this.offsets;
+  }
+
+  track(key, location) {
+    if (key in this.offsets) {
+      throw new _util.FormatError(`Already tracking location of ${key}`);
+    }
+
+    this.offsets[key] = location;
+  }
+
+  offset(value) {
+    for (var key in this.offsets) {
+      this.offsets[key] += value;
+    }
+  }
+
+  setEntryLocation(key, values, output) {
+    if (!(key in this.offsets)) {
+      throw new _util.FormatError(`Not tracking location of ${key}`);
+    }
+
+    var data = output.data;
+    var dataOffset = this.offsets[key];
+    var size = 5;
+
+    for (var i = 0, ii = values.length; i < ii; ++i) {
+      var offset0 = i * size + dataOffset;
+      var offset1 = offset0 + 1;
+      var offset2 = offset0 + 2;
+      var offset3 = offset0 + 3;
+      var offset4 = offset0 + 4;
+
+      if (data[offset0] !== 0x1d || data[offset1] !== 0 || data[offset2] !== 0 || data[offset3] !== 0 || data[offset4] !== 0) {
+        throw new _util.FormatError("writing to an offset that is not empty");
+      }
+
+      var value = values[i];
+      data[offset0] = 0x1d;
+      data[offset1] = value >> 24 & 0xff;
+      data[offset2] = value >> 16 & 0xff;
+      data[offset3] = value >> 8 & 0xff;
+      data[offset4] = value & 0xff;
+    }
+  }
+
+}
+
+class CFFCompiler {
+  constructor(cff) {
+    this.cff = cff;
+  }
+
+  compile() {
+    var cff = this.cff;
+    var output = {
+      data: [],
+      length: 0,
+      add: function CFFCompiler_add(data) {
+        this.data = this.data.concat(data);
+        this.length = this.data.length;
+      }
+    };
+    var header = this.compileHeader(cff.header);
+    output.add(header);
+    var nameIndex = this.compileNameIndex(cff.names);
+    output.add(nameIndex);
+
+    if (cff.isCIDFont) {
+      if (cff.topDict.hasName("FontMatrix")) {
+        var base = cff.topDict.getByName("FontMatrix");
+        cff.topDict.removeByName("FontMatrix");
+
+        for (var i = 0, ii = cff.fdArray.length; i < ii; i++) {
+          var subDict = cff.fdArray[i];
+          var matrix = base.slice(0);
+
+          if (subDict.hasName("FontMatrix")) {
+            matrix = _util.Util.transform(matrix, subDict.getByName("FontMatrix"));
+          }
+
+          subDict.setByName("FontMatrix", matrix);
+        }
+      }
+    }
+
+    const xuid = cff.topDict.getByName("XUID");
+
+    if (xuid && xuid.length > 16) {
+      cff.topDict.removeByName("XUID");
+    }
+
+    cff.topDict.setByName("charset", 0);
+    var compiled = this.compileTopDicts([cff.topDict], output.length, cff.isCIDFont);
+    output.add(compiled.output);
+    var topDictTracker = compiled.trackers[0];
+    var stringIndex = this.compileStringIndex(cff.strings.strings);
+    output.add(stringIndex);
+    var globalSubrIndex = this.compileIndex(cff.globalSubrIndex);
+    output.add(globalSubrIndex);
+
+    if (cff.encoding && cff.topDict.hasName("Encoding")) {
+      if (cff.encoding.predefined) {
+        topDictTracker.setEntryLocation("Encoding", [cff.encoding.format], output);
+      } else {
+        var encoding = this.compileEncoding(cff.encoding);
+        topDictTracker.setEntryLocation("Encoding", [output.length], output);
+        output.add(encoding);
+      }
+    }
+
+    var charset = this.compileCharset(cff.charset, cff.charStrings.count, cff.strings, cff.isCIDFont);
+    topDictTracker.setEntryLocation("charset", [output.length], output);
+    output.add(charset);
+    var charStrings = this.compileCharStrings(cff.charStrings);
+    topDictTracker.setEntryLocation("CharStrings", [output.length], output);
+    output.add(charStrings);
+
+    if (cff.isCIDFont) {
+      topDictTracker.setEntryLocation("FDSelect", [output.length], output);
+      var fdSelect = this.compileFDSelect(cff.fdSelect);
+      output.add(fdSelect);
+      compiled = this.compileTopDicts(cff.fdArray, output.length, true);
+      topDictTracker.setEntryLocation("FDArray", [output.length], output);
+      output.add(compiled.output);
+      var fontDictTrackers = compiled.trackers;
+      this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);
+    }
+
+    this.compilePrivateDicts([cff.topDict], [topDictTracker], output);
+    output.add([0]);
+    return output.data;
+  }
+
+  encodeNumber(value) {
+    if (Number.isInteger(value)) {
+      return this.encodeInteger(value);
+    }
+
+    return this.encodeFloat(value);
+  }
+
+  static get EncodeFloatRegExp() {
+    return (0, _util.shadow)(this, "EncodeFloatRegExp", /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/);
+  }
+
+  encodeFloat(num) {
+    var value = num.toString();
+    var m = CFFCompiler.EncodeFloatRegExp.exec(value);
+
+    if (m) {
+      var epsilon = parseFloat("1e" + ((m[2] ? +m[2] : 0) + m[1].length));
+      value = (Math.round(num * epsilon) / epsilon).toString();
+    }
+
+    var nibbles = "";
+    var i, ii;
+
+    for (i = 0, ii = value.length; i < ii; ++i) {
+      var a = value[i];
+
+      if (a === "e") {
+        nibbles += value[++i] === "-" ? "c" : "b";
+      } else if (a === ".") {
+        nibbles += "a";
+      } else if (a === "-") {
+        nibbles += "e";
+      } else {
+        nibbles += a;
+      }
+    }
+
+    nibbles += nibbles.length & 1 ? "f" : "ff";
+    var out = [30];
+
+    for (i = 0, ii = nibbles.length; i < ii; i += 2) {
+      out.push(parseInt(nibbles.substring(i, i + 2), 16));
+    }
+
+    return out;
+  }
+
+  encodeInteger(value) {
+    var code;
+
+    if (value >= -107 && value <= 107) {
+      code = [value + 139];
+    } else if (value >= 108 && value <= 1131) {
+      value = value - 108;
+      code = [(value >> 8) + 247, value & 0xff];
+    } else if (value >= -1131 && value <= -108) {
+      value = -value - 108;
+      code = [(value >> 8) + 251, value & 0xff];
+    } else if (value >= -32768 && value <= 32767) {
+      code = [0x1c, value >> 8 & 0xff, value & 0xff];
+    } else {
+      code = [0x1d, value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff];
+    }
+
+    return code;
+  }
+
+  compileHeader(header) {
+    return [header.major, header.minor, header.hdrSize, header.offSize];
+  }
+
+  compileNameIndex(names) {
+    var nameIndex = new CFFIndex();
+
+    for (var i = 0, ii = names.length; i < ii; ++i) {
+      var name = names[i];
+      var length = Math.min(name.length, 127);
+      var sanitizedName = new Array(length);
+
+      for (var j = 0; j < length; j++) {
+        var char = name[j];
+
+        if (char < "!" || char > "~" || char === "[" || char === "]" || char === "(" || char === ")" || char === "{" || char === "}" || char === "<" || char === ">" || char === "/" || char === "%") {
+          char = "_";
+        }
+
+        sanitizedName[j] = char;
+      }
+
+      sanitizedName = sanitizedName.join("");
+
+      if (sanitizedName === "") {
+        sanitizedName = "Bad_Font_Name";
+      }
+
+      nameIndex.add((0, _util.stringToBytes)(sanitizedName));
+    }
+
+    return this.compileIndex(nameIndex);
+  }
+
+  compileTopDicts(dicts, length, removeCidKeys) {
+    var fontDictTrackers = [];
+    var fdArrayIndex = new CFFIndex();
+
+    for (var i = 0, ii = dicts.length; i < ii; ++i) {
+      var fontDict = dicts[i];
+
+      if (removeCidKeys) {
+        fontDict.removeByName("CIDFontVersion");
+        fontDict.removeByName("CIDFontRevision");
+        fontDict.removeByName("CIDFontType");
+        fontDict.removeByName("CIDCount");
+        fontDict.removeByName("UIDBase");
+      }
+
+      var fontDictTracker = new CFFOffsetTracker();
+      var fontDictData = this.compileDict(fontDict, fontDictTracker);
+      fontDictTrackers.push(fontDictTracker);
+      fdArrayIndex.add(fontDictData);
+      fontDictTracker.offset(length);
+    }
+
+    fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);
+    return {
+      trackers: fontDictTrackers,
+      output: fdArrayIndex
+    };
+  }
+
+  compilePrivateDicts(dicts, trackers, output) {
+    for (var i = 0, ii = dicts.length; i < ii; ++i) {
+      var fontDict = dicts[i];
+      var privateDict = fontDict.privateDict;
+
+      if (!privateDict || !fontDict.hasName("Private")) {
+        throw new _util.FormatError("There must be a private dictionary.");
+      }
+
+      var privateDictTracker = new CFFOffsetTracker();
+      var privateDictData = this.compileDict(privateDict, privateDictTracker);
+      var outputLength = output.length;
+      privateDictTracker.offset(outputLength);
+
+      if (!privateDictData.length) {
+        outputLength = 0;
+      }
+
+      trackers[i].setEntryLocation("Private", [privateDictData.length, outputLength], output);
+      output.add(privateDictData);
+
+      if (privateDict.subrsIndex && privateDict.hasName("Subrs")) {
+        var subrs = this.compileIndex(privateDict.subrsIndex);
+        privateDictTracker.setEntryLocation("Subrs", [privateDictData.length], output);
+        output.add(subrs);
+      }
+    }
+  }
+
+  compileDict(dict, offsetTracker) {
+    var out = [];
+    var order = dict.order;
+
+    for (var i = 0; i < order.length; ++i) {
+      var key = order[i];
+
+      if (!(key in dict.values)) {
+        continue;
+      }
+
+      var values = dict.values[key];
+      var types = dict.types[key];
+
+      if (!Array.isArray(types)) {
+        types = [types];
+      }
+
+      if (!Array.isArray(values)) {
+        values = [values];
+      }
+
+      if (values.length === 0) {
+        continue;
+      }
+
+      for (var j = 0, jj = types.length; j < jj; ++j) {
+        var type = types[j];
+        var value = values[j];
+
+        switch (type) {
+          case "num":
+          case "sid":
+            out = out.concat(this.encodeNumber(value));
+            break;
+
+          case "offset":
+            var name = dict.keyToNameMap[key];
+
+            if (!offsetTracker.isTracking(name)) {
+              offsetTracker.track(name, out.length);
+            }
+
+            out = out.concat([0x1d, 0, 0, 0, 0]);
+            break;
+
+          case "array":
+          case "delta":
+            out = out.concat(this.encodeNumber(value));
+
+            for (var k = 1, kk = values.length; k < kk; ++k) {
+              out = out.concat(this.encodeNumber(values[k]));
+            }
+
+            break;
+
+          default:
+            throw new _util.FormatError(`Unknown data type of ${type}`);
+        }
+      }
+
+      out = out.concat(dict.opcodes[key]);
+    }
+
+    return out;
+  }
+
+  compileStringIndex(strings) {
+    var stringIndex = new CFFIndex();
+
+    for (var i = 0, ii = strings.length; i < ii; ++i) {
+      stringIndex.add((0, _util.stringToBytes)(strings[i]));
+    }
+
+    return this.compileIndex(stringIndex);
+  }
+
+  compileGlobalSubrIndex() {
+    var globalSubrIndex = this.cff.globalSubrIndex;
+    this.out.writeByteArray(this.compileIndex(globalSubrIndex));
+  }
+
+  compileCharStrings(charStrings) {
+    var charStringsIndex = new CFFIndex();
+
+    for (var i = 0; i < charStrings.count; i++) {
+      var glyph = charStrings.get(i);
+
+      if (glyph.length === 0) {
+        charStringsIndex.add(new Uint8Array([0x8b, 0x0e]));
+        continue;
+      }
+
+      charStringsIndex.add(glyph);
+    }
+
+    return this.compileIndex(charStringsIndex);
+  }
+
+  compileCharset(charset, numGlyphs, strings, isCIDFont) {
+    let out;
+    const numGlyphsLessNotDef = numGlyphs - 1;
+
+    if (isCIDFont) {
+      out = new Uint8Array([2, 0, 0, numGlyphsLessNotDef >> 8 & 0xff, numGlyphsLessNotDef & 0xff]);
+    } else {
+      const length = 1 + numGlyphsLessNotDef * 2;
+      out = new Uint8Array(length);
+      out[0] = 0;
+      let charsetIndex = 0;
+      const numCharsets = charset.charset.length;
+      let warned = false;
+
+      for (let i = 1; i < out.length; i += 2) {
+        let sid = 0;
+
+        if (charsetIndex < numCharsets) {
+          const name = charset.charset[charsetIndex++];
+          sid = strings.getSID(name);
+
+          if (sid === -1) {
+            sid = 0;
+
+            if (!warned) {
+              warned = true;
+              (0, _util.warn)(`Couldn't find ${name} in CFF strings`);
+            }
+          }
+        }
+
+        out[i] = sid >> 8 & 0xff;
+        out[i + 1] = sid & 0xff;
+      }
+    }
+
+    return this.compileTypedArray(out);
+  }
+
+  compileEncoding(encoding) {
+    return this.compileTypedArray(encoding.raw);
+  }
+
+  compileFDSelect(fdSelect) {
+    const format = fdSelect.format;
+    let out, i;
+
+    switch (format) {
+      case 0:
+        out = new Uint8Array(1 + fdSelect.fdSelect.length);
+        out[0] = format;
+
+        for (i = 0; i < fdSelect.fdSelect.length; i++) {
+          out[i + 1] = fdSelect.fdSelect[i];
+        }
+
+        break;
+
+      case 3:
+        const start = 0;
+        let lastFD = fdSelect.fdSelect[0];
+        const ranges = [format, 0, 0, start >> 8 & 0xff, start & 0xff, lastFD];
+
+        for (i = 1; i < fdSelect.fdSelect.length; i++) {
+          const currentFD = fdSelect.fdSelect[i];
+
+          if (currentFD !== lastFD) {
+            ranges.push(i >> 8 & 0xff, i & 0xff, currentFD);
+            lastFD = currentFD;
+          }
+        }
+
+        const numRanges = (ranges.length - 3) / 3;
+        ranges[1] = numRanges >> 8 & 0xff;
+        ranges[2] = numRanges & 0xff;
+        ranges.push(i >> 8 & 0xff, i & 0xff);
+        out = new Uint8Array(ranges);
+        break;
+    }
+
+    return this.compileTypedArray(out);
+  }
+
+  compileTypedArray(data) {
+    var out = [];
+
+    for (var i = 0, ii = data.length; i < ii; ++i) {
+      out[i] = data[i];
+    }
+
+    return out;
+  }
+
+  compileIndex(index, trackers = []) {
+    var objects = index.objects;
+    var count = objects.length;
+
+    if (count === 0) {
+      return [0, 0, 0];
+    }
+
+    var data = [count >> 8 & 0xff, count & 0xff];
+    var lastOffset = 1,
+        i;
+
+    for (i = 0; i < count; ++i) {
+      lastOffset += objects[i].length;
+    }
+
+    var offsetSize;
+
+    if (lastOffset < 0x100) {
+      offsetSize = 1;
+    } else if (lastOffset < 0x10000) {
+      offsetSize = 2;
+    } else if (lastOffset < 0x1000000) {
+      offsetSize = 3;
+    } else {
+      offsetSize = 4;
+    }
+
+    data.push(offsetSize);
+    var relativeOffset = 1;
+
+    for (i = 0; i < count + 1; i++) {
+      if (offsetSize === 1) {
+        data.push(relativeOffset & 0xff);
+      } else if (offsetSize === 2) {
+        data.push(relativeOffset >> 8 & 0xff, relativeOffset & 0xff);
+      } else if (offsetSize === 3) {
+        data.push(relativeOffset >> 16 & 0xff, relativeOffset >> 8 & 0xff, relativeOffset & 0xff);
+      } else {
+        data.push(relativeOffset >>> 24 & 0xff, relativeOffset >> 16 & 0xff, relativeOffset >> 8 & 0xff, relativeOffset & 0xff);
+      }
+
+      if (objects[i]) {
+        relativeOffset += objects[i].length;
+      }
+    }
+
+    for (i = 0; i < count; i++) {
+      if (trackers[i]) {
+        trackers[i].offset(data.length);
+      }
+
+      for (var j = 0, jj = objects[i].length; j < jj; j++) {
+        data.push(objects[i][j]);
+      }
+    }
+
+    return data;
+  }
+
+}
+
+exports.CFFCompiler = CFFCompiler;
+
+/***/ }),
+/* 33 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ISOAdobeCharset = exports.ExpertSubsetCharset = exports.ExpertCharset = void 0;
+const ISOAdobeCharset = [".notdef", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quoteright", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section", "currency", "quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi", "fl", "endash", "dagger", "daggerdbl", "periodcentered", "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright", "guillemotright", "ellipsis", "perthousand", "questiondown", "grave", "acute", "circumflex", "tilde", "macron", "breve", "dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "emdash", "AE", "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine", "ae", "dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior", "logicalnot", "mu", "trademark", "Eth", "onehalf", "plusminus", "Thorn", "onequarter", "divide", "brokenbar", "degree", "thorn", "threequarters", "twosuperior", "registered", "minus", "eth", "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave", "Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis", "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex", "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron", "aacute", "acircumflex", "adieresis", "agrave", "aring", "atilde", "ccedilla", "eacute", "ecircumflex", "edieresis", "egrave", "iacute", "icircumflex", "idieresis", "igrave", "ntilde", "oacute", "ocircumflex", "odieresis", "ograve", "otilde", "scaron", "uacute", "ucircumflex", "udieresis", "ugrave", "yacute", "ydieresis", "zcaron"];
+exports.ISOAdobeCharset = ISOAdobeCharset;
+const ExpertCharset = [".notdef", "space", "exclamsmall", "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "comma", "hyphen", "period", "fraction", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "colon", "semicolon", "commasuperior", "threequartersemdash", "periodsuperior", "questionsmall", "asuperior", "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior", "tsuperior", "ff", "fi", "fl", "ffi", "ffl", "parenleftinferior", "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall", "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall", "onequarter", "onehalf", "threequarters", "questiondownsmall", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "zerosuperior", "onesuperior", "twosuperior", "threesuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior", "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior", "dollarinferior", "periodinferior", "commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall", "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall"];
+exports.ExpertCharset = ExpertCharset;
+const ExpertSubsetCharset = [".notdef", "space", "dollaroldstyle", "dollarsuperior", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "comma", "hyphen", "period", "fraction", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "colon", "semicolon", "commasuperior", "threequartersemdash", "periodsuperior", "asuperior", "bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior", "tsuperior", "ff", "fi", "fl", "ffi", "ffl", "parenleftinferior", "parenrightinferior", "hyphensuperior", "colonmonetary", "onefitted", "rupiah", "centoldstyle", "figuredash", "hypheninferior", "onequarter", "onehalf", "threequarters", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "zerosuperior", "onesuperior", "twosuperior", "threesuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior", "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior", "dollarinferior", "periodinferior", "commainferior"];
+exports.ExpertSubsetCharset = ExpertSubsetCharset;
+
+/***/ }),
+/* 34 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getEncoding = getEncoding;
+exports.ZapfDingbatsEncoding = exports.WinAnsiEncoding = exports.SymbolSetEncoding = exports.StandardEncoding = exports.MacRomanEncoding = exports.ExpertEncoding = void 0;
+const ExpertEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclamsmall", "Hungarumlautsmall", "", "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "comma", "hyphen", "period", "fraction", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "colon", "semicolon", "commasuperior", "threequartersemdash", "periodsuperior", "questionsmall", "", "asuperior", "bsuperior", "centsuperior", "dsuperior", "esuperior", "", "", "", "isuperior", "", "", "lsuperior", "msuperior", "nsuperior", "osuperior", "", "", "rsuperior", "ssuperior", "tsuperior", "", "ff", "fi", "fl", "ffi", "ffl", "parenleftinferior", "", "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "exclamdownsmall", "centoldstyle", "Lslashsmall", "", "", "Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall", "", "Dotaccentsmall", "", "", "Macronsmall", "", "", "figuredash", "hypheninferior", "", "", "Ogoneksmall", "Ringsmall", "Cedillasmall", "", "", "", "onequarter", "onehalf", "threequarters", "questiondownsmall", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "", "", "zerosuperior", "onesuperior", "twosuperior", "threesuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior", "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior", "dollarinferior", "periodinferior", "commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall", "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall"];
+exports.ExpertEncoding = ExpertEncoding;
+const MacExpertEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclamsmall", "Hungarumlautsmall", "centoldstyle", "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "comma", "hyphen", "period", "fraction", "zerooldstyle", "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle", "colon", "semicolon", "", "threequartersemdash", "", "questionsmall", "", "", "", "", "Ethsmall", "", "", "onequarter", "onehalf", "threequarters", "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "", "", "", "", "", "", "ff", "fi", "fl", "ffi", "ffl", "parenleftinferior", "", "parenrightinferior", "Circumflexsmall", "hypheninferior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall", "", "", "asuperior", "centsuperior", "", "", "", "", "Aacutesmall", "Agravesmall", "Acircumflexsmall", "Adieresissmall", "Atildesmall", "Aringsmall", "Ccedillasmall", "Eacutesmall", "Egravesmall", "Ecircumflexsmall", "Edieresissmall", "Iacutesmall", "Igravesmall", "Icircumflexsmall", "Idieresissmall", "Ntildesmall", "Oacutesmall", "Ogravesmall", "Ocircumflexsmall", "Odieresissmall", "Otildesmall", "Uacutesmall", "Ugravesmall", "Ucircumflexsmall", "Udieresissmall", "", "eightsuperior", "fourinferior", "threeinferior", "sixinferior", "eightinferior", "seveninferior", "Scaronsmall", "", "centinferior", "twoinferior", "", "Dieresissmall", "", "Caronsmall", "osuperior", "fiveinferior", "", "commainferior", "periodinferior", "Yacutesmall", "", "dollarinferior", "", "", "Thornsmall", "", "nineinferior", "zeroinferior", "Zcaronsmall", "AEsmall", "Oslashsmall", "questiondownsmall", "oneinferior", "Lslashsmall", "", "", "", "", "", "", "Cedillasmall", "", "", "", "", "", "OEsmall", "figuredash", "hyphensuperior", "", "", "", "", "exclamdownsmall", "", "Ydieresissmall", "", "onesuperior", "twosuperior", "threesuperior", "foursuperior", "fivesuperior", "sixsuperior", "sevensuperior", "ninesuperior", "zerosuperior", "", "esuperior", "rsuperior", "tsuperior", "", "", "isuperior", "ssuperior", "dsuperior", "", "", "", "", "", "lsuperior", "Ogoneksmall", "Brevesmall", "Macronsmall", "bsuperior", "nsuperior", "msuperior", "commasuperior", "periodsuperior", "Dotaccentsmall", "Ringsmall", "", "", "", ""];
+const MacRomanEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quotesingle", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "grave", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "", "Adieresis", "Aring", "Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis", "aacute", "agrave", "acircumflex", "adieresis", "atilde", "aring", "ccedilla", "eacute", "egrave", "ecircumflex", "edieresis", "iacute", "igrave", "icircumflex", "idieresis", "ntilde", "oacute", "ograve", "ocircumflex", "odieresis", "otilde", "uacute", "ugrave", "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling", "section", "bullet", "paragraph", "germandbls", "registered", "copyright", "trademark", "acute", "dieresis", "notequal", "AE", "Oslash", "infinity", "plusminus", "lessequal", "greaterequal", "yen", "mu", "partialdiff", "summation", "product", "pi", "integral", "ordfeminine", "ordmasculine", "Omega", "ae", "oslash", "questiondown", "exclamdown", "logicalnot", "radical", "florin", "approxequal", "Delta", "guillemotleft", "guillemotright", "ellipsis", "space", "Agrave", "Atilde", "Otilde", "OE", "oe", "endash", "emdash", "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide", "lozenge", "ydieresis", "Ydieresis", "fraction", "currency", "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl", "periodcentered", "quotesinglbase", "quotedblbase", "perthousand", "Acircumflex", "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex", "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi", "circumflex", "tilde", "macron", "breve", "dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek", "caron"];
+exports.MacRomanEncoding = MacRomanEncoding;
+const StandardEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quoteright", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section", "currency", "quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi", "fl", "", "endash", "dagger", "daggerdbl", "periodcentered", "", "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright", "guillemotright", "ellipsis", "perthousand", "", "questiondown", "", "grave", "acute", "circumflex", "tilde", "macron", "breve", "dotaccent", "dieresis", "", "ring", "cedilla", "", "hungarumlaut", "ogonek", "caron", "emdash", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "AE", "", "ordfeminine", "", "", "", "", "Lslash", "Oslash", "OE", "ordmasculine", "", "", "", "", "", "ae", "", "", "", "dotlessi", "", "", "lslash", "oslash", "oe", "germandbls", "", "", "", ""];
+exports.StandardEncoding = StandardEncoding;
+const WinAnsiEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quotesingle", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore", "grave", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "bullet", "Euro", "bullet", "quotesinglbase", "florin", "quotedblbase", "ellipsis", "dagger", "daggerdbl", "circumflex", "perthousand", "Scaron", "guilsinglleft", "OE", "bullet", "Zcaron", "bullet", "bullet", "quoteleft", "quoteright", "quotedblleft", "quotedblright", "bullet", "endash", "emdash", "tilde", "trademark", "scaron", "guilsinglright", "oe", "bullet", "zcaron", "Ydieresis", "space", "exclamdown", "cent", "sterling", "currency", "yen", "brokenbar", "section", "dieresis", "copyright", "ordfeminine", "guillemotleft", "logicalnot", "hyphen", "registered", "macron", "degree", "plusminus", "twosuperior", "threesuperior", "acute", "mu", "paragraph", "periodcentered", "cedilla", "onesuperior", "ordmasculine", "guillemotright", "onequarter", "onehalf", "threequarters", "questiondown", "Agrave", "Aacute", "Acircumflex", "Atilde", "Adieresis", "Aring", "AE", "Ccedilla", "Egrave", "Eacute", "Ecircumflex", "Edieresis", "Igrave", "Iacute", "Icircumflex", "Idieresis", "Eth", "Ntilde", "Ograve", "Oacute", "Ocircumflex", "Otilde", "Odieresis", "multiply", "Oslash", "Ugrave", "Uacute", "Ucircumflex", "Udieresis", "Yacute", "Thorn", "germandbls", "agrave", "aacute", "acircumflex", "atilde", "adieresis", "aring", "ae", "ccedilla", "egrave", "eacute", "ecircumflex", "edieresis", "igrave", "iacute", "icircumflex", "idieresis", "eth", "ntilde", "ograve", "oacute", "ocircumflex", "otilde", "odieresis", "divide", "oslash", "ugrave", "uacute", "ucircumflex", "udieresis", "yacute", "thorn", "ydieresis"];
+exports.WinAnsiEncoding = WinAnsiEncoding;
+const SymbolSetEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "exclam", "universal", "numbersign", "existential", "percent", "ampersand", "suchthat", "parenleft", "parenright", "asteriskmath", "plus", "comma", "minus", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question", "congruent", "Alpha", "Beta", "Chi", "Delta", "Epsilon", "Phi", "Gamma", "Eta", "Iota", "theta1", "Kappa", "Lambda", "Mu", "Nu", "Omicron", "Pi", "Theta", "Rho", "Sigma", "Tau", "Upsilon", "sigma1", "Omega", "Xi", "Psi", "Zeta", "bracketleft", "therefore", "bracketright", "perpendicular", "underscore", "radicalex", "alpha", "beta", "chi", "delta", "epsilon", "phi", "gamma", "eta", "iota", "phi1", "kappa", "lambda", "mu", "nu", "omicron", "pi", "theta", "rho", "sigma", "tau", "upsilon", "omega1", "omega", "xi", "psi", "zeta", "braceleft", "bar", "braceright", "similar", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Euro", "Upsilon1", "minute", "lessequal", "fraction", "infinity", "florin", "club", "diamond", "heart", "spade", "arrowboth", "arrowleft", "arrowup", "arrowright", "arrowdown", "degree", "plusminus", "second", "greaterequal", "multiply", "proportional", "partialdiff", "bullet", "divide", "notequal", "equivalence", "approxequal", "ellipsis", "arrowvertex", "arrowhorizex", "carriagereturn", "aleph", "Ifraktur", "Rfraktur", "weierstrass", "circlemultiply", "circleplus", "emptyset", "intersection", "union", "propersuperset", "reflexsuperset", "notsubset", "propersubset", "reflexsubset", "element", "notelement", "angle", "gradient", "registerserif", "copyrightserif", "trademarkserif", "product", "radical", "dotmath", "logicalnot", "logicaland", "logicalor", "arrowdblboth", "arrowdblleft", "arrowdblup", "arrowdblright", "arrowdbldown", "lozenge", "angleleft", "registersans", "copyrightsans", "trademarksans", "summation", "parenlefttp", "parenleftex", "parenleftbt", "bracketlefttp", "bracketleftex", "bracketleftbt", "bracelefttp", "braceleftmid", "braceleftbt", "braceex", "", "angleright", "integral", "integraltp", "integralex", "integralbt", "parenrighttp", "parenrightex", "parenrightbt", "bracketrighttp", "bracketrightex", "bracketrightbt", "bracerighttp", "bracerightmid", "bracerightbt", ""];
+exports.SymbolSetEncoding = SymbolSetEncoding;
+const ZapfDingbatsEncoding = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "space", "a1", "a2", "a202", "a3", "a4", "a5", "a119", "a118", "a117", "a11", "a12", "a13", "a14", "a15", "a16", "a105", "a17", "a18", "a19", "a20", "a21", "a22", "a23", "a24", "a25", "a26", "a27", "a28", "a6", "a7", "a8", "a9", "a10", "a29", "a30", "a31", "a32", "a33", "a34", "a35", "a36", "a37", "a38", "a39", "a40", "a41", "a42", "a43", "a44", "a45", "a46", "a47", "a48", "a49", "a50", "a51", "a52", "a53", "a54", "a55", "a56", "a57", "a58", "a59", "a60", "a61", "a62", "a63", "a64", "a65", "a66", "a67", "a68", "a69", "a70", "a71", "a72", "a73", "a74", "a203", "a75", "a204", "a76", "a77", "a78", "a79", "a81", "a82", "a83", "a84", "a97", "a98", "a99", "a100", "", "a89", "a90", "a93", "a94", "a91", "a92", "a205", "a85", "a206", "a86", "a87", "a88", "a95", "a96", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "a101", "a102", "a103", "a104", "a106", "a107", "a108", "a112", "a111", "a110", "a109", "a120", "a121", "a122", "a123", "a124", "a125", "a126", "a127", "a128", "a129", "a130", "a131", "a132", "a133", "a134", "a135", "a136", "a137", "a138", "a139", "a140", "a141", "a142", "a143", "a144", "a145", "a146", "a147", "a148", "a149", "a150", "a151", "a152", "a153", "a154", "a155", "a156", "a157", "a158", "a159", "a160", "a161", "a163", "a164", "a196", "a165", "a192", "a166", "a167", "a168", "a169", "a170", "a171", "a172", "a173", "a162", "a174", "a175", "a176", "a177", "a178", "a179", "a193", "a180", "a199", "a181", "a200", "a182", "", "a201", "a183", "a184", "a197", "a185", "a194", "a198", "a186", "a195", "a187", "a188", "a189", "a190", "a191", ""];
+exports.ZapfDingbatsEncoding = ZapfDingbatsEncoding;
+
+function getEncoding(encodingName) {
+  switch (encodingName) {
+    case "WinAnsiEncoding":
+      return WinAnsiEncoding;
+
+    case "StandardEncoding":
+      return StandardEncoding;
+
+    case "MacRomanEncoding":
+      return MacRomanEncoding;
+
+    case "SymbolSetEncoding":
+      return SymbolSetEncoding;
+
+    case "ZapfDingbatsEncoding":
+      return ZapfDingbatsEncoding;
+
+    case "ExpertEncoding":
+      return ExpertEncoding;
+
+    case "MacExpertEncoding":
+      return MacExpertEncoding;
+
+    default:
+      return null;
+  }
+}
+
+/***/ }),
+/* 35 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getGlyphsUnicode = exports.getDingbatsGlyphsUnicode = void 0;
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var getGlyphsUnicode = (0, _core_utils.getArrayLookupTableFactory)(function () {
+  return ["A", 0x0041, "AE", 0x00c6, "AEacute", 0x01fc, "AEmacron", 0x01e2, "AEsmall", 0xf7e6, "Aacute", 0x00c1, "Aacutesmall", 0xf7e1, "Abreve", 0x0102, "Abreveacute", 0x1eae, "Abrevecyrillic", 0x04d0, "Abrevedotbelow", 0x1eb6, "Abrevegrave", 0x1eb0, "Abrevehookabove", 0x1eb2, "Abrevetilde", 0x1eb4, "Acaron", 0x01cd, "Acircle", 0x24b6, "Acircumflex", 0x00c2, "Acircumflexacute", 0x1ea4, "Acircumflexdotbelow", 0x1eac, "Acircumflexgrave", 0x1ea6, "Acircumflexhookabove", 0x1ea8, "Acircumflexsmall", 0xf7e2, "Acircumflextilde", 0x1eaa, "Acute", 0xf6c9, "Acutesmall", 0xf7b4, "Acyrillic", 0x0410, "Adblgrave", 0x0200, "Adieresis", 0x00c4, "Adieresiscyrillic", 0x04d2, "Adieresismacron", 0x01de, "Adieresissmall", 0xf7e4, "Adotbelow", 0x1ea0, "Adotmacron", 0x01e0, "Agrave", 0x00c0, "Agravesmall", 0xf7e0, "Ahookabove", 0x1ea2, "Aiecyrillic", 0x04d4, "Ainvertedbreve", 0x0202, "Alpha", 0x0391, "Alphatonos", 0x0386, "Amacron", 0x0100, "Amonospace", 0xff21, "Aogonek", 0x0104, "Aring", 0x00c5, "Aringacute", 0x01fa, "Aringbelow", 0x1e00, "Aringsmall", 0xf7e5, "Asmall", 0xf761, "Atilde", 0x00c3, "Atildesmall", 0xf7e3, "Aybarmenian", 0x0531, "B", 0x0042, "Bcircle", 0x24b7, "Bdotaccent", 0x1e02, "Bdotbelow", 0x1e04, "Becyrillic", 0x0411, "Benarmenian", 0x0532, "Beta", 0x0392, "Bhook", 0x0181, "Blinebelow", 0x1e06, "Bmonospace", 0xff22, "Brevesmall", 0xf6f4, "Bsmall", 0xf762, "Btopbar", 0x0182, "C", 0x0043, "Caarmenian", 0x053e, "Cacute", 0x0106, "Caron", 0xf6ca, "Caronsmall", 0xf6f5, "Ccaron", 0x010c, "Ccedilla", 0x00c7, "Ccedillaacute", 0x1e08, "Ccedillasmall", 0xf7e7, "Ccircle", 0x24b8, "Ccircumflex", 0x0108, "Cdot", 0x010a, "Cdotaccent", 0x010a, "Cedillasmall", 0xf7b8, "Chaarmenian", 0x0549, "Cheabkhasiancyrillic", 0x04bc, "Checyrillic", 0x0427, "Chedescenderabkhasiancyrillic", 0x04be, "Chedescendercyrillic", 0x04b6, "Chedieresiscyrillic", 0x04f4, "Cheharmenian", 0x0543, "Chekhakassiancyrillic", 0x04cb, "Cheverticalstrokecyrillic", 0x04b8, "Chi", 0x03a7, "Chook", 0x0187, "Circumflexsmall", 0xf6f6, "Cmonospace", 0xff23, "Coarmenian", 0x0551, "Csmall", 0xf763, "D", 0x0044, "DZ", 0x01f1, "DZcaron", 0x01c4, "Daarmenian", 0x0534, "Dafrican", 0x0189, "Dcaron", 0x010e, "Dcedilla", 0x1e10, "Dcircle", 0x24b9, "Dcircumflexbelow", 0x1e12, "Dcroat", 0x0110, "Ddotaccent", 0x1e0a, "Ddotbelow", 0x1e0c, "Decyrillic", 0x0414, "Deicoptic", 0x03ee, "Delta", 0x2206, "Deltagreek", 0x0394, "Dhook", 0x018a, "Dieresis", 0xf6cb, "DieresisAcute", 0xf6cc, "DieresisGrave", 0xf6cd, "Dieresissmall", 0xf7a8, "Digammagreek", 0x03dc, "Djecyrillic", 0x0402, "Dlinebelow", 0x1e0e, "Dmonospace", 0xff24, "Dotaccentsmall", 0xf6f7, "Dslash", 0x0110, "Dsmall", 0xf764, "Dtopbar", 0x018b, "Dz", 0x01f2, "Dzcaron", 0x01c5, "Dzeabkhasiancyrillic", 0x04e0, "Dzecyrillic", 0x0405, "Dzhecyrillic", 0x040f, "E", 0x0045, "Eacute", 0x00c9, "Eacutesmall", 0xf7e9, "Ebreve", 0x0114, "Ecaron", 0x011a, "Ecedillabreve", 0x1e1c, "Echarmenian", 0x0535, "Ecircle", 0x24ba, "Ecircumflex", 0x00ca, "Ecircumflexacute", 0x1ebe, "Ecircumflexbelow", 0x1e18, "Ecircumflexdotbelow", 0x1ec6, "Ecircumflexgrave", 0x1ec0, "Ecircumflexhookabove", 0x1ec2, "Ecircumflexsmall", 0xf7ea, "Ecircumflextilde", 0x1ec4, "Ecyrillic", 0x0404, "Edblgrave", 0x0204, "Edieresis", 0x00cb, "Edieresissmall", 0xf7eb, "Edot", 0x0116, "Edotaccent", 0x0116, "Edotbelow", 0x1eb8, "Efcyrillic", 0x0424, "Egrave", 0x00c8, "Egravesmall", 0xf7e8, "Eharmenian", 0x0537, "Ehookabove", 0x1eba, "Eightroman", 0x2167, "Einvertedbreve", 0x0206, "Eiotifiedcyrillic", 0x0464, "Elcyrillic", 0x041b, "Elevenroman", 0x216a, "Emacron", 0x0112, "Emacronacute", 0x1e16, "Emacrongrave", 0x1e14, "Emcyrillic", 0x041c, "Emonospace", 0xff25, "Encyrillic", 0x041d, "Endescendercyrillic", 0x04a2, "Eng", 0x014a, "Enghecyrillic", 0x04a4, "Enhookcyrillic", 0x04c7, "Eogonek", 0x0118, "Eopen", 0x0190, "Epsilon", 0x0395, "Epsilontonos", 0x0388, "Ercyrillic", 0x0420, "Ereversed", 0x018e, "Ereversedcyrillic", 0x042d, "Escyrillic", 0x0421, "Esdescendercyrillic", 0x04aa, "Esh", 0x01a9, "Esmall", 0xf765, "Eta", 0x0397, "Etarmenian", 0x0538, "Etatonos", 0x0389, "Eth", 0x00d0, "Ethsmall", 0xf7f0, "Etilde", 0x1ebc, "Etildebelow", 0x1e1a, "Euro", 0x20ac, "Ezh", 0x01b7, "Ezhcaron", 0x01ee, "Ezhreversed", 0x01b8, "F", 0x0046, "Fcircle", 0x24bb, "Fdotaccent", 0x1e1e, "Feharmenian", 0x0556, "Feicoptic", 0x03e4, "Fhook", 0x0191, "Fitacyrillic", 0x0472, "Fiveroman", 0x2164, "Fmonospace", 0xff26, "Fourroman", 0x2163, "Fsmall", 0xf766, "G", 0x0047, "GBsquare", 0x3387, "Gacute", 0x01f4, "Gamma", 0x0393, "Gammaafrican", 0x0194, "Gangiacoptic", 0x03ea, "Gbreve", 0x011e, "Gcaron", 0x01e6, "Gcedilla", 0x0122, "Gcircle", 0x24bc, "Gcircumflex", 0x011c, "Gcommaaccent", 0x0122, "Gdot", 0x0120, "Gdotaccent", 0x0120, "Gecyrillic", 0x0413, "Ghadarmenian", 0x0542, "Ghemiddlehookcyrillic", 0x0494, "Ghestrokecyrillic", 0x0492, "Gheupturncyrillic", 0x0490, "Ghook", 0x0193, "Gimarmenian", 0x0533, "Gjecyrillic", 0x0403, "Gmacron", 0x1e20, "Gmonospace", 0xff27, "Grave", 0xf6ce, "Gravesmall", 0xf760, "Gsmall", 0xf767, "Gsmallhook", 0x029b, "Gstroke", 0x01e4, "H", 0x0048, "H18533", 0x25cf, "H18543", 0x25aa, "H18551", 0x25ab, "H22073", 0x25a1, "HPsquare", 0x33cb, "Haabkhasiancyrillic", 0x04a8, "Hadescendercyrillic", 0x04b2, "Hardsigncyrillic", 0x042a, "Hbar", 0x0126, "Hbrevebelow", 0x1e2a, "Hcedilla", 0x1e28, "Hcircle", 0x24bd, "Hcircumflex", 0x0124, "Hdieresis", 0x1e26, "Hdotaccent", 0x1e22, "Hdotbelow", 0x1e24, "Hmonospace", 0xff28, "Hoarmenian", 0x0540, "Horicoptic", 0x03e8, "Hsmall", 0xf768, "Hungarumlaut", 0xf6cf, "Hungarumlautsmall", 0xf6f8, "Hzsquare", 0x3390, "I", 0x0049, "IAcyrillic", 0x042f, "IJ", 0x0132, "IUcyrillic", 0x042e, "Iacute", 0x00cd, "Iacutesmall", 0xf7ed, "Ibreve", 0x012c, "Icaron", 0x01cf, "Icircle", 0x24be, "Icircumflex", 0x00ce, "Icircumflexsmall", 0xf7ee, "Icyrillic", 0x0406, "Idblgrave", 0x0208, "Idieresis", 0x00cf, "Idieresisacute", 0x1e2e, "Idieresiscyrillic", 0x04e4, "Idieresissmall", 0xf7ef, "Idot", 0x0130, "Idotaccent", 0x0130, "Idotbelow", 0x1eca, "Iebrevecyrillic", 0x04d6, "Iecyrillic", 0x0415, "Ifraktur", 0x2111, "Igrave", 0x00cc, "Igravesmall", 0xf7ec, "Ihookabove", 0x1ec8, "Iicyrillic", 0x0418, "Iinvertedbreve", 0x020a, "Iishortcyrillic", 0x0419, "Imacron", 0x012a, "Imacroncyrillic", 0x04e2, "Imonospace", 0xff29, "Iniarmenian", 0x053b, "Iocyrillic", 0x0401, "Iogonek", 0x012e, "Iota", 0x0399, "Iotaafrican", 0x0196, "Iotadieresis", 0x03aa, "Iotatonos", 0x038a, "Ismall", 0xf769, "Istroke", 0x0197, "Itilde", 0x0128, "Itildebelow", 0x1e2c, "Izhitsacyrillic", 0x0474, "Izhitsadblgravecyrillic", 0x0476, "J", 0x004a, "Jaarmenian", 0x0541, "Jcircle", 0x24bf, "Jcircumflex", 0x0134, "Jecyrillic", 0x0408, "Jheharmenian", 0x054b, "Jmonospace", 0xff2a, "Jsmall", 0xf76a, "K", 0x004b, "KBsquare", 0x3385, "KKsquare", 0x33cd, "Kabashkircyrillic", 0x04a0, "Kacute", 0x1e30, "Kacyrillic", 0x041a, "Kadescendercyrillic", 0x049a, "Kahookcyrillic", 0x04c3, "Kappa", 0x039a, "Kastrokecyrillic", 0x049e, "Kaverticalstrokecyrillic", 0x049c, "Kcaron", 0x01e8, "Kcedilla", 0x0136, "Kcircle", 0x24c0, "Kcommaaccent", 0x0136, "Kdotbelow", 0x1e32, "Keharmenian", 0x0554, "Kenarmenian", 0x053f, "Khacyrillic", 0x0425, "Kheicoptic", 0x03e6, "Khook", 0x0198, "Kjecyrillic", 0x040c, "Klinebelow", 0x1e34, "Kmonospace", 0xff2b, "Koppacyrillic", 0x0480, "Koppagreek", 0x03de, "Ksicyrillic", 0x046e, "Ksmall", 0xf76b, "L", 0x004c, "LJ", 0x01c7, "LL", 0xf6bf, "Lacute", 0x0139, "Lambda", 0x039b, "Lcaron", 0x013d, "Lcedilla", 0x013b, "Lcircle", 0x24c1, "Lcircumflexbelow", 0x1e3c, "Lcommaaccent", 0x013b, "Ldot", 0x013f, "Ldotaccent", 0x013f, "Ldotbelow", 0x1e36, "Ldotbelowmacron", 0x1e38, "Liwnarmenian", 0x053c, "Lj", 0x01c8, "Ljecyrillic", 0x0409, "Llinebelow", 0x1e3a, "Lmonospace", 0xff2c, "Lslash", 0x0141, "Lslashsmall", 0xf6f9, "Lsmall", 0xf76c, "M", 0x004d, "MBsquare", 0x3386, "Macron", 0xf6d0, "Macronsmall", 0xf7af, "Macute", 0x1e3e, "Mcircle", 0x24c2, "Mdotaccent", 0x1e40, "Mdotbelow", 0x1e42, "Menarmenian", 0x0544, "Mmonospace", 0xff2d, "Msmall", 0xf76d, "Mturned", 0x019c, "Mu", 0x039c, "N", 0x004e, "NJ", 0x01ca, "Nacute", 0x0143, "Ncaron", 0x0147, "Ncedilla", 0x0145, "Ncircle", 0x24c3, "Ncircumflexbelow", 0x1e4a, "Ncommaaccent", 0x0145, "Ndotaccent", 0x1e44, "Ndotbelow", 0x1e46, "Nhookleft", 0x019d, "Nineroman", 0x2168, "Nj", 0x01cb, "Njecyrillic", 0x040a, "Nlinebelow", 0x1e48, "Nmonospace", 0xff2e, "Nowarmenian", 0x0546, "Nsmall", 0xf76e, "Ntilde", 0x00d1, "Ntildesmall", 0xf7f1, "Nu", 0x039d, "O", 0x004f, "OE", 0x0152, "OEsmall", 0xf6fa, "Oacute", 0x00d3, "Oacutesmall", 0xf7f3, "Obarredcyrillic", 0x04e8, "Obarreddieresiscyrillic", 0x04ea, "Obreve", 0x014e, "Ocaron", 0x01d1, "Ocenteredtilde", 0x019f, "Ocircle", 0x24c4, "Ocircumflex", 0x00d4, "Ocircumflexacute", 0x1ed0, "Ocircumflexdotbelow", 0x1ed8, "Ocircumflexgrave", 0x1ed2, "Ocircumflexhookabove", 0x1ed4, "Ocircumflexsmall", 0xf7f4, "Ocircumflextilde", 0x1ed6, "Ocyrillic", 0x041e, "Odblacute", 0x0150, "Odblgrave", 0x020c, "Odieresis", 0x00d6, "Odieresiscyrillic", 0x04e6, "Odieresissmall", 0xf7f6, "Odotbelow", 0x1ecc, "Ogoneksmall", 0xf6fb, "Ograve", 0x00d2, "Ogravesmall", 0xf7f2, "Oharmenian", 0x0555, "Ohm", 0x2126, "Ohookabove", 0x1ece, "Ohorn", 0x01a0, "Ohornacute", 0x1eda, "Ohorndotbelow", 0x1ee2, "Ohorngrave", 0x1edc, "Ohornhookabove", 0x1ede, "Ohorntilde", 0x1ee0, "Ohungarumlaut", 0x0150, "Oi", 0x01a2, "Oinvertedbreve", 0x020e, "Omacron", 0x014c, "Omacronacute", 0x1e52, "Omacrongrave", 0x1e50, "Omega", 0x2126, "Omegacyrillic", 0x0460, "Omegagreek", 0x03a9, "Omegaroundcyrillic", 0x047a, "Omegatitlocyrillic", 0x047c, "Omegatonos", 0x038f, "Omicron", 0x039f, "Omicrontonos", 0x038c, "Omonospace", 0xff2f, "Oneroman", 0x2160, "Oogonek", 0x01ea, "Oogonekmacron", 0x01ec, "Oopen", 0x0186, "Oslash", 0x00d8, "Oslashacute", 0x01fe, "Oslashsmall", 0xf7f8, "Osmall", 0xf76f, "Ostrokeacute", 0x01fe, "Otcyrillic", 0x047e, "Otilde", 0x00d5, "Otildeacute", 0x1e4c, "Otildedieresis", 0x1e4e, "Otildesmall", 0xf7f5, "P", 0x0050, "Pacute", 0x1e54, "Pcircle", 0x24c5, "Pdotaccent", 0x1e56, "Pecyrillic", 0x041f, "Peharmenian", 0x054a, "Pemiddlehookcyrillic", 0x04a6, "Phi", 0x03a6, "Phook", 0x01a4, "Pi", 0x03a0, "Piwrarmenian", 0x0553, "Pmonospace", 0xff30, "Psi", 0x03a8, "Psicyrillic", 0x0470, "Psmall", 0xf770, "Q", 0x0051, "Qcircle", 0x24c6, "Qmonospace", 0xff31, "Qsmall", 0xf771, "R", 0x0052, "Raarmenian", 0x054c, "Racute", 0x0154, "Rcaron", 0x0158, "Rcedilla", 0x0156, "Rcircle", 0x24c7, "Rcommaaccent", 0x0156, "Rdblgrave", 0x0210, "Rdotaccent", 0x1e58, "Rdotbelow", 0x1e5a, "Rdotbelowmacron", 0x1e5c, "Reharmenian", 0x0550, "Rfraktur", 0x211c, "Rho", 0x03a1, "Ringsmall", 0xf6fc, "Rinvertedbreve", 0x0212, "Rlinebelow", 0x1e5e, "Rmonospace", 0xff32, "Rsmall", 0xf772, "Rsmallinverted", 0x0281, "Rsmallinvertedsuperior", 0x02b6, "S", 0x0053, "SF010000", 0x250c, "SF020000", 0x2514, "SF030000", 0x2510, "SF040000", 0x2518, "SF050000", 0x253c, "SF060000", 0x252c, "SF070000", 0x2534, "SF080000", 0x251c, "SF090000", 0x2524, "SF100000", 0x2500, "SF110000", 0x2502, "SF190000", 0x2561, "SF200000", 0x2562, "SF210000", 0x2556, "SF220000", 0x2555, "SF230000", 0x2563, "SF240000", 0x2551, "SF250000", 0x2557, "SF260000", 0x255d, "SF270000", 0x255c, "SF280000", 0x255b, "SF360000", 0x255e, "SF370000", 0x255f, "SF380000", 0x255a, "SF390000", 0x2554, "SF400000", 0x2569, "SF410000", 0x2566, "SF420000", 0x2560, "SF430000", 0x2550, "SF440000", 0x256c, "SF450000", 0x2567, "SF460000", 0x2568, "SF470000", 0x2564, "SF480000", 0x2565, "SF490000", 0x2559, "SF500000", 0x2558, "SF510000", 0x2552, "SF520000", 0x2553, "SF530000", 0x256b, "SF540000", 0x256a, "Sacute", 0x015a, "Sacutedotaccent", 0x1e64, "Sampigreek", 0x03e0, "Scaron", 0x0160, "Scarondotaccent", 0x1e66, "Scaronsmall", 0xf6fd, "Scedilla", 0x015e, "Schwa", 0x018f, "Schwacyrillic", 0x04d8, "Schwadieresiscyrillic", 0x04da, "Scircle", 0x24c8, "Scircumflex", 0x015c, "Scommaaccent", 0x0218, "Sdotaccent", 0x1e60, "Sdotbelow", 0x1e62, "Sdotbelowdotaccent", 0x1e68, "Seharmenian", 0x054d, "Sevenroman", 0x2166, "Shaarmenian", 0x0547, "Shacyrillic", 0x0428, "Shchacyrillic", 0x0429, "Sheicoptic", 0x03e2, "Shhacyrillic", 0x04ba, "Shimacoptic", 0x03ec, "Sigma", 0x03a3, "Sixroman", 0x2165, "Smonospace", 0xff33, "Softsigncyrillic", 0x042c, "Ssmall", 0xf773, "Stigmagreek", 0x03da, "T", 0x0054, "Tau", 0x03a4, "Tbar", 0x0166, "Tcaron", 0x0164, "Tcedilla", 0x0162, "Tcircle", 0x24c9, "Tcircumflexbelow", 0x1e70, "Tcommaaccent", 0x0162, "Tdotaccent", 0x1e6a, "Tdotbelow", 0x1e6c, "Tecyrillic", 0x0422, "Tedescendercyrillic", 0x04ac, "Tenroman", 0x2169, "Tetsecyrillic", 0x04b4, "Theta", 0x0398, "Thook", 0x01ac, "Thorn", 0x00de, "Thornsmall", 0xf7fe, "Threeroman", 0x2162, "Tildesmall", 0xf6fe, "Tiwnarmenian", 0x054f, "Tlinebelow", 0x1e6e, "Tmonospace", 0xff34, "Toarmenian", 0x0539, "Tonefive", 0x01bc, "Tonesix", 0x0184, "Tonetwo", 0x01a7, "Tretroflexhook", 0x01ae, "Tsecyrillic", 0x0426, "Tshecyrillic", 0x040b, "Tsmall", 0xf774, "Twelveroman", 0x216b, "Tworoman", 0x2161, "U", 0x0055, "Uacute", 0x00da, "Uacutesmall", 0xf7fa, "Ubreve", 0x016c, "Ucaron", 0x01d3, "Ucircle", 0x24ca, "Ucircumflex", 0x00db, "Ucircumflexbelow", 0x1e76, "Ucircumflexsmall", 0xf7fb, "Ucyrillic", 0x0423, "Udblacute", 0x0170, "Udblgrave", 0x0214, "Udieresis", 0x00dc, "Udieresisacute", 0x01d7, "Udieresisbelow", 0x1e72, "Udieresiscaron", 0x01d9, "Udieresiscyrillic", 0x04f0, "Udieresisgrave", 0x01db, "Udieresismacron", 0x01d5, "Udieresissmall", 0xf7fc, "Udotbelow", 0x1ee4, "Ugrave", 0x00d9, "Ugravesmall", 0xf7f9, "Uhookabove", 0x1ee6, "Uhorn", 0x01af, "Uhornacute", 0x1ee8, "Uhorndotbelow", 0x1ef0, "Uhorngrave", 0x1eea, "Uhornhookabove", 0x1eec, "Uhorntilde", 0x1eee, "Uhungarumlaut", 0x0170, "Uhungarumlautcyrillic", 0x04f2, "Uinvertedbreve", 0x0216, "Ukcyrillic", 0x0478, "Umacron", 0x016a, "Umacroncyrillic", 0x04ee, "Umacrondieresis", 0x1e7a, "Umonospace", 0xff35, "Uogonek", 0x0172, "Upsilon", 0x03a5, "Upsilon1", 0x03d2, "Upsilonacutehooksymbolgreek", 0x03d3, "Upsilonafrican", 0x01b1, "Upsilondieresis", 0x03ab, "Upsilondieresishooksymbolgreek", 0x03d4, "Upsilonhooksymbol", 0x03d2, "Upsilontonos", 0x038e, "Uring", 0x016e, "Ushortcyrillic", 0x040e, "Usmall", 0xf775, "Ustraightcyrillic", 0x04ae, "Ustraightstrokecyrillic", 0x04b0, "Utilde", 0x0168, "Utildeacute", 0x1e78, "Utildebelow", 0x1e74, "V", 0x0056, "Vcircle", 0x24cb, "Vdotbelow", 0x1e7e, "Vecyrillic", 0x0412, "Vewarmenian", 0x054e, "Vhook", 0x01b2, "Vmonospace", 0xff36, "Voarmenian", 0x0548, "Vsmall", 0xf776, "Vtilde", 0x1e7c, "W", 0x0057, "Wacute", 0x1e82, "Wcircle", 0x24cc, "Wcircumflex", 0x0174, "Wdieresis", 0x1e84, "Wdotaccent", 0x1e86, "Wdotbelow", 0x1e88, "Wgrave", 0x1e80, "Wmonospace", 0xff37, "Wsmall", 0xf777, "X", 0x0058, "Xcircle", 0x24cd, "Xdieresis", 0x1e8c, "Xdotaccent", 0x1e8a, "Xeharmenian", 0x053d, "Xi", 0x039e, "Xmonospace", 0xff38, "Xsmall", 0xf778, "Y", 0x0059, "Yacute", 0x00dd, "Yacutesmall", 0xf7fd, "Yatcyrillic", 0x0462, "Ycircle", 0x24ce, "Ycircumflex", 0x0176, "Ydieresis", 0x0178, "Ydieresissmall", 0xf7ff, "Ydotaccent", 0x1e8e, "Ydotbelow", 0x1ef4, "Yericyrillic", 0x042b, "Yerudieresiscyrillic", 0x04f8, "Ygrave", 0x1ef2, "Yhook", 0x01b3, "Yhookabove", 0x1ef6, "Yiarmenian", 0x0545, "Yicyrillic", 0x0407, "Yiwnarmenian", 0x0552, "Ymonospace", 0xff39, "Ysmall", 0xf779, "Ytilde", 0x1ef8, "Yusbigcyrillic", 0x046a, "Yusbigiotifiedcyrillic", 0x046c, "Yuslittlecyrillic", 0x0466, "Yuslittleiotifiedcyrillic", 0x0468, "Z", 0x005a, "Zaarmenian", 0x0536, "Zacute", 0x0179, "Zcaron", 0x017d, "Zcaronsmall", 0xf6ff, "Zcircle", 0x24cf, "Zcircumflex", 0x1e90, "Zdot", 0x017b, "Zdotaccent", 0x017b, "Zdotbelow", 0x1e92, "Zecyrillic", 0x0417, "Zedescendercyrillic", 0x0498, "Zedieresiscyrillic", 0x04de, "Zeta", 0x0396, "Zhearmenian", 0x053a, "Zhebrevecyrillic", 0x04c1, "Zhecyrillic", 0x0416, "Zhedescendercyrillic", 0x0496, "Zhedieresiscyrillic", 0x04dc, "Zlinebelow", 0x1e94, "Zmonospace", 0xff3a, "Zsmall", 0xf77a, "Zstroke", 0x01b5, "a", 0x0061, "aabengali", 0x0986, "aacute", 0x00e1, "aadeva", 0x0906, "aagujarati", 0x0a86, "aagurmukhi", 0x0a06, "aamatragurmukhi", 0x0a3e, "aarusquare", 0x3303, "aavowelsignbengali", 0x09be, "aavowelsigndeva", 0x093e, "aavowelsigngujarati", 0x0abe, "abbreviationmarkarmenian", 0x055f, "abbreviationsigndeva", 0x0970, "abengali", 0x0985, "abopomofo", 0x311a, "abreve", 0x0103, "abreveacute", 0x1eaf, "abrevecyrillic", 0x04d1, "abrevedotbelow", 0x1eb7, "abrevegrave", 0x1eb1, "abrevehookabove", 0x1eb3, "abrevetilde", 0x1eb5, "acaron", 0x01ce, "acircle", 0x24d0, "acircumflex", 0x00e2, "acircumflexacute", 0x1ea5, "acircumflexdotbelow", 0x1ead, "acircumflexgrave", 0x1ea7, "acircumflexhookabove", 0x1ea9, "acircumflextilde", 0x1eab, "acute", 0x00b4, "acutebelowcmb", 0x0317, "acutecmb", 0x0301, "acutecomb", 0x0301, "acutedeva", 0x0954, "acutelowmod", 0x02cf, "acutetonecmb", 0x0341, "acyrillic", 0x0430, "adblgrave", 0x0201, "addakgurmukhi", 0x0a71, "adeva", 0x0905, "adieresis", 0x00e4, "adieresiscyrillic", 0x04d3, "adieresismacron", 0x01df, "adotbelow", 0x1ea1, "adotmacron", 0x01e1, "ae", 0x00e6, "aeacute", 0x01fd, "aekorean", 0x3150, "aemacron", 0x01e3, "afii00208", 0x2015, "afii08941", 0x20a4, "afii10017", 0x0410, "afii10018", 0x0411, "afii10019", 0x0412, "afii10020", 0x0413, "afii10021", 0x0414, "afii10022", 0x0415, "afii10023", 0x0401, "afii10024", 0x0416, "afii10025", 0x0417, "afii10026", 0x0418, "afii10027", 0x0419, "afii10028", 0x041a, "afii10029", 0x041b, "afii10030", 0x041c, "afii10031", 0x041d, "afii10032", 0x041e, "afii10033", 0x041f, "afii10034", 0x0420, "afii10035", 0x0421, "afii10036", 0x0422, "afii10037", 0x0423, "afii10038", 0x0424, "afii10039", 0x0425, "afii10040", 0x0426, "afii10041", 0x0427, "afii10042", 0x0428, "afii10043", 0x0429, "afii10044", 0x042a, "afii10045", 0x042b, "afii10046", 0x042c, "afii10047", 0x042d, "afii10048", 0x042e, "afii10049", 0x042f, "afii10050", 0x0490, "afii10051", 0x0402, "afii10052", 0x0403, "afii10053", 0x0404, "afii10054", 0x0405, "afii10055", 0x0406, "afii10056", 0x0407, "afii10057", 0x0408, "afii10058", 0x0409, "afii10059", 0x040a, "afii10060", 0x040b, "afii10061", 0x040c, "afii10062", 0x040e, "afii10063", 0xf6c4, "afii10064", 0xf6c5, "afii10065", 0x0430, "afii10066", 0x0431, "afii10067", 0x0432, "afii10068", 0x0433, "afii10069", 0x0434, "afii10070", 0x0435, "afii10071", 0x0451, "afii10072", 0x0436, "afii10073", 0x0437, "afii10074", 0x0438, "afii10075", 0x0439, "afii10076", 0x043a, "afii10077", 0x043b, "afii10078", 0x043c, "afii10079", 0x043d, "afii10080", 0x043e, "afii10081", 0x043f, "afii10082", 0x0440, "afii10083", 0x0441, "afii10084", 0x0442, "afii10085", 0x0443, "afii10086", 0x0444, "afii10087", 0x0445, "afii10088", 0x0446, "afii10089", 0x0447, "afii10090", 0x0448, "afii10091", 0x0449, "afii10092", 0x044a, "afii10093", 0x044b, "afii10094", 0x044c, "afii10095", 0x044d, "afii10096", 0x044e, "afii10097", 0x044f, "afii10098", 0x0491, "afii10099", 0x0452, "afii10100", 0x0453, "afii10101", 0x0454, "afii10102", 0x0455, "afii10103", 0x0456, "afii10104", 0x0457, "afii10105", 0x0458, "afii10106", 0x0459, "afii10107", 0x045a, "afii10108", 0x045b, "afii10109", 0x045c, "afii10110", 0x045e, "afii10145", 0x040f, "afii10146", 0x0462, "afii10147", 0x0472, "afii10148", 0x0474, "afii10192", 0xf6c6, "afii10193", 0x045f, "afii10194", 0x0463, "afii10195", 0x0473, "afii10196", 0x0475, "afii10831", 0xf6c7, "afii10832", 0xf6c8, "afii10846", 0x04d9, "afii299", 0x200e, "afii300", 0x200f, "afii301", 0x200d, "afii57381", 0x066a, "afii57388", 0x060c, "afii57392", 0x0660, "afii57393", 0x0661, "afii57394", 0x0662, "afii57395", 0x0663, "afii57396", 0x0664, "afii57397", 0x0665, "afii57398", 0x0666, "afii57399", 0x0667, "afii57400", 0x0668, "afii57401", 0x0669, "afii57403", 0x061b, "afii57407", 0x061f, "afii57409", 0x0621, "afii57410", 0x0622, "afii57411", 0x0623, "afii57412", 0x0624, "afii57413", 0x0625, "afii57414", 0x0626, "afii57415", 0x0627, "afii57416", 0x0628, "afii57417", 0x0629, "afii57418", 0x062a, "afii57419", 0x062b, "afii57420", 0x062c, "afii57421", 0x062d, "afii57422", 0x062e, "afii57423", 0x062f, "afii57424", 0x0630, "afii57425", 0x0631, "afii57426", 0x0632, "afii57427", 0x0633, "afii57428", 0x0634, "afii57429", 0x0635, "afii57430", 0x0636, "afii57431", 0x0637, "afii57432", 0x0638, "afii57433", 0x0639, "afii57434", 0x063a, "afii57440", 0x0640, "afii57441", 0x0641, "afii57442", 0x0642, "afii57443", 0x0643, "afii57444", 0x0644, "afii57445", 0x0645, "afii57446", 0x0646, "afii57448", 0x0648, "afii57449", 0x0649, "afii57450", 0x064a, "afii57451", 0x064b, "afii57452", 0x064c, "afii57453", 0x064d, "afii57454", 0x064e, "afii57455", 0x064f, "afii57456", 0x0650, "afii57457", 0x0651, "afii57458", 0x0652, "afii57470", 0x0647, "afii57505", 0x06a4, "afii57506", 0x067e, "afii57507", 0x0686, "afii57508", 0x0698, "afii57509", 0x06af, "afii57511", 0x0679, "afii57512", 0x0688, "afii57513", 0x0691, "afii57514", 0x06ba, "afii57519", 0x06d2, "afii57534", 0x06d5, "afii57636", 0x20aa, "afii57645", 0x05be, "afii57658", 0x05c3, "afii57664", 0x05d0, "afii57665", 0x05d1, "afii57666", 0x05d2, "afii57667", 0x05d3, "afii57668", 0x05d4, "afii57669", 0x05d5, "afii57670", 0x05d6, "afii57671", 0x05d7, "afii57672", 0x05d8, "afii57673", 0x05d9, "afii57674", 0x05da, "afii57675", 0x05db, "afii57676", 0x05dc, "afii57677", 0x05dd, "afii57678", 0x05de, "afii57679", 0x05df, "afii57680", 0x05e0, "afii57681", 0x05e1, "afii57682", 0x05e2, "afii57683", 0x05e3, "afii57684", 0x05e4, "afii57685", 0x05e5, "afii57686", 0x05e6, "afii57687", 0x05e7, "afii57688", 0x05e8, "afii57689", 0x05e9, "afii57690", 0x05ea, "afii57694", 0xfb2a, "afii57695", 0xfb2b, "afii57700", 0xfb4b, "afii57705", 0xfb1f, "afii57716", 0x05f0, "afii57717", 0x05f1, "afii57718", 0x05f2, "afii57723", 0xfb35, "afii57793", 0x05b4, "afii57794", 0x05b5, "afii57795", 0x05b6, "afii57796", 0x05bb, "afii57797", 0x05b8, "afii57798", 0x05b7, "afii57799", 0x05b0, "afii57800", 0x05b2, "afii57801", 0x05b1, "afii57802", 0x05b3, "afii57803", 0x05c2, "afii57804", 0x05c1, "afii57806", 0x05b9, "afii57807", 0x05bc, "afii57839", 0x05bd, "afii57841", 0x05bf, "afii57842", 0x05c0, "afii57929", 0x02bc, "afii61248", 0x2105, "afii61289", 0x2113, "afii61352", 0x2116, "afii61573", 0x202c, "afii61574", 0x202d, "afii61575", 0x202e, "afii61664", 0x200c, "afii63167", 0x066d, "afii64937", 0x02bd, "agrave", 0x00e0, "agujarati", 0x0a85, "agurmukhi", 0x0a05, "ahiragana", 0x3042, "ahookabove", 0x1ea3, "aibengali", 0x0990, "aibopomofo", 0x311e, "aideva", 0x0910, "aiecyrillic", 0x04d5, "aigujarati", 0x0a90, "aigurmukhi", 0x0a10, "aimatragurmukhi", 0x0a48, "ainarabic", 0x0639, "ainfinalarabic", 0xfeca, "aininitialarabic", 0xfecb, "ainmedialarabic", 0xfecc, "ainvertedbreve", 0x0203, "aivowelsignbengali", 0x09c8, "aivowelsigndeva", 0x0948, "aivowelsigngujarati", 0x0ac8, "akatakana", 0x30a2, "akatakanahalfwidth", 0xff71, "akorean", 0x314f, "alef", 0x05d0, "alefarabic", 0x0627, "alefdageshhebrew", 0xfb30, "aleffinalarabic", 0xfe8e, "alefhamzaabovearabic", 0x0623, "alefhamzaabovefinalarabic", 0xfe84, "alefhamzabelowarabic", 0x0625, "alefhamzabelowfinalarabic", 0xfe88, "alefhebrew", 0x05d0, "aleflamedhebrew", 0xfb4f, "alefmaddaabovearabic", 0x0622, "alefmaddaabovefinalarabic", 0xfe82, "alefmaksuraarabic", 0x0649, "alefmaksurafinalarabic", 0xfef0, "alefmaksurainitialarabic", 0xfef3, "alefmaksuramedialarabic", 0xfef4, "alefpatahhebrew", 0xfb2e, "alefqamatshebrew", 0xfb2f, "aleph", 0x2135, "allequal", 0x224c, "alpha", 0x03b1, "alphatonos", 0x03ac, "amacron", 0x0101, "amonospace", 0xff41, "ampersand", 0x0026, "ampersandmonospace", 0xff06, "ampersandsmall", 0xf726, "amsquare", 0x33c2, "anbopomofo", 0x3122, "angbopomofo", 0x3124, "angbracketleft", 0x3008, "angbracketright", 0x3009, "angkhankhuthai", 0x0e5a, "angle", 0x2220, "anglebracketleft", 0x3008, "anglebracketleftvertical", 0xfe3f, "anglebracketright", 0x3009, "anglebracketrightvertical", 0xfe40, "angleleft", 0x2329, "angleright", 0x232a, "angstrom", 0x212b, "anoteleia", 0x0387, "anudattadeva", 0x0952, "anusvarabengali", 0x0982, "anusvaradeva", 0x0902, "anusvaragujarati", 0x0a82, "aogonek", 0x0105, "apaatosquare", 0x3300, "aparen", 0x249c, "apostrophearmenian", 0x055a, "apostrophemod", 0x02bc, "apple", 0xf8ff, "approaches", 0x2250, "approxequal", 0x2248, "approxequalorimage", 0x2252, "approximatelyequal", 0x2245, "araeaekorean", 0x318e, "araeakorean", 0x318d, "arc", 0x2312, "arighthalfring", 0x1e9a, "aring", 0x00e5, "aringacute", 0x01fb, "aringbelow", 0x1e01, "arrowboth", 0x2194, "arrowdashdown", 0x21e3, "arrowdashleft", 0x21e0, "arrowdashright", 0x21e2, "arrowdashup", 0x21e1, "arrowdblboth", 0x21d4, "arrowdbldown", 0x21d3, "arrowdblleft", 0x21d0, "arrowdblright", 0x21d2, "arrowdblup", 0x21d1, "arrowdown", 0x2193, "arrowdownleft", 0x2199, "arrowdownright", 0x2198, "arrowdownwhite", 0x21e9, "arrowheaddownmod", 0x02c5, "arrowheadleftmod", 0x02c2, "arrowheadrightmod", 0x02c3, "arrowheadupmod", 0x02c4, "arrowhorizex", 0xf8e7, "arrowleft", 0x2190, "arrowleftdbl", 0x21d0, "arrowleftdblstroke", 0x21cd, "arrowleftoverright", 0x21c6, "arrowleftwhite", 0x21e6, "arrowright", 0x2192, "arrowrightdblstroke", 0x21cf, "arrowrightheavy", 0x279e, "arrowrightoverleft", 0x21c4, "arrowrightwhite", 0x21e8, "arrowtableft", 0x21e4, "arrowtabright", 0x21e5, "arrowup", 0x2191, "arrowupdn", 0x2195, "arrowupdnbse", 0x21a8, "arrowupdownbase", 0x21a8, "arrowupleft", 0x2196, "arrowupleftofdown", 0x21c5, "arrowupright", 0x2197, "arrowupwhite", 0x21e7, "arrowvertex", 0xf8e6, "asciicircum", 0x005e, "asciicircummonospace", 0xff3e, "asciitilde", 0x007e, "asciitildemonospace", 0xff5e, "ascript", 0x0251, "ascriptturned", 0x0252, "asmallhiragana", 0x3041, "asmallkatakana", 0x30a1, "asmallkatakanahalfwidth", 0xff67, "asterisk", 0x002a, "asteriskaltonearabic", 0x066d, "asteriskarabic", 0x066d, "asteriskmath", 0x2217, "asteriskmonospace", 0xff0a, "asterisksmall", 0xfe61, "asterism", 0x2042, "asuperior", 0xf6e9, "asymptoticallyequal", 0x2243, "at", 0x0040, "atilde", 0x00e3, "atmonospace", 0xff20, "atsmall", 0xfe6b, "aturned", 0x0250, "aubengali", 0x0994, "aubopomofo", 0x3120, "audeva", 0x0914, "augujarati", 0x0a94, "augurmukhi", 0x0a14, "aulengthmarkbengali", 0x09d7, "aumatragurmukhi", 0x0a4c, "auvowelsignbengali", 0x09cc, "auvowelsigndeva", 0x094c, "auvowelsigngujarati", 0x0acc, "avagrahadeva", 0x093d, "aybarmenian", 0x0561, "ayin", 0x05e2, "ayinaltonehebrew", 0xfb20, "ayinhebrew", 0x05e2, "b", 0x0062, "babengali", 0x09ac, "backslash", 0x005c, "backslashmonospace", 0xff3c, "badeva", 0x092c, "bagujarati", 0x0aac, "bagurmukhi", 0x0a2c, "bahiragana", 0x3070, "bahtthai", 0x0e3f, "bakatakana", 0x30d0, "bar", 0x007c, "barmonospace", 0xff5c, "bbopomofo", 0x3105, "bcircle", 0x24d1, "bdotaccent", 0x1e03, "bdotbelow", 0x1e05, "beamedsixteenthnotes", 0x266c, "because", 0x2235, "becyrillic", 0x0431, "beharabic", 0x0628, "behfinalarabic", 0xfe90, "behinitialarabic", 0xfe91, "behiragana", 0x3079, "behmedialarabic", 0xfe92, "behmeeminitialarabic", 0xfc9f, "behmeemisolatedarabic", 0xfc08, "behnoonfinalarabic", 0xfc6d, "bekatakana", 0x30d9, "benarmenian", 0x0562, "bet", 0x05d1, "beta", 0x03b2, "betasymbolgreek", 0x03d0, "betdagesh", 0xfb31, "betdageshhebrew", 0xfb31, "bethebrew", 0x05d1, "betrafehebrew", 0xfb4c, "bhabengali", 0x09ad, "bhadeva", 0x092d, "bhagujarati", 0x0aad, "bhagurmukhi", 0x0a2d, "bhook", 0x0253, "bihiragana", 0x3073, "bikatakana", 0x30d3, "bilabialclick", 0x0298, "bindigurmukhi", 0x0a02, "birusquare", 0x3331, "blackcircle", 0x25cf, "blackdiamond", 0x25c6, "blackdownpointingtriangle", 0x25bc, "blackleftpointingpointer", 0x25c4, "blackleftpointingtriangle", 0x25c0, "blacklenticularbracketleft", 0x3010, "blacklenticularbracketleftvertical", 0xfe3b, "blacklenticularbracketright", 0x3011, "blacklenticularbracketrightvertical", 0xfe3c, "blacklowerlefttriangle", 0x25e3, "blacklowerrighttriangle", 0x25e2, "blackrectangle", 0x25ac, "blackrightpointingpointer", 0x25ba, "blackrightpointingtriangle", 0x25b6, "blacksmallsquare", 0x25aa, "blacksmilingface", 0x263b, "blacksquare", 0x25a0, "blackstar", 0x2605, "blackupperlefttriangle", 0x25e4, "blackupperrighttriangle", 0x25e5, "blackuppointingsmalltriangle", 0x25b4, "blackuppointingtriangle", 0x25b2, "blank", 0x2423, "blinebelow", 0x1e07, "block", 0x2588, "bmonospace", 0xff42, "bobaimaithai", 0x0e1a, "bohiragana", 0x307c, "bokatakana", 0x30dc, "bparen", 0x249d, "bqsquare", 0x33c3, "braceex", 0xf8f4, "braceleft", 0x007b, "braceleftbt", 0xf8f3, "braceleftmid", 0xf8f2, "braceleftmonospace", 0xff5b, "braceleftsmall", 0xfe5b, "bracelefttp", 0xf8f1, "braceleftvertical", 0xfe37, "braceright", 0x007d, "bracerightbt", 0xf8fe, "bracerightmid", 0xf8fd, "bracerightmonospace", 0xff5d, "bracerightsmall", 0xfe5c, "bracerighttp", 0xf8fc, "bracerightvertical", 0xfe38, "bracketleft", 0x005b, "bracketleftbt", 0xf8f0, "bracketleftex", 0xf8ef, "bracketleftmonospace", 0xff3b, "bracketlefttp", 0xf8ee, "bracketright", 0x005d, "bracketrightbt", 0xf8fb, "bracketrightex", 0xf8fa, "bracketrightmonospace", 0xff3d, "bracketrighttp", 0xf8f9, "breve", 0x02d8, "brevebelowcmb", 0x032e, "brevecmb", 0x0306, "breveinvertedbelowcmb", 0x032f, "breveinvertedcmb", 0x0311, "breveinverteddoublecmb", 0x0361, "bridgebelowcmb", 0x032a, "bridgeinvertedbelowcmb", 0x033a, "brokenbar", 0x00a6, "bstroke", 0x0180, "bsuperior", 0xf6ea, "btopbar", 0x0183, "buhiragana", 0x3076, "bukatakana", 0x30d6, "bullet", 0x2022, "bulletinverse", 0x25d8, "bulletoperator", 0x2219, "bullseye", 0x25ce, "c", 0x0063, "caarmenian", 0x056e, "cabengali", 0x099a, "cacute", 0x0107, "cadeva", 0x091a, "cagujarati", 0x0a9a, "cagurmukhi", 0x0a1a, "calsquare", 0x3388, "candrabindubengali", 0x0981, "candrabinducmb", 0x0310, "candrabindudeva", 0x0901, "candrabindugujarati", 0x0a81, "capslock", 0x21ea, "careof", 0x2105, "caron", 0x02c7, "caronbelowcmb", 0x032c, "caroncmb", 0x030c, "carriagereturn", 0x21b5, "cbopomofo", 0x3118, "ccaron", 0x010d, "ccedilla", 0x00e7, "ccedillaacute", 0x1e09, "ccircle", 0x24d2, "ccircumflex", 0x0109, "ccurl", 0x0255, "cdot", 0x010b, "cdotaccent", 0x010b, "cdsquare", 0x33c5, "cedilla", 0x00b8, "cedillacmb", 0x0327, "cent", 0x00a2, "centigrade", 0x2103, "centinferior", 0xf6df, "centmonospace", 0xffe0, "centoldstyle", 0xf7a2, "centsuperior", 0xf6e0, "chaarmenian", 0x0579, "chabengali", 0x099b, "chadeva", 0x091b, "chagujarati", 0x0a9b, "chagurmukhi", 0x0a1b, "chbopomofo", 0x3114, "cheabkhasiancyrillic", 0x04bd, "checkmark", 0x2713, "checyrillic", 0x0447, "chedescenderabkhasiancyrillic", 0x04bf, "chedescendercyrillic", 0x04b7, "chedieresiscyrillic", 0x04f5, "cheharmenian", 0x0573, "chekhakassiancyrillic", 0x04cc, "cheverticalstrokecyrillic", 0x04b9, "chi", 0x03c7, "chieuchacirclekorean", 0x3277, "chieuchaparenkorean", 0x3217, "chieuchcirclekorean", 0x3269, "chieuchkorean", 0x314a, "chieuchparenkorean", 0x3209, "chochangthai", 0x0e0a, "chochanthai", 0x0e08, "chochingthai", 0x0e09, "chochoethai", 0x0e0c, "chook", 0x0188, "cieucacirclekorean", 0x3276, "cieucaparenkorean", 0x3216, "cieuccirclekorean", 0x3268, "cieuckorean", 0x3148, "cieucparenkorean", 0x3208, "cieucuparenkorean", 0x321c, "circle", 0x25cb, "circlecopyrt", 0x00a9, "circlemultiply", 0x2297, "circleot", 0x2299, "circleplus", 0x2295, "circlepostalmark", 0x3036, "circlewithlefthalfblack", 0x25d0, "circlewithrighthalfblack", 0x25d1, "circumflex", 0x02c6, "circumflexbelowcmb", 0x032d, "circumflexcmb", 0x0302, "clear", 0x2327, "clickalveolar", 0x01c2, "clickdental", 0x01c0, "clicklateral", 0x01c1, "clickretroflex", 0x01c3, "club", 0x2663, "clubsuitblack", 0x2663, "clubsuitwhite", 0x2667, "cmcubedsquare", 0x33a4, "cmonospace", 0xff43, "cmsquaredsquare", 0x33a0, "coarmenian", 0x0581, "colon", 0x003a, "colonmonetary", 0x20a1, "colonmonospace", 0xff1a, "colonsign", 0x20a1, "colonsmall", 0xfe55, "colontriangularhalfmod", 0x02d1, "colontriangularmod", 0x02d0, "comma", 0x002c, "commaabovecmb", 0x0313, "commaaboverightcmb", 0x0315, "commaaccent", 0xf6c3, "commaarabic", 0x060c, "commaarmenian", 0x055d, "commainferior", 0xf6e1, "commamonospace", 0xff0c, "commareversedabovecmb", 0x0314, "commareversedmod", 0x02bd, "commasmall", 0xfe50, "commasuperior", 0xf6e2, "commaturnedabovecmb", 0x0312, "commaturnedmod", 0x02bb, "compass", 0x263c, "congruent", 0x2245, "contourintegral", 0x222e, "control", 0x2303, "controlACK", 0x0006, "controlBEL", 0x0007, "controlBS", 0x0008, "controlCAN", 0x0018, "controlCR", 0x000d, "controlDC1", 0x0011, "controlDC2", 0x0012, "controlDC3", 0x0013, "controlDC4", 0x0014, "controlDEL", 0x007f, "controlDLE", 0x0010, "controlEM", 0x0019, "controlENQ", 0x0005, "controlEOT", 0x0004, "controlESC", 0x001b, "controlETB", 0x0017, "controlETX", 0x0003, "controlFF", 0x000c, "controlFS", 0x001c, "controlGS", 0x001d, "controlHT", 0x0009, "controlLF", 0x000a, "controlNAK", 0x0015, "controlNULL", 0x0000, "controlRS", 0x001e, "controlSI", 0x000f, "controlSO", 0x000e, "controlSOT", 0x0002, "controlSTX", 0x0001, "controlSUB", 0x001a, "controlSYN", 0x0016, "controlUS", 0x001f, "controlVT", 0x000b, "copyright", 0x00a9, "copyrightsans", 0xf8e9, "copyrightserif", 0xf6d9, "cornerbracketleft", 0x300c, "cornerbracketlefthalfwidth", 0xff62, "cornerbracketleftvertical", 0xfe41, "cornerbracketright", 0x300d, "cornerbracketrighthalfwidth", 0xff63, "cornerbracketrightvertical", 0xfe42, "corporationsquare", 0x337f, "cosquare", 0x33c7, "coverkgsquare", 0x33c6, "cparen", 0x249e, "cruzeiro", 0x20a2, "cstretched", 0x0297, "curlyand", 0x22cf, "curlyor", 0x22ce, "currency", 0x00a4, "cyrBreve", 0xf6d1, "cyrFlex", 0xf6d2, "cyrbreve", 0xf6d4, "cyrflex", 0xf6d5, "d", 0x0064, "daarmenian", 0x0564, "dabengali", 0x09a6, "dadarabic", 0x0636, "dadeva", 0x0926, "dadfinalarabic", 0xfebe, "dadinitialarabic", 0xfebf, "dadmedialarabic", 0xfec0, "dagesh", 0x05bc, "dageshhebrew", 0x05bc, "dagger", 0x2020, "daggerdbl", 0x2021, "dagujarati", 0x0aa6, "dagurmukhi", 0x0a26, "dahiragana", 0x3060, "dakatakana", 0x30c0, "dalarabic", 0x062f, "dalet", 0x05d3, "daletdagesh", 0xfb33, "daletdageshhebrew", 0xfb33, "dalethebrew", 0x05d3, "dalfinalarabic", 0xfeaa, "dammaarabic", 0x064f, "dammalowarabic", 0x064f, "dammatanaltonearabic", 0x064c, "dammatanarabic", 0x064c, "danda", 0x0964, "dargahebrew", 0x05a7, "dargalefthebrew", 0x05a7, "dasiapneumatacyrilliccmb", 0x0485, "dblGrave", 0xf6d3, "dblanglebracketleft", 0x300a, "dblanglebracketleftvertical", 0xfe3d, "dblanglebracketright", 0x300b, "dblanglebracketrightvertical", 0xfe3e, "dblarchinvertedbelowcmb", 0x032b, "dblarrowleft", 0x21d4, "dblarrowright", 0x21d2, "dbldanda", 0x0965, "dblgrave", 0xf6d6, "dblgravecmb", 0x030f, "dblintegral", 0x222c, "dbllowline", 0x2017, "dbllowlinecmb", 0x0333, "dbloverlinecmb", 0x033f, "dblprimemod", 0x02ba, "dblverticalbar", 0x2016, "dblverticallineabovecmb", 0x030e, "dbopomofo", 0x3109, "dbsquare", 0x33c8, "dcaron", 0x010f, "dcedilla", 0x1e11, "dcircle", 0x24d3, "dcircumflexbelow", 0x1e13, "dcroat", 0x0111, "ddabengali", 0x09a1, "ddadeva", 0x0921, "ddagujarati", 0x0aa1, "ddagurmukhi", 0x0a21, "ddalarabic", 0x0688, "ddalfinalarabic", 0xfb89, "dddhadeva", 0x095c, "ddhabengali", 0x09a2, "ddhadeva", 0x0922, "ddhagujarati", 0x0aa2, "ddhagurmukhi", 0x0a22, "ddotaccent", 0x1e0b, "ddotbelow", 0x1e0d, "decimalseparatorarabic", 0x066b, "decimalseparatorpersian", 0x066b, "decyrillic", 0x0434, "degree", 0x00b0, "dehihebrew", 0x05ad, "dehiragana", 0x3067, "deicoptic", 0x03ef, "dekatakana", 0x30c7, "deleteleft", 0x232b, "deleteright", 0x2326, "delta", 0x03b4, "deltaturned", 0x018d, "denominatorminusonenumeratorbengali", 0x09f8, "dezh", 0x02a4, "dhabengali", 0x09a7, "dhadeva", 0x0927, "dhagujarati", 0x0aa7, "dhagurmukhi", 0x0a27, "dhook", 0x0257, "dialytikatonos", 0x0385, "dialytikatonoscmb", 0x0344, "diamond", 0x2666, "diamondsuitwhite", 0x2662, "dieresis", 0x00a8, "dieresisacute", 0xf6d7, "dieresisbelowcmb", 0x0324, "dieresiscmb", 0x0308, "dieresisgrave", 0xf6d8, "dieresistonos", 0x0385, "dihiragana", 0x3062, "dikatakana", 0x30c2, "dittomark", 0x3003, "divide", 0x00f7, "divides", 0x2223, "divisionslash", 0x2215, "djecyrillic", 0x0452, "dkshade", 0x2593, "dlinebelow", 0x1e0f, "dlsquare", 0x3397, "dmacron", 0x0111, "dmonospace", 0xff44, "dnblock", 0x2584, "dochadathai", 0x0e0e, "dodekthai", 0x0e14, "dohiragana", 0x3069, "dokatakana", 0x30c9, "dollar", 0x0024, "dollarinferior", 0xf6e3, "dollarmonospace", 0xff04, "dollaroldstyle", 0xf724, "dollarsmall", 0xfe69, "dollarsuperior", 0xf6e4, "dong", 0x20ab, "dorusquare", 0x3326, "dotaccent", 0x02d9, "dotaccentcmb", 0x0307, "dotbelowcmb", 0x0323, "dotbelowcomb", 0x0323, "dotkatakana", 0x30fb, "dotlessi", 0x0131, "dotlessj", 0xf6be, "dotlessjstrokehook", 0x0284, "dotmath", 0x22c5, "dottedcircle", 0x25cc, "doubleyodpatah", 0xfb1f, "doubleyodpatahhebrew", 0xfb1f, "downtackbelowcmb", 0x031e, "downtackmod", 0x02d5, "dparen", 0x249f, "dsuperior", 0xf6eb, "dtail", 0x0256, "dtopbar", 0x018c, "duhiragana", 0x3065, "dukatakana", 0x30c5, "dz", 0x01f3, "dzaltone", 0x02a3, "dzcaron", 0x01c6, "dzcurl", 0x02a5, "dzeabkhasiancyrillic", 0x04e1, "dzecyrillic", 0x0455, "dzhecyrillic", 0x045f, "e", 0x0065, "eacute", 0x00e9, "earth", 0x2641, "ebengali", 0x098f, "ebopomofo", 0x311c, "ebreve", 0x0115, "ecandradeva", 0x090d, "ecandragujarati", 0x0a8d, "ecandravowelsigndeva", 0x0945, "ecandravowelsigngujarati", 0x0ac5, "ecaron", 0x011b, "ecedillabreve", 0x1e1d, "echarmenian", 0x0565, "echyiwnarmenian", 0x0587, "ecircle", 0x24d4, "ecircumflex", 0x00ea, "ecircumflexacute", 0x1ebf, "ecircumflexbelow", 0x1e19, "ecircumflexdotbelow", 0x1ec7, "ecircumflexgrave", 0x1ec1, "ecircumflexhookabove", 0x1ec3, "ecircumflextilde", 0x1ec5, "ecyrillic", 0x0454, "edblgrave", 0x0205, "edeva", 0x090f, "edieresis", 0x00eb, "edot", 0x0117, "edotaccent", 0x0117, "edotbelow", 0x1eb9, "eegurmukhi", 0x0a0f, "eematragurmukhi", 0x0a47, "efcyrillic", 0x0444, "egrave", 0x00e8, "egujarati", 0x0a8f, "eharmenian", 0x0567, "ehbopomofo", 0x311d, "ehiragana", 0x3048, "ehookabove", 0x1ebb, "eibopomofo", 0x311f, "eight", 0x0038, "eightarabic", 0x0668, "eightbengali", 0x09ee, "eightcircle", 0x2467, "eightcircleinversesansserif", 0x2791, "eightdeva", 0x096e, "eighteencircle", 0x2471, "eighteenparen", 0x2485, "eighteenperiod", 0x2499, "eightgujarati", 0x0aee, "eightgurmukhi", 0x0a6e, "eighthackarabic", 0x0668, "eighthangzhou", 0x3028, "eighthnotebeamed", 0x266b, "eightideographicparen", 0x3227, "eightinferior", 0x2088, "eightmonospace", 0xff18, "eightoldstyle", 0xf738, "eightparen", 0x247b, "eightperiod", 0x248f, "eightpersian", 0x06f8, "eightroman", 0x2177, "eightsuperior", 0x2078, "eightthai", 0x0e58, "einvertedbreve", 0x0207, "eiotifiedcyrillic", 0x0465, "ekatakana", 0x30a8, "ekatakanahalfwidth", 0xff74, "ekonkargurmukhi", 0x0a74, "ekorean", 0x3154, "elcyrillic", 0x043b, "element", 0x2208, "elevencircle", 0x246a, "elevenparen", 0x247e, "elevenperiod", 0x2492, "elevenroman", 0x217a, "ellipsis", 0x2026, "ellipsisvertical", 0x22ee, "emacron", 0x0113, "emacronacute", 0x1e17, "emacrongrave", 0x1e15, "emcyrillic", 0x043c, "emdash", 0x2014, "emdashvertical", 0xfe31, "emonospace", 0xff45, "emphasismarkarmenian", 0x055b, "emptyset", 0x2205, "enbopomofo", 0x3123, "encyrillic", 0x043d, "endash", 0x2013, "endashvertical", 0xfe32, "endescendercyrillic", 0x04a3, "eng", 0x014b, "engbopomofo", 0x3125, "enghecyrillic", 0x04a5, "enhookcyrillic", 0x04c8, "enspace", 0x2002, "eogonek", 0x0119, "eokorean", 0x3153, "eopen", 0x025b, "eopenclosed", 0x029a, "eopenreversed", 0x025c, "eopenreversedclosed", 0x025e, "eopenreversedhook", 0x025d, "eparen", 0x24a0, "epsilon", 0x03b5, "epsilontonos", 0x03ad, "equal", 0x003d, "equalmonospace", 0xff1d, "equalsmall", 0xfe66, "equalsuperior", 0x207c, "equivalence", 0x2261, "erbopomofo", 0x3126, "ercyrillic", 0x0440, "ereversed", 0x0258, "ereversedcyrillic", 0x044d, "escyrillic", 0x0441, "esdescendercyrillic", 0x04ab, "esh", 0x0283, "eshcurl", 0x0286, "eshortdeva", 0x090e, "eshortvowelsigndeva", 0x0946, "eshreversedloop", 0x01aa, "eshsquatreversed", 0x0285, "esmallhiragana", 0x3047, "esmallkatakana", 0x30a7, "esmallkatakanahalfwidth", 0xff6a, "estimated", 0x212e, "esuperior", 0xf6ec, "eta", 0x03b7, "etarmenian", 0x0568, "etatonos", 0x03ae, "eth", 0x00f0, "etilde", 0x1ebd, "etildebelow", 0x1e1b, "etnahtafoukhhebrew", 0x0591, "etnahtafoukhlefthebrew", 0x0591, "etnahtahebrew", 0x0591, "etnahtalefthebrew", 0x0591, "eturned", 0x01dd, "eukorean", 0x3161, "euro", 0x20ac, "evowelsignbengali", 0x09c7, "evowelsigndeva", 0x0947, "evowelsigngujarati", 0x0ac7, "exclam", 0x0021, "exclamarmenian", 0x055c, "exclamdbl", 0x203c, "exclamdown", 0x00a1, "exclamdownsmall", 0xf7a1, "exclammonospace", 0xff01, "exclamsmall", 0xf721, "existential", 0x2203, "ezh", 0x0292, "ezhcaron", 0x01ef, "ezhcurl", 0x0293, "ezhreversed", 0x01b9, "ezhtail", 0x01ba, "f", 0x0066, "fadeva", 0x095e, "fagurmukhi", 0x0a5e, "fahrenheit", 0x2109, "fathaarabic", 0x064e, "fathalowarabic", 0x064e, "fathatanarabic", 0x064b, "fbopomofo", 0x3108, "fcircle", 0x24d5, "fdotaccent", 0x1e1f, "feharabic", 0x0641, "feharmenian", 0x0586, "fehfinalarabic", 0xfed2, "fehinitialarabic", 0xfed3, "fehmedialarabic", 0xfed4, "feicoptic", 0x03e5, "female", 0x2640, "ff", 0xfb00, "f_f", 0xfb00, "ffi", 0xfb03, "ffl", 0xfb04, "fi", 0xfb01, "fifteencircle", 0x246e, "fifteenparen", 0x2482, "fifteenperiod", 0x2496, "figuredash", 0x2012, "filledbox", 0x25a0, "filledrect", 0x25ac, "finalkaf", 0x05da, "finalkafdagesh", 0xfb3a, "finalkafdageshhebrew", 0xfb3a, "finalkafhebrew", 0x05da, "finalmem", 0x05dd, "finalmemhebrew", 0x05dd, "finalnun", 0x05df, "finalnunhebrew", 0x05df, "finalpe", 0x05e3, "finalpehebrew", 0x05e3, "finaltsadi", 0x05e5, "finaltsadihebrew", 0x05e5, "firsttonechinese", 0x02c9, "fisheye", 0x25c9, "fitacyrillic", 0x0473, "five", 0x0035, "fivearabic", 0x0665, "fivebengali", 0x09eb, "fivecircle", 0x2464, "fivecircleinversesansserif", 0x278e, "fivedeva", 0x096b, "fiveeighths", 0x215d, "fivegujarati", 0x0aeb, "fivegurmukhi", 0x0a6b, "fivehackarabic", 0x0665, "fivehangzhou", 0x3025, "fiveideographicparen", 0x3224, "fiveinferior", 0x2085, "fivemonospace", 0xff15, "fiveoldstyle", 0xf735, "fiveparen", 0x2478, "fiveperiod", 0x248c, "fivepersian", 0x06f5, "fiveroman", 0x2174, "fivesuperior", 0x2075, "fivethai", 0x0e55, "fl", 0xfb02, "florin", 0x0192, "fmonospace", 0xff46, "fmsquare", 0x3399, "fofanthai", 0x0e1f, "fofathai", 0x0e1d, "fongmanthai", 0x0e4f, "forall", 0x2200, "four", 0x0034, "fourarabic", 0x0664, "fourbengali", 0x09ea, "fourcircle", 0x2463, "fourcircleinversesansserif", 0x278d, "fourdeva", 0x096a, "fourgujarati", 0x0aea, "fourgurmukhi", 0x0a6a, "fourhackarabic", 0x0664, "fourhangzhou", 0x3024, "fourideographicparen", 0x3223, "fourinferior", 0x2084, "fourmonospace", 0xff14, "fournumeratorbengali", 0x09f7, "fouroldstyle", 0xf734, "fourparen", 0x2477, "fourperiod", 0x248b, "fourpersian", 0x06f4, "fourroman", 0x2173, "foursuperior", 0x2074, "fourteencircle", 0x246d, "fourteenparen", 0x2481, "fourteenperiod", 0x2495, "fourthai", 0x0e54, "fourthtonechinese", 0x02cb, "fparen", 0x24a1, "fraction", 0x2044, "franc", 0x20a3, "g", 0x0067, "gabengali", 0x0997, "gacute", 0x01f5, "gadeva", 0x0917, "gafarabic", 0x06af, "gaffinalarabic", 0xfb93, "gafinitialarabic", 0xfb94, "gafmedialarabic", 0xfb95, "gagujarati", 0x0a97, "gagurmukhi", 0x0a17, "gahiragana", 0x304c, "gakatakana", 0x30ac, "gamma", 0x03b3, "gammalatinsmall", 0x0263, "gammasuperior", 0x02e0, "gangiacoptic", 0x03eb, "gbopomofo", 0x310d, "gbreve", 0x011f, "gcaron", 0x01e7, "gcedilla", 0x0123, "gcircle", 0x24d6, "gcircumflex", 0x011d, "gcommaaccent", 0x0123, "gdot", 0x0121, "gdotaccent", 0x0121, "gecyrillic", 0x0433, "gehiragana", 0x3052, "gekatakana", 0x30b2, "geometricallyequal", 0x2251, "gereshaccenthebrew", 0x059c, "gereshhebrew", 0x05f3, "gereshmuqdamhebrew", 0x059d, "germandbls", 0x00df, "gershayimaccenthebrew", 0x059e, "gershayimhebrew", 0x05f4, "getamark", 0x3013, "ghabengali", 0x0998, "ghadarmenian", 0x0572, "ghadeva", 0x0918, "ghagujarati", 0x0a98, "ghagurmukhi", 0x0a18, "ghainarabic", 0x063a, "ghainfinalarabic", 0xfece, "ghaininitialarabic", 0xfecf, "ghainmedialarabic", 0xfed0, "ghemiddlehookcyrillic", 0x0495, "ghestrokecyrillic", 0x0493, "gheupturncyrillic", 0x0491, "ghhadeva", 0x095a, "ghhagurmukhi", 0x0a5a, "ghook", 0x0260, "ghzsquare", 0x3393, "gihiragana", 0x304e, "gikatakana", 0x30ae, "gimarmenian", 0x0563, "gimel", 0x05d2, "gimeldagesh", 0xfb32, "gimeldageshhebrew", 0xfb32, "gimelhebrew", 0x05d2, "gjecyrillic", 0x0453, "glottalinvertedstroke", 0x01be, "glottalstop", 0x0294, "glottalstopinverted", 0x0296, "glottalstopmod", 0x02c0, "glottalstopreversed", 0x0295, "glottalstopreversedmod", 0x02c1, "glottalstopreversedsuperior", 0x02e4, "glottalstopstroke", 0x02a1, "glottalstopstrokereversed", 0x02a2, "gmacron", 0x1e21, "gmonospace", 0xff47, "gohiragana", 0x3054, "gokatakana", 0x30b4, "gparen", 0x24a2, "gpasquare", 0x33ac, "gradient", 0x2207, "grave", 0x0060, "gravebelowcmb", 0x0316, "gravecmb", 0x0300, "gravecomb", 0x0300, "gravedeva", 0x0953, "gravelowmod", 0x02ce, "gravemonospace", 0xff40, "gravetonecmb", 0x0340, "greater", 0x003e, "greaterequal", 0x2265, "greaterequalorless", 0x22db, "greatermonospace", 0xff1e, "greaterorequivalent", 0x2273, "greaterorless", 0x2277, "greateroverequal", 0x2267, "greatersmall", 0xfe65, "gscript", 0x0261, "gstroke", 0x01e5, "guhiragana", 0x3050, "guillemotleft", 0x00ab, "guillemotright", 0x00bb, "guilsinglleft", 0x2039, "guilsinglright", 0x203a, "gukatakana", 0x30b0, "guramusquare", 0x3318, "gysquare", 0x33c9, "h", 0x0068, "haabkhasiancyrillic", 0x04a9, "haaltonearabic", 0x06c1, "habengali", 0x09b9, "hadescendercyrillic", 0x04b3, "hadeva", 0x0939, "hagujarati", 0x0ab9, "hagurmukhi", 0x0a39, "haharabic", 0x062d, "hahfinalarabic", 0xfea2, "hahinitialarabic", 0xfea3, "hahiragana", 0x306f, "hahmedialarabic", 0xfea4, "haitusquare", 0x332a, "hakatakana", 0x30cf, "hakatakanahalfwidth", 0xff8a, "halantgurmukhi", 0x0a4d, "hamzaarabic", 0x0621, "hamzalowarabic", 0x0621, "hangulfiller", 0x3164, "hardsigncyrillic", 0x044a, "harpoonleftbarbup", 0x21bc, "harpoonrightbarbup", 0x21c0, "hasquare", 0x33ca, "hatafpatah", 0x05b2, "hatafpatah16", 0x05b2, "hatafpatah23", 0x05b2, "hatafpatah2f", 0x05b2, "hatafpatahhebrew", 0x05b2, "hatafpatahnarrowhebrew", 0x05b2, "hatafpatahquarterhebrew", 0x05b2, "hatafpatahwidehebrew", 0x05b2, "hatafqamats", 0x05b3, "hatafqamats1b", 0x05b3, "hatafqamats28", 0x05b3, "hatafqamats34", 0x05b3, "hatafqamatshebrew", 0x05b3, "hatafqamatsnarrowhebrew", 0x05b3, "hatafqamatsquarterhebrew", 0x05b3, "hatafqamatswidehebrew", 0x05b3, "hatafsegol", 0x05b1, "hatafsegol17", 0x05b1, "hatafsegol24", 0x05b1, "hatafsegol30", 0x05b1, "hatafsegolhebrew", 0x05b1, "hatafsegolnarrowhebrew", 0x05b1, "hatafsegolquarterhebrew", 0x05b1, "hatafsegolwidehebrew", 0x05b1, "hbar", 0x0127, "hbopomofo", 0x310f, "hbrevebelow", 0x1e2b, "hcedilla", 0x1e29, "hcircle", 0x24d7, "hcircumflex", 0x0125, "hdieresis", 0x1e27, "hdotaccent", 0x1e23, "hdotbelow", 0x1e25, "he", 0x05d4, "heart", 0x2665, "heartsuitblack", 0x2665, "heartsuitwhite", 0x2661, "hedagesh", 0xfb34, "hedageshhebrew", 0xfb34, "hehaltonearabic", 0x06c1, "heharabic", 0x0647, "hehebrew", 0x05d4, "hehfinalaltonearabic", 0xfba7, "hehfinalalttwoarabic", 0xfeea, "hehfinalarabic", 0xfeea, "hehhamzaabovefinalarabic", 0xfba5, "hehhamzaaboveisolatedarabic", 0xfba4, "hehinitialaltonearabic", 0xfba8, "hehinitialarabic", 0xfeeb, "hehiragana", 0x3078, "hehmedialaltonearabic", 0xfba9, "hehmedialarabic", 0xfeec, "heiseierasquare", 0x337b, "hekatakana", 0x30d8, "hekatakanahalfwidth", 0xff8d, "hekutaarusquare", 0x3336, "henghook", 0x0267, "herutusquare", 0x3339, "het", 0x05d7, "hethebrew", 0x05d7, "hhook", 0x0266, "hhooksuperior", 0x02b1, "hieuhacirclekorean", 0x327b, "hieuhaparenkorean", 0x321b, "hieuhcirclekorean", 0x326d, "hieuhkorean", 0x314e, "hieuhparenkorean", 0x320d, "hihiragana", 0x3072, "hikatakana", 0x30d2, "hikatakanahalfwidth", 0xff8b, "hiriq", 0x05b4, "hiriq14", 0x05b4, "hiriq21", 0x05b4, "hiriq2d", 0x05b4, "hiriqhebrew", 0x05b4, "hiriqnarrowhebrew", 0x05b4, "hiriqquarterhebrew", 0x05b4, "hiriqwidehebrew", 0x05b4, "hlinebelow", 0x1e96, "hmonospace", 0xff48, "hoarmenian", 0x0570, "hohipthai", 0x0e2b, "hohiragana", 0x307b, "hokatakana", 0x30db, "hokatakanahalfwidth", 0xff8e, "holam", 0x05b9, "holam19", 0x05b9, "holam26", 0x05b9, "holam32", 0x05b9, "holamhebrew", 0x05b9, "holamnarrowhebrew", 0x05b9, "holamquarterhebrew", 0x05b9, "holamwidehebrew", 0x05b9, "honokhukthai", 0x0e2e, "hookabovecomb", 0x0309, "hookcmb", 0x0309, "hookpalatalizedbelowcmb", 0x0321, "hookretroflexbelowcmb", 0x0322, "hoonsquare", 0x3342, "horicoptic", 0x03e9, "horizontalbar", 0x2015, "horncmb", 0x031b, "hotsprings", 0x2668, "house", 0x2302, "hparen", 0x24a3, "hsuperior", 0x02b0, "hturned", 0x0265, "huhiragana", 0x3075, "huiitosquare", 0x3333, "hukatakana", 0x30d5, "hukatakanahalfwidth", 0xff8c, "hungarumlaut", 0x02dd, "hungarumlautcmb", 0x030b, "hv", 0x0195, "hyphen", 0x002d, "hypheninferior", 0xf6e5, "hyphenmonospace", 0xff0d, "hyphensmall", 0xfe63, "hyphensuperior", 0xf6e6, "hyphentwo", 0x2010, "i", 0x0069, "iacute", 0x00ed, "iacyrillic", 0x044f, "ibengali", 0x0987, "ibopomofo", 0x3127, "ibreve", 0x012d, "icaron", 0x01d0, "icircle", 0x24d8, "icircumflex", 0x00ee, "icyrillic", 0x0456, "idblgrave", 0x0209, "ideographearthcircle", 0x328f, "ideographfirecircle", 0x328b, "ideographicallianceparen", 0x323f, "ideographiccallparen", 0x323a, "ideographiccentrecircle", 0x32a5, "ideographicclose", 0x3006, "ideographiccomma", 0x3001, "ideographiccommaleft", 0xff64, "ideographiccongratulationparen", 0x3237, "ideographiccorrectcircle", 0x32a3, "ideographicearthparen", 0x322f, "ideographicenterpriseparen", 0x323d, "ideographicexcellentcircle", 0x329d, "ideographicfestivalparen", 0x3240, "ideographicfinancialcircle", 0x3296, "ideographicfinancialparen", 0x3236, "ideographicfireparen", 0x322b, "ideographichaveparen", 0x3232, "ideographichighcircle", 0x32a4, "ideographiciterationmark", 0x3005, "ideographiclaborcircle", 0x3298, "ideographiclaborparen", 0x3238, "ideographicleftcircle", 0x32a7, "ideographiclowcircle", 0x32a6, "ideographicmedicinecircle", 0x32a9, "ideographicmetalparen", 0x322e, "ideographicmoonparen", 0x322a, "ideographicnameparen", 0x3234, "ideographicperiod", 0x3002, "ideographicprintcircle", 0x329e, "ideographicreachparen", 0x3243, "ideographicrepresentparen", 0x3239, "ideographicresourceparen", 0x323e, "ideographicrightcircle", 0x32a8, "ideographicsecretcircle", 0x3299, "ideographicselfparen", 0x3242, "ideographicsocietyparen", 0x3233, "ideographicspace", 0x3000, "ideographicspecialparen", 0x3235, "ideographicstockparen", 0x3231, "ideographicstudyparen", 0x323b, "ideographicsunparen", 0x3230, "ideographicsuperviseparen", 0x323c, "ideographicwaterparen", 0x322c, "ideographicwoodparen", 0x322d, "ideographiczero", 0x3007, "ideographmetalcircle", 0x328e, "ideographmooncircle", 0x328a, "ideographnamecircle", 0x3294, "ideographsuncircle", 0x3290, "ideographwatercircle", 0x328c, "ideographwoodcircle", 0x328d, "ideva", 0x0907, "idieresis", 0x00ef, "idieresisacute", 0x1e2f, "idieresiscyrillic", 0x04e5, "idotbelow", 0x1ecb, "iebrevecyrillic", 0x04d7, "iecyrillic", 0x0435, "ieungacirclekorean", 0x3275, "ieungaparenkorean", 0x3215, "ieungcirclekorean", 0x3267, "ieungkorean", 0x3147, "ieungparenkorean", 0x3207, "igrave", 0x00ec, "igujarati", 0x0a87, "igurmukhi", 0x0a07, "ihiragana", 0x3044, "ihookabove", 0x1ec9, "iibengali", 0x0988, "iicyrillic", 0x0438, "iideva", 0x0908, "iigujarati", 0x0a88, "iigurmukhi", 0x0a08, "iimatragurmukhi", 0x0a40, "iinvertedbreve", 0x020b, "iishortcyrillic", 0x0439, "iivowelsignbengali", 0x09c0, "iivowelsigndeva", 0x0940, "iivowelsigngujarati", 0x0ac0, "ij", 0x0133, "ikatakana", 0x30a4, "ikatakanahalfwidth", 0xff72, "ikorean", 0x3163, "ilde", 0x02dc, "iluyhebrew", 0x05ac, "imacron", 0x012b, "imacroncyrillic", 0x04e3, "imageorapproximatelyequal", 0x2253, "imatragurmukhi", 0x0a3f, "imonospace", 0xff49, "increment", 0x2206, "infinity", 0x221e, "iniarmenian", 0x056b, "integral", 0x222b, "integralbottom", 0x2321, "integralbt", 0x2321, "integralex", 0xf8f5, "integraltop", 0x2320, "integraltp", 0x2320, "intersection", 0x2229, "intisquare", 0x3305, "invbullet", 0x25d8, "invcircle", 0x25d9, "invsmileface", 0x263b, "iocyrillic", 0x0451, "iogonek", 0x012f, "iota", 0x03b9, "iotadieresis", 0x03ca, "iotadieresistonos", 0x0390, "iotalatin", 0x0269, "iotatonos", 0x03af, "iparen", 0x24a4, "irigurmukhi", 0x0a72, "ismallhiragana", 0x3043, "ismallkatakana", 0x30a3, "ismallkatakanahalfwidth", 0xff68, "issharbengali", 0x09fa, "istroke", 0x0268, "isuperior", 0xf6ed, "iterationhiragana", 0x309d, "iterationkatakana", 0x30fd, "itilde", 0x0129, "itildebelow", 0x1e2d, "iubopomofo", 0x3129, "iucyrillic", 0x044e, "ivowelsignbengali", 0x09bf, "ivowelsigndeva", 0x093f, "ivowelsigngujarati", 0x0abf, "izhitsacyrillic", 0x0475, "izhitsadblgravecyrillic", 0x0477, "j", 0x006a, "jaarmenian", 0x0571, "jabengali", 0x099c, "jadeva", 0x091c, "jagujarati", 0x0a9c, "jagurmukhi", 0x0a1c, "jbopomofo", 0x3110, "jcaron", 0x01f0, "jcircle", 0x24d9, "jcircumflex", 0x0135, "jcrossedtail", 0x029d, "jdotlessstroke", 0x025f, "jecyrillic", 0x0458, "jeemarabic", 0x062c, "jeemfinalarabic", 0xfe9e, "jeeminitialarabic", 0xfe9f, "jeemmedialarabic", 0xfea0, "jeharabic", 0x0698, "jehfinalarabic", 0xfb8b, "jhabengali", 0x099d, "jhadeva", 0x091d, "jhagujarati", 0x0a9d, "jhagurmukhi", 0x0a1d, "jheharmenian", 0x057b, "jis", 0x3004, "jmonospace", 0xff4a, "jparen", 0x24a5, "jsuperior", 0x02b2, "k", 0x006b, "kabashkircyrillic", 0x04a1, "kabengali", 0x0995, "kacute", 0x1e31, "kacyrillic", 0x043a, "kadescendercyrillic", 0x049b, "kadeva", 0x0915, "kaf", 0x05db, "kafarabic", 0x0643, "kafdagesh", 0xfb3b, "kafdageshhebrew", 0xfb3b, "kaffinalarabic", 0xfeda, "kafhebrew", 0x05db, "kafinitialarabic", 0xfedb, "kafmedialarabic", 0xfedc, "kafrafehebrew", 0xfb4d, "kagujarati", 0x0a95, "kagurmukhi", 0x0a15, "kahiragana", 0x304b, "kahookcyrillic", 0x04c4, "kakatakana", 0x30ab, "kakatakanahalfwidth", 0xff76, "kappa", 0x03ba, "kappasymbolgreek", 0x03f0, "kapyeounmieumkorean", 0x3171, "kapyeounphieuphkorean", 0x3184, "kapyeounpieupkorean", 0x3178, "kapyeounssangpieupkorean", 0x3179, "karoriisquare", 0x330d, "kashidaautoarabic", 0x0640, "kashidaautonosidebearingarabic", 0x0640, "kasmallkatakana", 0x30f5, "kasquare", 0x3384, "kasraarabic", 0x0650, "kasratanarabic", 0x064d, "kastrokecyrillic", 0x049f, "katahiraprolongmarkhalfwidth", 0xff70, "kaverticalstrokecyrillic", 0x049d, "kbopomofo", 0x310e, "kcalsquare", 0x3389, "kcaron", 0x01e9, "kcedilla", 0x0137, "kcircle", 0x24da, "kcommaaccent", 0x0137, "kdotbelow", 0x1e33, "keharmenian", 0x0584, "kehiragana", 0x3051, "kekatakana", 0x30b1, "kekatakanahalfwidth", 0xff79, "kenarmenian", 0x056f, "kesmallkatakana", 0x30f6, "kgreenlandic", 0x0138, "khabengali", 0x0996, "khacyrillic", 0x0445, "khadeva", 0x0916, "khagujarati", 0x0a96, "khagurmukhi", 0x0a16, "khaharabic", 0x062e, "khahfinalarabic", 0xfea6, "khahinitialarabic", 0xfea7, "khahmedialarabic", 0xfea8, "kheicoptic", 0x03e7, "khhadeva", 0x0959, "khhagurmukhi", 0x0a59, "khieukhacirclekorean", 0x3278, "khieukhaparenkorean", 0x3218, "khieukhcirclekorean", 0x326a, "khieukhkorean", 0x314b, "khieukhparenkorean", 0x320a, "khokhaithai", 0x0e02, "khokhonthai", 0x0e05, "khokhuatthai", 0x0e03, "khokhwaithai", 0x0e04, "khomutthai", 0x0e5b, "khook", 0x0199, "khorakhangthai", 0x0e06, "khzsquare", 0x3391, "kihiragana", 0x304d, "kikatakana", 0x30ad, "kikatakanahalfwidth", 0xff77, "kiroguramusquare", 0x3315, "kiromeetorusquare", 0x3316, "kirosquare", 0x3314, "kiyeokacirclekorean", 0x326e, "kiyeokaparenkorean", 0x320e, "kiyeokcirclekorean", 0x3260, "kiyeokkorean", 0x3131, "kiyeokparenkorean", 0x3200, "kiyeoksioskorean", 0x3133, "kjecyrillic", 0x045c, "klinebelow", 0x1e35, "klsquare", 0x3398, "kmcubedsquare", 0x33a6, "kmonospace", 0xff4b, "kmsquaredsquare", 0x33a2, "kohiragana", 0x3053, "kohmsquare", 0x33c0, "kokaithai", 0x0e01, "kokatakana", 0x30b3, "kokatakanahalfwidth", 0xff7a, "kooposquare", 0x331e, "koppacyrillic", 0x0481, "koreanstandardsymbol", 0x327f, "koroniscmb", 0x0343, "kparen", 0x24a6, "kpasquare", 0x33aa, "ksicyrillic", 0x046f, "ktsquare", 0x33cf, "kturned", 0x029e, "kuhiragana", 0x304f, "kukatakana", 0x30af, "kukatakanahalfwidth", 0xff78, "kvsquare", 0x33b8, "kwsquare", 0x33be, "l", 0x006c, "labengali", 0x09b2, "lacute", 0x013a, "ladeva", 0x0932, "lagujarati", 0x0ab2, "lagurmukhi", 0x0a32, "lakkhangyaothai", 0x0e45, "lamaleffinalarabic", 0xfefc, "lamalefhamzaabovefinalarabic", 0xfef8, "lamalefhamzaaboveisolatedarabic", 0xfef7, "lamalefhamzabelowfinalarabic", 0xfefa, "lamalefhamzabelowisolatedarabic", 0xfef9, "lamalefisolatedarabic", 0xfefb, "lamalefmaddaabovefinalarabic", 0xfef6, "lamalefmaddaaboveisolatedarabic", 0xfef5, "lamarabic", 0x0644, "lambda", 0x03bb, "lambdastroke", 0x019b, "lamed", 0x05dc, "lameddagesh", 0xfb3c, "lameddageshhebrew", 0xfb3c, "lamedhebrew", 0x05dc, "lamfinalarabic", 0xfede, "lamhahinitialarabic", 0xfcca, "laminitialarabic", 0xfedf, "lamjeeminitialarabic", 0xfcc9, "lamkhahinitialarabic", 0xfccb, "lamlamhehisolatedarabic", 0xfdf2, "lammedialarabic", 0xfee0, "lammeemhahinitialarabic", 0xfd88, "lammeeminitialarabic", 0xfccc, "largecircle", 0x25ef, "lbar", 0x019a, "lbelt", 0x026c, "lbopomofo", 0x310c, "lcaron", 0x013e, "lcedilla", 0x013c, "lcircle", 0x24db, "lcircumflexbelow", 0x1e3d, "lcommaaccent", 0x013c, "ldot", 0x0140, "ldotaccent", 0x0140, "ldotbelow", 0x1e37, "ldotbelowmacron", 0x1e39, "leftangleabovecmb", 0x031a, "lefttackbelowcmb", 0x0318, "less", 0x003c, "lessequal", 0x2264, "lessequalorgreater", 0x22da, "lessmonospace", 0xff1c, "lessorequivalent", 0x2272, "lessorgreater", 0x2276, "lessoverequal", 0x2266, "lesssmall", 0xfe64, "lezh", 0x026e, "lfblock", 0x258c, "lhookretroflex", 0x026d, "lira", 0x20a4, "liwnarmenian", 0x056c, "lj", 0x01c9, "ljecyrillic", 0x0459, "ll", 0xf6c0, "lladeva", 0x0933, "llagujarati", 0x0ab3, "llinebelow", 0x1e3b, "llladeva", 0x0934, "llvocalicbengali", 0x09e1, "llvocalicdeva", 0x0961, "llvocalicvowelsignbengali", 0x09e3, "llvocalicvowelsigndeva", 0x0963, "lmiddletilde", 0x026b, "lmonospace", 0xff4c, "lmsquare", 0x33d0, "lochulathai", 0x0e2c, "logicaland", 0x2227, "logicalnot", 0x00ac, "logicalnotreversed", 0x2310, "logicalor", 0x2228, "lolingthai", 0x0e25, "longs", 0x017f, "lowlinecenterline", 0xfe4e, "lowlinecmb", 0x0332, "lowlinedashed", 0xfe4d, "lozenge", 0x25ca, "lparen", 0x24a7, "lslash", 0x0142, "lsquare", 0x2113, "lsuperior", 0xf6ee, "ltshade", 0x2591, "luthai", 0x0e26, "lvocalicbengali", 0x098c, "lvocalicdeva", 0x090c, "lvocalicvowelsignbengali", 0x09e2, "lvocalicvowelsigndeva", 0x0962, "lxsquare", 0x33d3, "m", 0x006d, "mabengali", 0x09ae, "macron", 0x00af, "macronbelowcmb", 0x0331, "macroncmb", 0x0304, "macronlowmod", 0x02cd, "macronmonospace", 0xffe3, "macute", 0x1e3f, "madeva", 0x092e, "magujarati", 0x0aae, "magurmukhi", 0x0a2e, "mahapakhhebrew", 0x05a4, "mahapakhlefthebrew", 0x05a4, "mahiragana", 0x307e, "maichattawalowleftthai", 0xf895, "maichattawalowrightthai", 0xf894, "maichattawathai", 0x0e4b, "maichattawaupperleftthai", 0xf893, "maieklowleftthai", 0xf88c, "maieklowrightthai", 0xf88b, "maiekthai", 0x0e48, "maiekupperleftthai", 0xf88a, "maihanakatleftthai", 0xf884, "maihanakatthai", 0x0e31, "maitaikhuleftthai", 0xf889, "maitaikhuthai", 0x0e47, "maitholowleftthai", 0xf88f, "maitholowrightthai", 0xf88e, "maithothai", 0x0e49, "maithoupperleftthai", 0xf88d, "maitrilowleftthai", 0xf892, "maitrilowrightthai", 0xf891, "maitrithai", 0x0e4a, "maitriupperleftthai", 0xf890, "maiyamokthai", 0x0e46, "makatakana", 0x30de, "makatakanahalfwidth", 0xff8f, "male", 0x2642, "mansyonsquare", 0x3347, "maqafhebrew", 0x05be, "mars", 0x2642, "masoracirclehebrew", 0x05af, "masquare", 0x3383, "mbopomofo", 0x3107, "mbsquare", 0x33d4, "mcircle", 0x24dc, "mcubedsquare", 0x33a5, "mdotaccent", 0x1e41, "mdotbelow", 0x1e43, "meemarabic", 0x0645, "meemfinalarabic", 0xfee2, "meeminitialarabic", 0xfee3, "meemmedialarabic", 0xfee4, "meemmeeminitialarabic", 0xfcd1, "meemmeemisolatedarabic", 0xfc48, "meetorusquare", 0x334d, "mehiragana", 0x3081, "meizierasquare", 0x337e, "mekatakana", 0x30e1, "mekatakanahalfwidth", 0xff92, "mem", 0x05de, "memdagesh", 0xfb3e, "memdageshhebrew", 0xfb3e, "memhebrew", 0x05de, "menarmenian", 0x0574, "merkhahebrew", 0x05a5, "merkhakefulahebrew", 0x05a6, "merkhakefulalefthebrew", 0x05a6, "merkhalefthebrew", 0x05a5, "mhook", 0x0271, "mhzsquare", 0x3392, "middledotkatakanahalfwidth", 0xff65, "middot", 0x00b7, "mieumacirclekorean", 0x3272, "mieumaparenkorean", 0x3212, "mieumcirclekorean", 0x3264, "mieumkorean", 0x3141, "mieumpansioskorean", 0x3170, "mieumparenkorean", 0x3204, "mieumpieupkorean", 0x316e, "mieumsioskorean", 0x316f, "mihiragana", 0x307f, "mikatakana", 0x30df, "mikatakanahalfwidth", 0xff90, "minus", 0x2212, "minusbelowcmb", 0x0320, "minuscircle", 0x2296, "minusmod", 0x02d7, "minusplus", 0x2213, "minute", 0x2032, "miribaarusquare", 0x334a, "mirisquare", 0x3349, "mlonglegturned", 0x0270, "mlsquare", 0x3396, "mmcubedsquare", 0x33a3, "mmonospace", 0xff4d, "mmsquaredsquare", 0x339f, "mohiragana", 0x3082, "mohmsquare", 0x33c1, "mokatakana", 0x30e2, "mokatakanahalfwidth", 0xff93, "molsquare", 0x33d6, "momathai", 0x0e21, "moverssquare", 0x33a7, "moverssquaredsquare", 0x33a8, "mparen", 0x24a8, "mpasquare", 0x33ab, "mssquare", 0x33b3, "msuperior", 0xf6ef, "mturned", 0x026f, "mu", 0x00b5, "mu1", 0x00b5, "muasquare", 0x3382, "muchgreater", 0x226b, "muchless", 0x226a, "mufsquare", 0x338c, "mugreek", 0x03bc, "mugsquare", 0x338d, "muhiragana", 0x3080, "mukatakana", 0x30e0, "mukatakanahalfwidth", 0xff91, "mulsquare", 0x3395, "multiply", 0x00d7, "mumsquare", 0x339b, "munahhebrew", 0x05a3, "munahlefthebrew", 0x05a3, "musicalnote", 0x266a, "musicalnotedbl", 0x266b, "musicflatsign", 0x266d, "musicsharpsign", 0x266f, "mussquare", 0x33b2, "muvsquare", 0x33b6, "muwsquare", 0x33bc, "mvmegasquare", 0x33b9, "mvsquare", 0x33b7, "mwmegasquare", 0x33bf, "mwsquare", 0x33bd, "n", 0x006e, "nabengali", 0x09a8, "nabla", 0x2207, "nacute", 0x0144, "nadeva", 0x0928, "nagujarati", 0x0aa8, "nagurmukhi", 0x0a28, "nahiragana", 0x306a, "nakatakana", 0x30ca, "nakatakanahalfwidth", 0xff85, "napostrophe", 0x0149, "nasquare", 0x3381, "nbopomofo", 0x310b, "nbspace", 0x00a0, "ncaron", 0x0148, "ncedilla", 0x0146, "ncircle", 0x24dd, "ncircumflexbelow", 0x1e4b, "ncommaaccent", 0x0146, "ndotaccent", 0x1e45, "ndotbelow", 0x1e47, "nehiragana", 0x306d, "nekatakana", 0x30cd, "nekatakanahalfwidth", 0xff88, "newsheqelsign", 0x20aa, "nfsquare", 0x338b, "ngabengali", 0x0999, "ngadeva", 0x0919, "ngagujarati", 0x0a99, "ngagurmukhi", 0x0a19, "ngonguthai", 0x0e07, "nhiragana", 0x3093, "nhookleft", 0x0272, "nhookretroflex", 0x0273, "nieunacirclekorean", 0x326f, "nieunaparenkorean", 0x320f, "nieuncieuckorean", 0x3135, "nieuncirclekorean", 0x3261, "nieunhieuhkorean", 0x3136, "nieunkorean", 0x3134, "nieunpansioskorean", 0x3168, "nieunparenkorean", 0x3201, "nieunsioskorean", 0x3167, "nieuntikeutkorean", 0x3166, "nihiragana", 0x306b, "nikatakana", 0x30cb, "nikatakanahalfwidth", 0xff86, "nikhahitleftthai", 0xf899, "nikhahitthai", 0x0e4d, "nine", 0x0039, "ninearabic", 0x0669, "ninebengali", 0x09ef, "ninecircle", 0x2468, "ninecircleinversesansserif", 0x2792, "ninedeva", 0x096f, "ninegujarati", 0x0aef, "ninegurmukhi", 0x0a6f, "ninehackarabic", 0x0669, "ninehangzhou", 0x3029, "nineideographicparen", 0x3228, "nineinferior", 0x2089, "ninemonospace", 0xff19, "nineoldstyle", 0xf739, "nineparen", 0x247c, "nineperiod", 0x2490, "ninepersian", 0x06f9, "nineroman", 0x2178, "ninesuperior", 0x2079, "nineteencircle", 0x2472, "nineteenparen", 0x2486, "nineteenperiod", 0x249a, "ninethai", 0x0e59, "nj", 0x01cc, "njecyrillic", 0x045a, "nkatakana", 0x30f3, "nkatakanahalfwidth", 0xff9d, "nlegrightlong", 0x019e, "nlinebelow", 0x1e49, "nmonospace", 0xff4e, "nmsquare", 0x339a, "nnabengali", 0x09a3, "nnadeva", 0x0923, "nnagujarati", 0x0aa3, "nnagurmukhi", 0x0a23, "nnnadeva", 0x0929, "nohiragana", 0x306e, "nokatakana", 0x30ce, "nokatakanahalfwidth", 0xff89, "nonbreakingspace", 0x00a0, "nonenthai", 0x0e13, "nonuthai", 0x0e19, "noonarabic", 0x0646, "noonfinalarabic", 0xfee6, "noonghunnaarabic", 0x06ba, "noonghunnafinalarabic", 0xfb9f, "nooninitialarabic", 0xfee7, "noonjeeminitialarabic", 0xfcd2, "noonjeemisolatedarabic", 0xfc4b, "noonmedialarabic", 0xfee8, "noonmeeminitialarabic", 0xfcd5, "noonmeemisolatedarabic", 0xfc4e, "noonnoonfinalarabic", 0xfc8d, "notcontains", 0x220c, "notelement", 0x2209, "notelementof", 0x2209, "notequal", 0x2260, "notgreater", 0x226f, "notgreaternorequal", 0x2271, "notgreaternorless", 0x2279, "notidentical", 0x2262, "notless", 0x226e, "notlessnorequal", 0x2270, "notparallel", 0x2226, "notprecedes", 0x2280, "notsubset", 0x2284, "notsucceeds", 0x2281, "notsuperset", 0x2285, "nowarmenian", 0x0576, "nparen", 0x24a9, "nssquare", 0x33b1, "nsuperior", 0x207f, "ntilde", 0x00f1, "nu", 0x03bd, "nuhiragana", 0x306c, "nukatakana", 0x30cc, "nukatakanahalfwidth", 0xff87, "nuktabengali", 0x09bc, "nuktadeva", 0x093c, "nuktagujarati", 0x0abc, "nuktagurmukhi", 0x0a3c, "numbersign", 0x0023, "numbersignmonospace", 0xff03, "numbersignsmall", 0xfe5f, "numeralsigngreek", 0x0374, "numeralsignlowergreek", 0x0375, "numero", 0x2116, "nun", 0x05e0, "nundagesh", 0xfb40, "nundageshhebrew", 0xfb40, "nunhebrew", 0x05e0, "nvsquare", 0x33b5, "nwsquare", 0x33bb, "nyabengali", 0x099e, "nyadeva", 0x091e, "nyagujarati", 0x0a9e, "nyagurmukhi", 0x0a1e, "o", 0x006f, "oacute", 0x00f3, "oangthai", 0x0e2d, "obarred", 0x0275, "obarredcyrillic", 0x04e9, "obarreddieresiscyrillic", 0x04eb, "obengali", 0x0993, "obopomofo", 0x311b, "obreve", 0x014f, "ocandradeva", 0x0911, "ocandragujarati", 0x0a91, "ocandravowelsigndeva", 0x0949, "ocandravowelsigngujarati", 0x0ac9, "ocaron", 0x01d2, "ocircle", 0x24de, "ocircumflex", 0x00f4, "ocircumflexacute", 0x1ed1, "ocircumflexdotbelow", 0x1ed9, "ocircumflexgrave", 0x1ed3, "ocircumflexhookabove", 0x1ed5, "ocircumflextilde", 0x1ed7, "ocyrillic", 0x043e, "odblacute", 0x0151, "odblgrave", 0x020d, "odeva", 0x0913, "odieresis", 0x00f6, "odieresiscyrillic", 0x04e7, "odotbelow", 0x1ecd, "oe", 0x0153, "oekorean", 0x315a, "ogonek", 0x02db, "ogonekcmb", 0x0328, "ograve", 0x00f2, "ogujarati", 0x0a93, "oharmenian", 0x0585, "ohiragana", 0x304a, "ohookabove", 0x1ecf, "ohorn", 0x01a1, "ohornacute", 0x1edb, "ohorndotbelow", 0x1ee3, "ohorngrave", 0x1edd, "ohornhookabove", 0x1edf, "ohorntilde", 0x1ee1, "ohungarumlaut", 0x0151, "oi", 0x01a3, "oinvertedbreve", 0x020f, "okatakana", 0x30aa, "okatakanahalfwidth", 0xff75, "okorean", 0x3157, "olehebrew", 0x05ab, "omacron", 0x014d, "omacronacute", 0x1e53, "omacrongrave", 0x1e51, "omdeva", 0x0950, "omega", 0x03c9, "omega1", 0x03d6, "omegacyrillic", 0x0461, "omegalatinclosed", 0x0277, "omegaroundcyrillic", 0x047b, "omegatitlocyrillic", 0x047d, "omegatonos", 0x03ce, "omgujarati", 0x0ad0, "omicron", 0x03bf, "omicrontonos", 0x03cc, "omonospace", 0xff4f, "one", 0x0031, "onearabic", 0x0661, "onebengali", 0x09e7, "onecircle", 0x2460, "onecircleinversesansserif", 0x278a, "onedeva", 0x0967, "onedotenleader", 0x2024, "oneeighth", 0x215b, "onefitted", 0xf6dc, "onegujarati", 0x0ae7, "onegurmukhi", 0x0a67, "onehackarabic", 0x0661, "onehalf", 0x00bd, "onehangzhou", 0x3021, "oneideographicparen", 0x3220, "oneinferior", 0x2081, "onemonospace", 0xff11, "onenumeratorbengali", 0x09f4, "oneoldstyle", 0xf731, "oneparen", 0x2474, "oneperiod", 0x2488, "onepersian", 0x06f1, "onequarter", 0x00bc, "oneroman", 0x2170, "onesuperior", 0x00b9, "onethai", 0x0e51, "onethird", 0x2153, "oogonek", 0x01eb, "oogonekmacron", 0x01ed, "oogurmukhi", 0x0a13, "oomatragurmukhi", 0x0a4b, "oopen", 0x0254, "oparen", 0x24aa, "openbullet", 0x25e6, "option", 0x2325, "ordfeminine", 0x00aa, "ordmasculine", 0x00ba, "orthogonal", 0x221f, "oshortdeva", 0x0912, "oshortvowelsigndeva", 0x094a, "oslash", 0x00f8, "oslashacute", 0x01ff, "osmallhiragana", 0x3049, "osmallkatakana", 0x30a9, "osmallkatakanahalfwidth", 0xff6b, "ostrokeacute", 0x01ff, "osuperior", 0xf6f0, "otcyrillic", 0x047f, "otilde", 0x00f5, "otildeacute", 0x1e4d, "otildedieresis", 0x1e4f, "oubopomofo", 0x3121, "overline", 0x203e, "overlinecenterline", 0xfe4a, "overlinecmb", 0x0305, "overlinedashed", 0xfe49, "overlinedblwavy", 0xfe4c, "overlinewavy", 0xfe4b, "overscore", 0x00af, "ovowelsignbengali", 0x09cb, "ovowelsigndeva", 0x094b, "ovowelsigngujarati", 0x0acb, "p", 0x0070, "paampssquare", 0x3380, "paasentosquare", 0x332b, "pabengali", 0x09aa, "pacute", 0x1e55, "padeva", 0x092a, "pagedown", 0x21df, "pageup", 0x21de, "pagujarati", 0x0aaa, "pagurmukhi", 0x0a2a, "pahiragana", 0x3071, "paiyannoithai", 0x0e2f, "pakatakana", 0x30d1, "palatalizationcyrilliccmb", 0x0484, "palochkacyrillic", 0x04c0, "pansioskorean", 0x317f, "paragraph", 0x00b6, "parallel", 0x2225, "parenleft", 0x0028, "parenleftaltonearabic", 0xfd3e, "parenleftbt", 0xf8ed, "parenleftex", 0xf8ec, "parenleftinferior", 0x208d, "parenleftmonospace", 0xff08, "parenleftsmall", 0xfe59, "parenleftsuperior", 0x207d, "parenlefttp", 0xf8eb, "parenleftvertical", 0xfe35, "parenright", 0x0029, "parenrightaltonearabic", 0xfd3f, "parenrightbt", 0xf8f8, "parenrightex", 0xf8f7, "parenrightinferior", 0x208e, "parenrightmonospace", 0xff09, "parenrightsmall", 0xfe5a, "parenrightsuperior", 0x207e, "parenrighttp", 0xf8f6, "parenrightvertical", 0xfe36, "partialdiff", 0x2202, "paseqhebrew", 0x05c0, "pashtahebrew", 0x0599, "pasquare", 0x33a9, "patah", 0x05b7, "patah11", 0x05b7, "patah1d", 0x05b7, "patah2a", 0x05b7, "patahhebrew", 0x05b7, "patahnarrowhebrew", 0x05b7, "patahquarterhebrew", 0x05b7, "patahwidehebrew", 0x05b7, "pazerhebrew", 0x05a1, "pbopomofo", 0x3106, "pcircle", 0x24df, "pdotaccent", 0x1e57, "pe", 0x05e4, "pecyrillic", 0x043f, "pedagesh", 0xfb44, "pedageshhebrew", 0xfb44, "peezisquare", 0x333b, "pefinaldageshhebrew", 0xfb43, "peharabic", 0x067e, "peharmenian", 0x057a, "pehebrew", 0x05e4, "pehfinalarabic", 0xfb57, "pehinitialarabic", 0xfb58, "pehiragana", 0x307a, "pehmedialarabic", 0xfb59, "pekatakana", 0x30da, "pemiddlehookcyrillic", 0x04a7, "perafehebrew", 0xfb4e, "percent", 0x0025, "percentarabic", 0x066a, "percentmonospace", 0xff05, "percentsmall", 0xfe6a, "period", 0x002e, "periodarmenian", 0x0589, "periodcentered", 0x00b7, "periodhalfwidth", 0xff61, "periodinferior", 0xf6e7, "periodmonospace", 0xff0e, "periodsmall", 0xfe52, "periodsuperior", 0xf6e8, "perispomenigreekcmb", 0x0342, "perpendicular", 0x22a5, "perthousand", 0x2030, "peseta", 0x20a7, "pfsquare", 0x338a, "phabengali", 0x09ab, "phadeva", 0x092b, "phagujarati", 0x0aab, "phagurmukhi", 0x0a2b, "phi", 0x03c6, "phi1", 0x03d5, "phieuphacirclekorean", 0x327a, "phieuphaparenkorean", 0x321a, "phieuphcirclekorean", 0x326c, "phieuphkorean", 0x314d, "phieuphparenkorean", 0x320c, "philatin", 0x0278, "phinthuthai", 0x0e3a, "phisymbolgreek", 0x03d5, "phook", 0x01a5, "phophanthai", 0x0e1e, "phophungthai", 0x0e1c, "phosamphaothai", 0x0e20, "pi", 0x03c0, "pieupacirclekorean", 0x3273, "pieupaparenkorean", 0x3213, "pieupcieuckorean", 0x3176, "pieupcirclekorean", 0x3265, "pieupkiyeokkorean", 0x3172, "pieupkorean", 0x3142, "pieupparenkorean", 0x3205, "pieupsioskiyeokkorean", 0x3174, "pieupsioskorean", 0x3144, "pieupsiostikeutkorean", 0x3175, "pieupthieuthkorean", 0x3177, "pieuptikeutkorean", 0x3173, "pihiragana", 0x3074, "pikatakana", 0x30d4, "pisymbolgreek", 0x03d6, "piwrarmenian", 0x0583, "plus", 0x002b, "plusbelowcmb", 0x031f, "pluscircle", 0x2295, "plusminus", 0x00b1, "plusmod", 0x02d6, "plusmonospace", 0xff0b, "plussmall", 0xfe62, "plussuperior", 0x207a, "pmonospace", 0xff50, "pmsquare", 0x33d8, "pohiragana", 0x307d, "pointingindexdownwhite", 0x261f, "pointingindexleftwhite", 0x261c, "pointingindexrightwhite", 0x261e, "pointingindexupwhite", 0x261d, "pokatakana", 0x30dd, "poplathai", 0x0e1b, "postalmark", 0x3012, "postalmarkface", 0x3020, "pparen", 0x24ab, "precedes", 0x227a, "prescription", 0x211e, "primemod", 0x02b9, "primereversed", 0x2035, "product", 0x220f, "projective", 0x2305, "prolongedkana", 0x30fc, "propellor", 0x2318, "propersubset", 0x2282, "propersuperset", 0x2283, "proportion", 0x2237, "proportional", 0x221d, "psi", 0x03c8, "psicyrillic", 0x0471, "psilipneumatacyrilliccmb", 0x0486, "pssquare", 0x33b0, "puhiragana", 0x3077, "pukatakana", 0x30d7, "pvsquare", 0x33b4, "pwsquare", 0x33ba, "q", 0x0071, "qadeva", 0x0958, "qadmahebrew", 0x05a8, "qafarabic", 0x0642, "qaffinalarabic", 0xfed6, "qafinitialarabic", 0xfed7, "qafmedialarabic", 0xfed8, "qamats", 0x05b8, "qamats10", 0x05b8, "qamats1a", 0x05b8, "qamats1c", 0x05b8, "qamats27", 0x05b8, "qamats29", 0x05b8, "qamats33", 0x05b8, "qamatsde", 0x05b8, "qamatshebrew", 0x05b8, "qamatsnarrowhebrew", 0x05b8, "qamatsqatanhebrew", 0x05b8, "qamatsqatannarrowhebrew", 0x05b8, "qamatsqatanquarterhebrew", 0x05b8, "qamatsqatanwidehebrew", 0x05b8, "qamatsquarterhebrew", 0x05b8, "qamatswidehebrew", 0x05b8, "qarneyparahebrew", 0x059f, "qbopomofo", 0x3111, "qcircle", 0x24e0, "qhook", 0x02a0, "qmonospace", 0xff51, "qof", 0x05e7, "qofdagesh", 0xfb47, "qofdageshhebrew", 0xfb47, "qofhebrew", 0x05e7, "qparen", 0x24ac, "quarternote", 0x2669, "qubuts", 0x05bb, "qubuts18", 0x05bb, "qubuts25", 0x05bb, "qubuts31", 0x05bb, "qubutshebrew", 0x05bb, "qubutsnarrowhebrew", 0x05bb, "qubutsquarterhebrew", 0x05bb, "qubutswidehebrew", 0x05bb, "question", 0x003f, "questionarabic", 0x061f, "questionarmenian", 0x055e, "questiondown", 0x00bf, "questiondownsmall", 0xf7bf, "questiongreek", 0x037e, "questionmonospace", 0xff1f, "questionsmall", 0xf73f, "quotedbl", 0x0022, "quotedblbase", 0x201e, "quotedblleft", 0x201c, "quotedblmonospace", 0xff02, "quotedblprime", 0x301e, "quotedblprimereversed", 0x301d, "quotedblright", 0x201d, "quoteleft", 0x2018, "quoteleftreversed", 0x201b, "quotereversed", 0x201b, "quoteright", 0x2019, "quoterightn", 0x0149, "quotesinglbase", 0x201a, "quotesingle", 0x0027, "quotesinglemonospace", 0xff07, "r", 0x0072, "raarmenian", 0x057c, "rabengali", 0x09b0, "racute", 0x0155, "radeva", 0x0930, "radical", 0x221a, "radicalex", 0xf8e5, "radoverssquare", 0x33ae, "radoverssquaredsquare", 0x33af, "radsquare", 0x33ad, "rafe", 0x05bf, "rafehebrew", 0x05bf, "ragujarati", 0x0ab0, "ragurmukhi", 0x0a30, "rahiragana", 0x3089, "rakatakana", 0x30e9, "rakatakanahalfwidth", 0xff97, "ralowerdiagonalbengali", 0x09f1, "ramiddlediagonalbengali", 0x09f0, "ramshorn", 0x0264, "ratio", 0x2236, "rbopomofo", 0x3116, "rcaron", 0x0159, "rcedilla", 0x0157, "rcircle", 0x24e1, "rcommaaccent", 0x0157, "rdblgrave", 0x0211, "rdotaccent", 0x1e59, "rdotbelow", 0x1e5b, "rdotbelowmacron", 0x1e5d, "referencemark", 0x203b, "reflexsubset", 0x2286, "reflexsuperset", 0x2287, "registered", 0x00ae, "registersans", 0xf8e8, "registerserif", 0xf6da, "reharabic", 0x0631, "reharmenian", 0x0580, "rehfinalarabic", 0xfeae, "rehiragana", 0x308c, "rekatakana", 0x30ec, "rekatakanahalfwidth", 0xff9a, "resh", 0x05e8, "reshdageshhebrew", 0xfb48, "reshhebrew", 0x05e8, "reversedtilde", 0x223d, "reviahebrew", 0x0597, "reviamugrashhebrew", 0x0597, "revlogicalnot", 0x2310, "rfishhook", 0x027e, "rfishhookreversed", 0x027f, "rhabengali", 0x09dd, "rhadeva", 0x095d, "rho", 0x03c1, "rhook", 0x027d, "rhookturned", 0x027b, "rhookturnedsuperior", 0x02b5, "rhosymbolgreek", 0x03f1, "rhotichookmod", 0x02de, "rieulacirclekorean", 0x3271, "rieulaparenkorean", 0x3211, "rieulcirclekorean", 0x3263, "rieulhieuhkorean", 0x3140, "rieulkiyeokkorean", 0x313a, "rieulkiyeoksioskorean", 0x3169, "rieulkorean", 0x3139, "rieulmieumkorean", 0x313b, "rieulpansioskorean", 0x316c, "rieulparenkorean", 0x3203, "rieulphieuphkorean", 0x313f, "rieulpieupkorean", 0x313c, "rieulpieupsioskorean", 0x316b, "rieulsioskorean", 0x313d, "rieulthieuthkorean", 0x313e, "rieultikeutkorean", 0x316a, "rieulyeorinhieuhkorean", 0x316d, "rightangle", 0x221f, "righttackbelowcmb", 0x0319, "righttriangle", 0x22bf, "rihiragana", 0x308a, "rikatakana", 0x30ea, "rikatakanahalfwidth", 0xff98, "ring", 0x02da, "ringbelowcmb", 0x0325, "ringcmb", 0x030a, "ringhalfleft", 0x02bf, "ringhalfleftarmenian", 0x0559, "ringhalfleftbelowcmb", 0x031c, "ringhalfleftcentered", 0x02d3, "ringhalfright", 0x02be, "ringhalfrightbelowcmb", 0x0339, "ringhalfrightcentered", 0x02d2, "rinvertedbreve", 0x0213, "rittorusquare", 0x3351, "rlinebelow", 0x1e5f, "rlongleg", 0x027c, "rlonglegturned", 0x027a, "rmonospace", 0xff52, "rohiragana", 0x308d, "rokatakana", 0x30ed, "rokatakanahalfwidth", 0xff9b, "roruathai", 0x0e23, "rparen", 0x24ad, "rrabengali", 0x09dc, "rradeva", 0x0931, "rragurmukhi", 0x0a5c, "rreharabic", 0x0691, "rrehfinalarabic", 0xfb8d, "rrvocalicbengali", 0x09e0, "rrvocalicdeva", 0x0960, "rrvocalicgujarati", 0x0ae0, "rrvocalicvowelsignbengali", 0x09c4, "rrvocalicvowelsigndeva", 0x0944, "rrvocalicvowelsigngujarati", 0x0ac4, "rsuperior", 0xf6f1, "rtblock", 0x2590, "rturned", 0x0279, "rturnedsuperior", 0x02b4, "ruhiragana", 0x308b, "rukatakana", 0x30eb, "rukatakanahalfwidth", 0xff99, "rupeemarkbengali", 0x09f2, "rupeesignbengali", 0x09f3, "rupiah", 0xf6dd, "ruthai", 0x0e24, "rvocalicbengali", 0x098b, "rvocalicdeva", 0x090b, "rvocalicgujarati", 0x0a8b, "rvocalicvowelsignbengali", 0x09c3, "rvocalicvowelsigndeva", 0x0943, "rvocalicvowelsigngujarati", 0x0ac3, "s", 0x0073, "sabengali", 0x09b8, "sacute", 0x015b, "sacutedotaccent", 0x1e65, "sadarabic", 0x0635, "sadeva", 0x0938, "sadfinalarabic", 0xfeba, "sadinitialarabic", 0xfebb, "sadmedialarabic", 0xfebc, "sagujarati", 0x0ab8, "sagurmukhi", 0x0a38, "sahiragana", 0x3055, "sakatakana", 0x30b5, "sakatakanahalfwidth", 0xff7b, "sallallahoualayhewasallamarabic", 0xfdfa, "samekh", 0x05e1, "samekhdagesh", 0xfb41, "samekhdageshhebrew", 0xfb41, "samekhhebrew", 0x05e1, "saraaathai", 0x0e32, "saraaethai", 0x0e41, "saraaimaimalaithai", 0x0e44, "saraaimaimuanthai", 0x0e43, "saraamthai", 0x0e33, "saraathai", 0x0e30, "saraethai", 0x0e40, "saraiileftthai", 0xf886, "saraiithai", 0x0e35, "saraileftthai", 0xf885, "saraithai", 0x0e34, "saraothai", 0x0e42, "saraueeleftthai", 0xf888, "saraueethai", 0x0e37, "saraueleftthai", 0xf887, "sarauethai", 0x0e36, "sarauthai", 0x0e38, "sarauuthai", 0x0e39, "sbopomofo", 0x3119, "scaron", 0x0161, "scarondotaccent", 0x1e67, "scedilla", 0x015f, "schwa", 0x0259, "schwacyrillic", 0x04d9, "schwadieresiscyrillic", 0x04db, "schwahook", 0x025a, "scircle", 0x24e2, "scircumflex", 0x015d, "scommaaccent", 0x0219, "sdotaccent", 0x1e61, "sdotbelow", 0x1e63, "sdotbelowdotaccent", 0x1e69, "seagullbelowcmb", 0x033c, "second", 0x2033, "secondtonechinese", 0x02ca, "section", 0x00a7, "seenarabic", 0x0633, "seenfinalarabic", 0xfeb2, "seeninitialarabic", 0xfeb3, "seenmedialarabic", 0xfeb4, "segol", 0x05b6, "segol13", 0x05b6, "segol1f", 0x05b6, "segol2c", 0x05b6, "segolhebrew", 0x05b6, "segolnarrowhebrew", 0x05b6, "segolquarterhebrew", 0x05b6, "segoltahebrew", 0x0592, "segolwidehebrew", 0x05b6, "seharmenian", 0x057d, "sehiragana", 0x305b, "sekatakana", 0x30bb, "sekatakanahalfwidth", 0xff7e, "semicolon", 0x003b, "semicolonarabic", 0x061b, "semicolonmonospace", 0xff1b, "semicolonsmall", 0xfe54, "semivoicedmarkkana", 0x309c, "semivoicedmarkkanahalfwidth", 0xff9f, "sentisquare", 0x3322, "sentosquare", 0x3323, "seven", 0x0037, "sevenarabic", 0x0667, "sevenbengali", 0x09ed, "sevencircle", 0x2466, "sevencircleinversesansserif", 0x2790, "sevendeva", 0x096d, "seveneighths", 0x215e, "sevengujarati", 0x0aed, "sevengurmukhi", 0x0a6d, "sevenhackarabic", 0x0667, "sevenhangzhou", 0x3027, "sevenideographicparen", 0x3226, "seveninferior", 0x2087, "sevenmonospace", 0xff17, "sevenoldstyle", 0xf737, "sevenparen", 0x247a, "sevenperiod", 0x248e, "sevenpersian", 0x06f7, "sevenroman", 0x2176, "sevensuperior", 0x2077, "seventeencircle", 0x2470, "seventeenparen", 0x2484, "seventeenperiod", 0x2498, "seventhai", 0x0e57, "sfthyphen", 0x00ad, "shaarmenian", 0x0577, "shabengali", 0x09b6, "shacyrillic", 0x0448, "shaddaarabic", 0x0651, "shaddadammaarabic", 0xfc61, "shaddadammatanarabic", 0xfc5e, "shaddafathaarabic", 0xfc60, "shaddakasraarabic", 0xfc62, "shaddakasratanarabic", 0xfc5f, "shade", 0x2592, "shadedark", 0x2593, "shadelight", 0x2591, "shademedium", 0x2592, "shadeva", 0x0936, "shagujarati", 0x0ab6, "shagurmukhi", 0x0a36, "shalshelethebrew", 0x0593, "shbopomofo", 0x3115, "shchacyrillic", 0x0449, "sheenarabic", 0x0634, "sheenfinalarabic", 0xfeb6, "sheeninitialarabic", 0xfeb7, "sheenmedialarabic", 0xfeb8, "sheicoptic", 0x03e3, "sheqel", 0x20aa, "sheqelhebrew", 0x20aa, "sheva", 0x05b0, "sheva115", 0x05b0, "sheva15", 0x05b0, "sheva22", 0x05b0, "sheva2e", 0x05b0, "shevahebrew", 0x05b0, "shevanarrowhebrew", 0x05b0, "shevaquarterhebrew", 0x05b0, "shevawidehebrew", 0x05b0, "shhacyrillic", 0x04bb, "shimacoptic", 0x03ed, "shin", 0x05e9, "shindagesh", 0xfb49, "shindageshhebrew", 0xfb49, "shindageshshindot", 0xfb2c, "shindageshshindothebrew", 0xfb2c, "shindageshsindot", 0xfb2d, "shindageshsindothebrew", 0xfb2d, "shindothebrew", 0x05c1, "shinhebrew", 0x05e9, "shinshindot", 0xfb2a, "shinshindothebrew", 0xfb2a, "shinsindot", 0xfb2b, "shinsindothebrew", 0xfb2b, "shook", 0x0282, "sigma", 0x03c3, "sigma1", 0x03c2, "sigmafinal", 0x03c2, "sigmalunatesymbolgreek", 0x03f2, "sihiragana", 0x3057, "sikatakana", 0x30b7, "sikatakanahalfwidth", 0xff7c, "siluqhebrew", 0x05bd, "siluqlefthebrew", 0x05bd, "similar", 0x223c, "sindothebrew", 0x05c2, "siosacirclekorean", 0x3274, "siosaparenkorean", 0x3214, "sioscieuckorean", 0x317e, "sioscirclekorean", 0x3266, "sioskiyeokkorean", 0x317a, "sioskorean", 0x3145, "siosnieunkorean", 0x317b, "siosparenkorean", 0x3206, "siospieupkorean", 0x317d, "siostikeutkorean", 0x317c, "six", 0x0036, "sixarabic", 0x0666, "sixbengali", 0x09ec, "sixcircle", 0x2465, "sixcircleinversesansserif", 0x278f, "sixdeva", 0x096c, "sixgujarati", 0x0aec, "sixgurmukhi", 0x0a6c, "sixhackarabic", 0x0666, "sixhangzhou", 0x3026, "sixideographicparen", 0x3225, "sixinferior", 0x2086, "sixmonospace", 0xff16, "sixoldstyle", 0xf736, "sixparen", 0x2479, "sixperiod", 0x248d, "sixpersian", 0x06f6, "sixroman", 0x2175, "sixsuperior", 0x2076, "sixteencircle", 0x246f, "sixteencurrencydenominatorbengali", 0x09f9, "sixteenparen", 0x2483, "sixteenperiod", 0x2497, "sixthai", 0x0e56, "slash", 0x002f, "slashmonospace", 0xff0f, "slong", 0x017f, "slongdotaccent", 0x1e9b, "smileface", 0x263a, "smonospace", 0xff53, "sofpasuqhebrew", 0x05c3, "softhyphen", 0x00ad, "softsigncyrillic", 0x044c, "sohiragana", 0x305d, "sokatakana", 0x30bd, "sokatakanahalfwidth", 0xff7f, "soliduslongoverlaycmb", 0x0338, "solidusshortoverlaycmb", 0x0337, "sorusithai", 0x0e29, "sosalathai", 0x0e28, "sosothai", 0x0e0b, "sosuathai", 0x0e2a, "space", 0x0020, "spacehackarabic", 0x0020, "spade", 0x2660, "spadesuitblack", 0x2660, "spadesuitwhite", 0x2664, "sparen", 0x24ae, "squarebelowcmb", 0x033b, "squarecc", 0x33c4, "squarecm", 0x339d, "squarediagonalcrosshatchfill", 0x25a9, "squarehorizontalfill", 0x25a4, "squarekg", 0x338f, "squarekm", 0x339e, "squarekmcapital", 0x33ce, "squareln", 0x33d1, "squarelog", 0x33d2, "squaremg", 0x338e, "squaremil", 0x33d5, "squaremm", 0x339c, "squaremsquared", 0x33a1, "squareorthogonalcrosshatchfill", 0x25a6, "squareupperlefttolowerrightfill", 0x25a7, "squareupperrighttolowerleftfill", 0x25a8, "squareverticalfill", 0x25a5, "squarewhitewithsmallblack", 0x25a3, "srsquare", 0x33db, "ssabengali", 0x09b7, "ssadeva", 0x0937, "ssagujarati", 0x0ab7, "ssangcieuckorean", 0x3149, "ssanghieuhkorean", 0x3185, "ssangieungkorean", 0x3180, "ssangkiyeokkorean", 0x3132, "ssangnieunkorean", 0x3165, "ssangpieupkorean", 0x3143, "ssangsioskorean", 0x3146, "ssangtikeutkorean", 0x3138, "ssuperior", 0xf6f2, "sterling", 0x00a3, "sterlingmonospace", 0xffe1, "strokelongoverlaycmb", 0x0336, "strokeshortoverlaycmb", 0x0335, "subset", 0x2282, "subsetnotequal", 0x228a, "subsetorequal", 0x2286, "succeeds", 0x227b, "suchthat", 0x220b, "suhiragana", 0x3059, "sukatakana", 0x30b9, "sukatakanahalfwidth", 0xff7d, "sukunarabic", 0x0652, "summation", 0x2211, "sun", 0x263c, "superset", 0x2283, "supersetnotequal", 0x228b, "supersetorequal", 0x2287, "svsquare", 0x33dc, "syouwaerasquare", 0x337c, "t", 0x0074, "tabengali", 0x09a4, "tackdown", 0x22a4, "tackleft", 0x22a3, "tadeva", 0x0924, "tagujarati", 0x0aa4, "tagurmukhi", 0x0a24, "taharabic", 0x0637, "tahfinalarabic", 0xfec2, "tahinitialarabic", 0xfec3, "tahiragana", 0x305f, "tahmedialarabic", 0xfec4, "taisyouerasquare", 0x337d, "takatakana", 0x30bf, "takatakanahalfwidth", 0xff80, "tatweelarabic", 0x0640, "tau", 0x03c4, "tav", 0x05ea, "tavdages", 0xfb4a, "tavdagesh", 0xfb4a, "tavdageshhebrew", 0xfb4a, "tavhebrew", 0x05ea, "tbar", 0x0167, "tbopomofo", 0x310a, "tcaron", 0x0165, "tccurl", 0x02a8, "tcedilla", 0x0163, "tcheharabic", 0x0686, "tchehfinalarabic", 0xfb7b, "tchehinitialarabic", 0xfb7c, "tchehmedialarabic", 0xfb7d, "tcircle", 0x24e3, "tcircumflexbelow", 0x1e71, "tcommaaccent", 0x0163, "tdieresis", 0x1e97, "tdotaccent", 0x1e6b, "tdotbelow", 0x1e6d, "tecyrillic", 0x0442, "tedescendercyrillic", 0x04ad, "teharabic", 0x062a, "tehfinalarabic", 0xfe96, "tehhahinitialarabic", 0xfca2, "tehhahisolatedarabic", 0xfc0c, "tehinitialarabic", 0xfe97, "tehiragana", 0x3066, "tehjeeminitialarabic", 0xfca1, "tehjeemisolatedarabic", 0xfc0b, "tehmarbutaarabic", 0x0629, "tehmarbutafinalarabic", 0xfe94, "tehmedialarabic", 0xfe98, "tehmeeminitialarabic", 0xfca4, "tehmeemisolatedarabic", 0xfc0e, "tehnoonfinalarabic", 0xfc73, "tekatakana", 0x30c6, "tekatakanahalfwidth", 0xff83, "telephone", 0x2121, "telephoneblack", 0x260e, "telishagedolahebrew", 0x05a0, "telishaqetanahebrew", 0x05a9, "tencircle", 0x2469, "tenideographicparen", 0x3229, "tenparen", 0x247d, "tenperiod", 0x2491, "tenroman", 0x2179, "tesh", 0x02a7, "tet", 0x05d8, "tetdagesh", 0xfb38, "tetdageshhebrew", 0xfb38, "tethebrew", 0x05d8, "tetsecyrillic", 0x04b5, "tevirhebrew", 0x059b, "tevirlefthebrew", 0x059b, "thabengali", 0x09a5, "thadeva", 0x0925, "thagujarati", 0x0aa5, "thagurmukhi", 0x0a25, "thalarabic", 0x0630, "thalfinalarabic", 0xfeac, "thanthakhatlowleftthai", 0xf898, "thanthakhatlowrightthai", 0xf897, "thanthakhatthai", 0x0e4c, "thanthakhatupperleftthai", 0xf896, "theharabic", 0x062b, "thehfinalarabic", 0xfe9a, "thehinitialarabic", 0xfe9b, "thehmedialarabic", 0xfe9c, "thereexists", 0x2203, "therefore", 0x2234, "theta", 0x03b8, "theta1", 0x03d1, "thetasymbolgreek", 0x03d1, "thieuthacirclekorean", 0x3279, "thieuthaparenkorean", 0x3219, "thieuthcirclekorean", 0x326b, "thieuthkorean", 0x314c, "thieuthparenkorean", 0x320b, "thirteencircle", 0x246c, "thirteenparen", 0x2480, "thirteenperiod", 0x2494, "thonangmonthothai", 0x0e11, "thook", 0x01ad, "thophuthaothai", 0x0e12, "thorn", 0x00fe, "thothahanthai", 0x0e17, "thothanthai", 0x0e10, "thothongthai", 0x0e18, "thothungthai", 0x0e16, "thousandcyrillic", 0x0482, "thousandsseparatorarabic", 0x066c, "thousandsseparatorpersian", 0x066c, "three", 0x0033, "threearabic", 0x0663, "threebengali", 0x09e9, "threecircle", 0x2462, "threecircleinversesansserif", 0x278c, "threedeva", 0x0969, "threeeighths", 0x215c, "threegujarati", 0x0ae9, "threegurmukhi", 0x0a69, "threehackarabic", 0x0663, "threehangzhou", 0x3023, "threeideographicparen", 0x3222, "threeinferior", 0x2083, "threemonospace", 0xff13, "threenumeratorbengali", 0x09f6, "threeoldstyle", 0xf733, "threeparen", 0x2476, "threeperiod", 0x248a, "threepersian", 0x06f3, "threequarters", 0x00be, "threequartersemdash", 0xf6de, "threeroman", 0x2172, "threesuperior", 0x00b3, "threethai", 0x0e53, "thzsquare", 0x3394, "tihiragana", 0x3061, "tikatakana", 0x30c1, "tikatakanahalfwidth", 0xff81, "tikeutacirclekorean", 0x3270, "tikeutaparenkorean", 0x3210, "tikeutcirclekorean", 0x3262, "tikeutkorean", 0x3137, "tikeutparenkorean", 0x3202, "tilde", 0x02dc, "tildebelowcmb", 0x0330, "tildecmb", 0x0303, "tildecomb", 0x0303, "tildedoublecmb", 0x0360, "tildeoperator", 0x223c, "tildeoverlaycmb", 0x0334, "tildeverticalcmb", 0x033e, "timescircle", 0x2297, "tipehahebrew", 0x0596, "tipehalefthebrew", 0x0596, "tippigurmukhi", 0x0a70, "titlocyrilliccmb", 0x0483, "tiwnarmenian", 0x057f, "tlinebelow", 0x1e6f, "tmonospace", 0xff54, "toarmenian", 0x0569, "tohiragana", 0x3068, "tokatakana", 0x30c8, "tokatakanahalfwidth", 0xff84, "tonebarextrahighmod", 0x02e5, "tonebarextralowmod", 0x02e9, "tonebarhighmod", 0x02e6, "tonebarlowmod", 0x02e8, "tonebarmidmod", 0x02e7, "tonefive", 0x01bd, "tonesix", 0x0185, "tonetwo", 0x01a8, "tonos", 0x0384, "tonsquare", 0x3327, "topatakthai", 0x0e0f, "tortoiseshellbracketleft", 0x3014, "tortoiseshellbracketleftsmall", 0xfe5d, "tortoiseshellbracketleftvertical", 0xfe39, "tortoiseshellbracketright", 0x3015, "tortoiseshellbracketrightsmall", 0xfe5e, "tortoiseshellbracketrightvertical", 0xfe3a, "totaothai", 0x0e15, "tpalatalhook", 0x01ab, "tparen", 0x24af, "trademark", 0x2122, "trademarksans", 0xf8ea, "trademarkserif", 0xf6db, "tretroflexhook", 0x0288, "triagdn", 0x25bc, "triaglf", 0x25c4, "triagrt", 0x25ba, "triagup", 0x25b2, "ts", 0x02a6, "tsadi", 0x05e6, "tsadidagesh", 0xfb46, "tsadidageshhebrew", 0xfb46, "tsadihebrew", 0x05e6, "tsecyrillic", 0x0446, "tsere", 0x05b5, "tsere12", 0x05b5, "tsere1e", 0x05b5, "tsere2b", 0x05b5, "tserehebrew", 0x05b5, "tserenarrowhebrew", 0x05b5, "tserequarterhebrew", 0x05b5, "tserewidehebrew", 0x05b5, "tshecyrillic", 0x045b, "tsuperior", 0xf6f3, "ttabengali", 0x099f, "ttadeva", 0x091f, "ttagujarati", 0x0a9f, "ttagurmukhi", 0x0a1f, "tteharabic", 0x0679, "ttehfinalarabic", 0xfb67, "ttehinitialarabic", 0xfb68, "ttehmedialarabic", 0xfb69, "tthabengali", 0x09a0, "tthadeva", 0x0920, "tthagujarati", 0x0aa0, "tthagurmukhi", 0x0a20, "tturned", 0x0287, "tuhiragana", 0x3064, "tukatakana", 0x30c4, "tukatakanahalfwidth", 0xff82, "tusmallhiragana", 0x3063, "tusmallkatakana", 0x30c3, "tusmallkatakanahalfwidth", 0xff6f, "twelvecircle", 0x246b, "twelveparen", 0x247f, "twelveperiod", 0x2493, "twelveroman", 0x217b, "twentycircle", 0x2473, "twentyhangzhou", 0x5344, "twentyparen", 0x2487, "twentyperiod", 0x249b, "two", 0x0032, "twoarabic", 0x0662, "twobengali", 0x09e8, "twocircle", 0x2461, "twocircleinversesansserif", 0x278b, "twodeva", 0x0968, "twodotenleader", 0x2025, "twodotleader", 0x2025, "twodotleadervertical", 0xfe30, "twogujarati", 0x0ae8, "twogurmukhi", 0x0a68, "twohackarabic", 0x0662, "twohangzhou", 0x3022, "twoideographicparen", 0x3221, "twoinferior", 0x2082, "twomonospace", 0xff12, "twonumeratorbengali", 0x09f5, "twooldstyle", 0xf732, "twoparen", 0x2475, "twoperiod", 0x2489, "twopersian", 0x06f2, "tworoman", 0x2171, "twostroke", 0x01bb, "twosuperior", 0x00b2, "twothai", 0x0e52, "twothirds", 0x2154, "u", 0x0075, "uacute", 0x00fa, "ubar", 0x0289, "ubengali", 0x0989, "ubopomofo", 0x3128, "ubreve", 0x016d, "ucaron", 0x01d4, "ucircle", 0x24e4, "ucircumflex", 0x00fb, "ucircumflexbelow", 0x1e77, "ucyrillic", 0x0443, "udattadeva", 0x0951, "udblacute", 0x0171, "udblgrave", 0x0215, "udeva", 0x0909, "udieresis", 0x00fc, "udieresisacute", 0x01d8, "udieresisbelow", 0x1e73, "udieresiscaron", 0x01da, "udieresiscyrillic", 0x04f1, "udieresisgrave", 0x01dc, "udieresismacron", 0x01d6, "udotbelow", 0x1ee5, "ugrave", 0x00f9, "ugujarati", 0x0a89, "ugurmukhi", 0x0a09, "uhiragana", 0x3046, "uhookabove", 0x1ee7, "uhorn", 0x01b0, "uhornacute", 0x1ee9, "uhorndotbelow", 0x1ef1, "uhorngrave", 0x1eeb, "uhornhookabove", 0x1eed, "uhorntilde", 0x1eef, "uhungarumlaut", 0x0171, "uhungarumlautcyrillic", 0x04f3, "uinvertedbreve", 0x0217, "ukatakana", 0x30a6, "ukatakanahalfwidth", 0xff73, "ukcyrillic", 0x0479, "ukorean", 0x315c, "umacron", 0x016b, "umacroncyrillic", 0x04ef, "umacrondieresis", 0x1e7b, "umatragurmukhi", 0x0a41, "umonospace", 0xff55, "underscore", 0x005f, "underscoredbl", 0x2017, "underscoremonospace", 0xff3f, "underscorevertical", 0xfe33, "underscorewavy", 0xfe4f, "union", 0x222a, "universal", 0x2200, "uogonek", 0x0173, "uparen", 0x24b0, "upblock", 0x2580, "upperdothebrew", 0x05c4, "upsilon", 0x03c5, "upsilondieresis", 0x03cb, "upsilondieresistonos", 0x03b0, "upsilonlatin", 0x028a, "upsilontonos", 0x03cd, "uptackbelowcmb", 0x031d, "uptackmod", 0x02d4, "uragurmukhi", 0x0a73, "uring", 0x016f, "ushortcyrillic", 0x045e, "usmallhiragana", 0x3045, "usmallkatakana", 0x30a5, "usmallkatakanahalfwidth", 0xff69, "ustraightcyrillic", 0x04af, "ustraightstrokecyrillic", 0x04b1, "utilde", 0x0169, "utildeacute", 0x1e79, "utildebelow", 0x1e75, "uubengali", 0x098a, "uudeva", 0x090a, "uugujarati", 0x0a8a, "uugurmukhi", 0x0a0a, "uumatragurmukhi", 0x0a42, "uuvowelsignbengali", 0x09c2, "uuvowelsigndeva", 0x0942, "uuvowelsigngujarati", 0x0ac2, "uvowelsignbengali", 0x09c1, "uvowelsigndeva", 0x0941, "uvowelsigngujarati", 0x0ac1, "v", 0x0076, "vadeva", 0x0935, "vagujarati", 0x0ab5, "vagurmukhi", 0x0a35, "vakatakana", 0x30f7, "vav", 0x05d5, "vavdagesh", 0xfb35, "vavdagesh65", 0xfb35, "vavdageshhebrew", 0xfb35, "vavhebrew", 0x05d5, "vavholam", 0xfb4b, "vavholamhebrew", 0xfb4b, "vavvavhebrew", 0x05f0, "vavyodhebrew", 0x05f1, "vcircle", 0x24e5, "vdotbelow", 0x1e7f, "vecyrillic", 0x0432, "veharabic", 0x06a4, "vehfinalarabic", 0xfb6b, "vehinitialarabic", 0xfb6c, "vehmedialarabic", 0xfb6d, "vekatakana", 0x30f9, "venus", 0x2640, "verticalbar", 0x007c, "verticallineabovecmb", 0x030d, "verticallinebelowcmb", 0x0329, "verticallinelowmod", 0x02cc, "verticallinemod", 0x02c8, "vewarmenian", 0x057e, "vhook", 0x028b, "vikatakana", 0x30f8, "viramabengali", 0x09cd, "viramadeva", 0x094d, "viramagujarati", 0x0acd, "visargabengali", 0x0983, "visargadeva", 0x0903, "visargagujarati", 0x0a83, "vmonospace", 0xff56, "voarmenian", 0x0578, "voicediterationhiragana", 0x309e, "voicediterationkatakana", 0x30fe, "voicedmarkkana", 0x309b, "voicedmarkkanahalfwidth", 0xff9e, "vokatakana", 0x30fa, "vparen", 0x24b1, "vtilde", 0x1e7d, "vturned", 0x028c, "vuhiragana", 0x3094, "vukatakana", 0x30f4, "w", 0x0077, "wacute", 0x1e83, "waekorean", 0x3159, "wahiragana", 0x308f, "wakatakana", 0x30ef, "wakatakanahalfwidth", 0xff9c, "wakorean", 0x3158, "wasmallhiragana", 0x308e, "wasmallkatakana", 0x30ee, "wattosquare", 0x3357, "wavedash", 0x301c, "wavyunderscorevertical", 0xfe34, "wawarabic", 0x0648, "wawfinalarabic", 0xfeee, "wawhamzaabovearabic", 0x0624, "wawhamzaabovefinalarabic", 0xfe86, "wbsquare", 0x33dd, "wcircle", 0x24e6, "wcircumflex", 0x0175, "wdieresis", 0x1e85, "wdotaccent", 0x1e87, "wdotbelow", 0x1e89, "wehiragana", 0x3091, "weierstrass", 0x2118, "wekatakana", 0x30f1, "wekorean", 0x315e, "weokorean", 0x315d, "wgrave", 0x1e81, "whitebullet", 0x25e6, "whitecircle", 0x25cb, "whitecircleinverse", 0x25d9, "whitecornerbracketleft", 0x300e, "whitecornerbracketleftvertical", 0xfe43, "whitecornerbracketright", 0x300f, "whitecornerbracketrightvertical", 0xfe44, "whitediamond", 0x25c7, "whitediamondcontainingblacksmalldiamond", 0x25c8, "whitedownpointingsmalltriangle", 0x25bf, "whitedownpointingtriangle", 0x25bd, "whiteleftpointingsmalltriangle", 0x25c3, "whiteleftpointingtriangle", 0x25c1, "whitelenticularbracketleft", 0x3016, "whitelenticularbracketright", 0x3017, "whiterightpointingsmalltriangle", 0x25b9, "whiterightpointingtriangle", 0x25b7, "whitesmallsquare", 0x25ab, "whitesmilingface", 0x263a, "whitesquare", 0x25a1, "whitestar", 0x2606, "whitetelephone", 0x260f, "whitetortoiseshellbracketleft", 0x3018, "whitetortoiseshellbracketright", 0x3019, "whiteuppointingsmalltriangle", 0x25b5, "whiteuppointingtriangle", 0x25b3, "wihiragana", 0x3090, "wikatakana", 0x30f0, "wikorean", 0x315f, "wmonospace", 0xff57, "wohiragana", 0x3092, "wokatakana", 0x30f2, "wokatakanahalfwidth", 0xff66, "won", 0x20a9, "wonmonospace", 0xffe6, "wowaenthai", 0x0e27, "wparen", 0x24b2, "wring", 0x1e98, "wsuperior", 0x02b7, "wturned", 0x028d, "wynn", 0x01bf, "x", 0x0078, "xabovecmb", 0x033d, "xbopomofo", 0x3112, "xcircle", 0x24e7, "xdieresis", 0x1e8d, "xdotaccent", 0x1e8b, "xeharmenian", 0x056d, "xi", 0x03be, "xmonospace", 0xff58, "xparen", 0x24b3, "xsuperior", 0x02e3, "y", 0x0079, "yaadosquare", 0x334e, "yabengali", 0x09af, "yacute", 0x00fd, "yadeva", 0x092f, "yaekorean", 0x3152, "yagujarati", 0x0aaf, "yagurmukhi", 0x0a2f, "yahiragana", 0x3084, "yakatakana", 0x30e4, "yakatakanahalfwidth", 0xff94, "yakorean", 0x3151, "yamakkanthai", 0x0e4e, "yasmallhiragana", 0x3083, "yasmallkatakana", 0x30e3, "yasmallkatakanahalfwidth", 0xff6c, "yatcyrillic", 0x0463, "ycircle", 0x24e8, "ycircumflex", 0x0177, "ydieresis", 0x00ff, "ydotaccent", 0x1e8f, "ydotbelow", 0x1ef5, "yeharabic", 0x064a, "yehbarreearabic", 0x06d2, "yehbarreefinalarabic", 0xfbaf, "yehfinalarabic", 0xfef2, "yehhamzaabovearabic", 0x0626, "yehhamzaabovefinalarabic", 0xfe8a, "yehhamzaaboveinitialarabic", 0xfe8b, "yehhamzaabovemedialarabic", 0xfe8c, "yehinitialarabic", 0xfef3, "yehmedialarabic", 0xfef4, "yehmeeminitialarabic", 0xfcdd, "yehmeemisolatedarabic", 0xfc58, "yehnoonfinalarabic", 0xfc94, "yehthreedotsbelowarabic", 0x06d1, "yekorean", 0x3156, "yen", 0x00a5, "yenmonospace", 0xffe5, "yeokorean", 0x3155, "yeorinhieuhkorean", 0x3186, "yerahbenyomohebrew", 0x05aa, "yerahbenyomolefthebrew", 0x05aa, "yericyrillic", 0x044b, "yerudieresiscyrillic", 0x04f9, "yesieungkorean", 0x3181, "yesieungpansioskorean", 0x3183, "yesieungsioskorean", 0x3182, "yetivhebrew", 0x059a, "ygrave", 0x1ef3, "yhook", 0x01b4, "yhookabove", 0x1ef7, "yiarmenian", 0x0575, "yicyrillic", 0x0457, "yikorean", 0x3162, "yinyang", 0x262f, "yiwnarmenian", 0x0582, "ymonospace", 0xff59, "yod", 0x05d9, "yoddagesh", 0xfb39, "yoddageshhebrew", 0xfb39, "yodhebrew", 0x05d9, "yodyodhebrew", 0x05f2, "yodyodpatahhebrew", 0xfb1f, "yohiragana", 0x3088, "yoikorean", 0x3189, "yokatakana", 0x30e8, "yokatakanahalfwidth", 0xff96, "yokorean", 0x315b, "yosmallhiragana", 0x3087, "yosmallkatakana", 0x30e7, "yosmallkatakanahalfwidth", 0xff6e, "yotgreek", 0x03f3, "yoyaekorean", 0x3188, "yoyakorean", 0x3187, "yoyakthai", 0x0e22, "yoyingthai", 0x0e0d, "yparen", 0x24b4, "ypogegrammeni", 0x037a, "ypogegrammenigreekcmb", 0x0345, "yr", 0x01a6, "yring", 0x1e99, "ysuperior", 0x02b8, "ytilde", 0x1ef9, "yturned", 0x028e, "yuhiragana", 0x3086, "yuikorean", 0x318c, "yukatakana", 0x30e6, "yukatakanahalfwidth", 0xff95, "yukorean", 0x3160, "yusbigcyrillic", 0x046b, "yusbigiotifiedcyrillic", 0x046d, "yuslittlecyrillic", 0x0467, "yuslittleiotifiedcyrillic", 0x0469, "yusmallhiragana", 0x3085, "yusmallkatakana", 0x30e5, "yusmallkatakanahalfwidth", 0xff6d, "yuyekorean", 0x318b, "yuyeokorean", 0x318a, "yyabengali", 0x09df, "yyadeva", 0x095f, "z", 0x007a, "zaarmenian", 0x0566, "zacute", 0x017a, "zadeva", 0x095b, "zagurmukhi", 0x0a5b, "zaharabic", 0x0638, "zahfinalarabic", 0xfec6, "zahinitialarabic", 0xfec7, "zahiragana", 0x3056, "zahmedialarabic", 0xfec8, "zainarabic", 0x0632, "zainfinalarabic", 0xfeb0, "zakatakana", 0x30b6, "zaqefgadolhebrew", 0x0595, "zaqefqatanhebrew", 0x0594, "zarqahebrew", 0x0598, "zayin", 0x05d6, "zayindagesh", 0xfb36, "zayindageshhebrew", 0xfb36, "zayinhebrew", 0x05d6, "zbopomofo", 0x3117, "zcaron", 0x017e, "zcircle", 0x24e9, "zcircumflex", 0x1e91, "zcurl", 0x0291, "zdot", 0x017c, "zdotaccent", 0x017c, "zdotbelow", 0x1e93, "zecyrillic", 0x0437, "zedescendercyrillic", 0x0499, "zedieresiscyrillic", 0x04df, "zehiragana", 0x305c, "zekatakana", 0x30bc, "zero", 0x0030, "zeroarabic", 0x0660, "zerobengali", 0x09e6, "zerodeva", 0x0966, "zerogujarati", 0x0ae6, "zerogurmukhi", 0x0a66, "zerohackarabic", 0x0660, "zeroinferior", 0x2080, "zeromonospace", 0xff10, "zerooldstyle", 0xf730, "zeropersian", 0x06f0, "zerosuperior", 0x2070, "zerothai", 0x0e50, "zerowidthjoiner", 0xfeff, "zerowidthnonjoiner", 0x200c, "zerowidthspace", 0x200b, "zeta", 0x03b6, "zhbopomofo", 0x3113, "zhearmenian", 0x056a, "zhebrevecyrillic", 0x04c2, "zhecyrillic", 0x0436, "zhedescendercyrillic", 0x0497, "zhedieresiscyrillic", 0x04dd, "zihiragana", 0x3058, "zikatakana", 0x30b8, "zinorhebrew", 0x05ae, "zlinebelow", 0x1e95, "zmonospace", 0xff5a, "zohiragana", 0x305e, "zokatakana", 0x30be, "zparen", 0x24b5, "zretroflexhook", 0x0290, "zstroke", 0x01b6, "zuhiragana", 0x305a, "zukatakana", 0x30ba, ".notdef", 0x0000, "angbracketleftbig", 0x2329, "angbracketleftBig", 0x2329, "angbracketleftbigg", 0x2329, "angbracketleftBigg", 0x2329, "angbracketrightBig", 0x232a, "angbracketrightbig", 0x232a, "angbracketrightBigg", 0x232a, "angbracketrightbigg", 0x232a, "arrowhookleft", 0x21aa, "arrowhookright", 0x21a9, "arrowlefttophalf", 0x21bc, "arrowleftbothalf", 0x21bd, "arrownortheast", 0x2197, "arrownorthwest", 0x2196, "arrowrighttophalf", 0x21c0, "arrowrightbothalf", 0x21c1, "arrowsoutheast", 0x2198, "arrowsouthwest", 0x2199, "backslashbig", 0x2216, "backslashBig", 0x2216, "backslashBigg", 0x2216, "backslashbigg", 0x2216, "bardbl", 0x2016, "bracehtipdownleft", 0xfe37, "bracehtipdownright", 0xfe37, "bracehtipupleft", 0xfe38, "bracehtipupright", 0xfe38, "braceleftBig", 0x007b, "braceleftbig", 0x007b, "braceleftbigg", 0x007b, "braceleftBigg", 0x007b, "bracerightBig", 0x007d, "bracerightbig", 0x007d, "bracerightbigg", 0x007d, "bracerightBigg", 0x007d, "bracketleftbig", 0x005b, "bracketleftBig", 0x005b, "bracketleftbigg", 0x005b, "bracketleftBigg", 0x005b, "bracketrightBig", 0x005d, "bracketrightbig", 0x005d, "bracketrightbigg", 0x005d, "bracketrightBigg", 0x005d, "ceilingleftbig", 0x2308, "ceilingleftBig", 0x2308, "ceilingleftBigg", 0x2308, "ceilingleftbigg", 0x2308, "ceilingrightbig", 0x2309, "ceilingrightBig", 0x2309, "ceilingrightbigg", 0x2309, "ceilingrightBigg", 0x2309, "circledotdisplay", 0x2299, "circledottext", 0x2299, "circlemultiplydisplay", 0x2297, "circlemultiplytext", 0x2297, "circleplusdisplay", 0x2295, "circleplustext", 0x2295, "contintegraldisplay", 0x222e, "contintegraltext", 0x222e, "coproductdisplay", 0x2210, "coproducttext", 0x2210, "floorleftBig", 0x230a, "floorleftbig", 0x230a, "floorleftbigg", 0x230a, "floorleftBigg", 0x230a, "floorrightbig", 0x230b, "floorrightBig", 0x230b, "floorrightBigg", 0x230b, "floorrightbigg", 0x230b, "hatwide", 0x0302, "hatwider", 0x0302, "hatwidest", 0x0302, "intercal", 0x1d40, "integraldisplay", 0x222b, "integraltext", 0x222b, "intersectiondisplay", 0x22c2, "intersectiontext", 0x22c2, "logicalanddisplay", 0x2227, "logicalandtext", 0x2227, "logicalordisplay", 0x2228, "logicalortext", 0x2228, "parenleftBig", 0x0028, "parenleftbig", 0x0028, "parenleftBigg", 0x0028, "parenleftbigg", 0x0028, "parenrightBig", 0x0029, "parenrightbig", 0x0029, "parenrightBigg", 0x0029, "parenrightbigg", 0x0029, "prime", 0x2032, "productdisplay", 0x220f, "producttext", 0x220f, "radicalbig", 0x221a, "radicalBig", 0x221a, "radicalBigg", 0x221a, "radicalbigg", 0x221a, "radicalbt", 0x221a, "radicaltp", 0x221a, "radicalvertex", 0x221a, "slashbig", 0x002f, "slashBig", 0x002f, "slashBigg", 0x002f, "slashbigg", 0x002f, "summationdisplay", 0x2211, "summationtext", 0x2211, "tildewide", 0x02dc, "tildewider", 0x02dc, "tildewidest", 0x02dc, "uniondisplay", 0x22c3, "unionmultidisplay", 0x228e, "unionmultitext", 0x228e, "unionsqdisplay", 0x2294, "unionsqtext", 0x2294, "uniontext", 0x22c3, "vextenddouble", 0x2225, "vextendsingle", 0x2223];
+});
+exports.getGlyphsUnicode = getGlyphsUnicode;
+var getDingbatsGlyphsUnicode = (0, _core_utils.getArrayLookupTableFactory)(function () {
+  return ["space", 0x0020, "a1", 0x2701, "a2", 0x2702, "a202", 0x2703, "a3", 0x2704, "a4", 0x260e, "a5", 0x2706, "a119", 0x2707, "a118", 0x2708, "a117", 0x2709, "a11", 0x261b, "a12", 0x261e, "a13", 0x270c, "a14", 0x270d, "a15", 0x270e, "a16", 0x270f, "a105", 0x2710, "a17", 0x2711, "a18", 0x2712, "a19", 0x2713, "a20", 0x2714, "a21", 0x2715, "a22", 0x2716, "a23", 0x2717, "a24", 0x2718, "a25", 0x2719, "a26", 0x271a, "a27", 0x271b, "a28", 0x271c, "a6", 0x271d, "a7", 0x271e, "a8", 0x271f, "a9", 0x2720, "a10", 0x2721, "a29", 0x2722, "a30", 0x2723, "a31", 0x2724, "a32", 0x2725, "a33", 0x2726, "a34", 0x2727, "a35", 0x2605, "a36", 0x2729, "a37", 0x272a, "a38", 0x272b, "a39", 0x272c, "a40", 0x272d, "a41", 0x272e, "a42", 0x272f, "a43", 0x2730, "a44", 0x2731, "a45", 0x2732, "a46", 0x2733, "a47", 0x2734, "a48", 0x2735, "a49", 0x2736, "a50", 0x2737, "a51", 0x2738, "a52", 0x2739, "a53", 0x273a, "a54", 0x273b, "a55", 0x273c, "a56", 0x273d, "a57", 0x273e, "a58", 0x273f, "a59", 0x2740, "a60", 0x2741, "a61", 0x2742, "a62", 0x2743, "a63", 0x2744, "a64", 0x2745, "a65", 0x2746, "a66", 0x2747, "a67", 0x2748, "a68", 0x2749, "a69", 0x274a, "a70", 0x274b, "a71", 0x25cf, "a72", 0x274d, "a73", 0x25a0, "a74", 0x274f, "a203", 0x2750, "a75", 0x2751, "a204", 0x2752, "a76", 0x25b2, "a77", 0x25bc, "a78", 0x25c6, "a79", 0x2756, "a81", 0x25d7, "a82", 0x2758, "a83", 0x2759, "a84", 0x275a, "a97", 0x275b, "a98", 0x275c, "a99", 0x275d, "a100", 0x275e, "a101", 0x2761, "a102", 0x2762, "a103", 0x2763, "a104", 0x2764, "a106", 0x2765, "a107", 0x2766, "a108", 0x2767, "a112", 0x2663, "a111", 0x2666, "a110", 0x2665, "a109", 0x2660, "a120", 0x2460, "a121", 0x2461, "a122", 0x2462, "a123", 0x2463, "a124", 0x2464, "a125", 0x2465, "a126", 0x2466, "a127", 0x2467, "a128", 0x2468, "a129", 0x2469, "a130", 0x2776, "a131", 0x2777, "a132", 0x2778, "a133", 0x2779, "a134", 0x277a, "a135", 0x277b, "a136", 0x277c, "a137", 0x277d, "a138", 0x277e, "a139", 0x277f, "a140", 0x2780, "a141", 0x2781, "a142", 0x2782, "a143", 0x2783, "a144", 0x2784, "a145", 0x2785, "a146", 0x2786, "a147", 0x2787, "a148", 0x2788, "a149", 0x2789, "a150", 0x278a, "a151", 0x278b, "a152", 0x278c, "a153", 0x278d, "a154", 0x278e, "a155", 0x278f, "a156", 0x2790, "a157", 0x2791, "a158", 0x2792, "a159", 0x2793, "a160", 0x2794, "a161", 0x2192, "a163", 0x2194, "a164", 0x2195, "a196", 0x2798, "a165", 0x2799, "a192", 0x279a, "a166", 0x279b, "a167", 0x279c, "a168", 0x279d, "a169", 0x279e, "a170", 0x279f, "a171", 0x27a0, "a172", 0x27a1, "a173", 0x27a2, "a162", 0x27a3, "a174", 0x27a4, "a175", 0x27a5, "a176", 0x27a6, "a177", 0x27a7, "a178", 0x27a8, "a179", 0x27a9, "a193", 0x27aa, "a180", 0x27ab, "a199", 0x27ac, "a181", 0x27ad, "a200", 0x27ae, "a182", 0x27af, "a201", 0x27b1, "a183", 0x27b2, "a184", 0x27b3, "a197", 0x27b4, "a185", 0x27b5, "a194", 0x27b6, "a198", 0x27b7, "a186", 0x27b8, "a195", 0x27b9, "a187", 0x27ba, "a188", 0x27bb, "a189", 0x27bc, "a190", 0x27bd, "a191", 0x27be, "a89", 0x2768, "a90", 0x2769, "a93", 0x276a, "a94", 0x276b, "a91", 0x276c, "a92", 0x276d, "a205", 0x276e, "a85", 0x276f, "a206", 0x2770, "a86", 0x2771, "a87", 0x2772, "a88", 0x2773, "a95", 0x2774, "a96", 0x2775, ".notdef", 0x0000];
+});
+exports.getDingbatsGlyphsUnicode = getDingbatsGlyphsUnicode;
+
+/***/ }),
+/* 36 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getSymbolsFonts = exports.getSupplementalGlyphMapForCalibri = exports.getSupplementalGlyphMapForArialBlack = exports.getStdFontMap = exports.getSerifFonts = exports.getNonStdFontMap = exports.getGlyphMapForStandardFonts = void 0;
+
+var _core_utils = __w_pdfjs_require__(8);
+
+const getStdFontMap = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t.ArialNarrow = "Helvetica";
+  t["ArialNarrow-Bold"] = "Helvetica-Bold";
+  t["ArialNarrow-BoldItalic"] = "Helvetica-BoldOblique";
+  t["ArialNarrow-Italic"] = "Helvetica-Oblique";
+  t.ArialBlack = "Helvetica";
+  t["ArialBlack-Bold"] = "Helvetica-Bold";
+  t["ArialBlack-BoldItalic"] = "Helvetica-BoldOblique";
+  t["ArialBlack-Italic"] = "Helvetica-Oblique";
+  t["Arial-Black"] = "Helvetica";
+  t["Arial-Black-Bold"] = "Helvetica-Bold";
+  t["Arial-Black-BoldItalic"] = "Helvetica-BoldOblique";
+  t["Arial-Black-Italic"] = "Helvetica-Oblique";
+  t.Arial = "Helvetica";
+  t["Arial-Bold"] = "Helvetica-Bold";
+  t["Arial-BoldItalic"] = "Helvetica-BoldOblique";
+  t["Arial-Italic"] = "Helvetica-Oblique";
+  t["Arial-BoldItalicMT"] = "Helvetica-BoldOblique";
+  t["Arial-BoldMT"] = "Helvetica-Bold";
+  t["Arial-ItalicMT"] = "Helvetica-Oblique";
+  t.ArialMT = "Helvetica";
+  t["Courier-Bold"] = "Courier-Bold";
+  t["Courier-BoldItalic"] = "Courier-BoldOblique";
+  t["Courier-Italic"] = "Courier-Oblique";
+  t.CourierNew = "Courier";
+  t["CourierNew-Bold"] = "Courier-Bold";
+  t["CourierNew-BoldItalic"] = "Courier-BoldOblique";
+  t["CourierNew-Italic"] = "Courier-Oblique";
+  t["CourierNewPS-BoldItalicMT"] = "Courier-BoldOblique";
+  t["CourierNewPS-BoldMT"] = "Courier-Bold";
+  t["CourierNewPS-ItalicMT"] = "Courier-Oblique";
+  t.CourierNewPSMT = "Courier";
+  t.Helvetica = "Helvetica";
+  t["Helvetica-Bold"] = "Helvetica-Bold";
+  t["Helvetica-BoldItalic"] = "Helvetica-BoldOblique";
+  t["Helvetica-BoldOblique"] = "Helvetica-BoldOblique";
+  t["Helvetica-Italic"] = "Helvetica-Oblique";
+  t["Helvetica-Oblique"] = "Helvetica-Oblique";
+  t["Symbol-Bold"] = "Symbol";
+  t["Symbol-BoldItalic"] = "Symbol";
+  t["Symbol-Italic"] = "Symbol";
+  t.TimesNewRoman = "Times-Roman";
+  t["TimesNewRoman-Bold"] = "Times-Bold";
+  t["TimesNewRoman-BoldItalic"] = "Times-BoldItalic";
+  t["TimesNewRoman-Italic"] = "Times-Italic";
+  t.TimesNewRomanPS = "Times-Roman";
+  t["TimesNewRomanPS-Bold"] = "Times-Bold";
+  t["TimesNewRomanPS-BoldItalic"] = "Times-BoldItalic";
+  t["TimesNewRomanPS-BoldItalicMT"] = "Times-BoldItalic";
+  t["TimesNewRomanPS-BoldMT"] = "Times-Bold";
+  t["TimesNewRomanPS-Italic"] = "Times-Italic";
+  t["TimesNewRomanPS-ItalicMT"] = "Times-Italic";
+  t.TimesNewRomanPSMT = "Times-Roman";
+  t["TimesNewRomanPSMT-Bold"] = "Times-Bold";
+  t["TimesNewRomanPSMT-BoldItalic"] = "Times-BoldItalic";
+  t["TimesNewRomanPSMT-Italic"] = "Times-Italic";
+});
+exports.getStdFontMap = getStdFontMap;
+const getNonStdFontMap = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t.Calibri = "Helvetica";
+  t["Calibri-Bold"] = "Helvetica-Bold";
+  t["Calibri-BoldItalic"] = "Helvetica-BoldOblique";
+  t["Calibri-Italic"] = "Helvetica-Oblique";
+  t.CenturyGothic = "Helvetica";
+  t["CenturyGothic-Bold"] = "Helvetica-Bold";
+  t["CenturyGothic-BoldItalic"] = "Helvetica-BoldOblique";
+  t["CenturyGothic-Italic"] = "Helvetica-Oblique";
+  t.ComicSansMS = "Comic Sans MS";
+  t["ComicSansMS-Bold"] = "Comic Sans MS-Bold";
+  t["ComicSansMS-BoldItalic"] = "Comic Sans MS-BoldItalic";
+  t["ComicSansMS-Italic"] = "Comic Sans MS-Italic";
+  t.LucidaConsole = "Courier";
+  t["LucidaConsole-Bold"] = "Courier-Bold";
+  t["LucidaConsole-BoldItalic"] = "Courier-BoldOblique";
+  t["LucidaConsole-Italic"] = "Courier-Oblique";
+  t["LucidaSans-Demi"] = "Helvetica-Bold";
+  t["MS-Gothic"] = "MS Gothic";
+  t["MS-Gothic-Bold"] = "MS Gothic-Bold";
+  t["MS-Gothic-BoldItalic"] = "MS Gothic-BoldItalic";
+  t["MS-Gothic-Italic"] = "MS Gothic-Italic";
+  t["MS-Mincho"] = "MS Mincho";
+  t["MS-Mincho-Bold"] = "MS Mincho-Bold";
+  t["MS-Mincho-BoldItalic"] = "MS Mincho-BoldItalic";
+  t["MS-Mincho-Italic"] = "MS Mincho-Italic";
+  t["MS-PGothic"] = "MS PGothic";
+  t["MS-PGothic-Bold"] = "MS PGothic-Bold";
+  t["MS-PGothic-BoldItalic"] = "MS PGothic-BoldItalic";
+  t["MS-PGothic-Italic"] = "MS PGothic-Italic";
+  t["MS-PMincho"] = "MS PMincho";
+  t["MS-PMincho-Bold"] = "MS PMincho-Bold";
+  t["MS-PMincho-BoldItalic"] = "MS PMincho-BoldItalic";
+  t["MS-PMincho-Italic"] = "MS PMincho-Italic";
+  t.NuptialScript = "Times-Italic";
+  t.SegoeUISymbol = "Helvetica";
+  t.Wingdings = "ZapfDingbats";
+  t["Wingdings-Regular"] = "ZapfDingbats";
+});
+exports.getNonStdFontMap = getNonStdFontMap;
+const getSerifFonts = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t["Adobe Jenson"] = true;
+  t["Adobe Text"] = true;
+  t.Albertus = true;
+  t.Aldus = true;
+  t.Alexandria = true;
+  t.Algerian = true;
+  t["American Typewriter"] = true;
+  t.Antiqua = true;
+  t.Apex = true;
+  t.Arno = true;
+  t.Aster = true;
+  t.Aurora = true;
+  t.Baskerville = true;
+  t.Bell = true;
+  t.Bembo = true;
+  t["Bembo Schoolbook"] = true;
+  t.Benguiat = true;
+  t["Berkeley Old Style"] = true;
+  t["Bernhard Modern"] = true;
+  t["Berthold City"] = true;
+  t.Bodoni = true;
+  t["Bauer Bodoni"] = true;
+  t["Book Antiqua"] = true;
+  t.Bookman = true;
+  t["Bordeaux Roman"] = true;
+  t["Californian FB"] = true;
+  t.Calisto = true;
+  t.Calvert = true;
+  t.Capitals = true;
+  t.Cambria = true;
+  t.Cartier = true;
+  t.Caslon = true;
+  t.Catull = true;
+  t.Centaur = true;
+  t["Century Old Style"] = true;
+  t["Century Schoolbook"] = true;
+  t.Chaparral = true;
+  t["Charis SIL"] = true;
+  t.Cheltenham = true;
+  t["Cholla Slab"] = true;
+  t.Clarendon = true;
+  t.Clearface = true;
+  t.Cochin = true;
+  t.Colonna = true;
+  t["Computer Modern"] = true;
+  t["Concrete Roman"] = true;
+  t.Constantia = true;
+  t["Cooper Black"] = true;
+  t.Corona = true;
+  t.Ecotype = true;
+  t.Egyptienne = true;
+  t.Elephant = true;
+  t.Excelsior = true;
+  t.Fairfield = true;
+  t["FF Scala"] = true;
+  t.Folkard = true;
+  t.Footlight = true;
+  t.FreeSerif = true;
+  t["Friz Quadrata"] = true;
+  t.Garamond = true;
+  t.Gentium = true;
+  t.Georgia = true;
+  t.Gloucester = true;
+  t["Goudy Old Style"] = true;
+  t["Goudy Schoolbook"] = true;
+  t["Goudy Pro Font"] = true;
+  t.Granjon = true;
+  t["Guardian Egyptian"] = true;
+  t.Heather = true;
+  t.Hercules = true;
+  t["High Tower Text"] = true;
+  t.Hiroshige = true;
+  t["Hoefler Text"] = true;
+  t["Humana Serif"] = true;
+  t.Imprint = true;
+  t["Ionic No. 5"] = true;
+  t.Janson = true;
+  t.Joanna = true;
+  t.Korinna = true;
+  t.Lexicon = true;
+  t["Liberation Serif"] = true;
+  t["Linux Libertine"] = true;
+  t.Literaturnaya = true;
+  t.Lucida = true;
+  t["Lucida Bright"] = true;
+  t.Melior = true;
+  t.Memphis = true;
+  t.Miller = true;
+  t.Minion = true;
+  t.Modern = true;
+  t["Mona Lisa"] = true;
+  t["Mrs Eaves"] = true;
+  t["MS Serif"] = true;
+  t["Museo Slab"] = true;
+  t["New York"] = true;
+  t["Nimbus Roman"] = true;
+  t["NPS Rawlinson Roadway"] = true;
+  t.NuptialScript = true;
+  t.Palatino = true;
+  t.Perpetua = true;
+  t.Plantin = true;
+  t["Plantin Schoolbook"] = true;
+  t.Playbill = true;
+  t["Poor Richard"] = true;
+  t["Rawlinson Roadway"] = true;
+  t.Renault = true;
+  t.Requiem = true;
+  t.Rockwell = true;
+  t.Roman = true;
+  t["Rotis Serif"] = true;
+  t.Sabon = true;
+  t.Scala = true;
+  t.Seagull = true;
+  t.Sistina = true;
+  t.Souvenir = true;
+  t.STIX = true;
+  t["Stone Informal"] = true;
+  t["Stone Serif"] = true;
+  t.Sylfaen = true;
+  t.Times = true;
+  t.Trajan = true;
+  t["Trinité"] = true;
+  t["Trump Mediaeval"] = true;
+  t.Utopia = true;
+  t["Vale Type"] = true;
+  t["Bitstream Vera"] = true;
+  t["Vera Serif"] = true;
+  t.Versailles = true;
+  t.Wanted = true;
+  t.Weiss = true;
+  t["Wide Latin"] = true;
+  t.Windsor = true;
+  t.XITS = true;
+});
+exports.getSerifFonts = getSerifFonts;
+const getSymbolsFonts = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t.Dingbats = true;
+  t.Symbol = true;
+  t.ZapfDingbats = true;
+});
+exports.getSymbolsFonts = getSymbolsFonts;
+const getGlyphMapForStandardFonts = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t[2] = 10;
+  t[3] = 32;
+  t[4] = 33;
+  t[5] = 34;
+  t[6] = 35;
+  t[7] = 36;
+  t[8] = 37;
+  t[9] = 38;
+  t[10] = 39;
+  t[11] = 40;
+  t[12] = 41;
+  t[13] = 42;
+  t[14] = 43;
+  t[15] = 44;
+  t[16] = 45;
+  t[17] = 46;
+  t[18] = 47;
+  t[19] = 48;
+  t[20] = 49;
+  t[21] = 50;
+  t[22] = 51;
+  t[23] = 52;
+  t[24] = 53;
+  t[25] = 54;
+  t[26] = 55;
+  t[27] = 56;
+  t[28] = 57;
+  t[29] = 58;
+  t[30] = 894;
+  t[31] = 60;
+  t[32] = 61;
+  t[33] = 62;
+  t[34] = 63;
+  t[35] = 64;
+  t[36] = 65;
+  t[37] = 66;
+  t[38] = 67;
+  t[39] = 68;
+  t[40] = 69;
+  t[41] = 70;
+  t[42] = 71;
+  t[43] = 72;
+  t[44] = 73;
+  t[45] = 74;
+  t[46] = 75;
+  t[47] = 76;
+  t[48] = 77;
+  t[49] = 78;
+  t[50] = 79;
+  t[51] = 80;
+  t[52] = 81;
+  t[53] = 82;
+  t[54] = 83;
+  t[55] = 84;
+  t[56] = 85;
+  t[57] = 86;
+  t[58] = 87;
+  t[59] = 88;
+  t[60] = 89;
+  t[61] = 90;
+  t[62] = 91;
+  t[63] = 92;
+  t[64] = 93;
+  t[65] = 94;
+  t[66] = 95;
+  t[67] = 96;
+  t[68] = 97;
+  t[69] = 98;
+  t[70] = 99;
+  t[71] = 100;
+  t[72] = 101;
+  t[73] = 102;
+  t[74] = 103;
+  t[75] = 104;
+  t[76] = 105;
+  t[77] = 106;
+  t[78] = 107;
+  t[79] = 108;
+  t[80] = 109;
+  t[81] = 110;
+  t[82] = 111;
+  t[83] = 112;
+  t[84] = 113;
+  t[85] = 114;
+  t[86] = 115;
+  t[87] = 116;
+  t[88] = 117;
+  t[89] = 118;
+  t[90] = 119;
+  t[91] = 120;
+  t[92] = 121;
+  t[93] = 122;
+  t[94] = 123;
+  t[95] = 124;
+  t[96] = 125;
+  t[97] = 126;
+  t[98] = 196;
+  t[99] = 197;
+  t[100] = 199;
+  t[101] = 201;
+  t[102] = 209;
+  t[103] = 214;
+  t[104] = 220;
+  t[105] = 225;
+  t[106] = 224;
+  t[107] = 226;
+  t[108] = 228;
+  t[109] = 227;
+  t[110] = 229;
+  t[111] = 231;
+  t[112] = 233;
+  t[113] = 232;
+  t[114] = 234;
+  t[115] = 235;
+  t[116] = 237;
+  t[117] = 236;
+  t[118] = 238;
+  t[119] = 239;
+  t[120] = 241;
+  t[121] = 243;
+  t[122] = 242;
+  t[123] = 244;
+  t[124] = 246;
+  t[125] = 245;
+  t[126] = 250;
+  t[127] = 249;
+  t[128] = 251;
+  t[129] = 252;
+  t[130] = 8224;
+  t[131] = 176;
+  t[132] = 162;
+  t[133] = 163;
+  t[134] = 167;
+  t[135] = 8226;
+  t[136] = 182;
+  t[137] = 223;
+  t[138] = 174;
+  t[139] = 169;
+  t[140] = 8482;
+  t[141] = 180;
+  t[142] = 168;
+  t[143] = 8800;
+  t[144] = 198;
+  t[145] = 216;
+  t[146] = 8734;
+  t[147] = 177;
+  t[148] = 8804;
+  t[149] = 8805;
+  t[150] = 165;
+  t[151] = 181;
+  t[152] = 8706;
+  t[153] = 8721;
+  t[154] = 8719;
+  t[156] = 8747;
+  t[157] = 170;
+  t[158] = 186;
+  t[159] = 8486;
+  t[160] = 230;
+  t[161] = 248;
+  t[162] = 191;
+  t[163] = 161;
+  t[164] = 172;
+  t[165] = 8730;
+  t[166] = 402;
+  t[167] = 8776;
+  t[168] = 8710;
+  t[169] = 171;
+  t[170] = 187;
+  t[171] = 8230;
+  t[210] = 218;
+  t[223] = 711;
+  t[224] = 321;
+  t[225] = 322;
+  t[227] = 353;
+  t[229] = 382;
+  t[234] = 253;
+  t[252] = 263;
+  t[253] = 268;
+  t[254] = 269;
+  t[258] = 258;
+  t[260] = 260;
+  t[261] = 261;
+  t[265] = 280;
+  t[266] = 281;
+  t[268] = 283;
+  t[269] = 313;
+  t[275] = 323;
+  t[276] = 324;
+  t[278] = 328;
+  t[284] = 345;
+  t[285] = 346;
+  t[286] = 347;
+  t[292] = 367;
+  t[295] = 377;
+  t[296] = 378;
+  t[298] = 380;
+  t[305] = 963;
+  t[306] = 964;
+  t[307] = 966;
+  t[308] = 8215;
+  t[309] = 8252;
+  t[310] = 8319;
+  t[311] = 8359;
+  t[312] = 8592;
+  t[313] = 8593;
+  t[337] = 9552;
+  t[493] = 1039;
+  t[494] = 1040;
+  t[705] = 1524;
+  t[706] = 8362;
+  t[710] = 64288;
+  t[711] = 64298;
+  t[759] = 1617;
+  t[761] = 1776;
+  t[763] = 1778;
+  t[775] = 1652;
+  t[777] = 1764;
+  t[778] = 1780;
+  t[779] = 1781;
+  t[780] = 1782;
+  t[782] = 771;
+  t[783] = 64726;
+  t[786] = 8363;
+  t[788] = 8532;
+  t[790] = 768;
+  t[791] = 769;
+  t[792] = 768;
+  t[795] = 803;
+  t[797] = 64336;
+  t[798] = 64337;
+  t[799] = 64342;
+  t[800] = 64343;
+  t[801] = 64344;
+  t[802] = 64345;
+  t[803] = 64362;
+  t[804] = 64363;
+  t[805] = 64364;
+  t[2424] = 7821;
+  t[2425] = 7822;
+  t[2426] = 7823;
+  t[2427] = 7824;
+  t[2428] = 7825;
+  t[2429] = 7826;
+  t[2430] = 7827;
+  t[2433] = 7682;
+  t[2678] = 8045;
+  t[2679] = 8046;
+  t[2830] = 1552;
+  t[2838] = 686;
+  t[2840] = 751;
+  t[2842] = 753;
+  t[2843] = 754;
+  t[2844] = 755;
+  t[2846] = 757;
+  t[2856] = 767;
+  t[2857] = 848;
+  t[2858] = 849;
+  t[2862] = 853;
+  t[2863] = 854;
+  t[2864] = 855;
+  t[2865] = 861;
+  t[2866] = 862;
+  t[2906] = 7460;
+  t[2908] = 7462;
+  t[2909] = 7463;
+  t[2910] = 7464;
+  t[2912] = 7466;
+  t[2913] = 7467;
+  t[2914] = 7468;
+  t[2916] = 7470;
+  t[2917] = 7471;
+  t[2918] = 7472;
+  t[2920] = 7474;
+  t[2921] = 7475;
+  t[2922] = 7476;
+  t[2924] = 7478;
+  t[2925] = 7479;
+  t[2926] = 7480;
+  t[2928] = 7482;
+  t[2929] = 7483;
+  t[2930] = 7484;
+  t[2932] = 7486;
+  t[2933] = 7487;
+  t[2934] = 7488;
+  t[2936] = 7490;
+  t[2937] = 7491;
+  t[2938] = 7492;
+  t[2940] = 7494;
+  t[2941] = 7495;
+  t[2942] = 7496;
+  t[2944] = 7498;
+  t[2946] = 7500;
+  t[2948] = 7502;
+  t[2950] = 7504;
+  t[2951] = 7505;
+  t[2952] = 7506;
+  t[2954] = 7508;
+  t[2955] = 7509;
+  t[2956] = 7510;
+  t[2958] = 7512;
+  t[2959] = 7513;
+  t[2960] = 7514;
+  t[2962] = 7516;
+  t[2963] = 7517;
+  t[2964] = 7518;
+  t[2966] = 7520;
+  t[2967] = 7521;
+  t[2968] = 7522;
+  t[2970] = 7524;
+  t[2971] = 7525;
+  t[2972] = 7526;
+  t[2974] = 7528;
+  t[2975] = 7529;
+  t[2976] = 7530;
+  t[2978] = 1537;
+  t[2979] = 1538;
+  t[2980] = 1539;
+  t[2982] = 1549;
+  t[2983] = 1551;
+  t[2984] = 1552;
+  t[2986] = 1554;
+  t[2987] = 1555;
+  t[2988] = 1556;
+  t[2990] = 1623;
+  t[2991] = 1624;
+  t[2995] = 1775;
+  t[2999] = 1791;
+  t[3002] = 64290;
+  t[3003] = 64291;
+  t[3004] = 64292;
+  t[3006] = 64294;
+  t[3007] = 64295;
+  t[3008] = 64296;
+  t[3011] = 1900;
+  t[3014] = 8223;
+  t[3015] = 8244;
+  t[3017] = 7532;
+  t[3018] = 7533;
+  t[3019] = 7534;
+  t[3075] = 7590;
+  t[3076] = 7591;
+  t[3079] = 7594;
+  t[3080] = 7595;
+  t[3083] = 7598;
+  t[3084] = 7599;
+  t[3087] = 7602;
+  t[3088] = 7603;
+  t[3091] = 7606;
+  t[3092] = 7607;
+  t[3095] = 7610;
+  t[3096] = 7611;
+  t[3099] = 7614;
+  t[3100] = 7615;
+  t[3103] = 7618;
+  t[3104] = 7619;
+  t[3107] = 8337;
+  t[3108] = 8338;
+  t[3116] = 1884;
+  t[3119] = 1885;
+  t[3120] = 1885;
+  t[3123] = 1886;
+  t[3124] = 1886;
+  t[3127] = 1887;
+  t[3128] = 1887;
+  t[3131] = 1888;
+  t[3132] = 1888;
+  t[3135] = 1889;
+  t[3136] = 1889;
+  t[3139] = 1890;
+  t[3140] = 1890;
+  t[3143] = 1891;
+  t[3144] = 1891;
+  t[3147] = 1892;
+  t[3148] = 1892;
+  t[3153] = 580;
+  t[3154] = 581;
+  t[3157] = 584;
+  t[3158] = 585;
+  t[3161] = 588;
+  t[3162] = 589;
+  t[3165] = 891;
+  t[3166] = 892;
+  t[3169] = 1274;
+  t[3170] = 1275;
+  t[3173] = 1278;
+  t[3174] = 1279;
+  t[3181] = 7622;
+  t[3182] = 7623;
+  t[3282] = 11799;
+  t[3316] = 578;
+  t[3379] = 42785;
+  t[3393] = 1159;
+  t[3416] = 8377;
+});
+exports.getGlyphMapForStandardFonts = getGlyphMapForStandardFonts;
+const getSupplementalGlyphMapForArialBlack = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t[227] = 322;
+  t[264] = 261;
+  t[291] = 346;
+});
+exports.getSupplementalGlyphMapForArialBlack = getSupplementalGlyphMapForArialBlack;
+const getSupplementalGlyphMapForCalibri = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t[1] = 32;
+  t[4] = 65;
+  t[17] = 66;
+  t[18] = 67;
+  t[24] = 68;
+  t[28] = 69;
+  t[38] = 70;
+  t[39] = 71;
+  t[44] = 72;
+  t[47] = 73;
+  t[58] = 74;
+  t[60] = 75;
+  t[62] = 76;
+  t[68] = 77;
+  t[69] = 78;
+  t[75] = 79;
+  t[87] = 80;
+  t[89] = 81;
+  t[90] = 82;
+  t[94] = 83;
+  t[100] = 84;
+  t[104] = 85;
+  t[115] = 86;
+  t[116] = 87;
+  t[121] = 88;
+  t[122] = 89;
+  t[127] = 90;
+  t[258] = 97;
+  t[268] = 261;
+  t[271] = 98;
+  t[272] = 99;
+  t[273] = 263;
+  t[282] = 100;
+  t[286] = 101;
+  t[295] = 281;
+  t[296] = 102;
+  t[336] = 103;
+  t[346] = 104;
+  t[349] = 105;
+  t[361] = 106;
+  t[364] = 107;
+  t[367] = 108;
+  t[371] = 322;
+  t[373] = 109;
+  t[374] = 110;
+  t[381] = 111;
+  t[383] = 243;
+  t[393] = 112;
+  t[395] = 113;
+  t[396] = 114;
+  t[400] = 115;
+  t[401] = 347;
+  t[410] = 116;
+  t[437] = 117;
+  t[448] = 118;
+  t[449] = 119;
+  t[454] = 120;
+  t[455] = 121;
+  t[460] = 122;
+  t[463] = 380;
+  t[853] = 44;
+  t[855] = 58;
+  t[856] = 46;
+  t[876] = 47;
+  t[878] = 45;
+  t[882] = 45;
+  t[894] = 40;
+  t[895] = 41;
+  t[896] = 91;
+  t[897] = 93;
+  t[923] = 64;
+  t[1004] = 48;
+  t[1005] = 49;
+  t[1006] = 50;
+  t[1007] = 51;
+  t[1008] = 52;
+  t[1009] = 53;
+  t[1010] = 54;
+  t[1011] = 55;
+  t[1012] = 56;
+  t[1013] = 57;
+  t[1081] = 37;
+  t[1085] = 43;
+  t[1086] = 45;
+});
+exports.getSupplementalGlyphMapForCalibri = getSupplementalGlyphMapForCalibri;
+
+/***/ }),
+/* 37 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getUnicodeForGlyph = getUnicodeForGlyph;
+exports.getUnicodeRangeFor = getUnicodeRangeFor;
+exports.mapSpecialUnicodeValues = mapSpecialUnicodeValues;
+exports.reverseIfRtl = reverseIfRtl;
+exports.getNormalizedUnicodes = void 0;
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var getSpecialPUASymbols = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t[63721] = 0x00a9;
+  t[63193] = 0x00a9;
+  t[63720] = 0x00ae;
+  t[63194] = 0x00ae;
+  t[63722] = 0x2122;
+  t[63195] = 0x2122;
+  t[63729] = 0x23a7;
+  t[63730] = 0x23a8;
+  t[63731] = 0x23a9;
+  t[63740] = 0x23ab;
+  t[63741] = 0x23ac;
+  t[63742] = 0x23ad;
+  t[63726] = 0x23a1;
+  t[63727] = 0x23a2;
+  t[63728] = 0x23a3;
+  t[63737] = 0x23a4;
+  t[63738] = 0x23a5;
+  t[63739] = 0x23a6;
+  t[63723] = 0x239b;
+  t[63724] = 0x239c;
+  t[63725] = 0x239d;
+  t[63734] = 0x239e;
+  t[63735] = 0x239f;
+  t[63736] = 0x23a0;
+});
+
+function mapSpecialUnicodeValues(code) {
+  if (code >= 0xfff0 && code <= 0xffff) {
+    return 0;
+  } else if (code >= 0xf600 && code <= 0xf8ff) {
+    return getSpecialPUASymbols()[code] || code;
+  } else if (code === 0x00ad) {
+    return 0x002d;
+  }
+
+  return code;
+}
+
+function getUnicodeForGlyph(name, glyphsUnicodeMap) {
+  var unicode = glyphsUnicodeMap[name];
+
+  if (unicode !== undefined) {
+    return unicode;
+  }
+
+  if (!name) {
+    return -1;
+  }
+
+  if (name[0] === "u") {
+    var nameLen = name.length,
+        hexStr;
+
+    if (nameLen === 7 && name[1] === "n" && name[2] === "i") {
+      hexStr = name.substring(3);
+    } else if (nameLen >= 5 && nameLen <= 7) {
+      hexStr = name.substring(1);
+    } else {
+      return -1;
+    }
+
+    if (hexStr === hexStr.toUpperCase()) {
+      unicode = parseInt(hexStr, 16);
+
+      if (unicode >= 0) {
+        return unicode;
+      }
+    }
+  }
+
+  return -1;
+}
+
+var UnicodeRanges = [{
+  begin: 0x0000,
+  end: 0x007f
+}, {
+  begin: 0x0080,
+  end: 0x00ff
+}, {
+  begin: 0x0100,
+  end: 0x017f
+}, {
+  begin: 0x0180,
+  end: 0x024f
+}, {
+  begin: 0x0250,
+  end: 0x02af
+}, {
+  begin: 0x02b0,
+  end: 0x02ff
+}, {
+  begin: 0x0300,
+  end: 0x036f
+}, {
+  begin: 0x0370,
+  end: 0x03ff
+}, {
+  begin: 0x2c80,
+  end: 0x2cff
+}, {
+  begin: 0x0400,
+  end: 0x04ff
+}, {
+  begin: 0x0530,
+  end: 0x058f
+}, {
+  begin: 0x0590,
+  end: 0x05ff
+}, {
+  begin: 0xa500,
+  end: 0xa63f
+}, {
+  begin: 0x0600,
+  end: 0x06ff
+}, {
+  begin: 0x07c0,
+  end: 0x07ff
+}, {
+  begin: 0x0900,
+  end: 0x097f
+}, {
+  begin: 0x0980,
+  end: 0x09ff
+}, {
+  begin: 0x0a00,
+  end: 0x0a7f
+}, {
+  begin: 0x0a80,
+  end: 0x0aff
+}, {
+  begin: 0x0b00,
+  end: 0x0b7f
+}, {
+  begin: 0x0b80,
+  end: 0x0bff
+}, {
+  begin: 0x0c00,
+  end: 0x0c7f
+}, {
+  begin: 0x0c80,
+  end: 0x0cff
+}, {
+  begin: 0x0d00,
+  end: 0x0d7f
+}, {
+  begin: 0x0e00,
+  end: 0x0e7f
+}, {
+  begin: 0x0e80,
+  end: 0x0eff
+}, {
+  begin: 0x10a0,
+  end: 0x10ff
+}, {
+  begin: 0x1b00,
+  end: 0x1b7f
+}, {
+  begin: 0x1100,
+  end: 0x11ff
+}, {
+  begin: 0x1e00,
+  end: 0x1eff
+}, {
+  begin: 0x1f00,
+  end: 0x1fff
+}, {
+  begin: 0x2000,
+  end: 0x206f
+}, {
+  begin: 0x2070,
+  end: 0x209f
+}, {
+  begin: 0x20a0,
+  end: 0x20cf
+}, {
+  begin: 0x20d0,
+  end: 0x20ff
+}, {
+  begin: 0x2100,
+  end: 0x214f
+}, {
+  begin: 0x2150,
+  end: 0x218f
+}, {
+  begin: 0x2190,
+  end: 0x21ff
+}, {
+  begin: 0x2200,
+  end: 0x22ff
+}, {
+  begin: 0x2300,
+  end: 0x23ff
+}, {
+  begin: 0x2400,
+  end: 0x243f
+}, {
+  begin: 0x2440,
+  end: 0x245f
+}, {
+  begin: 0x2460,
+  end: 0x24ff
+}, {
+  begin: 0x2500,
+  end: 0x257f
+}, {
+  begin: 0x2580,
+  end: 0x259f
+}, {
+  begin: 0x25a0,
+  end: 0x25ff
+}, {
+  begin: 0x2600,
+  end: 0x26ff
+}, {
+  begin: 0x2700,
+  end: 0x27bf
+}, {
+  begin: 0x3000,
+  end: 0x303f
+}, {
+  begin: 0x3040,
+  end: 0x309f
+}, {
+  begin: 0x30a0,
+  end: 0x30ff
+}, {
+  begin: 0x3100,
+  end: 0x312f
+}, {
+  begin: 0x3130,
+  end: 0x318f
+}, {
+  begin: 0xa840,
+  end: 0xa87f
+}, {
+  begin: 0x3200,
+  end: 0x32ff
+}, {
+  begin: 0x3300,
+  end: 0x33ff
+}, {
+  begin: 0xac00,
+  end: 0xd7af
+}, {
+  begin: 0xd800,
+  end: 0xdfff
+}, {
+  begin: 0x10900,
+  end: 0x1091f
+}, {
+  begin: 0x4e00,
+  end: 0x9fff
+}, {
+  begin: 0xe000,
+  end: 0xf8ff
+}, {
+  begin: 0x31c0,
+  end: 0x31ef
+}, {
+  begin: 0xfb00,
+  end: 0xfb4f
+}, {
+  begin: 0xfb50,
+  end: 0xfdff
+}, {
+  begin: 0xfe20,
+  end: 0xfe2f
+}, {
+  begin: 0xfe10,
+  end: 0xfe1f
+}, {
+  begin: 0xfe50,
+  end: 0xfe6f
+}, {
+  begin: 0xfe70,
+  end: 0xfeff
+}, {
+  begin: 0xff00,
+  end: 0xffef
+}, {
+  begin: 0xfff0,
+  end: 0xffff
+}, {
+  begin: 0x0f00,
+  end: 0x0fff
+}, {
+  begin: 0x0700,
+  end: 0x074f
+}, {
+  begin: 0x0780,
+  end: 0x07bf
+}, {
+  begin: 0x0d80,
+  end: 0x0dff
+}, {
+  begin: 0x1000,
+  end: 0x109f
+}, {
+  begin: 0x1200,
+  end: 0x137f
+}, {
+  begin: 0x13a0,
+  end: 0x13ff
+}, {
+  begin: 0x1400,
+  end: 0x167f
+}, {
+  begin: 0x1680,
+  end: 0x169f
+}, {
+  begin: 0x16a0,
+  end: 0x16ff
+}, {
+  begin: 0x1780,
+  end: 0x17ff
+}, {
+  begin: 0x1800,
+  end: 0x18af
+}, {
+  begin: 0x2800,
+  end: 0x28ff
+}, {
+  begin: 0xa000,
+  end: 0xa48f
+}, {
+  begin: 0x1700,
+  end: 0x171f
+}, {
+  begin: 0x10300,
+  end: 0x1032f
+}, {
+  begin: 0x10330,
+  end: 0x1034f
+}, {
+  begin: 0x10400,
+  end: 0x1044f
+}, {
+  begin: 0x1d000,
+  end: 0x1d0ff
+}, {
+  begin: 0x1d400,
+  end: 0x1d7ff
+}, {
+  begin: 0xff000,
+  end: 0xffffd
+}, {
+  begin: 0xfe00,
+  end: 0xfe0f
+}, {
+  begin: 0xe0000,
+  end: 0xe007f
+}, {
+  begin: 0x1900,
+  end: 0x194f
+}, {
+  begin: 0x1950,
+  end: 0x197f
+}, {
+  begin: 0x1980,
+  end: 0x19df
+}, {
+  begin: 0x1a00,
+  end: 0x1a1f
+}, {
+  begin: 0x2c00,
+  end: 0x2c5f
+}, {
+  begin: 0x2d30,
+  end: 0x2d7f
+}, {
+  begin: 0x4dc0,
+  end: 0x4dff
+}, {
+  begin: 0xa800,
+  end: 0xa82f
+}, {
+  begin: 0x10000,
+  end: 0x1007f
+}, {
+  begin: 0x10140,
+  end: 0x1018f
+}, {
+  begin: 0x10380,
+  end: 0x1039f
+}, {
+  begin: 0x103a0,
+  end: 0x103df
+}, {
+  begin: 0x10450,
+  end: 0x1047f
+}, {
+  begin: 0x10480,
+  end: 0x104af
+}, {
+  begin: 0x10800,
+  end: 0x1083f
+}, {
+  begin: 0x10a00,
+  end: 0x10a5f
+}, {
+  begin: 0x1d300,
+  end: 0x1d35f
+}, {
+  begin: 0x12000,
+  end: 0x123ff
+}, {
+  begin: 0x1d360,
+  end: 0x1d37f
+}, {
+  begin: 0x1b80,
+  end: 0x1bbf
+}, {
+  begin: 0x1c00,
+  end: 0x1c4f
+}, {
+  begin: 0x1c50,
+  end: 0x1c7f
+}, {
+  begin: 0xa880,
+  end: 0xa8df
+}, {
+  begin: 0xa900,
+  end: 0xa92f
+}, {
+  begin: 0xa930,
+  end: 0xa95f
+}, {
+  begin: 0xaa00,
+  end: 0xaa5f
+}, {
+  begin: 0x10190,
+  end: 0x101cf
+}, {
+  begin: 0x101d0,
+  end: 0x101ff
+}, {
+  begin: 0x102a0,
+  end: 0x102df
+}, {
+  begin: 0x1f030,
+  end: 0x1f09f
+}];
+
+function getUnicodeRangeFor(value) {
+  for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) {
+    var range = UnicodeRanges[i];
+
+    if (value >= range.begin && value < range.end) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+function isRTLRangeFor(value) {
+  var range = UnicodeRanges[13];
+
+  if (value >= range.begin && value < range.end) {
+    return true;
+  }
+
+  range = UnicodeRanges[11];
+
+  if (value >= range.begin && value < range.end) {
+    return true;
+  }
+
+  return false;
+}
+
+var getNormalizedUnicodes = (0, _core_utils.getArrayLookupTableFactory)(function () {
+  return ["\u00A8", "\u0020\u0308", "\u00AF", "\u0020\u0304", "\u00B4", "\u0020\u0301", "\u00B5", "\u03BC", "\u00B8", "\u0020\u0327", "\u0132", "\u0049\u004A", "\u0133", "\u0069\u006A", "\u013F", "\u004C\u00B7", "\u0140", "\u006C\u00B7", "\u0149", "\u02BC\u006E", "\u017F", "\u0073", "\u01C4", "\u0044\u017D", "\u01C5", "\u0044\u017E", "\u01C6", "\u0064\u017E", "\u01C7", "\u004C\u004A", "\u01C8", "\u004C\u006A", "\u01C9", "\u006C\u006A", "\u01CA", "\u004E\u004A", "\u01CB", "\u004E\u006A", "\u01CC", "\u006E\u006A", "\u01F1", "\u0044\u005A", "\u01F2", "\u0044\u007A", "\u01F3", "\u0064\u007A", "\u02D8", "\u0020\u0306", "\u02D9", "\u0020\u0307", "\u02DA", "\u0020\u030A", "\u02DB", "\u0020\u0328", "\u02DC", "\u0020\u0303", "\u02DD", "\u0020\u030B", "\u037A", "\u0020\u0345", "\u0384", "\u0020\u0301", "\u03D0", "\u03B2", "\u03D1", "\u03B8", "\u03D2", "\u03A5", "\u03D5", "\u03C6", "\u03D6", "\u03C0", "\u03F0", "\u03BA", "\u03F1", "\u03C1", "\u03F2", "\u03C2", "\u03F4", "\u0398", "\u03F5", "\u03B5", "\u03F9", "\u03A3", "\u0587", "\u0565\u0582", "\u0675", "\u0627\u0674", "\u0676", "\u0648\u0674", "\u0677", "\u06C7\u0674", "\u0678", "\u064A\u0674", "\u0E33", "\u0E4D\u0E32", "\u0EB3", "\u0ECD\u0EB2", "\u0EDC", "\u0EAB\u0E99", "\u0EDD", "\u0EAB\u0EA1", "\u0F77", "\u0FB2\u0F81", "\u0F79", "\u0FB3\u0F81", "\u1E9A", "\u0061\u02BE", "\u1FBD", "\u0020\u0313", "\u1FBF", "\u0020\u0313", "\u1FC0", "\u0020\u0342", "\u1FFE", "\u0020\u0314", "\u2002", "\u0020", "\u2003", "\u0020", "\u2004", "\u0020", "\u2005", "\u0020", "\u2006", "\u0020", "\u2008", "\u0020", "\u2009", "\u0020", "\u200A", "\u0020", "\u2017", "\u0020\u0333", "\u2024", "\u002E", "\u2025", "\u002E\u002E", "\u2026", "\u002E\u002E\u002E", "\u2033", "\u2032\u2032", "\u2034", "\u2032\u2032\u2032", "\u2036", "\u2035\u2035", "\u2037", "\u2035\u2035\u2035", "\u203C", "\u0021\u0021", "\u203E", "\u0020\u0305", "\u2047", "\u003F\u003F", "\u2048", "\u003F\u0021", "\u2049", "\u0021\u003F", "\u2057", "\u2032\u2032\u2032\u2032", "\u205F", "\u0020", "\u20A8", "\u0052\u0073", "\u2100", "\u0061\u002F\u0063", "\u2101", "\u0061\u002F\u0073", "\u2103", "\u00B0\u0043", "\u2105", "\u0063\u002F\u006F", "\u2106", "\u0063\u002F\u0075", "\u2107", "\u0190", "\u2109", "\u00B0\u0046", "\u2116", "\u004E\u006F", "\u2121", "\u0054\u0045\u004C", "\u2135", "\u05D0", "\u2136", "\u05D1", "\u2137", "\u05D2", "\u2138", "\u05D3", "\u213B", "\u0046\u0041\u0058", "\u2160", "\u0049", "\u2161", "\u0049\u0049", "\u2162", "\u0049\u0049\u0049", "\u2163", "\u0049\u0056", "\u2164", "\u0056", "\u2165", "\u0056\u0049", "\u2166", "\u0056\u0049\u0049", "\u2167", "\u0056\u0049\u0049\u0049", "\u2168", "\u0049\u0058", "\u2169", "\u0058", "\u216A", "\u0058\u0049", "\u216B", "\u0058\u0049\u0049", "\u216C", "\u004C", "\u216D", "\u0043", "\u216E", "\u0044", "\u216F", "\u004D", "\u2170", "\u0069", "\u2171", "\u0069\u0069", "\u2172", "\u0069\u0069\u0069", "\u2173", "\u0069\u0076", "\u2174", "\u0076", "\u2175", "\u0076\u0069", "\u2176", "\u0076\u0069\u0069", "\u2177", "\u0076\u0069\u0069\u0069", "\u2178", "\u0069\u0078", "\u2179", "\u0078", "\u217A", "\u0078\u0069", "\u217B", "\u0078\u0069\u0069", "\u217C", "\u006C", "\u217D", "\u0063", "\u217E", "\u0064", "\u217F", "\u006D", "\u222C", "\u222B\u222B", "\u222D", "\u222B\u222B\u222B", "\u222F", "\u222E\u222E", "\u2230", "\u222E\u222E\u222E", "\u2474", "\u0028\u0031\u0029", "\u2475", "\u0028\u0032\u0029", "\u2476", "\u0028\u0033\u0029", "\u2477", "\u0028\u0034\u0029", "\u2478", "\u0028\u0035\u0029", "\u2479", "\u0028\u0036\u0029", "\u247A", "\u0028\u0037\u0029", "\u247B", "\u0028\u0038\u0029", "\u247C", "\u0028\u0039\u0029", "\u247D", "\u0028\u0031\u0030\u0029", "\u247E", "\u0028\u0031\u0031\u0029", "\u247F", "\u0028\u0031\u0032\u0029", "\u2480", "\u0028\u0031\u0033\u0029", "\u2481", "\u0028\u0031\u0034\u0029", "\u2482", "\u0028\u0031\u0035\u0029", "\u2483", "\u0028\u0031\u0036\u0029", "\u2484", "\u0028\u0031\u0037\u0029", "\u2485", "\u0028\u0031\u0038\u0029", "\u2486", "\u0028\u0031\u0039\u0029", "\u2487", "\u0028\u0032\u0030\u0029", "\u2488", "\u0031\u002E", "\u2489", "\u0032\u002E", "\u248A", "\u0033\u002E", "\u248B", "\u0034\u002E", "\u248C", "\u0035\u002E", "\u248D", "\u0036\u002E", "\u248E", "\u0037\u002E", "\u248F", "\u0038\u002E", "\u2490", "\u0039\u002E", "\u2491", "\u0031\u0030\u002E", "\u2492", "\u0031\u0031\u002E", "\u2493", "\u0031\u0032\u002E", "\u2494", "\u0031\u0033\u002E", "\u2495", "\u0031\u0034\u002E", "\u2496", "\u0031\u0035\u002E", "\u2497", "\u0031\u0036\u002E", "\u2498", "\u0031\u0037\u002E", "\u2499", "\u0031\u0038\u002E", "\u249A", "\u0031\u0039\u002E", "\u249B", "\u0032\u0030\u002E", "\u249C", "\u0028\u0061\u0029", "\u249D", "\u0028\u0062\u0029", "\u249E", "\u0028\u0063\u0029", "\u249F", "\u0028\u0064\u0029", "\u24A0", "\u0028\u0065\u0029", "\u24A1", "\u0028\u0066\u0029", "\u24A2", "\u0028\u0067\u0029", "\u24A3", "\u0028\u0068\u0029", "\u24A4", "\u0028\u0069\u0029", "\u24A5", "\u0028\u006A\u0029", "\u24A6", "\u0028\u006B\u0029", "\u24A7", "\u0028\u006C\u0029", "\u24A8", "\u0028\u006D\u0029", "\u24A9", "\u0028\u006E\u0029", "\u24AA", "\u0028\u006F\u0029", "\u24AB", "\u0028\u0070\u0029", "\u24AC", "\u0028\u0071\u0029", "\u24AD", "\u0028\u0072\u0029", "\u24AE", "\u0028\u0073\u0029", "\u24AF", "\u0028\u0074\u0029", "\u24B0", "\u0028\u0075\u0029", "\u24B1", "\u0028\u0076\u0029", "\u24B2", "\u0028\u0077\u0029", "\u24B3", "\u0028\u0078\u0029", "\u24B4", "\u0028\u0079\u0029", "\u24B5", "\u0028\u007A\u0029", "\u2A0C", "\u222B\u222B\u222B\u222B", "\u2A74", "\u003A\u003A\u003D", "\u2A75", "\u003D\u003D", "\u2A76", "\u003D\u003D\u003D", "\u2E9F", "\u6BCD", "\u2EF3", "\u9F9F", "\u2F00", "\u4E00", "\u2F01", "\u4E28", "\u2F02", "\u4E36", "\u2F03", "\u4E3F", "\u2F04", "\u4E59", "\u2F05", "\u4E85", "\u2F06", "\u4E8C", "\u2F07", "\u4EA0", "\u2F08", "\u4EBA", "\u2F09", "\u513F", "\u2F0A", "\u5165", "\u2F0B", "\u516B", "\u2F0C", "\u5182", "\u2F0D", "\u5196", "\u2F0E", "\u51AB", "\u2F0F", "\u51E0", "\u2F10", "\u51F5", "\u2F11", "\u5200", "\u2F12", "\u529B", "\u2F13", "\u52F9", "\u2F14", "\u5315", "\u2F15", "\u531A", "\u2F16", "\u5338", "\u2F17", "\u5341", "\u2F18", "\u535C", "\u2F19", "\u5369", "\u2F1A", "\u5382", "\u2F1B", "\u53B6", "\u2F1C", "\u53C8", "\u2F1D", "\u53E3", "\u2F1E", "\u56D7", "\u2F1F", "\u571F", "\u2F20", "\u58EB", "\u2F21", "\u5902", "\u2F22", "\u590A", "\u2F23", "\u5915", "\u2F24", "\u5927", "\u2F25", "\u5973", "\u2F26", "\u5B50", "\u2F27", "\u5B80", "\u2F28", "\u5BF8", "\u2F29", "\u5C0F", "\u2F2A", "\u5C22", "\u2F2B", "\u5C38", "\u2F2C", "\u5C6E", "\u2F2D", "\u5C71", "\u2F2E", "\u5DDB", "\u2F2F", "\u5DE5", "\u2F30", "\u5DF1", "\u2F31", "\u5DFE", "\u2F32", "\u5E72", "\u2F33", "\u5E7A", "\u2F34", "\u5E7F", "\u2F35", "\u5EF4", "\u2F36", "\u5EFE", "\u2F37", "\u5F0B", "\u2F38", "\u5F13", "\u2F39", "\u5F50", "\u2F3A", "\u5F61", "\u2F3B", "\u5F73", "\u2F3C", "\u5FC3", "\u2F3D", "\u6208", "\u2F3E", "\u6236", "\u2F3F", "\u624B", "\u2F40", "\u652F", "\u2F41", "\u6534", "\u2F42", "\u6587", "\u2F43", "\u6597", "\u2F44", "\u65A4", "\u2F45", "\u65B9", "\u2F46", "\u65E0", "\u2F47", "\u65E5", "\u2F48", "\u66F0", "\u2F49", "\u6708", "\u2F4A", "\u6728", "\u2F4B", "\u6B20", "\u2F4C", "\u6B62", "\u2F4D", "\u6B79", "\u2F4E", "\u6BB3", "\u2F4F", "\u6BCB", "\u2F50", "\u6BD4", "\u2F51", "\u6BDB", "\u2F52", "\u6C0F", "\u2F53", "\u6C14", "\u2F54", "\u6C34", "\u2F55", "\u706B", "\u2F56", "\u722A", "\u2F57", "\u7236", "\u2F58", "\u723B", "\u2F59", "\u723F", "\u2F5A", "\u7247", "\u2F5B", "\u7259", "\u2F5C", "\u725B", "\u2F5D", "\u72AC", "\u2F5E", "\u7384", "\u2F5F", "\u7389", "\u2F60", "\u74DC", "\u2F61", "\u74E6", "\u2F62", "\u7518", "\u2F63", "\u751F", "\u2F64", "\u7528", "\u2F65", "\u7530", "\u2F66", "\u758B", "\u2F67", "\u7592", "\u2F68", "\u7676", "\u2F69", "\u767D", "\u2F6A", "\u76AE", "\u2F6B", "\u76BF", "\u2F6C", "\u76EE", "\u2F6D", "\u77DB", "\u2F6E", "\u77E2", "\u2F6F", "\u77F3", "\u2F70", "\u793A", "\u2F71", "\u79B8", "\u2F72", "\u79BE", "\u2F73", "\u7A74", "\u2F74", "\u7ACB", "\u2F75", "\u7AF9", "\u2F76", "\u7C73", "\u2F77", "\u7CF8", "\u2F78", "\u7F36", "\u2F79", "\u7F51", "\u2F7A", "\u7F8A", "\u2F7B", "\u7FBD", "\u2F7C", "\u8001", "\u2F7D", "\u800C", "\u2F7E", "\u8012", "\u2F7F", "\u8033", "\u2F80", "\u807F", "\u2F81", "\u8089", "\u2F82", "\u81E3", "\u2F83", "\u81EA", "\u2F84", "\u81F3", "\u2F85", "\u81FC", "\u2F86", "\u820C", "\u2F87", "\u821B", "\u2F88", "\u821F", "\u2F89", "\u826E", "\u2F8A", "\u8272", "\u2F8B", "\u8278", "\u2F8C", "\u864D", "\u2F8D", "\u866B", "\u2F8E", "\u8840", "\u2F8F", "\u884C", "\u2F90", "\u8863", "\u2F91", "\u897E", "\u2F92", "\u898B", "\u2F93", "\u89D2", "\u2F94", "\u8A00", "\u2F95", "\u8C37", "\u2F96", "\u8C46", "\u2F97", "\u8C55", "\u2F98", "\u8C78", "\u2F99", "\u8C9D", "\u2F9A", "\u8D64", "\u2F9B", "\u8D70", "\u2F9C", "\u8DB3", "\u2F9D", "\u8EAB", "\u2F9E", "\u8ECA", "\u2F9F", "\u8F9B", "\u2FA0", "\u8FB0", "\u2FA1", "\u8FB5", "\u2FA2", "\u9091", "\u2FA3", "\u9149", "\u2FA4", "\u91C6", "\u2FA5", "\u91CC", "\u2FA6", "\u91D1", "\u2FA7", "\u9577", "\u2FA8", "\u9580", "\u2FA9", "\u961C", "\u2FAA", "\u96B6", "\u2FAB", "\u96B9", "\u2FAC", "\u96E8", "\u2FAD", "\u9751", "\u2FAE", "\u975E", "\u2FAF", "\u9762", "\u2FB0", "\u9769", "\u2FB1", "\u97CB", "\u2FB2", "\u97ED", "\u2FB3", "\u97F3", "\u2FB4", "\u9801", "\u2FB5", "\u98A8", "\u2FB6", "\u98DB", "\u2FB7", "\u98DF", "\u2FB8", "\u9996", "\u2FB9", "\u9999", "\u2FBA", "\u99AC", "\u2FBB", "\u9AA8", "\u2FBC", "\u9AD8", "\u2FBD", "\u9ADF", "\u2FBE", "\u9B25", "\u2FBF", "\u9B2F", "\u2FC0", "\u9B32", "\u2FC1", "\u9B3C", "\u2FC2", "\u9B5A", "\u2FC3", "\u9CE5", "\u2FC4", "\u9E75", "\u2FC5", "\u9E7F", "\u2FC6", "\u9EA5", "\u2FC7", "\u9EBB", "\u2FC8", "\u9EC3", "\u2FC9", "\u9ECD", "\u2FCA", "\u9ED1", "\u2FCB", "\u9EF9", "\u2FCC", "\u9EFD", "\u2FCD", "\u9F0E", "\u2FCE", "\u9F13", "\u2FCF", "\u9F20", "\u2FD0", "\u9F3B", "\u2FD1", "\u9F4A", "\u2FD2", "\u9F52", "\u2FD3", "\u9F8D", "\u2FD4", "\u9F9C", "\u2FD5", "\u9FA0", "\u3036", "\u3012", "\u3038", "\u5341", "\u3039", "\u5344", "\u303A", "\u5345", "\u309B", "\u0020\u3099", "\u309C", "\u0020\u309A", "\u3131", "\u1100", "\u3132", "\u1101", "\u3133", "\u11AA", "\u3134", "\u1102", "\u3135", "\u11AC", "\u3136", "\u11AD", "\u3137", "\u1103", "\u3138", "\u1104", "\u3139", "\u1105", "\u313A", "\u11B0", "\u313B", "\u11B1", "\u313C", "\u11B2", "\u313D", "\u11B3", "\u313E", "\u11B4", "\u313F", "\u11B5", "\u3140", "\u111A", "\u3141", "\u1106", "\u3142", "\u1107", "\u3143", "\u1108", "\u3144", "\u1121", "\u3145", "\u1109", "\u3146", "\u110A", "\u3147", "\u110B", "\u3148", "\u110C", "\u3149", "\u110D", "\u314A", "\u110E", "\u314B", "\u110F", "\u314C", "\u1110", "\u314D", "\u1111", "\u314E", "\u1112", "\u314F", "\u1161", "\u3150", "\u1162", "\u3151", "\u1163", "\u3152", "\u1164", "\u3153", "\u1165", "\u3154", "\u1166", "\u3155", "\u1167", "\u3156", "\u1168", "\u3157", "\u1169", "\u3158", "\u116A", "\u3159", "\u116B", "\u315A", "\u116C", "\u315B", "\u116D", "\u315C", "\u116E", "\u315D", "\u116F", "\u315E", "\u1170", "\u315F", "\u1171", "\u3160", "\u1172", "\u3161", "\u1173", "\u3162", "\u1174", "\u3163", "\u1175", "\u3164", "\u1160", "\u3165", "\u1114", "\u3166", "\u1115", "\u3167", "\u11C7", "\u3168", "\u11C8", "\u3169", "\u11CC", "\u316A", "\u11CE", "\u316B", "\u11D3", "\u316C", "\u11D7", "\u316D", "\u11D9", "\u316E", "\u111C", "\u316F", "\u11DD", "\u3170", "\u11DF", "\u3171", "\u111D", "\u3172", "\u111E", "\u3173", "\u1120", "\u3174", "\u1122", "\u3175", "\u1123", "\u3176", "\u1127", "\u3177", "\u1129", "\u3178", "\u112B", "\u3179", "\u112C", "\u317A", "\u112D", "\u317B", "\u112E", "\u317C", "\u112F", "\u317D", "\u1132", "\u317E", "\u1136", "\u317F", "\u1140", "\u3180", "\u1147", "\u3181", "\u114C", "\u3182", "\u11F1", "\u3183", "\u11F2", "\u3184", "\u1157", "\u3185", "\u1158", "\u3186", "\u1159", "\u3187", "\u1184", "\u3188", "\u1185", "\u3189", "\u1188", "\u318A", "\u1191", "\u318B", "\u1192", "\u318C", "\u1194", "\u318D", "\u119E", "\u318E", "\u11A1", "\u3200", "\u0028\u1100\u0029", "\u3201", "\u0028\u1102\u0029", "\u3202", "\u0028\u1103\u0029", "\u3203", "\u0028\u1105\u0029", "\u3204", "\u0028\u1106\u0029", "\u3205", "\u0028\u1107\u0029", "\u3206", "\u0028\u1109\u0029", "\u3207", "\u0028\u110B\u0029", "\u3208", "\u0028\u110C\u0029", "\u3209", "\u0028\u110E\u0029", "\u320A", "\u0028\u110F\u0029", "\u320B", "\u0028\u1110\u0029", "\u320C", "\u0028\u1111\u0029", "\u320D", "\u0028\u1112\u0029", "\u320E", "\u0028\u1100\u1161\u0029", "\u320F", "\u0028\u1102\u1161\u0029", "\u3210", "\u0028\u1103\u1161\u0029", "\u3211", "\u0028\u1105\u1161\u0029", "\u3212", "\u0028\u1106\u1161\u0029", "\u3213", "\u0028\u1107\u1161\u0029", "\u3214", "\u0028\u1109\u1161\u0029", "\u3215", "\u0028\u110B\u1161\u0029", "\u3216", "\u0028\u110C\u1161\u0029", "\u3217", "\u0028\u110E\u1161\u0029", "\u3218", "\u0028\u110F\u1161\u0029", "\u3219", "\u0028\u1110\u1161\u0029", "\u321A", "\u0028\u1111\u1161\u0029", "\u321B", "\u0028\u1112\u1161\u0029", "\u321C", "\u0028\u110C\u116E\u0029", "\u321D", "\u0028\u110B\u1169\u110C\u1165\u11AB\u0029", "\u321E", "\u0028\u110B\u1169\u1112\u116E\u0029", "\u3220", "\u0028\u4E00\u0029", "\u3221", "\u0028\u4E8C\u0029", "\u3222", "\u0028\u4E09\u0029", "\u3223", "\u0028\u56DB\u0029", "\u3224", "\u0028\u4E94\u0029", "\u3225", "\u0028\u516D\u0029", "\u3226", "\u0028\u4E03\u0029", "\u3227", "\u0028\u516B\u0029", "\u3228", "\u0028\u4E5D\u0029", "\u3229", "\u0028\u5341\u0029", "\u322A", "\u0028\u6708\u0029", "\u322B", "\u0028\u706B\u0029", "\u322C", "\u0028\u6C34\u0029", "\u322D", "\u0028\u6728\u0029", "\u322E", "\u0028\u91D1\u0029", "\u322F", "\u0028\u571F\u0029", "\u3230", "\u0028\u65E5\u0029", "\u3231", "\u0028\u682A\u0029", "\u3232", "\u0028\u6709\u0029", "\u3233", "\u0028\u793E\u0029", "\u3234", "\u0028\u540D\u0029", "\u3235", "\u0028\u7279\u0029", "\u3236", "\u0028\u8CA1\u0029", "\u3237", "\u0028\u795D\u0029", "\u3238", "\u0028\u52B4\u0029", "\u3239", "\u0028\u4EE3\u0029", "\u323A", "\u0028\u547C\u0029", "\u323B", "\u0028\u5B66\u0029", "\u323C", "\u0028\u76E3\u0029", "\u323D", "\u0028\u4F01\u0029", "\u323E", "\u0028\u8CC7\u0029", "\u323F", "\u0028\u5354\u0029", "\u3240", "\u0028\u796D\u0029", "\u3241", "\u0028\u4F11\u0029", "\u3242", "\u0028\u81EA\u0029", "\u3243", "\u0028\u81F3\u0029", "\u32C0", "\u0031\u6708", "\u32C1", "\u0032\u6708", "\u32C2", "\u0033\u6708", "\u32C3", "\u0034\u6708", "\u32C4", "\u0035\u6708", "\u32C5", "\u0036\u6708", "\u32C6", "\u0037\u6708", "\u32C7", "\u0038\u6708", "\u32C8", "\u0039\u6708", "\u32C9", "\u0031\u0030\u6708", "\u32CA", "\u0031\u0031\u6708", "\u32CB", "\u0031\u0032\u6708", "\u3358", "\u0030\u70B9", "\u3359", "\u0031\u70B9", "\u335A", "\u0032\u70B9", "\u335B", "\u0033\u70B9", "\u335C", "\u0034\u70B9", "\u335D", "\u0035\u70B9", "\u335E", "\u0036\u70B9", "\u335F", "\u0037\u70B9", "\u3360", "\u0038\u70B9", "\u3361", "\u0039\u70B9", "\u3362", "\u0031\u0030\u70B9", "\u3363", "\u0031\u0031\u70B9", "\u3364", "\u0031\u0032\u70B9", "\u3365", "\u0031\u0033\u70B9", "\u3366", "\u0031\u0034\u70B9", "\u3367", "\u0031\u0035\u70B9", "\u3368", "\u0031\u0036\u70B9", "\u3369", "\u0031\u0037\u70B9", "\u336A", "\u0031\u0038\u70B9", "\u336B", "\u0031\u0039\u70B9", "\u336C", "\u0032\u0030\u70B9", "\u336D", "\u0032\u0031\u70B9", "\u336E", "\u0032\u0032\u70B9", "\u336F", "\u0032\u0033\u70B9", "\u3370", "\u0032\u0034\u70B9", "\u33E0", "\u0031\u65E5", "\u33E1", "\u0032\u65E5", "\u33E2", "\u0033\u65E5", "\u33E3", "\u0034\u65E5", "\u33E4", "\u0035\u65E5", "\u33E5", "\u0036\u65E5", "\u33E6", "\u0037\u65E5", "\u33E7", "\u0038\u65E5", "\u33E8", "\u0039\u65E5", "\u33E9", "\u0031\u0030\u65E5", "\u33EA", "\u0031\u0031\u65E5", "\u33EB", "\u0031\u0032\u65E5", "\u33EC", "\u0031\u0033\u65E5", "\u33ED", "\u0031\u0034\u65E5", "\u33EE", "\u0031\u0035\u65E5", "\u33EF", "\u0031\u0036\u65E5", "\u33F0", "\u0031\u0037\u65E5", "\u33F1", "\u0031\u0038\u65E5", "\u33F2", "\u0031\u0039\u65E5", "\u33F3", "\u0032\u0030\u65E5", "\u33F4", "\u0032\u0031\u65E5", "\u33F5", "\u0032\u0032\u65E5", "\u33F6", "\u0032\u0033\u65E5", "\u33F7", "\u0032\u0034\u65E5", "\u33F8", "\u0032\u0035\u65E5", "\u33F9", "\u0032\u0036\u65E5", "\u33FA", "\u0032\u0037\u65E5", "\u33FB", "\u0032\u0038\u65E5", "\u33FC", "\u0032\u0039\u65E5", "\u33FD", "\u0033\u0030\u65E5", "\u33FE", "\u0033\u0031\u65E5", "\uFB00", "\u0066\u0066", "\uFB01", "\u0066\u0069", "\uFB02", "\u0066\u006C", "\uFB03", "\u0066\u0066\u0069", "\uFB04", "\u0066\u0066\u006C", "\uFB05", "\u017F\u0074", "\uFB06", "\u0073\u0074", "\uFB13", "\u0574\u0576", "\uFB14", "\u0574\u0565", "\uFB15", "\u0574\u056B", "\uFB16", "\u057E\u0576", "\uFB17", "\u0574\u056D", "\uFB4F", "\u05D0\u05DC", "\uFB50", "\u0671", "\uFB51", "\u0671", "\uFB52", "\u067B", "\uFB53", "\u067B", "\uFB54", "\u067B", "\uFB55", "\u067B", "\uFB56", "\u067E", "\uFB57", "\u067E", "\uFB58", "\u067E", "\uFB59", "\u067E", "\uFB5A", "\u0680", "\uFB5B", "\u0680", "\uFB5C", "\u0680", "\uFB5D", "\u0680", "\uFB5E", "\u067A", "\uFB5F", "\u067A", "\uFB60", "\u067A", "\uFB61", "\u067A", "\uFB62", "\u067F", "\uFB63", "\u067F", "\uFB64", "\u067F", "\uFB65", "\u067F", "\uFB66", "\u0679", "\uFB67", "\u0679", "\uFB68", "\u0679", "\uFB69", "\u0679", "\uFB6A", "\u06A4", "\uFB6B", "\u06A4", "\uFB6C", "\u06A4", "\uFB6D", "\u06A4", "\uFB6E", "\u06A6", "\uFB6F", "\u06A6", "\uFB70", "\u06A6", "\uFB71", "\u06A6", "\uFB72", "\u0684", "\uFB73", "\u0684", "\uFB74", "\u0684", "\uFB75", "\u0684", "\uFB76", "\u0683", "\uFB77", "\u0683", "\uFB78", "\u0683", "\uFB79", "\u0683", "\uFB7A", "\u0686", "\uFB7B", "\u0686", "\uFB7C", "\u0686", "\uFB7D", "\u0686", "\uFB7E", "\u0687", "\uFB7F", "\u0687", "\uFB80", "\u0687", "\uFB81", "\u0687", "\uFB82", "\u068D", "\uFB83", "\u068D", "\uFB84", "\u068C", "\uFB85", "\u068C", "\uFB86", "\u068E", "\uFB87", "\u068E", "\uFB88", "\u0688", "\uFB89", "\u0688", "\uFB8A", "\u0698", "\uFB8B", "\u0698", "\uFB8C", "\u0691", "\uFB8D", "\u0691", "\uFB8E", "\u06A9", "\uFB8F", "\u06A9", "\uFB90", "\u06A9", "\uFB91", "\u06A9", "\uFB92", "\u06AF", "\uFB93", "\u06AF", "\uFB94", "\u06AF", "\uFB95", "\u06AF", "\uFB96", "\u06B3", "\uFB97", "\u06B3", "\uFB98", "\u06B3", "\uFB99", "\u06B3", "\uFB9A", "\u06B1", "\uFB9B", "\u06B1", "\uFB9C", "\u06B1", "\uFB9D", "\u06B1", "\uFB9E", "\u06BA", "\uFB9F", "\u06BA", "\uFBA0", "\u06BB", "\uFBA1", "\u06BB", "\uFBA2", "\u06BB", "\uFBA3", "\u06BB", "\uFBA4", "\u06C0", "\uFBA5", "\u06C0", "\uFBA6", "\u06C1", "\uFBA7", "\u06C1", "\uFBA8", "\u06C1", "\uFBA9", "\u06C1", "\uFBAA", "\u06BE", "\uFBAB", "\u06BE", "\uFBAC", "\u06BE", "\uFBAD", "\u06BE", "\uFBAE", "\u06D2", "\uFBAF", "\u06D2", "\uFBB0", "\u06D3", "\uFBB1", "\u06D3", "\uFBD3", "\u06AD", "\uFBD4", "\u06AD", "\uFBD5", "\u06AD", "\uFBD6", "\u06AD", "\uFBD7", "\u06C7", "\uFBD8", "\u06C7", "\uFBD9", "\u06C6", "\uFBDA", "\u06C6", "\uFBDB", "\u06C8", "\uFBDC", "\u06C8", "\uFBDD", "\u0677", "\uFBDE", "\u06CB", "\uFBDF", "\u06CB", "\uFBE0", "\u06C5", "\uFBE1", "\u06C5", "\uFBE2", "\u06C9", "\uFBE3", "\u06C9", "\uFBE4", "\u06D0", "\uFBE5", "\u06D0", "\uFBE6", "\u06D0", "\uFBE7", "\u06D0", "\uFBE8", "\u0649", "\uFBE9", "\u0649", "\uFBEA", "\u0626\u0627", "\uFBEB", "\u0626\u0627", "\uFBEC", "\u0626\u06D5", "\uFBED", "\u0626\u06D5", "\uFBEE", "\u0626\u0648", "\uFBEF", "\u0626\u0648", "\uFBF0", "\u0626\u06C7", "\uFBF1", "\u0626\u06C7", "\uFBF2", "\u0626\u06C6", "\uFBF3", "\u0626\u06C6", "\uFBF4", "\u0626\u06C8", "\uFBF5", "\u0626\u06C8", "\uFBF6", "\u0626\u06D0", "\uFBF7", "\u0626\u06D0", "\uFBF8", "\u0626\u06D0", "\uFBF9", "\u0626\u0649", "\uFBFA", "\u0626\u0649", "\uFBFB", "\u0626\u0649", "\uFBFC", "\u06CC", "\uFBFD", "\u06CC", "\uFBFE", "\u06CC", "\uFBFF", "\u06CC", "\uFC00", "\u0626\u062C", "\uFC01", "\u0626\u062D", "\uFC02", "\u0626\u0645", "\uFC03", "\u0626\u0649", "\uFC04", "\u0626\u064A", "\uFC05", "\u0628\u062C", "\uFC06", "\u0628\u062D", "\uFC07", "\u0628\u062E", "\uFC08", "\u0628\u0645", "\uFC09", "\u0628\u0649", "\uFC0A", "\u0628\u064A", "\uFC0B", "\u062A\u062C", "\uFC0C", "\u062A\u062D", "\uFC0D", "\u062A\u062E", "\uFC0E", "\u062A\u0645", "\uFC0F", "\u062A\u0649", "\uFC10", "\u062A\u064A", "\uFC11", "\u062B\u062C", "\uFC12", "\u062B\u0645", "\uFC13", "\u062B\u0649", "\uFC14", "\u062B\u064A", "\uFC15", "\u062C\u062D", "\uFC16", "\u062C\u0645", "\uFC17", "\u062D\u062C", "\uFC18", "\u062D\u0645", "\uFC19", "\u062E\u062C", "\uFC1A", "\u062E\u062D", "\uFC1B", "\u062E\u0645", "\uFC1C", "\u0633\u062C", "\uFC1D", "\u0633\u062D", "\uFC1E", "\u0633\u062E", "\uFC1F", "\u0633\u0645", "\uFC20", "\u0635\u062D", "\uFC21", "\u0635\u0645", "\uFC22", "\u0636\u062C", "\uFC23", "\u0636\u062D", "\uFC24", "\u0636\u062E", "\uFC25", "\u0636\u0645", "\uFC26", "\u0637\u062D", "\uFC27", "\u0637\u0645", "\uFC28", "\u0638\u0645", "\uFC29", "\u0639\u062C", "\uFC2A", "\u0639\u0645", "\uFC2B", "\u063A\u062C", "\uFC2C", "\u063A\u0645", "\uFC2D", "\u0641\u062C", "\uFC2E", "\u0641\u062D", "\uFC2F", "\u0641\u062E", "\uFC30", "\u0641\u0645", "\uFC31", "\u0641\u0649", "\uFC32", "\u0641\u064A", "\uFC33", "\u0642\u062D", "\uFC34", "\u0642\u0645", "\uFC35", "\u0642\u0649", "\uFC36", "\u0642\u064A", "\uFC37", "\u0643\u0627", "\uFC38", "\u0643\u062C", "\uFC39", "\u0643\u062D", "\uFC3A", "\u0643\u062E", "\uFC3B", "\u0643\u0644", "\uFC3C", "\u0643\u0645", "\uFC3D", "\u0643\u0649", "\uFC3E", "\u0643\u064A", "\uFC3F", "\u0644\u062C", "\uFC40", "\u0644\u062D", "\uFC41", "\u0644\u062E", "\uFC42", "\u0644\u0645", "\uFC43", "\u0644\u0649", "\uFC44", "\u0644\u064A", "\uFC45", "\u0645\u062C", "\uFC46", "\u0645\u062D", "\uFC47", "\u0645\u062E", "\uFC48", "\u0645\u0645", "\uFC49", "\u0645\u0649", "\uFC4A", "\u0645\u064A", "\uFC4B", "\u0646\u062C", "\uFC4C", "\u0646\u062D", "\uFC4D", "\u0646\u062E", "\uFC4E", "\u0646\u0645", "\uFC4F", "\u0646\u0649", "\uFC50", "\u0646\u064A", "\uFC51", "\u0647\u062C", "\uFC52", "\u0647\u0645", "\uFC53", "\u0647\u0649", "\uFC54", "\u0647\u064A", "\uFC55", "\u064A\u062C", "\uFC56", "\u064A\u062D", "\uFC57", "\u064A\u062E", "\uFC58", "\u064A\u0645", "\uFC59", "\u064A\u0649", "\uFC5A", "\u064A\u064A", "\uFC5B", "\u0630\u0670", "\uFC5C", "\u0631\u0670", "\uFC5D", "\u0649\u0670", "\uFC5E", "\u0020\u064C\u0651", "\uFC5F", "\u0020\u064D\u0651", "\uFC60", "\u0020\u064E\u0651", "\uFC61", "\u0020\u064F\u0651", "\uFC62", "\u0020\u0650\u0651", "\uFC63", "\u0020\u0651\u0670", "\uFC64", "\u0626\u0631", "\uFC65", "\u0626\u0632", "\uFC66", "\u0626\u0645", "\uFC67", "\u0626\u0646", "\uFC68", "\u0626\u0649", "\uFC69", "\u0626\u064A", "\uFC6A", "\u0628\u0631", "\uFC6B", "\u0628\u0632", "\uFC6C", "\u0628\u0645", "\uFC6D", "\u0628\u0646", "\uFC6E", "\u0628\u0649", "\uFC6F", "\u0628\u064A", "\uFC70", "\u062A\u0631", "\uFC71", "\u062A\u0632", "\uFC72", "\u062A\u0645", "\uFC73", "\u062A\u0646", "\uFC74", "\u062A\u0649", "\uFC75", "\u062A\u064A", "\uFC76", "\u062B\u0631", "\uFC77", "\u062B\u0632", "\uFC78", "\u062B\u0645", "\uFC79", "\u062B\u0646", "\uFC7A", "\u062B\u0649", "\uFC7B", "\u062B\u064A", "\uFC7C", "\u0641\u0649", "\uFC7D", "\u0641\u064A", "\uFC7E", "\u0642\u0649", "\uFC7F", "\u0642\u064A", "\uFC80", "\u0643\u0627", "\uFC81", "\u0643\u0644", "\uFC82", "\u0643\u0645", "\uFC83", "\u0643\u0649", "\uFC84", "\u0643\u064A", "\uFC85", "\u0644\u0645", "\uFC86", "\u0644\u0649", "\uFC87", "\u0644\u064A", "\uFC88", "\u0645\u0627", "\uFC89", "\u0645\u0645", "\uFC8A", "\u0646\u0631", "\uFC8B", "\u0646\u0632", "\uFC8C", "\u0646\u0645", "\uFC8D", "\u0646\u0646", "\uFC8E", "\u0646\u0649", "\uFC8F", "\u0646\u064A", "\uFC90", "\u0649\u0670", "\uFC91", "\u064A\u0631", "\uFC92", "\u064A\u0632", "\uFC93", "\u064A\u0645", "\uFC94", "\u064A\u0646", "\uFC95", "\u064A\u0649", "\uFC96", "\u064A\u064A", "\uFC97", "\u0626\u062C", "\uFC98", "\u0626\u062D", "\uFC99", "\u0626\u062E", "\uFC9A", "\u0626\u0645", "\uFC9B", "\u0626\u0647", "\uFC9C", "\u0628\u062C", "\uFC9D", "\u0628\u062D", "\uFC9E", "\u0628\u062E", "\uFC9F", "\u0628\u0645", "\uFCA0", "\u0628\u0647", "\uFCA1", "\u062A\u062C", "\uFCA2", "\u062A\u062D", "\uFCA3", "\u062A\u062E", "\uFCA4", "\u062A\u0645", "\uFCA5", "\u062A\u0647", "\uFCA6", "\u062B\u0645", "\uFCA7", "\u062C\u062D", "\uFCA8", "\u062C\u0645", "\uFCA9", "\u062D\u062C", "\uFCAA", "\u062D\u0645", "\uFCAB", "\u062E\u062C", "\uFCAC", "\u062E\u0645", "\uFCAD", "\u0633\u062C", "\uFCAE", "\u0633\u062D", "\uFCAF", "\u0633\u062E", "\uFCB0", "\u0633\u0645", "\uFCB1", "\u0635\u062D", "\uFCB2", "\u0635\u062E", "\uFCB3", "\u0635\u0645", "\uFCB4", "\u0636\u062C", "\uFCB5", "\u0636\u062D", "\uFCB6", "\u0636\u062E", "\uFCB7", "\u0636\u0645", "\uFCB8", "\u0637\u062D", "\uFCB9", "\u0638\u0645", "\uFCBA", "\u0639\u062C", "\uFCBB", "\u0639\u0645", "\uFCBC", "\u063A\u062C", "\uFCBD", "\u063A\u0645", "\uFCBE", "\u0641\u062C", "\uFCBF", "\u0641\u062D", "\uFCC0", "\u0641\u062E", "\uFCC1", "\u0641\u0645", "\uFCC2", "\u0642\u062D", "\uFCC3", "\u0642\u0645", "\uFCC4", "\u0643\u062C", "\uFCC5", "\u0643\u062D", "\uFCC6", "\u0643\u062E", "\uFCC7", "\u0643\u0644", "\uFCC8", "\u0643\u0645", "\uFCC9", "\u0644\u062C", "\uFCCA", "\u0644\u062D", "\uFCCB", "\u0644\u062E", "\uFCCC", "\u0644\u0645", "\uFCCD", "\u0644\u0647", "\uFCCE", "\u0645\u062C", "\uFCCF", "\u0645\u062D", "\uFCD0", "\u0645\u062E", "\uFCD1", "\u0645\u0645", "\uFCD2", "\u0646\u062C", "\uFCD3", "\u0646\u062D", "\uFCD4", "\u0646\u062E", "\uFCD5", "\u0646\u0645", "\uFCD6", "\u0646\u0647", "\uFCD7", "\u0647\u062C", "\uFCD8", "\u0647\u0645", "\uFCD9", "\u0647\u0670", "\uFCDA", "\u064A\u062C", "\uFCDB", "\u064A\u062D", "\uFCDC", "\u064A\u062E", "\uFCDD", "\u064A\u0645", "\uFCDE", "\u064A\u0647", "\uFCDF", "\u0626\u0645", "\uFCE0", "\u0626\u0647", "\uFCE1", "\u0628\u0645", "\uFCE2", "\u0628\u0647", "\uFCE3", "\u062A\u0645", "\uFCE4", "\u062A\u0647", "\uFCE5", "\u062B\u0645", "\uFCE6", "\u062B\u0647", "\uFCE7", "\u0633\u0645", "\uFCE8", "\u0633\u0647", "\uFCE9", "\u0634\u0645", "\uFCEA", "\u0634\u0647", "\uFCEB", "\u0643\u0644", "\uFCEC", "\u0643\u0645", "\uFCED", "\u0644\u0645", "\uFCEE", "\u0646\u0645", "\uFCEF", "\u0646\u0647", "\uFCF0", "\u064A\u0645", "\uFCF1", "\u064A\u0647", "\uFCF2", "\u0640\u064E\u0651", "\uFCF3", "\u0640\u064F\u0651", "\uFCF4", "\u0640\u0650\u0651", "\uFCF5", "\u0637\u0649", "\uFCF6", "\u0637\u064A", "\uFCF7", "\u0639\u0649", "\uFCF8", "\u0639\u064A", "\uFCF9", "\u063A\u0649", "\uFCFA", "\u063A\u064A", "\uFCFB", "\u0633\u0649", "\uFCFC", "\u0633\u064A", "\uFCFD", "\u0634\u0649", "\uFCFE", "\u0634\u064A", "\uFCFF", "\u062D\u0649", "\uFD00", "\u062D\u064A", "\uFD01", "\u062C\u0649", "\uFD02", "\u062C\u064A", "\uFD03", "\u062E\u0649", "\uFD04", "\u062E\u064A", "\uFD05", "\u0635\u0649", "\uFD06", "\u0635\u064A", "\uFD07", "\u0636\u0649", "\uFD08", "\u0636\u064A", "\uFD09", "\u0634\u062C", "\uFD0A", "\u0634\u062D", "\uFD0B", "\u0634\u062E", "\uFD0C", "\u0634\u0645", "\uFD0D", "\u0634\u0631", "\uFD0E", "\u0633\u0631", "\uFD0F", "\u0635\u0631", "\uFD10", "\u0636\u0631", "\uFD11", "\u0637\u0649", "\uFD12", "\u0637\u064A", "\uFD13", "\u0639\u0649", "\uFD14", "\u0639\u064A", "\uFD15", "\u063A\u0649", "\uFD16", "\u063A\u064A", "\uFD17", "\u0633\u0649", "\uFD18", "\u0633\u064A", "\uFD19", "\u0634\u0649", "\uFD1A", "\u0634\u064A", "\uFD1B", "\u062D\u0649", "\uFD1C", "\u062D\u064A", "\uFD1D", "\u062C\u0649", "\uFD1E", "\u062C\u064A", "\uFD1F", "\u062E\u0649", "\uFD20", "\u062E\u064A", "\uFD21", "\u0635\u0649", "\uFD22", "\u0635\u064A", "\uFD23", "\u0636\u0649", "\uFD24", "\u0636\u064A", "\uFD25", "\u0634\u062C", "\uFD26", "\u0634\u062D", "\uFD27", "\u0634\u062E", "\uFD28", "\u0634\u0645", "\uFD29", "\u0634\u0631", "\uFD2A", "\u0633\u0631", "\uFD2B", "\u0635\u0631", "\uFD2C", "\u0636\u0631", "\uFD2D", "\u0634\u062C", "\uFD2E", "\u0634\u062D", "\uFD2F", "\u0634\u062E", "\uFD30", "\u0634\u0645", "\uFD31", "\u0633\u0647", "\uFD32", "\u0634\u0647", "\uFD33", "\u0637\u0645", "\uFD34", "\u0633\u062C", "\uFD35", "\u0633\u062D", "\uFD36", "\u0633\u062E", "\uFD37", "\u0634\u062C", "\uFD38", "\u0634\u062D", "\uFD39", "\u0634\u062E", "\uFD3A", "\u0637\u0645", "\uFD3B", "\u0638\u0645", "\uFD3C", "\u0627\u064B", "\uFD3D", "\u0627\u064B", "\uFD50", "\u062A\u062C\u0645", "\uFD51", "\u062A\u062D\u062C", "\uFD52", "\u062A\u062D\u062C", "\uFD53", "\u062A\u062D\u0645", "\uFD54", "\u062A\u062E\u0645", "\uFD55", "\u062A\u0645\u062C", "\uFD56", "\u062A\u0645\u062D", "\uFD57", "\u062A\u0645\u062E", "\uFD58", "\u062C\u0645\u062D", "\uFD59", "\u062C\u0645\u062D", "\uFD5A", "\u062D\u0645\u064A", "\uFD5B", "\u062D\u0645\u0649", "\uFD5C", "\u0633\u062D\u062C", "\uFD5D", "\u0633\u062C\u062D", "\uFD5E", "\u0633\u062C\u0649", "\uFD5F", "\u0633\u0645\u062D", "\uFD60", "\u0633\u0645\u062D", "\uFD61", "\u0633\u0645\u062C", "\uFD62", "\u0633\u0645\u0645", "\uFD63", "\u0633\u0645\u0645", "\uFD64", "\u0635\u062D\u062D", "\uFD65", "\u0635\u062D\u062D", "\uFD66", "\u0635\u0645\u0645", "\uFD67", "\u0634\u062D\u0645", "\uFD68", "\u0634\u062D\u0645", "\uFD69", "\u0634\u062C\u064A", "\uFD6A", "\u0634\u0645\u062E", "\uFD6B", "\u0634\u0645\u062E", "\uFD6C", "\u0634\u0645\u0645", "\uFD6D", "\u0634\u0645\u0645", "\uFD6E", "\u0636\u062D\u0649", "\uFD6F", "\u0636\u062E\u0645", "\uFD70", "\u0636\u062E\u0645", "\uFD71", "\u0637\u0645\u062D", "\uFD72", "\u0637\u0645\u062D", "\uFD73", "\u0637\u0645\u0645", "\uFD74", "\u0637\u0645\u064A", "\uFD75", "\u0639\u062C\u0645", "\uFD76", "\u0639\u0645\u0645", "\uFD77", "\u0639\u0645\u0645", "\uFD78", "\u0639\u0645\u0649", "\uFD79", "\u063A\u0645\u0645", "\uFD7A", "\u063A\u0645\u064A", "\uFD7B", "\u063A\u0645\u0649", "\uFD7C", "\u0641\u062E\u0645", "\uFD7D", "\u0641\u062E\u0645", "\uFD7E", "\u0642\u0645\u062D", "\uFD7F", "\u0642\u0645\u0645", "\uFD80", "\u0644\u062D\u0645", "\uFD81", "\u0644\u062D\u064A", "\uFD82", "\u0644\u062D\u0649", "\uFD83", "\u0644\u062C\u062C", "\uFD84", "\u0644\u062C\u062C", "\uFD85", "\u0644\u062E\u0645", "\uFD86", "\u0644\u062E\u0645", "\uFD87", "\u0644\u0645\u062D", "\uFD88", "\u0644\u0645\u062D", "\uFD89", "\u0645\u062D\u062C", "\uFD8A", "\u0645\u062D\u0645", "\uFD8B", "\u0645\u062D\u064A", "\uFD8C", "\u0645\u062C\u062D", "\uFD8D", "\u0645\u062C\u0645", "\uFD8E", "\u0645\u062E\u062C", "\uFD8F", "\u0645\u062E\u0645", "\uFD92", "\u0645\u062C\u062E", "\uFD93", "\u0647\u0645\u062C", "\uFD94", "\u0647\u0645\u0645", "\uFD95", "\u0646\u062D\u0645", "\uFD96", "\u0646\u062D\u0649", "\uFD97", "\u0646\u062C\u0645", "\uFD98", "\u0646\u062C\u0645", "\uFD99", "\u0646\u062C\u0649", "\uFD9A", "\u0646\u0645\u064A", "\uFD9B", "\u0646\u0645\u0649", "\uFD9C", "\u064A\u0645\u0645", "\uFD9D", "\u064A\u0645\u0645", "\uFD9E", "\u0628\u062E\u064A", "\uFD9F", "\u062A\u062C\u064A", "\uFDA0", "\u062A\u062C\u0649", "\uFDA1", "\u062A\u062E\u064A", "\uFDA2", "\u062A\u062E\u0649", "\uFDA3", "\u062A\u0645\u064A", "\uFDA4", "\u062A\u0645\u0649", "\uFDA5", "\u062C\u0645\u064A", "\uFDA6", "\u062C\u062D\u0649", "\uFDA7", "\u062C\u0645\u0649", "\uFDA8", "\u0633\u062E\u0649", "\uFDA9", "\u0635\u062D\u064A", "\uFDAA", "\u0634\u062D\u064A", "\uFDAB", "\u0636\u062D\u064A", "\uFDAC", "\u0644\u062C\u064A", "\uFDAD", "\u0644\u0645\u064A", "\uFDAE", "\u064A\u062D\u064A", "\uFDAF", "\u064A\u062C\u064A", "\uFDB0", "\u064A\u0645\u064A", "\uFDB1", "\u0645\u0645\u064A", "\uFDB2", "\u0642\u0645\u064A", "\uFDB3", "\u0646\u062D\u064A", "\uFDB4", "\u0642\u0645\u062D", "\uFDB5", "\u0644\u062D\u0645", "\uFDB6", "\u0639\u0645\u064A", "\uFDB7", "\u0643\u0645\u064A", "\uFDB8", "\u0646\u062C\u062D", "\uFDB9", "\u0645\u062E\u064A", "\uFDBA", "\u0644\u062C\u0645", "\uFDBB", "\u0643\u0645\u0645", "\uFDBC", "\u0644\u062C\u0645", "\uFDBD", "\u0646\u062C\u062D", "\uFDBE", "\u062C\u062D\u064A", "\uFDBF", "\u062D\u062C\u064A", "\uFDC0", "\u0645\u062C\u064A", "\uFDC1", "\u0641\u0645\u064A", "\uFDC2", "\u0628\u062D\u064A", "\uFDC3", "\u0643\u0645\u0645", "\uFDC4", "\u0639\u062C\u0645", "\uFDC5", "\u0635\u0645\u0645", "\uFDC6", "\u0633\u062E\u064A", "\uFDC7", "\u0646\u062C\u064A", "\uFE49", "\u203E", "\uFE4A", "\u203E", "\uFE4B", "\u203E", "\uFE4C", "\u203E", "\uFE4D", "\u005F", "\uFE4E", "\u005F", "\uFE4F", "\u005F", "\uFE80", "\u0621", "\uFE81", "\u0622", "\uFE82", "\u0622", "\uFE83", "\u0623", "\uFE84", "\u0623", "\uFE85", "\u0624", "\uFE86", "\u0624", "\uFE87", "\u0625", "\uFE88", "\u0625", "\uFE89", "\u0626", "\uFE8A", "\u0626", "\uFE8B", "\u0626", "\uFE8C", "\u0626", "\uFE8D", "\u0627", "\uFE8E", "\u0627", "\uFE8F", "\u0628", "\uFE90", "\u0628", "\uFE91", "\u0628", "\uFE92", "\u0628", "\uFE93", "\u0629", "\uFE94", "\u0629", "\uFE95", "\u062A", "\uFE96", "\u062A", "\uFE97", "\u062A", "\uFE98", "\u062A", "\uFE99", "\u062B", "\uFE9A", "\u062B", "\uFE9B", "\u062B", "\uFE9C", "\u062B", "\uFE9D", "\u062C", "\uFE9E", "\u062C", "\uFE9F", "\u062C", "\uFEA0", "\u062C", "\uFEA1", "\u062D", "\uFEA2", "\u062D", "\uFEA3", "\u062D", "\uFEA4", "\u062D", "\uFEA5", "\u062E", "\uFEA6", "\u062E", "\uFEA7", "\u062E", "\uFEA8", "\u062E", "\uFEA9", "\u062F", "\uFEAA", "\u062F", "\uFEAB", "\u0630", "\uFEAC", "\u0630", "\uFEAD", "\u0631", "\uFEAE", "\u0631", "\uFEAF", "\u0632", "\uFEB0", "\u0632", "\uFEB1", "\u0633", "\uFEB2", "\u0633", "\uFEB3", "\u0633", "\uFEB4", "\u0633", "\uFEB5", "\u0634", "\uFEB6", "\u0634", "\uFEB7", "\u0634", "\uFEB8", "\u0634", "\uFEB9", "\u0635", "\uFEBA", "\u0635", "\uFEBB", "\u0635", "\uFEBC", "\u0635", "\uFEBD", "\u0636", "\uFEBE", "\u0636", "\uFEBF", "\u0636", "\uFEC0", "\u0636", "\uFEC1", "\u0637", "\uFEC2", "\u0637", "\uFEC3", "\u0637", "\uFEC4", "\u0637", "\uFEC5", "\u0638", "\uFEC6", "\u0638", "\uFEC7", "\u0638", "\uFEC8", "\u0638", "\uFEC9", "\u0639", "\uFECA", "\u0639", "\uFECB", "\u0639", "\uFECC", "\u0639", "\uFECD", "\u063A", "\uFECE", "\u063A", "\uFECF", "\u063A", "\uFED0", "\u063A", "\uFED1", "\u0641", "\uFED2", "\u0641", "\uFED3", "\u0641", "\uFED4", "\u0641", "\uFED5", "\u0642", "\uFED6", "\u0642", "\uFED7", "\u0642", "\uFED8", "\u0642", "\uFED9", "\u0643", "\uFEDA", "\u0643", "\uFEDB", "\u0643", "\uFEDC", "\u0643", "\uFEDD", "\u0644", "\uFEDE", "\u0644", "\uFEDF", "\u0644", "\uFEE0", "\u0644", "\uFEE1", "\u0645", "\uFEE2", "\u0645", "\uFEE3", "\u0645", "\uFEE4", "\u0645", "\uFEE5", "\u0646", "\uFEE6", "\u0646", "\uFEE7", "\u0646", "\uFEE8", "\u0646", "\uFEE9", "\u0647", "\uFEEA", "\u0647", "\uFEEB", "\u0647", "\uFEEC", "\u0647", "\uFEED", "\u0648", "\uFEEE", "\u0648", "\uFEEF", "\u0649", "\uFEF0", "\u0649", "\uFEF1", "\u064A", "\uFEF2", "\u064A", "\uFEF3", "\u064A", "\uFEF4", "\u064A", "\uFEF5", "\u0644\u0622", "\uFEF6", "\u0644\u0622", "\uFEF7", "\u0644\u0623", "\uFEF8", "\u0644\u0623", "\uFEF9", "\u0644\u0625", "\uFEFA", "\u0644\u0625", "\uFEFB", "\u0644\u0627", "\uFEFC", "\u0644\u0627"];
+});
+exports.getNormalizedUnicodes = getNormalizedUnicodes;
+
+function reverseIfRtl(chars) {
+  var charsLength = chars.length;
+
+  if (charsLength <= 1 || !isRTLRangeFor(chars.charCodeAt(0))) {
+    return chars;
+  }
+
+  var s = "";
+
+  for (var ii = charsLength - 1; ii >= 0; ii--) {
+    s += chars[ii];
+  }
+
+  return s;
+}
+
+/***/ }),
+/* 38 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.FontRendererFactory = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _cff_parser = __w_pdfjs_require__(32);
+
+var _glyphlist = __w_pdfjs_require__(35);
+
+var _encodings = __w_pdfjs_require__(34);
+
+var _stream = __w_pdfjs_require__(12);
+
+var FontRendererFactory = function FontRendererFactoryClosure() {
+  function getLong(data, offset) {
+    return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+  }
+
+  function getUshort(data, offset) {
+    return data[offset] << 8 | data[offset + 1];
+  }
+
+  function getSubroutineBias(subrs) {
+    const numSubrs = subrs.length;
+    let bias = 32768;
+
+    if (numSubrs < 1240) {
+      bias = 107;
+    } else if (numSubrs < 33900) {
+      bias = 1131;
+    }
+
+    return bias;
+  }
+
+  function parseCmap(data, start, end) {
+    var offset = getUshort(data, start + 2) === 1 ? getLong(data, start + 8) : getLong(data, start + 16);
+    var format = getUshort(data, start + offset);
+    var ranges, p, i;
+
+    if (format === 4) {
+      getUshort(data, start + offset + 2);
+      var segCount = getUshort(data, start + offset + 6) >> 1;
+      p = start + offset + 14;
+      ranges = [];
+
+      for (i = 0; i < segCount; i++, p += 2) {
+        ranges[i] = {
+          end: getUshort(data, p)
+        };
+      }
+
+      p += 2;
+
+      for (i = 0; i < segCount; i++, p += 2) {
+        ranges[i].start = getUshort(data, p);
+      }
+
+      for (i = 0; i < segCount; i++, p += 2) {
+        ranges[i].idDelta = getUshort(data, p);
+      }
+
+      for (i = 0; i < segCount; i++, p += 2) {
+        var idOffset = getUshort(data, p);
+
+        if (idOffset === 0) {
+          continue;
+        }
+
+        ranges[i].ids = [];
+
+        for (var j = 0, jj = ranges[i].end - ranges[i].start + 1; j < jj; j++) {
+          ranges[i].ids[j] = getUshort(data, p + idOffset);
+          idOffset += 2;
+        }
+      }
+
+      return ranges;
+    } else if (format === 12) {
+      getLong(data, start + offset + 4);
+      var groups = getLong(data, start + offset + 12);
+      p = start + offset + 16;
+      ranges = [];
+
+      for (i = 0; i < groups; i++) {
+        ranges.push({
+          start: getLong(data, p),
+          end: getLong(data, p + 4),
+          idDelta: getLong(data, p + 8) - getLong(data, p)
+        });
+        p += 12;
+      }
+
+      return ranges;
+    }
+
+    throw new _util.FormatError(`unsupported cmap: ${format}`);
+  }
+
+  function parseCff(data, start, end, seacAnalysisEnabled) {
+    var properties = {};
+    var parser = new _cff_parser.CFFParser(new _stream.Stream(data, start, end - start), properties, seacAnalysisEnabled);
+    var cff = parser.parse();
+    return {
+      glyphs: cff.charStrings.objects,
+      subrs: cff.topDict.privateDict && cff.topDict.privateDict.subrsIndex && cff.topDict.privateDict.subrsIndex.objects,
+      gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects,
+      isCFFCIDFont: cff.isCIDFont,
+      fdSelect: cff.fdSelect,
+      fdArray: cff.fdArray
+    };
+  }
+
+  function parseGlyfTable(glyf, loca, isGlyphLocationsLong) {
+    var itemSize, itemDecode;
+
+    if (isGlyphLocationsLong) {
+      itemSize = 4;
+
+      itemDecode = function fontItemDecodeLong(data, offset) {
+        return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+      };
+    } else {
+      itemSize = 2;
+
+      itemDecode = function fontItemDecode(data, offset) {
+        return data[offset] << 9 | data[offset + 1] << 1;
+      };
+    }
+
+    var glyphs = [];
+    var startOffset = itemDecode(loca, 0);
+
+    for (var j = itemSize; j < loca.length; j += itemSize) {
+      var endOffset = itemDecode(loca, j);
+      glyphs.push(glyf.subarray(startOffset, endOffset));
+      startOffset = endOffset;
+    }
+
+    return glyphs;
+  }
+
+  function lookupCmap(ranges, unicode) {
+    var code = unicode.codePointAt(0),
+        gid = 0;
+    var l = 0,
+        r = ranges.length - 1;
+
+    while (l < r) {
+      var c = l + r + 1 >> 1;
+
+      if (code < ranges[c].start) {
+        r = c - 1;
+      } else {
+        l = c;
+      }
+    }
+
+    if (ranges[l].start <= code && code <= ranges[l].end) {
+      gid = ranges[l].idDelta + (ranges[l].ids ? ranges[l].ids[code - ranges[l].start] : code) & 0xffff;
+    }
+
+    return {
+      charCode: code,
+      glyphId: gid
+    };
+  }
+
+  function compileGlyf(code, cmds, font) {
+    function moveTo(x, y) {
+      cmds.push({
+        cmd: "moveTo",
+        args: [x, y]
+      });
+    }
+
+    function lineTo(x, y) {
+      cmds.push({
+        cmd: "lineTo",
+        args: [x, y]
+      });
+    }
+
+    function quadraticCurveTo(xa, ya, x, y) {
+      cmds.push({
+        cmd: "quadraticCurveTo",
+        args: [xa, ya, x, y]
+      });
+    }
+
+    var i = 0;
+    var numberOfContours = (code[i] << 24 | code[i + 1] << 16) >> 16;
+    var flags;
+    var x = 0,
+        y = 0;
+    i += 10;
+
+    if (numberOfContours < 0) {
+      do {
+        flags = code[i] << 8 | code[i + 1];
+        var glyphIndex = code[i + 2] << 8 | code[i + 3];
+        i += 4;
+        var arg1, arg2;
+
+        if (flags & 0x01) {
+          arg1 = (code[i] << 24 | code[i + 1] << 16) >> 16;
+          arg2 = (code[i + 2] << 24 | code[i + 3] << 16) >> 16;
+          i += 4;
+        } else {
+          arg1 = code[i++];
+          arg2 = code[i++];
+        }
+
+        if (flags & 0x02) {
+          x = arg1;
+          y = arg2;
+        } else {
+          x = 0;
+          y = 0;
+        }
+
+        var scaleX = 1,
+            scaleY = 1,
+            scale01 = 0,
+            scale10 = 0;
+
+        if (flags & 0x08) {
+          scaleX = scaleY = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+          i += 2;
+        } else if (flags & 0x40) {
+          scaleX = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+          scaleY = (code[i + 2] << 24 | code[i + 3] << 16) / 1073741824;
+          i += 4;
+        } else if (flags & 0x80) {
+          scaleX = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+          scale01 = (code[i + 2] << 24 | code[i + 3] << 16) / 1073741824;
+          scale10 = (code[i + 4] << 24 | code[i + 5] << 16) / 1073741824;
+          scaleY = (code[i + 6] << 24 | code[i + 7] << 16) / 1073741824;
+          i += 8;
+        }
+
+        var subglyph = font.glyphs[glyphIndex];
+
+        if (subglyph) {
+          cmds.push({
+            cmd: "save"
+          });
+          cmds.push({
+            cmd: "transform",
+            args: [scaleX, scale01, scale10, scaleY, x, y]
+          });
+          compileGlyf(subglyph, cmds, font);
+          cmds.push({
+            cmd: "restore"
+          });
+        }
+      } while (flags & 0x20);
+    } else {
+      var endPtsOfContours = [];
+      var j, jj;
+
+      for (j = 0; j < numberOfContours; j++) {
+        endPtsOfContours.push(code[i] << 8 | code[i + 1]);
+        i += 2;
+      }
+
+      var instructionLength = code[i] << 8 | code[i + 1];
+      i += 2 + instructionLength;
+      var numberOfPoints = endPtsOfContours[endPtsOfContours.length - 1] + 1;
+      var points = [];
+
+      while (points.length < numberOfPoints) {
+        flags = code[i++];
+        var repeat = 1;
+
+        if (flags & 0x08) {
+          repeat += code[i++];
+        }
+
+        while (repeat-- > 0) {
+          points.push({
+            flags
+          });
+        }
+      }
+
+      for (j = 0; j < numberOfPoints; j++) {
+        switch (points[j].flags & 0x12) {
+          case 0x00:
+            x += (code[i] << 24 | code[i + 1] << 16) >> 16;
+            i += 2;
+            break;
+
+          case 0x02:
+            x -= code[i++];
+            break;
+
+          case 0x12:
+            x += code[i++];
+            break;
+        }
+
+        points[j].x = x;
+      }
+
+      for (j = 0; j < numberOfPoints; j++) {
+        switch (points[j].flags & 0x24) {
+          case 0x00:
+            y += (code[i] << 24 | code[i + 1] << 16) >> 16;
+            i += 2;
+            break;
+
+          case 0x04:
+            y -= code[i++];
+            break;
+
+          case 0x24:
+            y += code[i++];
+            break;
+        }
+
+        points[j].y = y;
+      }
+
+      var startPoint = 0;
+
+      for (i = 0; i < numberOfContours; i++) {
+        var endPoint = endPtsOfContours[i];
+        var contour = points.slice(startPoint, endPoint + 1);
+
+        if (contour[0].flags & 1) {
+          contour.push(contour[0]);
+        } else if (contour[contour.length - 1].flags & 1) {
+          contour.unshift(contour[contour.length - 1]);
+        } else {
+          var p = {
+            flags: 1,
+            x: (contour[0].x + contour[contour.length - 1].x) / 2,
+            y: (contour[0].y + contour[contour.length - 1].y) / 2
+          };
+          contour.unshift(p);
+          contour.push(p);
+        }
+
+        moveTo(contour[0].x, contour[0].y);
+
+        for (j = 1, jj = contour.length; j < jj; j++) {
+          if (contour[j].flags & 1) {
+            lineTo(contour[j].x, contour[j].y);
+          } else if (contour[j + 1].flags & 1) {
+            quadraticCurveTo(contour[j].x, contour[j].y, contour[j + 1].x, contour[j + 1].y);
+            j++;
+          } else {
+            quadraticCurveTo(contour[j].x, contour[j].y, (contour[j].x + contour[j + 1].x) / 2, (contour[j].y + contour[j + 1].y) / 2);
+          }
+        }
+
+        startPoint = endPoint + 1;
+      }
+    }
+  }
+
+  function compileCharString(charStringCode, cmds, font, glyphId) {
+    function moveTo(x, y) {
+      cmds.push({
+        cmd: "moveTo",
+        args: [x, y]
+      });
+    }
+
+    function lineTo(x, y) {
+      cmds.push({
+        cmd: "lineTo",
+        args: [x, y]
+      });
+    }
+
+    function bezierCurveTo(x1, y1, x2, y2, x, y) {
+      cmds.push({
+        cmd: "bezierCurveTo",
+        args: [x1, y1, x2, y2, x, y]
+      });
+    }
+
+    var stack = [];
+    var x = 0,
+        y = 0;
+    var stems = 0;
+
+    function parse(code) {
+      var i = 0;
+
+      while (i < code.length) {
+        var stackClean = false;
+        var v = code[i++];
+        var xa, xb, ya, yb, y1, y2, y3, n, subrCode;
+
+        switch (v) {
+          case 1:
+            stems += stack.length >> 1;
+            stackClean = true;
+            break;
+
+          case 3:
+            stems += stack.length >> 1;
+            stackClean = true;
+            break;
+
+          case 4:
+            y += stack.pop();
+            moveTo(x, y);
+            stackClean = true;
+            break;
+
+          case 5:
+            while (stack.length > 0) {
+              x += stack.shift();
+              y += stack.shift();
+              lineTo(x, y);
+            }
+
+            break;
+
+          case 6:
+            while (stack.length > 0) {
+              x += stack.shift();
+              lineTo(x, y);
+
+              if (stack.length === 0) {
+                break;
+              }
+
+              y += stack.shift();
+              lineTo(x, y);
+            }
+
+            break;
+
+          case 7:
+            while (stack.length > 0) {
+              y += stack.shift();
+              lineTo(x, y);
+
+              if (stack.length === 0) {
+                break;
+              }
+
+              x += stack.shift();
+              lineTo(x, y);
+            }
+
+            break;
+
+          case 8:
+            while (stack.length > 0) {
+              xa = x + stack.shift();
+              ya = y + stack.shift();
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb + stack.shift();
+              y = yb + stack.shift();
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            break;
+
+          case 10:
+            n = stack.pop();
+            subrCode = null;
+
+            if (font.isCFFCIDFont) {
+              const fdIndex = font.fdSelect.getFDIndex(glyphId);
+
+              if (fdIndex >= 0 && fdIndex < font.fdArray.length) {
+                const fontDict = font.fdArray[fdIndex];
+                let subrs;
+
+                if (fontDict.privateDict && fontDict.privateDict.subrsIndex) {
+                  subrs = fontDict.privateDict.subrsIndex.objects;
+                }
+
+                if (subrs) {
+                  n += getSubroutineBias(subrs);
+                  subrCode = subrs[n];
+                }
+              } else {
+                (0, _util.warn)("Invalid fd index for glyph index.");
+              }
+            } else {
+              subrCode = font.subrs[n + font.subrsBias];
+            }
+
+            if (subrCode) {
+              parse(subrCode);
+            }
+
+            break;
+
+          case 11:
+            return;
+
+          case 12:
+            v = code[i++];
+
+            switch (v) {
+              case 34:
+                xa = x + stack.shift();
+                xb = xa + stack.shift();
+                y1 = y + stack.shift();
+                x = xb + stack.shift();
+                bezierCurveTo(xa, y, xb, y1, x, y1);
+                xa = x + stack.shift();
+                xb = xa + stack.shift();
+                x = xb + stack.shift();
+                bezierCurveTo(xa, y1, xb, y, x, y);
+                break;
+
+              case 35:
+                xa = x + stack.shift();
+                ya = y + stack.shift();
+                xb = xa + stack.shift();
+                yb = ya + stack.shift();
+                x = xb + stack.shift();
+                y = yb + stack.shift();
+                bezierCurveTo(xa, ya, xb, yb, x, y);
+                xa = x + stack.shift();
+                ya = y + stack.shift();
+                xb = xa + stack.shift();
+                yb = ya + stack.shift();
+                x = xb + stack.shift();
+                y = yb + stack.shift();
+                bezierCurveTo(xa, ya, xb, yb, x, y);
+                stack.pop();
+                break;
+
+              case 36:
+                xa = x + stack.shift();
+                y1 = y + stack.shift();
+                xb = xa + stack.shift();
+                y2 = y1 + stack.shift();
+                x = xb + stack.shift();
+                bezierCurveTo(xa, y1, xb, y2, x, y2);
+                xa = x + stack.shift();
+                xb = xa + stack.shift();
+                y3 = y2 + stack.shift();
+                x = xb + stack.shift();
+                bezierCurveTo(xa, y2, xb, y3, x, y);
+                break;
+
+              case 37:
+                var x0 = x,
+                    y0 = y;
+                xa = x + stack.shift();
+                ya = y + stack.shift();
+                xb = xa + stack.shift();
+                yb = ya + stack.shift();
+                x = xb + stack.shift();
+                y = yb + stack.shift();
+                bezierCurveTo(xa, ya, xb, yb, x, y);
+                xa = x + stack.shift();
+                ya = y + stack.shift();
+                xb = xa + stack.shift();
+                yb = ya + stack.shift();
+                x = xb;
+                y = yb;
+
+                if (Math.abs(x - x0) > Math.abs(y - y0)) {
+                  x += stack.shift();
+                } else {
+                  y += stack.shift();
+                }
+
+                bezierCurveTo(xa, ya, xb, yb, x, y);
+                break;
+
+              default:
+                throw new _util.FormatError(`unknown operator: 12 ${v}`);
+            }
+
+            break;
+
+          case 14:
+            if (stack.length >= 4) {
+              var achar = stack.pop();
+              var bchar = stack.pop();
+              y = stack.pop();
+              x = stack.pop();
+              cmds.push({
+                cmd: "save"
+              });
+              cmds.push({
+                cmd: "translate",
+                args: [x, y]
+              });
+              var cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[_encodings.StandardEncoding[achar]]));
+              compileCharString(font.glyphs[cmap.glyphId], cmds, font, cmap.glyphId);
+              cmds.push({
+                cmd: "restore"
+              });
+              cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[_encodings.StandardEncoding[bchar]]));
+              compileCharString(font.glyphs[cmap.glyphId], cmds, font, cmap.glyphId);
+            }
+
+            return;
+
+          case 18:
+            stems += stack.length >> 1;
+            stackClean = true;
+            break;
+
+          case 19:
+            stems += stack.length >> 1;
+            i += stems + 7 >> 3;
+            stackClean = true;
+            break;
+
+          case 20:
+            stems += stack.length >> 1;
+            i += stems + 7 >> 3;
+            stackClean = true;
+            break;
+
+          case 21:
+            y += stack.pop();
+            x += stack.pop();
+            moveTo(x, y);
+            stackClean = true;
+            break;
+
+          case 22:
+            x += stack.pop();
+            moveTo(x, y);
+            stackClean = true;
+            break;
+
+          case 23:
+            stems += stack.length >> 1;
+            stackClean = true;
+            break;
+
+          case 24:
+            while (stack.length > 2) {
+              xa = x + stack.shift();
+              ya = y + stack.shift();
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb + stack.shift();
+              y = yb + stack.shift();
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            x += stack.shift();
+            y += stack.shift();
+            lineTo(x, y);
+            break;
+
+          case 25:
+            while (stack.length > 6) {
+              x += stack.shift();
+              y += stack.shift();
+              lineTo(x, y);
+            }
+
+            xa = x + stack.shift();
+            ya = y + stack.shift();
+            xb = xa + stack.shift();
+            yb = ya + stack.shift();
+            x = xb + stack.shift();
+            y = yb + stack.shift();
+            bezierCurveTo(xa, ya, xb, yb, x, y);
+            break;
+
+          case 26:
+            if (stack.length % 2) {
+              x += stack.shift();
+            }
+
+            while (stack.length > 0) {
+              xa = x;
+              ya = y + stack.shift();
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb;
+              y = yb + stack.shift();
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            break;
+
+          case 27:
+            if (stack.length % 2) {
+              y += stack.shift();
+            }
+
+            while (stack.length > 0) {
+              xa = x + stack.shift();
+              ya = y;
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb + stack.shift();
+              y = yb;
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            break;
+
+          case 28:
+            stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+            i += 2;
+            break;
+
+          case 29:
+            n = stack.pop() + font.gsubrsBias;
+            subrCode = font.gsubrs[n];
+
+            if (subrCode) {
+              parse(subrCode);
+            }
+
+            break;
+
+          case 30:
+            while (stack.length > 0) {
+              xa = x;
+              ya = y + stack.shift();
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb + stack.shift();
+              y = yb + (stack.length === 1 ? stack.shift() : 0);
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+
+              if (stack.length === 0) {
+                break;
+              }
+
+              xa = x + stack.shift();
+              ya = y;
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              y = yb + stack.shift();
+              x = xb + (stack.length === 1 ? stack.shift() : 0);
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            break;
+
+          case 31:
+            while (stack.length > 0) {
+              xa = x + stack.shift();
+              ya = y;
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              y = yb + stack.shift();
+              x = xb + (stack.length === 1 ? stack.shift() : 0);
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+
+              if (stack.length === 0) {
+                break;
+              }
+
+              xa = x;
+              ya = y + stack.shift();
+              xb = xa + stack.shift();
+              yb = ya + stack.shift();
+              x = xb + stack.shift();
+              y = yb + (stack.length === 1 ? stack.shift() : 0);
+              bezierCurveTo(xa, ya, xb, yb, x, y);
+            }
+
+            break;
+
+          default:
+            if (v < 32) {
+              throw new _util.FormatError(`unknown operator: ${v}`);
+            }
+
+            if (v < 247) {
+              stack.push(v - 139);
+            } else if (v < 251) {
+              stack.push((v - 247) * 256 + code[i++] + 108);
+            } else if (v < 255) {
+              stack.push(-(v - 251) * 256 - code[i++] - 108);
+            } else {
+              stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+              i += 4;
+            }
+
+            break;
+        }
+
+        if (stackClean) {
+          stack.length = 0;
+        }
+      }
+    }
+
+    parse(charStringCode);
+  }
+
+  const NOOP = [];
+
+  class CompiledFont {
+    constructor(fontMatrix) {
+      if (this.constructor === CompiledFont) {
+        (0, _util.unreachable)("Cannot initialize CompiledFont.");
+      }
+
+      this.fontMatrix = fontMatrix;
+      this.compiledGlyphs = Object.create(null);
+      this.compiledCharCodeToGlyphId = Object.create(null);
+    }
+
+    getPathJs(unicode) {
+      const cmap = lookupCmap(this.cmap, unicode);
+      let fn = this.compiledGlyphs[cmap.glyphId];
+
+      if (!fn) {
+        fn = this.compileGlyph(this.glyphs[cmap.glyphId], cmap.glyphId);
+        this.compiledGlyphs[cmap.glyphId] = fn;
+      }
+
+      if (this.compiledCharCodeToGlyphId[cmap.charCode] === undefined) {
+        this.compiledCharCodeToGlyphId[cmap.charCode] = cmap.glyphId;
+      }
+
+      return fn;
+    }
+
+    compileGlyph(code, glyphId) {
+      if (!code || code.length === 0 || code[0] === 14) {
+        return NOOP;
+      }
+
+      let fontMatrix = this.fontMatrix;
+
+      if (this.isCFFCIDFont) {
+        const fdIndex = this.fdSelect.getFDIndex(glyphId);
+
+        if (fdIndex >= 0 && fdIndex < this.fdArray.length) {
+          const fontDict = this.fdArray[fdIndex];
+          fontMatrix = fontDict.getByName("FontMatrix") || _util.FONT_IDENTITY_MATRIX;
+        } else {
+          (0, _util.warn)("Invalid fd index for glyph index.");
+        }
+      }
+
+      const cmds = [];
+      cmds.push({
+        cmd: "save"
+      });
+      cmds.push({
+        cmd: "transform",
+        args: fontMatrix.slice()
+      });
+      cmds.push({
+        cmd: "scale",
+        args: ["size", "-size"]
+      });
+      this.compileGlyphImpl(code, cmds, glyphId);
+      cmds.push({
+        cmd: "restore"
+      });
+      return cmds;
+    }
+
+    compileGlyphImpl() {
+      (0, _util.unreachable)("Children classes should implement this.");
+    }
+
+    hasBuiltPath(unicode) {
+      const cmap = lookupCmap(this.cmap, unicode);
+      return this.compiledGlyphs[cmap.glyphId] !== undefined && this.compiledCharCodeToGlyphId[cmap.charCode] !== undefined;
+    }
+
+  }
+
+  class TrueTypeCompiled extends CompiledFont {
+    constructor(glyphs, cmap, fontMatrix) {
+      super(fontMatrix || [0.000488, 0, 0, 0.000488, 0, 0]);
+      this.glyphs = glyphs;
+      this.cmap = cmap;
+    }
+
+    compileGlyphImpl(code, cmds) {
+      compileGlyf(code, cmds, this);
+    }
+
+  }
+
+  class Type2Compiled extends CompiledFont {
+    constructor(cffInfo, cmap, fontMatrix, glyphNameMap) {
+      super(fontMatrix || [0.001, 0, 0, 0.001, 0, 0]);
+      this.glyphs = cffInfo.glyphs;
+      this.gsubrs = cffInfo.gsubrs || [];
+      this.subrs = cffInfo.subrs || [];
+      this.cmap = cmap;
+      this.glyphNameMap = glyphNameMap || (0, _glyphlist.getGlyphsUnicode)();
+      this.gsubrsBias = getSubroutineBias(this.gsubrs);
+      this.subrsBias = getSubroutineBias(this.subrs);
+      this.isCFFCIDFont = cffInfo.isCFFCIDFont;
+      this.fdSelect = cffInfo.fdSelect;
+      this.fdArray = cffInfo.fdArray;
+    }
+
+    compileGlyphImpl(code, cmds, glyphId) {
+      compileCharString(code, cmds, this, glyphId);
+    }
+
+  }
+
+  return {
+    create: function FontRendererFactory_create(font, seacAnalysisEnabled) {
+      var data = new Uint8Array(font.data);
+      var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm;
+      var numTables = getUshort(data, 4);
+
+      for (var i = 0, p = 12; i < numTables; i++, p += 16) {
+        var tag = (0, _util.bytesToString)(data.subarray(p, p + 4));
+        var offset = getLong(data, p + 8);
+        var length = getLong(data, p + 12);
+
+        switch (tag) {
+          case "cmap":
+            cmap = parseCmap(data, offset, offset + length);
+            break;
+
+          case "glyf":
+            glyf = data.subarray(offset, offset + length);
+            break;
+
+          case "loca":
+            loca = data.subarray(offset, offset + length);
+            break;
+
+          case "head":
+            unitsPerEm = getUshort(data, offset + 18);
+            indexToLocFormat = getUshort(data, offset + 50);
+            break;
+
+          case "CFF ":
+            cff = parseCff(data, offset, offset + length, seacAnalysisEnabled);
+            break;
+        }
+      }
+
+      if (glyf) {
+        var fontMatrix = !unitsPerEm ? font.fontMatrix : [1 / unitsPerEm, 0, 0, 1 / unitsPerEm, 0, 0];
+        return new TrueTypeCompiled(parseGlyfTable(glyf, loca, indexToLocFormat), cmap, fontMatrix);
+      }
+
+      return new Type2Compiled(cff, cmap, font.fontMatrix, font.glyphNameMap);
+    }
+  };
+}();
+
+exports.FontRendererFactory = FontRendererFactory;
+
+/***/ }),
+/* 39 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Type1Parser = void 0;
+
+var _encodings = __w_pdfjs_require__(34);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _util = __w_pdfjs_require__(2);
+
+var HINTING_ENABLED = false;
+
+var Type1CharString = function Type1CharStringClosure() {
+  var COMMAND_MAP = {
+    hstem: [1],
+    vstem: [3],
+    vmoveto: [4],
+    rlineto: [5],
+    hlineto: [6],
+    vlineto: [7],
+    rrcurveto: [8],
+    callsubr: [10],
+    flex: [12, 35],
+    drop: [12, 18],
+    endchar: [14],
+    rmoveto: [21],
+    hmoveto: [22],
+    vhcurveto: [30],
+    hvcurveto: [31]
+  };
+
+  function Type1CharString() {
+    this.width = 0;
+    this.lsb = 0;
+    this.flexing = false;
+    this.output = [];
+    this.stack = [];
+  }
+
+  Type1CharString.prototype = {
+    convert: function Type1CharString_convert(encoded, subrs, seacAnalysisEnabled) {
+      var count = encoded.length;
+      var error = false;
+      var wx, sbx, subrNumber;
+
+      for (var i = 0; i < count; i++) {
+        var value = encoded[i];
+
+        if (value < 32) {
+          if (value === 12) {
+            value = (value << 8) + encoded[++i];
+          }
+
+          switch (value) {
+            case 1:
+              if (!HINTING_ENABLED) {
+                this.stack = [];
+                break;
+              }
+
+              error = this.executeCommand(2, COMMAND_MAP.hstem);
+              break;
+
+            case 3:
+              if (!HINTING_ENABLED) {
+                this.stack = [];
+                break;
+              }
+
+              error = this.executeCommand(2, COMMAND_MAP.vstem);
+              break;
+
+            case 4:
+              if (this.flexing) {
+                if (this.stack.length < 1) {
+                  error = true;
+                  break;
+                }
+
+                var dy = this.stack.pop();
+                this.stack.push(0, dy);
+                break;
+              }
+
+              error = this.executeCommand(1, COMMAND_MAP.vmoveto);
+              break;
+
+            case 5:
+              error = this.executeCommand(2, COMMAND_MAP.rlineto);
+              break;
+
+            case 6:
+              error = this.executeCommand(1, COMMAND_MAP.hlineto);
+              break;
+
+            case 7:
+              error = this.executeCommand(1, COMMAND_MAP.vlineto);
+              break;
+
+            case 8:
+              error = this.executeCommand(6, COMMAND_MAP.rrcurveto);
+              break;
+
+            case 9:
+              this.stack = [];
+              break;
+
+            case 10:
+              if (this.stack.length < 1) {
+                error = true;
+                break;
+              }
+
+              subrNumber = this.stack.pop();
+
+              if (!subrs[subrNumber]) {
+                error = true;
+                break;
+              }
+
+              error = this.convert(subrs[subrNumber], subrs, seacAnalysisEnabled);
+              break;
+
+            case 11:
+              return error;
+
+            case 13:
+              if (this.stack.length < 2) {
+                error = true;
+                break;
+              }
+
+              wx = this.stack.pop();
+              sbx = this.stack.pop();
+              this.lsb = sbx;
+              this.width = wx;
+              this.stack.push(wx, sbx);
+              error = this.executeCommand(2, COMMAND_MAP.hmoveto);
+              break;
+
+            case 14:
+              this.output.push(COMMAND_MAP.endchar[0]);
+              break;
+
+            case 21:
+              if (this.flexing) {
+                break;
+              }
+
+              error = this.executeCommand(2, COMMAND_MAP.rmoveto);
+              break;
+
+            case 22:
+              if (this.flexing) {
+                this.stack.push(0);
+                break;
+              }
+
+              error = this.executeCommand(1, COMMAND_MAP.hmoveto);
+              break;
+
+            case 30:
+              error = this.executeCommand(4, COMMAND_MAP.vhcurveto);
+              break;
+
+            case 31:
+              error = this.executeCommand(4, COMMAND_MAP.hvcurveto);
+              break;
+
+            case (12 << 8) + 0:
+              this.stack = [];
+              break;
+
+            case (12 << 8) + 1:
+              if (!HINTING_ENABLED) {
+                this.stack = [];
+                break;
+              }
+
+              error = this.executeCommand(2, COMMAND_MAP.vstem);
+              break;
+
+            case (12 << 8) + 2:
+              if (!HINTING_ENABLED) {
+                this.stack = [];
+                break;
+              }
+
+              error = this.executeCommand(2, COMMAND_MAP.hstem);
+              break;
+
+            case (12 << 8) + 6:
+              if (seacAnalysisEnabled) {
+                const asb = this.stack[this.stack.length - 5];
+                this.seac = this.stack.splice(-4, 4);
+                this.seac[0] += this.lsb - asb;
+                error = this.executeCommand(0, COMMAND_MAP.endchar);
+              } else {
+                error = this.executeCommand(4, COMMAND_MAP.endchar);
+              }
+
+              break;
+
+            case (12 << 8) + 7:
+              if (this.stack.length < 4) {
+                error = true;
+                break;
+              }
+
+              this.stack.pop();
+              wx = this.stack.pop();
+              var sby = this.stack.pop();
+              sbx = this.stack.pop();
+              this.lsb = sbx;
+              this.width = wx;
+              this.stack.push(wx, sbx, sby);
+              error = this.executeCommand(3, COMMAND_MAP.rmoveto);
+              break;
+
+            case (12 << 8) + 12:
+              if (this.stack.length < 2) {
+                error = true;
+                break;
+              }
+
+              var num2 = this.stack.pop();
+              var num1 = this.stack.pop();
+              this.stack.push(num1 / num2);
+              break;
+
+            case (12 << 8) + 16:
+              if (this.stack.length < 2) {
+                error = true;
+                break;
+              }
+
+              subrNumber = this.stack.pop();
+              var numArgs = this.stack.pop();
+
+              if (subrNumber === 0 && numArgs === 3) {
+                var flexArgs = this.stack.splice(this.stack.length - 17, 17);
+                this.stack.push(flexArgs[2] + flexArgs[0], flexArgs[3] + flexArgs[1], flexArgs[4], flexArgs[5], flexArgs[6], flexArgs[7], flexArgs[8], flexArgs[9], flexArgs[10], flexArgs[11], flexArgs[12], flexArgs[13], flexArgs[14]);
+                error = this.executeCommand(13, COMMAND_MAP.flex, true);
+                this.flexing = false;
+                this.stack.push(flexArgs[15], flexArgs[16]);
+              } else if (subrNumber === 1 && numArgs === 0) {
+                this.flexing = true;
+              }
+
+              break;
+
+            case (12 << 8) + 17:
+              break;
+
+            case (12 << 8) + 33:
+              this.stack = [];
+              break;
+
+            default:
+              (0, _util.warn)('Unknown type 1 charstring command of "' + value + '"');
+              break;
+          }
+
+          if (error) {
+            break;
+          }
+
+          continue;
+        } else if (value <= 246) {
+          value = value - 139;
+        } else if (value <= 250) {
+          value = (value - 247) * 256 + encoded[++i] + 108;
+        } else if (value <= 254) {
+          value = -((value - 251) * 256) - encoded[++i] - 108;
+        } else {
+          value = (encoded[++i] & 0xff) << 24 | (encoded[++i] & 0xff) << 16 | (encoded[++i] & 0xff) << 8 | (encoded[++i] & 0xff) << 0;
+        }
+
+        this.stack.push(value);
+      }
+
+      return error;
+    },
+
+    executeCommand(howManyArgs, command, keepStack) {
+      var stackLength = this.stack.length;
+
+      if (howManyArgs > stackLength) {
+        return true;
+      }
+
+      var start = stackLength - howManyArgs;
+
+      for (var i = start; i < stackLength; i++) {
+        var value = this.stack[i];
+
+        if (Number.isInteger(value)) {
+          this.output.push(28, value >> 8 & 0xff, value & 0xff);
+        } else {
+          value = 65536 * value | 0;
+          this.output.push(255, value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
+        }
+      }
+
+      this.output.push.apply(this.output, command);
+
+      if (keepStack) {
+        this.stack.splice(start, howManyArgs);
+      } else {
+        this.stack.length = 0;
+      }
+
+      return false;
+    }
+
+  };
+  return Type1CharString;
+}();
+
+var Type1Parser = function Type1ParserClosure() {
+  var EEXEC_ENCRYPT_KEY = 55665;
+  var CHAR_STRS_ENCRYPT_KEY = 4330;
+
+  function isHexDigit(code) {
+    return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
+  }
+
+  function decrypt(data, key, discardNumber) {
+    if (discardNumber >= data.length) {
+      return new Uint8Array(0);
+    }
+
+    var r = key | 0,
+        c1 = 52845,
+        c2 = 22719,
+        i,
+        j;
+
+    for (i = 0; i < discardNumber; i++) {
+      r = (data[i] + r) * c1 + c2 & (1 << 16) - 1;
+    }
+
+    var count = data.length - discardNumber;
+    var decrypted = new Uint8Array(count);
+
+    for (i = discardNumber, j = 0; j < count; i++, j++) {
+      var value = data[i];
+      decrypted[j] = value ^ r >> 8;
+      r = (value + r) * c1 + c2 & (1 << 16) - 1;
+    }
+
+    return decrypted;
+  }
+
+  function decryptAscii(data, key, discardNumber) {
+    var r = key | 0,
+        c1 = 52845,
+        c2 = 22719;
+    var count = data.length,
+        maybeLength = count >>> 1;
+    var decrypted = new Uint8Array(maybeLength);
+    var i, j;
+
+    for (i = 0, j = 0; i < count; i++) {
+      var digit1 = data[i];
+
+      if (!isHexDigit(digit1)) {
+        continue;
+      }
+
+      i++;
+      var digit2;
+
+      while (i < count && !isHexDigit(digit2 = data[i])) {
+        i++;
+      }
+
+      if (i < count) {
+        var value = parseInt(String.fromCharCode(digit1, digit2), 16);
+        decrypted[j++] = value ^ r >> 8;
+        r = (value + r) * c1 + c2 & (1 << 16) - 1;
+      }
+    }
+
+    return decrypted.slice(discardNumber, j);
+  }
+
+  function isSpecial(c) {
+    return c === 0x2f || c === 0x5b || c === 0x5d || c === 0x7b || c === 0x7d || c === 0x28 || c === 0x29;
+  }
+
+  function Type1Parser(stream, encrypted, seacAnalysisEnabled) {
+    if (encrypted) {
+      var data = stream.getBytes();
+      var isBinary = !((isHexDigit(data[0]) || (0, _core_utils.isWhiteSpace)(data[0])) && isHexDigit(data[1]) && isHexDigit(data[2]) && isHexDigit(data[3]) && isHexDigit(data[4]) && isHexDigit(data[5]) && isHexDigit(data[6]) && isHexDigit(data[7]));
+      stream = new _stream.Stream(isBinary ? decrypt(data, EEXEC_ENCRYPT_KEY, 4) : decryptAscii(data, EEXEC_ENCRYPT_KEY, 4));
+    }
+
+    this.seacAnalysisEnabled = !!seacAnalysisEnabled;
+    this.stream = stream;
+    this.nextChar();
+  }
+
+  Type1Parser.prototype = {
+    readNumberArray: function Type1Parser_readNumberArray() {
+      this.getToken();
+      var array = [];
+
+      while (true) {
+        var token = this.getToken();
+
+        if (token === null || token === "]" || token === "}") {
+          break;
+        }
+
+        array.push(parseFloat(token || 0));
+      }
+
+      return array;
+    },
+    readNumber: function Type1Parser_readNumber() {
+      var token = this.getToken();
+      return parseFloat(token || 0);
+    },
+    readInt: function Type1Parser_readInt() {
+      var token = this.getToken();
+      return parseInt(token || 0, 10) | 0;
+    },
+    readBoolean: function Type1Parser_readBoolean() {
+      var token = this.getToken();
+      return token === "true" ? 1 : 0;
+    },
+    nextChar: function Type1_nextChar() {
+      return this.currentChar = this.stream.getByte();
+    },
+    getToken: function Type1Parser_getToken() {
+      var comment = false;
+      var ch = this.currentChar;
+
+      while (true) {
+        if (ch === -1) {
+          return null;
+        }
+
+        if (comment) {
+          if (ch === 0x0a || ch === 0x0d) {
+            comment = false;
+          }
+        } else if (ch === 0x25) {
+          comment = true;
+        } else if (!(0, _core_utils.isWhiteSpace)(ch)) {
+          break;
+        }
+
+        ch = this.nextChar();
+      }
+
+      if (isSpecial(ch)) {
+        this.nextChar();
+        return String.fromCharCode(ch);
+      }
+
+      var token = "";
+
+      do {
+        token += String.fromCharCode(ch);
+        ch = this.nextChar();
+      } while (ch >= 0 && !(0, _core_utils.isWhiteSpace)(ch) && !isSpecial(ch));
+
+      return token;
+    },
+    readCharStrings: function Type1Parser_readCharStrings(bytes, lenIV) {
+      if (lenIV === -1) {
+        return bytes;
+      }
+
+      return decrypt(bytes, CHAR_STRS_ENCRYPT_KEY, lenIV);
+    },
+    extractFontProgram: function Type1Parser_extractFontProgram(properties) {
+      var stream = this.stream;
+      var subrs = [],
+          charstrings = [];
+      var privateData = Object.create(null);
+      privateData.lenIV = 4;
+      var program = {
+        subrs: [],
+        charstrings: [],
+        properties: {
+          privateData
+        }
+      };
+      var token, length, data, lenIV, encoded;
+
+      while ((token = this.getToken()) !== null) {
+        if (token !== "/") {
+          continue;
+        }
+
+        token = this.getToken();
+
+        switch (token) {
+          case "CharStrings":
+            this.getToken();
+            this.getToken();
+            this.getToken();
+            this.getToken();
+
+            while (true) {
+              token = this.getToken();
+
+              if (token === null || token === "end") {
+                break;
+              }
+
+              if (token !== "/") {
+                continue;
+              }
+
+              var glyph = this.getToken();
+              length = this.readInt();
+              this.getToken();
+              data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
+              lenIV = program.properties.privateData.lenIV;
+              encoded = this.readCharStrings(data, lenIV);
+              this.nextChar();
+              token = this.getToken();
+
+              if (token === "noaccess") {
+                this.getToken();
+              }
+
+              charstrings.push({
+                glyph,
+                encoded
+              });
+            }
+
+            break;
+
+          case "Subrs":
+            this.readInt();
+            this.getToken();
+
+            while (this.getToken() === "dup") {
+              const index = this.readInt();
+              length = this.readInt();
+              this.getToken();
+              data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
+              lenIV = program.properties.privateData.lenIV;
+              encoded = this.readCharStrings(data, lenIV);
+              this.nextChar();
+              token = this.getToken();
+
+              if (token === "noaccess") {
+                this.getToken();
+              }
+
+              subrs[index] = encoded;
+            }
+
+            break;
+
+          case "BlueValues":
+          case "OtherBlues":
+          case "FamilyBlues":
+          case "FamilyOtherBlues":
+            var blueArray = this.readNumberArray();
+
+            if (blueArray.length > 0 && blueArray.length % 2 === 0 && HINTING_ENABLED) {
+              program.properties.privateData[token] = blueArray;
+            }
+
+            break;
+
+          case "StemSnapH":
+          case "StemSnapV":
+            program.properties.privateData[token] = this.readNumberArray();
+            break;
+
+          case "StdHW":
+          case "StdVW":
+            program.properties.privateData[token] = this.readNumberArray()[0];
+            break;
+
+          case "BlueShift":
+          case "lenIV":
+          case "BlueFuzz":
+          case "BlueScale":
+          case "LanguageGroup":
+          case "ExpansionFactor":
+            program.properties.privateData[token] = this.readNumber();
+            break;
+
+          case "ForceBold":
+            program.properties.privateData[token] = this.readBoolean();
+            break;
+        }
+      }
+
+      for (var i = 0; i < charstrings.length; i++) {
+        glyph = charstrings[i].glyph;
+        encoded = charstrings[i].encoded;
+        var charString = new Type1CharString();
+        var error = charString.convert(encoded, subrs, this.seacAnalysisEnabled);
+        var output = charString.output;
+
+        if (error) {
+          output = [14];
+        }
+
+        const charStringObject = {
+          glyphName: glyph,
+          charstring: output,
+          width: charString.width,
+          lsb: charString.lsb,
+          seac: charString.seac
+        };
+
+        if (glyph === ".notdef") {
+          program.charstrings.unshift(charStringObject);
+        } else {
+          program.charstrings.push(charStringObject);
+        }
+
+        if (properties.builtInEncoding) {
+          const index = properties.builtInEncoding.indexOf(glyph);
+
+          if (index > -1 && properties.widths[index] === undefined && index >= properties.firstChar && index <= properties.lastChar) {
+            properties.widths[index] = charString.width;
+          }
+        }
+      }
+
+      return program;
+    },
+    extractFontHeader: function Type1Parser_extractFontHeader(properties) {
+      var token;
+
+      while ((token = this.getToken()) !== null) {
+        if (token !== "/") {
+          continue;
+        }
+
+        token = this.getToken();
+
+        switch (token) {
+          case "FontMatrix":
+            var matrix = this.readNumberArray();
+            properties.fontMatrix = matrix;
+            break;
+
+          case "Encoding":
+            var encodingArg = this.getToken();
+            var encoding;
+
+            if (!/^\d+$/.test(encodingArg)) {
+              encoding = (0, _encodings.getEncoding)(encodingArg);
+            } else {
+              encoding = [];
+              var size = parseInt(encodingArg, 10) | 0;
+              this.getToken();
+
+              for (var j = 0; j < size; j++) {
+                token = this.getToken();
+
+                while (token !== "dup" && token !== "def") {
+                  token = this.getToken();
+
+                  if (token === null) {
+                    return;
+                  }
+                }
+
+                if (token === "def") {
+                  break;
+                }
+
+                var index = this.readInt();
+                this.getToken();
+                var glyph = this.getToken();
+                encoding[index] = glyph;
+                this.getToken();
+              }
+            }
+
+            properties.builtInEncoding = encoding;
+            break;
+
+          case "FontBBox":
+            var fontBBox = this.readNumberArray();
+            properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
+            properties.descent = Math.min(fontBBox[1], fontBBox[3]);
+            properties.ascentScaled = true;
+            break;
+        }
+      }
+    }
+  };
+  return Type1Parser;
+}();
+
+exports.Type1Parser = Type1Parser;
+
+/***/ }),
+/* 40 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getTilingPatternIR = getTilingPatternIR;
+exports.Pattern = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _colorspace = __w_pdfjs_require__(23);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var ShadingType = {
+  FUNCTION_BASED: 1,
+  AXIAL: 2,
+  RADIAL: 3,
+  FREE_FORM_MESH: 4,
+  LATTICE_FORM_MESH: 5,
+  COONS_PATCH_MESH: 6,
+  TENSOR_PATCH_MESH: 7
+};
+
+var Pattern = function PatternClosure() {
+  function Pattern() {
+    (0, _util.unreachable)("should not call Pattern constructor");
+  }
+
+  Pattern.prototype = {
+    getPattern: function Pattern_getPattern(ctx) {
+      (0, _util.unreachable)(`Should not call Pattern.getStyle: ${ctx}`);
+    }
+  };
+
+  Pattern.parseShading = function (shading, matrix, xref, res, handler, pdfFunctionFactory, localColorSpaceCache) {
+    var dict = (0, _primitives.isStream)(shading) ? shading.dict : shading;
+    var type = dict.get("ShadingType");
+
+    try {
+      switch (type) {
+        case ShadingType.AXIAL:
+        case ShadingType.RADIAL:
+          return new Shadings.RadialAxial(dict, matrix, xref, res, pdfFunctionFactory, localColorSpaceCache);
+
+        case ShadingType.FREE_FORM_MESH:
+        case ShadingType.LATTICE_FORM_MESH:
+        case ShadingType.COONS_PATCH_MESH:
+        case ShadingType.TENSOR_PATCH_MESH:
+          return new Shadings.Mesh(shading, matrix, xref, res, pdfFunctionFactory, localColorSpaceCache);
+
+        default:
+          throw new _util.FormatError("Unsupported ShadingType: " + type);
+      }
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
+
+      handler.send("UnsupportedFeature", {
+        featureId: _util.UNSUPPORTED_FEATURES.shadingPattern
+      });
+      (0, _util.warn)(ex);
+      return new Shadings.Dummy();
+    }
+  };
+
+  return Pattern;
+}();
+
+exports.Pattern = Pattern;
+var Shadings = {};
+Shadings.SMALL_NUMBER = 1e-6;
+
+Shadings.RadialAxial = function RadialAxialClosure() {
+  function RadialAxial(dict, matrix, xref, resources, pdfFunctionFactory, localColorSpaceCache) {
+    this.matrix = matrix;
+    this.coordsArr = dict.getArray("Coords");
+    this.shadingType = dict.get("ShadingType");
+    this.type = "Pattern";
+
+    const cs = _colorspace.ColorSpace.parse({
+      cs: dict.getRaw("ColorSpace") || dict.getRaw("CS"),
+      xref,
+      resources,
+      pdfFunctionFactory,
+      localColorSpaceCache
+    });
+
+    this.cs = cs;
+    const bbox = dict.getArray("BBox");
+
+    if (Array.isArray(bbox) && bbox.length === 4) {
+      this.bbox = _util.Util.normalizeRect(bbox);
+    } else {
+      this.bbox = null;
+    }
+
+    var t0 = 0.0,
+        t1 = 1.0;
+
+    if (dict.has("Domain")) {
+      var domainArr = dict.getArray("Domain");
+      t0 = domainArr[0];
+      t1 = domainArr[1];
+    }
+
+    var extendStart = false,
+        extendEnd = false;
+
+    if (dict.has("Extend")) {
+      var extendArr = dict.getArray("Extend");
+      extendStart = extendArr[0];
+      extendEnd = extendArr[1];
+    }
+
+    if (this.shadingType === ShadingType.RADIAL && (!extendStart || !extendEnd)) {
+      var x1 = this.coordsArr[0];
+      var y1 = this.coordsArr[1];
+      var r1 = this.coordsArr[2];
+      var x2 = this.coordsArr[3];
+      var y2 = this.coordsArr[4];
+      var r2 = this.coordsArr[5];
+      var distance = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+
+      if (r1 <= r2 + distance && r2 <= r1 + distance) {
+        (0, _util.warn)("Unsupported radial gradient.");
+      }
+    }
+
+    this.extendStart = extendStart;
+    this.extendEnd = extendEnd;
+    var fnObj = dict.getRaw("Function");
+    var fn = pdfFunctionFactory.createFromArray(fnObj);
+    const NUMBER_OF_SAMPLES = 10;
+    const step = (t1 - t0) / NUMBER_OF_SAMPLES;
+    var colorStops = this.colorStops = [];
+
+    if (t0 >= t1 || step <= 0) {
+      (0, _util.info)("Bad shading domain.");
+      return;
+    }
+
+    var color = new Float32Array(cs.numComps),
+        ratio = new Float32Array(1);
+    var rgbColor;
+
+    for (let i = 0; i <= NUMBER_OF_SAMPLES; i++) {
+      ratio[0] = t0 + i * step;
+      fn(ratio, 0, color, 0);
+      rgbColor = cs.getRgb(color, 0);
+
+      var cssColor = _util.Util.makeHexColor(rgbColor[0], rgbColor[1], rgbColor[2]);
+
+      colorStops.push([i / NUMBER_OF_SAMPLES, cssColor]);
+    }
+
+    var background = "transparent";
+
+    if (dict.has("Background")) {
+      rgbColor = cs.getRgb(dict.get("Background"), 0);
+      background = _util.Util.makeHexColor(rgbColor[0], rgbColor[1], rgbColor[2]);
+    }
+
+    if (!extendStart) {
+      colorStops.unshift([0, background]);
+      colorStops[1][0] += Shadings.SMALL_NUMBER;
+    }
+
+    if (!extendEnd) {
+      colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER;
+      colorStops.push([1, background]);
+    }
+
+    this.colorStops = colorStops;
+  }
+
+  RadialAxial.prototype = {
+    getIR: function RadialAxial_getIR() {
+      var coordsArr = this.coordsArr;
+      var shadingType = this.shadingType;
+      var type, p0, p1, r0, r1;
+
+      if (shadingType === ShadingType.AXIAL) {
+        p0 = [coordsArr[0], coordsArr[1]];
+        p1 = [coordsArr[2], coordsArr[3]];
+        r0 = null;
+        r1 = null;
+        type = "axial";
+      } else if (shadingType === ShadingType.RADIAL) {
+        p0 = [coordsArr[0], coordsArr[1]];
+        p1 = [coordsArr[3], coordsArr[4]];
+        r0 = coordsArr[2];
+        r1 = coordsArr[5];
+        type = "radial";
+      } else {
+        (0, _util.unreachable)(`getPattern type unknown: ${shadingType}`);
+      }
+
+      var matrix = this.matrix;
+
+      if (matrix) {
+        p0 = _util.Util.applyTransform(p0, matrix);
+        p1 = _util.Util.applyTransform(p1, matrix);
+
+        if (shadingType === ShadingType.RADIAL) {
+          var scale = _util.Util.singularValueDecompose2dScale(matrix);
+
+          r0 *= scale[0];
+          r1 *= scale[1];
+        }
+      }
+
+      return ["RadialAxial", type, this.bbox, this.colorStops, p0, p1, r0, r1];
+    }
+  };
+  return RadialAxial;
+}();
+
+Shadings.Mesh = function MeshClosure() {
+  function MeshStreamReader(stream, context) {
+    this.stream = stream;
+    this.context = context;
+    this.buffer = 0;
+    this.bufferLength = 0;
+    var numComps = context.numComps;
+    this.tmpCompsBuf = new Float32Array(numComps);
+    var csNumComps = context.colorSpace.numComps;
+    this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : this.tmpCompsBuf;
+  }
+
+  MeshStreamReader.prototype = {
+    get hasData() {
+      if (this.stream.end) {
+        return this.stream.pos < this.stream.end;
+      }
+
+      if (this.bufferLength > 0) {
+        return true;
+      }
+
+      var nextByte = this.stream.getByte();
+
+      if (nextByte < 0) {
+        return false;
+      }
+
+      this.buffer = nextByte;
+      this.bufferLength = 8;
+      return true;
+    },
+
+    readBits: function MeshStreamReader_readBits(n) {
+      var buffer = this.buffer;
+      var bufferLength = this.bufferLength;
+
+      if (n === 32) {
+        if (bufferLength === 0) {
+          return (this.stream.getByte() << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte()) >>> 0;
+        }
+
+        buffer = buffer << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte();
+        var nextByte = this.stream.getByte();
+        this.buffer = nextByte & (1 << bufferLength) - 1;
+        return (buffer << 8 - bufferLength | (nextByte & 0xff) >> bufferLength) >>> 0;
+      }
+
+      if (n === 8 && bufferLength === 0) {
+        return this.stream.getByte();
+      }
+
+      while (bufferLength < n) {
+        buffer = buffer << 8 | this.stream.getByte();
+        bufferLength += 8;
+      }
+
+      bufferLength -= n;
+      this.bufferLength = bufferLength;
+      this.buffer = buffer & (1 << bufferLength) - 1;
+      return buffer >> bufferLength;
+    },
+    align: function MeshStreamReader_align() {
+      this.buffer = 0;
+      this.bufferLength = 0;
+    },
+    readFlag: function MeshStreamReader_readFlag() {
+      return this.readBits(this.context.bitsPerFlag);
+    },
+    readCoordinate: function MeshStreamReader_readCoordinate() {
+      var bitsPerCoordinate = this.context.bitsPerCoordinate;
+      var xi = this.readBits(bitsPerCoordinate);
+      var yi = this.readBits(bitsPerCoordinate);
+      var decode = this.context.decode;
+      var scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : 2.3283064365386963e-10;
+      return [xi * scale * (decode[1] - decode[0]) + decode[0], yi * scale * (decode[3] - decode[2]) + decode[2]];
+    },
+    readComponents: function MeshStreamReader_readComponents() {
+      var numComps = this.context.numComps;
+      var bitsPerComponent = this.context.bitsPerComponent;
+      var scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : 2.3283064365386963e-10;
+      var decode = this.context.decode;
+      var components = this.tmpCompsBuf;
+
+      for (var i = 0, j = 4; i < numComps; i++, j += 2) {
+        var ci = this.readBits(bitsPerComponent);
+        components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
+      }
+
+      var color = this.tmpCsCompsBuf;
+
+      if (this.context.colorFn) {
+        this.context.colorFn(components, 0, color, 0);
+      }
+
+      return this.context.colorSpace.getRgb(color, 0);
+    }
+  };
+
+  function decodeType4Shading(mesh, reader) {
+    var coords = mesh.coords;
+    var colors = mesh.colors;
+    var operators = [];
+    var ps = [];
+    var verticesLeft = 0;
+
+    while (reader.hasData) {
+      var f = reader.readFlag();
+      var coord = reader.readCoordinate();
+      var color = reader.readComponents();
+
+      if (verticesLeft === 0) {
+        if (!(0 <= f && f <= 2)) {
+          throw new _util.FormatError("Unknown type4 flag");
+        }
+
+        switch (f) {
+          case 0:
+            verticesLeft = 3;
+            break;
+
+          case 1:
+            ps.push(ps[ps.length - 2], ps[ps.length - 1]);
+            verticesLeft = 1;
+            break;
+
+          case 2:
+            ps.push(ps[ps.length - 3], ps[ps.length - 1]);
+            verticesLeft = 1;
+            break;
+        }
+
+        operators.push(f);
+      }
+
+      ps.push(coords.length);
+      coords.push(coord);
+      colors.push(color);
+      verticesLeft--;
+      reader.align();
+    }
+
+    mesh.figures.push({
+      type: "triangles",
+      coords: new Int32Array(ps),
+      colors: new Int32Array(ps)
+    });
+  }
+
+  function decodeType5Shading(mesh, reader, verticesPerRow) {
+    var coords = mesh.coords;
+    var colors = mesh.colors;
+    var ps = [];
+
+    while (reader.hasData) {
+      var coord = reader.readCoordinate();
+      var color = reader.readComponents();
+      ps.push(coords.length);
+      coords.push(coord);
+      colors.push(color);
+    }
+
+    mesh.figures.push({
+      type: "lattice",
+      coords: new Int32Array(ps),
+      colors: new Int32Array(ps),
+      verticesPerRow
+    });
+  }
+
+  var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
+  var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
+  var TRIANGLE_DENSITY = 20;
+
+  var getB = function getBClosure() {
+    function buildB(count) {
+      var lut = [];
+
+      for (var i = 0; i <= count; i++) {
+        var t = i / count,
+            t_ = 1 - t;
+        lut.push(new Float32Array([t_ * t_ * t_, 3 * t * t_ * t_, 3 * t * t * t_, t * t * t]));
+      }
+
+      return lut;
+    }
+
+    var cache = [];
+    return function getB(count) {
+      if (!cache[count]) {
+        cache[count] = buildB(count);
+      }
+
+      return cache[count];
+    };
+  }();
+
+  function buildFigureFromPatch(mesh, index) {
+    var figure = mesh.figures[index];
+    (0, _util.assert)(figure.type === "patch", "Unexpected patch mesh figure");
+    var coords = mesh.coords,
+        colors = mesh.colors;
+    var pi = figure.coords;
+    var ci = figure.colors;
+    var figureMinX = Math.min(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
+    var figureMinY = Math.min(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
+    var figureMaxX = Math.max(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
+    var figureMaxY = Math.max(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
+    var splitXBy = Math.ceil((figureMaxX - figureMinX) * TRIANGLE_DENSITY / (mesh.bounds[2] - mesh.bounds[0]));
+    splitXBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy));
+    var splitYBy = Math.ceil((figureMaxY - figureMinY) * TRIANGLE_DENSITY / (mesh.bounds[3] - mesh.bounds[1]));
+    splitYBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy));
+    var verticesPerRow = splitXBy + 1;
+    var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
+    var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
+    var k = 0;
+    var cl = new Uint8Array(3),
+        cr = new Uint8Array(3);
+    var c0 = colors[ci[0]],
+        c1 = colors[ci[1]],
+        c2 = colors[ci[2]],
+        c3 = colors[ci[3]];
+    var bRow = getB(splitYBy),
+        bCol = getB(splitXBy);
+
+    for (var row = 0; row <= splitYBy; row++) {
+      cl[0] = (c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy | 0;
+      cl[1] = (c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy | 0;
+      cl[2] = (c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy | 0;
+      cr[0] = (c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy | 0;
+      cr[1] = (c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy | 0;
+      cr[2] = (c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy | 0;
+
+      for (var col = 0; col <= splitXBy; col++, k++) {
+        if ((row === 0 || row === splitYBy) && (col === 0 || col === splitXBy)) {
+          continue;
+        }
+
+        var x = 0,
+            y = 0;
+        var q = 0;
+
+        for (var i = 0; i <= 3; i++) {
+          for (var j = 0; j <= 3; j++, q++) {
+            var m = bRow[row][i] * bCol[col][j];
+            x += coords[pi[q]][0] * m;
+            y += coords[pi[q]][1] * m;
+          }
+        }
+
+        figureCoords[k] = coords.length;
+        coords.push([x, y]);
+        figureColors[k] = colors.length;
+        var newColor = new Uint8Array(3);
+        newColor[0] = (cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy | 0;
+        newColor[1] = (cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy | 0;
+        newColor[2] = (cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy | 0;
+        colors.push(newColor);
+      }
+    }
+
+    figureCoords[0] = pi[0];
+    figureColors[0] = ci[0];
+    figureCoords[splitXBy] = pi[3];
+    figureColors[splitXBy] = ci[1];
+    figureCoords[verticesPerRow * splitYBy] = pi[12];
+    figureColors[verticesPerRow * splitYBy] = ci[2];
+    figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
+    figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
+    mesh.figures[index] = {
+      type: "lattice",
+      coords: figureCoords,
+      colors: figureColors,
+      verticesPerRow
+    };
+  }
+
+  function decodeType6Shading(mesh, reader) {
+    var coords = mesh.coords;
+    var colors = mesh.colors;
+    var ps = new Int32Array(16);
+    var cs = new Int32Array(4);
+
+    while (reader.hasData) {
+      var f = reader.readFlag();
+
+      if (!(0 <= f && f <= 3)) {
+        throw new _util.FormatError("Unknown type6 flag");
+      }
+
+      var i, ii;
+      var pi = coords.length;
+
+      for (i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
+        coords.push(reader.readCoordinate());
+      }
+
+      var ci = colors.length;
+
+      for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+        colors.push(reader.readComponents());
+      }
+
+      var tmp1, tmp2, tmp3, tmp4;
+
+      switch (f) {
+        case 0:
+          ps[12] = pi + 3;
+          ps[13] = pi + 4;
+          ps[14] = pi + 5;
+          ps[15] = pi + 6;
+          ps[8] = pi + 2;
+          ps[11] = pi + 7;
+          ps[4] = pi + 1;
+          ps[7] = pi + 8;
+          ps[0] = pi;
+          ps[1] = pi + 11;
+          ps[2] = pi + 10;
+          ps[3] = pi + 9;
+          cs[2] = ci + 1;
+          cs[3] = ci + 2;
+          cs[0] = ci;
+          cs[1] = ci + 3;
+          break;
+
+        case 1:
+          tmp1 = ps[12];
+          tmp2 = ps[13];
+          tmp3 = ps[14];
+          tmp4 = ps[15];
+          ps[12] = tmp4;
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = tmp3;
+          ps[11] = pi + 3;
+          ps[4] = tmp2;
+          ps[7] = pi + 4;
+          ps[0] = tmp1;
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          tmp1 = cs[2];
+          tmp2 = cs[3];
+          cs[2] = tmp2;
+          cs[3] = ci;
+          cs[0] = tmp1;
+          cs[1] = ci + 1;
+          break;
+
+        case 2:
+          tmp1 = ps[15];
+          tmp2 = ps[11];
+          ps[12] = ps[3];
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = ps[7];
+          ps[11] = pi + 3;
+          ps[4] = tmp2;
+          ps[7] = pi + 4;
+          ps[0] = tmp1;
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          tmp1 = cs[3];
+          cs[2] = cs[1];
+          cs[3] = ci;
+          cs[0] = tmp1;
+          cs[1] = ci + 1;
+          break;
+
+        case 3:
+          ps[12] = ps[0];
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = ps[1];
+          ps[11] = pi + 3;
+          ps[4] = ps[2];
+          ps[7] = pi + 4;
+          ps[0] = ps[3];
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          cs[2] = cs[0];
+          cs[3] = ci;
+          cs[0] = cs[1];
+          cs[1] = ci + 1;
+          break;
+      }
+
+      ps[5] = coords.length;
+      coords.push([(-4 * coords[ps[0]][0] - coords[ps[15]][0] + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9, (-4 * coords[ps[0]][1] - coords[ps[15]][1] + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9]);
+      ps[6] = coords.length;
+      coords.push([(-4 * coords[ps[3]][0] - coords[ps[12]][0] + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9, (-4 * coords[ps[3]][1] - coords[ps[12]][1] + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9]);
+      ps[9] = coords.length;
+      coords.push([(-4 * coords[ps[12]][0] - coords[ps[3]][0] + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9, (-4 * coords[ps[12]][1] - coords[ps[3]][1] + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9]);
+      ps[10] = coords.length;
+      coords.push([(-4 * coords[ps[15]][0] - coords[ps[0]][0] + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9, (-4 * coords[ps[15]][1] - coords[ps[0]][1] + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9]);
+      mesh.figures.push({
+        type: "patch",
+        coords: new Int32Array(ps),
+        colors: new Int32Array(cs)
+      });
+    }
+  }
+
+  function decodeType7Shading(mesh, reader) {
+    var coords = mesh.coords;
+    var colors = mesh.colors;
+    var ps = new Int32Array(16);
+    var cs = new Int32Array(4);
+
+    while (reader.hasData) {
+      var f = reader.readFlag();
+
+      if (!(0 <= f && f <= 3)) {
+        throw new _util.FormatError("Unknown type7 flag");
+      }
+
+      var i, ii;
+      var pi = coords.length;
+
+      for (i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
+        coords.push(reader.readCoordinate());
+      }
+
+      var ci = colors.length;
+
+      for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+        colors.push(reader.readComponents());
+      }
+
+      var tmp1, tmp2, tmp3, tmp4;
+
+      switch (f) {
+        case 0:
+          ps[12] = pi + 3;
+          ps[13] = pi + 4;
+          ps[14] = pi + 5;
+          ps[15] = pi + 6;
+          ps[8] = pi + 2;
+          ps[9] = pi + 13;
+          ps[10] = pi + 14;
+          ps[11] = pi + 7;
+          ps[4] = pi + 1;
+          ps[5] = pi + 12;
+          ps[6] = pi + 15;
+          ps[7] = pi + 8;
+          ps[0] = pi;
+          ps[1] = pi + 11;
+          ps[2] = pi + 10;
+          ps[3] = pi + 9;
+          cs[2] = ci + 1;
+          cs[3] = ci + 2;
+          cs[0] = ci;
+          cs[1] = ci + 3;
+          break;
+
+        case 1:
+          tmp1 = ps[12];
+          tmp2 = ps[13];
+          tmp3 = ps[14];
+          tmp4 = ps[15];
+          ps[12] = tmp4;
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = tmp3;
+          ps[9] = pi + 9;
+          ps[10] = pi + 10;
+          ps[11] = pi + 3;
+          ps[4] = tmp2;
+          ps[5] = pi + 8;
+          ps[6] = pi + 11;
+          ps[7] = pi + 4;
+          ps[0] = tmp1;
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          tmp1 = cs[2];
+          tmp2 = cs[3];
+          cs[2] = tmp2;
+          cs[3] = ci;
+          cs[0] = tmp1;
+          cs[1] = ci + 1;
+          break;
+
+        case 2:
+          tmp1 = ps[15];
+          tmp2 = ps[11];
+          ps[12] = ps[3];
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = ps[7];
+          ps[9] = pi + 9;
+          ps[10] = pi + 10;
+          ps[11] = pi + 3;
+          ps[4] = tmp2;
+          ps[5] = pi + 8;
+          ps[6] = pi + 11;
+          ps[7] = pi + 4;
+          ps[0] = tmp1;
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          tmp1 = cs[3];
+          cs[2] = cs[1];
+          cs[3] = ci;
+          cs[0] = tmp1;
+          cs[1] = ci + 1;
+          break;
+
+        case 3:
+          ps[12] = ps[0];
+          ps[13] = pi + 0;
+          ps[14] = pi + 1;
+          ps[15] = pi + 2;
+          ps[8] = ps[1];
+          ps[9] = pi + 9;
+          ps[10] = pi + 10;
+          ps[11] = pi + 3;
+          ps[4] = ps[2];
+          ps[5] = pi + 8;
+          ps[6] = pi + 11;
+          ps[7] = pi + 4;
+          ps[0] = ps[3];
+          ps[1] = pi + 7;
+          ps[2] = pi + 6;
+          ps[3] = pi + 5;
+          cs[2] = cs[0];
+          cs[3] = ci;
+          cs[0] = cs[1];
+          cs[1] = ci + 1;
+          break;
+      }
+
+      mesh.figures.push({
+        type: "patch",
+        coords: new Int32Array(ps),
+        colors: new Int32Array(cs)
+      });
+    }
+  }
+
+  function updateBounds(mesh) {
+    var minX = mesh.coords[0][0],
+        minY = mesh.coords[0][1],
+        maxX = minX,
+        maxY = minY;
+
+    for (var i = 1, ii = mesh.coords.length; i < ii; i++) {
+      var x = mesh.coords[i][0],
+          y = mesh.coords[i][1];
+      minX = minX > x ? x : minX;
+      minY = minY > y ? y : minY;
+      maxX = maxX < x ? x : maxX;
+      maxY = maxY < y ? y : maxY;
+    }
+
+    mesh.bounds = [minX, minY, maxX, maxY];
+  }
+
+  function packData(mesh) {
+    var i, ii, j, jj;
+    var coords = mesh.coords;
+    var coordsPacked = new Float32Array(coords.length * 2);
+
+    for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
+      var xy = coords[i];
+      coordsPacked[j++] = xy[0];
+      coordsPacked[j++] = xy[1];
+    }
+
+    mesh.coords = coordsPacked;
+    var colors = mesh.colors;
+    var colorsPacked = new Uint8Array(colors.length * 3);
+
+    for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
+      var c = colors[i];
+      colorsPacked[j++] = c[0];
+      colorsPacked[j++] = c[1];
+      colorsPacked[j++] = c[2];
+    }
+
+    mesh.colors = colorsPacked;
+    var figures = mesh.figures;
+
+    for (i = 0, ii = figures.length; i < ii; i++) {
+      var figure = figures[i],
+          ps = figure.coords,
+          cs = figure.colors;
+
+      for (j = 0, jj = ps.length; j < jj; j++) {
+        ps[j] *= 2;
+        cs[j] *= 3;
+      }
+    }
+  }
+
+  function Mesh(stream, matrix, xref, resources, pdfFunctionFactory, localColorSpaceCache) {
+    if (!(0, _primitives.isStream)(stream)) {
+      throw new _util.FormatError("Mesh data is not a stream");
+    }
+
+    var dict = stream.dict;
+    this.matrix = matrix;
+    this.shadingType = dict.get("ShadingType");
+    this.type = "Pattern";
+    const bbox = dict.getArray("BBox");
+
+    if (Array.isArray(bbox) && bbox.length === 4) {
+      this.bbox = _util.Util.normalizeRect(bbox);
+    } else {
+      this.bbox = null;
+    }
+
+    const cs = _colorspace.ColorSpace.parse({
+      cs: dict.getRaw("ColorSpace") || dict.getRaw("CS"),
+      xref,
+      resources,
+      pdfFunctionFactory,
+      localColorSpaceCache
+    });
+
+    this.cs = cs;
+    this.background = dict.has("Background") ? cs.getRgb(dict.get("Background"), 0) : null;
+    var fnObj = dict.getRaw("Function");
+    var fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
+    this.coords = [];
+    this.colors = [];
+    this.figures = [];
+    var decodeContext = {
+      bitsPerCoordinate: dict.get("BitsPerCoordinate"),
+      bitsPerComponent: dict.get("BitsPerComponent"),
+      bitsPerFlag: dict.get("BitsPerFlag"),
+      decode: dict.getArray("Decode"),
+      colorFn: fn,
+      colorSpace: cs,
+      numComps: fn ? 1 : cs.numComps
+    };
+    var reader = new MeshStreamReader(stream, decodeContext);
+    var patchMesh = false;
+
+    switch (this.shadingType) {
+      case ShadingType.FREE_FORM_MESH:
+        decodeType4Shading(this, reader);
+        break;
+
+      case ShadingType.LATTICE_FORM_MESH:
+        var verticesPerRow = dict.get("VerticesPerRow") | 0;
+
+        if (verticesPerRow < 2) {
+          throw new _util.FormatError("Invalid VerticesPerRow");
+        }
+
+        decodeType5Shading(this, reader, verticesPerRow);
+        break;
+
+      case ShadingType.COONS_PATCH_MESH:
+        decodeType6Shading(this, reader);
+        patchMesh = true;
+        break;
+
+      case ShadingType.TENSOR_PATCH_MESH:
+        decodeType7Shading(this, reader);
+        patchMesh = true;
+        break;
+
+      default:
+        (0, _util.unreachable)("Unsupported mesh type.");
+        break;
+    }
+
+    if (patchMesh) {
+      updateBounds(this);
+
+      for (var i = 0, ii = this.figures.length; i < ii; i++) {
+        buildFigureFromPatch(this, i);
+      }
+    }
+
+    updateBounds(this);
+    packData(this);
+  }
+
+  Mesh.prototype = {
+    getIR: function Mesh_getIR() {
+      return ["Mesh", this.shadingType, this.coords, this.colors, this.figures, this.bounds, this.matrix, this.bbox, this.background];
+    }
+  };
+  return Mesh;
+}();
+
+Shadings.Dummy = function DummyClosure() {
+  function Dummy() {
+    this.type = "Pattern";
+  }
+
+  Dummy.prototype = {
+    getIR: function Dummy_getIR() {
+      return ["Dummy"];
+    }
+  };
+  return Dummy;
+}();
+
+function getTilingPatternIR(operatorList, dict, color) {
+  const matrix = dict.getArray("Matrix");
+
+  const bbox = _util.Util.normalizeRect(dict.getArray("BBox"));
+
+  const xstep = dict.get("XStep");
+  const ystep = dict.get("YStep");
+  const paintType = dict.get("PaintType");
+  const tilingType = dict.get("TilingType");
+
+  if (bbox[2] - bbox[0] === 0 || bbox[3] - bbox[1] === 0) {
+    throw new _util.FormatError(`Invalid getTilingPatternIR /BBox array: [${bbox}].`);
+  }
+
+  return ["TilingPattern", color, operatorList, matrix, bbox, xstep, ystep, paintType, tilingType];
+}
+
+/***/ }),
+/* 41 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.isPDFFunction = isPDFFunction;
+exports.PostScriptEvaluator = exports.PostScriptCompiler = exports.PDFFunctionFactory = void 0;
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _util = __w_pdfjs_require__(2);
+
+var _ps_parser = __w_pdfjs_require__(42);
+
+var _image_utils = __w_pdfjs_require__(24);
+
+class PDFFunctionFactory {
+  constructor({
+    xref,
+    isEvalSupported = true
+  }) {
+    this.xref = xref;
+    this.isEvalSupported = isEvalSupported !== false;
+    this._localFunctionCache = null;
+  }
+
+  create(fn) {
+    const cachedFunction = this.getCached(fn);
+
+    if (cachedFunction) {
+      return cachedFunction;
+    }
+
+    const parsedFunction = PDFFunction.parse({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      fn: fn instanceof _primitives.Ref ? this.xref.fetch(fn) : fn
+    });
+
+    this._cache(fn, parsedFunction);
+
+    return parsedFunction;
+  }
+
+  createFromArray(fnObj) {
+    const cachedFunction = this.getCached(fnObj);
+
+    if (cachedFunction) {
+      return cachedFunction;
+    }
+
+    const parsedFunction = PDFFunction.parseArray({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      fnObj: fnObj instanceof _primitives.Ref ? this.xref.fetch(fnObj) : fnObj
+    });
+
+    this._cache(fnObj, parsedFunction);
+
+    return parsedFunction;
+  }
+
+  getCached(cacheKey) {
+    let fnRef;
+
+    if (cacheKey instanceof _primitives.Ref) {
+      fnRef = cacheKey;
+    } else if (cacheKey instanceof _primitives.Dict) {
+      fnRef = cacheKey.objId;
+    } else if ((0, _primitives.isStream)(cacheKey)) {
+      fnRef = cacheKey.dict && cacheKey.dict.objId;
+    }
+
+    if (fnRef) {
+      if (!this._localFunctionCache) {
+        this._localFunctionCache = new _image_utils.LocalFunctionCache();
+      }
+
+      const localFunction = this._localFunctionCache.getByRef(fnRef);
+
+      if (localFunction) {
+        return localFunction;
+      }
+    }
+
+    return null;
+  }
+
+  _cache(cacheKey, parsedFunction) {
+    if (!parsedFunction) {
+      throw new Error('PDFFunctionFactory._cache - expected "parsedFunction" argument.');
+    }
+
+    let fnRef;
+
+    if (cacheKey instanceof _primitives.Ref) {
+      fnRef = cacheKey;
+    } else if (cacheKey instanceof _primitives.Dict) {
+      fnRef = cacheKey.objId;
+    } else if ((0, _primitives.isStream)(cacheKey)) {
+      fnRef = cacheKey.dict && cacheKey.dict.objId;
+    }
+
+    if (fnRef) {
+      if (!this._localFunctionCache) {
+        this._localFunctionCache = new _image_utils.LocalFunctionCache();
+      }
+
+      this._localFunctionCache.set(null, fnRef, parsedFunction);
+    }
+  }
+
+}
+
+exports.PDFFunctionFactory = PDFFunctionFactory;
+
+function toNumberArray(arr) {
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+
+  const length = arr.length;
+
+  for (let i = 0; i < length; i++) {
+    if (typeof arr[i] !== "number") {
+      const result = new Array(length);
+
+      for (let j = 0; j < length; j++) {
+        result[j] = +arr[j];
+      }
+
+      return result;
+    }
+  }
+
+  return arr;
+}
+
+var PDFFunction = function PDFFunctionClosure() {
+  const CONSTRUCT_SAMPLED = 0;
+  const CONSTRUCT_INTERPOLATED = 2;
+  const CONSTRUCT_STICHED = 3;
+  const CONSTRUCT_POSTSCRIPT = 4;
+  return {
+    getSampleArray(size, outputSize, bps, stream) {
+      var i, ii;
+      var length = 1;
+
+      for (i = 0, ii = size.length; i < ii; i++) {
+        length *= size[i];
+      }
+
+      length *= outputSize;
+      var array = new Array(length);
+      var codeSize = 0;
+      var codeBuf = 0;
+      var sampleMul = 1.0 / (2.0 ** bps - 1);
+      var strBytes = stream.getBytes((length * bps + 7) / 8);
+      var strIdx = 0;
+
+      for (i = 0; i < length; i++) {
+        while (codeSize < bps) {
+          codeBuf <<= 8;
+          codeBuf |= strBytes[strIdx++];
+          codeSize += 8;
+        }
+
+        codeSize -= bps;
+        array[i] = (codeBuf >> codeSize) * sampleMul;
+        codeBuf &= (1 << codeSize) - 1;
+      }
+
+      return array;
+    },
+
+    getIR({
+      xref,
+      isEvalSupported,
+      fn
+    }) {
+      var dict = fn.dict;
+
+      if (!dict) {
+        dict = fn;
+      }
+
+      var types = [this.constructSampled, null, this.constructInterpolated, this.constructStiched, this.constructPostScript];
+      var typeNum = dict.get("FunctionType");
+      var typeFn = types[typeNum];
+
+      if (!typeFn) {
+        throw new _util.FormatError("Unknown type of function");
+      }
+
+      return typeFn.call(this, {
+        xref,
+        isEvalSupported,
+        fn,
+        dict
+      });
+    },
+
+    fromIR({
+      xref,
+      isEvalSupported,
+      IR
+    }) {
+      var type = IR[0];
+
+      switch (type) {
+        case CONSTRUCT_SAMPLED:
+          return this.constructSampledFromIR({
+            xref,
+            isEvalSupported,
+            IR
+          });
+
+        case CONSTRUCT_INTERPOLATED:
+          return this.constructInterpolatedFromIR({
+            xref,
+            isEvalSupported,
+            IR
+          });
+
+        case CONSTRUCT_STICHED:
+          return this.constructStichedFromIR({
+            xref,
+            isEvalSupported,
+            IR
+          });
+
+        default:
+          return this.constructPostScriptFromIR({
+            xref,
+            isEvalSupported,
+            IR
+          });
+      }
+    },
+
+    parse({
+      xref,
+      isEvalSupported,
+      fn
+    }) {
+      const IR = this.getIR({
+        xref,
+        isEvalSupported,
+        fn
+      });
+      return this.fromIR({
+        xref,
+        isEvalSupported,
+        IR
+      });
+    },
+
+    parseArray({
+      xref,
+      isEvalSupported,
+      fnObj
+    }) {
+      if (!Array.isArray(fnObj)) {
+        return this.parse({
+          xref,
+          isEvalSupported,
+          fn: fnObj
+        });
+      }
+
+      var fnArray = [];
+
+      for (var j = 0, jj = fnObj.length; j < jj; j++) {
+        fnArray.push(this.parse({
+          xref,
+          isEvalSupported,
+          fn: xref.fetchIfRef(fnObj[j])
+        }));
+      }
+
+      return function (src, srcOffset, dest, destOffset) {
+        for (var i = 0, ii = fnArray.length; i < ii; i++) {
+          fnArray[i](src, srcOffset, dest, destOffset + i);
+        }
+      };
+    },
+
+    constructSampled({
+      xref,
+      isEvalSupported,
+      fn,
+      dict
+    }) {
+      function toMultiArray(arr) {
+        var inputLength = arr.length;
+        var out = [];
+        var index = 0;
+
+        for (var i = 0; i < inputLength; i += 2) {
+          out[index] = [arr[i], arr[i + 1]];
+          ++index;
+        }
+
+        return out;
+      }
+
+      var domain = toNumberArray(dict.getArray("Domain"));
+      var range = toNumberArray(dict.getArray("Range"));
+
+      if (!domain || !range) {
+        throw new _util.FormatError("No domain or range");
+      }
+
+      var inputSize = domain.length / 2;
+      var outputSize = range.length / 2;
+      domain = toMultiArray(domain);
+      range = toMultiArray(range);
+      var size = toNumberArray(dict.getArray("Size"));
+      var bps = dict.get("BitsPerSample");
+      var order = dict.get("Order") || 1;
+
+      if (order !== 1) {
+        (0, _util.info)("No support for cubic spline interpolation: " + order);
+      }
+
+      var encode = toNumberArray(dict.getArray("Encode"));
+
+      if (!encode) {
+        encode = [];
+
+        for (var i = 0; i < inputSize; ++i) {
+          encode.push([0, size[i] - 1]);
+        }
+      } else {
+        encode = toMultiArray(encode);
+      }
+
+      var decode = toNumberArray(dict.getArray("Decode"));
+
+      if (!decode) {
+        decode = range;
+      } else {
+        decode = toMultiArray(decode);
+      }
+
+      var samples = this.getSampleArray(size, outputSize, bps, fn);
+      return [CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size, outputSize, 2 ** bps - 1, range];
+    },
+
+    constructSampledFromIR({
+      xref,
+      isEvalSupported,
+      IR
+    }) {
+      function interpolate(x, xmin, xmax, ymin, ymax) {
+        return ymin + (x - xmin) * ((ymax - ymin) / (xmax - xmin));
+      }
+
+      return function constructSampledFromIRResult(src, srcOffset, dest, destOffset) {
+        var m = IR[1];
+        var domain = IR[2];
+        var encode = IR[3];
+        var decode = IR[4];
+        var samples = IR[5];
+        var size = IR[6];
+        var n = IR[7];
+        var range = IR[9];
+        var cubeVertices = 1 << m;
+        var cubeN = new Float64Array(cubeVertices);
+        var cubeVertex = new Uint32Array(cubeVertices);
+        var i, j;
+
+        for (j = 0; j < cubeVertices; j++) {
+          cubeN[j] = 1;
+        }
+
+        var k = n,
+            pos = 1;
+
+        for (i = 0; i < m; ++i) {
+          var domain_2i = domain[i][0];
+          var domain_2i_1 = domain[i][1];
+          var xi = Math.min(Math.max(src[srcOffset + i], domain_2i), domain_2i_1);
+          var e = interpolate(xi, domain_2i, domain_2i_1, encode[i][0], encode[i][1]);
+          var size_i = size[i];
+          e = Math.min(Math.max(e, 0), size_i - 1);
+          var e0 = e < size_i - 1 ? Math.floor(e) : e - 1;
+          var n0 = e0 + 1 - e;
+          var n1 = e - e0;
+          var offset0 = e0 * k;
+          var offset1 = offset0 + k;
+
+          for (j = 0; j < cubeVertices; j++) {
+            if (j & pos) {
+              cubeN[j] *= n1;
+              cubeVertex[j] += offset1;
+            } else {
+              cubeN[j] *= n0;
+              cubeVertex[j] += offset0;
+            }
+          }
+
+          k *= size_i;
+          pos <<= 1;
+        }
+
+        for (j = 0; j < n; ++j) {
+          var rj = 0;
+
+          for (i = 0; i < cubeVertices; i++) {
+            rj += samples[cubeVertex[i] + j] * cubeN[i];
+          }
+
+          rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
+          dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
+        }
+      };
+    },
+
+    constructInterpolated({
+      xref,
+      isEvalSupported,
+      fn,
+      dict
+    }) {
+      var c0 = toNumberArray(dict.getArray("C0")) || [0];
+      var c1 = toNumberArray(dict.getArray("C1")) || [1];
+      var n = dict.get("N");
+      var length = c0.length;
+      var diff = [];
+
+      for (var i = 0; i < length; ++i) {
+        diff.push(c1[i] - c0[i]);
+      }
+
+      return [CONSTRUCT_INTERPOLATED, c0, diff, n];
+    },
+
+    constructInterpolatedFromIR({
+      xref,
+      isEvalSupported,
+      IR
+    }) {
+      var c0 = IR[1];
+      var diff = IR[2];
+      var n = IR[3];
+      var length = diff.length;
+      return function constructInterpolatedFromIRResult(src, srcOffset, dest, destOffset) {
+        var x = n === 1 ? src[srcOffset] : src[srcOffset] ** n;
+
+        for (var j = 0; j < length; ++j) {
+          dest[destOffset + j] = c0[j] + x * diff[j];
+        }
+      };
+    },
+
+    constructStiched({
+      xref,
+      isEvalSupported,
+      fn,
+      dict
+    }) {
+      var domain = toNumberArray(dict.getArray("Domain"));
+
+      if (!domain) {
+        throw new _util.FormatError("No domain");
+      }
+
+      var inputSize = domain.length / 2;
+
+      if (inputSize !== 1) {
+        throw new _util.FormatError("Bad domain for stiched function");
+      }
+
+      var fnRefs = dict.get("Functions");
+      var fns = [];
+
+      for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
+        fns.push(this.parse({
+          xref,
+          isEvalSupported,
+          fn: xref.fetchIfRef(fnRefs[i])
+        }));
+      }
+
+      var bounds = toNumberArray(dict.getArray("Bounds"));
+      var encode = toNumberArray(dict.getArray("Encode"));
+      return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
+    },
+
+    constructStichedFromIR({
+      xref,
+      isEvalSupported,
+      IR
+    }) {
+      var domain = IR[1];
+      var bounds = IR[2];
+      var encode = IR[3];
+      var fns = IR[4];
+      var tmpBuf = new Float32Array(1);
+      return function constructStichedFromIRResult(src, srcOffset, dest, destOffset) {
+        var clip = function constructStichedFromIRClip(v, min, max) {
+          if (v > max) {
+            v = max;
+          } else if (v < min) {
+            v = min;
+          }
+
+          return v;
+        };
+
+        var v = clip(src[srcOffset], domain[0], domain[1]);
+
+        for (var i = 0, ii = bounds.length; i < ii; ++i) {
+          if (v < bounds[i]) {
+            break;
+          }
+        }
+
+        var dmin = domain[0];
+
+        if (i > 0) {
+          dmin = bounds[i - 1];
+        }
+
+        var dmax = domain[1];
+
+        if (i < bounds.length) {
+          dmax = bounds[i];
+        }
+
+        var rmin = encode[2 * i];
+        var rmax = encode[2 * i + 1];
+        tmpBuf[0] = dmin === dmax ? rmin : rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);
+        fns[i](tmpBuf, 0, dest, destOffset);
+      };
+    },
+
+    constructPostScript({
+      xref,
+      isEvalSupported,
+      fn,
+      dict
+    }) {
+      var domain = toNumberArray(dict.getArray("Domain"));
+      var range = toNumberArray(dict.getArray("Range"));
+
+      if (!domain) {
+        throw new _util.FormatError("No domain.");
+      }
+
+      if (!range) {
+        throw new _util.FormatError("No range.");
+      }
+
+      var lexer = new _ps_parser.PostScriptLexer(fn);
+      var parser = new _ps_parser.PostScriptParser(lexer);
+      var code = parser.parse();
+      return [CONSTRUCT_POSTSCRIPT, domain, range, code];
+    },
+
+    constructPostScriptFromIR({
+      xref,
+      isEvalSupported,
+      IR
+    }) {
+      var domain = IR[1];
+      var range = IR[2];
+      var code = IR[3];
+
+      if (isEvalSupported && _util.IsEvalSupportedCached.value) {
+        const compiled = new PostScriptCompiler().compile(code, domain, range);
+
+        if (compiled) {
+          return new Function("src", "srcOffset", "dest", "destOffset", compiled);
+        }
+      }
+
+      (0, _util.info)("Unable to compile PS function");
+      var numOutputs = range.length >> 1;
+      var numInputs = domain.length >> 1;
+      var evaluator = new PostScriptEvaluator(code);
+      var cache = Object.create(null);
+      var MAX_CACHE_SIZE = 2048 * 4;
+      var cache_available = MAX_CACHE_SIZE;
+      var tmpBuf = new Float32Array(numInputs);
+      return function constructPostScriptFromIRResult(src, srcOffset, dest, destOffset) {
+        var i, value;
+        var key = "";
+        var input = tmpBuf;
+
+        for (i = 0; i < numInputs; i++) {
+          value = src[srcOffset + i];
+          input[i] = value;
+          key += value + "_";
+        }
+
+        var cachedValue = cache[key];
+
+        if (cachedValue !== undefined) {
+          dest.set(cachedValue, destOffset);
+          return;
+        }
+
+        var output = new Float32Array(numOutputs);
+        var stack = evaluator.execute(input);
+        var stackIndex = stack.length - numOutputs;
+
+        for (i = 0; i < numOutputs; i++) {
+          value = stack[stackIndex + i];
+          var bound = range[i * 2];
+
+          if (value < bound) {
+            value = bound;
+          } else {
+            bound = range[i * 2 + 1];
+
+            if (value > bound) {
+              value = bound;
+            }
+          }
+
+          output[i] = value;
+        }
+
+        if (cache_available > 0) {
+          cache_available--;
+          cache[key] = output;
+        }
+
+        dest.set(output, destOffset);
+      };
+    }
+
+  };
+}();
+
+function isPDFFunction(v) {
+  var fnDict;
+
+  if (typeof v !== "object") {
+    return false;
+  } else if ((0, _primitives.isDict)(v)) {
+    fnDict = v;
+  } else if ((0, _primitives.isStream)(v)) {
+    fnDict = v.dict;
+  } else {
+    return false;
+  }
+
+  return fnDict.has("FunctionType");
+}
+
+var PostScriptStack = function PostScriptStackClosure() {
+  var MAX_STACK_SIZE = 100;
+
+  function PostScriptStack(initialStack) {
+    this.stack = !initialStack ? [] : Array.prototype.slice.call(initialStack, 0);
+  }
+
+  PostScriptStack.prototype = {
+    push: function PostScriptStack_push(value) {
+      if (this.stack.length >= MAX_STACK_SIZE) {
+        throw new Error("PostScript function stack overflow.");
+      }
+
+      this.stack.push(value);
+    },
+    pop: function PostScriptStack_pop() {
+      if (this.stack.length <= 0) {
+        throw new Error("PostScript function stack underflow.");
+      }
+
+      return this.stack.pop();
+    },
+    copy: function PostScriptStack_copy(n) {
+      if (this.stack.length + n >= MAX_STACK_SIZE) {
+        throw new Error("PostScript function stack overflow.");
+      }
+
+      var stack = this.stack;
+
+      for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
+        stack.push(stack[i]);
+      }
+    },
+    index: function PostScriptStack_index(n) {
+      this.push(this.stack[this.stack.length - n - 1]);
+    },
+    roll: function PostScriptStack_roll(n, p) {
+      var stack = this.stack;
+      var l = stack.length - n;
+      var r = stack.length - 1,
+          c = l + (p - Math.floor(p / n) * n),
+          i,
+          j,
+          t;
+
+      for (i = l, j = r; i < j; i++, j--) {
+        t = stack[i];
+        stack[i] = stack[j];
+        stack[j] = t;
+      }
+
+      for (i = l, j = c - 1; i < j; i++, j--) {
+        t = stack[i];
+        stack[i] = stack[j];
+        stack[j] = t;
+      }
+
+      for (i = c, j = r; i < j; i++, j--) {
+        t = stack[i];
+        stack[i] = stack[j];
+        stack[j] = t;
+      }
+    }
+  };
+  return PostScriptStack;
+}();
+
+var PostScriptEvaluator = function PostScriptEvaluatorClosure() {
+  function PostScriptEvaluator(operators) {
+    this.operators = operators;
+  }
+
+  PostScriptEvaluator.prototype = {
+    execute: function PostScriptEvaluator_execute(initialStack) {
+      var stack = new PostScriptStack(initialStack);
+      var counter = 0;
+      var operators = this.operators;
+      var length = operators.length;
+      var operator, a, b;
+
+      while (counter < length) {
+        operator = operators[counter++];
+
+        if (typeof operator === "number") {
+          stack.push(operator);
+          continue;
+        }
+
+        switch (operator) {
+          case "jz":
+            b = stack.pop();
+            a = stack.pop();
+
+            if (!a) {
+              counter = b;
+            }
+
+            break;
+
+          case "j":
+            a = stack.pop();
+            counter = a;
+            break;
+
+          case "abs":
+            a = stack.pop();
+            stack.push(Math.abs(a));
+            break;
+
+          case "add":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a + b);
+            break;
+
+          case "and":
+            b = stack.pop();
+            a = stack.pop();
+
+            if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
+              stack.push(a && b);
+            } else {
+              stack.push(a & b);
+            }
+
+            break;
+
+          case "atan":
+            a = stack.pop();
+            stack.push(Math.atan(a));
+            break;
+
+          case "bitshift":
+            b = stack.pop();
+            a = stack.pop();
+
+            if (a > 0) {
+              stack.push(a << b);
+            } else {
+              stack.push(a >> b);
+            }
+
+            break;
+
+          case "ceiling":
+            a = stack.pop();
+            stack.push(Math.ceil(a));
+            break;
+
+          case "copy":
+            a = stack.pop();
+            stack.copy(a);
+            break;
+
+          case "cos":
+            a = stack.pop();
+            stack.push(Math.cos(a));
+            break;
+
+          case "cvi":
+            a = stack.pop() | 0;
+            stack.push(a);
+            break;
+
+          case "cvr":
+            break;
+
+          case "div":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a / b);
+            break;
+
+          case "dup":
+            stack.copy(1);
+            break;
+
+          case "eq":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a === b);
+            break;
+
+          case "exch":
+            stack.roll(2, 1);
+            break;
+
+          case "exp":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a ** b);
+            break;
+
+          case "false":
+            stack.push(false);
+            break;
+
+          case "floor":
+            a = stack.pop();
+            stack.push(Math.floor(a));
+            break;
+
+          case "ge":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a >= b);
+            break;
+
+          case "gt":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a > b);
+            break;
+
+          case "idiv":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a / b | 0);
+            break;
+
+          case "index":
+            a = stack.pop();
+            stack.index(a);
+            break;
+
+          case "le":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a <= b);
+            break;
+
+          case "ln":
+            a = stack.pop();
+            stack.push(Math.log(a));
+            break;
+
+          case "log":
+            a = stack.pop();
+            stack.push(Math.log(a) / Math.LN10);
+            break;
+
+          case "lt":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a < b);
+            break;
+
+          case "mod":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a % b);
+            break;
+
+          case "mul":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a * b);
+            break;
+
+          case "ne":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a !== b);
+            break;
+
+          case "neg":
+            a = stack.pop();
+            stack.push(-a);
+            break;
+
+          case "not":
+            a = stack.pop();
+
+            if ((0, _util.isBool)(a)) {
+              stack.push(!a);
+            } else {
+              stack.push(~a);
+            }
+
+            break;
+
+          case "or":
+            b = stack.pop();
+            a = stack.pop();
+
+            if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
+              stack.push(a || b);
+            } else {
+              stack.push(a | b);
+            }
+
+            break;
+
+          case "pop":
+            stack.pop();
+            break;
+
+          case "roll":
+            b = stack.pop();
+            a = stack.pop();
+            stack.roll(a, b);
+            break;
+
+          case "round":
+            a = stack.pop();
+            stack.push(Math.round(a));
+            break;
+
+          case "sin":
+            a = stack.pop();
+            stack.push(Math.sin(a));
+            break;
+
+          case "sqrt":
+            a = stack.pop();
+            stack.push(Math.sqrt(a));
+            break;
+
+          case "sub":
+            b = stack.pop();
+            a = stack.pop();
+            stack.push(a - b);
+            break;
+
+          case "true":
+            stack.push(true);
+            break;
+
+          case "truncate":
+            a = stack.pop();
+            a = a < 0 ? Math.ceil(a) : Math.floor(a);
+            stack.push(a);
+            break;
+
+          case "xor":
+            b = stack.pop();
+            a = stack.pop();
+
+            if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
+              stack.push(a !== b);
+            } else {
+              stack.push(a ^ b);
+            }
+
+            break;
+
+          default:
+            throw new _util.FormatError(`Unknown operator ${operator}`);
+        }
+      }
+
+      return stack.stack;
+    }
+  };
+  return PostScriptEvaluator;
+}();
+
+exports.PostScriptEvaluator = PostScriptEvaluator;
+
+var PostScriptCompiler = function PostScriptCompilerClosure() {
+  function AstNode(type) {
+    this.type = type;
+  }
+
+  AstNode.prototype.visit = function (visitor) {
+    (0, _util.unreachable)("abstract method");
+  };
+
+  function AstArgument(index, min, max) {
+    AstNode.call(this, "args");
+    this.index = index;
+    this.min = min;
+    this.max = max;
+  }
+
+  AstArgument.prototype = Object.create(AstNode.prototype);
+
+  AstArgument.prototype.visit = function (visitor) {
+    visitor.visitArgument(this);
+  };
+
+  function AstLiteral(number) {
+    AstNode.call(this, "literal");
+    this.number = number;
+    this.min = number;
+    this.max = number;
+  }
+
+  AstLiteral.prototype = Object.create(AstNode.prototype);
+
+  AstLiteral.prototype.visit = function (visitor) {
+    visitor.visitLiteral(this);
+  };
+
+  function AstBinaryOperation(op, arg1, arg2, min, max) {
+    AstNode.call(this, "binary");
+    this.op = op;
+    this.arg1 = arg1;
+    this.arg2 = arg2;
+    this.min = min;
+    this.max = max;
+  }
+
+  AstBinaryOperation.prototype = Object.create(AstNode.prototype);
+
+  AstBinaryOperation.prototype.visit = function (visitor) {
+    visitor.visitBinaryOperation(this);
+  };
+
+  function AstMin(arg, max) {
+    AstNode.call(this, "max");
+    this.arg = arg;
+    this.min = arg.min;
+    this.max = max;
+  }
+
+  AstMin.prototype = Object.create(AstNode.prototype);
+
+  AstMin.prototype.visit = function (visitor) {
+    visitor.visitMin(this);
+  };
+
+  function AstVariable(index, min, max) {
+    AstNode.call(this, "var");
+    this.index = index;
+    this.min = min;
+    this.max = max;
+  }
+
+  AstVariable.prototype = Object.create(AstNode.prototype);
+
+  AstVariable.prototype.visit = function (visitor) {
+    visitor.visitVariable(this);
+  };
+
+  function AstVariableDefinition(variable, arg) {
+    AstNode.call(this, "definition");
+    this.variable = variable;
+    this.arg = arg;
+  }
+
+  AstVariableDefinition.prototype = Object.create(AstNode.prototype);
+
+  AstVariableDefinition.prototype.visit = function (visitor) {
+    visitor.visitVariableDefinition(this);
+  };
+
+  function ExpressionBuilderVisitor() {
+    this.parts = [];
+  }
+
+  ExpressionBuilderVisitor.prototype = {
+    visitArgument(arg) {
+      this.parts.push("Math.max(", arg.min, ", Math.min(", arg.max, ", src[srcOffset + ", arg.index, "]))");
+    },
+
+    visitVariable(variable) {
+      this.parts.push("v", variable.index);
+    },
+
+    visitLiteral(literal) {
+      this.parts.push(literal.number);
+    },
+
+    visitBinaryOperation(operation) {
+      this.parts.push("(");
+      operation.arg1.visit(this);
+      this.parts.push(" ", operation.op, " ");
+      operation.arg2.visit(this);
+      this.parts.push(")");
+    },
+
+    visitVariableDefinition(definition) {
+      this.parts.push("var ");
+      definition.variable.visit(this);
+      this.parts.push(" = ");
+      definition.arg.visit(this);
+      this.parts.push(";");
+    },
+
+    visitMin(max) {
+      this.parts.push("Math.min(");
+      max.arg.visit(this);
+      this.parts.push(", ", max.max, ")");
+    },
+
+    toString() {
+      return this.parts.join("");
+    }
+
+  };
+
+  function buildAddOperation(num1, num2) {
+    if (num2.type === "literal" && num2.number === 0) {
+      return num1;
+    }
+
+    if (num1.type === "literal" && num1.number === 0) {
+      return num2;
+    }
+
+    if (num2.type === "literal" && num1.type === "literal") {
+      return new AstLiteral(num1.number + num2.number);
+    }
+
+    return new AstBinaryOperation("+", num1, num2, num1.min + num2.min, num1.max + num2.max);
+  }
+
+  function buildMulOperation(num1, num2) {
+    if (num2.type === "literal") {
+      if (num2.number === 0) {
+        return new AstLiteral(0);
+      } else if (num2.number === 1) {
+        return num1;
+      } else if (num1.type === "literal") {
+        return new AstLiteral(num1.number * num2.number);
+      }
+    }
+
+    if (num1.type === "literal") {
+      if (num1.number === 0) {
+        return new AstLiteral(0);
+      } else if (num1.number === 1) {
+        return num2;
+      }
+    }
+
+    var min = Math.min(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
+    var max = Math.max(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
+    return new AstBinaryOperation("*", num1, num2, min, max);
+  }
+
+  function buildSubOperation(num1, num2) {
+    if (num2.type === "literal") {
+      if (num2.number === 0) {
+        return num1;
+      } else if (num1.type === "literal") {
+        return new AstLiteral(num1.number - num2.number);
+      }
+    }
+
+    if (num2.type === "binary" && num2.op === "-" && num1.type === "literal" && num1.number === 1 && num2.arg1.type === "literal" && num2.arg1.number === 1) {
+      return num2.arg2;
+    }
+
+    return new AstBinaryOperation("-", num1, num2, num1.min - num2.max, num1.max - num2.min);
+  }
+
+  function buildMinOperation(num1, max) {
+    if (num1.min >= max) {
+      return new AstLiteral(max);
+    } else if (num1.max <= max) {
+      return num1;
+    }
+
+    return new AstMin(num1, max);
+  }
+
+  function PostScriptCompiler() {}
+
+  PostScriptCompiler.prototype = {
+    compile: function PostScriptCompiler_compile(code, domain, range) {
+      var stack = [];
+      var instructions = [];
+      var inputSize = domain.length >> 1,
+          outputSize = range.length >> 1;
+      var lastRegister = 0;
+      var n, j;
+      var num1, num2, ast1, ast2, tmpVar, item;
+
+      for (let i = 0; i < inputSize; i++) {
+        stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
+      }
+
+      for (let i = 0, ii = code.length; i < ii; i++) {
+        item = code[i];
+
+        if (typeof item === "number") {
+          stack.push(new AstLiteral(item));
+          continue;
+        }
+
+        switch (item) {
+          case "add":
+            if (stack.length < 2) {
+              return null;
+            }
+
+            num2 = stack.pop();
+            num1 = stack.pop();
+            stack.push(buildAddOperation(num1, num2));
+            break;
+
+          case "cvr":
+            if (stack.length < 1) {
+              return null;
+            }
+
+            break;
+
+          case "mul":
+            if (stack.length < 2) {
+              return null;
+            }
+
+            num2 = stack.pop();
+            num1 = stack.pop();
+            stack.push(buildMulOperation(num1, num2));
+            break;
+
+          case "sub":
+            if (stack.length < 2) {
+              return null;
+            }
+
+            num2 = stack.pop();
+            num1 = stack.pop();
+            stack.push(buildSubOperation(num1, num2));
+            break;
+
+          case "exch":
+            if (stack.length < 2) {
+              return null;
+            }
+
+            ast1 = stack.pop();
+            ast2 = stack.pop();
+            stack.push(ast1, ast2);
+            break;
+
+          case "pop":
+            if (stack.length < 1) {
+              return null;
+            }
+
+            stack.pop();
+            break;
+
+          case "index":
+            if (stack.length < 1) {
+              return null;
+            }
+
+            num1 = stack.pop();
+
+            if (num1.type !== "literal") {
+              return null;
+            }
+
+            n = num1.number;
+
+            if (n < 0 || !Number.isInteger(n) || stack.length < n) {
+              return null;
+            }
+
+            ast1 = stack[stack.length - n - 1];
+
+            if (ast1.type === "literal" || ast1.type === "var") {
+              stack.push(ast1);
+              break;
+            }
+
+            tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
+            stack[stack.length - n - 1] = tmpVar;
+            stack.push(tmpVar);
+            instructions.push(new AstVariableDefinition(tmpVar, ast1));
+            break;
+
+          case "dup":
+            if (stack.length < 1) {
+              return null;
+            }
+
+            if (typeof code[i + 1] === "number" && code[i + 2] === "gt" && code[i + 3] === i + 7 && code[i + 4] === "jz" && code[i + 5] === "pop" && code[i + 6] === code[i + 1]) {
+              num1 = stack.pop();
+              stack.push(buildMinOperation(num1, code[i + 1]));
+              i += 6;
+              break;
+            }
+
+            ast1 = stack[stack.length - 1];
+
+            if (ast1.type === "literal" || ast1.type === "var") {
+              stack.push(ast1);
+              break;
+            }
+
+            tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
+            stack[stack.length - 1] = tmpVar;
+            stack.push(tmpVar);
+            instructions.push(new AstVariableDefinition(tmpVar, ast1));
+            break;
+
+          case "roll":
+            if (stack.length < 2) {
+              return null;
+            }
+
+            num2 = stack.pop();
+            num1 = stack.pop();
+
+            if (num2.type !== "literal" || num1.type !== "literal") {
+              return null;
+            }
+
+            j = num2.number;
+            n = num1.number;
+
+            if (n <= 0 || !Number.isInteger(n) || !Number.isInteger(j) || stack.length < n) {
+              return null;
+            }
+
+            j = (j % n + n) % n;
+
+            if (j === 0) {
+              break;
+            }
+
+            Array.prototype.push.apply(stack, stack.splice(stack.length - n, n - j));
+            break;
+
+          default:
+            return null;
+        }
+      }
+
+      if (stack.length !== outputSize) {
+        return null;
+      }
+
+      var result = [];
+      instructions.forEach(function (instruction) {
+        var statementBuilder = new ExpressionBuilderVisitor();
+        instruction.visit(statementBuilder);
+        result.push(statementBuilder.toString());
+      });
+      stack.forEach(function (expr, i) {
+        var statementBuilder = new ExpressionBuilderVisitor();
+        expr.visit(statementBuilder);
+        var min = range[i * 2],
+            max = range[i * 2 + 1];
+        var out = [statementBuilder.toString()];
+
+        if (min > expr.min) {
+          out.unshift("Math.max(", min, ", ");
+          out.push(")");
+        }
+
+        if (max < expr.max) {
+          out.unshift("Math.min(", max, ", ");
+          out.push(")");
+        }
+
+        out.unshift("dest[destOffset + ", i, "] = ");
+        out.push(";");
+        result.push(out.join(""));
+      });
+      return result.join("\n");
+    }
+  };
+  return PostScriptCompiler;
+}();
+
+exports.PostScriptCompiler = PostScriptCompiler;
+
+/***/ }),
+/* 42 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PostScriptParser = exports.PostScriptLexer = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _core_utils = __w_pdfjs_require__(8);
+
+class PostScriptParser {
+  constructor(lexer) {
+    this.lexer = lexer;
+    this.operators = [];
+    this.token = null;
+    this.prev = null;
+  }
+
+  nextToken() {
+    this.prev = this.token;
+    this.token = this.lexer.getToken();
+  }
+
+  accept(type) {
+    if (this.token.type === type) {
+      this.nextToken();
+      return true;
+    }
+
+    return false;
+  }
+
+  expect(type) {
+    if (this.accept(type)) {
+      return true;
+    }
+
+    throw new _util.FormatError(`Unexpected symbol: found ${this.token.type} expected ${type}.`);
+  }
+
+  parse() {
+    this.nextToken();
+    this.expect(PostScriptTokenTypes.LBRACE);
+    this.parseBlock();
+    this.expect(PostScriptTokenTypes.RBRACE);
+    return this.operators;
+  }
+
+  parseBlock() {
+    while (true) {
+      if (this.accept(PostScriptTokenTypes.NUMBER)) {
+        this.operators.push(this.prev.value);
+      } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {
+        this.operators.push(this.prev.value);
+      } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+        this.parseCondition();
+      } else {
+        return;
+      }
+    }
+  }
+
+  parseCondition() {
+    const conditionLocation = this.operators.length;
+    this.operators.push(null, null);
+    this.parseBlock();
+    this.expect(PostScriptTokenTypes.RBRACE);
+
+    if (this.accept(PostScriptTokenTypes.IF)) {
+      this.operators[conditionLocation] = this.operators.length;
+      this.operators[conditionLocation + 1] = "jz";
+    } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+      const jumpLocation = this.operators.length;
+      this.operators.push(null, null);
+      const endOfTrue = this.operators.length;
+      this.parseBlock();
+      this.expect(PostScriptTokenTypes.RBRACE);
+      this.expect(PostScriptTokenTypes.IFELSE);
+      this.operators[jumpLocation] = this.operators.length;
+      this.operators[jumpLocation + 1] = "j";
+      this.operators[conditionLocation] = endOfTrue;
+      this.operators[conditionLocation + 1] = "jz";
+    } else {
+      throw new _util.FormatError("PS Function: error parsing conditional.");
+    }
+  }
+
+}
+
+exports.PostScriptParser = PostScriptParser;
+const PostScriptTokenTypes = {
+  LBRACE: 0,
+  RBRACE: 1,
+  NUMBER: 2,
+  OPERATOR: 3,
+  IF: 4,
+  IFELSE: 5
+};
+
+const PostScriptToken = function PostScriptTokenClosure() {
+  const opCache = Object.create(null);
+
+  class PostScriptToken {
+    constructor(type, value) {
+      this.type = type;
+      this.value = value;
+    }
+
+    static getOperator(op) {
+      const opValue = opCache[op];
+
+      if (opValue) {
+        return opValue;
+      }
+
+      return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op);
+    }
+
+    static get LBRACE() {
+      return (0, _util.shadow)(this, "LBRACE", new PostScriptToken(PostScriptTokenTypes.LBRACE, "{"));
+    }
+
+    static get RBRACE() {
+      return (0, _util.shadow)(this, "RBRACE", new PostScriptToken(PostScriptTokenTypes.RBRACE, "}"));
+    }
+
+    static get IF() {
+      return (0, _util.shadow)(this, "IF", new PostScriptToken(PostScriptTokenTypes.IF, "IF"));
+    }
+
+    static get IFELSE() {
+      return (0, _util.shadow)(this, "IFELSE", new PostScriptToken(PostScriptTokenTypes.IFELSE, "IFELSE"));
+    }
+
+  }
+
+  return PostScriptToken;
+}();
+
+class PostScriptLexer {
+  constructor(stream) {
+    this.stream = stream;
+    this.nextChar();
+    this.strBuf = [];
+  }
+
+  nextChar() {
+    return this.currentChar = this.stream.getByte();
+  }
+
+  getToken() {
+    let comment = false;
+    let ch = this.currentChar;
+
+    while (true) {
+      if (ch < 0) {
+        return _primitives.EOF;
+      }
+
+      if (comment) {
+        if (ch === 0x0a || ch === 0x0d) {
+          comment = false;
+        }
+      } else if (ch === 0x25) {
+        comment = true;
+      } else if (!(0, _core_utils.isWhiteSpace)(ch)) {
+        break;
+      }
+
+      ch = this.nextChar();
+    }
+
+    switch (ch | 0) {
+      case 0x30:
+      case 0x31:
+      case 0x32:
+      case 0x33:
+      case 0x34:
+      case 0x35:
+      case 0x36:
+      case 0x37:
+      case 0x38:
+      case 0x39:
+      case 0x2b:
+      case 0x2d:
+      case 0x2e:
+        return new PostScriptToken(PostScriptTokenTypes.NUMBER, this.getNumber());
+
+      case 0x7b:
+        this.nextChar();
+        return PostScriptToken.LBRACE;
+
+      case 0x7d:
+        this.nextChar();
+        return PostScriptToken.RBRACE;
+    }
+
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    strBuf[0] = String.fromCharCode(ch);
+
+    while ((ch = this.nextChar()) >= 0 && (ch >= 0x41 && ch <= 0x5a || ch >= 0x61 && ch <= 0x7a)) {
+      strBuf.push(String.fromCharCode(ch));
+    }
+
+    const str = strBuf.join("");
+
+    switch (str.toLowerCase()) {
+      case "if":
+        return PostScriptToken.IF;
+
+      case "ifelse":
+        return PostScriptToken.IFELSE;
+
+      default:
+        return PostScriptToken.getOperator(str);
+    }
+  }
+
+  getNumber() {
+    let ch = this.currentChar;
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    strBuf[0] = String.fromCharCode(ch);
+
+    while ((ch = this.nextChar()) >= 0) {
+      if (ch >= 0x30 && ch <= 0x39 || ch === 0x2d || ch === 0x2e) {
+        strBuf.push(String.fromCharCode(ch));
+      } else {
+        break;
+      }
+    }
+
+    const value = parseFloat(strBuf.join(""));
+
+    if (isNaN(value)) {
+      throw new _util.FormatError(`Invalid floating point number: ${value}`);
+    }
+
+    return value;
+  }
+
+}
+
+exports.PostScriptLexer = PostScriptLexer;
+
+/***/ }),
+/* 43 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.bidi = bidi;
+
+var _util = __w_pdfjs_require__(2);
+
+var baseTypes = ["BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "S", "B", "S", "WS", "B", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "B", "B", "B", "S", "WS", "ON", "ON", "ET", "ET", "ET", "ON", "ON", "ON", "ON", "ON", "ES", "CS", "ES", "CS", "CS", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "CS", "ON", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "ON", "ON", "ON", "BN", "BN", "BN", "BN", "BN", "BN", "B", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "BN", "CS", "ON", "ET", "ET", "ET", "ET", "ON", "ON", "ON", "ON", "L", "ON", "ON", "BN", "ON", "ON", "ET", "ET", "EN", "EN", "ON", "L", "ON", "ON", "ON", "EN", "L", "ON", "ON", "ON", "ON", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "L", "ON", "L", "L", "L", "L", "L", "L", "L", "L"];
+var arabicTypes = ["AN", "AN", "AN", "AN", "AN", "AN", "ON", "ON", "AL", "ET", "ET", "AL", "CS", "AL", "ON", "ON", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "AN", "ET", "AN", "AN", "AL", "AL", "AL", "NSM", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "AL", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AN", "ON", "NSM", "NSM", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "NSM", "NSM", "ON", "NSM", "NSM", "NSM", "NSM", "AL", "AL", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "EN", "AL", "AL", "AL", "AL", "AL", "AL"];
+
+function isOdd(i) {
+  return (i & 1) !== 0;
+}
+
+function isEven(i) {
+  return (i & 1) === 0;
+}
+
+function findUnequal(arr, start, value) {
+  for (var j = start, jj = arr.length; j < jj; ++j) {
+    if (arr[j] !== value) {
+      return j;
+    }
+  }
+
+  return j;
+}
+
+function setValues(arr, start, end, value) {
+  for (var j = start; j < end; ++j) {
+    arr[j] = value;
+  }
+}
+
+function reverseValues(arr, start, end) {
+  for (var i = start, j = end - 1; i < j; ++i, --j) {
+    var temp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = temp;
+  }
+}
+
+function createBidiText(str, isLTR, vertical = false) {
+  let dir = "ltr";
+
+  if (vertical) {
+    dir = "ttb";
+  } else if (!isLTR) {
+    dir = "rtl";
+  }
+
+  return {
+    str,
+    dir
+  };
+}
+
+var chars = [];
+var types = [];
+
+function bidi(str, startLevel, vertical) {
+  var isLTR = true;
+  var strLength = str.length;
+
+  if (strLength === 0 || vertical) {
+    return createBidiText(str, isLTR, vertical);
+  }
+
+  chars.length = strLength;
+  types.length = strLength;
+  var numBidi = 0;
+  var i, ii;
+
+  for (i = 0; i < strLength; ++i) {
+    chars[i] = str.charAt(i);
+    var charCode = str.charCodeAt(i);
+    var charType = "L";
+
+    if (charCode <= 0x00ff) {
+      charType = baseTypes[charCode];
+    } else if (0x0590 <= charCode && charCode <= 0x05f4) {
+      charType = "R";
+    } else if (0x0600 <= charCode && charCode <= 0x06ff) {
+      charType = arabicTypes[charCode & 0xff];
+
+      if (!charType) {
+        (0, _util.warn)("Bidi: invalid Unicode character " + charCode.toString(16));
+      }
+    } else if (0x0700 <= charCode && charCode <= 0x08ac) {
+      charType = "AL";
+    }
+
+    if (charType === "R" || charType === "AL" || charType === "AN") {
+      numBidi++;
+    }
+
+    types[i] = charType;
+  }
+
+  if (numBidi === 0) {
+    isLTR = true;
+    return createBidiText(str, isLTR);
+  }
+
+  if (startLevel === -1) {
+    if (numBidi / strLength < 0.3) {
+      isLTR = true;
+      startLevel = 0;
+    } else {
+      isLTR = false;
+      startLevel = 1;
+    }
+  }
+
+  var levels = [];
+
+  for (i = 0; i < strLength; ++i) {
+    levels[i] = startLevel;
+  }
+
+  var e = isOdd(startLevel) ? "R" : "L";
+  var sor = e;
+  var eor = sor;
+  var lastType = sor;
+
+  for (i = 0; i < strLength; ++i) {
+    if (types[i] === "NSM") {
+      types[i] = lastType;
+    } else {
+      lastType = types[i];
+    }
+  }
+
+  lastType = sor;
+  var t;
+
+  for (i = 0; i < strLength; ++i) {
+    t = types[i];
+
+    if (t === "EN") {
+      types[i] = lastType === "AL" ? "AN" : "EN";
+    } else if (t === "R" || t === "L" || t === "AL") {
+      lastType = t;
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    t = types[i];
+
+    if (t === "AL") {
+      types[i] = "R";
+    }
+  }
+
+  for (i = 1; i < strLength - 1; ++i) {
+    if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {
+      types[i] = "EN";
+    }
+
+    if (types[i] === "CS" && (types[i - 1] === "EN" || types[i - 1] === "AN") && types[i + 1] === types[i - 1]) {
+      types[i] = types[i - 1];
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    if (types[i] === "EN") {
+      var j;
+
+      for (j = i - 1; j >= 0; --j) {
+        if (types[j] !== "ET") {
+          break;
+        }
+
+        types[j] = "EN";
+      }
+
+      for (j = i + 1; j < strLength; ++j) {
+        if (types[j] !== "ET") {
+          break;
+        }
+
+        types[j] = "EN";
+      }
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    t = types[i];
+
+    if (t === "WS" || t === "ES" || t === "ET" || t === "CS") {
+      types[i] = "ON";
+    }
+  }
+
+  lastType = sor;
+
+  for (i = 0; i < strLength; ++i) {
+    t = types[i];
+
+    if (t === "EN") {
+      types[i] = lastType === "L" ? "L" : "EN";
+    } else if (t === "R" || t === "L") {
+      lastType = t;
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    if (types[i] === "ON") {
+      var end = findUnequal(types, i + 1, "ON");
+      var before = sor;
+
+      if (i > 0) {
+        before = types[i - 1];
+      }
+
+      var after = eor;
+
+      if (end + 1 < strLength) {
+        after = types[end + 1];
+      }
+
+      if (before !== "L") {
+        before = "R";
+      }
+
+      if (after !== "L") {
+        after = "R";
+      }
+
+      if (before === after) {
+        setValues(types, i, end, before);
+      }
+
+      i = end - 1;
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    if (types[i] === "ON") {
+      types[i] = e;
+    }
+  }
+
+  for (i = 0; i < strLength; ++i) {
+    t = types[i];
+
+    if (isEven(levels[i])) {
+      if (t === "R") {
+        levels[i] += 1;
+      } else if (t === "AN" || t === "EN") {
+        levels[i] += 2;
+      }
+    } else {
+      if (t === "L" || t === "AN" || t === "EN") {
+        levels[i] += 1;
+      }
+    }
+  }
+
+  var highestLevel = -1;
+  var lowestOddLevel = 99;
+  var level;
+
+  for (i = 0, ii = levels.length; i < ii; ++i) {
+    level = levels[i];
+
+    if (highestLevel < level) {
+      highestLevel = level;
+    }
+
+    if (lowestOddLevel > level && isOdd(level)) {
+      lowestOddLevel = level;
+    }
+  }
+
+  for (level = highestLevel; level >= lowestOddLevel; --level) {
+    var start = -1;
+
+    for (i = 0, ii = levels.length; i < ii; ++i) {
+      if (levels[i] < level) {
+        if (start >= 0) {
+          reverseValues(chars, start, i);
+          start = -1;
+        }
+      } else if (start < 0) {
+        start = i;
+      }
+    }
+
+    if (start >= 0) {
+      reverseValues(chars, start, levels.length);
+    }
+  }
+
+  for (i = 0, ii = chars.length; i < ii; ++i) {
+    var ch = chars[i];
+
+    if (ch === "<" || ch === ">") {
+      chars[i] = "";
+    }
+  }
+
+  return createBidiText(chars.join(""), isLTR);
+}
+
+/***/ }),
+/* 44 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getMetrics = void 0;
+
+var _core_utils = __w_pdfjs_require__(8);
+
+var getMetrics = (0, _core_utils.getLookupTableFactory)(function (t) {
+  t.Courier = 600;
+  t["Courier-Bold"] = 600;
+  t["Courier-BoldOblique"] = 600;
+  t["Courier-Oblique"] = 600;
+  t.Helvetica = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 278;
+    t.exclam = 278;
+    t.quotedbl = 355;
+    t.numbersign = 556;
+    t.dollar = 556;
+    t.percent = 889;
+    t.ampersand = 667;
+    t.quoteright = 222;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 389;
+    t.plus = 584;
+    t.comma = 278;
+    t.hyphen = 333;
+    t.period = 278;
+    t.slash = 278;
+    t.zero = 556;
+    t.one = 556;
+    t.two = 556;
+    t.three = 556;
+    t.four = 556;
+    t.five = 556;
+    t.six = 556;
+    t.seven = 556;
+    t.eight = 556;
+    t.nine = 556;
+    t.colon = 278;
+    t.semicolon = 278;
+    t.less = 584;
+    t.equal = 584;
+    t.greater = 584;
+    t.question = 556;
+    t.at = 1015;
+    t.A = 667;
+    t.B = 667;
+    t.C = 722;
+    t.D = 722;
+    t.E = 667;
+    t.F = 611;
+    t.G = 778;
+    t.H = 722;
+    t.I = 278;
+    t.J = 500;
+    t.K = 667;
+    t.L = 556;
+    t.M = 833;
+    t.N = 722;
+    t.O = 778;
+    t.P = 667;
+    t.Q = 778;
+    t.R = 722;
+    t.S = 667;
+    t.T = 611;
+    t.U = 722;
+    t.V = 667;
+    t.W = 944;
+    t.X = 667;
+    t.Y = 667;
+    t.Z = 611;
+    t.bracketleft = 278;
+    t.backslash = 278;
+    t.bracketright = 278;
+    t.asciicircum = 469;
+    t.underscore = 556;
+    t.quoteleft = 222;
+    t.a = 556;
+    t.b = 556;
+    t.c = 500;
+    t.d = 556;
+    t.e = 556;
+    t.f = 278;
+    t.g = 556;
+    t.h = 556;
+    t.i = 222;
+    t.j = 222;
+    t.k = 500;
+    t.l = 222;
+    t.m = 833;
+    t.n = 556;
+    t.o = 556;
+    t.p = 556;
+    t.q = 556;
+    t.r = 333;
+    t.s = 500;
+    t.t = 278;
+    t.u = 556;
+    t.v = 500;
+    t.w = 722;
+    t.x = 500;
+    t.y = 500;
+    t.z = 500;
+    t.braceleft = 334;
+    t.bar = 260;
+    t.braceright = 334;
+    t.asciitilde = 584;
+    t.exclamdown = 333;
+    t.cent = 556;
+    t.sterling = 556;
+    t.fraction = 167;
+    t.yen = 556;
+    t.florin = 556;
+    t.section = 556;
+    t.currency = 556;
+    t.quotesingle = 191;
+    t.quotedblleft = 333;
+    t.guillemotleft = 556;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 500;
+    t.fl = 500;
+    t.endash = 556;
+    t.dagger = 556;
+    t.daggerdbl = 556;
+    t.periodcentered = 278;
+    t.paragraph = 537;
+    t.bullet = 350;
+    t.quotesinglbase = 222;
+    t.quotedblbase = 333;
+    t.quotedblright = 333;
+    t.guillemotright = 556;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 611;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 1000;
+    t.ordfeminine = 370;
+    t.Lslash = 556;
+    t.Oslash = 778;
+    t.OE = 1000;
+    t.ordmasculine = 365;
+    t.ae = 889;
+    t.dotlessi = 278;
+    t.lslash = 222;
+    t.oslash = 611;
+    t.oe = 944;
+    t.germandbls = 611;
+    t.Idieresis = 278;
+    t.eacute = 556;
+    t.abreve = 556;
+    t.uhungarumlaut = 556;
+    t.ecaron = 556;
+    t.Ydieresis = 667;
+    t.divide = 584;
+    t.Yacute = 667;
+    t.Acircumflex = 667;
+    t.aacute = 556;
+    t.Ucircumflex = 722;
+    t.yacute = 500;
+    t.scommaaccent = 500;
+    t.ecircumflex = 556;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 556;
+    t.Uacute = 722;
+    t.uogonek = 556;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 737;
+    t.Emacron = 667;
+    t.ccaron = 500;
+    t.aring = 556;
+    t.Ncommaaccent = 722;
+    t.lacute = 222;
+    t.agrave = 556;
+    t.Tcommaaccent = 611;
+    t.Cacute = 722;
+    t.atilde = 556;
+    t.Edotaccent = 667;
+    t.scaron = 500;
+    t.scedilla = 500;
+    t.iacute = 278;
+    t.lozenge = 471;
+    t.Rcaron = 722;
+    t.Gcommaaccent = 778;
+    t.ucircumflex = 556;
+    t.acircumflex = 556;
+    t.Amacron = 667;
+    t.rcaron = 333;
+    t.ccedilla = 500;
+    t.Zdotaccent = 611;
+    t.Thorn = 667;
+    t.Omacron = 778;
+    t.Racute = 722;
+    t.Sacute = 667;
+    t.dcaron = 643;
+    t.Umacron = 722;
+    t.uring = 556;
+    t.threesuperior = 333;
+    t.Ograve = 778;
+    t.Agrave = 667;
+    t.Abreve = 667;
+    t.multiply = 584;
+    t.uacute = 556;
+    t.Tcaron = 611;
+    t.partialdiff = 476;
+    t.ydieresis = 500;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 556;
+    t.edieresis = 556;
+    t.cacute = 500;
+    t.nacute = 556;
+    t.umacron = 556;
+    t.Ncaron = 722;
+    t.Iacute = 278;
+    t.plusminus = 584;
+    t.brokenbar = 260;
+    t.registered = 737;
+    t.Gbreve = 778;
+    t.Idotaccent = 278;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 333;
+    t.omacron = 556;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 722;
+    t.lcommaaccent = 222;
+    t.tcaron = 317;
+    t.eogonek = 556;
+    t.Uogonek = 722;
+    t.Aacute = 667;
+    t.Adieresis = 667;
+    t.egrave = 556;
+    t.zacute = 500;
+    t.iogonek = 222;
+    t.Oacute = 778;
+    t.oacute = 556;
+    t.amacron = 556;
+    t.sacute = 500;
+    t.idieresis = 278;
+    t.Ocircumflex = 778;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 556;
+    t.twosuperior = 333;
+    t.Odieresis = 778;
+    t.mu = 556;
+    t.igrave = 278;
+    t.ohungarumlaut = 556;
+    t.Eogonek = 667;
+    t.dcroat = 556;
+    t.threequarters = 834;
+    t.Scedilla = 667;
+    t.lcaron = 299;
+    t.Kcommaaccent = 667;
+    t.Lacute = 556;
+    t.trademark = 1000;
+    t.edotaccent = 556;
+    t.Igrave = 278;
+    t.Imacron = 278;
+    t.Lcaron = 556;
+    t.onehalf = 834;
+    t.lessequal = 549;
+    t.ocircumflex = 556;
+    t.ntilde = 556;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 556;
+    t.gbreve = 556;
+    t.onequarter = 834;
+    t.Scaron = 667;
+    t.Scommaaccent = 667;
+    t.Ohungarumlaut = 778;
+    t.degree = 400;
+    t.ograve = 556;
+    t.Ccaron = 722;
+    t.ugrave = 556;
+    t.radical = 453;
+    t.Dcaron = 722;
+    t.rcommaaccent = 333;
+    t.Ntilde = 722;
+    t.otilde = 556;
+    t.Rcommaaccent = 722;
+    t.Lcommaaccent = 556;
+    t.Atilde = 667;
+    t.Aogonek = 667;
+    t.Aring = 667;
+    t.Otilde = 778;
+    t.zdotaccent = 500;
+    t.Ecaron = 667;
+    t.Iogonek = 278;
+    t.kcommaaccent = 500;
+    t.minus = 584;
+    t.Icircumflex = 278;
+    t.ncaron = 556;
+    t.tcommaaccent = 278;
+    t.logicalnot = 584;
+    t.odieresis = 556;
+    t.udieresis = 556;
+    t.notequal = 549;
+    t.gcommaaccent = 556;
+    t.eth = 556;
+    t.zcaron = 500;
+    t.ncommaaccent = 556;
+    t.onesuperior = 333;
+    t.imacron = 278;
+    t.Euro = 556;
+  });
+  t["Helvetica-Bold"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 278;
+    t.exclam = 333;
+    t.quotedbl = 474;
+    t.numbersign = 556;
+    t.dollar = 556;
+    t.percent = 889;
+    t.ampersand = 722;
+    t.quoteright = 278;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 389;
+    t.plus = 584;
+    t.comma = 278;
+    t.hyphen = 333;
+    t.period = 278;
+    t.slash = 278;
+    t.zero = 556;
+    t.one = 556;
+    t.two = 556;
+    t.three = 556;
+    t.four = 556;
+    t.five = 556;
+    t.six = 556;
+    t.seven = 556;
+    t.eight = 556;
+    t.nine = 556;
+    t.colon = 333;
+    t.semicolon = 333;
+    t.less = 584;
+    t.equal = 584;
+    t.greater = 584;
+    t.question = 611;
+    t.at = 975;
+    t.A = 722;
+    t.B = 722;
+    t.C = 722;
+    t.D = 722;
+    t.E = 667;
+    t.F = 611;
+    t.G = 778;
+    t.H = 722;
+    t.I = 278;
+    t.J = 556;
+    t.K = 722;
+    t.L = 611;
+    t.M = 833;
+    t.N = 722;
+    t.O = 778;
+    t.P = 667;
+    t.Q = 778;
+    t.R = 722;
+    t.S = 667;
+    t.T = 611;
+    t.U = 722;
+    t.V = 667;
+    t.W = 944;
+    t.X = 667;
+    t.Y = 667;
+    t.Z = 611;
+    t.bracketleft = 333;
+    t.backslash = 278;
+    t.bracketright = 333;
+    t.asciicircum = 584;
+    t.underscore = 556;
+    t.quoteleft = 278;
+    t.a = 556;
+    t.b = 611;
+    t.c = 556;
+    t.d = 611;
+    t.e = 556;
+    t.f = 333;
+    t.g = 611;
+    t.h = 611;
+    t.i = 278;
+    t.j = 278;
+    t.k = 556;
+    t.l = 278;
+    t.m = 889;
+    t.n = 611;
+    t.o = 611;
+    t.p = 611;
+    t.q = 611;
+    t.r = 389;
+    t.s = 556;
+    t.t = 333;
+    t.u = 611;
+    t.v = 556;
+    t.w = 778;
+    t.x = 556;
+    t.y = 556;
+    t.z = 500;
+    t.braceleft = 389;
+    t.bar = 280;
+    t.braceright = 389;
+    t.asciitilde = 584;
+    t.exclamdown = 333;
+    t.cent = 556;
+    t.sterling = 556;
+    t.fraction = 167;
+    t.yen = 556;
+    t.florin = 556;
+    t.section = 556;
+    t.currency = 556;
+    t.quotesingle = 238;
+    t.quotedblleft = 500;
+    t.guillemotleft = 556;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 611;
+    t.fl = 611;
+    t.endash = 556;
+    t.dagger = 556;
+    t.daggerdbl = 556;
+    t.periodcentered = 278;
+    t.paragraph = 556;
+    t.bullet = 350;
+    t.quotesinglbase = 278;
+    t.quotedblbase = 500;
+    t.quotedblright = 500;
+    t.guillemotright = 556;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 611;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 1000;
+    t.ordfeminine = 370;
+    t.Lslash = 611;
+    t.Oslash = 778;
+    t.OE = 1000;
+    t.ordmasculine = 365;
+    t.ae = 889;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 611;
+    t.oe = 944;
+    t.germandbls = 611;
+    t.Idieresis = 278;
+    t.eacute = 556;
+    t.abreve = 556;
+    t.uhungarumlaut = 611;
+    t.ecaron = 556;
+    t.Ydieresis = 667;
+    t.divide = 584;
+    t.Yacute = 667;
+    t.Acircumflex = 722;
+    t.aacute = 556;
+    t.Ucircumflex = 722;
+    t.yacute = 556;
+    t.scommaaccent = 556;
+    t.ecircumflex = 556;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 556;
+    t.Uacute = 722;
+    t.uogonek = 611;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 737;
+    t.Emacron = 667;
+    t.ccaron = 556;
+    t.aring = 556;
+    t.Ncommaaccent = 722;
+    t.lacute = 278;
+    t.agrave = 556;
+    t.Tcommaaccent = 611;
+    t.Cacute = 722;
+    t.atilde = 556;
+    t.Edotaccent = 667;
+    t.scaron = 556;
+    t.scedilla = 556;
+    t.iacute = 278;
+    t.lozenge = 494;
+    t.Rcaron = 722;
+    t.Gcommaaccent = 778;
+    t.ucircumflex = 611;
+    t.acircumflex = 556;
+    t.Amacron = 722;
+    t.rcaron = 389;
+    t.ccedilla = 556;
+    t.Zdotaccent = 611;
+    t.Thorn = 667;
+    t.Omacron = 778;
+    t.Racute = 722;
+    t.Sacute = 667;
+    t.dcaron = 743;
+    t.Umacron = 722;
+    t.uring = 611;
+    t.threesuperior = 333;
+    t.Ograve = 778;
+    t.Agrave = 722;
+    t.Abreve = 722;
+    t.multiply = 584;
+    t.uacute = 611;
+    t.Tcaron = 611;
+    t.partialdiff = 494;
+    t.ydieresis = 556;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 556;
+    t.edieresis = 556;
+    t.cacute = 556;
+    t.nacute = 611;
+    t.umacron = 611;
+    t.Ncaron = 722;
+    t.Iacute = 278;
+    t.plusminus = 584;
+    t.brokenbar = 280;
+    t.registered = 737;
+    t.Gbreve = 778;
+    t.Idotaccent = 278;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 389;
+    t.omacron = 611;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 722;
+    t.lcommaaccent = 278;
+    t.tcaron = 389;
+    t.eogonek = 556;
+    t.Uogonek = 722;
+    t.Aacute = 722;
+    t.Adieresis = 722;
+    t.egrave = 556;
+    t.zacute = 500;
+    t.iogonek = 278;
+    t.Oacute = 778;
+    t.oacute = 611;
+    t.amacron = 556;
+    t.sacute = 556;
+    t.idieresis = 278;
+    t.Ocircumflex = 778;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 611;
+    t.twosuperior = 333;
+    t.Odieresis = 778;
+    t.mu = 611;
+    t.igrave = 278;
+    t.ohungarumlaut = 611;
+    t.Eogonek = 667;
+    t.dcroat = 611;
+    t.threequarters = 834;
+    t.Scedilla = 667;
+    t.lcaron = 400;
+    t.Kcommaaccent = 722;
+    t.Lacute = 611;
+    t.trademark = 1000;
+    t.edotaccent = 556;
+    t.Igrave = 278;
+    t.Imacron = 278;
+    t.Lcaron = 611;
+    t.onehalf = 834;
+    t.lessequal = 549;
+    t.ocircumflex = 611;
+    t.ntilde = 611;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 556;
+    t.gbreve = 611;
+    t.onequarter = 834;
+    t.Scaron = 667;
+    t.Scommaaccent = 667;
+    t.Ohungarumlaut = 778;
+    t.degree = 400;
+    t.ograve = 611;
+    t.Ccaron = 722;
+    t.ugrave = 611;
+    t.radical = 549;
+    t.Dcaron = 722;
+    t.rcommaaccent = 389;
+    t.Ntilde = 722;
+    t.otilde = 611;
+    t.Rcommaaccent = 722;
+    t.Lcommaaccent = 611;
+    t.Atilde = 722;
+    t.Aogonek = 722;
+    t.Aring = 722;
+    t.Otilde = 778;
+    t.zdotaccent = 500;
+    t.Ecaron = 667;
+    t.Iogonek = 278;
+    t.kcommaaccent = 556;
+    t.minus = 584;
+    t.Icircumflex = 278;
+    t.ncaron = 611;
+    t.tcommaaccent = 333;
+    t.logicalnot = 584;
+    t.odieresis = 611;
+    t.udieresis = 611;
+    t.notequal = 549;
+    t.gcommaaccent = 611;
+    t.eth = 611;
+    t.zcaron = 500;
+    t.ncommaaccent = 611;
+    t.onesuperior = 333;
+    t.imacron = 278;
+    t.Euro = 556;
+  });
+  t["Helvetica-BoldOblique"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 278;
+    t.exclam = 333;
+    t.quotedbl = 474;
+    t.numbersign = 556;
+    t.dollar = 556;
+    t.percent = 889;
+    t.ampersand = 722;
+    t.quoteright = 278;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 389;
+    t.plus = 584;
+    t.comma = 278;
+    t.hyphen = 333;
+    t.period = 278;
+    t.slash = 278;
+    t.zero = 556;
+    t.one = 556;
+    t.two = 556;
+    t.three = 556;
+    t.four = 556;
+    t.five = 556;
+    t.six = 556;
+    t.seven = 556;
+    t.eight = 556;
+    t.nine = 556;
+    t.colon = 333;
+    t.semicolon = 333;
+    t.less = 584;
+    t.equal = 584;
+    t.greater = 584;
+    t.question = 611;
+    t.at = 975;
+    t.A = 722;
+    t.B = 722;
+    t.C = 722;
+    t.D = 722;
+    t.E = 667;
+    t.F = 611;
+    t.G = 778;
+    t.H = 722;
+    t.I = 278;
+    t.J = 556;
+    t.K = 722;
+    t.L = 611;
+    t.M = 833;
+    t.N = 722;
+    t.O = 778;
+    t.P = 667;
+    t.Q = 778;
+    t.R = 722;
+    t.S = 667;
+    t.T = 611;
+    t.U = 722;
+    t.V = 667;
+    t.W = 944;
+    t.X = 667;
+    t.Y = 667;
+    t.Z = 611;
+    t.bracketleft = 333;
+    t.backslash = 278;
+    t.bracketright = 333;
+    t.asciicircum = 584;
+    t.underscore = 556;
+    t.quoteleft = 278;
+    t.a = 556;
+    t.b = 611;
+    t.c = 556;
+    t.d = 611;
+    t.e = 556;
+    t.f = 333;
+    t.g = 611;
+    t.h = 611;
+    t.i = 278;
+    t.j = 278;
+    t.k = 556;
+    t.l = 278;
+    t.m = 889;
+    t.n = 611;
+    t.o = 611;
+    t.p = 611;
+    t.q = 611;
+    t.r = 389;
+    t.s = 556;
+    t.t = 333;
+    t.u = 611;
+    t.v = 556;
+    t.w = 778;
+    t.x = 556;
+    t.y = 556;
+    t.z = 500;
+    t.braceleft = 389;
+    t.bar = 280;
+    t.braceright = 389;
+    t.asciitilde = 584;
+    t.exclamdown = 333;
+    t.cent = 556;
+    t.sterling = 556;
+    t.fraction = 167;
+    t.yen = 556;
+    t.florin = 556;
+    t.section = 556;
+    t.currency = 556;
+    t.quotesingle = 238;
+    t.quotedblleft = 500;
+    t.guillemotleft = 556;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 611;
+    t.fl = 611;
+    t.endash = 556;
+    t.dagger = 556;
+    t.daggerdbl = 556;
+    t.periodcentered = 278;
+    t.paragraph = 556;
+    t.bullet = 350;
+    t.quotesinglbase = 278;
+    t.quotedblbase = 500;
+    t.quotedblright = 500;
+    t.guillemotright = 556;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 611;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 1000;
+    t.ordfeminine = 370;
+    t.Lslash = 611;
+    t.Oslash = 778;
+    t.OE = 1000;
+    t.ordmasculine = 365;
+    t.ae = 889;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 611;
+    t.oe = 944;
+    t.germandbls = 611;
+    t.Idieresis = 278;
+    t.eacute = 556;
+    t.abreve = 556;
+    t.uhungarumlaut = 611;
+    t.ecaron = 556;
+    t.Ydieresis = 667;
+    t.divide = 584;
+    t.Yacute = 667;
+    t.Acircumflex = 722;
+    t.aacute = 556;
+    t.Ucircumflex = 722;
+    t.yacute = 556;
+    t.scommaaccent = 556;
+    t.ecircumflex = 556;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 556;
+    t.Uacute = 722;
+    t.uogonek = 611;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 737;
+    t.Emacron = 667;
+    t.ccaron = 556;
+    t.aring = 556;
+    t.Ncommaaccent = 722;
+    t.lacute = 278;
+    t.agrave = 556;
+    t.Tcommaaccent = 611;
+    t.Cacute = 722;
+    t.atilde = 556;
+    t.Edotaccent = 667;
+    t.scaron = 556;
+    t.scedilla = 556;
+    t.iacute = 278;
+    t.lozenge = 494;
+    t.Rcaron = 722;
+    t.Gcommaaccent = 778;
+    t.ucircumflex = 611;
+    t.acircumflex = 556;
+    t.Amacron = 722;
+    t.rcaron = 389;
+    t.ccedilla = 556;
+    t.Zdotaccent = 611;
+    t.Thorn = 667;
+    t.Omacron = 778;
+    t.Racute = 722;
+    t.Sacute = 667;
+    t.dcaron = 743;
+    t.Umacron = 722;
+    t.uring = 611;
+    t.threesuperior = 333;
+    t.Ograve = 778;
+    t.Agrave = 722;
+    t.Abreve = 722;
+    t.multiply = 584;
+    t.uacute = 611;
+    t.Tcaron = 611;
+    t.partialdiff = 494;
+    t.ydieresis = 556;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 556;
+    t.edieresis = 556;
+    t.cacute = 556;
+    t.nacute = 611;
+    t.umacron = 611;
+    t.Ncaron = 722;
+    t.Iacute = 278;
+    t.plusminus = 584;
+    t.brokenbar = 280;
+    t.registered = 737;
+    t.Gbreve = 778;
+    t.Idotaccent = 278;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 389;
+    t.omacron = 611;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 722;
+    t.lcommaaccent = 278;
+    t.tcaron = 389;
+    t.eogonek = 556;
+    t.Uogonek = 722;
+    t.Aacute = 722;
+    t.Adieresis = 722;
+    t.egrave = 556;
+    t.zacute = 500;
+    t.iogonek = 278;
+    t.Oacute = 778;
+    t.oacute = 611;
+    t.amacron = 556;
+    t.sacute = 556;
+    t.idieresis = 278;
+    t.Ocircumflex = 778;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 611;
+    t.twosuperior = 333;
+    t.Odieresis = 778;
+    t.mu = 611;
+    t.igrave = 278;
+    t.ohungarumlaut = 611;
+    t.Eogonek = 667;
+    t.dcroat = 611;
+    t.threequarters = 834;
+    t.Scedilla = 667;
+    t.lcaron = 400;
+    t.Kcommaaccent = 722;
+    t.Lacute = 611;
+    t.trademark = 1000;
+    t.edotaccent = 556;
+    t.Igrave = 278;
+    t.Imacron = 278;
+    t.Lcaron = 611;
+    t.onehalf = 834;
+    t.lessequal = 549;
+    t.ocircumflex = 611;
+    t.ntilde = 611;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 556;
+    t.gbreve = 611;
+    t.onequarter = 834;
+    t.Scaron = 667;
+    t.Scommaaccent = 667;
+    t.Ohungarumlaut = 778;
+    t.degree = 400;
+    t.ograve = 611;
+    t.Ccaron = 722;
+    t.ugrave = 611;
+    t.radical = 549;
+    t.Dcaron = 722;
+    t.rcommaaccent = 389;
+    t.Ntilde = 722;
+    t.otilde = 611;
+    t.Rcommaaccent = 722;
+    t.Lcommaaccent = 611;
+    t.Atilde = 722;
+    t.Aogonek = 722;
+    t.Aring = 722;
+    t.Otilde = 778;
+    t.zdotaccent = 500;
+    t.Ecaron = 667;
+    t.Iogonek = 278;
+    t.kcommaaccent = 556;
+    t.minus = 584;
+    t.Icircumflex = 278;
+    t.ncaron = 611;
+    t.tcommaaccent = 333;
+    t.logicalnot = 584;
+    t.odieresis = 611;
+    t.udieresis = 611;
+    t.notequal = 549;
+    t.gcommaaccent = 611;
+    t.eth = 611;
+    t.zcaron = 500;
+    t.ncommaaccent = 611;
+    t.onesuperior = 333;
+    t.imacron = 278;
+    t.Euro = 556;
+  });
+  t["Helvetica-Oblique"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 278;
+    t.exclam = 278;
+    t.quotedbl = 355;
+    t.numbersign = 556;
+    t.dollar = 556;
+    t.percent = 889;
+    t.ampersand = 667;
+    t.quoteright = 222;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 389;
+    t.plus = 584;
+    t.comma = 278;
+    t.hyphen = 333;
+    t.period = 278;
+    t.slash = 278;
+    t.zero = 556;
+    t.one = 556;
+    t.two = 556;
+    t.three = 556;
+    t.four = 556;
+    t.five = 556;
+    t.six = 556;
+    t.seven = 556;
+    t.eight = 556;
+    t.nine = 556;
+    t.colon = 278;
+    t.semicolon = 278;
+    t.less = 584;
+    t.equal = 584;
+    t.greater = 584;
+    t.question = 556;
+    t.at = 1015;
+    t.A = 667;
+    t.B = 667;
+    t.C = 722;
+    t.D = 722;
+    t.E = 667;
+    t.F = 611;
+    t.G = 778;
+    t.H = 722;
+    t.I = 278;
+    t.J = 500;
+    t.K = 667;
+    t.L = 556;
+    t.M = 833;
+    t.N = 722;
+    t.O = 778;
+    t.P = 667;
+    t.Q = 778;
+    t.R = 722;
+    t.S = 667;
+    t.T = 611;
+    t.U = 722;
+    t.V = 667;
+    t.W = 944;
+    t.X = 667;
+    t.Y = 667;
+    t.Z = 611;
+    t.bracketleft = 278;
+    t.backslash = 278;
+    t.bracketright = 278;
+    t.asciicircum = 469;
+    t.underscore = 556;
+    t.quoteleft = 222;
+    t.a = 556;
+    t.b = 556;
+    t.c = 500;
+    t.d = 556;
+    t.e = 556;
+    t.f = 278;
+    t.g = 556;
+    t.h = 556;
+    t.i = 222;
+    t.j = 222;
+    t.k = 500;
+    t.l = 222;
+    t.m = 833;
+    t.n = 556;
+    t.o = 556;
+    t.p = 556;
+    t.q = 556;
+    t.r = 333;
+    t.s = 500;
+    t.t = 278;
+    t.u = 556;
+    t.v = 500;
+    t.w = 722;
+    t.x = 500;
+    t.y = 500;
+    t.z = 500;
+    t.braceleft = 334;
+    t.bar = 260;
+    t.braceright = 334;
+    t.asciitilde = 584;
+    t.exclamdown = 333;
+    t.cent = 556;
+    t.sterling = 556;
+    t.fraction = 167;
+    t.yen = 556;
+    t.florin = 556;
+    t.section = 556;
+    t.currency = 556;
+    t.quotesingle = 191;
+    t.quotedblleft = 333;
+    t.guillemotleft = 556;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 500;
+    t.fl = 500;
+    t.endash = 556;
+    t.dagger = 556;
+    t.daggerdbl = 556;
+    t.periodcentered = 278;
+    t.paragraph = 537;
+    t.bullet = 350;
+    t.quotesinglbase = 222;
+    t.quotedblbase = 333;
+    t.quotedblright = 333;
+    t.guillemotright = 556;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 611;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 1000;
+    t.ordfeminine = 370;
+    t.Lslash = 556;
+    t.Oslash = 778;
+    t.OE = 1000;
+    t.ordmasculine = 365;
+    t.ae = 889;
+    t.dotlessi = 278;
+    t.lslash = 222;
+    t.oslash = 611;
+    t.oe = 944;
+    t.germandbls = 611;
+    t.Idieresis = 278;
+    t.eacute = 556;
+    t.abreve = 556;
+    t.uhungarumlaut = 556;
+    t.ecaron = 556;
+    t.Ydieresis = 667;
+    t.divide = 584;
+    t.Yacute = 667;
+    t.Acircumflex = 667;
+    t.aacute = 556;
+    t.Ucircumflex = 722;
+    t.yacute = 500;
+    t.scommaaccent = 500;
+    t.ecircumflex = 556;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 556;
+    t.Uacute = 722;
+    t.uogonek = 556;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 737;
+    t.Emacron = 667;
+    t.ccaron = 500;
+    t.aring = 556;
+    t.Ncommaaccent = 722;
+    t.lacute = 222;
+    t.agrave = 556;
+    t.Tcommaaccent = 611;
+    t.Cacute = 722;
+    t.atilde = 556;
+    t.Edotaccent = 667;
+    t.scaron = 500;
+    t.scedilla = 500;
+    t.iacute = 278;
+    t.lozenge = 471;
+    t.Rcaron = 722;
+    t.Gcommaaccent = 778;
+    t.ucircumflex = 556;
+    t.acircumflex = 556;
+    t.Amacron = 667;
+    t.rcaron = 333;
+    t.ccedilla = 500;
+    t.Zdotaccent = 611;
+    t.Thorn = 667;
+    t.Omacron = 778;
+    t.Racute = 722;
+    t.Sacute = 667;
+    t.dcaron = 643;
+    t.Umacron = 722;
+    t.uring = 556;
+    t.threesuperior = 333;
+    t.Ograve = 778;
+    t.Agrave = 667;
+    t.Abreve = 667;
+    t.multiply = 584;
+    t.uacute = 556;
+    t.Tcaron = 611;
+    t.partialdiff = 476;
+    t.ydieresis = 500;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 556;
+    t.edieresis = 556;
+    t.cacute = 500;
+    t.nacute = 556;
+    t.umacron = 556;
+    t.Ncaron = 722;
+    t.Iacute = 278;
+    t.plusminus = 584;
+    t.brokenbar = 260;
+    t.registered = 737;
+    t.Gbreve = 778;
+    t.Idotaccent = 278;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 333;
+    t.omacron = 556;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 722;
+    t.lcommaaccent = 222;
+    t.tcaron = 317;
+    t.eogonek = 556;
+    t.Uogonek = 722;
+    t.Aacute = 667;
+    t.Adieresis = 667;
+    t.egrave = 556;
+    t.zacute = 500;
+    t.iogonek = 222;
+    t.Oacute = 778;
+    t.oacute = 556;
+    t.amacron = 556;
+    t.sacute = 500;
+    t.idieresis = 278;
+    t.Ocircumflex = 778;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 556;
+    t.twosuperior = 333;
+    t.Odieresis = 778;
+    t.mu = 556;
+    t.igrave = 278;
+    t.ohungarumlaut = 556;
+    t.Eogonek = 667;
+    t.dcroat = 556;
+    t.threequarters = 834;
+    t.Scedilla = 667;
+    t.lcaron = 299;
+    t.Kcommaaccent = 667;
+    t.Lacute = 556;
+    t.trademark = 1000;
+    t.edotaccent = 556;
+    t.Igrave = 278;
+    t.Imacron = 278;
+    t.Lcaron = 556;
+    t.onehalf = 834;
+    t.lessequal = 549;
+    t.ocircumflex = 556;
+    t.ntilde = 556;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 556;
+    t.gbreve = 556;
+    t.onequarter = 834;
+    t.Scaron = 667;
+    t.Scommaaccent = 667;
+    t.Ohungarumlaut = 778;
+    t.degree = 400;
+    t.ograve = 556;
+    t.Ccaron = 722;
+    t.ugrave = 556;
+    t.radical = 453;
+    t.Dcaron = 722;
+    t.rcommaaccent = 333;
+    t.Ntilde = 722;
+    t.otilde = 556;
+    t.Rcommaaccent = 722;
+    t.Lcommaaccent = 556;
+    t.Atilde = 667;
+    t.Aogonek = 667;
+    t.Aring = 667;
+    t.Otilde = 778;
+    t.zdotaccent = 500;
+    t.Ecaron = 667;
+    t.Iogonek = 278;
+    t.kcommaaccent = 500;
+    t.minus = 584;
+    t.Icircumflex = 278;
+    t.ncaron = 556;
+    t.tcommaaccent = 278;
+    t.logicalnot = 584;
+    t.odieresis = 556;
+    t.udieresis = 556;
+    t.notequal = 549;
+    t.gcommaaccent = 556;
+    t.eth = 556;
+    t.zcaron = 500;
+    t.ncommaaccent = 556;
+    t.onesuperior = 333;
+    t.imacron = 278;
+    t.Euro = 556;
+  });
+  t.Symbol = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 250;
+    t.exclam = 333;
+    t.universal = 713;
+    t.numbersign = 500;
+    t.existential = 549;
+    t.percent = 833;
+    t.ampersand = 778;
+    t.suchthat = 439;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asteriskmath = 500;
+    t.plus = 549;
+    t.comma = 250;
+    t.minus = 549;
+    t.period = 250;
+    t.slash = 278;
+    t.zero = 500;
+    t.one = 500;
+    t.two = 500;
+    t.three = 500;
+    t.four = 500;
+    t.five = 500;
+    t.six = 500;
+    t.seven = 500;
+    t.eight = 500;
+    t.nine = 500;
+    t.colon = 278;
+    t.semicolon = 278;
+    t.less = 549;
+    t.equal = 549;
+    t.greater = 549;
+    t.question = 444;
+    t.congruent = 549;
+    t.Alpha = 722;
+    t.Beta = 667;
+    t.Chi = 722;
+    t.Delta = 612;
+    t.Epsilon = 611;
+    t.Phi = 763;
+    t.Gamma = 603;
+    t.Eta = 722;
+    t.Iota = 333;
+    t.theta1 = 631;
+    t.Kappa = 722;
+    t.Lambda = 686;
+    t.Mu = 889;
+    t.Nu = 722;
+    t.Omicron = 722;
+    t.Pi = 768;
+    t.Theta = 741;
+    t.Rho = 556;
+    t.Sigma = 592;
+    t.Tau = 611;
+    t.Upsilon = 690;
+    t.sigma1 = 439;
+    t.Omega = 768;
+    t.Xi = 645;
+    t.Psi = 795;
+    t.Zeta = 611;
+    t.bracketleft = 333;
+    t.therefore = 863;
+    t.bracketright = 333;
+    t.perpendicular = 658;
+    t.underscore = 500;
+    t.radicalex = 500;
+    t.alpha = 631;
+    t.beta = 549;
+    t.chi = 549;
+    t.delta = 494;
+    t.epsilon = 439;
+    t.phi = 521;
+    t.gamma = 411;
+    t.eta = 603;
+    t.iota = 329;
+    t.phi1 = 603;
+    t.kappa = 549;
+    t.lambda = 549;
+    t.mu = 576;
+    t.nu = 521;
+    t.omicron = 549;
+    t.pi = 549;
+    t.theta = 521;
+    t.rho = 549;
+    t.sigma = 603;
+    t.tau = 439;
+    t.upsilon = 576;
+    t.omega1 = 713;
+    t.omega = 686;
+    t.xi = 493;
+    t.psi = 686;
+    t.zeta = 494;
+    t.braceleft = 480;
+    t.bar = 200;
+    t.braceright = 480;
+    t.similar = 549;
+    t.Euro = 750;
+    t.Upsilon1 = 620;
+    t.minute = 247;
+    t.lessequal = 549;
+    t.fraction = 167;
+    t.infinity = 713;
+    t.florin = 500;
+    t.club = 753;
+    t.diamond = 753;
+    t.heart = 753;
+    t.spade = 753;
+    t.arrowboth = 1042;
+    t.arrowleft = 987;
+    t.arrowup = 603;
+    t.arrowright = 987;
+    t.arrowdown = 603;
+    t.degree = 400;
+    t.plusminus = 549;
+    t.second = 411;
+    t.greaterequal = 549;
+    t.multiply = 549;
+    t.proportional = 713;
+    t.partialdiff = 494;
+    t.bullet = 460;
+    t.divide = 549;
+    t.notequal = 549;
+    t.equivalence = 549;
+    t.approxequal = 549;
+    t.ellipsis = 1000;
+    t.arrowvertex = 603;
+    t.arrowhorizex = 1000;
+    t.carriagereturn = 658;
+    t.aleph = 823;
+    t.Ifraktur = 686;
+    t.Rfraktur = 795;
+    t.weierstrass = 987;
+    t.circlemultiply = 768;
+    t.circleplus = 768;
+    t.emptyset = 823;
+    t.intersection = 768;
+    t.union = 768;
+    t.propersuperset = 713;
+    t.reflexsuperset = 713;
+    t.notsubset = 713;
+    t.propersubset = 713;
+    t.reflexsubset = 713;
+    t.element = 713;
+    t.notelement = 713;
+    t.angle = 768;
+    t.gradient = 713;
+    t.registerserif = 790;
+    t.copyrightserif = 790;
+    t.trademarkserif = 890;
+    t.product = 823;
+    t.radical = 549;
+    t.dotmath = 250;
+    t.logicalnot = 713;
+    t.logicaland = 603;
+    t.logicalor = 603;
+    t.arrowdblboth = 1042;
+    t.arrowdblleft = 987;
+    t.arrowdblup = 603;
+    t.arrowdblright = 987;
+    t.arrowdbldown = 603;
+    t.lozenge = 494;
+    t.angleleft = 329;
+    t.registersans = 790;
+    t.copyrightsans = 790;
+    t.trademarksans = 786;
+    t.summation = 713;
+    t.parenlefttp = 384;
+    t.parenleftex = 384;
+    t.parenleftbt = 384;
+    t.bracketlefttp = 384;
+    t.bracketleftex = 384;
+    t.bracketleftbt = 384;
+    t.bracelefttp = 494;
+    t.braceleftmid = 494;
+    t.braceleftbt = 494;
+    t.braceex = 494;
+    t.angleright = 329;
+    t.integral = 274;
+    t.integraltp = 686;
+    t.integralex = 686;
+    t.integralbt = 686;
+    t.parenrighttp = 384;
+    t.parenrightex = 384;
+    t.parenrightbt = 384;
+    t.bracketrighttp = 384;
+    t.bracketrightex = 384;
+    t.bracketrightbt = 384;
+    t.bracerighttp = 494;
+    t.bracerightmid = 494;
+    t.bracerightbt = 494;
+    t.apple = 790;
+  });
+  t["Times-Roman"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 250;
+    t.exclam = 333;
+    t.quotedbl = 408;
+    t.numbersign = 500;
+    t.dollar = 500;
+    t.percent = 833;
+    t.ampersand = 778;
+    t.quoteright = 333;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 500;
+    t.plus = 564;
+    t.comma = 250;
+    t.hyphen = 333;
+    t.period = 250;
+    t.slash = 278;
+    t.zero = 500;
+    t.one = 500;
+    t.two = 500;
+    t.three = 500;
+    t.four = 500;
+    t.five = 500;
+    t.six = 500;
+    t.seven = 500;
+    t.eight = 500;
+    t.nine = 500;
+    t.colon = 278;
+    t.semicolon = 278;
+    t.less = 564;
+    t.equal = 564;
+    t.greater = 564;
+    t.question = 444;
+    t.at = 921;
+    t.A = 722;
+    t.B = 667;
+    t.C = 667;
+    t.D = 722;
+    t.E = 611;
+    t.F = 556;
+    t.G = 722;
+    t.H = 722;
+    t.I = 333;
+    t.J = 389;
+    t.K = 722;
+    t.L = 611;
+    t.M = 889;
+    t.N = 722;
+    t.O = 722;
+    t.P = 556;
+    t.Q = 722;
+    t.R = 667;
+    t.S = 556;
+    t.T = 611;
+    t.U = 722;
+    t.V = 722;
+    t.W = 944;
+    t.X = 722;
+    t.Y = 722;
+    t.Z = 611;
+    t.bracketleft = 333;
+    t.backslash = 278;
+    t.bracketright = 333;
+    t.asciicircum = 469;
+    t.underscore = 500;
+    t.quoteleft = 333;
+    t.a = 444;
+    t.b = 500;
+    t.c = 444;
+    t.d = 500;
+    t.e = 444;
+    t.f = 333;
+    t.g = 500;
+    t.h = 500;
+    t.i = 278;
+    t.j = 278;
+    t.k = 500;
+    t.l = 278;
+    t.m = 778;
+    t.n = 500;
+    t.o = 500;
+    t.p = 500;
+    t.q = 500;
+    t.r = 333;
+    t.s = 389;
+    t.t = 278;
+    t.u = 500;
+    t.v = 500;
+    t.w = 722;
+    t.x = 500;
+    t.y = 500;
+    t.z = 444;
+    t.braceleft = 480;
+    t.bar = 200;
+    t.braceright = 480;
+    t.asciitilde = 541;
+    t.exclamdown = 333;
+    t.cent = 500;
+    t.sterling = 500;
+    t.fraction = 167;
+    t.yen = 500;
+    t.florin = 500;
+    t.section = 500;
+    t.currency = 500;
+    t.quotesingle = 180;
+    t.quotedblleft = 444;
+    t.guillemotleft = 500;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 556;
+    t.fl = 556;
+    t.endash = 500;
+    t.dagger = 500;
+    t.daggerdbl = 500;
+    t.periodcentered = 250;
+    t.paragraph = 453;
+    t.bullet = 350;
+    t.quotesinglbase = 333;
+    t.quotedblbase = 444;
+    t.quotedblright = 444;
+    t.guillemotright = 500;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 444;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 889;
+    t.ordfeminine = 276;
+    t.Lslash = 611;
+    t.Oslash = 722;
+    t.OE = 889;
+    t.ordmasculine = 310;
+    t.ae = 667;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 500;
+    t.oe = 722;
+    t.germandbls = 500;
+    t.Idieresis = 333;
+    t.eacute = 444;
+    t.abreve = 444;
+    t.uhungarumlaut = 500;
+    t.ecaron = 444;
+    t.Ydieresis = 722;
+    t.divide = 564;
+    t.Yacute = 722;
+    t.Acircumflex = 722;
+    t.aacute = 444;
+    t.Ucircumflex = 722;
+    t.yacute = 500;
+    t.scommaaccent = 389;
+    t.ecircumflex = 444;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 444;
+    t.Uacute = 722;
+    t.uogonek = 500;
+    t.Edieresis = 611;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 760;
+    t.Emacron = 611;
+    t.ccaron = 444;
+    t.aring = 444;
+    t.Ncommaaccent = 722;
+    t.lacute = 278;
+    t.agrave = 444;
+    t.Tcommaaccent = 611;
+    t.Cacute = 667;
+    t.atilde = 444;
+    t.Edotaccent = 611;
+    t.scaron = 389;
+    t.scedilla = 389;
+    t.iacute = 278;
+    t.lozenge = 471;
+    t.Rcaron = 667;
+    t.Gcommaaccent = 722;
+    t.ucircumflex = 500;
+    t.acircumflex = 444;
+    t.Amacron = 722;
+    t.rcaron = 333;
+    t.ccedilla = 444;
+    t.Zdotaccent = 611;
+    t.Thorn = 556;
+    t.Omacron = 722;
+    t.Racute = 667;
+    t.Sacute = 556;
+    t.dcaron = 588;
+    t.Umacron = 722;
+    t.uring = 500;
+    t.threesuperior = 300;
+    t.Ograve = 722;
+    t.Agrave = 722;
+    t.Abreve = 722;
+    t.multiply = 564;
+    t.uacute = 500;
+    t.Tcaron = 611;
+    t.partialdiff = 476;
+    t.ydieresis = 500;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 611;
+    t.adieresis = 444;
+    t.edieresis = 444;
+    t.cacute = 444;
+    t.nacute = 500;
+    t.umacron = 500;
+    t.Ncaron = 722;
+    t.Iacute = 333;
+    t.plusminus = 564;
+    t.brokenbar = 200;
+    t.registered = 760;
+    t.Gbreve = 722;
+    t.Idotaccent = 333;
+    t.summation = 600;
+    t.Egrave = 611;
+    t.racute = 333;
+    t.omacron = 500;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 667;
+    t.lcommaaccent = 278;
+    t.tcaron = 326;
+    t.eogonek = 444;
+    t.Uogonek = 722;
+    t.Aacute = 722;
+    t.Adieresis = 722;
+    t.egrave = 444;
+    t.zacute = 444;
+    t.iogonek = 278;
+    t.Oacute = 722;
+    t.oacute = 500;
+    t.amacron = 444;
+    t.sacute = 389;
+    t.idieresis = 278;
+    t.Ocircumflex = 722;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 500;
+    t.twosuperior = 300;
+    t.Odieresis = 722;
+    t.mu = 500;
+    t.igrave = 278;
+    t.ohungarumlaut = 500;
+    t.Eogonek = 611;
+    t.dcroat = 500;
+    t.threequarters = 750;
+    t.Scedilla = 556;
+    t.lcaron = 344;
+    t.Kcommaaccent = 722;
+    t.Lacute = 611;
+    t.trademark = 980;
+    t.edotaccent = 444;
+    t.Igrave = 333;
+    t.Imacron = 333;
+    t.Lcaron = 611;
+    t.onehalf = 750;
+    t.lessequal = 549;
+    t.ocircumflex = 500;
+    t.ntilde = 500;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 611;
+    t.emacron = 444;
+    t.gbreve = 500;
+    t.onequarter = 750;
+    t.Scaron = 556;
+    t.Scommaaccent = 556;
+    t.Ohungarumlaut = 722;
+    t.degree = 400;
+    t.ograve = 500;
+    t.Ccaron = 667;
+    t.ugrave = 500;
+    t.radical = 453;
+    t.Dcaron = 722;
+    t.rcommaaccent = 333;
+    t.Ntilde = 722;
+    t.otilde = 500;
+    t.Rcommaaccent = 667;
+    t.Lcommaaccent = 611;
+    t.Atilde = 722;
+    t.Aogonek = 722;
+    t.Aring = 722;
+    t.Otilde = 722;
+    t.zdotaccent = 444;
+    t.Ecaron = 611;
+    t.Iogonek = 333;
+    t.kcommaaccent = 500;
+    t.minus = 564;
+    t.Icircumflex = 333;
+    t.ncaron = 500;
+    t.tcommaaccent = 278;
+    t.logicalnot = 564;
+    t.odieresis = 500;
+    t.udieresis = 500;
+    t.notequal = 549;
+    t.gcommaaccent = 500;
+    t.eth = 500;
+    t.zcaron = 444;
+    t.ncommaaccent = 500;
+    t.onesuperior = 300;
+    t.imacron = 278;
+    t.Euro = 500;
+  });
+  t["Times-Bold"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 250;
+    t.exclam = 333;
+    t.quotedbl = 555;
+    t.numbersign = 500;
+    t.dollar = 500;
+    t.percent = 1000;
+    t.ampersand = 833;
+    t.quoteright = 333;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 500;
+    t.plus = 570;
+    t.comma = 250;
+    t.hyphen = 333;
+    t.period = 250;
+    t.slash = 278;
+    t.zero = 500;
+    t.one = 500;
+    t.two = 500;
+    t.three = 500;
+    t.four = 500;
+    t.five = 500;
+    t.six = 500;
+    t.seven = 500;
+    t.eight = 500;
+    t.nine = 500;
+    t.colon = 333;
+    t.semicolon = 333;
+    t.less = 570;
+    t.equal = 570;
+    t.greater = 570;
+    t.question = 500;
+    t.at = 930;
+    t.A = 722;
+    t.B = 667;
+    t.C = 722;
+    t.D = 722;
+    t.E = 667;
+    t.F = 611;
+    t.G = 778;
+    t.H = 778;
+    t.I = 389;
+    t.J = 500;
+    t.K = 778;
+    t.L = 667;
+    t.M = 944;
+    t.N = 722;
+    t.O = 778;
+    t.P = 611;
+    t.Q = 778;
+    t.R = 722;
+    t.S = 556;
+    t.T = 667;
+    t.U = 722;
+    t.V = 722;
+    t.W = 1000;
+    t.X = 722;
+    t.Y = 722;
+    t.Z = 667;
+    t.bracketleft = 333;
+    t.backslash = 278;
+    t.bracketright = 333;
+    t.asciicircum = 581;
+    t.underscore = 500;
+    t.quoteleft = 333;
+    t.a = 500;
+    t.b = 556;
+    t.c = 444;
+    t.d = 556;
+    t.e = 444;
+    t.f = 333;
+    t.g = 500;
+    t.h = 556;
+    t.i = 278;
+    t.j = 333;
+    t.k = 556;
+    t.l = 278;
+    t.m = 833;
+    t.n = 556;
+    t.o = 500;
+    t.p = 556;
+    t.q = 556;
+    t.r = 444;
+    t.s = 389;
+    t.t = 333;
+    t.u = 556;
+    t.v = 500;
+    t.w = 722;
+    t.x = 500;
+    t.y = 500;
+    t.z = 444;
+    t.braceleft = 394;
+    t.bar = 220;
+    t.braceright = 394;
+    t.asciitilde = 520;
+    t.exclamdown = 333;
+    t.cent = 500;
+    t.sterling = 500;
+    t.fraction = 167;
+    t.yen = 500;
+    t.florin = 500;
+    t.section = 500;
+    t.currency = 500;
+    t.quotesingle = 278;
+    t.quotedblleft = 500;
+    t.guillemotleft = 500;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 556;
+    t.fl = 556;
+    t.endash = 500;
+    t.dagger = 500;
+    t.daggerdbl = 500;
+    t.periodcentered = 250;
+    t.paragraph = 540;
+    t.bullet = 350;
+    t.quotesinglbase = 333;
+    t.quotedblbase = 500;
+    t.quotedblright = 500;
+    t.guillemotright = 500;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 500;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 1000;
+    t.ordfeminine = 300;
+    t.Lslash = 667;
+    t.Oslash = 778;
+    t.OE = 1000;
+    t.ordmasculine = 330;
+    t.ae = 722;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 500;
+    t.oe = 722;
+    t.germandbls = 556;
+    t.Idieresis = 389;
+    t.eacute = 444;
+    t.abreve = 500;
+    t.uhungarumlaut = 556;
+    t.ecaron = 444;
+    t.Ydieresis = 722;
+    t.divide = 570;
+    t.Yacute = 722;
+    t.Acircumflex = 722;
+    t.aacute = 500;
+    t.Ucircumflex = 722;
+    t.yacute = 500;
+    t.scommaaccent = 389;
+    t.ecircumflex = 444;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 500;
+    t.Uacute = 722;
+    t.uogonek = 556;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 747;
+    t.Emacron = 667;
+    t.ccaron = 444;
+    t.aring = 500;
+    t.Ncommaaccent = 722;
+    t.lacute = 278;
+    t.agrave = 500;
+    t.Tcommaaccent = 667;
+    t.Cacute = 722;
+    t.atilde = 500;
+    t.Edotaccent = 667;
+    t.scaron = 389;
+    t.scedilla = 389;
+    t.iacute = 278;
+    t.lozenge = 494;
+    t.Rcaron = 722;
+    t.Gcommaaccent = 778;
+    t.ucircumflex = 556;
+    t.acircumflex = 500;
+    t.Amacron = 722;
+    t.rcaron = 444;
+    t.ccedilla = 444;
+    t.Zdotaccent = 667;
+    t.Thorn = 611;
+    t.Omacron = 778;
+    t.Racute = 722;
+    t.Sacute = 556;
+    t.dcaron = 672;
+    t.Umacron = 722;
+    t.uring = 556;
+    t.threesuperior = 300;
+    t.Ograve = 778;
+    t.Agrave = 722;
+    t.Abreve = 722;
+    t.multiply = 570;
+    t.uacute = 556;
+    t.Tcaron = 667;
+    t.partialdiff = 494;
+    t.ydieresis = 500;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 500;
+    t.edieresis = 444;
+    t.cacute = 444;
+    t.nacute = 556;
+    t.umacron = 556;
+    t.Ncaron = 722;
+    t.Iacute = 389;
+    t.plusminus = 570;
+    t.brokenbar = 220;
+    t.registered = 747;
+    t.Gbreve = 778;
+    t.Idotaccent = 389;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 444;
+    t.omacron = 500;
+    t.Zacute = 667;
+    t.Zcaron = 667;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 722;
+    t.lcommaaccent = 278;
+    t.tcaron = 416;
+    t.eogonek = 444;
+    t.Uogonek = 722;
+    t.Aacute = 722;
+    t.Adieresis = 722;
+    t.egrave = 444;
+    t.zacute = 444;
+    t.iogonek = 278;
+    t.Oacute = 778;
+    t.oacute = 500;
+    t.amacron = 500;
+    t.sacute = 389;
+    t.idieresis = 278;
+    t.Ocircumflex = 778;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 556;
+    t.twosuperior = 300;
+    t.Odieresis = 778;
+    t.mu = 556;
+    t.igrave = 278;
+    t.ohungarumlaut = 500;
+    t.Eogonek = 667;
+    t.dcroat = 556;
+    t.threequarters = 750;
+    t.Scedilla = 556;
+    t.lcaron = 394;
+    t.Kcommaaccent = 778;
+    t.Lacute = 667;
+    t.trademark = 1000;
+    t.edotaccent = 444;
+    t.Igrave = 389;
+    t.Imacron = 389;
+    t.Lcaron = 667;
+    t.onehalf = 750;
+    t.lessequal = 549;
+    t.ocircumflex = 500;
+    t.ntilde = 556;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 444;
+    t.gbreve = 500;
+    t.onequarter = 750;
+    t.Scaron = 556;
+    t.Scommaaccent = 556;
+    t.Ohungarumlaut = 778;
+    t.degree = 400;
+    t.ograve = 500;
+    t.Ccaron = 722;
+    t.ugrave = 556;
+    t.radical = 549;
+    t.Dcaron = 722;
+    t.rcommaaccent = 444;
+    t.Ntilde = 722;
+    t.otilde = 500;
+    t.Rcommaaccent = 722;
+    t.Lcommaaccent = 667;
+    t.Atilde = 722;
+    t.Aogonek = 722;
+    t.Aring = 722;
+    t.Otilde = 778;
+    t.zdotaccent = 444;
+    t.Ecaron = 667;
+    t.Iogonek = 389;
+    t.kcommaaccent = 556;
+    t.minus = 570;
+    t.Icircumflex = 389;
+    t.ncaron = 556;
+    t.tcommaaccent = 333;
+    t.logicalnot = 570;
+    t.odieresis = 500;
+    t.udieresis = 556;
+    t.notequal = 549;
+    t.gcommaaccent = 500;
+    t.eth = 500;
+    t.zcaron = 444;
+    t.ncommaaccent = 556;
+    t.onesuperior = 300;
+    t.imacron = 278;
+    t.Euro = 500;
+  });
+  t["Times-BoldItalic"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 250;
+    t.exclam = 389;
+    t.quotedbl = 555;
+    t.numbersign = 500;
+    t.dollar = 500;
+    t.percent = 833;
+    t.ampersand = 778;
+    t.quoteright = 333;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 500;
+    t.plus = 570;
+    t.comma = 250;
+    t.hyphen = 333;
+    t.period = 250;
+    t.slash = 278;
+    t.zero = 500;
+    t.one = 500;
+    t.two = 500;
+    t.three = 500;
+    t.four = 500;
+    t.five = 500;
+    t.six = 500;
+    t.seven = 500;
+    t.eight = 500;
+    t.nine = 500;
+    t.colon = 333;
+    t.semicolon = 333;
+    t.less = 570;
+    t.equal = 570;
+    t.greater = 570;
+    t.question = 500;
+    t.at = 832;
+    t.A = 667;
+    t.B = 667;
+    t.C = 667;
+    t.D = 722;
+    t.E = 667;
+    t.F = 667;
+    t.G = 722;
+    t.H = 778;
+    t.I = 389;
+    t.J = 500;
+    t.K = 667;
+    t.L = 611;
+    t.M = 889;
+    t.N = 722;
+    t.O = 722;
+    t.P = 611;
+    t.Q = 722;
+    t.R = 667;
+    t.S = 556;
+    t.T = 611;
+    t.U = 722;
+    t.V = 667;
+    t.W = 889;
+    t.X = 667;
+    t.Y = 611;
+    t.Z = 611;
+    t.bracketleft = 333;
+    t.backslash = 278;
+    t.bracketright = 333;
+    t.asciicircum = 570;
+    t.underscore = 500;
+    t.quoteleft = 333;
+    t.a = 500;
+    t.b = 500;
+    t.c = 444;
+    t.d = 500;
+    t.e = 444;
+    t.f = 333;
+    t.g = 500;
+    t.h = 556;
+    t.i = 278;
+    t.j = 278;
+    t.k = 500;
+    t.l = 278;
+    t.m = 778;
+    t.n = 556;
+    t.o = 500;
+    t.p = 500;
+    t.q = 500;
+    t.r = 389;
+    t.s = 389;
+    t.t = 278;
+    t.u = 556;
+    t.v = 444;
+    t.w = 667;
+    t.x = 500;
+    t.y = 444;
+    t.z = 389;
+    t.braceleft = 348;
+    t.bar = 220;
+    t.braceright = 348;
+    t.asciitilde = 570;
+    t.exclamdown = 389;
+    t.cent = 500;
+    t.sterling = 500;
+    t.fraction = 167;
+    t.yen = 500;
+    t.florin = 500;
+    t.section = 500;
+    t.currency = 500;
+    t.quotesingle = 278;
+    t.quotedblleft = 500;
+    t.guillemotleft = 500;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 556;
+    t.fl = 556;
+    t.endash = 500;
+    t.dagger = 500;
+    t.daggerdbl = 500;
+    t.periodcentered = 250;
+    t.paragraph = 500;
+    t.bullet = 350;
+    t.quotesinglbase = 333;
+    t.quotedblbase = 500;
+    t.quotedblright = 500;
+    t.guillemotright = 500;
+    t.ellipsis = 1000;
+    t.perthousand = 1000;
+    t.questiondown = 500;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 1000;
+    t.AE = 944;
+    t.ordfeminine = 266;
+    t.Lslash = 611;
+    t.Oslash = 722;
+    t.OE = 944;
+    t.ordmasculine = 300;
+    t.ae = 722;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 500;
+    t.oe = 722;
+    t.germandbls = 500;
+    t.Idieresis = 389;
+    t.eacute = 444;
+    t.abreve = 500;
+    t.uhungarumlaut = 556;
+    t.ecaron = 444;
+    t.Ydieresis = 611;
+    t.divide = 570;
+    t.Yacute = 611;
+    t.Acircumflex = 667;
+    t.aacute = 500;
+    t.Ucircumflex = 722;
+    t.yacute = 444;
+    t.scommaaccent = 389;
+    t.ecircumflex = 444;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 500;
+    t.Uacute = 722;
+    t.uogonek = 556;
+    t.Edieresis = 667;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 747;
+    t.Emacron = 667;
+    t.ccaron = 444;
+    t.aring = 500;
+    t.Ncommaaccent = 722;
+    t.lacute = 278;
+    t.agrave = 500;
+    t.Tcommaaccent = 611;
+    t.Cacute = 667;
+    t.atilde = 500;
+    t.Edotaccent = 667;
+    t.scaron = 389;
+    t.scedilla = 389;
+    t.iacute = 278;
+    t.lozenge = 494;
+    t.Rcaron = 667;
+    t.Gcommaaccent = 722;
+    t.ucircumflex = 556;
+    t.acircumflex = 500;
+    t.Amacron = 667;
+    t.rcaron = 389;
+    t.ccedilla = 444;
+    t.Zdotaccent = 611;
+    t.Thorn = 611;
+    t.Omacron = 722;
+    t.Racute = 667;
+    t.Sacute = 556;
+    t.dcaron = 608;
+    t.Umacron = 722;
+    t.uring = 556;
+    t.threesuperior = 300;
+    t.Ograve = 722;
+    t.Agrave = 667;
+    t.Abreve = 667;
+    t.multiply = 570;
+    t.uacute = 556;
+    t.Tcaron = 611;
+    t.partialdiff = 494;
+    t.ydieresis = 444;
+    t.Nacute = 722;
+    t.icircumflex = 278;
+    t.Ecircumflex = 667;
+    t.adieresis = 500;
+    t.edieresis = 444;
+    t.cacute = 444;
+    t.nacute = 556;
+    t.umacron = 556;
+    t.Ncaron = 722;
+    t.Iacute = 389;
+    t.plusminus = 570;
+    t.brokenbar = 220;
+    t.registered = 747;
+    t.Gbreve = 722;
+    t.Idotaccent = 389;
+    t.summation = 600;
+    t.Egrave = 667;
+    t.racute = 389;
+    t.omacron = 500;
+    t.Zacute = 611;
+    t.Zcaron = 611;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 667;
+    t.lcommaaccent = 278;
+    t.tcaron = 366;
+    t.eogonek = 444;
+    t.Uogonek = 722;
+    t.Aacute = 667;
+    t.Adieresis = 667;
+    t.egrave = 444;
+    t.zacute = 389;
+    t.iogonek = 278;
+    t.Oacute = 722;
+    t.oacute = 500;
+    t.amacron = 500;
+    t.sacute = 389;
+    t.idieresis = 278;
+    t.Ocircumflex = 722;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 500;
+    t.twosuperior = 300;
+    t.Odieresis = 722;
+    t.mu = 576;
+    t.igrave = 278;
+    t.ohungarumlaut = 500;
+    t.Eogonek = 667;
+    t.dcroat = 500;
+    t.threequarters = 750;
+    t.Scedilla = 556;
+    t.lcaron = 382;
+    t.Kcommaaccent = 667;
+    t.Lacute = 611;
+    t.trademark = 1000;
+    t.edotaccent = 444;
+    t.Igrave = 389;
+    t.Imacron = 389;
+    t.Lcaron = 611;
+    t.onehalf = 750;
+    t.lessequal = 549;
+    t.ocircumflex = 500;
+    t.ntilde = 556;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 667;
+    t.emacron = 444;
+    t.gbreve = 500;
+    t.onequarter = 750;
+    t.Scaron = 556;
+    t.Scommaaccent = 556;
+    t.Ohungarumlaut = 722;
+    t.degree = 400;
+    t.ograve = 500;
+    t.Ccaron = 667;
+    t.ugrave = 556;
+    t.radical = 549;
+    t.Dcaron = 722;
+    t.rcommaaccent = 389;
+    t.Ntilde = 722;
+    t.otilde = 500;
+    t.Rcommaaccent = 667;
+    t.Lcommaaccent = 611;
+    t.Atilde = 667;
+    t.Aogonek = 667;
+    t.Aring = 667;
+    t.Otilde = 722;
+    t.zdotaccent = 389;
+    t.Ecaron = 667;
+    t.Iogonek = 389;
+    t.kcommaaccent = 500;
+    t.minus = 606;
+    t.Icircumflex = 389;
+    t.ncaron = 556;
+    t.tcommaaccent = 278;
+    t.logicalnot = 606;
+    t.odieresis = 500;
+    t.udieresis = 556;
+    t.notequal = 549;
+    t.gcommaaccent = 500;
+    t.eth = 500;
+    t.zcaron = 389;
+    t.ncommaaccent = 556;
+    t.onesuperior = 300;
+    t.imacron = 278;
+    t.Euro = 500;
+  });
+  t["Times-Italic"] = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 250;
+    t.exclam = 333;
+    t.quotedbl = 420;
+    t.numbersign = 500;
+    t.dollar = 500;
+    t.percent = 833;
+    t.ampersand = 778;
+    t.quoteright = 333;
+    t.parenleft = 333;
+    t.parenright = 333;
+    t.asterisk = 500;
+    t.plus = 675;
+    t.comma = 250;
+    t.hyphen = 333;
+    t.period = 250;
+    t.slash = 278;
+    t.zero = 500;
+    t.one = 500;
+    t.two = 500;
+    t.three = 500;
+    t.four = 500;
+    t.five = 500;
+    t.six = 500;
+    t.seven = 500;
+    t.eight = 500;
+    t.nine = 500;
+    t.colon = 333;
+    t.semicolon = 333;
+    t.less = 675;
+    t.equal = 675;
+    t.greater = 675;
+    t.question = 500;
+    t.at = 920;
+    t.A = 611;
+    t.B = 611;
+    t.C = 667;
+    t.D = 722;
+    t.E = 611;
+    t.F = 611;
+    t.G = 722;
+    t.H = 722;
+    t.I = 333;
+    t.J = 444;
+    t.K = 667;
+    t.L = 556;
+    t.M = 833;
+    t.N = 667;
+    t.O = 722;
+    t.P = 611;
+    t.Q = 722;
+    t.R = 611;
+    t.S = 500;
+    t.T = 556;
+    t.U = 722;
+    t.V = 611;
+    t.W = 833;
+    t.X = 611;
+    t.Y = 556;
+    t.Z = 556;
+    t.bracketleft = 389;
+    t.backslash = 278;
+    t.bracketright = 389;
+    t.asciicircum = 422;
+    t.underscore = 500;
+    t.quoteleft = 333;
+    t.a = 500;
+    t.b = 500;
+    t.c = 444;
+    t.d = 500;
+    t.e = 444;
+    t.f = 278;
+    t.g = 500;
+    t.h = 500;
+    t.i = 278;
+    t.j = 278;
+    t.k = 444;
+    t.l = 278;
+    t.m = 722;
+    t.n = 500;
+    t.o = 500;
+    t.p = 500;
+    t.q = 500;
+    t.r = 389;
+    t.s = 389;
+    t.t = 278;
+    t.u = 500;
+    t.v = 444;
+    t.w = 667;
+    t.x = 444;
+    t.y = 444;
+    t.z = 389;
+    t.braceleft = 400;
+    t.bar = 275;
+    t.braceright = 400;
+    t.asciitilde = 541;
+    t.exclamdown = 389;
+    t.cent = 500;
+    t.sterling = 500;
+    t.fraction = 167;
+    t.yen = 500;
+    t.florin = 500;
+    t.section = 500;
+    t.currency = 500;
+    t.quotesingle = 214;
+    t.quotedblleft = 556;
+    t.guillemotleft = 500;
+    t.guilsinglleft = 333;
+    t.guilsinglright = 333;
+    t.fi = 500;
+    t.fl = 500;
+    t.endash = 500;
+    t.dagger = 500;
+    t.daggerdbl = 500;
+    t.periodcentered = 250;
+    t.paragraph = 523;
+    t.bullet = 350;
+    t.quotesinglbase = 333;
+    t.quotedblbase = 556;
+    t.quotedblright = 556;
+    t.guillemotright = 500;
+    t.ellipsis = 889;
+    t.perthousand = 1000;
+    t.questiondown = 500;
+    t.grave = 333;
+    t.acute = 333;
+    t.circumflex = 333;
+    t.tilde = 333;
+    t.macron = 333;
+    t.breve = 333;
+    t.dotaccent = 333;
+    t.dieresis = 333;
+    t.ring = 333;
+    t.cedilla = 333;
+    t.hungarumlaut = 333;
+    t.ogonek = 333;
+    t.caron = 333;
+    t.emdash = 889;
+    t.AE = 889;
+    t.ordfeminine = 276;
+    t.Lslash = 556;
+    t.Oslash = 722;
+    t.OE = 944;
+    t.ordmasculine = 310;
+    t.ae = 667;
+    t.dotlessi = 278;
+    t.lslash = 278;
+    t.oslash = 500;
+    t.oe = 667;
+    t.germandbls = 500;
+    t.Idieresis = 333;
+    t.eacute = 444;
+    t.abreve = 500;
+    t.uhungarumlaut = 500;
+    t.ecaron = 444;
+    t.Ydieresis = 556;
+    t.divide = 675;
+    t.Yacute = 556;
+    t.Acircumflex = 611;
+    t.aacute = 500;
+    t.Ucircumflex = 722;
+    t.yacute = 444;
+    t.scommaaccent = 389;
+    t.ecircumflex = 444;
+    t.Uring = 722;
+    t.Udieresis = 722;
+    t.aogonek = 500;
+    t.Uacute = 722;
+    t.uogonek = 500;
+    t.Edieresis = 611;
+    t.Dcroat = 722;
+    t.commaaccent = 250;
+    t.copyright = 760;
+    t.Emacron = 611;
+    t.ccaron = 444;
+    t.aring = 500;
+    t.Ncommaaccent = 667;
+    t.lacute = 278;
+    t.agrave = 500;
+    t.Tcommaaccent = 556;
+    t.Cacute = 667;
+    t.atilde = 500;
+    t.Edotaccent = 611;
+    t.scaron = 389;
+    t.scedilla = 389;
+    t.iacute = 278;
+    t.lozenge = 471;
+    t.Rcaron = 611;
+    t.Gcommaaccent = 722;
+    t.ucircumflex = 500;
+    t.acircumflex = 500;
+    t.Amacron = 611;
+    t.rcaron = 389;
+    t.ccedilla = 444;
+    t.Zdotaccent = 556;
+    t.Thorn = 611;
+    t.Omacron = 722;
+    t.Racute = 611;
+    t.Sacute = 500;
+    t.dcaron = 544;
+    t.Umacron = 722;
+    t.uring = 500;
+    t.threesuperior = 300;
+    t.Ograve = 722;
+    t.Agrave = 611;
+    t.Abreve = 611;
+    t.multiply = 675;
+    t.uacute = 500;
+    t.Tcaron = 556;
+    t.partialdiff = 476;
+    t.ydieresis = 444;
+    t.Nacute = 667;
+    t.icircumflex = 278;
+    t.Ecircumflex = 611;
+    t.adieresis = 500;
+    t.edieresis = 444;
+    t.cacute = 444;
+    t.nacute = 500;
+    t.umacron = 500;
+    t.Ncaron = 667;
+    t.Iacute = 333;
+    t.plusminus = 675;
+    t.brokenbar = 275;
+    t.registered = 760;
+    t.Gbreve = 722;
+    t.Idotaccent = 333;
+    t.summation = 600;
+    t.Egrave = 611;
+    t.racute = 389;
+    t.omacron = 500;
+    t.Zacute = 556;
+    t.Zcaron = 556;
+    t.greaterequal = 549;
+    t.Eth = 722;
+    t.Ccedilla = 667;
+    t.lcommaaccent = 278;
+    t.tcaron = 300;
+    t.eogonek = 444;
+    t.Uogonek = 722;
+    t.Aacute = 611;
+    t.Adieresis = 611;
+    t.egrave = 444;
+    t.zacute = 389;
+    t.iogonek = 278;
+    t.Oacute = 722;
+    t.oacute = 500;
+    t.amacron = 500;
+    t.sacute = 389;
+    t.idieresis = 278;
+    t.Ocircumflex = 722;
+    t.Ugrave = 722;
+    t.Delta = 612;
+    t.thorn = 500;
+    t.twosuperior = 300;
+    t.Odieresis = 722;
+    t.mu = 500;
+    t.igrave = 278;
+    t.ohungarumlaut = 500;
+    t.Eogonek = 611;
+    t.dcroat = 500;
+    t.threequarters = 750;
+    t.Scedilla = 500;
+    t.lcaron = 300;
+    t.Kcommaaccent = 667;
+    t.Lacute = 556;
+    t.trademark = 980;
+    t.edotaccent = 444;
+    t.Igrave = 333;
+    t.Imacron = 333;
+    t.Lcaron = 611;
+    t.onehalf = 750;
+    t.lessequal = 549;
+    t.ocircumflex = 500;
+    t.ntilde = 500;
+    t.Uhungarumlaut = 722;
+    t.Eacute = 611;
+    t.emacron = 444;
+    t.gbreve = 500;
+    t.onequarter = 750;
+    t.Scaron = 500;
+    t.Scommaaccent = 500;
+    t.Ohungarumlaut = 722;
+    t.degree = 400;
+    t.ograve = 500;
+    t.Ccaron = 667;
+    t.ugrave = 500;
+    t.radical = 453;
+    t.Dcaron = 722;
+    t.rcommaaccent = 389;
+    t.Ntilde = 667;
+    t.otilde = 500;
+    t.Rcommaaccent = 611;
+    t.Lcommaaccent = 556;
+    t.Atilde = 611;
+    t.Aogonek = 611;
+    t.Aring = 611;
+    t.Otilde = 722;
+    t.zdotaccent = 389;
+    t.Ecaron = 611;
+    t.Iogonek = 333;
+    t.kcommaaccent = 444;
+    t.minus = 675;
+    t.Icircumflex = 333;
+    t.ncaron = 500;
+    t.tcommaaccent = 278;
+    t.logicalnot = 675;
+    t.odieresis = 500;
+    t.udieresis = 500;
+    t.notequal = 549;
+    t.gcommaaccent = 500;
+    t.eth = 500;
+    t.zcaron = 389;
+    t.ncommaaccent = 500;
+    t.onesuperior = 300;
+    t.imacron = 278;
+    t.Euro = 500;
+  });
+  t.ZapfDingbats = (0, _core_utils.getLookupTableFactory)(function (t) {
+    t.space = 278;
+    t.a1 = 974;
+    t.a2 = 961;
+    t.a202 = 974;
+    t.a3 = 980;
+    t.a4 = 719;
+    t.a5 = 789;
+    t.a119 = 790;
+    t.a118 = 791;
+    t.a117 = 690;
+    t.a11 = 960;
+    t.a12 = 939;
+    t.a13 = 549;
+    t.a14 = 855;
+    t.a15 = 911;
+    t.a16 = 933;
+    t.a105 = 911;
+    t.a17 = 945;
+    t.a18 = 974;
+    t.a19 = 755;
+    t.a20 = 846;
+    t.a21 = 762;
+    t.a22 = 761;
+    t.a23 = 571;
+    t.a24 = 677;
+    t.a25 = 763;
+    t.a26 = 760;
+    t.a27 = 759;
+    t.a28 = 754;
+    t.a6 = 494;
+    t.a7 = 552;
+    t.a8 = 537;
+    t.a9 = 577;
+    t.a10 = 692;
+    t.a29 = 786;
+    t.a30 = 788;
+    t.a31 = 788;
+    t.a32 = 790;
+    t.a33 = 793;
+    t.a34 = 794;
+    t.a35 = 816;
+    t.a36 = 823;
+    t.a37 = 789;
+    t.a38 = 841;
+    t.a39 = 823;
+    t.a40 = 833;
+    t.a41 = 816;
+    t.a42 = 831;
+    t.a43 = 923;
+    t.a44 = 744;
+    t.a45 = 723;
+    t.a46 = 749;
+    t.a47 = 790;
+    t.a48 = 792;
+    t.a49 = 695;
+    t.a50 = 776;
+    t.a51 = 768;
+    t.a52 = 792;
+    t.a53 = 759;
+    t.a54 = 707;
+    t.a55 = 708;
+    t.a56 = 682;
+    t.a57 = 701;
+    t.a58 = 826;
+    t.a59 = 815;
+    t.a60 = 789;
+    t.a61 = 789;
+    t.a62 = 707;
+    t.a63 = 687;
+    t.a64 = 696;
+    t.a65 = 689;
+    t.a66 = 786;
+    t.a67 = 787;
+    t.a68 = 713;
+    t.a69 = 791;
+    t.a70 = 785;
+    t.a71 = 791;
+    t.a72 = 873;
+    t.a73 = 761;
+    t.a74 = 762;
+    t.a203 = 762;
+    t.a75 = 759;
+    t.a204 = 759;
+    t.a76 = 892;
+    t.a77 = 892;
+    t.a78 = 788;
+    t.a79 = 784;
+    t.a81 = 438;
+    t.a82 = 138;
+    t.a83 = 277;
+    t.a84 = 415;
+    t.a97 = 392;
+    t.a98 = 392;
+    t.a99 = 668;
+    t.a100 = 668;
+    t.a89 = 390;
+    t.a90 = 390;
+    t.a93 = 317;
+    t.a94 = 317;
+    t.a91 = 276;
+    t.a92 = 276;
+    t.a205 = 509;
+    t.a85 = 509;
+    t.a206 = 410;
+    t.a86 = 410;
+    t.a87 = 234;
+    t.a88 = 234;
+    t.a95 = 334;
+    t.a96 = 334;
+    t.a101 = 732;
+    t.a102 = 544;
+    t.a103 = 544;
+    t.a104 = 910;
+    t.a106 = 667;
+    t.a107 = 760;
+    t.a108 = 760;
+    t.a112 = 776;
+    t.a111 = 595;
+    t.a110 = 694;
+    t.a109 = 626;
+    t.a120 = 788;
+    t.a121 = 788;
+    t.a122 = 788;
+    t.a123 = 788;
+    t.a124 = 788;
+    t.a125 = 788;
+    t.a126 = 788;
+    t.a127 = 788;
+    t.a128 = 788;
+    t.a129 = 788;
+    t.a130 = 788;
+    t.a131 = 788;
+    t.a132 = 788;
+    t.a133 = 788;
+    t.a134 = 788;
+    t.a135 = 788;
+    t.a136 = 788;
+    t.a137 = 788;
+    t.a138 = 788;
+    t.a139 = 788;
+    t.a140 = 788;
+    t.a141 = 788;
+    t.a142 = 788;
+    t.a143 = 788;
+    t.a144 = 788;
+    t.a145 = 788;
+    t.a146 = 788;
+    t.a147 = 788;
+    t.a148 = 788;
+    t.a149 = 788;
+    t.a150 = 788;
+    t.a151 = 788;
+    t.a152 = 788;
+    t.a153 = 788;
+    t.a154 = 788;
+    t.a155 = 788;
+    t.a156 = 788;
+    t.a157 = 788;
+    t.a158 = 788;
+    t.a159 = 788;
+    t.a160 = 894;
+    t.a161 = 838;
+    t.a163 = 1016;
+    t.a164 = 458;
+    t.a196 = 748;
+    t.a165 = 924;
+    t.a192 = 748;
+    t.a166 = 918;
+    t.a167 = 927;
+    t.a168 = 928;
+    t.a169 = 928;
+    t.a170 = 834;
+    t.a171 = 873;
+    t.a172 = 828;
+    t.a173 = 924;
+    t.a162 = 924;
+    t.a174 = 917;
+    t.a175 = 930;
+    t.a176 = 931;
+    t.a177 = 463;
+    t.a178 = 883;
+    t.a179 = 836;
+    t.a193 = 836;
+    t.a180 = 867;
+    t.a199 = 867;
+    t.a181 = 696;
+    t.a200 = 696;
+    t.a182 = 874;
+    t.a201 = 874;
+    t.a183 = 760;
+    t.a184 = 946;
+    t.a197 = 771;
+    t.a185 = 865;
+    t.a194 = 771;
+    t.a198 = 888;
+    t.a186 = 967;
+    t.a195 = 888;
+    t.a187 = 831;
+    t.a188 = 873;
+    t.a189 = 927;
+    t.a190 = 970;
+    t.a191 = 918;
+  });
+});
+exports.getMetrics = getMetrics;
+
+/***/ }),
+/* 45 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.MurmurHash3_64 = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const SEED = 0xc3d2e1f0;
+const MASK_HIGH = 0xffff0000;
+const MASK_LOW = 0xffff;
+
+class MurmurHash3_64 {
+  constructor(seed) {
+    this.h1 = seed ? seed & 0xffffffff : SEED;
+    this.h2 = seed ? seed & 0xffffffff : SEED;
+  }
+
+  update(input) {
+    let data, length;
+
+    if ((0, _util.isString)(input)) {
+      data = new Uint8Array(input.length * 2);
+      length = 0;
+
+      for (let i = 0, ii = input.length; i < ii; i++) {
+        const code = input.charCodeAt(i);
+
+        if (code <= 0xff) {
+          data[length++] = code;
+        } else {
+          data[length++] = code >>> 8;
+          data[length++] = code & 0xff;
+        }
+      }
+    } else if ((0, _util.isArrayBuffer)(input)) {
+      data = input.slice();
+      length = data.byteLength;
+    } else {
+      throw new Error("Wrong data format in MurmurHash3_64_update. " + "Input must be a string or array.");
+    }
+
+    const blockCounts = length >> 2;
+    const tailLength = length - blockCounts * 4;
+    const dataUint32 = new Uint32Array(data.buffer, 0, blockCounts);
+    let k1 = 0,
+        k2 = 0;
+    let h1 = this.h1,
+        h2 = this.h2;
+    const C1 = 0xcc9e2d51,
+          C2 = 0x1b873593;
+    const C1_LOW = C1 & MASK_LOW,
+          C2_LOW = C2 & MASK_LOW;
+
+    for (let i = 0; i < blockCounts; i++) {
+      if (i & 1) {
+        k1 = dataUint32[i];
+        k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+        h1 ^= k1;
+        h1 = h1 << 13 | h1 >>> 19;
+        h1 = h1 * 5 + 0xe6546b64;
+      } else {
+        k2 = dataUint32[i];
+        k2 = k2 * C1 & MASK_HIGH | k2 * C1_LOW & MASK_LOW;
+        k2 = k2 << 15 | k2 >>> 17;
+        k2 = k2 * C2 & MASK_HIGH | k2 * C2_LOW & MASK_LOW;
+        h2 ^= k2;
+        h2 = h2 << 13 | h2 >>> 19;
+        h2 = h2 * 5 + 0xe6546b64;
+      }
+    }
+
+    k1 = 0;
+
+    switch (tailLength) {
+      case 3:
+        k1 ^= data[blockCounts * 4 + 2] << 16;
+
+      case 2:
+        k1 ^= data[blockCounts * 4 + 1] << 8;
+
+      case 1:
+        k1 ^= data[blockCounts * 4];
+        k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+        k1 = k1 << 15 | k1 >>> 17;
+        k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+
+        if (blockCounts & 1) {
+          h1 ^= k1;
+        } else {
+          h2 ^= k1;
+        }
+
+    }
+
+    this.h1 = h1;
+    this.h2 = h2;
+  }
+
+  hexdigest() {
+    let h1 = this.h1,
+        h2 = this.h2;
+    h1 ^= h2 >>> 1;
+    h1 = h1 * 0xed558ccd & MASK_HIGH | h1 * 0x8ccd & MASK_LOW;
+    h2 = h2 * 0xff51afd7 & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xafd7ed55 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    h1 = h1 * 0x1a85ec53 & MASK_HIGH | h1 * 0xec53 & MASK_LOW;
+    h2 = h2 * 0xc4ceb9fe & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xb9fe1a85 & MASK_HIGH) >>> 16;
+    h1 ^= h2 >>> 1;
+    const hex1 = (h1 >>> 0).toString(16),
+          hex2 = (h2 >>> 0).toString(16);
+    return hex1.padStart(8, "0") + hex2.padStart(8, "0");
+  }
+
+}
+
+exports.MurmurHash3_64 = MurmurHash3_64;
+
+/***/ }),
+/* 46 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFImage = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+var _primitives = __w_pdfjs_require__(5);
+
+var _colorspace = __w_pdfjs_require__(23);
+
+var _stream = __w_pdfjs_require__(12);
+
+var _jpeg_stream = __w_pdfjs_require__(18);
+
+var _jpx = __w_pdfjs_require__(21);
+
+function decodeAndClamp(value, addend, coefficient, max) {
+  value = addend + value * coefficient;
+
+  if (value < 0) {
+    value = 0;
+  } else if (value > max) {
+    value = max;
+  }
+
+  return value;
+}
+
+function resizeImageMask(src, bpc, w1, h1, w2, h2) {
+  var length = w2 * h2;
+  let dest;
+
+  if (bpc <= 8) {
+    dest = new Uint8Array(length);
+  } else if (bpc <= 16) {
+    dest = new Uint16Array(length);
+  } else {
+    dest = new Uint32Array(length);
+  }
+
+  var xRatio = w1 / w2;
+  var yRatio = h1 / h2;
+  var i,
+      j,
+      py,
+      newIndex = 0,
+      oldIndex;
+  var xScaled = new Uint16Array(w2);
+  var w1Scanline = w1;
+
+  for (i = 0; i < w2; i++) {
+    xScaled[i] = Math.floor(i * xRatio);
+  }
+
+  for (i = 0; i < h2; i++) {
+    py = Math.floor(i * yRatio) * w1Scanline;
+
+    for (j = 0; j < w2; j++) {
+      oldIndex = py + xScaled[j];
+      dest[newIndex++] = src[oldIndex];
+    }
+  }
+
+  return dest;
+}
+
+class PDFImage {
+  constructor({
+    xref,
+    res,
+    image,
+    isInline = false,
+    smask = null,
+    mask = null,
+    isMask = false,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    this.image = image;
+    var dict = image.dict;
+    const filter = dict.get("Filter");
+
+    if ((0, _primitives.isName)(filter)) {
+      switch (filter.name) {
+        case "JPXDecode":
+          var jpxImage = new _jpx.JpxImage();
+          jpxImage.parseImageProperties(image.stream);
+          image.stream.reset();
+          image.width = jpxImage.width;
+          image.height = jpxImage.height;
+          image.bitsPerComponent = jpxImage.bitsPerComponent;
+          image.numComps = jpxImage.componentsCount;
+          break;
+
+        case "JBIG2Decode":
+          image.bitsPerComponent = 1;
+          image.numComps = 1;
+          break;
+      }
+    }
+
+    let width = dict.get("Width", "W");
+    let height = dict.get("Height", "H");
+
+    if (Number.isInteger(image.width) && image.width > 0 && Number.isInteger(image.height) && image.height > 0 && (image.width !== width || image.height !== height)) {
+      (0, _util.warn)("PDFImage - using the Width/Height of the image data, " + "rather than the image dictionary.");
+      width = image.width;
+      height = image.height;
+    }
+
+    if (width < 1 || height < 1) {
+      throw new _util.FormatError(`Invalid image width: ${width} or height: ${height}`);
+    }
+
+    this.width = width;
+    this.height = height;
+    this.interpolate = dict.get("Interpolate", "I") || false;
+    this.imageMask = dict.get("ImageMask", "IM") || false;
+    this.matte = dict.get("Matte") || false;
+    var bitsPerComponent = image.bitsPerComponent;
+
+    if (!bitsPerComponent) {
+      bitsPerComponent = dict.get("BitsPerComponent", "BPC");
+
+      if (!bitsPerComponent) {
+        if (this.imageMask) {
+          bitsPerComponent = 1;
+        } else {
+          throw new _util.FormatError(`Bits per component missing in image: ${this.imageMask}`);
+        }
+      }
+    }
+
+    this.bpc = bitsPerComponent;
+
+    if (!this.imageMask) {
+      let colorSpace = dict.getRaw("ColorSpace") || dict.getRaw("CS");
+
+      if (!colorSpace) {
+        (0, _util.info)("JPX images (which do not require color spaces)");
+
+        switch (image.numComps) {
+          case 1:
+            colorSpace = _primitives.Name.get("DeviceGray");
+            break;
+
+          case 3:
+            colorSpace = _primitives.Name.get("DeviceRGB");
+            break;
+
+          case 4:
+            colorSpace = _primitives.Name.get("DeviceCMYK");
+            break;
+
+          default:
+            throw new Error(`JPX images with ${image.numComps} ` + "color components not supported.");
+        }
+      }
+
+      this.colorSpace = _colorspace.ColorSpace.parse({
+        cs: colorSpace,
+        xref,
+        resources: isInline ? res : null,
+        pdfFunctionFactory,
+        localColorSpaceCache
+      });
+      this.numComps = this.colorSpace.numComps;
+    }
+
+    this.decode = dict.getArray("Decode", "D");
+    this.needsDecode = false;
+
+    if (this.decode && (this.colorSpace && !this.colorSpace.isDefaultDecode(this.decode, bitsPerComponent) || isMask && !_colorspace.ColorSpace.isDefaultDecode(this.decode, 1))) {
+      this.needsDecode = true;
+      var max = (1 << bitsPerComponent) - 1;
+      this.decodeCoefficients = [];
+      this.decodeAddends = [];
+      const isIndexed = this.colorSpace && this.colorSpace.name === "Indexed";
+
+      for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) {
+        var dmin = this.decode[i];
+        var dmax = this.decode[i + 1];
+        this.decodeCoefficients[j] = isIndexed ? (dmax - dmin) / max : dmax - dmin;
+        this.decodeAddends[j] = isIndexed ? dmin : max * dmin;
+      }
+    }
+
+    if (smask) {
+      this.smask = new PDFImage({
+        xref,
+        res,
+        image: smask,
+        isInline,
+        pdfFunctionFactory,
+        localColorSpaceCache
+      });
+    } else if (mask) {
+      if ((0, _primitives.isStream)(mask)) {
+        var maskDict = mask.dict,
+            imageMask = maskDict.get("ImageMask", "IM");
+
+        if (!imageMask) {
+          (0, _util.warn)("Ignoring /Mask in image without /ImageMask.");
+        } else {
+          this.mask = new PDFImage({
+            xref,
+            res,
+            image: mask,
+            isInline,
+            isMask: true,
+            pdfFunctionFactory,
+            localColorSpaceCache
+          });
+        }
+      } else {
+        this.mask = mask;
+      }
+    }
+  }
+
+  static async buildImage({
+    xref,
+    res,
+    image,
+    isInline = false,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    const imageData = image;
+    let smaskData = null;
+    let maskData = null;
+    const smask = image.dict.get("SMask");
+    const mask = image.dict.get("Mask");
+
+    if (smask) {
+      smaskData = smask;
+    } else if (mask) {
+      if ((0, _primitives.isStream)(mask) || Array.isArray(mask)) {
+        maskData = mask;
+      } else {
+        (0, _util.warn)("Unsupported mask format.");
+      }
+    }
+
+    return new PDFImage({
+      xref,
+      res,
+      image: imageData,
+      isInline,
+      smask: smaskData,
+      mask: maskData,
+      pdfFunctionFactory,
+      localColorSpaceCache
+    });
+  }
+
+  static createMask({
+    imgArray,
+    width,
+    height,
+    imageIsFromDecodeStream,
+    inverseDecode
+  }) {
+    var computedLength = (width + 7 >> 3) * height;
+    var actualLength = imgArray.byteLength;
+    var haveFullData = computedLength === actualLength;
+    var data, i;
+
+    if (imageIsFromDecodeStream && (!inverseDecode || haveFullData)) {
+      data = imgArray;
+    } else if (!inverseDecode) {
+      data = new Uint8ClampedArray(actualLength);
+      data.set(imgArray);
+    } else {
+      data = new Uint8ClampedArray(computedLength);
+      data.set(imgArray);
+
+      for (i = actualLength; i < computedLength; i++) {
+        data[i] = 0xff;
+      }
+    }
+
+    if (inverseDecode) {
+      for (i = 0; i < actualLength; i++) {
+        data[i] ^= 0xff;
+      }
+    }
+
+    return {
+      data,
+      width,
+      height
+    };
+  }
+
+  get drawWidth() {
+    return Math.max(this.width, this.smask && this.smask.width || 0, this.mask && this.mask.width || 0);
+  }
+
+  get drawHeight() {
+    return Math.max(this.height, this.smask && this.smask.height || 0, this.mask && this.mask.height || 0);
+  }
+
+  decodeBuffer(buffer) {
+    var bpc = this.bpc;
+    var numComps = this.numComps;
+    var decodeAddends = this.decodeAddends;
+    var decodeCoefficients = this.decodeCoefficients;
+    var max = (1 << bpc) - 1;
+    var i, ii;
+
+    if (bpc === 1) {
+      for (i = 0, ii = buffer.length; i < ii; i++) {
+        buffer[i] = +!buffer[i];
+      }
+
+      return;
+    }
+
+    var index = 0;
+
+    for (i = 0, ii = this.width * this.height; i < ii; i++) {
+      for (var j = 0; j < numComps; j++) {
+        buffer[index] = decodeAndClamp(buffer[index], decodeAddends[j], decodeCoefficients[j], max);
+        index++;
+      }
+    }
+  }
+
+  getComponents(buffer) {
+    var bpc = this.bpc;
+
+    if (bpc === 8) {
+      return buffer;
+    }
+
+    var width = this.width;
+    var height = this.height;
+    var numComps = this.numComps;
+    var length = width * height * numComps;
+    var bufferPos = 0;
+    let output;
+
+    if (bpc <= 8) {
+      output = new Uint8Array(length);
+    } else if (bpc <= 16) {
+      output = new Uint16Array(length);
+    } else {
+      output = new Uint32Array(length);
+    }
+
+    var rowComps = width * numComps;
+    var max = (1 << bpc) - 1;
+    var i = 0,
+        ii,
+        buf;
+
+    if (bpc === 1) {
+      var mask, loop1End, loop2End;
+
+      for (var j = 0; j < height; j++) {
+        loop1End = i + (rowComps & ~7);
+        loop2End = i + rowComps;
+
+        while (i < loop1End) {
+          buf = buffer[bufferPos++];
+          output[i] = buf >> 7 & 1;
+          output[i + 1] = buf >> 6 & 1;
+          output[i + 2] = buf >> 5 & 1;
+          output[i + 3] = buf >> 4 & 1;
+          output[i + 4] = buf >> 3 & 1;
+          output[i + 5] = buf >> 2 & 1;
+          output[i + 6] = buf >> 1 & 1;
+          output[i + 7] = buf & 1;
+          i += 8;
+        }
+
+        if (i < loop2End) {
+          buf = buffer[bufferPos++];
+          mask = 128;
+
+          while (i < loop2End) {
+            output[i++] = +!!(buf & mask);
+            mask >>= 1;
+          }
+        }
+      }
+    } else {
+      var bits = 0;
+      buf = 0;
+
+      for (i = 0, ii = length; i < ii; ++i) {
+        if (i % rowComps === 0) {
+          buf = 0;
+          bits = 0;
+        }
+
+        while (bits < bpc) {
+          buf = buf << 8 | buffer[bufferPos++];
+          bits += 8;
+        }
+
+        var remainingBits = bits - bpc;
+        let value = buf >> remainingBits;
+
+        if (value < 0) {
+          value = 0;
+        } else if (value > max) {
+          value = max;
+        }
+
+        output[i] = value;
+        buf = buf & (1 << remainingBits) - 1;
+        bits = remainingBits;
+      }
+    }
+
+    return output;
+  }
+
+  fillOpacity(rgbaBuf, width, height, actualHeight, image) {
+    var smask = this.smask;
+    var mask = this.mask;
+    var alphaBuf, sw, sh, i, ii, j;
+
+    if (smask) {
+      sw = smask.width;
+      sh = smask.height;
+      alphaBuf = new Uint8ClampedArray(sw * sh);
+      smask.fillGrayBuffer(alphaBuf);
+
+      if (sw !== width || sh !== height) {
+        alphaBuf = resizeImageMask(alphaBuf, smask.bpc, sw, sh, width, height);
+      }
+    } else if (mask) {
+      if (mask instanceof PDFImage) {
+        sw = mask.width;
+        sh = mask.height;
+        alphaBuf = new Uint8ClampedArray(sw * sh);
+        mask.numComps = 1;
+        mask.fillGrayBuffer(alphaBuf);
+
+        for (i = 0, ii = sw * sh; i < ii; ++i) {
+          alphaBuf[i] = 255 - alphaBuf[i];
+        }
+
+        if (sw !== width || sh !== height) {
+          alphaBuf = resizeImageMask(alphaBuf, mask.bpc, sw, sh, width, height);
+        }
+      } else if (Array.isArray(mask)) {
+        alphaBuf = new Uint8ClampedArray(width * height);
+        var numComps = this.numComps;
+
+        for (i = 0, ii = width * height; i < ii; ++i) {
+          var opacity = 0;
+          var imageOffset = i * numComps;
+
+          for (j = 0; j < numComps; ++j) {
+            var color = image[imageOffset + j];
+            var maskOffset = j * 2;
+
+            if (color < mask[maskOffset] || color > mask[maskOffset + 1]) {
+              opacity = 255;
+              break;
+            }
+          }
+
+          alphaBuf[i] = opacity;
+        }
+      } else {
+        throw new _util.FormatError("Unknown mask format.");
+      }
+    }
+
+    if (alphaBuf) {
+      for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
+        rgbaBuf[j] = alphaBuf[i];
+      }
+    } else {
+      for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
+        rgbaBuf[j] = 255;
+      }
+    }
+  }
+
+  undoPreblend(buffer, width, height) {
+    var matte = this.smask && this.smask.matte;
+
+    if (!matte) {
+      return;
+    }
+
+    var matteRgb = this.colorSpace.getRgb(matte, 0);
+    var matteR = matteRgb[0];
+    var matteG = matteRgb[1];
+    var matteB = matteRgb[2];
+    var length = width * height * 4;
+
+    for (var i = 0; i < length; i += 4) {
+      var alpha = buffer[i + 3];
+
+      if (alpha === 0) {
+        buffer[i] = 255;
+        buffer[i + 1] = 255;
+        buffer[i + 2] = 255;
+        continue;
+      }
+
+      var k = 255 / alpha;
+      buffer[i] = (buffer[i] - matteR) * k + matteR;
+      buffer[i + 1] = (buffer[i + 1] - matteG) * k + matteG;
+      buffer[i + 2] = (buffer[i + 2] - matteB) * k + matteB;
+    }
+  }
+
+  createImageData(forceRGBA = false) {
+    var drawWidth = this.drawWidth;
+    var drawHeight = this.drawHeight;
+    var imgData = {
+      width: drawWidth,
+      height: drawHeight,
+      kind: 0,
+      data: null
+    };
+    var numComps = this.numComps;
+    var originalWidth = this.width;
+    var originalHeight = this.height;
+    var bpc = this.bpc;
+    var rowBytes = originalWidth * numComps * bpc + 7 >> 3;
+    var imgArray;
+
+    if (!forceRGBA) {
+      var kind;
+
+      if (this.colorSpace.name === "DeviceGray" && bpc === 1) {
+        kind = _util.ImageKind.GRAYSCALE_1BPP;
+      } else if (this.colorSpace.name === "DeviceRGB" && bpc === 8 && !this.needsDecode) {
+        kind = _util.ImageKind.RGB_24BPP;
+      }
+
+      if (kind && !this.smask && !this.mask && drawWidth === originalWidth && drawHeight === originalHeight) {
+        imgData.kind = kind;
+        imgArray = this.getImageBytes(originalHeight * rowBytes);
+
+        if (this.image instanceof _stream.DecodeStream) {
+          imgData.data = imgArray;
+        } else {
+          var newArray = new Uint8ClampedArray(imgArray.length);
+          newArray.set(imgArray);
+          imgData.data = newArray;
+        }
+
+        if (this.needsDecode) {
+          (0, _util.assert)(kind === _util.ImageKind.GRAYSCALE_1BPP, "PDFImage.createImageData: The image must be grayscale.");
+          var buffer = imgData.data;
+
+          for (var i = 0, ii = buffer.length; i < ii; i++) {
+            buffer[i] ^= 0xff;
+          }
+        }
+
+        return imgData;
+      }
+
+      if (this.image instanceof _jpeg_stream.JpegStream && !this.smask && !this.mask) {
+        let imageLength = originalHeight * rowBytes;
+
+        switch (this.colorSpace.name) {
+          case "DeviceGray":
+            imageLength *= 3;
+
+          case "DeviceRGB":
+          case "DeviceCMYK":
+            imgData.kind = _util.ImageKind.RGB_24BPP;
+            imgData.data = this.getImageBytes(imageLength, drawWidth, drawHeight, true);
+            return imgData;
+        }
+      }
+    }
+
+    imgArray = this.getImageBytes(originalHeight * rowBytes);
+    var actualHeight = 0 | imgArray.length / rowBytes * drawHeight / originalHeight;
+    var comps = this.getComponents(imgArray);
+    var alpha01, maybeUndoPreblend;
+
+    if (!forceRGBA && !this.smask && !this.mask) {
+      imgData.kind = _util.ImageKind.RGB_24BPP;
+      imgData.data = new Uint8ClampedArray(drawWidth * drawHeight * 3);
+      alpha01 = 0;
+      maybeUndoPreblend = false;
+    } else {
+      imgData.kind = _util.ImageKind.RGBA_32BPP;
+      imgData.data = new Uint8ClampedArray(drawWidth * drawHeight * 4);
+      alpha01 = 1;
+      maybeUndoPreblend = true;
+      this.fillOpacity(imgData.data, drawWidth, drawHeight, actualHeight, comps);
+    }
+
+    if (this.needsDecode) {
+      this.decodeBuffer(comps);
+    }
+
+    this.colorSpace.fillRgb(imgData.data, originalWidth, originalHeight, drawWidth, drawHeight, actualHeight, bpc, comps, alpha01);
+
+    if (maybeUndoPreblend) {
+      this.undoPreblend(imgData.data, drawWidth, actualHeight);
+    }
+
+    return imgData;
+  }
+
+  fillGrayBuffer(buffer) {
+    var numComps = this.numComps;
+
+    if (numComps !== 1) {
+      throw new _util.FormatError(`Reading gray scale from a color image: ${numComps}`);
+    }
+
+    var width = this.width;
+    var height = this.height;
+    var bpc = this.bpc;
+    var rowBytes = width * numComps * bpc + 7 >> 3;
+    var imgArray = this.getImageBytes(height * rowBytes);
+    var comps = this.getComponents(imgArray);
+    var i, length;
+
+    if (bpc === 1) {
+      length = width * height;
+
+      if (this.needsDecode) {
+        for (i = 0; i < length; ++i) {
+          buffer[i] = comps[i] - 1 & 255;
+        }
+      } else {
+        for (i = 0; i < length; ++i) {
+          buffer[i] = -comps[i] & 255;
+        }
+      }
+
+      return;
+    }
+
+    if (this.needsDecode) {
+      this.decodeBuffer(comps);
+    }
+
+    length = width * height;
+    var scale = 255 / ((1 << bpc) - 1);
+
+    for (i = 0; i < length; ++i) {
+      buffer[i] = scale * comps[i];
+    }
+  }
+
+  getImageBytes(length, drawWidth, drawHeight, forceRGB = false) {
+    this.image.reset();
+    this.image.drawWidth = drawWidth || this.width;
+    this.image.drawHeight = drawHeight || this.height;
+    this.image.forceRGB = !!forceRGB;
+    return this.image.getBytes(length, true);
+  }
+
+}
+
+exports.PDFImage = PDFImage;
+
+/***/ }),
+/* 47 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.MessageHandler = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+const CallbackKind = {
+  UNKNOWN: 0,
+  DATA: 1,
+  ERROR: 2
+};
+const StreamKind = {
+  UNKNOWN: 0,
+  CANCEL: 1,
+  CANCEL_COMPLETE: 2,
+  CLOSE: 3,
+  ENQUEUE: 4,
+  ERROR: 5,
+  PULL: 6,
+  PULL_COMPLETE: 7,
+  START_COMPLETE: 8
+};
+
+function wrapReason(reason) {
+  if (typeof reason !== "object" || reason === null) {
+    return reason;
+  }
+
+  switch (reason.name) {
+    case "AbortException":
+      return new _util.AbortException(reason.message);
+
+    case "MissingPDFException":
+      return new _util.MissingPDFException(reason.message);
+
+    case "UnexpectedResponseException":
+      return new _util.UnexpectedResponseException(reason.message, reason.status);
+
+    case "UnknownErrorException":
+      return new _util.UnknownErrorException(reason.message, reason.details);
+
+    default:
+      return new _util.UnknownErrorException(reason.message, reason.toString());
+  }
+}
+
+class MessageHandler {
+  constructor(sourceName, targetName, comObj) {
+    this.sourceName = sourceName;
+    this.targetName = targetName;
+    this.comObj = comObj;
+    this.callbackId = 1;
+    this.streamId = 1;
+    this.postMessageTransfers = true;
+    this.streamSinks = Object.create(null);
+    this.streamControllers = Object.create(null);
+    this.callbackCapabilities = Object.create(null);
+    this.actionHandler = Object.create(null);
+
+    this._onComObjOnMessage = event => {
+      const data = event.data;
+
+      if (data.targetName !== this.sourceName) {
+        return;
+      }
+
+      if (data.stream) {
+        this._processStreamMessage(data);
+
+        return;
+      }
+
+      if (data.callback) {
+        const callbackId = data.callbackId;
+        const capability = this.callbackCapabilities[callbackId];
+
+        if (!capability) {
+          throw new Error(`Cannot resolve callback ${callbackId}`);
+        }
+
+        delete this.callbackCapabilities[callbackId];
+
+        if (data.callback === CallbackKind.DATA) {
+          capability.resolve(data.data);
+        } else if (data.callback === CallbackKind.ERROR) {
+          capability.reject(wrapReason(data.reason));
+        } else {
+          throw new Error("Unexpected callback case");
+        }
+
+        return;
+      }
+
+      const action = this.actionHandler[data.action];
+
+      if (!action) {
+        throw new Error(`Unknown action from worker: ${data.action}`);
+      }
+
+      if (data.callbackId) {
+        const cbSourceName = this.sourceName;
+        const cbTargetName = data.sourceName;
+        new Promise(function (resolve) {
+          resolve(action(data.data));
+        }).then(function (result) {
+          comObj.postMessage({
+            sourceName: cbSourceName,
+            targetName: cbTargetName,
+            callback: CallbackKind.DATA,
+            callbackId: data.callbackId,
+            data: result
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName: cbSourceName,
+            targetName: cbTargetName,
+            callback: CallbackKind.ERROR,
+            callbackId: data.callbackId,
+            reason: wrapReason(reason)
+          });
+        });
+        return;
+      }
+
+      if (data.streamId) {
+        this._createStreamSink(data);
+
+        return;
+      }
+
+      action(data.data);
+    };
+
+    comObj.addEventListener("message", this._onComObjOnMessage);
+  }
+
+  on(actionName, handler) {
+    const ah = this.actionHandler;
+
+    if (ah[actionName]) {
+      throw new Error(`There is already an actionName called "${actionName}"`);
+    }
+
+    ah[actionName] = handler;
+  }
+
+  send(actionName, data, transfers) {
+    this._postMessage({
+      sourceName: this.sourceName,
+      targetName: this.targetName,
+      action: actionName,
+      data
+    }, transfers);
+  }
+
+  sendWithPromise(actionName, data, transfers) {
+    const callbackId = this.callbackId++;
+    const capability = (0, _util.createPromiseCapability)();
+    this.callbackCapabilities[callbackId] = capability;
+
+    try {
+      this._postMessage({
+        sourceName: this.sourceName,
+        targetName: this.targetName,
+        action: actionName,
+        callbackId,
+        data
+      }, transfers);
+    } catch (ex) {
+      capability.reject(ex);
+    }
+
+    return capability.promise;
+  }
+
+  sendWithStream(actionName, data, queueingStrategy, transfers) {
+    const streamId = this.streamId++;
+    const sourceName = this.sourceName;
+    const targetName = this.targetName;
+    const comObj = this.comObj;
+    return new ReadableStream({
+      start: controller => {
+        const startCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId] = {
+          controller,
+          startCall: startCapability,
+          pullCall: null,
+          cancelCall: null,
+          isClosed: false
+        };
+
+        this._postMessage({
+          sourceName,
+          targetName,
+          action: actionName,
+          streamId,
+          data,
+          desiredSize: controller.desiredSize
+        }, transfers);
+
+        return startCapability.promise;
+      },
+      pull: controller => {
+        const pullCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].pullCall = pullCapability;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.PULL,
+          streamId,
+          desiredSize: controller.desiredSize
+        });
+        return pullCapability.promise;
+      },
+      cancel: reason => {
+        (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason");
+        const cancelCapability = (0, _util.createPromiseCapability)();
+        this.streamControllers[streamId].cancelCall = cancelCapability;
+        this.streamControllers[streamId].isClosed = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.CANCEL,
+          streamId,
+          reason: wrapReason(reason)
+        });
+        return cancelCapability.promise;
+      }
+    }, queueingStrategy);
+  }
+
+  _createStreamSink(data) {
+    const self = this;
+    const action = this.actionHandler[data.action];
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
+    const streamSink = {
+      enqueue(chunk, size = 1, transfers) {
+        if (this.isCancelled) {
+          return;
+        }
+
+        const lastDesiredSize = this.desiredSize;
+        this.desiredSize -= size;
+
+        if (lastDesiredSize > 0 && this.desiredSize <= 0) {
+          this.sinkCapability = (0, _util.createPromiseCapability)();
+          this.ready = this.sinkCapability.promise;
+        }
+
+        self._postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.ENQUEUE,
+          streamId,
+          chunk
+        }, transfers);
+      },
+
+      close() {
+        if (this.isCancelled) {
+          return;
+        }
+
+        this.isCancelled = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.CLOSE,
+          streamId
+        });
+        delete self.streamSinks[streamId];
+      },
+
+      error(reason) {
+        (0, _util.assert)(reason instanceof Error, "error must have a valid reason");
+
+        if (this.isCancelled) {
+          return;
+        }
+
+        this.isCancelled = true;
+        comObj.postMessage({
+          sourceName,
+          targetName,
+          stream: StreamKind.ERROR,
+          streamId,
+          reason: wrapReason(reason)
+        });
+      },
+
+      sinkCapability: (0, _util.createPromiseCapability)(),
+      onPull: null,
+      onCancel: null,
+      isCancelled: false,
+      desiredSize: data.desiredSize,
+      ready: null
+    };
+    streamSink.sinkCapability.resolve();
+    streamSink.ready = streamSink.sinkCapability.promise;
+    this.streamSinks[streamId] = streamSink;
+    new Promise(function (resolve) {
+      resolve(action(data.data, streamSink));
+    }).then(function () {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        success: true
+      });
+    }, function (reason) {
+      comObj.postMessage({
+        sourceName,
+        targetName,
+        stream: StreamKind.START_COMPLETE,
+        streamId,
+        reason: wrapReason(reason)
+      });
+    });
+  }
+
+  _processStreamMessage(data) {
+    const streamId = data.streamId;
+    const sourceName = this.sourceName;
+    const targetName = data.sourceName;
+    const comObj = this.comObj;
+
+    switch (data.stream) {
+      case StreamKind.START_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].startCall.resolve();
+        } else {
+          this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
+        }
+
+        break;
+
+      case StreamKind.PULL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].pullCall.resolve();
+        } else {
+          this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
+        }
+
+        break;
+
+      case StreamKind.PULL:
+        if (!this.streamSinks[streamId]) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            success: true
+          });
+          break;
+        }
+
+        if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
+          this.streamSinks[streamId].sinkCapability.resolve();
+        }
+
+        this.streamSinks[streamId].desiredSize = data.desiredSize;
+        const {
+          onPull
+        } = this.streamSinks[data.streamId];
+        new Promise(function (resolve) {
+          resolve(onPull && onPull());
+        }).then(function () {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            success: true
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.PULL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        });
+        break;
+
+      case StreamKind.ENQUEUE:
+        (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
+
+        if (this.streamControllers[streamId].isClosed) {
+          break;
+        }
+
+        this.streamControllers[streamId].controller.enqueue(data.chunk);
+        break;
+
+      case StreamKind.CLOSE:
+        (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
+
+        if (this.streamControllers[streamId].isClosed) {
+          break;
+        }
+
+        this.streamControllers[streamId].isClosed = true;
+        this.streamControllers[streamId].controller.close();
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.ERROR:
+        (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
+        this.streamControllers[streamId].controller.error(wrapReason(data.reason));
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.CANCEL_COMPLETE:
+        if (data.success) {
+          this.streamControllers[streamId].cancelCall.resolve();
+        } else {
+          this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
+        }
+
+        this._deleteStreamController(streamId);
+
+        break;
+
+      case StreamKind.CANCEL:
+        if (!this.streamSinks[streamId]) {
+          break;
+        }
+
+        const {
+          onCancel
+        } = this.streamSinks[data.streamId];
+        new Promise(function (resolve) {
+          resolve(onCancel && onCancel(wrapReason(data.reason)));
+        }).then(function () {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            success: true
+          });
+        }, function (reason) {
+          comObj.postMessage({
+            sourceName,
+            targetName,
+            stream: StreamKind.CANCEL_COMPLETE,
+            streamId,
+            reason: wrapReason(reason)
+          });
+        });
+        this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
+        this.streamSinks[streamId].isCancelled = true;
+        delete this.streamSinks[streamId];
+        break;
+
+      default:
+        throw new Error("Unexpected stream case");
+    }
+  }
+
+  async _deleteStreamController(streamId) {
+    await Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
+      return capability && capability.promise;
+    }));
+    delete this.streamControllers[streamId];
+  }
+
+  _postMessage(message, transfers) {
+    if (transfers && this.postMessageTransfers) {
+      this.comObj.postMessage(message, transfers);
+    } else {
+      this.comObj.postMessage(message);
+    }
+  }
+
+  destroy() {
+    this.comObj.removeEventListener("message", this._onComObjOnMessage);
+  }
+
+}
+
+exports.MessageHandler = MessageHandler;
+
+/***/ }),
+/* 48 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFWorkerStream = void 0;
+
+var _util = __w_pdfjs_require__(2);
+
+class PDFWorkerStream {
+  constructor(msgHandler) {
+    this._msgHandler = msgHandler;
+    this._contentLength = null;
+    this._fullRequestReader = null;
+    this._rangeRequestReaders = [];
+  }
+
+  getFullReader() {
+    (0, _util.assert)(!this._fullRequestReader, "PDFWorkerStream.getFullReader can only be called once.");
+    this._fullRequestReader = new PDFWorkerStreamReader(this._msgHandler);
+    return this._fullRequestReader;
+  }
+
+  getRangeReader(begin, end) {
+    const reader = new PDFWorkerStreamRangeReader(begin, end, this._msgHandler);
+
+    this._rangeRequestReaders.push(reader);
+
+    return reader;
+  }
+
+  cancelAllRequests(reason) {
+    if (this._fullRequestReader) {
+      this._fullRequestReader.cancel(reason);
+    }
+
+    const readers = this._rangeRequestReaders.slice(0);
+
+    readers.forEach(function (reader) {
+      reader.cancel(reason);
+    });
+  }
+
+}
+
+exports.PDFWorkerStream = PDFWorkerStream;
+
+class PDFWorkerStreamReader {
+  constructor(msgHandler) {
+    this._msgHandler = msgHandler;
+    this.onProgress = null;
+    this._contentLength = null;
+    this._isRangeSupported = false;
+    this._isStreamingSupported = false;
+
+    const readableStream = this._msgHandler.sendWithStream("GetReader");
+
+    this._reader = readableStream.getReader();
+    this._headersReady = this._msgHandler.sendWithPromise("ReaderHeadersReady").then(data => {
+      this._isStreamingSupported = data.isStreamingSupported;
+      this._isRangeSupported = data.isRangeSupported;
+      this._contentLength = data.contentLength;
+    });
+  }
+
+  get headersReady() {
+    return this._headersReady;
+  }
+
+  get contentLength() {
+    return this._contentLength;
+  }
+
+  get isStreamingSupported() {
+    return this._isStreamingSupported;
+  }
+
+  get isRangeSupported() {
+    return this._isRangeSupported;
+  }
+
+  async read() {
+    const {
+      value,
+      done
+    } = await this._reader.read();
+
+    if (done) {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
+
+    return {
+      value: value.buffer,
+      done: false
+    };
+  }
+
+  cancel(reason) {
+    this._reader.cancel(reason);
+  }
+
+}
+
+class PDFWorkerStreamRangeReader {
+  constructor(begin, end, msgHandler) {
+    this._msgHandler = msgHandler;
+    this.onProgress = null;
+
+    const readableStream = this._msgHandler.sendWithStream("GetRangeReader", {
+      begin,
+      end
+    });
+
+    this._reader = readableStream.getReader();
+  }
+
+  get isStreamingSupported() {
+    return false;
+  }
+
+  async read() {
+    const {
+      value,
+      done
+    } = await this._reader.read();
+
+    if (done) {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
+
+    return {
+      value: value.buffer,
+      done: false
+    };
+  }
+
+  cancel(reason) {
+    this._reader.cancel(reason);
+  }
+
+}
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __w_pdfjs_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	// module exports must be returned from runtime so entry inlining is disabled
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	return __w_pdfjs_require__(0);
+/******/ })()
+;
+});
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-EUC-H.bcmap
new file mode 100644
index 0000000000..2655fc70ae
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-EUC-V.bcmap
new file mode 100644
index 0000000000..f1ed853828
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-H.bcmap
new file mode 100644
index 0000000000..39e89d3339
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap
new file mode 100644
index 0000000000..e4167cb51f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap
new file mode 100644
index 0000000000..50b1646e94
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78-V.bcmap
new file mode 100644
index 0000000000..d7af99b5e2
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap
new file mode 100644
index 0000000000..37077d01e2
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap
new file mode 100644
index 0000000000..acf23231ae
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap
new file mode 100644
index 0000000000..2359bc529d
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap
new file mode 100644
index 0000000000..af8293829c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap
new file mode 100644
index 0000000000..780549de19
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap
new file mode 100644
index 0000000000..bfd3119c62
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap
new file mode 100644
index 0000000000..25ef14ab4a
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap
new file mode 100644
index 0000000000..02f713bb83
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap
new file mode 100644
index 0000000000..d08e0cc5d9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Add-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Add-H.bcmap
new file mode 100644
index 0000000000..59442acafb
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Add-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap
new file mode 100644
index 0000000000..a3065e441a
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap
new file mode 100644
index 0000000000..040014cfc0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Add-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Add-V.bcmap
new file mode 100644
index 0000000000..2f816d320f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Add-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap
new file mode 100644
index 0000000000..88ec04af49
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap
new file mode 100644
index 0000000000..03a501477c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap
new file mode 100644
index 0000000000..2aa95141f9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap
new file mode 100644
index 0000000000..86d8b8c79c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap
new file mode 100644
index 0000000000..f50fc6c14e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap
new file mode 100644
index 0000000000..6caf4a8314
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap
new file mode 100644
index 0000000000..b77fb0705c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap
new file mode 100644
index 0000000000..69d79a2c2c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap
new file mode 100644
index 0000000000..36101083fa
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap
new file mode 100644
index 0000000000..707bb1065c
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap
new file mode 100644
index 0000000000..f7648cc3ff
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap
new file mode 100644
index 0000000000..852145890e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap
new file mode 100644
index 0000000000..e40c63ab1e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap
new file mode 100644
index 0000000000..d7623b5002
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap
new file mode 100644
index 0000000000..7586525936
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap
new file mode 100644
index 0000000000..f0e94ec196
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap
new file mode 100644
index 0000000000..dad42c5ad7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap
new file mode 100644
index 0000000000..090819a064
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap
new file mode 100644
index 0000000000..087dfc1558
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap
new file mode 100644
index 0000000000..46aa9bffe5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap
new file mode 100644
index 0000000000..5b4b65cc62
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap
new file mode 100644
index 0000000000..e77d699ab6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap
new file mode 100644
index 0000000000..128a141077
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap
new file mode 100644
index 0000000000..cef1a99851
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap
new file mode 100644
index 0000000000..11ffa36df8
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap
new file mode 100644
index 0000000000..3172308c79
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap
new file mode 100644
index 0000000000..f3371c0cbd
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/B5-H.bcmap
new file mode 100644
index 0000000000..beb4d22810
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/B5-V.bcmap
new file mode 100644
index 0000000000..2d4f87d503
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/B5pc-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/B5pc-H.bcmap
new file mode 100644
index 0000000000..ce0013167f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/B5pc-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/B5pc-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/B5pc-V.bcmap
new file mode 100644
index 0000000000..73b99ff2fb
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/B5pc-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap
new file mode 100644
index 0000000000..61d1d0cb00
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap
new file mode 100644
index 0000000000..1a393a51e0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS1-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS1-H.bcmap
new file mode 100644
index 0000000000..f738e218ae
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS1-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS1-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS1-V.bcmap
new file mode 100644
index 0000000000..9c3169f0d9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS1-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS2-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS2-H.bcmap
new file mode 100644
index 0000000000..c89b3527fe
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS2-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/CNS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/CNS2-V.bcmap
new file mode 100644
index 0000000000..7588cec83e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/CNS2-V.bcmap
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEáCNS2-H
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap
new file mode 100644
index 0000000000..cb29415de4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap
new file mode 100644
index 0000000000..f09aec6318
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-H.bcmap
new file mode 100644
index 0000000000..c2d77462d2
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-V.bcmap
new file mode 100644
index 0000000000..89bff159ec
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETen-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap
new file mode 100644
index 0000000000..a7d69db5e3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEá	ETen-B5-H`
 ^

\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap
new file mode 100644
index 0000000000..adc5d618d6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/EUC-H.bcmap
new file mode 100644
index 0000000000..e92ea5b3b9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/EUC-V.bcmap
new file mode 100644
index 0000000000..7a7c183228
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Ext-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Ext-H.bcmap
new file mode 100644
index 0000000000..3b5cde44db
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Ext-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap
new file mode 100644
index 0000000000..ea4d2d97b8
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap
new file mode 100644
index 0000000000..3457c27709
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Ext-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Ext-V.bcmap
new file mode 100644
index 0000000000..4999ca4041
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Ext-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-H.bcmap
new file mode 100644
index 0000000000..e39908b984
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-V.bcmap
new file mode 100644
index 0000000000..d5be5446aa
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GB-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GB-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GB-H.bcmap
new file mode 100644
index 0000000000..39189c54e3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GB-H.bcmap
@@ -0,0 +1,4 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSE

!!�º]aX!!]`�21�>	�p�z�$]‚�"R‚d�-Uƒ7�*„
4„%�+ „Z „{�/…%…<�9K…b�1]†.�"‡‰`]‡,�"]ˆ
+�"]ˆh�"]‰F�"]Š$�"]‹�"]‹`�"]Œ>�"]��"]�z�"]ŽX�"]�6�"]��"]�r�"]‘P�"]’.�"]“�"]“j�"]”H�"]•&�"]–�"]–b�"]—@�"]˜�"]˜|�"]™Z�"]š8�"]›�"]›t�"]œR�"]�0�"]ž�"]žl�"]ŸJ�"] (�"]¡�"]¡d�"]¢B�"]£ �"X£~�']¤W�"]¥5�"]¦�"]¦q�"]§O�"]¨-�"]©�"]©i�"]ªG�"]«%�"]¬�"]¬a�"]­?�"]®�"]®{�"]¯Y�"]°7�"]±�"]±s�"]²Q�"]³/�"]´
�"]´k�"]µI�"]¶'�"]·�"]·c�"]¸A�"]¹�"]¹}�"]º[�"]»9
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GB-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GB-V.bcmap
new file mode 100644
index 0000000000..310834512f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GB-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap
new file mode 100644
index 0000000000..05fff7e825
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap
new file mode 100644
index 0000000000..0cdf6bed6d
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBK2K-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBK2K-H.bcmap
new file mode 100644
index 0000000000..46f6ba5967
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBK2K-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBK2K-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBK2K-V.bcmap
new file mode 100644
index 0000000000..d9a9479843
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBK2K-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap
new file mode 100644
index 0000000000..5cb0af687e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap
new file mode 100644
index 0000000000..bca93b8efb
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap
new file mode 100644
index 0000000000..4b4e2d3229
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap
new file mode 100644
index 0000000000..38f706699f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBT-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBT-H.bcmap
new file mode 100644
index 0000000000..8437ac3377
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBT-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBT-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBT-V.bcmap
new file mode 100644
index 0000000000..697ab4a8e7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBT-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap
new file mode 100644
index 0000000000..f6e50e8936
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap
new file mode 100644
index 0000000000..6c0d71a2d0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap
new file mode 100644
index 0000000000..c9edf67cf6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap
new file mode 100644
index 0000000000..31450c97f6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/H.bcmap
new file mode 100644
index 0000000000..7b24ea4629
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap
new file mode 100644
index 0000000000..7d30c05005
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap
new file mode 100644
index 0000000000..78946940d6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap
new file mode 100644
index 0000000000..d829a23101
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap
new file mode 100644
index 0000000000..2b572b50a4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap
new file mode 100644
index 0000000000..971a4f23f7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap
new file mode 100644
index 0000000000..d353ca256b
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap
new file mode 100644
index 0000000000..576dc01112
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap
new file mode 100644
index 0000000000..0e96d0e228
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap
new file mode 100644
index 0000000000..11d170c75e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap
new file mode 100644
index 0000000000..54959bf9e7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap
new file mode 100644
index 0000000000..6ef7857ad1
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap
new file mode 100644
index 0000000000..1fb2fa2a2e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Hankaku.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Hankaku.bcmap
new file mode 100644
index 0000000000..4b8ec7fcef
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Hankaku.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Hiragana.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Hiragana.bcmap
new file mode 100644
index 0000000000..17e983e772
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Hiragana.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap
new file mode 100644
index 0000000000..a45c65f008
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap
new file mode 100644
index 0000000000..0e7b21f0a6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-H.bcmap
new file mode 100644
index 0000000000..b9b22b6787
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap
new file mode 100644
index 0000000000..2531ffcf41
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap
new file mode 100644
index 0000000000..367ceb226a
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSC-V.bcmap
new file mode 100644
index 0000000000..6ae2f0b6b7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap
new file mode 100644
index 0000000000..a8d4240e6a
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap
new file mode 100644
index 0000000000..8b4ae18fd3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap
new file mode 100644
index 0000000000..b655dbcfb1
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap
new file mode 100644
index 0000000000..21f97f65b4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap
new file mode 100644
index 0000000000..e06f361eb6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap
new file mode 100644
index 0000000000..f3c9113fcf
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Katakana.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Katakana.bcmap
new file mode 100644
index 0000000000..524303c4f0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Katakana.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/LICENSE b/toolkit/components/pdfjs/content/web/cmaps/LICENSE
new file mode 100644
index 0000000000..b1ad168ad0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/LICENSE
@@ -0,0 +1,36 @@
+%%Copyright: -----------------------------------------------------------
+%%Copyright: Copyright 1990-2009 Adobe Systems Incorporated.
+%%Copyright: All rights reserved.
+%%Copyright:
+%%Copyright: Redistribution and use in source and binary forms, with or
+%%Copyright: without modification, are permitted provided that the
+%%Copyright: following conditions are met:
+%%Copyright:
+%%Copyright: Redistributions of source code must retain the above
+%%Copyright: copyright notice, this list of conditions and the following
+%%Copyright: disclaimer.
+%%Copyright:
+%%Copyright: Redistributions in binary form must reproduce the above
+%%Copyright: copyright notice, this list of conditions and the following
+%%Copyright: disclaimer in the documentation and/or other materials
+%%Copyright: provided with the distribution. 
+%%Copyright:
+%%Copyright: Neither the name of Adobe Systems Incorporated nor the names
+%%Copyright: of its contributors may be used to endorse or promote
+%%Copyright: products derived from this software without specific prior
+%%Copyright: written permission. 
+%%Copyright:
+%%Copyright: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+%%Copyright: CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+%%Copyright: INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%%Copyright: MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+%%Copyright: DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+%%Copyright: CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+%%Copyright: SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+%%Copyright: NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%%Copyright: LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+%%Copyright: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+%%Copyright: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+%%Copyright: OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%%Copyright: SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+%%Copyright: -----------------------------------------------------------
diff --git a/toolkit/components/pdfjs/content/web/cmaps/NWP-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/NWP-H.bcmap
new file mode 100644
index 0000000000..afc5e4b05e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/NWP-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/NWP-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/NWP-V.bcmap
new file mode 100644
index 0000000000..bb5785e327
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/NWP-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/RKSJ-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/RKSJ-H.bcmap
new file mode 100644
index 0000000000..fb8d298e9b
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/RKSJ-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/RKSJ-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/RKSJ-V.bcmap
new file mode 100644
index 0000000000..a2555a6c04
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/RKSJ-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/Roman.bcmap b/toolkit/components/pdfjs/content/web/cmaps/Roman.bcmap
new file mode 100644
index 0000000000..f896dcf1c7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/Roman.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap
new file mode 100644
index 0000000000..d5db27c5cf
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap
new file mode 100644
index 0000000000..1dc9b7a21b
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap
new file mode 100644
index 0000000000..961afefb66
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap
new file mode 100644
index 0000000000..df0cffe86b
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap
new file mode 100644
index 0000000000..1ab18a1436
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap
new file mode 100644
index 0000000000..ad14662e25
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap
new file mode 100644
index 0000000000..83c6bd7c4f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap
new file mode 100644
index 0000000000..22a27e4ddb
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap
new file mode 100644
index 0000000000..5bd6228ce6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap
new file mode 100644
index 0000000000..53c534b7fe
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap
new file mode 100644
index 0000000000..b95045b400
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap
new file mode 100644
index 0000000000..51f023e0d6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap
new file mode 100644
index 0000000000..f0dbd14f37
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap
new file mode 100644
index 0000000000..ce9c30a985
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap
new file mode 100644
index 0000000000..982ca462b1
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap
new file mode 100644
index 0000000000..f78020dd40
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap
new file mode 100644
index 0000000000..7daf56afab
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap
new file mode 100644
index 0000000000..ac9975c585
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap
new file mode 100644
index 0000000000..3da0a1c62f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap
new file mode 100644
index 0000000000..c50b9ddfde
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap
new file mode 100644
index 0000000000..6761344639
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap
new file mode 100644
index 0000000000..70bf90c0ef
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap
new file mode 100644
index 0000000000..7a83d53ae7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap
new file mode 100644
index 0000000000..7a87135394
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap
new file mode 100644
index 0000000000..9f0334cac7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap
new file mode 100644
index 0000000000..808a94f0fd
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap
new file mode 100644
index 0000000000..d768bf811f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap
new file mode 100644
index 0000000000..3d5bf6fb4e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap
new file mode 100644
index 0000000000..09eee10d4f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap
new file mode 100644
index 0000000000..6c54600133
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap
new file mode 100644
index 0000000000..1b1a64f50d
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap
new file mode 100644
index 0000000000..994aa9ef9f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap
new file mode 100644
index 0000000000..643f921b65
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap
new file mode 100644
index 0000000000..c148f67f5e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap
new file mode 100644
index 0000000000..1849d809a6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap
new file mode 100644
index 0000000000..a83a677c56
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap
new file mode 100644
index 0000000000..f527248ad5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap
new file mode 100644
index 0000000000..e1a988dc9e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap
new file mode 100644
index 0000000000..47e054a961
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap
new file mode 100644
index 0000000000..b5b94852a5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap
new file mode 100644
index 0000000000..026adcaad4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap
new file mode 100644
index 0000000000..fd4e66e81f
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap
new file mode 100644
index 0000000000..075efb7054
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap
new file mode 100644
index 0000000000..769d2142c0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap
new file mode 100644
index 0000000000..bdab208b69
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap
new file mode 100644
index 0000000000..6ff8674af7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap
new file mode 100644
index 0000000000..8dfa76a58e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/V.bcmap b/toolkit/components/pdfjs/content/web/cmaps/V.bcmap
new file mode 100644
index 0000000000..fdec990662
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/V.bcmap
diff --git a/toolkit/components/pdfjs/content/web/cmaps/WP-Symbol.bcmap b/toolkit/components/pdfjs/content/web/cmaps/WP-Symbol.bcmap
new file mode 100644
index 0000000000..46729bbf30
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/cmaps/WP-Symbol.bcmap
diff --git a/toolkit/components/pdfjs/content/web/debugger.js b/toolkit/components/pdfjs/content/web/debugger.js
new file mode 100644
index 0000000000..c79aeeecf9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/debugger.js
@@ -0,0 +1,623 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable no-var */
+
+"use strict";
+
+var FontInspector = (function FontInspectorClosure() {
+  var fonts;
+  var active = false;
+  var fontAttribute = "data-font-name";
+  function removeSelection() {
+    const divs = document.querySelectorAll(`span[${fontAttribute}]`);
+    for (const div of divs) {
+      div.className = "";
+    }
+  }
+  function resetSelection() {
+    const divs = document.querySelectorAll(`span[${fontAttribute}]`);
+    for (const div of divs) {
+      div.className = "debuggerHideText";
+    }
+  }
+  function selectFont(fontName, show) {
+    const divs = document.querySelectorAll(
+      `span[${fontAttribute}=${fontName}]`
+    );
+    for (const div of divs) {
+      div.className = show ? "debuggerShowText" : "debuggerHideText";
+    }
+  }
+  function textLayerClick(e) {
+    if (
+      !e.target.dataset.fontName ||
+      e.target.tagName.toUpperCase() !== "SPAN"
+    ) {
+      return;
+    }
+    var fontName = e.target.dataset.fontName;
+    var selects = document.getElementsByTagName("input");
+    for (var i = 0; i < selects.length; ++i) {
+      var select = selects[i];
+      if (select.dataset.fontName !== fontName) {
+        continue;
+      }
+      select.checked = !select.checked;
+      selectFont(fontName, select.checked);
+      select.scrollIntoView();
+    }
+  }
+  return {
+    // Properties/functions needed by PDFBug.
+    id: "FontInspector",
+    name: "Font Inspector",
+    panel: null,
+    manager: null,
+    init: function init(pdfjsLib) {
+      var panel = this.panel;
+      var tmp = document.createElement("button");
+      tmp.addEventListener("click", resetSelection);
+      tmp.textContent = "Refresh";
+      panel.appendChild(tmp);
+
+      fonts = document.createElement("div");
+      panel.appendChild(fonts);
+    },
+    cleanup: function cleanup() {
+      fonts.textContent = "";
+    },
+    enabled: false,
+    get active() {
+      return active;
+    },
+    set active(value) {
+      active = value;
+      if (active) {
+        document.body.addEventListener("click", textLayerClick, true);
+        resetSelection();
+      } else {
+        document.body.removeEventListener("click", textLayerClick, true);
+        removeSelection();
+      }
+    },
+    // FontInspector specific functions.
+    fontAdded: function fontAdded(fontObj, url) {
+      function properties(obj, list) {
+        var moreInfo = document.createElement("table");
+        for (var i = 0; i < list.length; i++) {
+          var tr = document.createElement("tr");
+          var td1 = document.createElement("td");
+          td1.textContent = list[i];
+          tr.appendChild(td1);
+          var td2 = document.createElement("td");
+          td2.textContent = obj[list[i]].toString();
+          tr.appendChild(td2);
+          moreInfo.appendChild(tr);
+        }
+        return moreInfo;
+      }
+      var moreInfo = properties(fontObj, ["name", "type"]);
+      const fontName = fontObj.loadedName;
+      var font = document.createElement("div");
+      var name = document.createElement("span");
+      name.textContent = fontName;
+      var download = document.createElement("a");
+      if (url) {
+        url = /url\(['"]?([^)"']+)/.exec(url);
+        download.href = url[1];
+      } else if (fontObj.data) {
+        download.href = URL.createObjectURL(
+          new Blob([fontObj.data], { type: fontObj.mimeType })
+        );
+      }
+      download.textContent = "Download";
+      var logIt = document.createElement("a");
+      logIt.href = "";
+      logIt.textContent = "Log";
+      logIt.addEventListener("click", function (event) {
+        event.preventDefault();
+        console.log(fontObj);
+      });
+      const select = document.createElement("input");
+      select.setAttribute("type", "checkbox");
+      select.dataset.fontName = fontName;
+      select.addEventListener("click", function () {
+        selectFont(fontName, select.checked);
+      });
+      font.appendChild(select);
+      font.appendChild(name);
+      font.appendChild(document.createTextNode(" "));
+      font.appendChild(download);
+      font.appendChild(document.createTextNode(" "));
+      font.appendChild(logIt);
+      font.appendChild(moreInfo);
+      fonts.appendChild(font);
+      // Somewhat of a hack, should probably add a hook for when the text layer
+      // is done rendering.
+      setTimeout(() => {
+        if (this.active) {
+          resetSelection();
+        }
+      }, 2000);
+    },
+  };
+})();
+
+var opMap;
+
+// Manages all the page steppers.
+var StepperManager = (function StepperManagerClosure() {
+  var steppers = [];
+  var stepperDiv = null;
+  var stepperControls = null;
+  var stepperChooser = null;
+  var breakPoints = Object.create(null);
+  return {
+    // Properties/functions needed by PDFBug.
+    id: "Stepper",
+    name: "Stepper",
+    panel: null,
+    manager: null,
+    init: function init(pdfjsLib) {
+      var self = this;
+      stepperControls = document.createElement("div");
+      stepperChooser = document.createElement("select");
+      stepperChooser.addEventListener("change", function (event) {
+        self.selectStepper(this.value);
+      });
+      stepperControls.appendChild(stepperChooser);
+      stepperDiv = document.createElement("div");
+      this.panel.appendChild(stepperControls);
+      this.panel.appendChild(stepperDiv);
+      if (sessionStorage.getItem("pdfjsBreakPoints")) {
+        breakPoints = JSON.parse(sessionStorage.getItem("pdfjsBreakPoints"));
+      }
+
+      opMap = Object.create(null);
+      for (var key in pdfjsLib.OPS) {
+        opMap[pdfjsLib.OPS[key]] = key;
+      }
+    },
+    cleanup: function cleanup() {
+      stepperChooser.textContent = "";
+      stepperDiv.textContent = "";
+      steppers = [];
+    },
+    enabled: false,
+    active: false,
+    // Stepper specific functions.
+    create: function create(pageIndex) {
+      var debug = document.createElement("div");
+      debug.id = "stepper" + pageIndex;
+      debug.setAttribute("hidden", true);
+      debug.className = "stepper";
+      stepperDiv.appendChild(debug);
+      var b = document.createElement("option");
+      b.textContent = "Page " + (pageIndex + 1);
+      b.value = pageIndex;
+      stepperChooser.appendChild(b);
+      var initBreakPoints = breakPoints[pageIndex] || [];
+      var stepper = new Stepper(debug, pageIndex, initBreakPoints);
+      steppers.push(stepper);
+      if (steppers.length === 1) {
+        this.selectStepper(pageIndex, false);
+      }
+      return stepper;
+    },
+    selectStepper: function selectStepper(pageIndex, selectPanel) {
+      var i;
+      pageIndex = pageIndex | 0;
+      if (selectPanel) {
+        this.manager.selectPanel(this);
+      }
+      for (i = 0; i < steppers.length; ++i) {
+        var stepper = steppers[i];
+        if (stepper.pageIndex === pageIndex) {
+          stepper.panel.removeAttribute("hidden");
+        } else {
+          stepper.panel.setAttribute("hidden", true);
+        }
+      }
+      var options = stepperChooser.options;
+      for (i = 0; i < options.length; ++i) {
+        var option = options[i];
+        option.selected = (option.value | 0) === pageIndex;
+      }
+    },
+    saveBreakPoints: function saveBreakPoints(pageIndex, bps) {
+      breakPoints[pageIndex] = bps;
+      sessionStorage.setItem("pdfjsBreakPoints", JSON.stringify(breakPoints));
+    },
+  };
+})();
+
+// The stepper for each page's IRQueue.
+var Stepper = (function StepperClosure() {
+  // Shorter way to create element and optionally set textContent.
+  function c(tag, textContent) {
+    var d = document.createElement(tag);
+    if (textContent) {
+      d.textContent = textContent;
+    }
+    return d;
+  }
+
+  function simplifyArgs(args) {
+    if (typeof args === "string") {
+      var MAX_STRING_LENGTH = 75;
+      return args.length <= MAX_STRING_LENGTH
+        ? args
+        : args.substring(0, MAX_STRING_LENGTH) + "...";
+    }
+    if (typeof args !== "object" || args === null) {
+      return args;
+    }
+    if ("length" in args) {
+      // array
+      var simpleArgs = [],
+        i,
+        ii;
+      var MAX_ITEMS = 10;
+      for (i = 0, ii = Math.min(MAX_ITEMS, args.length); i < ii; i++) {
+        simpleArgs.push(simplifyArgs(args[i]));
+      }
+      if (i < args.length) {
+        simpleArgs.push("...");
+      }
+      return simpleArgs;
+    }
+    var simpleObj = {};
+    for (var key in args) {
+      simpleObj[key] = simplifyArgs(args[key]);
+    }
+    return simpleObj;
+  }
+
+  // eslint-disable-next-line no-shadow
+  function Stepper(panel, pageIndex, initialBreakPoints) {
+    this.panel = panel;
+    this.breakPoint = 0;
+    this.nextBreakPoint = null;
+    this.pageIndex = pageIndex;
+    this.breakPoints = initialBreakPoints;
+    this.currentIdx = -1;
+    this.operatorListIdx = 0;
+  }
+  Stepper.prototype = {
+    init: function init(operatorList) {
+      var panel = this.panel;
+      var content = c("div", "c=continue, s=step");
+      var table = c("table");
+      content.appendChild(table);
+      table.cellSpacing = 0;
+      var headerRow = c("tr");
+      table.appendChild(headerRow);
+      headerRow.appendChild(c("th", "Break"));
+      headerRow.appendChild(c("th", "Idx"));
+      headerRow.appendChild(c("th", "fn"));
+      headerRow.appendChild(c("th", "args"));
+      panel.appendChild(content);
+      this.table = table;
+      this.updateOperatorList(operatorList);
+    },
+    updateOperatorList: function updateOperatorList(operatorList) {
+      var self = this;
+
+      function cboxOnClick() {
+        var x = +this.dataset.idx;
+        if (this.checked) {
+          self.breakPoints.push(x);
+        } else {
+          self.breakPoints.splice(self.breakPoints.indexOf(x), 1);
+        }
+        StepperManager.saveBreakPoints(self.pageIndex, self.breakPoints);
+      }
+
+      var MAX_OPERATORS_COUNT = 15000;
+      if (this.operatorListIdx > MAX_OPERATORS_COUNT) {
+        return;
+      }
+
+      var chunk = document.createDocumentFragment();
+      var operatorsToDisplay = Math.min(
+        MAX_OPERATORS_COUNT,
+        operatorList.fnArray.length
+      );
+      for (var i = this.operatorListIdx; i < operatorsToDisplay; i++) {
+        var line = c("tr");
+        line.className = "line";
+        line.dataset.idx = i;
+        chunk.appendChild(line);
+        var checked = this.breakPoints.includes(i);
+        var args = operatorList.argsArray[i] || [];
+
+        var breakCell = c("td");
+        var cbox = c("input");
+        cbox.type = "checkbox";
+        cbox.className = "points";
+        cbox.checked = checked;
+        cbox.dataset.idx = i;
+        cbox.onclick = cboxOnClick;
+
+        breakCell.appendChild(cbox);
+        line.appendChild(breakCell);
+        line.appendChild(c("td", i.toString()));
+        var fn = opMap[operatorList.fnArray[i]];
+        var decArgs = args;
+        if (fn === "showText") {
+          var glyphs = args[0];
+          var newArgs = [];
+          var str = [];
+          for (var j = 0; j < glyphs.length; j++) {
+            var glyph = glyphs[j];
+            if (typeof glyph === "object" && glyph !== null) {
+              str.push(glyph.fontChar);
+            } else {
+              if (str.length > 0) {
+                newArgs.push(str.join(""));
+                str = [];
+              }
+              newArgs.push(glyph); // null or number
+            }
+          }
+          if (str.length > 0) {
+            newArgs.push(str.join(""));
+          }
+          decArgs = [newArgs];
+        }
+        line.appendChild(c("td", fn));
+        line.appendChild(c("td", JSON.stringify(simplifyArgs(decArgs))));
+      }
+      if (operatorsToDisplay < operatorList.fnArray.length) {
+        var lastCell = c("td", "...");
+        lastCell.colspan = 4;
+        chunk.appendChild(lastCell);
+      }
+      this.operatorListIdx = operatorList.fnArray.length;
+      this.table.appendChild(chunk);
+    },
+    getNextBreakPoint: function getNextBreakPoint() {
+      this.breakPoints.sort(function (a, b) {
+        return a - b;
+      });
+      for (var i = 0; i < this.breakPoints.length; i++) {
+        if (this.breakPoints[i] > this.currentIdx) {
+          return this.breakPoints[i];
+        }
+      }
+      return null;
+    },
+    breakIt: function breakIt(idx, callback) {
+      StepperManager.selectStepper(this.pageIndex, true);
+      var self = this;
+      var dom = document;
+      self.currentIdx = idx;
+      var listener = function (e) {
+        switch (e.keyCode) {
+          case 83: // step
+            dom.removeEventListener("keydown", listener);
+            self.nextBreakPoint = self.currentIdx + 1;
+            self.goTo(-1);
+            callback();
+            break;
+          case 67: // continue
+            dom.removeEventListener("keydown", listener);
+            var breakPoint = self.getNextBreakPoint();
+            self.nextBreakPoint = breakPoint;
+            self.goTo(-1);
+            callback();
+            break;
+        }
+      };
+      dom.addEventListener("keydown", listener);
+      self.goTo(idx);
+    },
+    goTo: function goTo(idx) {
+      var allRows = this.panel.getElementsByClassName("line");
+      for (var x = 0, xx = allRows.length; x < xx; ++x) {
+        var row = allRows[x];
+        if ((row.dataset.idx | 0) === idx) {
+          row.style.backgroundColor = "rgb(251,250,207)";
+          row.scrollIntoView();
+        } else {
+          row.style.backgroundColor = null;
+        }
+      }
+    },
+  };
+  return Stepper;
+})();
+
+var Stats = (function Stats() {
+  var stats = [];
+  function clear(node) {
+    while (node.hasChildNodes()) {
+      node.removeChild(node.lastChild);
+    }
+  }
+  function getStatIndex(pageNumber) {
+    for (var i = 0, ii = stats.length; i < ii; ++i) {
+      if (stats[i].pageNumber === pageNumber) {
+        return i;
+      }
+    }
+    return false;
+  }
+  return {
+    // Properties/functions needed by PDFBug.
+    id: "Stats",
+    name: "Stats",
+    panel: null,
+    manager: null,
+    init(pdfjsLib) {},
+    enabled: false,
+    active: false,
+    // Stats specific functions.
+    add(pageNumber, stat) {
+      if (!stat) {
+        return;
+      }
+      var statsIndex = getStatIndex(pageNumber);
+      if (statsIndex !== false) {
+        const b = stats[statsIndex];
+        this.panel.removeChild(b.div);
+        stats.splice(statsIndex, 1);
+      }
+      var wrapper = document.createElement("div");
+      wrapper.className = "stats";
+      var title = document.createElement("div");
+      title.className = "title";
+      title.textContent = "Page: " + pageNumber;
+      var statsDiv = document.createElement("div");
+      statsDiv.textContent = stat.toString();
+      wrapper.appendChild(title);
+      wrapper.appendChild(statsDiv);
+      stats.push({ pageNumber, div: wrapper });
+      stats.sort(function (a, b) {
+        return a.pageNumber - b.pageNumber;
+      });
+      clear(this.panel);
+      for (var i = 0, ii = stats.length; i < ii; ++i) {
+        this.panel.appendChild(stats[i].div);
+      }
+    },
+    cleanup() {
+      stats = [];
+      clear(this.panel);
+    },
+  };
+})();
+
+// Manages all the debugging tools.
+window.PDFBug = (function PDFBugClosure() {
+  var panelWidth = 300;
+  var buttons = [];
+  var activePanel = null;
+
+  return {
+    tools: [FontInspector, StepperManager, Stats],
+    enable(ids) {
+      var all = false,
+        tools = this.tools;
+      if (ids.length === 1 && ids[0] === "all") {
+        all = true;
+      }
+      for (var i = 0; i < tools.length; ++i) {
+        var tool = tools[i];
+        if (all || ids.includes(tool.id)) {
+          tool.enabled = true;
+        }
+      }
+      if (!all) {
+        // Sort the tools by the order they are enabled.
+        tools.sort(function (a, b) {
+          var indexA = ids.indexOf(a.id);
+          indexA = indexA < 0 ? tools.length : indexA;
+          var indexB = ids.indexOf(b.id);
+          indexB = indexB < 0 ? tools.length : indexB;
+          return indexA - indexB;
+        });
+      }
+    },
+    init(pdfjsLib, container) {
+      /*
+       * Basic Layout:
+       * PDFBug
+       *  Controls
+       *  Panels
+       *    Panel
+       *    Panel
+       *    ...
+       */
+      var ui = document.createElement("div");
+      ui.id = "PDFBug";
+
+      var controls = document.createElement("div");
+      controls.setAttribute("class", "controls");
+      ui.appendChild(controls);
+
+      var panels = document.createElement("div");
+      panels.setAttribute("class", "panels");
+      ui.appendChild(panels);
+
+      container.appendChild(ui);
+      container.style.right = panelWidth + "px";
+
+      // Initialize all the debugging tools.
+      var tools = this.tools;
+      var self = this;
+      for (var i = 0; i < tools.length; ++i) {
+        var tool = tools[i];
+        var panel = document.createElement("div");
+        var panelButton = document.createElement("button");
+        panelButton.textContent = tool.name;
+        panelButton.addEventListener(
+          "click",
+          (function (selected) {
+            return function (event) {
+              event.preventDefault();
+              self.selectPanel(selected);
+            };
+          })(i)
+        );
+        controls.appendChild(panelButton);
+        panels.appendChild(panel);
+        tool.panel = panel;
+        tool.manager = this;
+        if (tool.enabled) {
+          tool.init(pdfjsLib);
+        } else {
+          panel.textContent =
+            tool.name +
+            " is disabled. To enable add " +
+            ' "' +
+            tool.id +
+            '" to the pdfBug parameter ' +
+            "and refresh (separate multiple by commas).";
+        }
+        buttons.push(panelButton);
+      }
+      this.selectPanel(0);
+    },
+    cleanup() {
+      for (var i = 0, ii = this.tools.length; i < ii; i++) {
+        if (this.tools[i].enabled) {
+          this.tools[i].cleanup();
+        }
+      }
+    },
+    selectPanel(index) {
+      if (typeof index !== "number") {
+        index = this.tools.indexOf(index);
+      }
+      if (index === activePanel) {
+        return;
+      }
+      activePanel = index;
+      var tools = this.tools;
+      for (var j = 0; j < tools.length; ++j) {
+        if (j === index) {
+          buttons[j].setAttribute("class", "active");
+          tools[j].active = true;
+          tools[j].panel.removeAttribute("hidden");
+        } else {
+          buttons[j].setAttribute("class", "");
+          tools[j].active = false;
+          tools[j].panel.setAttribute("hidden", "true");
+        }
+      }
+    },
+  };
+})();
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-check.svg b/toolkit/components/pdfjs/content/web/images/annotation-check.svg
new file mode 100644
index 0000000000..71cd16df57
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-check.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <path
+     d="M 1.5006714,23.536225 6.8925879,18.994244 14.585721,26.037937 34.019683,4.5410479 38.499329,9.2235032 14.585721,35.458952 z"
+     id="path4"
+     style="fill:#ffff00;fill-opacity:1;stroke:#000000;stroke-width:1.25402856;stroke-opacity:1" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-comment.svg b/toolkit/components/pdfjs/content/web/images/annotation-comment.svg
new file mode 100644
index 0000000000..86f1f17249
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-comment.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   height="40"
+   width="40"
+   viewBox="0 0 40 40">
+  <rect
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+     width="33.76017"
+     height="33.76017"
+     x="3.119915"
+     y="3.119915" />
+  <path
+     d="m 20.677967,8.54499 c -7.342801,0 -13.295293,4.954293 -13.295293,11.065751 0,2.088793 0.3647173,3.484376 1.575539,5.150563 L 6.0267418,31.45501 13.560595,29.011117 c 2.221262,1.387962 4.125932,1.665377 7.117372,1.665377 7.3428,0 13.295291,-4.954295 13.295291,-11.065753 0,-6.111458 -5.952491,-11.065751 -13.295291,-11.065751 z"
+     style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.93031836;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"/>
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-help.svg b/toolkit/components/pdfjs/content/web/images/annotation-help.svg
new file mode 100644
index 0000000000..00938fefe0
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-help.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <g
+     transform="translate(0,-60)"
+     id="layer1">
+    <rect
+       width="36.460953"
+       height="34.805603"
+       x="1.7695236"
+       y="62.597198"
+       style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.30826771;stroke-opacity:1" />
+    <g
+       transform="matrix(0.88763677,0,0,0.88763677,2.2472646,8.9890584)">
+      <path
+         d="M 20,64.526342 C 11.454135,64.526342 4.5263421,71.454135 4.5263421,80 4.5263421,88.545865 11.454135,95.473658 20,95.473658 28.545865,95.473658 35.473658,88.545865 35.473658,80 35.473658,71.454135 28.545865,64.526342 20,64.526342 z m -0.408738,9.488564 c 3.527079,0 6.393832,2.84061 6.393832,6.335441 0,3.494831 -2.866753,6.335441 -6.393832,6.335441 -3.527079,0 -6.393832,-2.84061 -6.393832,-6.335441 0,-3.494831 2.866753,-6.335441 6.393832,-6.335441 z"
+         style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:1.02768445;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+      <path
+         d="m 7.2335209,71.819938 4.9702591,4.161823 c -1.679956,2.581606 -1.443939,6.069592 0.159325,8.677725 l -5.1263071,3.424463 c 0.67516,1.231452 3.0166401,3.547686 4.2331971,4.194757 l 3.907728,-4.567277 c 2.541952,1.45975 5.730694,1.392161 8.438683,-0.12614 l 3.469517,6.108336 c 1.129779,-0.44367 4.742234,-3.449633 5.416358,-5.003859 l -5.46204,-4.415541 c 1.44319,-2.424098 1.651175,-5.267515 0.557303,-7.748623 l 5.903195,-3.833951 C 33.14257,71.704996 30.616217,69.018606 29.02952,67.99296 l -4.118813,4.981678 C 22.411934,71.205099 18.900853,70.937534 16.041319,72.32916 l -3.595408,-5.322091 c -1.345962,0.579488 -4.1293881,2.921233 -5.2123901,4.812869 z m 8.1010311,3.426672 c 2.75284,-2.446266 6.769149,-2.144694 9.048998,0.420874 2.279848,2.56557 2.113919,6.596919 -0.638924,9.043185 -2.752841,2.446267 -6.775754,2.13726 -9.055604,-0.428308 -2.279851,-2.565568 -2.107313,-6.589485 0.64553,-9.035751 z"
+         style="fill:#000000;fill-opacity:1;stroke:none" />
+    </g>
+  </g>
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-insert.svg b/toolkit/components/pdfjs/content/web/images/annotation-insert.svg
new file mode 100644
index 0000000000..519ef6826e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-insert.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 32.003143,1.4044602 57.432701,62.632577 6.5672991,62.627924 z"
+     style="fill:#ffff00;fill-opacity:0.94117647;fill-rule:nonzero;stroke:#000000;stroke-width:1.00493038;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-key.svg b/toolkit/components/pdfjs/content/web/images/annotation-key.svg
new file mode 100644
index 0000000000..8d09d5378d
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-key.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 25.470843,9.4933766 C 25.30219,12.141818 30.139101,14.445969 34.704831,13.529144 40.62635,12.541995 41.398833,7.3856498 35.97505,5.777863 31.400921,4.1549155 25.157674,6.5445892 25.470843,9.4933766 z M 4.5246282,17.652051 C 4.068249,11.832873 9.2742983,5.9270407 18.437379,3.0977088 29.751911,-0.87185184 45.495663,1.4008022 53.603953,7.1104009 c 9.275765,6.1889221 7.158128,16.2079421 -3.171076,21.5939521 -1.784316,1.635815 -6.380222,1.21421 -7.068351,3.186186 -1.04003,0.972427 -1.288046,2.050158 -1.232864,3.168203 1.015111,2.000108 -3.831548,1.633216 -3.270553,3.759574 0.589477,5.264544 -0.179276,10.53738 -0.362842,15.806257 -0.492006,2.184998 1.163456,4.574232 -0.734888,6.610642 -2.482919,2.325184 -7.30604,2.189143 -9.193497,-0.274767 -2.733688,-1.740626 -8.254447,-3.615254 -6.104247,-6.339626 3.468112,-1.708686 -2.116197,-3.449897 0.431242,-5.080274 5.058402,-1.39256 -2.393215,-2.304318 -0.146889,-4.334645 3.069198,-0.977415 2.056986,-2.518352 -0.219121,-3.540397 1.876567,-1.807151 1.484149,-4.868919 -2.565455,-5.942205 0.150866,-1.805474 2.905737,-4.136876 -1.679967,-5.20493 C 10.260902,27.882167 4.6872697,22.95045 4.5245945,17.652051 z"
+     id="path604"
+     style="fill:#ffff00;fill-opacity:1;stroke:#000000;stroke-width:1.72665179;stroke-opacity:1" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-newparagraph.svg b/toolkit/components/pdfjs/content/web/images/annotation-newparagraph.svg
new file mode 100644
index 0000000000..38d2497da9
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-newparagraph.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 32.003143,10.913072 57.432701,53.086929 6.567299,53.083723 z"
+     id="path2985"
+     style="fill:#ffff00;fill-opacity:0.94117647;fill-rule:nonzero;stroke:#000000;stroke-width:0.83403099;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-noicon.svg b/toolkit/components/pdfjs/content/web/images/annotation-noicon.svg
new file mode 100644
index 0000000000..c07d108083
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-noicon.svg
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-note.svg b/toolkit/components/pdfjs/content/web/images/annotation-note.svg
new file mode 100644
index 0000000000..70173651c7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-note.svg
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <rect
+     width="36.075428"
+     height="31.096582"
+     x="1.962286"
+     y="4.4517088"
+     id="rect4"
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.23004246;stroke-opacity:1" />
+  <rect
+     width="27.96859"
+     height="1.5012145"
+     x="6.0157046"
+     y="10.285"
+     id="rect6"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="6.0157056"
+     y="23.21689"
+     id="rect8"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="5.8130345"
+     y="28.964394"
+     id="rect10"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="6.0157046"
+     y="17.426493"
+     id="rect12"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/annotation-paragraph.svg b/toolkit/components/pdfjs/content/web/images/annotation-paragraph.svg
new file mode 100644
index 0000000000..6ae5212b75
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/annotation-paragraph.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <rect
+     width="33.76017"
+     height="33.76017"
+     x="3.119915"
+     y="3.119915"
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+  <path
+     d="m 17.692678,34.50206 0,-16.182224 c -1.930515,-0.103225 -3.455824,-0.730383 -4.57593,-1.881473 -1.12011,-1.151067 -1.680164,-2.619596 -1.680164,-4.405591 0,-1.992435 0.621995,-3.5796849 1.865988,-4.7617553 1.243989,-1.1820288 3.06352,-1.7730536 5.458598,-1.7730764 l 9.802246,0 0,2.6789711 -2.229895,0 0,26.3251486 -2.632515,0 0,-26.3251486 -3.45324,0 0,26.3251486 z"
+     style="font-size:29.42051125px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:1.07795751;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" />
+</svg>
diff --git a/toolkit/components/pdfjs/content/web/images/findbarButton-next.svg b/toolkit/components/pdfjs/content/web/images/findbarButton-next.svg
new file mode 100644
index 0000000000..a81eb02962
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/findbarButton-next.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M8 12a1 1 0 0 1-.707-.293l-5-5a1 1 0 0 1 1.414-1.414L8 9.586l4.293-4.293a1 1 0 0 1 1.414 1.414l-5 5A1 1 0 0 1 8 12z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/findbarButton-previous.svg b/toolkit/components/pdfjs/content/web/images/findbarButton-previous.svg
new file mode 100644
index 0000000000..5fd7032259
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/findbarButton-previous.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M13 11a1 1 0 0 1-.707-.293L8 6.414l-4.293 4.293a1 1 0 0 1-1.414-1.414l5-5a1 1 0 0 1 1.414 0l5 5A1 1 0 0 1 13 11z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/loading-dark.svg b/toolkit/components/pdfjs/content/web/images/loading-dark.svg
new file mode 100644
index 0000000000..fa5269b1a3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/loading-dark.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"
+fill="rgba(255,255,255,1)" style="animation:spinLoadingIcon 1s steps(12,end)
+infinite"><style>@keyframes
+spinLoadingIcon{to{transform:rotate(360deg)}}</style><path
+d="M7 3V1s0-1 1-1 1 1 1 1v2s0 1-1 1-1-1-1-1z"/><path d="M4.63
+4.1l-1-1.73S3.13 1.5 4 1c.87-.5 1.37.37 1.37.37l1 1.73s.5.87-.37
+1.37c-.87.57-1.37-.37-1.37-.37z" fill-opacity=".93"/><path
+d="M3.1 6.37l-1.73-1S.5 4.87 1 4c.5-.87 1.37-.37 1.37-.37l1.73 1s.87.5.37
+1.37c-.5.87-1.37.37-1.37.37z" fill-opacity=".86"/><path d="M3
+9H1S0 9 0 8s1-1 1-1h2s1 0 1 1-1 1-1 1z" fill-opacity=".79"/><path d="M4.1 11.37l-1.73 1S1.5 12.87 1
+12c-.5-.87.37-1.37.37-1.37l1.73-1s.87-.5 1.37.37c.5.87-.37 1.37-.37 1.37z"
+fill-opacity=".72"/><path d="M3.63 13.56l1-1.73s.5-.87
+1.37-.37c.87.5.37 1.37.37 1.37l-1 1.73s-.5.87-1.37.37c-.87-.5-.37-1.37-.37-1.37z"
+fill-opacity=".65"/><path d="M7 15v-2s0-1 1-1 1 1 1 1v2s0 1-1
+1-1-1-1-1z" fill-opacity=".58"/><path d="M10.63
+14.56l-1-1.73s-.5-.87.37-1.37c.87-.5 1.37.37 1.37.37l1 1.73s.5.87-.37
+1.37c-.87.5-1.37-.37-1.37-.37z" fill-opacity=".51"/><path
+d="M13.56 12.37l-1.73-1s-.87-.5-.37-1.37c.5-.87 1.37-.37 1.37-.37l1.73 1s.87.5.37
+1.37c-.5.87-1.37.37-1.37.37z" fill-opacity=".44"/><path d="M15
+9h-2s-1 0-1-1 1-1 1-1h2s1 0 1 1-1 1-1 1z" fill-opacity=".37"/><path d="M14.56 5.37l-1.73
+1s-.87.5-1.37-.37c-.5-.87.37-1.37.37-1.37l1.73-1s.87-.5 1.37.37c.5.87-.37 1.37-.37
+1.37z" fill-opacity=".3"/><path d="M9.64 3.1l.98-1.66s.5-.874
+1.37-.37c.87.5.37 1.37.37 1.37l-1 1.73s-.5.87-1.37.37c-.87-.5-.37-1.37-.37-1.37z"
+fill-opacity=".23"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/loading-icon.gif b/toolkit/components/pdfjs/content/web/images/loading-icon.gif
new file mode 100644
index 0000000000..1c72ebb554
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/loading-icon.gif
diff --git a/toolkit/components/pdfjs/content/web/images/loading.svg b/toolkit/components/pdfjs/content/web/images/loading.svg
new file mode 100644
index 0000000000..0a15ff6885
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/loading.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16" style="animation:spinLoadingIcon 1s steps(12,end) infinite"><style>@keyframes spinLoadingIcon{to{transform:rotate(360deg)}}</style><path d="M7 3V1s0-1 1-1 1 1 1 1v2s0 1-1 1-1-1-1-1z"/><path d="M4.63 4.1l-1-1.73S3.13 1.5 4 1c.87-.5 1.37.37 1.37.37l1 1.73s.5.87-.37 1.37c-.87.57-1.37-.37-1.37-.37z" fill-opacity=".93"/><path d="M3.1 6.37l-1.73-1S.5 4.87 1 4c.5-.87 1.37-.37 1.37-.37l1.73 1s.87.5.37 1.37c-.5.87-1.37.37-1.37.37z" fill-opacity=".86"/><path d="M3 9H1S0 9 0 8s1-1 1-1h2s1 0 1 1-1 1-1 1z" fill-opacity=".79"/><path d="M4.1 11.37l-1.73 1S1.5 12.87 1 12c-.5-.87.37-1.37.37-1.37l1.73-1s.87-.5 1.37.37c.5.87-.37 1.37-.37 1.37z" fill-opacity=".72"/><path d="M3.63 13.56l1-1.73s.5-.87 1.37-.37c.87.5.37 1.37.37 1.37l-1 1.73s-.5.87-1.37.37c-.87-.5-.37-1.37-.37-1.37z" fill-opacity=".65"/><path d="M7 15v-2s0-1 1-1 1 1 1 1v2s0 1-1 1-1-1-1-1z" fill-opacity=".58"/><path d="M10.63 14.56l-1-1.73s-.5-.87.37-1.37c.87-.5 1.37.37 1.37.37l1 1.73s.5.87-.37 1.37c-.87.5-1.37-.37-1.37-.37z" fill-opacity=".51"/><path d="M13.56 12.37l-1.73-1s-.87-.5-.37-1.37c.5-.87 1.37-.37 1.37-.37l1.73 1s.87.5.37 1.37c-.5.87-1.37.37-1.37.37z" fill-opacity=".44"/><path d="M15 9h-2s-1 0-1-1 1-1 1-1h2s1 0 1 1-1 1-1 1z" fill-opacity=".37"/><path d="M14.56 5.37l-1.73 1s-.87.5-1.37-.37c-.5-.87.37-1.37.37-1.37l1.73-1s.87-.5 1.37.37c.5.87-.37 1.37-.37 1.37z" fill-opacity=".3"/><path d="M9.64 3.1l.98-1.66s.5-.874 1.37-.37c.87.5.37 1.37.37 1.37l-1 1.73s-.5.87-1.37.37c-.87-.5-.37-1.37-.37-1.37z" fill-opacity=".23"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.svg
new file mode 100644
index 0000000000..6bd55cda78
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.svg
@@ -0,0 +1,15 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16
+16">
+<path 
+   d="M8 16a8 8 0 1 1 8-8 8.009 8.009 0 0 1-8 8zM8 2a6 6 0 1 0 6 6 6.006 6.006 0 0 0-6-6z">
+</path>
+<path 
+   d="M8 7a1 1 0 0 0-1 1v3a1 1 0 0 0 2 0V8a1 1 0 0 0-1-1z">
+</path>
+<circle
+   cx="8" cy="5" r="1.188">
+</circle>
+</svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-firstPage.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-firstPage.svg
new file mode 100644
index 0000000000..2fa0fa6da5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-firstPage.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M13 13c-.3 0-.5-.1-.7-.3L8 8.4l-4.3 4.3c-.9.9-2.3-.5-1.4-1.4l5-5c.4-.4 1-.4 1.4 0l5 5c.6.6.2 1.7-.7 1.7zm0-11H3C1.7 2 1.7 4 3 4h10c1.3 0 1.3-2 0-2z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-handTool.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-handTool.svg
new file mode 100644
index 0000000000..3d038fabb7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-handTool.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M15 3.7V13c0 1.5-1.53 3-3 3H7.13c-.72 0-1.63-.5-2.13-1l-5-5s.84-1 .87-1c.13-.1.33-.2.53-.2.1 0 .3.1.4.2L4 10.6V2.7c0-.6.4-1 1-1s1 .4 1 1v4.6h1V1c0-.6.4-1 1-1s1 .4 1 1v6.3h1V1.7c0-.6.4-1 1-1s1 .4 1 1v5.7h1V3.7c0-.6.4-1 1-1s1 .4 1 1z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-lastPage.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-lastPage.svg
new file mode 100644
index 0000000000..53fa9a6d07
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-lastPage.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M8 10c-.3 0-.5-.1-.7-.3l-5-5c-.9-.9.5-2.3 1.4-1.4L8 7.6l4.3-4.3c.9-.9 2.3.5 1.4 1.4l-5 5c-.2.2-.4.3-.7.3zm5 2H3c-1.3 0-1.3 2 0 2h10c1.3 0 1.3-2 0-2z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.svg
new file mode 100644
index 0000000000..c71ea8e8d4
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M1 1a1 1 0 011 1v2.4A7 7 0 118 15a7 7 0 01-4.9-2 1 1 0 011.4-1.5 5 5 0 10-1-5.5H6a1 1 0 010 2H1a1 1 0 01-1-1V2a1 1 0 011-1z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.svg
new file mode 100644
index 0000000000..e1e19e73d2
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M15 1a1 1 0 0 0-1 1v2.418A6.995 6.995 0 1 0 8 15a6.954 6.954 0 0 0 4.95-2.05 1 1 0 0 0-1.414-1.414A5.019 5.019 0 1 1 12.549 6H10a1 1 0 0 0 0 2h5a1 1 0 0 0 1-1V2a1 1 0 0 0-1-1z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollHorizontal.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollHorizontal.svg
new file mode 100644
index 0000000000..8693eec397
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollHorizontal.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M0 4h1.5c1 0 1.5.5 1.5 1.5v5c0 1-.5 1.5-1.5 1.5H0zM9.5 4c1 0 1.5.5 1.5 1.5v5c0 1-.5 1.5-1.5 1.5h-3c-1 0-1.5-.5-1.5-1.5v-5C5 4.5 5.5 4 6.5 4zM16 4h-1.5c-1 0-1.5.5-1.5 1.5v5c0 1 .5 1.5 1.5 1.5H16z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollVertical.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollVertical.svg
new file mode 100644
index 0000000000..ee1cf22f98
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollVertical.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M9.5 4c1 0 1.5.5 1.5 1.5v5c0 1-.5 1.5-1.5 1.5h-3c-1 0-1.5-.5-1.5-1.5v-5C5 4.5 5.5 4 6.5 4zM11 0v.5c0 1-.5 1.5-1.5 1.5h-3C5.5 2 5 1.5 5 .5V0h6zM11 16v-.5c0-1-.5-1.5-1.5-1.5h-3c-1 0-1.5.5-1.5 1.5v.5h6z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollWrapped.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollWrapped.svg
new file mode 100644
index 0000000000..804e7469bf
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-scrollWrapped.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M5.5 4c1 0 1.5.5 1.5 1.5v5c0 1-.5 1.5-1.5 1.5h-3c-1 0-1.5-.5-1.5-1.5v-5C1 4.5 1.5 4 2.5 4zM7 0v.5C7 1.5 6.5 2 5.5 2h-3C1.5 2 1 1.5 1 .5V0h6zM7 16v-.5c0-1-.5-1.5-1.5-1.5h-3c-1 0-1.5.5-1.5 1.5v.5h6zM13.5 4c1 0 1.5.5 1.5 1.5v5c0 1-.5 1.5-1.5 1.5h-3c-1 0-1.5-.5-1.5-1.5v-5c0-1 .5-1.5 1.5-1.5zM15 0v.5c0 1-.5 1.5-1.5 1.5h-3C9.5 2 9 1.5 9 .5V0h6zM15 16v-.507c0-1-.5-1.5-1.5-1.5h-3C9.5 14 9 14.5 9 15.5v.5h6z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-selectTool.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-selectTool.svg
new file mode 100644
index 0000000000..43e9789444
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-selectTool.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M12.408 8.217l-8.083-6.7A.2.2 0 0 0 4 1.672V12.3a.2.2 0 0 0 .333.146l2.56-2.372 1.857 3.9A1.125 1.125 0 1 0 10.782 13L8.913 9.075l3.4-.51a.2.2 0 0 0 .095-.348z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadEven.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadEven.svg
new file mode 100644
index 0000000000..ddec5e68d5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadEven.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M1.5 3.5C.5 3.5 0 4 0 5v6.5c0 1 .5 1.5 1.5 1.5h4c1 0 1.5-.5 1.5-1.5V5c0-1-.5-1.5-1.5-1.5zm2 1.2c.8 0 1.4.2 1.8.6.5.4.7 1 .7 1.7 0 .5-.2 1-.5 1.4-.2.3-.5.7-1 1l-.6.4c-.4.3-.6.4-.75.56-.15.14-.25.24-.35.44H6v1.3H1c0-.6.1-1.1.3-1.5.3-.6.7-1 1.5-1.6.7-.4 1.1-.8 1.28-1 .32-.3.42-.6.42-1 0-.3-.1-.6-.23-.8-.17-.2-.37-.3-.77-.3s-.7.1-.9.5c-.04.2-.1.5-.1.9H1.1c0-.6.1-1.1.3-1.5.4-.7 1.1-1.1 2.1-1.1zM10.54 3.54C9.5 3.54 9 4 9 5v6.5c0 1 .5 1.5 1.54 1.5h4c.96 0 1.46-.5 1.46-1.5V5c0-1-.5-1.46-1.5-1.46zm1.9.95c.7 0 1.3.2 1.7.5.4.4.6.8.6 1.4 0 .4-.1.8-.4 1.1-.2.2-.3.3-.5.4.1 0 .3.1.6.3.4.3.5.8.5 1.4 0 .6-.2 1.2-.6 1.6-.4.5-1.1.7-1.9.7-1 0-1.8-.3-2.2-1-.14-.29-.24-.69-.24-1.29h1.4c0 .3 0 .5.1.7.2.4.5.5 1 .5.3 0 .5-.1.7-.3.2-.2.3-.5.3-.8 0-.5-.2-.8-.6-.95-.2-.05-.5-.15-1-.15v-1c.5 0 .8-.1 1-.14.3-.1.5-.4.5-.9 0-.3-.1-.5-.2-.7-.2-.2-.4-.3-.7-.3-.3 0-.6.1-.75.3-.2.2-.2.5-.2.86h-1.34c0-.4.1-.7.19-1.1 0-.12.2-.32.4-.62.2-.2.4-.3.7-.4.3-.1.6-.1 1-.1z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadNone.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadNone.svg
new file mode 100644
index 0000000000..63318c56ba
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadNone.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M6 3c-1 0-1.5.5-1.5 1.5v7c0 1 .5 1.5 1.5 1.5h4c1 0 1.5-.5 1.5-1.5v-7c0-1-.5-1.5-1.5-1.5z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadOdd.svg b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadOdd.svg
new file mode 100644
index 0000000000..29909e9fac
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/secondaryToolbarButton-spreadOdd.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M10.56 3.5C9.56 3.5 9 4 9 5v6.5c0 1 .5 1.5 1.5 1.5h4c1 0 1.5-.5 1.5-1.5V5c0-1-.5-1.5-1.5-1.5zm1.93 1.2c.8 0 1.4.2 1.8.64.5.4.7 1 .7 1.7 0 .5-.2 1-.5 1.44-.2.3-.6.6-1 .93l-.6.4c-.4.3-.6.4-.7.55-.1.1-.2.2-.3.4h3.2v1.27h-5c0-.5.1-1 .3-1.43.2-.49.7-1 1.5-1.54.7-.5 1.1-.8 1.3-1.02.3-.3.4-.7.4-1.05 0-.3-.1-.6-.3-.77-.2-.2-.4-.3-.7-.3-.4 0-.7.2-.9.5-.1.2-.1.5-.2.9h-1.4c0-.6.2-1.1.3-1.5.4-.7 1.1-1.1 2-1.1zM1.54 3.5C.54 3.5 0 4 0 5v6.5c0 1 .5 1.5 1.54 1.5h4c1 0 1.5-.5 1.5-1.5V5c0-1-.5-1.5-1.5-1.5zm1.8 1.125H4.5V12H3V6.9H1.3v-1c.5 0 .8 0 .97-.03.33-.07.53-.17.73-.37.1-.2.2-.3.25-.5.05-.2.05-.3.05-.3z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/shadow.png b/toolkit/components/pdfjs/content/web/images/shadow.png
new file mode 100644
index 0000000000..a00061ac7e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/shadow.png
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-bookmark.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-bookmark.svg
new file mode 100644
index 0000000000..79d39b090e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-bookmark.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M4 16V2s0-1 1-1h6s1 0 1 1v14l-4-5z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-currentOutlineItem.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-currentOutlineItem.svg
new file mode 100644
index 0000000000..c1c72b2080
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-currentOutlineItem.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="m14 9h-6c-1.3 0-1.3 2 0 2h6c1.3 0 1.3-2 0-2zm-5.2-8h-3.8c-1.3 0-1.3 2 0 2h1.7zm-6.8 0c-1 0-1.3 1-0.7 1.7 0.7 0.6 1.7 0.3 1.7-0.7 0-0.5-0.4-1-1-1zm3 8c-1 0-1.3 1-0.7 1.7 0.6 0.6 1.7 0.2 1.7-0.7 0-0.5-0.4-1-1-1zm0.3-4h-0.3c-1.4 0-1.4 2 0 2h2.3zm-3.3 0c-0.9 0-1.4 1-0.7 1.7 0.7 0.6 1.7 0.2 1.7-0.7 0-0.6-0.5-1-1-1zm12 8h-9c-1.3 0-1.3 2 0 2h9c1.3 0 1.3-2 0-2zm-12 0c-1 0-1.3 1-0.7 1.7 0.7 0.6 1.7 0.2 1.7-0.712 0-0.5-0.4-1-1-1z"/><path d="m7.37 4.838 3.93-3.911v2.138h3.629v3.546h-3.629v2.138l-3.93-3.911"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-download.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-download.svg
new file mode 100644
index 0000000000..2cdb5db3c7
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-download.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M14 3h-2v2h2v8H2V5h7V3h-.849L6.584 1.538A2 2 0 0 0 5.219 1H2a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2zM2 3h3.219l1.072 1H2z"></path><path d="M8.146 6.146a.5.5 0 0 0 0 .707l2 2a.5.5 0 0 0 .707 0l2-2a.5.5 0 1 0-.707-.707L11 7.293V.5a.5.5 0 0 0-1 0v6.793L8.854 6.146a.5.5 0 0 0-.708 0z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-menuArrow.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-menuArrow.svg
new file mode 100644
index 0000000000..46e41e18c5
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-menuArrow.svg
@@ -0,0 +1 @@
+<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg"><path d="M8 11a1 1 0 01-.707-.293l-2.99-2.99c-.91-.942.471-2.324 1.414-1.414L8 8.586l2.283-2.283c.943-.91 2.324.472 1.414 1.414l-2.99 2.99A1 1 0 018 11z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-openFile.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-openFile.svg
new file mode 100644
index 0000000000..cb35980f0e
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-openFile.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M14.859 3.2a1.335 1.335 0 0 1-1.217.8H13v1h1v8H2V5h8V4h-.642a1.365 1.365 0 0 1-1.325-1.11L6.584 1.538A2 2 0 0 0 5.219 1H2a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V5a2 2 0 0 0-1.141-1.8zM2 3h3.219l1.072 1H2zm7.854-.146L11 1.707V8.5a.5.5 0 0 0 1 0V1.707l1.146 1.146a.5.5 0 1 0 .707-.707l-2-2a.5.5 0 0 0-.707 0l-2 2a.5.5 0 0 0 .707.707z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-pageDown.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-pageDown.svg
new file mode 100644
index 0000000000..c5d8b0f3fc
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-pageDown.svg
@@ -0,0 +1,7 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16
+16"><path transform='rotate(90) translate(0, -16)'
+d="M15.707 7.293l-6-6a1 1 0 0 0-1.414 1.414L12.586 7H1a1 1 0 0 0 0 2h11.586l-4.293
+4.293a1 1 0 1 0 1.414 1.414l6-6a1 1 0 0 0 0-1.414z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-pageUp.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-pageUp.svg
new file mode 100644
index 0000000000..aa0160ab99
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-pageUp.svg
@@ -0,0 +1,12 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16
+16">
+<path 
+   transform='rotate(90) translate(0, -16)'
+   d="M15 7H3.414l4.293-4.293a1 1 0 0
+0-1.414-1.414l-6 6a1 1 0 0 0 0 1.414l6 6a1 1 0 0 0 1.414-1.414L3.414 9H15a1 1 0 0
+0 0-2z">
+</path>
+</svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-presentationMode.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-presentationMode.svg
new file mode 100644
index 0000000000..3f1f832e51
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-presentationMode.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M.5 1H7s0-1 1-1 1 1 1 1h6.5s.5 0 .5.5-.5.5-.5.5H.5S0 2 0 1.5.5 1 .5 1zM1 3h14v7c0 2-1 2-2 2H3c-1 0-2 0-2-2zm5 1v7l6-3.5zM3.72 15.33l.53-2s0-.5.65-.35c.51.13.38.63.38.63l-.53 2s0 .5-.64.35c-.53-.13-.39-.63-.39-.63zM11.24 15.61l-.53-1.99s0-.5.38-.63c.51-.13.64.35.64.35l.53 2s0 .5-.38.63c-.5.13-.64-.35-.65-.35z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-print.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-print.svg
new file mode 100644
index 0000000000..d521c9ad28
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-print.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M14 5h-1V1a1 1 0 0 0-1-1H4a1 1 0 0 0-1 1v4H2a2 2 0 0 0-2 2v5h3v3a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1v-3h3V7a2 2 0 0 0-2-2zM2.5 8a.5.5 0 1 1 .5-.5.5.5 0 0 1-.5.5zm9.5 7H4v-5h8zm0-10H4V1h8zm-6.5 7h4a.5.5 0 0 0 0-1h-4a.5.5 0 1 0 0 1zm0 2h5a.5.5 0 0 0 0-1h-5a.5.5 0 1 0 0 1z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-search.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-search.svg
new file mode 100644
index 0000000000..28b7774eb6
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-search.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M15.707 14.293l-4.822-4.822a6.019 6.019 0 1 0-1.414 1.414l4.822 4.822a1 1 0 0 0 1.414-1.414zM6 10a4 4 0 1 1 4-4 4 4 0 0 1-4 4z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.svg
new file mode 100644
index 0000000000..dbef238040
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M8.707 7.293l-5-5a1 1 0 0 0-1.414 1.414L6.586 8l-4.293 4.293a1 1 0 1 0 1.414 1.414l5-5a1 1 0 0 0 0-1.414zm6 0l-5-5a1 1 0 0 0-1.414 1.414L12.586 8l-4.293 4.293a1 1 0 1 0 1.414 1.414l5-5a1 1 0 0 0 0-1.414z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-sidebarToggle.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-sidebarToggle.svg
new file mode 100644
index 0000000000..691c41cb10
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-sidebarToggle.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M3 1h10a3.008 3.008 0 0 1 3 3v8a3.009 3.009 0 0 1-3 3H3a3.005 3.005 0 0 1-3-3V4a3.013 3.013 0 0 1 3-3zm11 11V4a1 1 0 0 0-1-1H8v10h5a1 1 0 0 0 1-1zM2 12a1 1 0 0 0 1 1h4V3H3a1 1 0 0 0-1 1v8z"></path><path d="M3.5 5h2a.5.5 0 0 0 0-1h-2a.5.5 0 0 0 0 1zm0 2h2a.5.5 0 0 0 0-1h-2a.5.5 0 0 0 0 1zm1 2h1a.5.5 0 0 0 0-1h-1a.5.5 0 0 0 0 1z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-viewAttachments.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewAttachments.svg
new file mode 100644
index 0000000000..e914ec0833
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewAttachments.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M6.2 2s.5-.5 1.06 0c.5.5 0 1 0 1l-4.6 4.61s-2.5 2.5 0 5 5 0 5 0L13.8 6.4s1.6-1.6 0-3.2-3.2 0-3.2 0L5.8 8s-.7.7 0 1.4 1.4 0 1.4 0l3.9-3.9s.6-.5 1 0c.5.5 0 1 0 1l-3.8 4s-1.8 1.8-3.5 0C3 8.7 4.8 7 4.8 7l4.7-4.9s2.7-2.6 5.3 0c2.6 2.6 0 5.3 0 5.3l-6.2 6.3s-3.5 3.5-7 0 0-7 0-7z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-viewLayers.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewLayers.svg
new file mode 100644
index 0000000000..e8687b7704
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewLayers.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4.233 4.233" height="16" width="16"><path d="M.15 2.992c-.198.1-.2.266-.002.365l1.604.802a.93.93 0 00.729-.001l1.602-.801c.198-.1.197-.264 0-.364l-.695-.348c-1.306.595-2.542 0-2.542 0m-.264.53l.658-.329c.6.252 1.238.244 1.754 0l.659.329-1.536.768zM.15 1.935c-.198.1-.198.265 0 .364l1.604.802a.926.926 0 00.727 0l1.603-.802c.198-.099.198-.264 0-.363l-.694-.35c-1.14.56-2.546.001-2.546.001m-.264.53l.664-.332c.52.266 1.261.235 1.75.002l.659.33-1.537.768zM.15.877c-.198.099-.198.264 0 .363l1.604.802a.926.926 0 00.727 0l1.603-.802c.198-.099.198-.264 0-.363L2.481.075a.926.926 0 00-.727 0zm.43.182L2.117.29l1.538.769-1.538.768z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-viewOutline.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewOutline.svg
new file mode 100644
index 0000000000..030c28dfe1
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewOutline.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="16" width="16"><path d="M14 9H8c-1.3 0-1.3 2 0 2h6c1.3 0 1.3-2 0-2zm0-8H5C3.7 1 3.7 3 5 3h9c1.3 0 1.3-2 0-2zM2 1C1 1 .7 2 1.3 2.7 2 3.3 3 3 3 2c0-.5-.4-1-1-1zm3 8c-1 0-1.3 1-.7 1.7.6.6 1.7.2 1.7-.7 0-.5-.4-1-1-1zM14 5H5C3.6 5 3.6 7 5 7h9c1.3 0 1.3-2 0-2zM2 5c-.9 0-1.4 1-.7 1.7C2 7.3 3 6.9 3 6c0-.6-.5-1-1-1zM14 13H5c-1.3 0-1.3 2 0 2h9c1.3 0 1.3-2 0-2zM2 13c-1 0-1.3 1-.7 1.7.7.6 1.7.2 1.7-.712 0-.5-.4-1-1-1z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-viewThumbnail.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewThumbnail.svg
new file mode 100644
index 0000000000..b997ec49a3
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-viewThumbnail.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><g style="--darkreader-inline-fill:rgba(81, 82, 83, 0.8);" data-darkreader-inline-fill=""><rect x="1" y="1" width="6" height="6" rx="1" ry="1"></rect><rect x="9" y="1" width="6" height="6" rx="1" ry="1"></rect><rect x="1" y="9" width="6" height="6" rx="1" ry="1"></rect><rect x="9" y="9" width="6" height="6" rx="1" ry="1"></rect></g></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomIn.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomIn.svg
new file mode 100644
index 0000000000..480d2cef00
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomIn.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M14 7H9V2a1 1 0 0 0-2 0v5H2a1 1 0 0 0 0 2h5v5a1 1 0 0 0 2 0V9h5a1 1 0 0 0 0-2z"></path></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomOut.svg b/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomOut.svg
new file mode 100644
index 0000000000..527f521068
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/toolbarButton-zoomOut.svg
@@ -0,0 +1,4 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><rect x="2" y="7" width="12" height="2" rx="1"></rect></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/treeitem-collapsed.svg b/toolkit/components/pdfjs/content/web/images/treeitem-collapsed.svg
new file mode 100644
index 0000000000..831cddfc86
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/treeitem-collapsed.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M13 9L6 5v8z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/images/treeitem-expanded.svg b/toolkit/components/pdfjs/content/web/images/treeitem-expanded.svg
new file mode 100644
index 0000000000..2d45f0c8d1
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/images/treeitem-expanded.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M10 13l4-7H6z"/></svg>
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/content/web/viewer.css b/toolkit/components/pdfjs/content/web/viewer.css
new file mode 100644
index 0000000000..47f79e4290
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/viewer.css
@@ -0,0 +1,2170 @@
+/* Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.textLayer {
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  opacity: 0.2;
+  line-height: 1;
+}
+
+.textLayer > span {
+  color: transparent;
+  position: absolute;
+  white-space: pre;
+  cursor: text;
+  transform-origin: 0% 0%;
+}
+
+.textLayer .highlight {
+  margin: -1px;
+  padding: 1px;
+  background-color: rgba(180, 0, 170, 1);
+  border-radius: 4px;
+}
+
+.textLayer .highlight.begin {
+  border-radius: 4px 0 0 4px;
+}
+
+.textLayer .highlight.end {
+  border-radius: 0 4px 4px 0;
+}
+
+.textLayer .highlight.middle {
+  border-radius: 0;
+}
+
+.textLayer .highlight.selected {
+  background-color: rgba(0, 100, 0, 1);
+}
+
+.textLayer ::selection {
+  background: rgba(0, 0, 255, 1);
+}
+
+.textLayer .endOfContent {
+  display: block;
+  position: absolute;
+  left: 0;
+  top: 100%;
+  right: 0;
+  bottom: 0;
+  z-index: -1;
+  cursor: default;
+  user-select: none;
+}
+
+.textLayer .endOfContent.active {
+  top: 0;
+}
+
+
+.annotationLayer section {
+  position: absolute;
+  text-align: initial;
+}
+
+.annotationLayer .linkAnnotation > a,
+.annotationLayer .buttonWidgetAnnotation.pushButton > a {
+  position: absolute;
+  font-size: 1em;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.annotationLayer .linkAnnotation > a:hover,
+.annotationLayer .buttonWidgetAnnotation.pushButton > a:hover {
+  opacity: 0.2;
+  background: rgba(255, 255, 0, 1);
+  box-shadow: 0 2px 10px rgba(255, 255, 0, 1);
+}
+
+.annotationLayer .textAnnotation img {
+  position: absolute;
+  cursor: pointer;
+}
+
+.annotationLayer .textWidgetAnnotation input,
+.annotationLayer .textWidgetAnnotation textarea,
+.annotationLayer .choiceWidgetAnnotation select,
+.annotationLayer .buttonWidgetAnnotation.checkBox input,
+.annotationLayer .buttonWidgetAnnotation.radioButton input {
+  background-color: rgba(0, 54, 255, 0.13);
+  border: 1px solid transparent;
+  box-sizing: border-box;
+  font-size: 9px;
+  height: 100%;
+  margin: 0;
+  padding: 0 3px;
+  vertical-align: top;
+  width: 100%;
+}
+
+.annotationLayer .choiceWidgetAnnotation select option {
+  padding: 0;
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input {
+  border-radius: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation textarea {
+  font: message-box;
+  font-size: 9px;
+  resize: none;
+}
+
+.annotationLayer .textWidgetAnnotation input[disabled],
+.annotationLayer .textWidgetAnnotation textarea[disabled],
+.annotationLayer .choiceWidgetAnnotation select[disabled],
+.annotationLayer .buttonWidgetAnnotation.checkBox input[disabled],
+.annotationLayer .buttonWidgetAnnotation.radioButton input[disabled] {
+  background: none;
+  border: 1px solid transparent;
+  cursor: not-allowed;
+}
+
+.annotationLayer .textWidgetAnnotation input:hover,
+.annotationLayer .textWidgetAnnotation textarea:hover,
+.annotationLayer .choiceWidgetAnnotation select:hover,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:hover,
+.annotationLayer .buttonWidgetAnnotation.radioButton input:hover {
+  border: 1px solid rgba(0, 0, 0, 1);
+}
+
+.annotationLayer .textWidgetAnnotation input:focus,
+.annotationLayer .textWidgetAnnotation textarea:focus,
+.annotationLayer .choiceWidgetAnnotation select:focus {
+  background: none;
+  border: 1px solid transparent;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after,
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before {
+  background-color: rgba(0, 0, 0, 1);
+  content: "";
+  display: block;
+  position: absolute;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after {
+  height: 80%;
+  left: 45%;
+  width: 1px;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before {
+  transform: rotate(45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after {
+  transform: rotate(-45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before {
+  border-radius: 50%;
+  height: 50%;
+  left: 30%;
+  top: 20%;
+  width: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb {
+  font-family: monospace;
+  padding-left: 2px;
+  padding-right: 0;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb:focus {
+  /*
+   * Letter spacing is placed on the right side of each character. Hence, the
+   * letter spacing of the last character may be placed outside the visible
+   * area, causing horizontal scrolling. We avoid this by extending the width
+   * when the element has focus and revert this when it loses focus.
+   */
+  width: 115%;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input,
+.annotationLayer .buttonWidgetAnnotation.radioButton input {
+  appearance: none;
+  padding: 0;
+}
+
+.annotationLayer .popupWrapper {
+  position: absolute;
+  width: 20em;
+}
+
+.annotationLayer .popup {
+  position: absolute;
+  z-index: 200;
+  max-width: 20em;
+  background-color: rgba(255, 255, 153, 1);
+  box-shadow: 0 2px 5px rgba(136, 136, 136, 1);
+  border-radius: 2px;
+  padding: 6px;
+  margin-left: 5px;
+  cursor: pointer;
+  font: message-box;
+  font-size: 9px;
+  white-space: normal;
+  word-wrap: break-word;
+}
+
+.annotationLayer .popup > * {
+  font-size: 9px;
+}
+
+.annotationLayer .popup h1 {
+  display: inline-block;
+}
+
+.annotationLayer .popup span {
+  display: inline-block;
+  margin-left: 5px;
+}
+
+.annotationLayer .popup p {
+  border-top: 1px solid rgba(51, 51, 51, 1);
+  margin-top: 2px;
+  padding-top: 2px;
+}
+
+.annotationLayer .highlightAnnotation,
+.annotationLayer .underlineAnnotation,
+.annotationLayer .squigglyAnnotation,
+.annotationLayer .strikeoutAnnotation,
+.annotationLayer .freeTextAnnotation,
+.annotationLayer .lineAnnotation svg line,
+.annotationLayer .squareAnnotation svg rect,
+.annotationLayer .circleAnnotation svg ellipse,
+.annotationLayer .polylineAnnotation svg polyline,
+.annotationLayer .polygonAnnotation svg polygon,
+.annotationLayer .caretAnnotation,
+.annotationLayer .inkAnnotation svg polyline,
+.annotationLayer .stampAnnotation,
+.annotationLayer .fileAttachmentAnnotation {
+  cursor: pointer;
+}
+
+.pdfViewer .canvasWrapper {
+  overflow: hidden;
+}
+
+.pdfViewer .page {
+  direction: ltr;
+  width: 816px;
+  height: 1056px;
+  margin: 1px auto -8px auto;
+  position: relative;
+  overflow: visible;
+  border: 9px solid transparent;
+  background-clip: content-box;
+  border-image: url(images/shadow.png) 9 9 repeat;
+  background-color: rgba(255, 255, 255, 1);
+}
+
+.pdfViewer.removePageBorders .page {
+  margin: 0 auto 10px auto;
+  border: none;
+}
+
+.pdfViewer.singlePageView {
+  display: inline-block;
+}
+
+.pdfViewer.singlePageView .page {
+  margin: 0;
+  border: none;
+}
+
+.pdfViewer.scrollHorizontal,
+.pdfViewer.scrollWrapped,
+.spread {
+  margin-left: 3.5px;
+  margin-right: 3.5px;
+  text-align: center;
+}
+
+.pdfViewer.scrollHorizontal,
+.spread {
+  white-space: nowrap;
+}
+
+.pdfViewer.removePageBorders,
+.pdfViewer.scrollHorizontal .spread,
+.pdfViewer.scrollWrapped .spread {
+  margin-left: 0;
+  margin-right: 0;
+}
+
+.spread .page,
+.pdfViewer.scrollHorizontal .page,
+.pdfViewer.scrollWrapped .page,
+.pdfViewer.scrollHorizontal .spread,
+.pdfViewer.scrollWrapped .spread {
+  display: inline-block;
+  vertical-align: middle;
+}
+
+.spread .page,
+.pdfViewer.scrollHorizontal .page,
+.pdfViewer.scrollWrapped .page {
+  margin-left: -3.5px;
+  margin-right: -3.5px;
+}
+
+.pdfViewer.removePageBorders .spread .page,
+.pdfViewer.removePageBorders.scrollHorizontal .page,
+.pdfViewer.removePageBorders.scrollWrapped .page {
+  margin-left: 5px;
+  margin-right: 5px;
+}
+
+.pdfViewer .page canvas {
+  margin: 0;
+  display: block;
+}
+
+.pdfViewer .page canvas[hidden] {
+  display: none;
+}
+
+.pdfViewer .page .loadingIcon {
+  position: absolute;
+  display: block;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  background: url("images/loading-icon.gif") center no-repeat;
+}
+
+.pdfPresentationMode .pdfViewer {
+  margin-left: 0;
+  margin-right: 0;
+}
+
+.pdfPresentationMode .pdfViewer .page,
+.pdfPresentationMode .pdfViewer .spread {
+  display: block;
+}
+
+.pdfPresentationMode .pdfViewer .page,
+.pdfPresentationMode .pdfViewer.removePageBorders .page {
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.pdfPresentationMode:fullscreen .pdfViewer .page {
+  margin-bottom: 100%;
+  border: 0;
+}
+
+:root {
+  --sidebar-width: 200px;
+  --sidebar-transition-duration: 200ms;
+  --sidebar-transition-timing-function: ease;
+  --loadingBar-end-offset: 0;
+
+  --toolbar-icon-opacity: 0.7;
+  --doorhanger-icon-opacity: 0.9;
+
+  --main-color: rgba(12, 12, 13, 1);
+  --body-bg-color: rgba(237, 237, 240, 1);
+  --errorWrapper-bg-color: rgba(255, 74, 74, 1);
+  --progressBar-color: rgba(10, 132, 255, 1);
+  --progressBar-indeterminate-bg-color: rgba(221, 221, 222, 1);
+  --progressBar-indeterminate-blend-color: rgba(116, 177, 239, 1);
+  --scrollbar-color: auto;
+  --scrollbar-bg-color: auto;
+  --toolbar-icon-bg-color: rgba(0, 0, 0, 1);
+
+  --sidebar-bg-color: rgba(245, 246, 247, 1);
+  --toolbar-bg-color: rgba(249, 249, 250, 1);
+  --toolbar-border-color: rgba(204, 204, 204, 1);
+  --button-hover-color: rgba(221, 222, 223, 1);
+  --toggled-btn-bg-color: rgba(0, 0, 0, 0.3);
+  --toggled-hover-active-btn-color: rgba(0, 0, 0, 0.4);
+  --dropdown-btn-bg-color: rgba(215, 215, 219, 1);
+  --separator-color: rgba(0, 0, 0, 0.3);
+  --field-color: rgba(6, 6, 6, 1);
+  --field-bg-color: rgba(255, 255, 255, 1);
+  --field-border-color: rgba(187, 187, 188, 1);
+  --findbar-nextprevious-btn-bg-color: rgba(227, 228, 230, 1);
+  --treeitem-color: rgba(0, 0, 0, 0.8);
+  --treeitem-hover-color: rgba(0, 0, 0, 0.9);
+  --treeitem-selected-color: rgba(0, 0, 0, 0.9);
+  --treeitem-selected-bg-color: rgba(0, 0, 0, 0.25);
+  --sidebaritem-bg-color: rgba(0, 0, 0, 0.15);
+  --doorhanger-bg-color: rgba(255, 255, 255, 1);
+  --doorhanger-border-color: rgba(12, 12, 13, 0.2);
+  --doorhanger-hover-color: rgba(237, 237, 237, 1);
+  --doorhanger-separator-color: rgba(222, 222, 222, 1);
+  --overlay-button-bg-color: rgba(12, 12, 13, 0.1);
+  --overlay-button-hover-color: rgba(12, 12, 13, 0.3);
+
+  --loading-icon: url(images/loading.svg);
+  --treeitem-expanded-icon: url(images/treeitem-expanded.svg);
+  --treeitem-collapsed-icon: url(images/treeitem-collapsed.svg);
+  --toolbarButton-menuArrow-icon: url(images/toolbarButton-menuArrow.svg);
+  --toolbarButton-sidebarToggle-icon: url(images/toolbarButton-sidebarToggle.svg);
+  --toolbarButton-secondaryToolbarToggle-icon: url(images/toolbarButton-secondaryToolbarToggle.svg);
+  --toolbarButton-pageUp-icon: url(images/toolbarButton-pageUp.svg);
+  --toolbarButton-pageDown-icon: url(images/toolbarButton-pageDown.svg);
+  --toolbarButton-zoomOut-icon: url(images/toolbarButton-zoomOut.svg);
+  --toolbarButton-zoomIn-icon: url(images/toolbarButton-zoomIn.svg);
+  --toolbarButton-presentationMode-icon: url(images/toolbarButton-presentationMode.svg);
+  --toolbarButton-print-icon: url(images/toolbarButton-print.svg);
+  --toolbarButton-openFile-icon: url(images/toolbarButton-openFile.svg);
+  --toolbarButton-download-icon: url(images/toolbarButton-download.svg);
+  --toolbarButton-bookmark-icon: url(images/toolbarButton-bookmark.svg);
+  --toolbarButton-viewThumbnail-icon: url(images/toolbarButton-viewThumbnail.svg);
+  --toolbarButton-viewOutline-icon: url(images/toolbarButton-viewOutline.svg);
+  --toolbarButton-viewAttachments-icon: url(images/toolbarButton-viewAttachments.svg);
+  --toolbarButton-viewLayers-icon: url(images/toolbarButton-viewLayers.svg);
+  --toolbarButton-currentOutlineItem-icon: url(images/toolbarButton-currentOutlineItem.svg);
+  --toolbarButton-search-icon: url(images/toolbarButton-search.svg);
+  --findbarButton-previous-icon: url(images/findbarButton-previous.svg);
+  --findbarButton-next-icon: url(images/findbarButton-next.svg);
+  --secondaryToolbarButton-firstPage-icon: url(images/secondaryToolbarButton-firstPage.svg);
+  --secondaryToolbarButton-lastPage-icon: url(images/secondaryToolbarButton-lastPage.svg);
+  --secondaryToolbarButton-rotateCcw-icon: url(images/secondaryToolbarButton-rotateCcw.svg);
+  --secondaryToolbarButton-rotateCw-icon: url(images/secondaryToolbarButton-rotateCw.svg);
+  --secondaryToolbarButton-selectTool-icon: url(images/secondaryToolbarButton-selectTool.svg);
+  --secondaryToolbarButton-handTool-icon: url(images/secondaryToolbarButton-handTool.svg);
+  --secondaryToolbarButton-scrollVertical-icon: url(images/secondaryToolbarButton-scrollVertical.svg);
+  --secondaryToolbarButton-scrollHorizontal-icon: url(images/secondaryToolbarButton-scrollHorizontal.svg);
+  --secondaryToolbarButton-scrollWrapped-icon: url(images/secondaryToolbarButton-scrollWrapped.svg);
+  --secondaryToolbarButton-spreadNone-icon: url(images/secondaryToolbarButton-spreadNone.svg);
+  --secondaryToolbarButton-spreadOdd-icon: url(images/secondaryToolbarButton-spreadOdd.svg);
+  --secondaryToolbarButton-spreadEven-icon: url(images/secondaryToolbarButton-spreadEven.svg);
+  --secondaryToolbarButton-documentProperties-icon: url(images/secondaryToolbarButton-documentProperties.svg);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --main-color: rgba(249, 249, 250, 1);
+    --body-bg-color: rgba(42, 42, 46, 1);
+    --errorWrapper-bg-color: rgba(199, 17, 17, 1);
+    --progressBar-color: rgba(0, 96, 223, 1);
+    --progressBar-indeterminate-bg-color: rgba(40, 40, 43, 1);
+    --progressBar-indeterminate-blend-color: rgba(20, 68, 133, 1);
+    --scrollbar-color: rgba(121, 121, 123, 1);
+    --scrollbar-bg-color: rgba(35, 35, 39, 1);
+    --toolbar-icon-bg-color: rgba(255, 255, 255, 1);
+
+    --sidebar-bg-color: rgba(50, 50, 52, 1);
+    --toolbar-bg-color: rgba(56, 56, 61, 1);
+    --toolbar-border-color: rgba(12, 12, 13, 1);
+    --button-hover-color: rgba(102, 102, 103, 1);
+    --toggled-btn-bg-color: rgba(0, 0, 0, 0.3);
+    --toggled-hover-active-btn-color: rgba(0, 0, 0, 0.4);
+    --dropdown-btn-bg-color: rgba(74, 74, 79, 1);
+    --separator-color: rgba(0, 0, 0, 0.3);
+    --field-color: rgba(250, 250, 250, 1);
+    --field-bg-color: rgba(64, 64, 68, 1);
+    --field-border-color: rgba(115, 115, 115, 1);
+    --findbar-nextprevious-btn-bg-color: rgba(89, 89, 89, 1);
+    --treeitem-color: rgba(255, 255, 255, 0.8);
+    --treeitem-hover-color: rgba(255, 255, 255, 0.9);
+    --treeitem-selected-color: rgba(255, 255, 255, 0.9);
+    --treeitem-selected-bg-color: rgba(255, 255, 255, 0.25);
+    --sidebaritem-bg-color: rgba(255, 255, 255, 0.15);
+    --doorhanger-bg-color: rgba(74, 74, 79, 1);
+    --doorhanger-border-color: rgba(39, 39, 43, 1);
+    --doorhanger-hover-color: rgba(93, 94, 98, 1);
+    --doorhanger-separator-color: rgba(92, 92, 97, 1);
+    --overlay-button-bg-color: rgba(92, 92, 97, 1);
+    --overlay-button-hover-color: rgba(115, 115, 115, 1);
+
+    /* This image is used in <input> elements, which unfortunately means that
+     * the `mask-image` approach used with all of the other images doesn't work
+     * here; hence why we still have two versions of this particular image. */
+    --loading-icon: url(images/loading-dark.svg);
+  }
+}
+
+* {
+  padding: 0;
+  margin: 0;
+}
+
+html {
+  height: 100%;
+  width: 100%;
+  /* Font size is needed to make the activity bar the correct size. */
+  font-size: 10px;
+}
+
+body {
+  height: 100%;
+  width: 100%;
+  background-color: var(--body-bg-color);
+}
+
+body,
+input,
+button,
+select {
+  font: message-box;
+  outline: none;
+  scrollbar-color: var(--scrollbar-color) var(--scrollbar-bg-color);
+}
+
+.hidden {
+  display: none !important;
+}
+[hidden] {
+  display: none !important;
+}
+
+.pdfViewer.enablePermissions .textLayer > span {
+  user-select: none !important;
+  cursor: not-allowed;
+}
+
+#viewerContainer.pdfPresentationMode:fullscreen {
+  top: 0;
+  border-top: 2px solid rgba(0, 0, 0, 0);
+  background-color: rgba(0, 0, 0, 1);
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  cursor: none;
+  user-select: none;
+}
+
+.pdfPresentationMode:fullscreen a:not(.internalLink) {
+  display: none;
+}
+
+.pdfPresentationMode:fullscreen .textLayer > span {
+  cursor: none;
+}
+
+.pdfPresentationMode.pdfPresentationModeControls > *,
+.pdfPresentationMode.pdfPresentationModeControls .textLayer > span {
+  cursor: default;
+}
+
+#outerContainer {
+  width: 100%;
+  height: 100%;
+  position: relative;
+}
+
+#sidebarContainer {
+  position: absolute;
+  top: 32px;
+  bottom: 0;
+  width: var(--sidebar-width);
+  visibility: hidden;
+  z-index: 100;
+  border-top: 1px solid rgba(51, 51, 51, 1);
+  transition-duration: var(--sidebar-transition-duration);
+  transition-timing-function: var(--sidebar-transition-timing-function);
+}
+html[dir="ltr"] #sidebarContainer {
+  transition-property: left;
+  left: calc(0px - var(--sidebar-width));
+}
+html[dir="rtl"] #sidebarContainer {
+  transition-property: right;
+  right: calc(0px - var(--sidebar-width));
+}
+
+#outerContainer.sidebarResizing #sidebarContainer {
+  /* Improve responsiveness and avoid visual glitches when the sidebar is resized. */
+  transition-duration: 0s;
+  /* Prevent e.g. the thumbnails being selected when the sidebar is resized. */
+  user-select: none;
+}
+
+#outerContainer.sidebarMoving #sidebarContainer,
+#outerContainer.sidebarOpen #sidebarContainer {
+  visibility: visible;
+}
+html[dir="ltr"] #outerContainer.sidebarOpen #sidebarContainer {
+  left: 0;
+}
+html[dir="rtl"] #outerContainer.sidebarOpen #sidebarContainer {
+  right: 0;
+}
+
+#mainContainer {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  min-width: 320px;
+}
+
+#sidebarContent {
+  top: 32px;
+  bottom: 0;
+  overflow: auto;
+  position: absolute;
+  width: 100%;
+  background-color: rgba(0, 0, 0, 0.1);
+}
+html[dir="ltr"] #sidebarContent {
+  left: 0;
+  box-shadow: inset -1px 0 0 rgba(0, 0, 0, 0.25);
+}
+html[dir="rtl"] #sidebarContent {
+  right: 0;
+  box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.25);
+}
+
+#viewerContainer {
+  overflow: auto;
+  position: absolute;
+  top: 32px;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  outline: none;
+}
+#viewerContainer:not(.pdfPresentationMode) {
+  transition-duration: var(--sidebar-transition-duration);
+  transition-timing-function: var(--sidebar-transition-timing-function);
+}
+
+#outerContainer.sidebarResizing #viewerContainer {
+  /* Improve responsiveness and avoid visual glitches when the sidebar is resized. */
+  transition-duration: 0s;
+}
+
+html[dir="ltr"]
+  #outerContainer.sidebarOpen
+  #viewerContainer:not(.pdfPresentationMode) {
+  transition-property: left;
+  left: var(--sidebar-width);
+}
+html[dir="rtl"]
+  #outerContainer.sidebarOpen
+  #viewerContainer:not(.pdfPresentationMode) {
+  transition-property: right;
+  right: var(--sidebar-width);
+}
+
+.toolbar {
+  position: relative;
+  left: 0;
+  right: 0;
+  z-index: 9999;
+  cursor: default;
+}
+
+#toolbarContainer {
+  width: 100%;
+}
+
+#toolbarSidebar {
+  width: 100%;
+  height: 32px;
+  background-color: var(--sidebar-bg-color);
+}
+html[dir="ltr"] #toolbarSidebar {
+  box-shadow: inset -1px 0 0 rgba(0, 0, 0, 0.25), 0 1px 0 rgba(0, 0, 0, 0.15),
+    0 0 1px rgba(0, 0, 0, 0.1);
+}
+html[dir="rtl"] #toolbarSidebar {
+  box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.25), 0 1px 0 rgba(0, 0, 0, 0.15),
+    0 0 1px rgba(0, 0, 0, 0.1);
+}
+
+html[dir="ltr"] #toolbarSidebar .toolbarButton {
+  margin-right: 2px !important;
+}
+html[dir="rtl"] #toolbarSidebar .toolbarButton {
+  margin-left: 2px !important;
+}
+
+html[dir="ltr"] #toolbarSidebarRight .toolbarButton {
+  margin-right: 3px !important;
+}
+html[dir="rtl"] #toolbarSidebarRight .toolbarButton {
+  margin-left: 3px !important;
+}
+
+#sidebarResizer {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  width: 6px;
+  z-index: 200;
+  cursor: ew-resize;
+}
+html[dir="ltr"] #sidebarResizer {
+  right: -6px;
+}
+html[dir="rtl"] #sidebarResizer {
+  left: -6px;
+}
+
+#toolbarContainer,
+.findbar,
+.secondaryToolbar {
+  position: relative;
+  height: 32px;
+  background-color: var(--toolbar-bg-color);
+  box-shadow: 0 1px 0 var(--toolbar-border-color);
+}
+
+#toolbarViewer {
+  height: 32px;
+}
+
+#loadingBar {
+  position: absolute;
+  height: 4px;
+  background-color: var(--body-bg-color);
+  border-bottom: 1px solid var(--toolbar-border-color);
+
+  transition-duration: var(--sidebar-transition-duration);
+  transition-timing-function: var(--sidebar-transition-timing-function);
+}
+html[dir="ltr"] #loadingBar {
+  transition-property: left;
+  left: 0;
+  right: var(--loadingBar-end-offset);
+}
+html[dir="rtl"] #loadingBar {
+  transition-property: right;
+  left: var(--loadingBar-end-offset);
+  right: 0;
+}
+
+html[dir="ltr"] #outerContainer.sidebarOpen #loadingBar {
+  left: var(--sidebar-width);
+}
+html[dir="rtl"] #outerContainer.sidebarOpen #loadingBar {
+  right: var(--sidebar-width);
+}
+
+#outerContainer.sidebarResizing #loadingBar {
+  /* Improve responsiveness and avoid visual glitches when the sidebar is resized. */
+  transition-duration: 0s;
+}
+
+#loadingBar .progress {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 0%;
+  height: 100%;
+  background-color: var(--progressBar-color);
+  overflow: hidden;
+  transition: width 200ms;
+}
+
+@keyframes progressIndeterminate {
+  0% {
+    left: -142px;
+  }
+  100% {
+    left: 0;
+  }
+}
+
+#loadingBar .progress.indeterminate {
+  background-color: var(--progressBar-indeterminate-bg-color);
+  transition: none;
+}
+
+#loadingBar .progress.indeterminate .glimmer {
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 100%;
+  width: calc(100% + 150px);
+  background: repeating-linear-gradient(
+    135deg,
+    var(--progressBar-indeterminate-blend-color) 0,
+    var(--progressBar-indeterminate-bg-color) 5px,
+    var(--progressBar-indeterminate-bg-color) 45px,
+    var(--progressBar-color) 55px,
+    var(--progressBar-color) 95px,
+    var(--progressBar-indeterminate-blend-color) 100px
+  );
+  animation: progressIndeterminate 1s linear infinite;
+}
+
+.findbar,
+.secondaryToolbar {
+  top: 32px;
+  position: absolute;
+  z-index: 10000;
+  height: auto;
+  min-width: 16px;
+  padding: 0 4px 0 4px;
+  margin: 4px 2px 4px 2px;
+  color: rgba(217, 217, 217, 1);
+  font-size: 12px;
+  line-height: 14px;
+  text-align: left;
+  cursor: default;
+}
+
+.findbar {
+  min-width: 300px;
+  background-color: var(--toolbar-bg-color);
+}
+.findbar > div {
+  height: 32px;
+}
+.findbar.wrapContainers > div {
+  clear: both;
+}
+.findbar.wrapContainers > div#findbarMessageContainer {
+  height: auto;
+}
+html[dir="ltr"] .findbar {
+  left: 64px;
+}
+html[dir="rtl"] .findbar {
+  right: 64px;
+}
+
+.findbar .splitToolbarButton {
+  margin-top: 3px;
+}
+html[dir="ltr"] .findbar .splitToolbarButton {
+  margin-left: 0;
+  margin-right: 5px;
+}
+html[dir="rtl"] .findbar .splitToolbarButton {
+  margin-left: 5px;
+  margin-right: 0;
+}
+
+.findbar .splitToolbarButton > .toolbarButton {
+  background-color: var(--findbar-nextprevious-btn-bg-color);
+  border-radius: 0;
+  height: 26px;
+  border-top: 1px solid var(--field-border-color);
+  border-bottom: 1px solid var(--field-border-color);
+}
+
+.findbar .splitToolbarButton > .toolbarButton::before {
+  top: 5px;
+}
+
+.findbar .splitToolbarButton > .findNext {
+  width: 29px;
+}
+html[dir="ltr"] .findbar .splitToolbarButton > .findNext {
+  border-bottom-right-radius: 2px;
+  border-top-right-radius: 2px;
+  border-right: 1px solid var(--field-border-color);
+}
+html[dir="rtl"] .findbar .splitToolbarButton > .findNext {
+  border-bottom-left-radius: 2px;
+  border-top-left-radius: 2px;
+  border-left: 1px solid var(--field-border-color);
+}
+
+.findbar input[type="checkbox"] {
+  pointer-events: none;
+}
+
+.findbar label {
+  user-select: none;
+}
+
+.findbar label:hover,
+.findbar input:focus + label {
+  background-color: var(--button-hover-color);
+}
+
+html[dir="ltr"] #findInput {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+html[dir="rtl"] #findInput {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.findbar .toolbarField[type="checkbox"]:checked + .toolbarLabel {
+  background-color: var(--toggled-btn-bg-color) !important;
+}
+
+#findInput {
+  width: 200px;
+}
+#findInput::placeholder {
+  font-style: normal;
+}
+#findInput[data-status="pending"] {
+  background-image: var(--loading-icon);
+  background-repeat: no-repeat;
+  background-position: 98%;
+}
+html[dir="rtl"] #findInput[data-status="pending"] {
+  background-position: 3px;
+}
+#findInput[data-status="notFound"] {
+  background-color: rgba(255, 102, 102, 1);
+}
+
+.secondaryToolbar {
+  padding: 6px 0 10px 0;
+  height: auto;
+  z-index: 30000;
+  background-color: var(--doorhanger-bg-color);
+}
+html[dir="ltr"] .secondaryToolbar {
+  right: 4px;
+}
+html[dir="rtl"] .secondaryToolbar {
+  left: 4px;
+}
+
+#secondaryToolbarButtonContainer {
+  max-width: 220px;
+  max-height: 400px;
+  overflow-y: auto;
+  margin-bottom: -4px;
+}
+
+#secondaryToolbarButtonContainer.hiddenScrollModeButtons > .scrollModeButtons,
+#secondaryToolbarButtonContainer.hiddenSpreadModeButtons > .spreadModeButtons {
+  display: none !important;
+}
+
+.doorHanger,
+.doorHangerRight {
+  border-radius: 2px;
+  box-shadow: 0 1px 5px var(--doorhanger-border-color),
+    0 0 0 1px var(--doorhanger-border-color);
+}
+.doorHanger:after,
+.doorHanger:before,
+.doorHangerRight:after,
+.doorHangerRight:before {
+  bottom: 100%;
+  border: solid rgba(0, 0, 0, 0);
+  content: " ";
+  height: 0;
+  width: 0;
+  position: absolute;
+  pointer-events: none;
+}
+.doorHanger:after,
+.doorHangerRight:after {
+  border-width: 8px;
+}
+.doorHanger:after {
+  border-bottom-color: var(--toolbar-bg-color);
+}
+.doorHangerRight:after {
+  border-bottom-color: var(--doorhanger-bg-color);
+}
+.doorHanger:before,
+.doorHangerRight:before {
+  border-bottom-color: var(--doorhanger-border-color);
+  border-width: 9px;
+}
+
+html[dir="ltr"] .doorHanger:after,
+html[dir="rtl"] .doorHangerRight:after {
+  left: 10px;
+  margin-left: -8px;
+}
+
+html[dir="ltr"] .doorHanger:before,
+html[dir="rtl"] .doorHangerRight:before {
+  left: 10px;
+  margin-left: -9px;
+}
+
+html[dir="rtl"] .doorHanger:after,
+html[dir="ltr"] .doorHangerRight:after {
+  right: 10px;
+  margin-right: -8px;
+}
+
+html[dir="rtl"] .doorHanger:before,
+html[dir="ltr"] .doorHangerRight:before {
+  right: 10px;
+  margin-right: -9px;
+}
+
+#findResultsCount {
+  background-color: rgba(217, 217, 217, 1);
+  color: rgba(82, 82, 82, 1);
+  text-align: center;
+  padding: 3px 4px;
+  margin: 5px;
+}
+
+#findMsg {
+  color: rgba(251, 0, 0, 1);
+}
+#findMsg:empty {
+  display: none;
+}
+
+#toolbarViewerMiddle {
+  position: absolute;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+html[dir="ltr"] #toolbarViewerLeft,
+html[dir="rtl"] #toolbarViewerRight,
+html[dir="ltr"] #toolbarSidebarLeft,
+html[dir="rtl"] #toolbarSidebarRight {
+  float: left;
+}
+html[dir="ltr"] #toolbarViewerRight,
+html[dir="rtl"] #toolbarViewerLeft,
+html[dir="ltr"] #toolbarSidebarRight,
+html[dir="rtl"] #toolbarSidebarLeft {
+  float: right;
+}
+html[dir="ltr"] #toolbarViewerLeft > *,
+html[dir="ltr"] #toolbarViewerMiddle > *,
+html[dir="ltr"] #toolbarViewerRight > *,
+html[dir="ltr"] #toolbarSidebarLeft *,
+html[dir="ltr"] #toolbarSidebarRight *,
+html[dir="ltr"] .findbar * {
+  position: relative;
+  float: left;
+}
+html[dir="rtl"] #toolbarViewerLeft > *,
+html[dir="rtl"] #toolbarViewerMiddle > *,
+html[dir="rtl"] #toolbarViewerRight > *,
+html[dir="rtl"] #toolbarSidebarLeft *,
+html[dir="rtl"] #toolbarSidebarRight *,
+html[dir="rtl"] .findbar * {
+  position: relative;
+  float: right;
+}
+
+.splitToolbarButton {
+  margin: 2px 2px 0;
+  display: inline-block;
+}
+html[dir="ltr"] .splitToolbarButton > .toolbarButton {
+  float: left;
+}
+html[dir="rtl"] .splitToolbarButton > .toolbarButton {
+  float: right;
+}
+
+.toolbarButton,
+.secondaryToolbarButton,
+.overlayButton {
+  border: 0 none;
+  background: none;
+  width: 28px;
+  height: 28px;
+}
+.overlayButton {
+  background-color: var(--overlay-button-bg-color);
+}
+
+.overlayButton:hover,
+.overlayButton:focus {
+  background-color: var(--overlay-button-hover-color);
+}
+
+.toolbarButton > span {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  overflow: hidden;
+}
+
+.toolbarButton[disabled],
+.secondaryToolbarButton[disabled],
+.overlayButton[disabled] {
+  opacity: 0.5;
+}
+
+.splitToolbarButton.toggled .toolbarButton {
+  margin: 0;
+}
+
+.splitToolbarButton > .toolbarButton:hover,
+.splitToolbarButton > .toolbarButton:focus,
+.dropdownToolbarButton:hover,
+.toolbarButton.textButton:hover,
+.toolbarButton.textButton:focus {
+  background-color: var(--button-hover-color);
+  z-index: 199;
+}
+.splitToolbarButton > .toolbarButton {
+  position: relative;
+}
+html[dir="ltr"] .splitToolbarButton > .toolbarButton:first-child,
+html[dir="rtl"] .splitToolbarButton > .toolbarButton:last-child {
+  margin: 0;
+}
+html[dir="ltr"] .splitToolbarButton > .toolbarButton:last-child,
+html[dir="rtl"] .splitToolbarButton > .toolbarButton:first-child {
+  margin: 0;
+}
+.splitToolbarButtonSeparator {
+  padding: 10px 0;
+  width: 1px;
+  background-color: var(--separator-color);
+  z-index: 99;
+  display: inline-block;
+  margin: 4px 0;
+}
+
+.findbar .splitToolbarButtonSeparator {
+  background-color: var(--field-border-color);
+  margin: 0;
+  padding: 13px 0;
+}
+
+html[dir="ltr"] .splitToolbarButtonSeparator {
+  float: left;
+}
+html[dir="rtl"] .splitToolbarButtonSeparator {
+  float: right;
+}
+
+.toolbarButton,
+.dropdownToolbarButton,
+.secondaryToolbarButton,
+.overlayButton {
+  min-width: 16px;
+  margin: 2px 1px;
+  padding: 2px 6px 0;
+  border: none;
+  border-radius: 2px;
+  color: var(--main-color);
+  font-size: 12px;
+  line-height: 14px;
+  user-select: none;
+  cursor: default;
+  box-sizing: border-box;
+}
+
+html[dir="ltr"] #toolbarViewerLeft > .toolbarButton:first-child,
+html[dir="rtl"] #toolbarViewerRight > .toolbarButton:last-child {
+  margin-left: 2px;
+}
+
+html[dir="ltr"] #toolbarViewerRight > .toolbarButton:last-child,
+html[dir="rtl"] #toolbarViewerLeft > .toolbarButton:first-child {
+  margin-right: 2px;
+}
+.toolbarButton:hover,
+.toolbarButton:focus {
+  background-color: var(--button-hover-color);
+}
+.secondaryToolbarButton:hover,
+.secondaryToolbarButton:focus {
+  background-color: var(--doorhanger-hover-color);
+}
+
+.toolbarButton.toggled,
+.splitToolbarButton.toggled > .toolbarButton.toggled,
+.secondaryToolbarButton.toggled {
+  background-color: var(--toggled-btn-bg-color);
+}
+
+.toolbarButton.toggled:hover:active,
+.splitToolbarButton.toggled > .toolbarButton.toggled:hover:active,
+.secondaryToolbarButton.toggled:hover:active {
+  background-color: var(--toggled-hover-active-btn-color);
+}
+
+.dropdownToolbarButton {
+  width: 140px;
+  padding: 0;
+  overflow: hidden;
+  background-color: var(--dropdown-btn-bg-color);
+  margin-top: 2px !important;
+}
+.dropdownToolbarButton::after {
+  top: 6px;
+  pointer-events: none;
+
+  mask-image: var(--toolbarButton-menuArrow-icon);
+}
+html[dir="ltr"] .dropdownToolbarButton::after {
+  right: 7px;
+}
+html[dir="rtl"] .dropdownToolbarButton::after {
+  left: 7px;
+}
+
+.dropdownToolbarButton > select {
+  width: 162px;
+  height: 28px;
+  font-size: 12px;
+  color: var(--main-color);
+  margin: 0;
+  padding: 1px 0 2px;
+  border: none;
+  background-color: var(--dropdown-btn-bg-color);
+}
+html[dir="ltr"] .dropdownToolbarButton > select {
+  padding-left: 4px;
+}
+html[dir="rtl"] .dropdownToolbarButton > select {
+  padding-right: 4px;
+}
+.dropdownToolbarButton > select:hover {
+  background-color: var(--button-hover-color);
+}
+
+.dropdownToolbarButton > select:focus {
+  background-color: var(--button-hover-color);
+}
+
+.dropdownToolbarButton > select > option {
+  background: var(--doorhanger-bg-color);
+}
+
+#customScaleOption {
+  display: none;
+}
+
+#pageWidthOption {
+  border-bottom: 1px rgba(255, 255, 255, 0.5) solid;
+}
+
+.toolbarButtonSpacer {
+  width: 30px;
+  display: inline-block;
+  height: 1px;
+}
+
+.toolbarButton::before,
+.secondaryToolbarButton::before,
+.dropdownToolbarButton::after,
+.treeItemToggler::before {
+  /* All matching images have a size of 16x16
+   * All relevant containers have a size of 28x28 */
+  position: absolute;
+  display: inline-block;
+  width: 16px;
+  height: 16px;
+
+  content: "";
+  background-color: var(--toolbar-icon-bg-color);
+  mask-size: cover;
+}
+
+.toolbarButton::before {
+  opacity: var(--toolbar-icon-opacity);
+  top: 6px;
+  left: 6px;
+}
+
+.secondaryToolbarButton::before {
+  opacity: var(--doorhanger-icon-opacity);
+  top: 5px;
+}
+html[dir="ltr"] .secondaryToolbarButton::before {
+  left: 12px;
+}
+html[dir="rtl"] .secondaryToolbarButton::before {
+  right: 12px;
+}
+
+.toolbarButton#sidebarToggle::before {
+  mask-image: var(--toolbarButton-sidebarToggle-icon);
+}
+html[dir="rtl"] .toolbarButton#sidebarToggle::before {
+  transform: scaleX(-1);
+}
+
+.toolbarButton#secondaryToolbarToggle::before {
+  mask-image: var(--toolbarButton-secondaryToolbarToggle-icon);
+}
+html[dir="rtl"] .toolbarButton#secondaryToolbarToggle::before {
+  transform: scaleX(-1);
+}
+
+.toolbarButton.findPrevious::before {
+  mask-image: var(--findbarButton-previous-icon);
+}
+
+.toolbarButton.findNext::before {
+  mask-image: var(--findbarButton-next-icon);
+}
+
+.toolbarButton.pageUp::before {
+  mask-image: var(--toolbarButton-pageUp-icon);
+}
+
+.toolbarButton.pageDown::before {
+  mask-image: var(--toolbarButton-pageDown-icon);
+}
+
+.toolbarButton.zoomOut::before {
+  mask-image: var(--toolbarButton-zoomOut-icon);
+}
+
+.toolbarButton.zoomIn::before {
+  mask-image: var(--toolbarButton-zoomIn-icon);
+}
+
+.toolbarButton.presentationMode::before,
+.secondaryToolbarButton.presentationMode::before {
+  mask-image: var(--toolbarButton-presentationMode-icon);
+}
+
+.toolbarButton.print::before,
+.secondaryToolbarButton.print::before {
+  mask-image: var(--toolbarButton-print-icon);
+}
+
+.toolbarButton.openFile::before,
+.secondaryToolbarButton.openFile::before {
+  mask-image: var(--toolbarButton-openFile-icon);
+}
+
+.toolbarButton.download::before,
+.secondaryToolbarButton.download::before {
+  mask-image: var(--toolbarButton-download-icon);
+}
+
+.secondaryToolbarButton.bookmark {
+  padding-top: 6px;
+  text-decoration: none;
+}
+
+.bookmark[href="#"] {
+  opacity: 0.5;
+  pointer-events: none;
+}
+
+.toolbarButton.bookmark::before,
+.secondaryToolbarButton.bookmark::before {
+  mask-image: var(--toolbarButton-bookmark-icon);
+}
+
+#viewThumbnail.toolbarButton::before {
+  mask-image: var(--toolbarButton-viewThumbnail-icon);
+}
+
+#viewOutline.toolbarButton::before {
+  mask-image: var(--toolbarButton-viewOutline-icon);
+}
+html[dir="rtl"] #viewOutline.toolbarButton::before {
+  transform: scaleX(-1);
+}
+
+#viewAttachments.toolbarButton::before {
+  mask-image: var(--toolbarButton-viewAttachments-icon);
+}
+
+#viewLayers.toolbarButton::before {
+  mask-image: var(--toolbarButton-viewLayers-icon);
+}
+
+#currentOutlineItem.toolbarButton::before {
+  mask-image: var(--toolbarButton-currentOutlineItem-icon);
+}
+html[dir="rtl"] #currentOutlineItem.toolbarButton::before {
+  transform: scaleX(-1);
+}
+
+#viewFind.toolbarButton::before {
+  mask-image: var(--toolbarButton-search-icon);
+}
+
+.toolbarButton.pdfSidebarNotification::after {
+  position: absolute;
+  display: inline-block;
+  top: 1px;
+  /* Create a filled circle, with a diameter of 9 pixels, using only CSS: */
+  content: "";
+  background-color: rgba(112, 219, 85, 1);
+  height: 9px;
+  width: 9px;
+  border-radius: 50%;
+}
+html[dir="ltr"] .toolbarButton.pdfSidebarNotification::after {
+  left: 17px;
+}
+html[dir="rtl"] .toolbarButton.pdfSidebarNotification::after {
+  right: 17px;
+}
+
+.secondaryToolbarButton {
+  position: relative;
+  margin: 0;
+  padding: 0 0 1px 0;
+  height: auto;
+  min-height: 26px;
+  width: auto;
+  min-width: 100%;
+  white-space: normal;
+  border-radius: 0;
+  box-sizing: border-box;
+}
+html[dir="ltr"] .secondaryToolbarButton {
+  padding-left: 36px;
+  text-align: left;
+}
+html[dir="rtl"] .secondaryToolbarButton {
+  padding-right: 36px;
+  text-align: right;
+}
+
+html[dir="ltr"] .secondaryToolbarButton > span {
+  padding-right: 4px;
+}
+html[dir="rtl"] .secondaryToolbarButton > span {
+  padding-left: 4px;
+}
+
+.secondaryToolbarButton.firstPage::before {
+  mask-image: var(--secondaryToolbarButton-firstPage-icon);
+}
+
+.secondaryToolbarButton.lastPage::before {
+  mask-image: var(--secondaryToolbarButton-lastPage-icon);
+}
+
+.secondaryToolbarButton.rotateCcw::before {
+  mask-image: var(--secondaryToolbarButton-rotateCcw-icon);
+}
+
+.secondaryToolbarButton.rotateCw::before {
+  mask-image: var(--secondaryToolbarButton-rotateCw-icon);
+}
+
+.secondaryToolbarButton.selectTool::before {
+  mask-image: var(--secondaryToolbarButton-selectTool-icon);
+}
+
+.secondaryToolbarButton.handTool::before {
+  mask-image: var(--secondaryToolbarButton-handTool-icon);
+}
+
+.secondaryToolbarButton.scrollVertical::before {
+  mask-image: var(--secondaryToolbarButton-scrollVertical-icon);
+}
+
+.secondaryToolbarButton.scrollHorizontal::before {
+  mask-image: var(--secondaryToolbarButton-scrollHorizontal-icon);
+}
+
+.secondaryToolbarButton.scrollWrapped::before {
+  mask-image: var(--secondaryToolbarButton-scrollWrapped-icon);
+}
+
+.secondaryToolbarButton.spreadNone::before {
+  mask-image: var(--secondaryToolbarButton-spreadNone-icon);
+}
+
+.secondaryToolbarButton.spreadOdd::before {
+  mask-image: var(--secondaryToolbarButton-spreadOdd-icon);
+}
+
+.secondaryToolbarButton.spreadEven::before {
+  mask-image: var(--secondaryToolbarButton-spreadEven-icon);
+}
+
+.secondaryToolbarButton.documentProperties::before {
+  mask-image: var(--secondaryToolbarButton-documentProperties-icon);
+}
+
+.verticalToolbarSeparator {
+  display: block;
+  padding: 11px 0;
+  margin: 5px 2px;
+  width: 1px;
+  background-color: var(--separator-color);
+}
+html[dir="ltr"] .verticalToolbarSeparator {
+  margin-left: 2px;
+}
+html[dir="rtl"] .verticalToolbarSeparator {
+  margin-right: 2px;
+}
+
+.horizontalToolbarSeparator {
+  display: block;
+  margin: 6px 0 5px 0;
+  height: 1px;
+  width: 100%;
+  border-top: 1px solid var(--doorhanger-separator-color);
+}
+
+.toolbarField {
+  padding: 4px 7px;
+  margin: 3px 0 3px 0;
+  border-radius: 2px;
+  background-color: var(--field-bg-color);
+  background-clip: padding-box;
+  border-width: 1px;
+  border-style: solid;
+  border-color: var(--field-border-color);
+  box-shadow: none;
+  color: var(--field-color);
+  font-size: 12px;
+  line-height: 16px;
+  outline-style: none;
+}
+
+.toolbarField[type="checkbox"] {
+  opacity: 0;
+  position: absolute !important;
+  left: 0;
+}
+
+html[dir="ltr"] .toolbarField[type="checkbox"] {
+  margin: 10px 0 3px 7px;
+}
+
+html[dir="rtl"] .toolbarField[type="checkbox"] {
+  margin: 10px 7px 3px 0;
+}
+
+.toolbarField.pageNumber {
+  -moz-appearance: textfield; /* hides the spinner in moz */
+  min-width: 16px;
+  text-align: right;
+  width: 40px;
+}
+
+.toolbarField.pageNumber.visiblePageIsLoading {
+  background-image: var(--loading-icon);
+  background-repeat: no-repeat;
+  background-position: 3px;
+}
+
+.toolbarField:focus {
+  border-color: #0a84ff;
+}
+
+.toolbarLabel {
+  min-width: 16px;
+  padding: 6px;
+  margin: 2px;
+  border: 1px solid rgba(0, 0, 0, 0);
+  border-radius: 2px;
+  color: var(--main-color);
+  font-size: 12px;
+  line-height: 14px;
+  text-align: left;
+  user-select: none;
+  cursor: default;
+}
+
+html[dir="ltr"] #numPages.toolbarLabel {
+  padding-left: 2px;
+}
+html[dir="rtl"] #numPages.toolbarLabel {
+  padding-right: 2px;
+}
+
+#thumbnailView {
+  position: absolute;
+  width: calc(100% - 60px);
+  top: 0;
+  bottom: 0;
+  padding: 10px 30px 0;
+  overflow: auto;
+}
+
+#thumbnailView > a:active,
+#thumbnailView > a:focus {
+  outline: 0;
+}
+
+.thumbnail {
+  margin: 0 10px 5px 10px;
+}
+html[dir="ltr"] .thumbnail {
+  float: left;
+}
+html[dir="rtl"] .thumbnail {
+  float: right;
+}
+
+#thumbnailView > a:last-of-type > .thumbnail {
+  margin-bottom: 10px;
+}
+
+#thumbnailView > a:last-of-type > .thumbnail:not([data-loaded]) {
+  margin-bottom: 9px;
+}
+
+.thumbnail:not([data-loaded]) {
+  border: 1px dashed rgba(132, 132, 132, 1);
+  margin: -1px 9px 4px 9px;
+}
+
+.thumbnailImage {
+  border: 1px solid rgba(0, 0, 0, 0);
+  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.5), 0 2px 8px rgba(0, 0, 0, 0.3);
+  opacity: 0.8;
+  z-index: 99;
+  background-color: rgba(255, 255, 255, 1);
+  background-clip: content-box;
+}
+
+.thumbnailSelectionRing {
+  border-radius: 2px;
+  padding: 7px;
+}
+
+a:focus > .thumbnail > .thumbnailSelectionRing > .thumbnailImage,
+.thumbnail:hover > .thumbnailSelectionRing > .thumbnailImage {
+  opacity: 0.9;
+}
+
+a:focus > .thumbnail > .thumbnailSelectionRing,
+.thumbnail:hover > .thumbnailSelectionRing {
+  background-color: var(--sidebaritem-bg-color);
+  background-clip: padding-box;
+  color: rgba(255, 255, 255, 0.9);
+}
+
+.thumbnail.selected > .thumbnailSelectionRing > .thumbnailImage {
+  opacity: 1;
+}
+
+.thumbnail.selected > .thumbnailSelectionRing {
+  background-color: var(--sidebaritem-bg-color);
+  background-clip: padding-box;
+  color: rgba(255, 255, 255, 1);
+}
+
+#outlineView,
+#attachmentsView,
+#layersView {
+  position: absolute;
+  width: calc(100% - 8px);
+  top: 0;
+  bottom: 0;
+  padding: 4px 4px 0;
+  overflow: auto;
+  user-select: none;
+}
+
+html[dir="ltr"] .treeWithDeepNesting > .treeItem,
+html[dir="ltr"] .treeItem > .treeItems {
+  margin-left: 20px;
+}
+
+html[dir="rtl"] .treeWithDeepNesting > .treeItem,
+html[dir="rtl"] .treeItem > .treeItems {
+  margin-right: 20px;
+}
+
+.treeItem > a {
+  text-decoration: none;
+  display: inline-block;
+  min-width: 95%;
+  /* Subtract the right padding (left, in RTL mode) of the container: */
+  min-width: calc(100% - 4px);
+  height: auto;
+  margin-bottom: 1px;
+  border-radius: 2px;
+  color: var(--treeitem-color);
+  font-size: 13px;
+  line-height: 15px;
+  user-select: none;
+  white-space: normal;
+  cursor: pointer;
+}
+html[dir="ltr"] .treeItem > a {
+  padding: 2px 0 5px 4px;
+}
+html[dir="rtl"] .treeItem > a {
+  padding: 2px 4px 5px 0;
+}
+
+#layersView .treeItem > a > * {
+  cursor: pointer;
+}
+html[dir="ltr"] #layersView .treeItem > a > label {
+  padding-left: 4px;
+}
+html[dir="rtl"] #layersView .treesItem > a > label {
+  padding-right: 4px;
+}
+
+.treeItemToggler {
+  position: relative;
+  height: 0;
+  width: 0;
+  color: rgba(255, 255, 255, 0.5);
+}
+.treeItemToggler::before {
+  mask-image: var(--treeitem-expanded-icon);
+}
+.treeItemToggler.treeItemsHidden::before {
+  mask-image: var(--treeitem-collapsed-icon);
+}
+html[dir="rtl"] .treeItemToggler.treeItemsHidden::before {
+  transform: scaleX(-1);
+}
+.treeItemToggler.treeItemsHidden ~ .treeItems {
+  display: none;
+}
+html[dir="ltr"] .treeItemToggler {
+  float: left;
+}
+html[dir="rtl"] .treeItemToggler {
+  float: right;
+}
+html[dir="ltr"] .treeItemToggler::before {
+  right: 4px;
+}
+html[dir="rtl"] .treeItemToggler::before {
+  left: 4px;
+}
+
+.treeItem.selected > a {
+  background-color: var(--treeitem-selected-bg-color);
+  color: var(--treeitem-selected-color);
+}
+
+.treeItemToggler:hover,
+.treeItemToggler:hover + a,
+.treeItemToggler:hover ~ .treeItems,
+.treeItem > a:hover {
+  background-color: var(--sidebaritem-bg-color);
+  background-clip: padding-box;
+  border-radius: 2px;
+  color: var(--treeitem-hover-color);
+}
+
+/* TODO: file FF bug to support ::-moz-selection:window-inactive
+   so we can override the opaque grey background when the window is inactive;
+   see https://bugzilla.mozilla.org/show_bug.cgi?id=706209 */
+::selection {
+  background: rgba(0, 0, 255, 0.3);
+}
+
+#errorWrapper {
+  background: none repeat scroll 0 0 var(--errorWrapper-bg-color);
+  color: var(--main-color);
+  left: 0;
+  position: absolute;
+  right: 0;
+  z-index: 1000;
+  padding: 3px 6px;
+}
+
+#errorMessageLeft {
+  float: left;
+}
+
+#errorMessageRight {
+  float: right;
+}
+
+#errorMoreInfo {
+  background-color: var(--field-bg-color);
+  color: var(--field-color);
+  border: 1px solid var(--field-border-color);
+  padding: 3px;
+  margin: 3px;
+  width: 98%;
+}
+
+.overlayButton {
+  width: auto;
+  margin: 3px 4px 2px 4px !important;
+  padding: 2px 11px 2px 11px;
+}
+
+#overlayContainer {
+  display: table;
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.2);
+  z-index: 40000;
+}
+#overlayContainer > * {
+  overflow: auto;
+}
+
+#overlayContainer > .container {
+  display: table-cell;
+  vertical-align: middle;
+  text-align: center;
+}
+
+#overlayContainer > .container > .dialog {
+  display: inline-block;
+  padding: 15px;
+  border-spacing: 4px;
+  color: var(--main-color);
+  font-size: 12px;
+  line-height: 14px;
+  background-color: var(--doorhanger-bg-color);
+  border: 1px solid rgba(0, 0, 0, 0.5);
+  border-radius: 4px;
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3);
+}
+
+.dialog > .row {
+  display: table-row;
+}
+
+.dialog > .row > * {
+  display: table-cell;
+}
+
+.dialog .toolbarField {
+  margin: 5px 0;
+}
+
+.dialog .separator {
+  display: block;
+  margin: 4px 0 4px 0;
+  height: 1px;
+  width: 100%;
+  background-color: var(--separator-color);
+}
+
+.dialog .buttonRow {
+  text-align: center;
+  vertical-align: middle;
+}
+
+.dialog :link {
+  color: rgba(255, 255, 255, 1);
+}
+
+#passwordOverlay > .dialog {
+  text-align: center;
+}
+#passwordOverlay .toolbarField {
+  width: 200px;
+}
+
+#documentPropertiesOverlay > .dialog {
+  text-align: left;
+}
+#documentPropertiesOverlay .row > * {
+  min-width: 100px;
+}
+html[dir="ltr"] #documentPropertiesOverlay .row > * {
+  text-align: left;
+}
+html[dir="rtl"] #documentPropertiesOverlay .row > * {
+  text-align: right;
+}
+#documentPropertiesOverlay .row > span {
+  width: 125px;
+  word-wrap: break-word;
+}
+#documentPropertiesOverlay .row > p {
+  max-width: 225px;
+  word-wrap: break-word;
+}
+#documentPropertiesOverlay .buttonRow {
+  margin-top: 10px;
+}
+
+.clearBoth {
+  clear: both;
+}
+
+.fileInput {
+  background: rgba(255, 255, 255, 1);
+  color: rgba(0, 0, 0, 1);
+  margin-top: 5px;
+  visibility: hidden;
+  position: fixed;
+  right: 0;
+  top: 0;
+}
+
+#PDFBug {
+  background: none repeat scroll 0 0 rgba(255, 255, 255, 1);
+  border: 1px solid rgba(102, 102, 102, 1);
+  position: fixed;
+  top: 32px;
+  right: 0;
+  bottom: 0;
+  font-size: 10px;
+  padding: 0;
+  width: 300px;
+}
+#PDFBug .controls {
+  background: rgba(238, 238, 238, 1);
+  border-bottom: 1px solid rgba(102, 102, 102, 1);
+  padding: 3px;
+}
+#PDFBug .panels {
+  bottom: 0;
+  left: 0;
+  overflow: auto;
+  position: absolute;
+  right: 0;
+  top: 27px;
+}
+#PDFBug .panels > div {
+  padding: 5px;
+}
+#PDFBug button.active {
+  font-weight: bold;
+}
+.debuggerShowText {
+  background: none repeat scroll 0 0 rgba(255, 255, 0, 1);
+  color: rgba(0, 0, 255, 1);
+}
+.debuggerHideText:hover {
+  background: none repeat scroll 0 0 rgba(255, 255, 0, 1);
+}
+#PDFBug .stats {
+  font-family: courier;
+  font-size: 10px;
+  white-space: pre;
+}
+#PDFBug .stats .title {
+  font-weight: bold;
+}
+#PDFBug table {
+  font-size: 10px;
+}
+
+#viewer.textLayer-visible .textLayer {
+  opacity: 1;
+}
+
+#viewer.textLayer-visible .canvasWrapper {
+  background-color: rgba(128, 255, 128, 1);
+}
+
+#viewer.textLayer-visible .canvasWrapper canvas {
+  mix-blend-mode: screen;
+}
+
+#viewer.textLayer-visible .textLayer > span {
+  background-color: rgba(255, 255, 0, 0.1);
+  color: rgba(0, 0, 0, 1);
+  border: solid 1px rgba(255, 0, 0, 0.5);
+  box-sizing: border-box;
+}
+
+#viewer.textLayer-hover .textLayer > span:hover {
+  background-color: rgba(255, 255, 255, 1);
+  color: rgba(0, 0, 0, 1);
+}
+
+#viewer.textLayer-shadow .textLayer > span {
+  background-color: rgba(255, 255, 255, 0.6);
+  color: rgba(0, 0, 0, 1);
+}
+
+.grab-to-pan-grab {
+  cursor: url("images/grab.cur"), move !important;
+  cursor: grab !important;
+}
+.grab-to-pan-grab
+  *:not(input):not(textarea):not(button):not(select):not(:link) {
+  cursor: inherit !important;
+}
+.grab-to-pan-grab:active,
+.grab-to-pan-grabbing {
+  cursor: url("images/grabbing.cur"), move !important;
+  cursor: grabbing !important;
+  position: fixed;
+  background: rgba(0, 0, 0, 0);
+  display: block;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  z-index: 50000; /* should be higher than anything else in PDF.js! */
+}
+
+@page {
+  margin: 0;
+}
+
+#printContainer {
+  display: none;
+}
+
+@media print {
+  /* General rules for printing. */
+  body {
+    background: rgba(0, 0, 0, 0) none;
+  }
+
+  /* Rules for browsers that don't support mozPrintCallback. */
+  #sidebarContainer,
+  #secondaryToolbar,
+  .toolbar,
+  #loadingBox,
+  #errorWrapper,
+  .textLayer {
+    display: none;
+  }
+  #viewerContainer {
+    overflow: visible;
+  }
+
+  #mainContainer,
+  #viewerContainer,
+  .page,
+  .page canvas {
+    position: static;
+    padding: 0;
+    margin: 0;
+  }
+
+  .page {
+    float: left;
+    display: none;
+    border: none;
+    box-shadow: none;
+    background-clip: content-box;
+    background-color: rgba(255, 255, 255, 1);
+  }
+
+  .page[data-loaded] {
+    display: block;
+  }
+
+  .fileInput {
+    display: none;
+  }
+
+  /* Rules for browsers that support PDF.js printing */
+  body[data-pdfjsprinting] #outerContainer {
+    display: none;
+  }
+  body[data-pdfjsprinting] #printContainer {
+    display: block;
+  }
+  #printContainer {
+    height: 100%;
+  }
+  /* wrapper around (scaled) print canvas elements */
+  #printContainer > div {
+    position: relative;
+    top: 0;
+    left: 0;
+    width: 1px;
+    height: 1px;
+    overflow: visible;
+    page-break-after: always;
+    page-break-inside: avoid;
+  }
+  #printContainer canvas,
+  #printContainer img {
+    direction: ltr;
+    display: block;
+  }
+}
+
+.visibleLargeView,
+.visibleMediumView,
+.visibleSmallView {
+  display: none;
+}
+
+@media all and (max-width: 900px) {
+  #toolbarViewerMiddle {
+    display: table;
+    margin: auto;
+    left: auto;
+    position: inherit;
+    transform: none;
+  }
+}
+
+@media all and (max-width: 840px) {
+  #sidebarContent {
+    background-color: rgba(0, 0, 0, 0.7);
+  }
+
+  html[dir="ltr"] #outerContainer.sidebarOpen #viewerContainer {
+    left: 0 !important;
+  }
+  html[dir="rtl"] #outerContainer.sidebarOpen #viewerContainer {
+    right: 0 !important;
+  }
+
+  #outerContainer .hiddenLargeView,
+  #outerContainer .hiddenMediumView {
+    display: inherit;
+  }
+  #outerContainer .visibleLargeView,
+  #outerContainer .visibleMediumView {
+    display: none;
+  }
+}
+
+@media all and (max-width: 770px) {
+  #outerContainer .hiddenLargeView {
+    display: none;
+  }
+  #outerContainer .visibleLargeView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 700px) {
+  #outerContainer .hiddenMediumView {
+    display: none;
+  }
+  #outerContainer .visibleMediumView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 640px) {
+  .hiddenSmallView,
+  .hiddenSmallView * {
+    display: none;
+  }
+  .visibleSmallView {
+    display: inherit;
+  }
+  .toolbarButtonSpacer {
+    width: 0;
+  }
+  html[dir="ltr"] .findbar {
+    left: 34px;
+  }
+  html[dir="rtl"] .findbar {
+    right: 34px;
+  }
+}
+
+@media all and (max-width: 535px) {
+  #scaleSelectContainer {
+    display: none;
+  }
+}
diff --git a/toolkit/components/pdfjs/content/web/viewer.html b/toolkit/components/pdfjs/content/web/viewer.html
new file mode 100644
index 0000000000..d6ee275e44
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/viewer.html
@@ -0,0 +1,394 @@
+<!DOCTYPE html>
+<!--
+Copyright 2012 Mozilla Foundation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Adobe CMap resources are covered by their own copyright but the same license:
+
+    Copyright 1990-2015 Adobe Systems Incorporated.
+
+See https://github.com/adobe-type-tools/cmap-resources
+-->
+<html dir="ltr" mozdisallowselectionprint>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+    <title>PDF.js viewer</title>
+
+<!-- This snippet is used in the Firefox extension (included from viewer.html) -->
+<base href="resource://pdf.js/web/">
+<script src="../build/pdf.js"></script>
+
+
+    <link rel="stylesheet" href="viewer.css">
+
+
+
+  <script src="viewer.js"></script>
+
+  </head>
+
+  <body tabindex="1">
+    <div id="outerContainer">
+
+      <div id="sidebarContainer">
+        <div id="toolbarSidebar">
+          <div id="toolbarSidebarLeft">
+            <div class="splitToolbarButton toggled">
+              <button id="viewThumbnail" class="toolbarButton toggled" title="Show Thumbnails" tabindex="2" data-l10n-id="thumbs">
+                 <span data-l10n-id="thumbs_label">Thumbnails</span>
+              </button>
+              <button id="viewOutline" class="toolbarButton" title="Show Document Outline (double-click to expand/collapse all items)" tabindex="3" data-l10n-id="document_outline">
+                 <span data-l10n-id="document_outline_label">Document Outline</span>
+              </button>
+              <button id="viewAttachments" class="toolbarButton" title="Show Attachments" tabindex="4" data-l10n-id="attachments">
+                 <span data-l10n-id="attachments_label">Attachments</span>
+              </button>
+              <button id="viewLayers" class="toolbarButton" title="Show Layers (double-click to reset all layers to the default state)" tabindex="5" data-l10n-id="layers">
+                 <span data-l10n-id="layers_label">Layers</span>
+              </button>
+            </div>
+          </div>
+
+          <div id="toolbarSidebarRight">
+            <div id="outlineOptionsContainer" class="hidden">
+              <div class="verticalToolbarSeparator"></div>
+
+              <button id="currentOutlineItem" class="toolbarButton" disabled="disabled" title="Find Current Outline Item" tabindex="6" data-l10n-id="current_outline_item">
+                <span data-l10n-id="current_outline_item_label">Current Outline Item</span>
+              </button>
+            </div>
+          </div>
+        </div>
+        <div id="sidebarContent">
+          <div id="thumbnailView">
+          </div>
+          <div id="outlineView" class="hidden">
+          </div>
+          <div id="attachmentsView" class="hidden">
+          </div>
+          <div id="layersView" class="hidden">
+          </div>
+        </div>
+        <div id="sidebarResizer"></div>
+      </div>  <!-- sidebarContainer -->
+
+      <div id="mainContainer">
+        <div class="findbar hidden doorHanger" id="findbar">
+          <div id="findbarInputContainer">
+            <input id="findInput" class="toolbarField" title="Find" placeholder="Find in document…" tabindex="91" data-l10n-id="find_input">
+            <div class="splitToolbarButton">
+              <button id="findPrevious" class="toolbarButton findPrevious" title="Find the previous occurrence of the phrase" tabindex="92" data-l10n-id="find_previous">
+                <span data-l10n-id="find_previous_label">Previous</span>
+              </button>
+              <div class="splitToolbarButtonSeparator"></div>
+              <button id="findNext" class="toolbarButton findNext" title="Find the next occurrence of the phrase" tabindex="93" data-l10n-id="find_next">
+                <span data-l10n-id="find_next_label">Next</span>
+              </button>
+            </div>
+          </div>
+
+          <div id="findbarOptionsOneContainer">
+            <input type="checkbox" id="findHighlightAll" class="toolbarField" tabindex="94">
+            <label for="findHighlightAll" class="toolbarLabel" data-l10n-id="find_highlight">Highlight all</label>
+            <input type="checkbox" id="findMatchCase" class="toolbarField" tabindex="95">
+            <label for="findMatchCase" class="toolbarLabel" data-l10n-id="find_match_case_label">Match case</label>
+          </div>
+          <div id="findbarOptionsTwoContainer">
+            <input type="checkbox" id="findEntireWord" class="toolbarField" tabindex="96">
+            <label for="findEntireWord" class="toolbarLabel" data-l10n-id="find_entire_word_label">Whole words</label>
+            <span id="findResultsCount" class="toolbarLabel hidden"></span>
+          </div>
+
+          <div id="findbarMessageContainer">
+            <span id="findMsg" class="toolbarLabel"></span>
+          </div>
+        </div>  <!-- findbar -->
+
+        <div id="secondaryToolbar" class="secondaryToolbar hidden doorHangerRight">
+          <div id="secondaryToolbarButtonContainer">
+            <button id="secondaryPresentationMode" class="secondaryToolbarButton presentationMode visibleLargeView" title="Switch to Presentation Mode" tabindex="51" data-l10n-id="presentation_mode">
+              <span data-l10n-id="presentation_mode_label">Presentation Mode</span>
+            </button>
+
+            <button id="secondaryOpenFile" class="secondaryToolbarButton openFile visibleLargeView" title="Open File" tabindex="52" data-l10n-id="open_file">
+              <span data-l10n-id="open_file_label">Open</span>
+            </button>
+
+            <button id="secondaryPrint" class="secondaryToolbarButton print visibleMediumView" title="Print" tabindex="53" data-l10n-id="print">
+              <span data-l10n-id="print_label">Print</span>
+            </button>
+
+            <button id="secondaryDownload" class="secondaryToolbarButton download visibleMediumView" title="Download" tabindex="54" data-l10n-id="download">
+              <span data-l10n-id="download_label">Download</span>
+            </button>
+
+            <a href="#" id="secondaryViewBookmark" class="secondaryToolbarButton bookmark visibleSmallView" title="Current view (copy or open in new window)" tabindex="55" data-l10n-id="bookmark">
+              <span data-l10n-id="bookmark_label">Current View</span>
+            </a>
+
+            <div class="horizontalToolbarSeparator visibleLargeView"></div>
+
+            <button id="firstPage" class="secondaryToolbarButton firstPage" title="Go to First Page" tabindex="56" data-l10n-id="first_page">
+              <span data-l10n-id="first_page_label">Go to First Page</span>
+            </button>
+            <button id="lastPage" class="secondaryToolbarButton lastPage" title="Go to Last Page" tabindex="57" data-l10n-id="last_page">
+              <span data-l10n-id="last_page_label">Go to Last Page</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="pageRotateCw" class="secondaryToolbarButton rotateCw" title="Rotate Clockwise" tabindex="58" data-l10n-id="page_rotate_cw">
+              <span data-l10n-id="page_rotate_cw_label">Rotate Clockwise</span>
+            </button>
+            <button id="pageRotateCcw" class="secondaryToolbarButton rotateCcw" title="Rotate Counterclockwise" tabindex="59" data-l10n-id="page_rotate_ccw">
+              <span data-l10n-id="page_rotate_ccw_label">Rotate Counterclockwise</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="cursorSelectTool" class="secondaryToolbarButton selectTool toggled" title="Enable Text Selection Tool" tabindex="60" data-l10n-id="cursor_text_select_tool">
+              <span data-l10n-id="cursor_text_select_tool_label">Text Selection Tool</span>
+            </button>
+            <button id="cursorHandTool" class="secondaryToolbarButton handTool" title="Enable Hand Tool" tabindex="61" data-l10n-id="cursor_hand_tool">
+              <span data-l10n-id="cursor_hand_tool_label">Hand Tool</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="scrollVertical" class="secondaryToolbarButton scrollModeButtons scrollVertical toggled" title="Use Vertical Scrolling" tabindex="62" data-l10n-id="scroll_vertical">
+              <span data-l10n-id="scroll_vertical_label">Vertical Scrolling</span>
+            </button>
+            <button id="scrollHorizontal" class="secondaryToolbarButton scrollModeButtons scrollHorizontal" title="Use Horizontal Scrolling" tabindex="63" data-l10n-id="scroll_horizontal">
+              <span data-l10n-id="scroll_horizontal_label">Horizontal Scrolling</span>
+            </button>
+            <button id="scrollWrapped" class="secondaryToolbarButton scrollModeButtons scrollWrapped" title="Use Wrapped Scrolling" tabindex="64" data-l10n-id="scroll_wrapped">
+              <span data-l10n-id="scroll_wrapped_label">Wrapped Scrolling</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator scrollModeButtons"></div>
+
+            <button id="spreadNone" class="secondaryToolbarButton spreadModeButtons spreadNone toggled" title="Do not join page spreads" tabindex="65" data-l10n-id="spread_none">
+              <span data-l10n-id="spread_none_label">No Spreads</span>
+            </button>
+            <button id="spreadOdd" class="secondaryToolbarButton spreadModeButtons spreadOdd" title="Join page spreads starting with odd-numbered pages" tabindex="66" data-l10n-id="spread_odd">
+              <span data-l10n-id="spread_odd_label">Odd Spreads</span>
+            </button>
+            <button id="spreadEven" class="secondaryToolbarButton spreadModeButtons spreadEven" title="Join page spreads starting with even-numbered pages" tabindex="67" data-l10n-id="spread_even">
+              <span data-l10n-id="spread_even_label">Even Spreads</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator spreadModeButtons"></div>
+
+            <button id="documentProperties" class="secondaryToolbarButton documentProperties" title="Document Properties…" tabindex="68" data-l10n-id="document_properties">
+              <span data-l10n-id="document_properties_label">Document Properties…</span>
+            </button>
+          </div>
+        </div>  <!-- secondaryToolbar -->
+
+        <div class="toolbar">
+          <div id="toolbarContainer">
+            <div id="toolbarViewer">
+              <div id="toolbarViewerLeft">
+                <button id="sidebarToggle" class="toolbarButton" title="Toggle Sidebar" tabindex="11" data-l10n-id="toggle_sidebar">
+                  <span data-l10n-id="toggle_sidebar_label">Toggle Sidebar</span>
+                </button>
+                <div class="toolbarButtonSpacer"></div>
+                <button id="viewFind" class="toolbarButton" title="Find in Document" tabindex="12" data-l10n-id="findbar">
+                  <span data-l10n-id="findbar_label">Find</span>
+                </button>
+                <div class="splitToolbarButton hiddenSmallView">
+                  <button class="toolbarButton pageUp" title="Previous Page" id="previous" tabindex="13" data-l10n-id="previous">
+                    <span data-l10n-id="previous_label">Previous</span>
+                  </button>
+                  <div class="splitToolbarButtonSeparator"></div>
+                  <button class="toolbarButton pageDown" title="Next Page" id="next" tabindex="14" data-l10n-id="next">
+                    <span data-l10n-id="next_label">Next</span>
+                  </button>
+                </div>
+                <input type="number" id="pageNumber" class="toolbarField pageNumber" title="Page" value="1" size="4" min="1" tabindex="15" data-l10n-id="page" autocomplete="off">
+                <span id="numPages" class="toolbarLabel"></span>
+              </div>
+              <div id="toolbarViewerRight">
+                <button id="presentationMode" class="toolbarButton presentationMode hiddenLargeView" title="Switch to Presentation Mode" tabindex="31" data-l10n-id="presentation_mode">
+                  <span data-l10n-id="presentation_mode_label">Presentation Mode</span>
+                </button>
+
+                <button id="openFile" class="toolbarButton openFile hiddenLargeView" title="Open File" tabindex="32" data-l10n-id="open_file">
+                  <span data-l10n-id="open_file_label">Open</span>
+                </button>
+
+                <button id="print" class="toolbarButton print hiddenMediumView" title="Print" tabindex="33" data-l10n-id="print">
+                  <span data-l10n-id="print_label">Print</span>
+                </button>
+
+                <button id="download" class="toolbarButton download hiddenMediumView" title="Download" tabindex="34" data-l10n-id="download">
+                  <span data-l10n-id="download_label">Download</span>
+                </button>
+                <a href="#" id="viewBookmark" class="toolbarButton bookmark hiddenSmallView" title="Current view (copy or open in new window)" tabindex="35" data-l10n-id="bookmark">
+                  <span data-l10n-id="bookmark_label">Current View</span>
+                </a>
+
+                <div class="verticalToolbarSeparator hiddenSmallView"></div>
+
+                <button id="secondaryToolbarToggle" class="toolbarButton" title="Tools" tabindex="36" data-l10n-id="tools">
+                  <span data-l10n-id="tools_label">Tools</span>
+                </button>
+              </div>
+              <div id="toolbarViewerMiddle">
+                <div class="splitToolbarButton">
+                  <button id="zoomOut" class="toolbarButton zoomOut" title="Zoom Out" tabindex="21" data-l10n-id="zoom_out">
+                    <span data-l10n-id="zoom_out_label">Zoom Out</span>
+                  </button>
+                  <div class="splitToolbarButtonSeparator"></div>
+                  <button id="zoomIn" class="toolbarButton zoomIn" title="Zoom In" tabindex="22" data-l10n-id="zoom_in">
+                    <span data-l10n-id="zoom_in_label">Zoom In</span>
+                   </button>
+                </div>
+                <span id="scaleSelectContainer" class="dropdownToolbarButton">
+                  <select id="scaleSelect" title="Zoom" tabindex="23" data-l10n-id="zoom">
+                    <option id="pageAutoOption" title="" value="auto" selected="selected" data-l10n-id="page_scale_auto">Automatic Zoom</option>
+                    <option id="pageActualOption" title="" value="page-actual" data-l10n-id="page_scale_actual">Actual Size</option>
+                    <option id="pageFitOption" title="" value="page-fit" data-l10n-id="page_scale_fit">Page Fit</option>
+                    <option id="pageWidthOption" title="" value="page-width" data-l10n-id="page_scale_width">Page Width</option>
+                    <option id="customScaleOption" title="" value="custom" disabled="disabled" hidden="true"></option>
+                    <option title="" value="0.5" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 50 }'>50%</option>
+                    <option title="" value="0.75" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 75 }'>75%</option>
+                    <option title="" value="1" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 100 }'>100%</option>
+                    <option title="" value="1.25" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 125 }'>125%</option>
+                    <option title="" value="1.5" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 150 }'>150%</option>
+                    <option title="" value="2" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 200 }'>200%</option>
+                    <option title="" value="3" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 300 }'>300%</option>
+                    <option title="" value="4" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 400 }'>400%</option>
+                  </select>
+                </span>
+              </div>
+            </div>
+            <div id="loadingBar">
+              <div class="progress">
+                <div class="glimmer">
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <menu type="context" id="viewerContextMenu">
+          <menuitem id="contextFirstPage" label="First Page"
+                    data-l10n-id="first_page"></menuitem>
+          <menuitem id="contextLastPage" label="Last Page"
+                    data-l10n-id="last_page"></menuitem>
+          <menuitem id="contextPageRotateCw" label="Rotate Clockwise"
+                    data-l10n-id="page_rotate_cw"></menuitem>
+          <menuitem id="contextPageRotateCcw" label="Rotate Counter-Clockwise"
+                    data-l10n-id="page_rotate_ccw"></menuitem>
+        </menu>
+
+        <div id="viewerContainer" tabindex="0">
+          <div id="viewer" class="pdfViewer"></div>
+        </div>
+
+        <div id="errorWrapper" hidden='true'>
+          <div id="errorMessageLeft">
+            <span id="errorMessage"></span>
+            <button id="errorShowMore" data-l10n-id="error_more_info">
+              More Information
+            </button>
+            <button id="errorShowLess" data-l10n-id="error_less_info" hidden='true'>
+              Less Information
+            </button>
+          </div>
+          <div id="errorMessageRight">
+            <button id="errorClose" data-l10n-id="error_close">
+              Close
+            </button>
+          </div>
+          <div class="clearBoth"></div>
+          <textarea id="errorMoreInfo" hidden='true' readonly="readonly"></textarea>
+        </div>
+      </div> <!-- mainContainer -->
+
+      <div id="overlayContainer" class="hidden">
+        <div id="passwordOverlay" class="container hidden">
+          <div class="dialog">
+            <div class="row">
+              <p id="passwordText" data-l10n-id="password_label">Enter the password to open this PDF file:</p>
+            </div>
+            <div class="row">
+              <input type="password" id="password" class="toolbarField">
+            </div>
+            <div class="buttonRow">
+              <button id="passwordCancel" class="overlayButton"><span data-l10n-id="password_cancel">Cancel</span></button>
+              <button id="passwordSubmit" class="overlayButton"><span data-l10n-id="password_ok">OK</span></button>
+            </div>
+          </div>
+        </div>
+        <div id="documentPropertiesOverlay" class="container hidden">
+          <div class="dialog">
+            <div class="row">
+              <span data-l10n-id="document_properties_file_name">File name:</span> <p id="fileNameField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_file_size">File size:</span> <p id="fileSizeField">-</p>
+            </div>
+            <div class="separator"></div>
+            <div class="row">
+              <span data-l10n-id="document_properties_title">Title:</span> <p id="titleField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_author">Author:</span> <p id="authorField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_subject">Subject:</span> <p id="subjectField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_keywords">Keywords:</span> <p id="keywordsField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_creation_date">Creation Date:</span> <p id="creationDateField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_modification_date">Modification Date:</span> <p id="modificationDateField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_creator">Creator:</span> <p id="creatorField">-</p>
+            </div>
+            <div class="separator"></div>
+            <div class="row">
+              <span data-l10n-id="document_properties_producer">PDF Producer:</span> <p id="producerField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_version">PDF Version:</span> <p id="versionField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_page_count">Page Count:</span> <p id="pageCountField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_page_size">Page Size:</span> <p id="pageSizeField">-</p>
+            </div>
+            <div class="separator"></div>
+            <div class="row">
+              <span data-l10n-id="document_properties_linearized">Fast Web View:</span> <p id="linearizedField">-</p>
+            </div>
+            <div class="buttonRow">
+              <button id="documentPropertiesClose" class="overlayButton"><span data-l10n-id="document_properties_close">Close</span></button>
+            </div>
+          </div>
+        </div>
+      </div>  <!-- overlayContainer -->
+
+    </div> <!-- outerContainer -->
+    <div id="printContainer"></div>
+  </body>
+</html>
diff --git a/toolkit/components/pdfjs/content/web/viewer.js b/toolkit/components/pdfjs/content/web/viewer.js
new file mode 100644
index 0000000000..a00c774025
--- /dev/null
+++ b/toolkit/components/pdfjs/content/web/viewer.js
@@ -0,0 +1,13800 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "PDFViewerApplicationOptions", ({
+  enumerable: true,
+  get: function () {
+    return _app_options.AppOptions;
+  }
+}));
+Object.defineProperty(exports, "PDFViewerApplication", ({
+  enumerable: true,
+  get: function () {
+    return _app.PDFViewerApplication;
+  }
+}));
+
+var _app_options = __webpack_require__(1);
+
+var _app = __webpack_require__(3);
+
+const pdfjsVersion = '2.7.510';
+const pdfjsBuild = '631bada0d';
+window.PDFViewerApplication = _app.PDFViewerApplication;
+window.PDFViewerApplicationOptions = _app_options.AppOptions;
+;
+{
+  __webpack_require__(35);
+
+  __webpack_require__(38);
+}
+;
+;
+;
+
+function getViewerConfiguration() {
+  return {
+    appContainer: document.body,
+    mainContainer: document.getElementById("viewerContainer"),
+    viewerContainer: document.getElementById("viewer"),
+    eventBus: null,
+    toolbar: {
+      container: document.getElementById("toolbarViewer"),
+      numPages: document.getElementById("numPages"),
+      pageNumber: document.getElementById("pageNumber"),
+      scaleSelectContainer: document.getElementById("scaleSelectContainer"),
+      scaleSelect: document.getElementById("scaleSelect"),
+      customScaleOption: document.getElementById("customScaleOption"),
+      previous: document.getElementById("previous"),
+      next: document.getElementById("next"),
+      zoomIn: document.getElementById("zoomIn"),
+      zoomOut: document.getElementById("zoomOut"),
+      viewFind: document.getElementById("viewFind"),
+      openFile: document.getElementById("openFile"),
+      print: document.getElementById("print"),
+      presentationModeButton: document.getElementById("presentationMode"),
+      download: document.getElementById("download"),
+      viewBookmark: document.getElementById("viewBookmark")
+    },
+    secondaryToolbar: {
+      toolbar: document.getElementById("secondaryToolbar"),
+      toggleButton: document.getElementById("secondaryToolbarToggle"),
+      toolbarButtonContainer: document.getElementById("secondaryToolbarButtonContainer"),
+      presentationModeButton: document.getElementById("secondaryPresentationMode"),
+      openFileButton: document.getElementById("secondaryOpenFile"),
+      printButton: document.getElementById("secondaryPrint"),
+      downloadButton: document.getElementById("secondaryDownload"),
+      viewBookmarkButton: document.getElementById("secondaryViewBookmark"),
+      firstPageButton: document.getElementById("firstPage"),
+      lastPageButton: document.getElementById("lastPage"),
+      pageRotateCwButton: document.getElementById("pageRotateCw"),
+      pageRotateCcwButton: document.getElementById("pageRotateCcw"),
+      cursorSelectToolButton: document.getElementById("cursorSelectTool"),
+      cursorHandToolButton: document.getElementById("cursorHandTool"),
+      scrollVerticalButton: document.getElementById("scrollVertical"),
+      scrollHorizontalButton: document.getElementById("scrollHorizontal"),
+      scrollWrappedButton: document.getElementById("scrollWrapped"),
+      spreadNoneButton: document.getElementById("spreadNone"),
+      spreadOddButton: document.getElementById("spreadOdd"),
+      spreadEvenButton: document.getElementById("spreadEven"),
+      documentPropertiesButton: document.getElementById("documentProperties")
+    },
+    fullscreen: {
+      contextFirstPage: document.getElementById("contextFirstPage"),
+      contextLastPage: document.getElementById("contextLastPage"),
+      contextPageRotateCw: document.getElementById("contextPageRotateCw"),
+      contextPageRotateCcw: document.getElementById("contextPageRotateCcw")
+    },
+    sidebar: {
+      outerContainer: document.getElementById("outerContainer"),
+      viewerContainer: document.getElementById("viewerContainer"),
+      toggleButton: document.getElementById("sidebarToggle"),
+      thumbnailButton: document.getElementById("viewThumbnail"),
+      outlineButton: document.getElementById("viewOutline"),
+      attachmentsButton: document.getElementById("viewAttachments"),
+      layersButton: document.getElementById("viewLayers"),
+      thumbnailView: document.getElementById("thumbnailView"),
+      outlineView: document.getElementById("outlineView"),
+      attachmentsView: document.getElementById("attachmentsView"),
+      layersView: document.getElementById("layersView"),
+      outlineOptionsContainer: document.getElementById("outlineOptionsContainer"),
+      currentOutlineItemButton: document.getElementById("currentOutlineItem")
+    },
+    sidebarResizer: {
+      outerContainer: document.getElementById("outerContainer"),
+      resizer: document.getElementById("sidebarResizer")
+    },
+    findBar: {
+      bar: document.getElementById("findbar"),
+      toggleButton: document.getElementById("viewFind"),
+      findField: document.getElementById("findInput"),
+      highlightAllCheckbox: document.getElementById("findHighlightAll"),
+      caseSensitiveCheckbox: document.getElementById("findMatchCase"),
+      entireWordCheckbox: document.getElementById("findEntireWord"),
+      findMsg: document.getElementById("findMsg"),
+      findResultsCount: document.getElementById("findResultsCount"),
+      findPreviousButton: document.getElementById("findPrevious"),
+      findNextButton: document.getElementById("findNext")
+    },
+    passwordOverlay: {
+      overlayName: "passwordOverlay",
+      container: document.getElementById("passwordOverlay"),
+      label: document.getElementById("passwordText"),
+      input: document.getElementById("password"),
+      submitButton: document.getElementById("passwordSubmit"),
+      cancelButton: document.getElementById("passwordCancel")
+    },
+    documentProperties: {
+      overlayName: "documentPropertiesOverlay",
+      container: document.getElementById("documentPropertiesOverlay"),
+      closeButton: document.getElementById("documentPropertiesClose"),
+      fields: {
+        fileName: document.getElementById("fileNameField"),
+        fileSize: document.getElementById("fileSizeField"),
+        title: document.getElementById("titleField"),
+        author: document.getElementById("authorField"),
+        subject: document.getElementById("subjectField"),
+        keywords: document.getElementById("keywordsField"),
+        creationDate: document.getElementById("creationDateField"),
+        modificationDate: document.getElementById("modificationDateField"),
+        creator: document.getElementById("creatorField"),
+        producer: document.getElementById("producerField"),
+        version: document.getElementById("versionField"),
+        pageCount: document.getElementById("pageCountField"),
+        pageSize: document.getElementById("pageSizeField"),
+        linearized: document.getElementById("linearizedField")
+      }
+    },
+    errorWrapper: {
+      container: document.getElementById("errorWrapper"),
+      errorMessage: document.getElementById("errorMessage"),
+      closeButton: document.getElementById("errorClose"),
+      errorMoreInfo: document.getElementById("errorMoreInfo"),
+      moreInfoButton: document.getElementById("errorShowMore"),
+      lessInfoButton: document.getElementById("errorShowLess")
+    },
+    printContainer: document.getElementById("printContainer"),
+    openFileInputName: "fileInput",
+    debuggerScriptPath: "./debugger.js"
+  };
+}
+
+function webViewerLoad() {
+  const config = getViewerConfiguration();
+
+  _app.PDFViewerApplication.run(config);
+}
+
+if (document.readyState === "interactive" || document.readyState === "complete") {
+  webViewerLoad();
+} else {
+  document.addEventListener("DOMContentLoaded", webViewerLoad, true);
+}
+
+/***/ }),
+/* 1 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.OptionKind = exports.AppOptions = void 0;
+
+var _viewer_compatibility = __webpack_require__(2);
+
+const OptionKind = {
+  VIEWER: 0x02,
+  API: 0x04,
+  WORKER: 0x08,
+  PREFERENCE: 0x80
+};
+exports.OptionKind = OptionKind;
+const defaultOptions = {
+  cursorToolOnLoad: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  defaultUrl: {
+    value: "compressed.tracemonkey-pldi-09.pdf",
+    kind: OptionKind.VIEWER
+  },
+  defaultZoomValue: {
+    value: "",
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  disableHistory: {
+    value: false,
+    kind: OptionKind.VIEWER
+  },
+  disablePageLabels: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enablePermissions: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enablePrintAutoRotate: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enableScripting: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enableWebGL: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  externalLinkRel: {
+    value: "noopener noreferrer nofollow",
+    kind: OptionKind.VIEWER
+  },
+  externalLinkTarget: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  historyUpdateUrl: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  ignoreDestinationZoom: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  imageResourcesPath: {
+    value: "./images/",
+    kind: OptionKind.VIEWER
+  },
+  maxCanvasPixels: {
+    value: 16777216,
+    compatibility: _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels,
+    kind: OptionKind.VIEWER
+  },
+  pdfBugEnabled: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  printResolution: {
+    value: 150,
+    kind: OptionKind.VIEWER
+  },
+  renderer: {
+    value: "canvas",
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  renderInteractiveForms: {
+    value: true,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  sidebarViewOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  scrollModeOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  spreadModeOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  textLayerMode: {
+    value: 1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  useOnlyCssZoom: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  viewerCssTheme: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  viewOnLoad: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  cMapPacked: {
+    value: true,
+    kind: OptionKind.API
+  },
+  cMapUrl: {
+    value: "../web/cmaps/",
+    kind: OptionKind.API
+  },
+  disableAutoFetch: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableFontFace: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableRange: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableStream: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  docBaseUrl: {
+    value: "",
+    kind: OptionKind.API
+  },
+  fontExtraProperties: {
+    value: false,
+    kind: OptionKind.API
+  },
+  isEvalSupported: {
+    value: true,
+    kind: OptionKind.API
+  },
+  maxImageSize: {
+    value: -1,
+    kind: OptionKind.API
+  },
+  pdfBug: {
+    value: false,
+    kind: OptionKind.API
+  },
+  verbosity: {
+    value: 1,
+    kind: OptionKind.API
+  },
+  workerPort: {
+    value: null,
+    kind: OptionKind.WORKER
+  },
+  workerSrc: {
+    value: "../build/pdf.worker.js",
+    kind: OptionKind.WORKER
+  }
+};
+;
+const userOptions = Object.create(null);
+
+class AppOptions {
+  constructor() {
+    throw new Error("Cannot initialize AppOptions.");
+  }
+
+  static get(name) {
+    const userOption = userOptions[name];
+
+    if (userOption !== undefined) {
+      return userOption;
+    }
+
+    const defaultOption = defaultOptions[name];
+
+    if (defaultOption !== undefined) {
+      return defaultOption.compatibility || defaultOption.value;
+    }
+
+    return undefined;
+  }
+
+  static getAll(kind = null) {
+    const options = Object.create(null);
+
+    for (const name in defaultOptions) {
+      const defaultOption = defaultOptions[name];
+
+      if (kind) {
+        if ((kind & defaultOption.kind) === 0) {
+          continue;
+        }
+
+        if (kind === OptionKind.PREFERENCE) {
+          const value = defaultOption.value,
+                valueType = typeof value;
+
+          if (valueType === "boolean" || valueType === "string" || valueType === "number" && Number.isInteger(value)) {
+            options[name] = value;
+            continue;
+          }
+
+          throw new Error(`Invalid type for preference: ${name}`);
+        }
+      }
+
+      const userOption = userOptions[name];
+      options[name] = userOption !== undefined ? userOption : defaultOption.compatibility || defaultOption.value;
+    }
+
+    return options;
+  }
+
+  static set(name, value) {
+    userOptions[name] = value;
+  }
+
+  static setAll(options) {
+    for (const name in options) {
+      userOptions[name] = options[name];
+    }
+  }
+
+  static remove(name) {
+    delete userOptions[name];
+  }
+
+}
+
+exports.AppOptions = AppOptions;
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.viewerCompatibilityParams = void 0;
+const compatibilityParams = Object.create(null);
+;
+const viewerCompatibilityParams = Object.freeze(compatibilityParams);
+exports.viewerCompatibilityParams = viewerCompatibilityParams;
+
+/***/ }),
+/* 3 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFViewerApplication = exports.PDFPrintServiceFactory = exports.DefaultExternalServices = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _app_options = __webpack_require__(1);
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _pdf_cursor_tools = __webpack_require__(6);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+var _overlay_manager = __webpack_require__(9);
+
+var _password_prompt = __webpack_require__(10);
+
+var _pdf_attachment_viewer = __webpack_require__(11);
+
+var _pdf_document_properties = __webpack_require__(13);
+
+var _pdf_find_bar = __webpack_require__(14);
+
+var _pdf_find_controller = __webpack_require__(15);
+
+var _pdf_history = __webpack_require__(17);
+
+var _pdf_layer_viewer = __webpack_require__(18);
+
+var _pdf_link_service = __webpack_require__(19);
+
+var _pdf_outline_viewer = __webpack_require__(20);
+
+var _pdf_presentation_mode = __webpack_require__(21);
+
+var _pdf_sidebar = __webpack_require__(22);
+
+var _pdf_sidebar_resizer = __webpack_require__(23);
+
+var _pdf_thumbnail_viewer = __webpack_require__(24);
+
+var _pdf_viewer = __webpack_require__(26);
+
+var _secondary_toolbar = __webpack_require__(31);
+
+var _toolbar = __webpack_require__(33);
+
+var _viewer_compatibility = __webpack_require__(2);
+
+var _view_history = __webpack_require__(34);
+
+const DEFAULT_SCALE_DELTA = 1.1;
+const DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
+const FORCE_PAGES_LOADED_TIMEOUT = 10000;
+const WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
+const ENABLE_PERMISSIONS_CLASS = "enablePermissions";
+const ViewOnLoad = {
+  UNKNOWN: -1,
+  PREVIOUS: 0,
+  INITIAL: 1
+};
+const ViewerCssTheme = {
+  AUTOMATIC: 0,
+  LIGHT: 1,
+  DARK: 2
+};
+const KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
+const KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
+
+class DefaultExternalServices {
+  constructor() {
+    throw new Error("Cannot initialize DefaultExternalServices.");
+  }
+
+  static updateFindControlState(data) {}
+
+  static updateFindMatchesCount(data) {}
+
+  static initPassiveLoading(callbacks) {}
+
+  static async fallback(data) {}
+
+  static reportTelemetry(data) {}
+
+  static createDownloadManager(options) {
+    throw new Error("Not implemented: createDownloadManager");
+  }
+
+  static createPreferences() {
+    throw new Error("Not implemented: createPreferences");
+  }
+
+  static createL10n(options) {
+    throw new Error("Not implemented: createL10n");
+  }
+
+  static createScripting(options) {
+    throw new Error("Not implemented: createScripting");
+  }
+
+  static get supportsIntegratedFind() {
+    return (0, _pdfjsLib.shadow)(this, "supportsIntegratedFind", false);
+  }
+
+  static get supportsDocumentFonts() {
+    return (0, _pdfjsLib.shadow)(this, "supportsDocumentFonts", true);
+  }
+
+  static get supportedMouseWheelZoomModifierKeys() {
+    return (0, _pdfjsLib.shadow)(this, "supportedMouseWheelZoomModifierKeys", {
+      ctrlKey: true,
+      metaKey: true
+    });
+  }
+
+  static get isInAutomation() {
+    return (0, _pdfjsLib.shadow)(this, "isInAutomation", false);
+  }
+
+}
+
+exports.DefaultExternalServices = DefaultExternalServices;
+const PDFViewerApplication = {
+  initialBookmark: document.location.hash.substring(1),
+  _initializedCapability: (0, _pdfjsLib.createPromiseCapability)(),
+  fellback: false,
+  appConfig: null,
+  pdfDocument: null,
+  pdfLoadingTask: null,
+  printService: null,
+  pdfViewer: null,
+  pdfThumbnailViewer: null,
+  pdfRenderingQueue: null,
+  pdfPresentationMode: null,
+  pdfDocumentProperties: null,
+  pdfLinkService: null,
+  pdfHistory: null,
+  pdfSidebar: null,
+  pdfSidebarResizer: null,
+  pdfOutlineViewer: null,
+  pdfAttachmentViewer: null,
+  pdfLayerViewer: null,
+  pdfCursorTools: null,
+  store: null,
+  downloadManager: null,
+  overlayManager: null,
+  preferences: null,
+  toolbar: null,
+  secondaryToolbar: null,
+  eventBus: null,
+  l10n: null,
+  isInitialViewSet: false,
+  downloadComplete: false,
+  isViewerEmbedded: window.parent !== window,
+  url: "",
+  baseUrl: "",
+  externalServices: DefaultExternalServices,
+  _boundEvents: Object.create(null),
+  documentInfo: null,
+  metadata: null,
+  _contentDispositionFilename: null,
+  _contentLength: null,
+  triggerDelayedFallback: null,
+  _saveInProgress: false,
+  _wheelUnusedTicks: 0,
+  _idleCallbacks: new Set(),
+  _scriptingInstance: null,
+  _mouseState: Object.create(null),
+
+  async initialize(appConfig) {
+    this.preferences = this.externalServices.createPreferences();
+    this.appConfig = appConfig;
+    await this._readPreferences();
+    await this._parseHashParameters();
+
+    this._forceCssTheme();
+
+    await this._initializeL10n();
+
+    if (this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdfjsLib.LinkTarget.NONE) {
+      _app_options.AppOptions.set("externalLinkTarget", _pdfjsLib.LinkTarget.TOP);
+    }
+
+    await this._initializeViewerComponents();
+    this.bindEvents();
+    this.bindWindowEvents();
+    const appContainer = appConfig.appContainer || document.documentElement;
+    this.l10n.translate(appContainer).then(() => {
+      this.eventBus.dispatch("localized", {
+        source: this
+      });
+    });
+
+    this._initializedCapability.resolve();
+  },
+
+  async _readPreferences() {
+    try {
+      _app_options.AppOptions.setAll(await this.preferences.getAll());
+    } catch (reason) {
+      console.error(`_readPreferences: "${reason?.message}".`);
+    }
+  },
+
+  async _parseHashParameters() {
+    if (!_app_options.AppOptions.get("pdfBugEnabled")) {
+      return undefined;
+    }
+
+    const hash = document.location.hash.substring(1);
+
+    if (!hash) {
+      return undefined;
+    }
+
+    const hashParams = (0, _ui_utils.parseQueryString)(hash),
+          waitOn = [];
+
+    if ("disableworker" in hashParams && hashParams.disableworker === "true") {
+      waitOn.push(loadFakeWorker());
+    }
+
+    if ("disablerange" in hashParams) {
+      _app_options.AppOptions.set("disableRange", hashParams.disablerange === "true");
+    }
+
+    if ("disablestream" in hashParams) {
+      _app_options.AppOptions.set("disableStream", hashParams.disablestream === "true");
+    }
+
+    if ("disableautofetch" in hashParams) {
+      _app_options.AppOptions.set("disableAutoFetch", hashParams.disableautofetch === "true");
+    }
+
+    if ("disablefontface" in hashParams) {
+      _app_options.AppOptions.set("disableFontFace", hashParams.disablefontface === "true");
+    }
+
+    if ("disablehistory" in hashParams) {
+      _app_options.AppOptions.set("disableHistory", hashParams.disablehistory === "true");
+    }
+
+    if ("webgl" in hashParams) {
+      _app_options.AppOptions.set("enableWebGL", hashParams.webgl === "true");
+    }
+
+    if ("verbosity" in hashParams) {
+      _app_options.AppOptions.set("verbosity", hashParams.verbosity | 0);
+    }
+
+    if ("textlayer" in hashParams) {
+      switch (hashParams.textlayer) {
+        case "off":
+          _app_options.AppOptions.set("textLayerMode", _ui_utils.TextLayerMode.DISABLE);
+
+          break;
+
+        case "visible":
+        case "shadow":
+        case "hover":
+          const viewer = this.appConfig.viewerContainer;
+          viewer.classList.add("textLayer-" + hashParams.textlayer);
+          break;
+      }
+    }
+
+    if ("pdfbug" in hashParams) {
+      _app_options.AppOptions.set("pdfBug", true);
+
+      _app_options.AppOptions.set("fontExtraProperties", true);
+
+      const enabled = hashParams.pdfbug.split(",");
+      waitOn.push(loadAndEnablePDFBug(enabled));
+    }
+
+    if (waitOn.length === 0) {
+      return undefined;
+    }
+
+    return Promise.all(waitOn).catch(reason => {
+      console.error(`_parseHashParameters: "${reason.message}".`);
+    });
+  },
+
+  async _initializeL10n() {
+    this.l10n = this.externalServices.createL10n(null);
+    const dir = await this.l10n.getDirection();
+    document.getElementsByTagName("html")[0].dir = dir;
+  },
+
+  _forceCssTheme() {
+    const cssTheme = _app_options.AppOptions.get("viewerCssTheme");
+
+    if (cssTheme === ViewerCssTheme.AUTOMATIC || !Object.values(ViewerCssTheme).includes(cssTheme)) {
+      return;
+    }
+
+    try {
+      const styleSheet = document.styleSheets[0];
+      const cssRules = styleSheet?.cssRules || [];
+
+      for (let i = 0, ii = cssRules.length; i < ii; i++) {
+        const rule = cssRules[i];
+
+        if (rule instanceof CSSMediaRule && rule.media?.[0] === "(prefers-color-scheme: dark)") {
+          if (cssTheme === ViewerCssTheme.LIGHT) {
+            styleSheet.deleteRule(i);
+            return;
+          }
+
+          const darkRules = /^@media \(prefers-color-scheme: dark\) {\n\s*([\w\s-.,:;/\\{}()]+)\n}$/.exec(rule.cssText);
+
+          if (darkRules?.[1]) {
+            styleSheet.deleteRule(i);
+            styleSheet.insertRule(darkRules[1], i);
+          }
+
+          return;
+        }
+      }
+    } catch (reason) {
+      console.error(`_forceCssTheme: "${reason?.message}".`);
+    }
+  },
+
+  async _initializeViewerComponents() {
+    const appConfig = this.appConfig;
+    const eventBus = appConfig.eventBus || new _ui_utils.EventBus({
+      isInAutomation: this.externalServices.isInAutomation
+    });
+    this.eventBus = eventBus;
+    this.overlayManager = new _overlay_manager.OverlayManager();
+    const pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
+    pdfRenderingQueue.onIdle = this.cleanup.bind(this);
+    this.pdfRenderingQueue = pdfRenderingQueue;
+    const pdfLinkService = new _pdf_link_service.PDFLinkService({
+      eventBus,
+      externalLinkTarget: _app_options.AppOptions.get("externalLinkTarget"),
+      externalLinkRel: _app_options.AppOptions.get("externalLinkRel"),
+      ignoreDestinationZoom: _app_options.AppOptions.get("ignoreDestinationZoom")
+    });
+    this.pdfLinkService = pdfLinkService;
+    const downloadManager = this.externalServices.createDownloadManager();
+    this.downloadManager = downloadManager;
+    const findController = new _pdf_find_controller.PDFFindController({
+      linkService: pdfLinkService,
+      eventBus
+    });
+    this.findController = findController;
+    const container = appConfig.mainContainer;
+    const viewer = appConfig.viewerContainer;
+    this.pdfViewer = new _pdf_viewer.PDFViewer({
+      container,
+      viewer,
+      eventBus,
+      renderingQueue: pdfRenderingQueue,
+      linkService: pdfLinkService,
+      downloadManager,
+      findController,
+      renderer: _app_options.AppOptions.get("renderer"),
+      enableWebGL: _app_options.AppOptions.get("enableWebGL"),
+      l10n: this.l10n,
+      textLayerMode: _app_options.AppOptions.get("textLayerMode"),
+      imageResourcesPath: _app_options.AppOptions.get("imageResourcesPath"),
+      renderInteractiveForms: _app_options.AppOptions.get("renderInteractiveForms"),
+      enablePrintAutoRotate: _app_options.AppOptions.get("enablePrintAutoRotate"),
+      useOnlyCssZoom: _app_options.AppOptions.get("useOnlyCssZoom"),
+      maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels"),
+      enableScripting: _app_options.AppOptions.get("enableScripting"),
+      mouseState: this._mouseState
+    });
+    pdfRenderingQueue.setViewer(this.pdfViewer);
+    pdfLinkService.setViewer(this.pdfViewer);
+    this.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
+      container: appConfig.sidebar.thumbnailView,
+      eventBus,
+      renderingQueue: pdfRenderingQueue,
+      linkService: pdfLinkService,
+      l10n: this.l10n
+    });
+    pdfRenderingQueue.setThumbnailViewer(this.pdfThumbnailViewer);
+    this.pdfHistory = new _pdf_history.PDFHistory({
+      linkService: pdfLinkService,
+      eventBus
+    });
+    pdfLinkService.setHistory(this.pdfHistory);
+
+    if (!this.supportsIntegratedFind) {
+      this.findBar = new _pdf_find_bar.PDFFindBar(appConfig.findBar, eventBus, this.l10n);
+    }
+
+    this.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, this.l10n);
+    this.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
+      container,
+      eventBus,
+      cursorToolOnLoad: _app_options.AppOptions.get("cursorToolOnLoad")
+    });
+    this.toolbar = new _toolbar.Toolbar(appConfig.toolbar, eventBus, this.l10n);
+    this.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
+
+    if (this.supportsFullscreen) {
+      this.pdfPresentationMode = new _pdf_presentation_mode.PDFPresentationMode({
+        container,
+        pdfViewer: this.pdfViewer,
+        eventBus,
+        contextMenuItems: appConfig.fullscreen
+      });
+    }
+
+    this.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.l10n);
+    this.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
+      container: appConfig.sidebar.outlineView,
+      eventBus,
+      linkService: pdfLinkService
+    });
+    this.pdfAttachmentViewer = new _pdf_attachment_viewer.PDFAttachmentViewer({
+      container: appConfig.sidebar.attachmentsView,
+      eventBus,
+      downloadManager
+    });
+    this.pdfLayerViewer = new _pdf_layer_viewer.PDFLayerViewer({
+      container: appConfig.sidebar.layersView,
+      eventBus,
+      l10n: this.l10n
+    });
+    this.pdfSidebar = new _pdf_sidebar.PDFSidebar({
+      elements: appConfig.sidebar,
+      pdfViewer: this.pdfViewer,
+      pdfThumbnailViewer: this.pdfThumbnailViewer,
+      eventBus,
+      l10n: this.l10n
+    });
+    this.pdfSidebar.onToggled = this.forceRendering.bind(this);
+    this.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, this.l10n);
+  },
+
+  run(config) {
+    this.initialize(config).then(webViewerInitialized);
+  },
+
+  get initialized() {
+    return this._initializedCapability.settled;
+  },
+
+  get initializedPromise() {
+    return this._initializedCapability.promise;
+  },
+
+  zoomIn(ticks) {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
+    let newScale = this.pdfViewer.currentScale;
+
+    do {
+      newScale = (newScale * DEFAULT_SCALE_DELTA).toFixed(2);
+      newScale = Math.ceil(newScale * 10) / 10;
+      newScale = Math.min(_ui_utils.MAX_SCALE, newScale);
+    } while (--ticks > 0 && newScale < _ui_utils.MAX_SCALE);
+
+    this.pdfViewer.currentScaleValue = newScale;
+  },
+
+  zoomOut(ticks) {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
+    let newScale = this.pdfViewer.currentScale;
+
+    do {
+      newScale = (newScale / DEFAULT_SCALE_DELTA).toFixed(2);
+      newScale = Math.floor(newScale * 10) / 10;
+      newScale = Math.max(_ui_utils.MIN_SCALE, newScale);
+    } while (--ticks > 0 && newScale > _ui_utils.MIN_SCALE);
+
+    this.pdfViewer.currentScaleValue = newScale;
+  },
+
+  zoomReset() {
+    if (this.pdfViewer.isInPresentationMode) {
+      return;
+    }
+
+    this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+  },
+
+  get pagesCount() {
+    return this.pdfDocument ? this.pdfDocument.numPages : 0;
+  },
+
+  get page() {
+    return this.pdfViewer.currentPageNumber;
+  },
+
+  set page(val) {
+    this.pdfViewer.currentPageNumber = val;
+  },
+
+  get supportsPrinting() {
+    return PDFPrintServiceFactory.instance.supportsPrinting;
+  },
+
+  get supportsFullscreen() {
+    let support;
+    support = document.fullscreenEnabled === true || document.mozFullScreenEnabled === true;
+    return (0, _pdfjsLib.shadow)(this, "supportsFullscreen", support);
+  },
+
+  get supportsIntegratedFind() {
+    return this.externalServices.supportsIntegratedFind;
+  },
+
+  get supportsDocumentFonts() {
+    return this.externalServices.supportsDocumentFonts;
+  },
+
+  get loadingBar() {
+    const bar = new _ui_utils.ProgressBar("#loadingBar");
+    return (0, _pdfjsLib.shadow)(this, "loadingBar", bar);
+  },
+
+  get supportedMouseWheelZoomModifierKeys() {
+    return this.externalServices.supportedMouseWheelZoomModifierKeys;
+  },
+
+  initPassiveLoading() {
+    this.externalServices.initPassiveLoading({
+      onOpenWithTransport(url, length, transport) {
+        PDFViewerApplication.open(url, {
+          length,
+          range: transport
+        });
+      },
+
+      onOpenWithData(data) {
+        PDFViewerApplication.open(data);
+      },
+
+      onOpenWithURL(url, length, originalUrl) {
+        let file = url,
+            args = null;
+
+        if (length !== undefined) {
+          args = {
+            length
+          };
+        }
+
+        if (originalUrl !== undefined) {
+          file = {
+            url,
+            originalUrl
+          };
+        }
+
+        PDFViewerApplication.open(file, args);
+      },
+
+      onError(err) {
+        PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(msg => {
+          PDFViewerApplication.error(msg, err);
+        });
+      },
+
+      onProgress(loaded, total) {
+        PDFViewerApplication.progress(loaded / total);
+      }
+
+    });
+  },
+
+  setTitleUsingUrl(url = "") {
+    this.url = url;
+    this.baseUrl = url.split("#")[0];
+    let title = (0, _ui_utils.getPDFFileNameFromURL)(url, "");
+
+    if (!title) {
+      try {
+        title = decodeURIComponent((0, _pdfjsLib.getFilenameFromUrl)(url)) || url;
+      } catch (ex) {
+        title = url;
+      }
+    }
+
+    this.setTitle(title);
+  },
+
+  setTitle(title) {
+    if (this.isViewerEmbedded) {
+      return;
+    }
+
+    document.title = title;
+  },
+
+  get _docFilename() {
+    return this._contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
+  },
+
+  _cancelIdleCallbacks() {
+    if (!this._idleCallbacks.size) {
+      return;
+    }
+
+    for (const callback of this._idleCallbacks) {
+      window.cancelIdleCallback(callback);
+    }
+
+    this._idleCallbacks.clear();
+  },
+
+  async _destroyScriptingInstance() {
+    if (!this._scriptingInstance) {
+      return;
+    }
+
+    const {
+      scripting,
+      internalEvents,
+      domEvents
+    } = this._scriptingInstance;
+
+    try {
+      await scripting.destroySandbox();
+    } catch (ex) {}
+
+    for (const [name, listener] of internalEvents) {
+      this.eventBus._off(name, listener);
+    }
+
+    internalEvents.clear();
+
+    for (const [name, listener] of domEvents) {
+      window.removeEventListener(name, listener);
+    }
+
+    domEvents.clear();
+    delete this._mouseState.isDown;
+    this._scriptingInstance = null;
+  },
+
+  async close() {
+    const errorWrapper = this.appConfig.errorWrapper.container;
+    errorWrapper.setAttribute("hidden", "true");
+
+    if (!this.pdfLoadingTask) {
+      return undefined;
+    }
+
+    const promises = [];
+    promises.push(this.pdfLoadingTask.destroy());
+    this.pdfLoadingTask = null;
+
+    if (this.pdfDocument) {
+      this.pdfDocument = null;
+      this.pdfThumbnailViewer.setDocument(null);
+      this.pdfViewer.setDocument(null);
+      this.pdfLinkService.setDocument(null);
+      this.pdfDocumentProperties.setDocument(null);
+    }
+
+    webViewerResetPermissions();
+    this.store = null;
+    this.isInitialViewSet = false;
+    this.downloadComplete = false;
+    this.url = "";
+    this.baseUrl = "";
+    this.documentInfo = null;
+    this.metadata = null;
+    this._contentDispositionFilename = null;
+    this._contentLength = null;
+    this.triggerDelayedFallback = null;
+    this._saveInProgress = false;
+
+    this._cancelIdleCallbacks();
+
+    promises.push(this._destroyScriptingInstance());
+    this.pdfSidebar.reset();
+    this.pdfOutlineViewer.reset();
+    this.pdfAttachmentViewer.reset();
+    this.pdfLayerViewer.reset();
+
+    if (this.pdfHistory) {
+      this.pdfHistory.reset();
+    }
+
+    if (this.findBar) {
+      this.findBar.reset();
+    }
+
+    this.toolbar.reset();
+    this.secondaryToolbar.reset();
+
+    if (typeof PDFBug !== "undefined") {
+      PDFBug.cleanup();
+    }
+
+    return Promise.all(promises);
+  },
+
+  async open(file, args) {
+    if (this.pdfLoadingTask) {
+      await this.close();
+    }
+
+    const workerParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.WORKER);
+
+    for (const key in workerParameters) {
+      _pdfjsLib.GlobalWorkerOptions[key] = workerParameters[key];
+    }
+
+    const parameters = Object.create(null);
+
+    if (typeof file === "string") {
+      this.setTitleUsingUrl(file);
+      parameters.url = file;
+    } else if (file && "byteLength" in file) {
+      parameters.data = file;
+    } else if (file.url && file.originalUrl) {
+      this.setTitleUsingUrl(file.originalUrl);
+      parameters.url = file.url;
+    }
+
+    const apiParameters = _app_options.AppOptions.getAll(_app_options.OptionKind.API);
+
+    for (const key in apiParameters) {
+      let value = apiParameters[key];
+
+      if (key === "docBaseUrl" && !value) {
+        value = this.baseUrl;
+      }
+
+      parameters[key] = value;
+    }
+
+    if (args) {
+      for (const key in args) {
+        parameters[key] = args[key];
+      }
+    }
+
+    const loadingTask = (0, _pdfjsLib.getDocument)(parameters);
+    this.pdfLoadingTask = loadingTask;
+
+    loadingTask.onPassword = (updateCallback, reason) => {
+      this.pdfLinkService.externalLinkEnabled = false;
+      this.passwordPrompt.setUpdateCallback(updateCallback, reason);
+      this.passwordPrompt.open();
+    };
+
+    loadingTask.onProgress = ({
+      loaded,
+      total
+    }) => {
+      this.progress(loaded / total);
+    };
+
+    loadingTask.onUnsupportedFeature = this.fallback.bind(this);
+    return loadingTask.promise.then(pdfDocument => {
+      this.load(pdfDocument);
+    }, exception => {
+      if (loadingTask !== this.pdfLoadingTask) {
+        return undefined;
+      }
+
+      const message = exception?.message;
+      let loadingErrorMessage;
+
+      if (exception instanceof _pdfjsLib.InvalidPDFException) {
+        loadingErrorMessage = this.l10n.get("invalid_file_error", null, "Invalid or corrupted PDF file.");
+      } else if (exception instanceof _pdfjsLib.MissingPDFException) {
+        loadingErrorMessage = this.l10n.get("missing_file_error", null, "Missing PDF file.");
+      } else if (exception instanceof _pdfjsLib.UnexpectedResponseException) {
+        loadingErrorMessage = this.l10n.get("unexpected_response_error", null, "Unexpected server response.");
+      } else {
+        loadingErrorMessage = this.l10n.get("loading_error", null, "An error occurred while loading the PDF.");
+      }
+
+      return loadingErrorMessage.then(msg => {
+        this.error(msg, {
+          message
+        });
+        throw exception;
+      });
+    });
+  },
+
+  download({
+    sourceEventType = "download"
+  } = {}) {
+    function downloadByUrl() {
+      downloadManager.downloadUrl(url, filename);
+    }
+
+    const downloadManager = this.downloadManager,
+          url = this.baseUrl,
+          filename = this._docFilename;
+
+    if (!this.pdfDocument || !this.downloadComplete) {
+      downloadByUrl();
+      return;
+    }
+
+    this.pdfDocument.getData().then(function (data) {
+      const blob = new Blob([data], {
+        type: "application/pdf"
+      });
+      downloadManager.download(blob, url, filename, sourceEventType);
+    }).catch(downloadByUrl);
+  },
+
+  async save({
+    sourceEventType = "download"
+  } = {}) {
+    if (this._saveInProgress) {
+      return;
+    }
+
+    const downloadManager = this.downloadManager,
+          url = this.baseUrl,
+          filename = this._docFilename;
+
+    if (!this.pdfDocument || !this.downloadComplete) {
+      this.download({
+        sourceEventType
+      });
+      return;
+    }
+
+    this._saveInProgress = true;
+    await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillSave"
+    });
+    this.pdfDocument.saveDocument(this.pdfDocument.annotationStorage).then(data => {
+      const blob = new Blob([data], {
+        type: "application/pdf"
+      });
+      downloadManager.download(blob, url, filename, sourceEventType);
+    }).catch(() => {
+      this.download({
+        sourceEventType
+      });
+    }).finally(async () => {
+      await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+        id: "doc",
+        name: "DidSave"
+      });
+      this._saveInProgress = false;
+    });
+  },
+
+  downloadOrSave(options) {
+    if (this.pdfDocument?.annotationStorage.size > 0) {
+      this.save(options);
+    } else {
+      this.download(options);
+    }
+  },
+
+  _delayedFallback(featureId) {
+    this.externalServices.reportTelemetry({
+      type: "unsupportedFeature",
+      featureId
+    });
+
+    if (!this.triggerDelayedFallback) {
+      this.triggerDelayedFallback = () => {
+        this.fallback(featureId);
+        this.triggerDelayedFallback = null;
+      };
+    }
+  },
+
+  fallback(featureId) {
+    this.externalServices.reportTelemetry({
+      type: "unsupportedFeature",
+      featureId
+    });
+
+    if (this.fellback) {
+      return;
+    }
+
+    this.fellback = true;
+    this.externalServices.fallback({
+      featureId,
+      url: this.baseUrl
+    }).then(download => {
+      if (!download) {
+        return;
+      }
+
+      this.download({
+        sourceEventType: "download"
+      });
+    });
+  },
+
+  error(message, moreInfo) {
+    const moreInfoText = [this.l10n.get("error_version_info", {
+      version: _pdfjsLib.version || "?",
+      build: _pdfjsLib.build || "?"
+    }, "PDF.js v{{version}} (build: {{build}})")];
+
+    if (moreInfo) {
+      moreInfoText.push(this.l10n.get("error_message", {
+        message: moreInfo.message
+      }, "Message: {{message}}"));
+
+      if (moreInfo.stack) {
+        moreInfoText.push(this.l10n.get("error_stack", {
+          stack: moreInfo.stack
+        }, "Stack: {{stack}}"));
+      } else {
+        if (moreInfo.filename) {
+          moreInfoText.push(this.l10n.get("error_file", {
+            file: moreInfo.filename
+          }, "File: {{file}}"));
+        }
+
+        if (moreInfo.lineNumber) {
+          moreInfoText.push(this.l10n.get("error_line", {
+            line: moreInfo.lineNumber
+          }, "Line: {{line}}"));
+        }
+      }
+    }
+
+    Promise.all(moreInfoText).then(parts => {
+      console.error(message + "\n" + parts.join("\n"));
+    });
+    this.fallback();
+  },
+
+  progress(level) {
+    if (this.downloadComplete) {
+      return;
+    }
+
+    const percent = Math.round(level * 100);
+
+    if (percent > this.loadingBar.percent || isNaN(percent)) {
+      this.loadingBar.percent = percent;
+      const disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams.disableAutoFetch : _app_options.AppOptions.get("disableAutoFetch");
+
+      if (disableAutoFetch && percent) {
+        if (this.disableAutoFetchLoadingBarTimeout) {
+          clearTimeout(this.disableAutoFetchLoadingBarTimeout);
+          this.disableAutoFetchLoadingBarTimeout = null;
+        }
+
+        this.loadingBar.show();
+        this.disableAutoFetchLoadingBarTimeout = setTimeout(() => {
+          this.loadingBar.hide();
+          this.disableAutoFetchLoadingBarTimeout = null;
+        }, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
+      }
+    }
+  },
+
+  load(pdfDocument) {
+    this.pdfDocument = pdfDocument;
+    pdfDocument.getDownloadInfo().then(({
+      length
+    }) => {
+      this._contentLength = length;
+      this.downloadComplete = true;
+      this.loadingBar.hide();
+      firstPagePromise.then(() => {
+        this.eventBus.dispatch("documentloaded", {
+          source: this
+        });
+      });
+    });
+    const pageLayoutPromise = pdfDocument.getPageLayout().catch(function () {});
+    const pageModePromise = pdfDocument.getPageMode().catch(function () {});
+    const openActionPromise = pdfDocument.getOpenAction().catch(function () {});
+    this.toolbar.setPagesCount(pdfDocument.numPages, false);
+    this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
+    let baseDocumentUrl;
+    baseDocumentUrl = this.baseUrl;
+    this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
+    this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
+    const pdfViewer = this.pdfViewer;
+    pdfViewer.setDocument(pdfDocument);
+    const {
+      firstPagePromise,
+      onePageRendered,
+      pagesPromise
+    } = pdfViewer;
+    const pdfThumbnailViewer = this.pdfThumbnailViewer;
+    pdfThumbnailViewer.setDocument(pdfDocument);
+    const storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument.fingerprint)).getMultiple({
+      page: null,
+      zoom: _ui_utils.DEFAULT_SCALE_VALUE,
+      scrollLeft: "0",
+      scrollTop: "0",
+      rotation: null,
+      sidebarView: _ui_utils.SidebarView.UNKNOWN,
+      scrollMode: _ui_utils.ScrollMode.UNKNOWN,
+      spreadMode: _ui_utils.SpreadMode.UNKNOWN
+    }).catch(() => {
+      return Object.create(null);
+    });
+    firstPagePromise.then(pdfPage => {
+      this.loadingBar.setWidth(this.appConfig.viewerContainer);
+
+      this._initializeAnnotationStorageCallbacks(pdfDocument);
+
+      Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then(async ([timeStamp, stored, pageLayout, pageMode, openAction]) => {
+        const viewOnLoad = _app_options.AppOptions.get("viewOnLoad");
+
+        this._initializePdfHistory({
+          fingerprint: pdfDocument.fingerprint,
+          viewOnLoad,
+          initialDest: openAction && openAction.dest
+        });
+
+        const initialBookmark = this.initialBookmark;
+
+        const zoom = _app_options.AppOptions.get("defaultZoomValue");
+
+        let hash = zoom ? `zoom=${zoom}` : null;
+        let rotation = null;
+
+        let sidebarView = _app_options.AppOptions.get("sidebarViewOnLoad");
+
+        let scrollMode = _app_options.AppOptions.get("scrollModeOnLoad");
+
+        let spreadMode = _app_options.AppOptions.get("spreadModeOnLoad");
+
+        if (stored.page && viewOnLoad !== ViewOnLoad.INITIAL) {
+          hash = `page=${stored.page}&zoom=${zoom || stored.zoom},` + `${stored.scrollLeft},${stored.scrollTop}`;
+          rotation = parseInt(stored.rotation, 10);
+
+          if (sidebarView === _ui_utils.SidebarView.UNKNOWN) {
+            sidebarView = stored.sidebarView | 0;
+          }
+
+          if (scrollMode === _ui_utils.ScrollMode.UNKNOWN) {
+            scrollMode = stored.scrollMode | 0;
+          }
+
+          if (spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+            spreadMode = stored.spreadMode | 0;
+          }
+        }
+
+        if (pageMode && sidebarView === _ui_utils.SidebarView.UNKNOWN) {
+          sidebarView = apiPageModeToSidebarView(pageMode);
+        }
+
+        if (pageLayout && spreadMode === _ui_utils.SpreadMode.UNKNOWN) {
+          spreadMode = apiPageLayoutToSpreadMode(pageLayout);
+        }
+
+        this.setInitialView(hash, {
+          rotation,
+          sidebarView,
+          scrollMode,
+          spreadMode
+        });
+        this.eventBus.dispatch("documentinit", {
+          source: this
+        });
+
+        if (!this.isViewerEmbedded) {
+          pdfViewer.focus();
+        }
+
+        this._initializePermissions(pdfDocument);
+
+        await Promise.race([pagesPromise, new Promise(resolve => {
+          setTimeout(resolve, FORCE_PAGES_LOADED_TIMEOUT);
+        })]);
+
+        if (!initialBookmark && !hash) {
+          return;
+        }
+
+        if (pdfViewer.hasEqualPageSizes) {
+          return;
+        }
+
+        this.initialBookmark = initialBookmark;
+        pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
+        this.setInitialView(hash);
+      }).catch(() => {
+        this.setInitialView();
+      }).then(function () {
+        pdfViewer.update();
+      });
+    });
+    pagesPromise.then(() => {
+      this._initializeAutoPrint(pdfDocument, openActionPromise);
+    });
+    onePageRendered.then(() => {
+      pdfDocument.getOutline().then(outline => {
+        this.pdfOutlineViewer.render({
+          outline,
+          pdfDocument
+        });
+      });
+      pdfDocument.getAttachments().then(attachments => {
+        this.pdfAttachmentViewer.render({
+          attachments
+        });
+      });
+      pdfViewer.optionalContentConfigPromise.then(optionalContentConfig => {
+        this.pdfLayerViewer.render({
+          optionalContentConfig,
+          pdfDocument
+        });
+      });
+
+      if ("requestIdleCallback" in window) {
+        const callback = window.requestIdleCallback(() => {
+          this._collectTelemetry(pdfDocument);
+
+          this._idleCallbacks.delete(callback);
+        }, {
+          timeout: 1000
+        });
+
+        this._idleCallbacks.add(callback);
+      }
+
+      this._initializeJavaScript(pdfDocument);
+    });
+
+    this._initializePageLabels(pdfDocument);
+
+    this._initializeMetadata(pdfDocument);
+  },
+
+  async _initializeJavaScript(pdfDocument) {
+    if (!_app_options.AppOptions.get("enableScripting")) {
+      return;
+    }
+
+    const [objects, calculationOrder, docActions] = await Promise.all([pdfDocument.getFieldObjects(), pdfDocument.getCalculationOrderIds(), pdfDocument.getJSActions()]);
+
+    if (!objects && !docActions) {
+      return;
+    }
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const scripting = this.externalServices.createScripting(null);
+    const internalEvents = new Map(),
+          domEvents = new Map();
+    this._scriptingInstance = {
+      scripting,
+      ready: false,
+      internalEvents,
+      domEvents
+    };
+
+    if (!this.documentInfo) {
+      await new Promise(resolve => {
+        this.eventBus._on("metadataloaded", evt => {
+          resolve();
+        }, {
+          once: true
+        });
+      });
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+    }
+
+    if (!this._contentLength) {
+      await new Promise(resolve => {
+        this.eventBus._on("documentloaded", evt => {
+          resolve();
+        }, {
+          once: true
+        });
+      });
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+    }
+
+    const updateFromSandbox = ({
+      detail
+    }) => {
+      const {
+        id,
+        command,
+        value
+      } = detail;
+
+      if (!id) {
+        switch (command) {
+          case "clear":
+            console.clear();
+            break;
+
+          case "error":
+            console.error(value);
+            break;
+
+          case "layout":
+            this.pdfViewer.spreadMode = apiPageLayoutToSpreadMode(value);
+            break;
+
+          case "page-num":
+            this.pdfViewer.currentPageNumber = value + 1;
+            break;
+
+          case "print":
+            this.pdfViewer.pagesPromise.then(() => {
+              this.triggerPrinting();
+            });
+            break;
+
+          case "println":
+            console.log(value);
+            break;
+
+          case "zoom":
+            this.pdfViewer.currentScaleValue = value;
+            break;
+        }
+
+        return;
+      }
+
+      const element = document.getElementById(id);
+
+      if (element) {
+        element.dispatchEvent(new CustomEvent("updatefromsandbox", {
+          detail
+        }));
+      } else {
+        if (value !== undefined && value !== null) {
+          pdfDocument.annotationStorage.setValue(id, value);
+        }
+      }
+    };
+
+    internalEvents.set("updatefromsandbox", updateFromSandbox);
+    const visitedPages = new Map();
+
+    const pageOpen = ({
+      pageNumber
+    }) => {
+      visitedPages.set(pageNumber, (async () => {
+        let actions = null;
+
+        if (!visitedPages.has(pageNumber)) {
+          const pageView = this.pdfViewer.getPageView(pageNumber - 1);
+
+          if (pageView?.pdfPage) {
+            actions = await pageView.pdfPage.getJSActions();
+          } else {
+            actions = await pdfDocument.getPage(pageNumber).getJSActions();
+          }
+
+          if (pdfDocument !== this.pdfDocument) {
+            return;
+          }
+        }
+
+        this._scriptingInstance?.scripting.dispatchEventInSandbox({
+          id: "page",
+          name: "PageOpen",
+          pageNumber,
+          actions
+        });
+      })());
+    };
+
+    const pageClose = async ({
+      pageNumber
+    }) => {
+      const promise = visitedPages.get(pageNumber);
+
+      if (!promise) {
+        return;
+      }
+
+      visitedPages.set(pageNumber, null);
+      await promise;
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+
+      this._scriptingInstance?.scripting.dispatchEventInSandbox({
+        id: "page",
+        name: "PageClose",
+        pageNumber
+      });
+    };
+
+    internalEvents.set("pageopen", pageOpen);
+    internalEvents.set("pageclose", pageClose);
+
+    const dispatchEventInSandbox = ({
+      detail
+    }) => {
+      scripting.dispatchEventInSandbox(detail);
+    };
+
+    internalEvents.set("dispatcheventinsandbox", dispatchEventInSandbox);
+
+    const mouseDown = event => {
+      this._mouseState.isDown = true;
+    };
+
+    domEvents.set("mousedown", mouseDown);
+
+    const mouseUp = event => {
+      this._mouseState.isDown = false;
+    };
+
+    domEvents.set("mouseup", mouseUp);
+
+    for (const [name, listener] of internalEvents) {
+      this.eventBus._on(name, listener);
+    }
+
+    for (const [name, listener] of domEvents) {
+      window.addEventListener(name, listener);
+    }
+
+    try {
+      await scripting.createSandbox({
+        objects,
+        calculationOrder,
+        appInfo: {
+          platform: navigator.platform,
+          language: navigator.language
+        },
+        docInfo: { ...this.documentInfo,
+          baseURL: this.baseUrl,
+          filesize: this._contentLength,
+          filename: this._docFilename,
+          metadata: this.metadata,
+          numPages: pdfDocument.numPages,
+          URL: this.url,
+          actions: docActions
+        }
+      });
+
+      if (this.externalServices.isInAutomation) {
+        this.eventBus.dispatch("sandboxcreated", {
+          source: this
+        });
+      }
+    } catch (error) {
+      console.error(`_initializeJavaScript: "${error?.message}".`);
+
+      this._destroyScriptingInstance();
+
+      return;
+    }
+
+    await scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "Open"
+    });
+    await pageOpen({
+      pageNumber: this.pdfViewer.currentPageNumber
+    });
+    Promise.resolve().then(() => {
+      if (this._scriptingInstance) {
+        this._scriptingInstance.ready = true;
+      }
+    });
+  },
+
+  async _collectTelemetry(pdfDocument) {
+    const markInfo = await this.pdfDocument.getMarkInfo();
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const tagged = markInfo?.Marked || false;
+    this.externalServices.reportTelemetry({
+      type: "tagged",
+      tagged
+    });
+  },
+
+  async _initializeAutoPrint(pdfDocument, openActionPromise) {
+    const [openAction, javaScript] = await Promise.all([openActionPromise, !_app_options.AppOptions.get("enableScripting") ? pdfDocument.getJavaScript() : null]);
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    let triggerAutoPrint = false;
+
+    if (openAction?.action === "Print") {
+      triggerAutoPrint = true;
+    }
+
+    if (javaScript) {
+      javaScript.some(js => {
+        if (!js) {
+          return false;
+        }
+
+        console.warn("Warning: JavaScript is not supported");
+
+        this._delayedFallback(_pdfjsLib.UNSUPPORTED_FEATURES.javaScript);
+
+        return true;
+      });
+
+      if (!triggerAutoPrint) {
+        for (const js of javaScript) {
+          if (js && _ui_utils.AutoPrintRegExp.test(js)) {
+            triggerAutoPrint = true;
+            break;
+          }
+        }
+      }
+    }
+
+    if (triggerAutoPrint) {
+      this.triggerPrinting();
+    }
+  },
+
+  async _initializeMetadata(pdfDocument) {
+    const {
+      info,
+      metadata,
+      contentDispositionFilename,
+      contentLength
+    } = await pdfDocument.getMetadata();
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    this.documentInfo = info;
+    this.metadata = metadata;
+    this._contentDispositionFilename = contentDispositionFilename;
+    this._contentLength ?? (this._contentLength = contentLength);
+    console.log(`PDF ${pdfDocument.fingerprint} [${info.PDFFormatVersion} ` + `${(info.Producer || "-").trim()} / ${(info.Creator || "-").trim()}] ` + `(PDF.js: ${_pdfjsLib.version || "-"}` + `${this.pdfViewer.enableWebGL ? " [WebGL]" : ""})`);
+    let pdfTitle;
+    const infoTitle = info && info.Title;
+
+    if (infoTitle) {
+      pdfTitle = infoTitle;
+    }
+
+    const metadataTitle = metadata && metadata.get("dc:title");
+
+    if (metadataTitle) {
+      if (metadataTitle !== "Untitled" && !/[\uFFF0-\uFFFF]/g.test(metadataTitle)) {
+        pdfTitle = metadataTitle;
+      }
+    }
+
+    if (pdfTitle) {
+      this.setTitle(`${pdfTitle} - ${contentDispositionFilename || document.title}`);
+    } else if (contentDispositionFilename) {
+      this.setTitle(contentDispositionFilename);
+    }
+
+    if (info.IsXFAPresent && !info.IsAcroFormPresent) {
+      console.warn("Warning: XFA is not supported");
+
+      this._delayedFallback(_pdfjsLib.UNSUPPORTED_FEATURES.forms);
+    } else if ((info.IsAcroFormPresent || info.IsXFAPresent) && !this.pdfViewer.renderInteractiveForms) {
+      console.warn("Warning: Interactive form support is not enabled");
+
+      this._delayedFallback(_pdfjsLib.UNSUPPORTED_FEATURES.forms);
+    }
+
+    let versionId = "other";
+
+    if (KNOWN_VERSIONS.includes(info.PDFFormatVersion)) {
+      versionId = `v${info.PDFFormatVersion.replace(".", "_")}`;
+    }
+
+    let generatorId = "other";
+
+    if (info.Producer) {
+      const producer = info.Producer.toLowerCase();
+      KNOWN_GENERATORS.some(function (generator) {
+        if (!producer.includes(generator)) {
+          return false;
+        }
+
+        generatorId = generator.replace(/[ .-]/g, "_");
+        return true;
+      });
+    }
+
+    let formType = null;
+
+    if (info.IsXFAPresent) {
+      formType = "xfa";
+    } else if (info.IsAcroFormPresent) {
+      formType = "acroform";
+    }
+
+    this.externalServices.reportTelemetry({
+      type: "documentInfo",
+      version: versionId,
+      generator: generatorId,
+      formType
+    });
+    this.eventBus.dispatch("metadataloaded", {
+      source: this
+    });
+  },
+
+  async _initializePageLabels(pdfDocument) {
+    const labels = await pdfDocument.getPageLabels();
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    if (!labels || _app_options.AppOptions.get("disablePageLabels")) {
+      return;
+    }
+
+    const numLabels = labels.length;
+
+    if (numLabels !== this.pagesCount) {
+      console.error("The number of Page Labels does not match the number of pages in the document.");
+      return;
+    }
+
+    let i = 0;
+
+    while (i < numLabels && labels[i] === (i + 1).toString()) {
+      i++;
+    }
+
+    if (i === numLabels) {
+      return;
+    }
+
+    const {
+      pdfViewer,
+      pdfThumbnailViewer,
+      toolbar
+    } = this;
+    pdfViewer.setPageLabels(labels);
+    pdfThumbnailViewer.setPageLabels(labels);
+    toolbar.setPagesCount(numLabels, true);
+    toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
+  },
+
+  _initializePdfHistory({
+    fingerprint,
+    viewOnLoad,
+    initialDest = null
+  }) {
+    if (this.isViewerEmbedded || _app_options.AppOptions.get("disableHistory")) {
+      return;
+    }
+
+    this.pdfHistory.initialize({
+      fingerprint,
+      resetHistory: viewOnLoad === ViewOnLoad.INITIAL,
+      updateUrl: _app_options.AppOptions.get("historyUpdateUrl")
+    });
+
+    if (this.pdfHistory.initialBookmark) {
+      this.initialBookmark = this.pdfHistory.initialBookmark;
+      this.initialRotation = this.pdfHistory.initialRotation;
+    }
+
+    if (initialDest && !this.initialBookmark && viewOnLoad === ViewOnLoad.UNKNOWN) {
+      this.initialBookmark = JSON.stringify(initialDest);
+      this.pdfHistory.push({
+        explicitDest: initialDest,
+        pageNumber: null
+      });
+    }
+  },
+
+  async _initializePermissions(pdfDocument) {
+    const permissions = await pdfDocument.getPermissions();
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    if (!permissions || !_app_options.AppOptions.get("enablePermissions")) {
+      return;
+    }
+
+    if (!permissions.includes(_pdfjsLib.PermissionFlag.COPY)) {
+      this.appConfig.viewerContainer.classList.add(ENABLE_PERMISSIONS_CLASS);
+    }
+  },
+
+  _initializeAnnotationStorageCallbacks(pdfDocument) {
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const {
+      annotationStorage
+    } = pdfDocument;
+
+    annotationStorage.onSetModified = function () {
+      window.addEventListener("beforeunload", beforeUnload);
+    };
+
+    annotationStorage.onResetModified = function () {
+      window.removeEventListener("beforeunload", beforeUnload);
+    };
+  },
+
+  setInitialView(storedHash, {
+    rotation,
+    sidebarView,
+    scrollMode,
+    spreadMode
+  } = {}) {
+    const setRotation = angle => {
+      if ((0, _ui_utils.isValidRotation)(angle)) {
+        this.pdfViewer.pagesRotation = angle;
+      }
+    };
+
+    const setViewerModes = (scroll, spread) => {
+      if ((0, _ui_utils.isValidScrollMode)(scroll)) {
+        this.pdfViewer.scrollMode = scroll;
+      }
+
+      if ((0, _ui_utils.isValidSpreadMode)(spread)) {
+        this.pdfViewer.spreadMode = spread;
+      }
+    };
+
+    this.isInitialViewSet = true;
+    this.pdfSidebar.setInitialView(sidebarView);
+    setViewerModes(scrollMode, spreadMode);
+
+    if (this.initialBookmark) {
+      setRotation(this.initialRotation);
+      delete this.initialRotation;
+      this.pdfLinkService.setHash(this.initialBookmark);
+      this.initialBookmark = null;
+    } else if (storedHash) {
+      setRotation(rotation);
+      this.pdfLinkService.setHash(storedHash);
+    }
+
+    this.toolbar.setPageNumber(this.pdfViewer.currentPageNumber, this.pdfViewer.currentPageLabel);
+    this.secondaryToolbar.setPageNumber(this.pdfViewer.currentPageNumber);
+
+    if (!this.pdfViewer.currentScaleValue) {
+      this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+    }
+  },
+
+  cleanup() {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    this.pdfViewer.cleanup();
+    this.pdfThumbnailViewer.cleanup();
+
+    if (this.pdfViewer.renderer !== _ui_utils.RendererType.SVG) {
+      this.pdfDocument.cleanup();
+    }
+  },
+
+  forceRendering() {
+    this.pdfRenderingQueue.printing = !!this.printService;
+    this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.isThumbnailViewVisible;
+    this.pdfRenderingQueue.renderHighestPriority();
+  },
+
+  beforePrint() {
+    this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillPrint"
+    });
+
+    if (this.printService) {
+      return;
+    }
+
+    if (!this.supportsPrinting) {
+      this.l10n.get("printing_not_supported", null, "Warning: Printing is not fully supported by this browser.").then(printMessage => {
+        this.error(printMessage);
+      });
+      return;
+    }
+
+    if (!this.pdfViewer.pageViewsReady) {
+      this.l10n.get("printing_not_ready", null, "Warning: The PDF is not fully loaded for printing.").then(notReadyMessage => {
+        window.alert(notReadyMessage);
+      });
+      return;
+    }
+
+    const pagesOverview = this.pdfViewer.getPagesOverview();
+    const printContainer = this.appConfig.printContainer;
+
+    const printResolution = _app_options.AppOptions.get("printResolution");
+
+    const optionalContentConfigPromise = this.pdfViewer.optionalContentConfigPromise;
+    const printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise, this.l10n);
+    this.printService = printService;
+    this.forceRendering();
+    printService.layout();
+    this.externalServices.reportTelemetry({
+      type: "print"
+    });
+  },
+
+  afterPrint() {
+    this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "DidPrint"
+    });
+
+    if (this.printService) {
+      this.printService.destroy();
+      this.printService = null;
+
+      if (this.pdfDocument) {
+        this.pdfDocument.annotationStorage.resetModified();
+      }
+    }
+
+    this.forceRendering();
+  },
+
+  rotatePages(delta) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    const newRotation = (this.pdfViewer.pagesRotation + 360 + delta) % 360;
+    this.pdfViewer.pagesRotation = newRotation;
+  },
+
+  requestPresentationMode() {
+    if (!this.pdfPresentationMode) {
+      return;
+    }
+
+    this.pdfPresentationMode.request();
+  },
+
+  triggerPrinting() {
+    if (!this.supportsPrinting) {
+      return;
+    }
+
+    window.print();
+  },
+
+  bindEvents() {
+    const {
+      eventBus,
+      _boundEvents
+    } = this;
+    _boundEvents.beforePrint = this.beforePrint.bind(this);
+    _boundEvents.afterPrint = this.afterPrint.bind(this);
+
+    eventBus._on("resize", webViewerResize);
+
+    eventBus._on("hashchange", webViewerHashchange);
+
+    eventBus._on("beforeprint", _boundEvents.beforePrint);
+
+    eventBus._on("afterprint", _boundEvents.afterPrint);
+
+    eventBus._on("pagerendered", webViewerPageRendered);
+
+    eventBus._on("updateviewarea", webViewerUpdateViewarea);
+
+    eventBus._on("pagechanging", webViewerPageChanging);
+
+    eventBus._on("scalechanging", webViewerScaleChanging);
+
+    eventBus._on("rotationchanging", webViewerRotationChanging);
+
+    eventBus._on("sidebarviewchanged", webViewerSidebarViewChanged);
+
+    eventBus._on("pagemode", webViewerPageMode);
+
+    eventBus._on("namedaction", webViewerNamedAction);
+
+    eventBus._on("presentationmodechanged", webViewerPresentationModeChanged);
+
+    eventBus._on("presentationmode", webViewerPresentationMode);
+
+    eventBus._on("print", webViewerPrint);
+
+    eventBus._on("download", webViewerDownload);
+
+    eventBus._on("save", webViewerSave);
+
+    eventBus._on("firstpage", webViewerFirstPage);
+
+    eventBus._on("lastpage", webViewerLastPage);
+
+    eventBus._on("nextpage", webViewerNextPage);
+
+    eventBus._on("previouspage", webViewerPreviousPage);
+
+    eventBus._on("zoomin", webViewerZoomIn);
+
+    eventBus._on("zoomout", webViewerZoomOut);
+
+    eventBus._on("zoomreset", webViewerZoomReset);
+
+    eventBus._on("pagenumberchanged", webViewerPageNumberChanged);
+
+    eventBus._on("scalechanged", webViewerScaleChanged);
+
+    eventBus._on("rotatecw", webViewerRotateCw);
+
+    eventBus._on("rotateccw", webViewerRotateCcw);
+
+    eventBus._on("optionalcontentconfig", webViewerOptionalContentConfig);
+
+    eventBus._on("switchscrollmode", webViewerSwitchScrollMode);
+
+    eventBus._on("scrollmodechanged", webViewerScrollModeChanged);
+
+    eventBus._on("switchspreadmode", webViewerSwitchSpreadMode);
+
+    eventBus._on("spreadmodechanged", webViewerSpreadModeChanged);
+
+    eventBus._on("documentproperties", webViewerDocumentProperties);
+
+    eventBus._on("find", webViewerFind);
+
+    eventBus._on("findfromurlhash", webViewerFindFromUrlHash);
+
+    eventBus._on("updatefindmatchescount", webViewerUpdateFindMatchesCount);
+
+    eventBus._on("updatefindcontrolstate", webViewerUpdateFindControlState);
+
+    if (_app_options.AppOptions.get("pdfBug")) {
+      _boundEvents.reportPageStatsPDFBug = reportPageStatsPDFBug;
+
+      eventBus._on("pagerendered", _boundEvents.reportPageStatsPDFBug);
+
+      eventBus._on("pagechanging", _boundEvents.reportPageStatsPDFBug);
+    }
+  },
+
+  bindWindowEvents() {
+    const {
+      eventBus,
+      _boundEvents
+    } = this;
+
+    _boundEvents.windowResize = () => {
+      eventBus.dispatch("resize", {
+        source: window
+      });
+    };
+
+    _boundEvents.windowHashChange = () => {
+      eventBus.dispatch("hashchange", {
+        source: window,
+        hash: document.location.hash.substring(1)
+      });
+    };
+
+    _boundEvents.windowBeforePrint = () => {
+      eventBus.dispatch("beforeprint", {
+        source: window
+      });
+    };
+
+    _boundEvents.windowAfterPrint = () => {
+      eventBus.dispatch("afterprint", {
+        source: window
+      });
+    };
+
+    _boundEvents.windowUpdateFromSandbox = event => {
+      eventBus.dispatch("updatefromsandbox", {
+        source: window,
+        detail: event.detail
+      });
+    };
+
+    window.addEventListener("visibilitychange", webViewerVisibilityChange);
+    window.addEventListener("wheel", webViewerWheel, {
+      passive: false
+    });
+    window.addEventListener("touchstart", webViewerTouchStart, {
+      passive: false
+    });
+    window.addEventListener("click", webViewerClick);
+    window.addEventListener("keydown", webViewerKeyDown);
+    window.addEventListener("keyup", webViewerKeyUp);
+    window.addEventListener("resize", _boundEvents.windowResize);
+    window.addEventListener("hashchange", _boundEvents.windowHashChange);
+    window.addEventListener("beforeprint", _boundEvents.windowBeforePrint);
+    window.addEventListener("afterprint", _boundEvents.windowAfterPrint);
+    window.addEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
+  },
+
+  unbindEvents() {
+    const {
+      eventBus,
+      _boundEvents
+    } = this;
+
+    eventBus._off("resize", webViewerResize);
+
+    eventBus._off("hashchange", webViewerHashchange);
+
+    eventBus._off("beforeprint", _boundEvents.beforePrint);
+
+    eventBus._off("afterprint", _boundEvents.afterPrint);
+
+    eventBus._off("pagerendered", webViewerPageRendered);
+
+    eventBus._off("updateviewarea", webViewerUpdateViewarea);
+
+    eventBus._off("pagechanging", webViewerPageChanging);
+
+    eventBus._off("scalechanging", webViewerScaleChanging);
+
+    eventBus._off("rotationchanging", webViewerRotationChanging);
+
+    eventBus._off("sidebarviewchanged", webViewerSidebarViewChanged);
+
+    eventBus._off("pagemode", webViewerPageMode);
+
+    eventBus._off("namedaction", webViewerNamedAction);
+
+    eventBus._off("presentationmodechanged", webViewerPresentationModeChanged);
+
+    eventBus._off("presentationmode", webViewerPresentationMode);
+
+    eventBus._off("print", webViewerPrint);
+
+    eventBus._off("download", webViewerDownload);
+
+    eventBus._off("save", webViewerSave);
+
+    eventBus._off("firstpage", webViewerFirstPage);
+
+    eventBus._off("lastpage", webViewerLastPage);
+
+    eventBus._off("nextpage", webViewerNextPage);
+
+    eventBus._off("previouspage", webViewerPreviousPage);
+
+    eventBus._off("zoomin", webViewerZoomIn);
+
+    eventBus._off("zoomout", webViewerZoomOut);
+
+    eventBus._off("zoomreset", webViewerZoomReset);
+
+    eventBus._off("pagenumberchanged", webViewerPageNumberChanged);
+
+    eventBus._off("scalechanged", webViewerScaleChanged);
+
+    eventBus._off("rotatecw", webViewerRotateCw);
+
+    eventBus._off("rotateccw", webViewerRotateCcw);
+
+    eventBus._off("optionalcontentconfig", webViewerOptionalContentConfig);
+
+    eventBus._off("switchscrollmode", webViewerSwitchScrollMode);
+
+    eventBus._off("scrollmodechanged", webViewerScrollModeChanged);
+
+    eventBus._off("switchspreadmode", webViewerSwitchSpreadMode);
+
+    eventBus._off("spreadmodechanged", webViewerSpreadModeChanged);
+
+    eventBus._off("documentproperties", webViewerDocumentProperties);
+
+    eventBus._off("find", webViewerFind);
+
+    eventBus._off("findfromurlhash", webViewerFindFromUrlHash);
+
+    eventBus._off("updatefindmatchescount", webViewerUpdateFindMatchesCount);
+
+    eventBus._off("updatefindcontrolstate", webViewerUpdateFindControlState);
+
+    if (_boundEvents.reportPageStatsPDFBug) {
+      eventBus._off("pagerendered", _boundEvents.reportPageStatsPDFBug);
+
+      eventBus._off("pagechanging", _boundEvents.reportPageStatsPDFBug);
+
+      _boundEvents.reportPageStatsPDFBug = null;
+    }
+
+    _boundEvents.beforePrint = null;
+    _boundEvents.afterPrint = null;
+  },
+
+  unbindWindowEvents() {
+    const {
+      _boundEvents
+    } = this;
+    window.removeEventListener("visibilitychange", webViewerVisibilityChange);
+    window.removeEventListener("wheel", webViewerWheel, {
+      passive: false
+    });
+    window.removeEventListener("touchstart", webViewerTouchStart, {
+      passive: false
+    });
+    window.removeEventListener("click", webViewerClick);
+    window.removeEventListener("keydown", webViewerKeyDown);
+    window.removeEventListener("keyup", webViewerKeyUp);
+    window.removeEventListener("resize", _boundEvents.windowResize);
+    window.removeEventListener("hashchange", _boundEvents.windowHashChange);
+    window.removeEventListener("beforeprint", _boundEvents.windowBeforePrint);
+    window.removeEventListener("afterprint", _boundEvents.windowAfterPrint);
+    window.removeEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
+    _boundEvents.windowResize = null;
+    _boundEvents.windowHashChange = null;
+    _boundEvents.windowBeforePrint = null;
+    _boundEvents.windowAfterPrint = null;
+    _boundEvents.windowUpdateFromSandbox = null;
+  },
+
+  accumulateWheelTicks(ticks) {
+    if (this._wheelUnusedTicks > 0 && ticks < 0 || this._wheelUnusedTicks < 0 && ticks > 0) {
+      this._wheelUnusedTicks = 0;
+    }
+
+    this._wheelUnusedTicks += ticks;
+    const wholeTicks = Math.sign(this._wheelUnusedTicks) * Math.floor(Math.abs(this._wheelUnusedTicks));
+    this._wheelUnusedTicks -= wholeTicks;
+    return wholeTicks;
+  },
+
+  get scriptingReady() {
+    return this._scriptingInstance?.ready || false;
+  }
+
+};
+exports.PDFViewerApplication = PDFViewerApplication;
+let validateFileURL;
+;
+
+async function loadFakeWorker() {
+  if (!_pdfjsLib.GlobalWorkerOptions.workerSrc) {
+    _pdfjsLib.GlobalWorkerOptions.workerSrc = _app_options.AppOptions.get("workerSrc");
+  }
+
+  return (0, _pdfjsLib.loadScript)(_pdfjsLib.PDFWorker.getWorkerSrc());
+}
+
+function loadAndEnablePDFBug(enabledTabs) {
+  const appConfig = PDFViewerApplication.appConfig;
+  return (0, _pdfjsLib.loadScript)(appConfig.debuggerScriptPath).then(function () {
+    PDFBug.enable(enabledTabs);
+    PDFBug.init({
+      OPS: _pdfjsLib.OPS
+    }, appConfig.mainContainer);
+  });
+}
+
+function reportPageStatsPDFBug({
+  pageNumber
+}) {
+  if (typeof Stats === "undefined" || !Stats.enabled) {
+    return;
+  }
+
+  const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
+  const pageStats = pageView && pageView.pdfPage && pageView.pdfPage.stats;
+
+  if (!pageStats) {
+    return;
+  }
+
+  Stats.add(pageNumber, pageStats);
+}
+
+function webViewerInitialized() {
+  const appConfig = PDFViewerApplication.appConfig;
+  let file;
+  file = window.location.href;
+  appConfig.toolbar.openFile.setAttribute("hidden", "true");
+  appConfig.secondaryToolbar.openFileButton.setAttribute("hidden", "true");
+
+  if (!PDFViewerApplication.supportsDocumentFonts) {
+    _app_options.AppOptions.set("disableFontFace", true);
+
+    PDFViewerApplication.l10n.get("web_fonts_disabled", null, "Web fonts are disabled: unable to use embedded PDF fonts.").then(msg => {
+      console.warn(msg);
+    });
+  }
+
+  if (!PDFViewerApplication.supportsPrinting) {
+    appConfig.toolbar.print.classList.add("hidden");
+    appConfig.secondaryToolbar.printButton.classList.add("hidden");
+  }
+
+  if (!PDFViewerApplication.supportsFullscreen) {
+    appConfig.toolbar.presentationModeButton.classList.add("hidden");
+    appConfig.secondaryToolbar.presentationModeButton.classList.add("hidden");
+  }
+
+  if (PDFViewerApplication.supportsIntegratedFind) {
+    appConfig.toolbar.viewFind.classList.add("hidden");
+  }
+
+  appConfig.mainContainer.addEventListener("transitionend", function (evt) {
+    if (evt.target === this) {
+      PDFViewerApplication.eventBus.dispatch("resize", {
+        source: this
+      });
+    }
+  }, true);
+
+  try {
+    webViewerOpenFileViaURL(file);
+  } catch (reason) {
+    PDFViewerApplication.l10n.get("loading_error", null, "An error occurred while loading the PDF.").then(msg => {
+      PDFViewerApplication.error(msg, reason);
+    });
+  }
+}
+
+let webViewerOpenFileViaURL;
+{
+  webViewerOpenFileViaURL = function (file) {
+    PDFViewerApplication.setTitleUsingUrl(file);
+    PDFViewerApplication.initPassiveLoading();
+  };
+}
+
+function webViewerResetPermissions() {
+  const {
+    appConfig
+  } = PDFViewerApplication;
+
+  if (!appConfig) {
+    return;
+  }
+
+  appConfig.viewerContainer.classList.remove(ENABLE_PERMISSIONS_CLASS);
+}
+
+function webViewerPageRendered({
+  pageNumber,
+  timestamp,
+  error
+}) {
+  if (pageNumber === PDFViewerApplication.page) {
+    PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
+  }
+
+  if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
+    const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
+    const thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageNumber - 1);
+
+    if (pageView && thumbnailView) {
+      thumbnailView.setImage(pageView);
+    }
+  }
+
+  if (error) {
+    PDFViewerApplication.l10n.get("rendering_error", null, "An error occurred while rendering the page.").then(msg => {
+      PDFViewerApplication.error(msg, error);
+    });
+  }
+
+  PDFViewerApplication.externalServices.reportTelemetry({
+    type: "pageInfo",
+    timestamp
+  });
+  PDFViewerApplication.pdfDocument.getStats().then(function (stats) {
+    PDFViewerApplication.externalServices.reportTelemetry({
+      type: "documentStats",
+      stats
+    });
+  });
+}
+
+function webViewerPageMode({
+  mode
+}) {
+  let view;
+
+  switch (mode) {
+    case "thumbs":
+      view = _ui_utils.SidebarView.THUMBS;
+      break;
+
+    case "bookmarks":
+    case "outline":
+      view = _ui_utils.SidebarView.OUTLINE;
+      break;
+
+    case "attachments":
+      view = _ui_utils.SidebarView.ATTACHMENTS;
+      break;
+
+    case "layers":
+      view = _ui_utils.SidebarView.LAYERS;
+      break;
+
+    case "none":
+      view = _ui_utils.SidebarView.NONE;
+      break;
+
+    default:
+      console.error('Invalid "pagemode" hash parameter: ' + mode);
+      return;
+  }
+
+  PDFViewerApplication.pdfSidebar.switchView(view, true);
+}
+
+function webViewerNamedAction(evt) {
+  switch (evt.action) {
+    case "GoToPage":
+      PDFViewerApplication.appConfig.toolbar.pageNumber.select();
+      break;
+
+    case "Find":
+      if (!PDFViewerApplication.supportsIntegratedFind) {
+        PDFViewerApplication.findBar.toggle();
+      }
+
+      break;
+
+    case "Print":
+      PDFViewerApplication.triggerPrinting();
+      break;
+
+    case "SaveAs":
+      webViewerSave();
+      break;
+  }
+}
+
+function webViewerPresentationModeChanged(evt) {
+  PDFViewerApplication.pdfViewer.presentationModeState = evt.state;
+}
+
+function webViewerSidebarViewChanged(evt) {
+  PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar.isThumbnailViewVisible;
+  const store = PDFViewerApplication.store;
+
+  if (store && PDFViewerApplication.isInitialViewSet) {
+    store.set("sidebarView", evt.view).catch(function () {});
+  }
+}
+
+function webViewerUpdateViewarea(evt) {
+  const location = evt.location,
+        store = PDFViewerApplication.store;
+
+  if (store && PDFViewerApplication.isInitialViewSet) {
+    store.setMultiple({
+      page: location.pageNumber,
+      zoom: location.scale,
+      scrollLeft: location.left,
+      scrollTop: location.top,
+      rotation: location.rotation
+    }).catch(function () {});
+  }
+
+  const href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
+  PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
+  PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
+  const currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
+  const loading = (currentPage && currentPage.renderingState) !== _pdf_rendering_queue.RenderingStates.FINISHED;
+  PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
+}
+
+function webViewerScrollModeChanged(evt) {
+  const store = PDFViewerApplication.store;
+
+  if (store && PDFViewerApplication.isInitialViewSet) {
+    store.set("scrollMode", evt.mode).catch(function () {});
+  }
+}
+
+function webViewerSpreadModeChanged(evt) {
+  const store = PDFViewerApplication.store;
+
+  if (store && PDFViewerApplication.isInitialViewSet) {
+    store.set("spreadMode", evt.mode).catch(function () {});
+  }
+}
+
+function webViewerResize() {
+  const {
+    pdfDocument,
+    pdfViewer
+  } = PDFViewerApplication;
+
+  if (!pdfDocument) {
+    return;
+  }
+
+  const currentScaleValue = pdfViewer.currentScaleValue;
+
+  if (currentScaleValue === "auto" || currentScaleValue === "page-fit" || currentScaleValue === "page-width") {
+    pdfViewer.currentScaleValue = currentScaleValue;
+  }
+
+  pdfViewer.update();
+}
+
+function webViewerHashchange(evt) {
+  const hash = evt.hash;
+
+  if (!hash) {
+    return;
+  }
+
+  if (!PDFViewerApplication.isInitialViewSet) {
+    PDFViewerApplication.initialBookmark = hash;
+  } else if (!PDFViewerApplication.pdfHistory.popStateInProgress) {
+    PDFViewerApplication.pdfLinkService.setHash(hash);
+  }
+}
+
+let webViewerFileInputChange, webViewerOpenFile;
+;
+
+function webViewerPresentationMode() {
+  PDFViewerApplication.requestPresentationMode();
+}
+
+function webViewerPrint() {
+  PDFViewerApplication.triggerPrinting();
+}
+
+function webViewerDownload() {
+  PDFViewerApplication.downloadOrSave({
+    sourceEventType: "download"
+  });
+}
+
+function webViewerSave() {
+  PDFViewerApplication.downloadOrSave({
+    sourceEventType: "save"
+  });
+}
+
+function webViewerFirstPage() {
+  if (PDFViewerApplication.pdfDocument) {
+    PDFViewerApplication.page = 1;
+  }
+}
+
+function webViewerLastPage() {
+  if (PDFViewerApplication.pdfDocument) {
+    PDFViewerApplication.page = PDFViewerApplication.pagesCount;
+  }
+}
+
+function webViewerNextPage() {
+  PDFViewerApplication.page++;
+}
+
+function webViewerPreviousPage() {
+  PDFViewerApplication.page--;
+}
+
+function webViewerZoomIn() {
+  PDFViewerApplication.zoomIn();
+}
+
+function webViewerZoomOut() {
+  PDFViewerApplication.zoomOut();
+}
+
+function webViewerZoomReset() {
+  PDFViewerApplication.zoomReset();
+}
+
+function webViewerPageNumberChanged(evt) {
+  const pdfViewer = PDFViewerApplication.pdfViewer;
+
+  if (evt.value !== "") {
+    PDFViewerApplication.pdfLinkService.goToPage(evt.value);
+  }
+
+  if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer.currentPageLabel) {
+    PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
+  }
+}
+
+function webViewerScaleChanged(evt) {
+  PDFViewerApplication.pdfViewer.currentScaleValue = evt.value;
+}
+
+function webViewerRotateCw() {
+  PDFViewerApplication.rotatePages(90);
+}
+
+function webViewerRotateCcw() {
+  PDFViewerApplication.rotatePages(-90);
+}
+
+function webViewerOptionalContentConfig(evt) {
+  PDFViewerApplication.pdfViewer.optionalContentConfigPromise = evt.promise;
+}
+
+function webViewerSwitchScrollMode(evt) {
+  PDFViewerApplication.pdfViewer.scrollMode = evt.mode;
+}
+
+function webViewerSwitchSpreadMode(evt) {
+  PDFViewerApplication.pdfViewer.spreadMode = evt.mode;
+}
+
+function webViewerDocumentProperties() {
+  PDFViewerApplication.pdfDocumentProperties.open();
+}
+
+function webViewerFind(evt) {
+  PDFViewerApplication.findController.executeCommand("find" + evt.type, {
+    query: evt.query,
+    phraseSearch: evt.phraseSearch,
+    caseSensitive: evt.caseSensitive,
+    entireWord: evt.entireWord,
+    highlightAll: evt.highlightAll,
+    findPrevious: evt.findPrevious
+  });
+}
+
+function webViewerFindFromUrlHash(evt) {
+  PDFViewerApplication.findController.executeCommand("find", {
+    query: evt.query,
+    phraseSearch: evt.phraseSearch,
+    caseSensitive: false,
+    entireWord: false,
+    highlightAll: true,
+    findPrevious: false
+  });
+}
+
+function webViewerUpdateFindMatchesCount({
+  matchesCount
+}) {
+  if (PDFViewerApplication.supportsIntegratedFind) {
+    PDFViewerApplication.externalServices.updateFindMatchesCount(matchesCount);
+  } else {
+    PDFViewerApplication.findBar.updateResultsCount(matchesCount);
+  }
+}
+
+function webViewerUpdateFindControlState({
+  state,
+  previous,
+  matchesCount,
+  rawQuery
+}) {
+  if (PDFViewerApplication.supportsIntegratedFind) {
+    PDFViewerApplication.externalServices.updateFindControlState({
+      result: state,
+      findPrevious: previous,
+      matchesCount,
+      rawQuery
+    });
+  } else {
+    PDFViewerApplication.findBar.updateUIState(state, previous, matchesCount);
+  }
+}
+
+function webViewerScaleChanging(evt) {
+  PDFViewerApplication.toolbar.setPageScale(evt.presetValue, evt.scale);
+  PDFViewerApplication.pdfViewer.update();
+}
+
+function webViewerRotationChanging(evt) {
+  PDFViewerApplication.pdfThumbnailViewer.pagesRotation = evt.pagesRotation;
+  PDFViewerApplication.forceRendering();
+  PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
+}
+
+function webViewerPageChanging({
+  pageNumber,
+  pageLabel
+}) {
+  PDFViewerApplication.toolbar.setPageNumber(pageNumber, pageLabel);
+  PDFViewerApplication.secondaryToolbar.setPageNumber(pageNumber);
+
+  if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
+    PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(pageNumber);
+  }
+}
+
+function webViewerVisibilityChange(evt) {
+  if (document.visibilityState === "visible") {
+    setZoomDisabledTimeout();
+  }
+}
+
+let zoomDisabledTimeout = null;
+
+function setZoomDisabledTimeout() {
+  if (zoomDisabledTimeout) {
+    clearTimeout(zoomDisabledTimeout);
+  }
+
+  zoomDisabledTimeout = setTimeout(function () {
+    zoomDisabledTimeout = null;
+  }, WHEEL_ZOOM_DISABLED_TIMEOUT);
+}
+
+function webViewerWheel(evt) {
+  const {
+    pdfViewer,
+    supportedMouseWheelZoomModifierKeys
+  } = PDFViewerApplication;
+
+  if (pdfViewer.isInPresentationMode) {
+    return;
+  }
+
+  if (evt.ctrlKey && supportedMouseWheelZoomModifierKeys.ctrlKey || evt.metaKey && supportedMouseWheelZoomModifierKeys.metaKey) {
+    evt.preventDefault();
+
+    if (zoomDisabledTimeout || document.visibilityState === "hidden") {
+      return;
+    }
+
+    const previousScale = pdfViewer.currentScale;
+    const delta = (0, _ui_utils.normalizeWheelEventDirection)(evt);
+    let ticks = 0;
+
+    if (evt.deltaMode === WheelEvent.DOM_DELTA_LINE || evt.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
+      if (Math.abs(delta) >= 1) {
+        ticks = Math.sign(delta);
+      } else {
+        ticks = PDFViewerApplication.accumulateWheelTicks(delta);
+      }
+    } else {
+      const PIXELS_PER_LINE_SCALE = 30;
+      ticks = PDFViewerApplication.accumulateWheelTicks(delta / PIXELS_PER_LINE_SCALE);
+    }
+
+    if (ticks < 0) {
+      PDFViewerApplication.zoomOut(-ticks);
+    } else if (ticks > 0) {
+      PDFViewerApplication.zoomIn(ticks);
+    }
+
+    const currentScale = pdfViewer.currentScale;
+
+    if (previousScale !== currentScale) {
+      const scaleCorrectionFactor = currentScale / previousScale - 1;
+      const rect = pdfViewer.container.getBoundingClientRect();
+      const dx = evt.clientX - rect.left;
+      const dy = evt.clientY - rect.top;
+      pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
+      pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
+    }
+  } else {
+    setZoomDisabledTimeout();
+  }
+}
+
+function webViewerTouchStart(evt) {
+  if (evt.touches.length > 1) {
+    evt.preventDefault();
+  }
+}
+
+function webViewerClick(evt) {
+  if (PDFViewerApplication.triggerDelayedFallback && PDFViewerApplication.pdfViewer.containsElement(evt.target)) {
+    PDFViewerApplication.triggerDelayedFallback();
+  }
+
+  if (!PDFViewerApplication.secondaryToolbar.isOpen) {
+    return;
+  }
+
+  const appConfig = PDFViewerApplication.appConfig;
+
+  if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
+    PDFViewerApplication.secondaryToolbar.close();
+  }
+}
+
+function webViewerKeyUp(evt) {
+  if (evt.keyCode === 9) {
+    if (PDFViewerApplication.triggerDelayedFallback) {
+      PDFViewerApplication.triggerDelayedFallback();
+    }
+  }
+}
+
+function webViewerKeyDown(evt) {
+  if (PDFViewerApplication.overlayManager.active) {
+    return;
+  }
+
+  let handled = false,
+      ensureViewerFocused = false;
+  const cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
+  const pdfViewer = PDFViewerApplication.pdfViewer;
+  const isViewerInPresentationMode = pdfViewer && pdfViewer.isInPresentationMode;
+
+  if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
+    switch (evt.keyCode) {
+      case 70:
+        if (!PDFViewerApplication.supportsIntegratedFind && !evt.shiftKey) {
+          PDFViewerApplication.findBar.open();
+          handled = true;
+        }
+
+        break;
+
+      case 71:
+        if (!PDFViewerApplication.supportsIntegratedFind) {
+          const findState = PDFViewerApplication.findController.state;
+
+          if (findState) {
+            PDFViewerApplication.findController.executeCommand("findagain", {
+              query: findState.query,
+              phraseSearch: findState.phraseSearch,
+              caseSensitive: findState.caseSensitive,
+              entireWord: findState.entireWord,
+              highlightAll: findState.highlightAll,
+              findPrevious: cmd === 5 || cmd === 12
+            });
+          }
+
+          handled = true;
+        }
+
+        break;
+
+      case 61:
+      case 107:
+      case 187:
+      case 171:
+        if (!isViewerInPresentationMode) {
+          PDFViewerApplication.zoomIn();
+        }
+
+        handled = true;
+        break;
+
+      case 173:
+      case 109:
+      case 189:
+        if (!isViewerInPresentationMode) {
+          PDFViewerApplication.zoomOut();
+        }
+
+        handled = true;
+        break;
+
+      case 48:
+      case 96:
+        if (!isViewerInPresentationMode) {
+          setTimeout(function () {
+            PDFViewerApplication.zoomReset();
+          });
+          handled = false;
+        }
+
+        break;
+
+      case 38:
+        if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
+          PDFViewerApplication.page = 1;
+          handled = true;
+          ensureViewerFocused = true;
+        }
+
+        break;
+
+      case 40:
+        if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
+          PDFViewerApplication.page = PDFViewerApplication.pagesCount;
+          handled = true;
+          ensureViewerFocused = true;
+        }
+
+        break;
+    }
+  }
+
+  if (cmd === 3 || cmd === 10) {
+    switch (evt.keyCode) {
+      case 80:
+        PDFViewerApplication.requestPresentationMode();
+        handled = true;
+        break;
+
+      case 71:
+        PDFViewerApplication.appConfig.toolbar.pageNumber.select();
+        handled = true;
+        break;
+    }
+  }
+
+  if (handled) {
+    if (ensureViewerFocused && !isViewerInPresentationMode) {
+      pdfViewer.focus();
+    }
+
+    evt.preventDefault();
+    return;
+  }
+
+  const curElement = (0, _ui_utils.getActiveOrFocusedElement)();
+  const curElementTagName = curElement && curElement.tagName.toUpperCase();
+
+  if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" || curElementTagName === "SELECT" || curElement && curElement.isContentEditable) {
+    if (evt.keyCode !== 27) {
+      return;
+    }
+  }
+
+  if (cmd === 0) {
+    let turnPage = 0,
+        turnOnlyIfPageFit = false;
+
+    switch (evt.keyCode) {
+      case 38:
+      case 33:
+        if (pdfViewer.isVerticalScrollbarEnabled) {
+          turnOnlyIfPageFit = true;
+        }
+
+        turnPage = -1;
+        break;
+
+      case 8:
+        if (!isViewerInPresentationMode) {
+          turnOnlyIfPageFit = true;
+        }
+
+        turnPage = -1;
+        break;
+
+      case 37:
+        if (pdfViewer.isHorizontalScrollbarEnabled) {
+          turnOnlyIfPageFit = true;
+        }
+
+      case 75:
+      case 80:
+        turnPage = -1;
+        break;
+
+      case 27:
+        if (PDFViewerApplication.secondaryToolbar.isOpen) {
+          PDFViewerApplication.secondaryToolbar.close();
+          handled = true;
+        }
+
+        if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication.findBar.opened) {
+          PDFViewerApplication.findBar.close();
+          handled = true;
+        }
+
+        break;
+
+      case 40:
+      case 34:
+        if (pdfViewer.isVerticalScrollbarEnabled) {
+          turnOnlyIfPageFit = true;
+        }
+
+        turnPage = 1;
+        break;
+
+      case 13:
+      case 32:
+        if (!isViewerInPresentationMode) {
+          turnOnlyIfPageFit = true;
+        }
+
+        turnPage = 1;
+        break;
+
+      case 39:
+        if (pdfViewer.isHorizontalScrollbarEnabled) {
+          turnOnlyIfPageFit = true;
+        }
+
+      case 74:
+      case 78:
+        turnPage = 1;
+        break;
+
+      case 36:
+        if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
+          PDFViewerApplication.page = 1;
+          handled = true;
+          ensureViewerFocused = true;
+        }
+
+        break;
+
+      case 35:
+        if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
+          PDFViewerApplication.page = PDFViewerApplication.pagesCount;
+          handled = true;
+          ensureViewerFocused = true;
+        }
+
+        break;
+
+      case 83:
+        PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.SELECT);
+        break;
+
+      case 72:
+        PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.HAND);
+        break;
+
+      case 82:
+        PDFViewerApplication.rotatePages(90);
+        break;
+
+      case 115:
+        PDFViewerApplication.pdfSidebar.toggle();
+        break;
+    }
+
+    if (turnPage !== 0 && (!turnOnlyIfPageFit || pdfViewer.currentScaleValue === "page-fit")) {
+      if (turnPage > 0) {
+        if (PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
+          PDFViewerApplication.page++;
+        }
+      } else {
+        if (PDFViewerApplication.page > 1) {
+          PDFViewerApplication.page--;
+        }
+      }
+
+      handled = true;
+    }
+  }
+
+  if (cmd === 4) {
+    switch (evt.keyCode) {
+      case 13:
+      case 32:
+        if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== "page-fit") {
+          break;
+        }
+
+        if (PDFViewerApplication.page > 1) {
+          PDFViewerApplication.page--;
+        }
+
+        handled = true;
+        break;
+
+      case 82:
+        PDFViewerApplication.rotatePages(-90);
+        break;
+    }
+  }
+
+  if (!handled && !isViewerInPresentationMode) {
+    if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !== "BUTTON") {
+      ensureViewerFocused = true;
+    }
+  }
+
+  if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
+    pdfViewer.focus();
+  }
+
+  if (handled) {
+    evt.preventDefault();
+  }
+}
+
+function beforeUnload(evt) {
+  evt.preventDefault();
+  evt.returnValue = "";
+  return false;
+}
+
+function apiPageLayoutToSpreadMode(layout) {
+  switch (layout) {
+    case "SinglePage":
+    case "OneColumn":
+      return _ui_utils.SpreadMode.NONE;
+
+    case "TwoColumnLeft":
+    case "TwoPageLeft":
+      return _ui_utils.SpreadMode.ODD;
+
+    case "TwoColumnRight":
+    case "TwoPageRight":
+      return _ui_utils.SpreadMode.EVEN;
+  }
+
+  return _ui_utils.SpreadMode.NONE;
+}
+
+function apiPageModeToSidebarView(mode) {
+  switch (mode) {
+    case "UseNone":
+      return _ui_utils.SidebarView.NONE;
+
+    case "UseThumbs":
+      return _ui_utils.SidebarView.THUMBS;
+
+    case "UseOutlines":
+      return _ui_utils.SidebarView.OUTLINE;
+
+    case "UseAttachments":
+      return _ui_utils.SidebarView.ATTACHMENTS;
+
+    case "UseOC":
+      return _ui_utils.SidebarView.LAYERS;
+  }
+
+  return _ui_utils.SidebarView.NONE;
+}
+
+const PDFPrintServiceFactory = {
+  instance: {
+    supportsPrinting: false,
+
+    createPrintService() {
+      throw new Error("Not implemented: createPrintService");
+    }
+
+  }
+};
+exports.PDFPrintServiceFactory = PDFPrintServiceFactory;
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.approximateFraction = approximateFraction;
+exports.backtrackBeforeAllVisibleElements = backtrackBeforeAllVisibleElements;
+exports.binarySearchFirstItem = binarySearchFirstItem;
+exports.getActiveOrFocusedElement = getActiveOrFocusedElement;
+exports.getOutputScale = getOutputScale;
+exports.getPageSizeInches = getPageSizeInches;
+exports.getPDFFileNameFromURL = getPDFFileNameFromURL;
+exports.getVisibleElements = getVisibleElements;
+exports.isPortraitOrientation = isPortraitOrientation;
+exports.isValidRotation = isValidRotation;
+exports.isValidScrollMode = isValidScrollMode;
+exports.isValidSpreadMode = isValidSpreadMode;
+exports.moveToEndOfArray = moveToEndOfArray;
+exports.noContextMenuHandler = noContextMenuHandler;
+exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
+exports.normalizeWheelEventDirection = normalizeWheelEventDirection;
+exports.parseQueryString = parseQueryString;
+exports.roundToDivide = roundToDivide;
+exports.scrollIntoView = scrollIntoView;
+exports.waitOnEventOrTimeout = waitOnEventOrTimeout;
+exports.watchScroll = watchScroll;
+exports.WaitOnType = exports.VERTICAL_PADDING = exports.UNKNOWN_SCALE = exports.TextLayerMode = exports.SpreadMode = exports.SidebarView = exports.ScrollMode = exports.SCROLLBAR_PADDING = exports.RendererType = exports.ProgressBar = exports.PresentationModeState = exports.NullL10n = exports.MIN_SCALE = exports.MAX_SCALE = exports.MAX_AUTO_SCALE = exports.EventBus = exports.DEFAULT_SCALE_VALUE = exports.DEFAULT_SCALE = exports.CSS_UNITS = exports.AutoPrintRegExp = exports.animationStarted = void 0;
+const CSS_UNITS = 96.0 / 72.0;
+exports.CSS_UNITS = CSS_UNITS;
+const DEFAULT_SCALE_VALUE = "auto";
+exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
+const DEFAULT_SCALE = 1.0;
+exports.DEFAULT_SCALE = DEFAULT_SCALE;
+const MIN_SCALE = 0.1;
+exports.MIN_SCALE = MIN_SCALE;
+const MAX_SCALE = 10.0;
+exports.MAX_SCALE = MAX_SCALE;
+const UNKNOWN_SCALE = 0;
+exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
+const MAX_AUTO_SCALE = 1.25;
+exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
+const SCROLLBAR_PADDING = 40;
+exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
+const VERTICAL_PADDING = 5;
+exports.VERTICAL_PADDING = VERTICAL_PADDING;
+const LOADINGBAR_END_OFFSET_VAR = "--loadingBar-end-offset";
+const PresentationModeState = {
+  UNKNOWN: 0,
+  NORMAL: 1,
+  CHANGING: 2,
+  FULLSCREEN: 3
+};
+exports.PresentationModeState = PresentationModeState;
+const SidebarView = {
+  UNKNOWN: -1,
+  NONE: 0,
+  THUMBS: 1,
+  OUTLINE: 2,
+  ATTACHMENTS: 3,
+  LAYERS: 4
+};
+exports.SidebarView = SidebarView;
+const RendererType = {
+  CANVAS: "canvas",
+  SVG: "svg"
+};
+exports.RendererType = RendererType;
+const TextLayerMode = {
+  DISABLE: 0,
+  ENABLE: 1,
+  ENABLE_ENHANCE: 2
+};
+exports.TextLayerMode = TextLayerMode;
+const ScrollMode = {
+  UNKNOWN: -1,
+  VERTICAL: 0,
+  HORIZONTAL: 1,
+  WRAPPED: 2
+};
+exports.ScrollMode = ScrollMode;
+const SpreadMode = {
+  UNKNOWN: -1,
+  NONE: 0,
+  ODD: 1,
+  EVEN: 2
+};
+exports.SpreadMode = SpreadMode;
+const AutoPrintRegExp = /\bprint\s*\(/;
+exports.AutoPrintRegExp = AutoPrintRegExp;
+
+function formatL10nValue(text, args) {
+  if (!args) {
+    return text;
+  }
+
+  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
+    return name in args ? args[name] : "{{" + name + "}}";
+  });
+}
+
+const NullL10n = {
+  async getLanguage() {
+    return "en-us";
+  },
+
+  async getDirection() {
+    return "ltr";
+  },
+
+  async get(property, args, fallback) {
+    return formatL10nValue(fallback, args);
+  },
+
+  async translate(element) {}
+
+};
+exports.NullL10n = NullL10n;
+
+function getOutputScale(ctx) {
+  const devicePixelRatio = window.devicePixelRatio || 1;
+  const backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
+  const pixelRatio = devicePixelRatio / backingStoreRatio;
+  return {
+    sx: pixelRatio,
+    sy: pixelRatio,
+    scaled: pixelRatio !== 1
+  };
+}
+
+function scrollIntoView(element, spot, skipOverflowHiddenElements = false) {
+  let parent = element.offsetParent;
+
+  if (!parent) {
+    console.error("offsetParent is not set -- cannot scroll");
+    return;
+  }
+
+  let offsetY = element.offsetTop + element.clientTop;
+  let offsetX = element.offsetLeft + element.clientLeft;
+
+  while (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent.scrollWidth || skipOverflowHiddenElements && getComputedStyle(parent).overflow === "hidden") {
+    if (parent.dataset._scaleY) {
+      offsetY /= parent.dataset._scaleY;
+      offsetX /= parent.dataset._scaleX;
+    }
+
+    offsetY += parent.offsetTop;
+    offsetX += parent.offsetLeft;
+    parent = parent.offsetParent;
+
+    if (!parent) {
+      return;
+    }
+  }
+
+  if (spot) {
+    if (spot.top !== undefined) {
+      offsetY += spot.top;
+    }
+
+    if (spot.left !== undefined) {
+      offsetX += spot.left;
+      parent.scrollLeft = offsetX;
+    }
+  }
+
+  parent.scrollTop = offsetY;
+}
+
+function watchScroll(viewAreaElement, callback) {
+  const debounceScroll = function (evt) {
+    if (rAF) {
+      return;
+    }
+
+    rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
+      rAF = null;
+      const currentX = viewAreaElement.scrollLeft;
+      const lastX = state.lastX;
+
+      if (currentX !== lastX) {
+        state.right = currentX > lastX;
+      }
+
+      state.lastX = currentX;
+      const currentY = viewAreaElement.scrollTop;
+      const lastY = state.lastY;
+
+      if (currentY !== lastY) {
+        state.down = currentY > lastY;
+      }
+
+      state.lastY = currentY;
+      callback(state);
+    });
+  };
+
+  const state = {
+    right: true,
+    down: true,
+    lastX: viewAreaElement.scrollLeft,
+    lastY: viewAreaElement.scrollTop,
+    _eventHandler: debounceScroll
+  };
+  let rAF = null;
+  viewAreaElement.addEventListener("scroll", debounceScroll, true);
+  return state;
+}
+
+function parseQueryString(query) {
+  const parts = query.split("&");
+  const params = Object.create(null);
+
+  for (let i = 0, ii = parts.length; i < ii; ++i) {
+    const param = parts[i].split("=");
+    const key = param[0].toLowerCase();
+    const value = param.length > 1 ? param[1] : null;
+    params[decodeURIComponent(key)] = decodeURIComponent(value);
+  }
+
+  return params;
+}
+
+function binarySearchFirstItem(items, condition) {
+  let minIndex = 0;
+  let maxIndex = items.length - 1;
+
+  if (maxIndex < 0 || !condition(items[maxIndex])) {
+    return items.length;
+  }
+
+  if (condition(items[minIndex])) {
+    return minIndex;
+  }
+
+  while (minIndex < maxIndex) {
+    const currentIndex = minIndex + maxIndex >> 1;
+    const currentItem = items[currentIndex];
+
+    if (condition(currentItem)) {
+      maxIndex = currentIndex;
+    } else {
+      minIndex = currentIndex + 1;
+    }
+  }
+
+  return minIndex;
+}
+
+function approximateFraction(x) {
+  if (Math.floor(x) === x) {
+    return [x, 1];
+  }
+
+  const xinv = 1 / x;
+  const limit = 8;
+
+  if (xinv > limit) {
+    return [1, limit];
+  } else if (Math.floor(xinv) === xinv) {
+    return [1, xinv];
+  }
+
+  const x_ = x > 1 ? xinv : x;
+  let a = 0,
+      b = 1,
+      c = 1,
+      d = 1;
+
+  while (true) {
+    const p = a + c,
+          q = b + d;
+
+    if (q > limit) {
+      break;
+    }
+
+    if (x_ <= p / q) {
+      c = p;
+      d = q;
+    } else {
+      a = p;
+      b = q;
+    }
+  }
+
+  let result;
+
+  if (x_ - a / b < c / d - x_) {
+    result = x_ === x ? [a, b] : [b, a];
+  } else {
+    result = x_ === x ? [c, d] : [d, c];
+  }
+
+  return result;
+}
+
+function roundToDivide(x, div) {
+  const r = x % div;
+  return r === 0 ? x : Math.round(x - r + div);
+}
+
+function getPageSizeInches({
+  view,
+  userUnit,
+  rotate
+}) {
+  const [x1, y1, x2, y2] = view;
+  const changeOrientation = rotate % 180 !== 0;
+  const width = (x2 - x1) / 72 * userUnit;
+  const height = (y2 - y1) / 72 * userUnit;
+  return {
+    width: changeOrientation ? height : width,
+    height: changeOrientation ? width : height
+  };
+}
+
+function backtrackBeforeAllVisibleElements(index, views, top) {
+  if (index < 2) {
+    return index;
+  }
+
+  let elt = views[index].div;
+  let pageTop = elt.offsetTop + elt.clientTop;
+
+  if (pageTop >= top) {
+    elt = views[index - 1].div;
+    pageTop = elt.offsetTop + elt.clientTop;
+  }
+
+  for (let i = index - 2; i >= 0; --i) {
+    elt = views[i].div;
+
+    if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
+      break;
+    }
+
+    index = i;
+  }
+
+  return index;
+}
+
+function getVisibleElements({
+  scrollEl,
+  views,
+  sortByVisibility = false,
+  horizontal = false,
+  rtl = false
+}) {
+  const top = scrollEl.scrollTop,
+        bottom = top + scrollEl.clientHeight;
+  const left = scrollEl.scrollLeft,
+        right = left + scrollEl.clientWidth;
+
+  function isElementBottomAfterViewTop(view) {
+    const element = view.div;
+    const elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
+    return elementBottom > top;
+  }
+
+  function isElementNextAfterViewHorizontally(view) {
+    const element = view.div;
+    const elementLeft = element.offsetLeft + element.clientLeft;
+    const elementRight = elementLeft + element.clientWidth;
+    return rtl ? elementLeft < right : elementRight > left;
+  }
+
+  const visible = [],
+        numViews = views.length;
+  let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop);
+
+  if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
+    firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
+  }
+
+  let lastEdge = horizontal ? right : -1;
+
+  for (let i = firstVisibleElementInd; i < numViews; i++) {
+    const view = views[i],
+          element = view.div;
+    const currentWidth = element.offsetLeft + element.clientLeft;
+    const currentHeight = element.offsetTop + element.clientTop;
+    const viewWidth = element.clientWidth,
+          viewHeight = element.clientHeight;
+    const viewRight = currentWidth + viewWidth;
+    const viewBottom = currentHeight + viewHeight;
+
+    if (lastEdge === -1) {
+      if (viewBottom >= bottom) {
+        lastEdge = viewBottom;
+      }
+    } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
+      break;
+    }
+
+    if (viewBottom <= top || currentHeight >= bottom || viewRight <= left || currentWidth >= right) {
+      continue;
+    }
+
+    const hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom);
+    const hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);
+    const percent = (viewHeight - hiddenHeight) * (viewWidth - hiddenWidth) * 100 / viewHeight / viewWidth | 0;
+    visible.push({
+      id: view.id,
+      x: currentWidth,
+      y: currentHeight,
+      view,
+      percent
+    });
+  }
+
+  const first = visible[0],
+        last = visible[visible.length - 1];
+
+  if (sortByVisibility) {
+    visible.sort(function (a, b) {
+      const pc = a.percent - b.percent;
+
+      if (Math.abs(pc) > 0.001) {
+        return -pc;
+      }
+
+      return a.id - b.id;
+    });
+  }
+
+  return {
+    first,
+    last,
+    views: visible
+  };
+}
+
+function noContextMenuHandler(evt) {
+  evt.preventDefault();
+}
+
+function isDataSchema(url) {
+  let i = 0;
+  const ii = url.length;
+
+  while (i < ii && url[i].trim() === "") {
+    i++;
+  }
+
+  return url.substring(i, i + 5).toLowerCase() === "data:";
+}
+
+function getPDFFileNameFromURL(url, defaultFilename = "document.pdf") {
+  if (typeof url !== "string") {
+    return defaultFilename;
+  }
+
+  if (isDataSchema(url)) {
+    console.warn("getPDFFileNameFromURL: " + 'ignoring "data:" URL for performance reasons.');
+    return defaultFilename;
+  }
+
+  const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
+  const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
+  const splitURI = reURI.exec(url);
+  let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
+
+  if (suggestedFilename) {
+    suggestedFilename = suggestedFilename[0];
+
+    if (suggestedFilename.includes("%")) {
+      try {
+        suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
+      } catch (ex) {}
+    }
+  }
+
+  return suggestedFilename || defaultFilename;
+}
+
+function normalizeWheelEventDirection(evt) {
+  let delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
+  const angle = Math.atan2(evt.deltaY, evt.deltaX);
+
+  if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
+    delta = -delta;
+  }
+
+  return delta;
+}
+
+function normalizeWheelEventDelta(evt) {
+  let delta = normalizeWheelEventDirection(evt);
+  const MOUSE_DOM_DELTA_PIXEL_MODE = 0;
+  const MOUSE_DOM_DELTA_LINE_MODE = 1;
+  const MOUSE_PIXELS_PER_LINE = 30;
+  const MOUSE_LINES_PER_PAGE = 30;
+
+  if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
+    delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
+  } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
+    delta /= MOUSE_LINES_PER_PAGE;
+  }
+
+  return delta;
+}
+
+function isValidRotation(angle) {
+  return Number.isInteger(angle) && angle % 90 === 0;
+}
+
+function isValidScrollMode(mode) {
+  return Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) && mode !== ScrollMode.UNKNOWN;
+}
+
+function isValidSpreadMode(mode) {
+  return Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) && mode !== SpreadMode.UNKNOWN;
+}
+
+function isPortraitOrientation(size) {
+  return size.width <= size.height;
+}
+
+const WaitOnType = {
+  EVENT: "event",
+  TIMEOUT: "timeout"
+};
+exports.WaitOnType = WaitOnType;
+
+function waitOnEventOrTimeout({
+  target,
+  name,
+  delay = 0
+}) {
+  return new Promise(function (resolve, reject) {
+    if (typeof target !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
+      throw new Error("waitOnEventOrTimeout - invalid parameters.");
+    }
+
+    function handler(type) {
+      if (target instanceof EventBus) {
+        target._off(name, eventHandler);
+      } else {
+        target.removeEventListener(name, eventHandler);
+      }
+
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+
+      resolve(type);
+    }
+
+    const eventHandler = handler.bind(null, WaitOnType.EVENT);
+
+    if (target instanceof EventBus) {
+      target._on(name, eventHandler);
+    } else {
+      target.addEventListener(name, eventHandler);
+    }
+
+    const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
+    const timeout = setTimeout(timeoutHandler, delay);
+  });
+}
+
+const animationStarted = new Promise(function (resolve) {
+  window.requestAnimationFrame(resolve);
+});
+exports.animationStarted = animationStarted;
+
+function dispatchDOMEvent(eventName, args = null) {
+  const details = Object.create(null);
+
+  if (args && args.length > 0) {
+    const obj = args[0];
+
+    for (const key in obj) {
+      const value = obj[key];
+
+      if (key === "source") {
+        if (value === window || value === document) {
+          return;
+        }
+
+        continue;
+      }
+
+      details[key] = value;
+    }
+  }
+
+  const event = document.createEvent("CustomEvent");
+  event.initCustomEvent(eventName, true, true, details);
+  document.dispatchEvent(event);
+}
+
+class EventBus {
+  constructor(options) {
+    this._listeners = Object.create(null);
+    this._isInAutomation = options?.isInAutomation === true;
+  }
+
+  on(eventName, listener, options = null) {
+    this._on(eventName, listener, {
+      external: true,
+      once: options?.once
+    });
+  }
+
+  off(eventName, listener, options = null) {
+    this._off(eventName, listener, {
+      external: true,
+      once: options?.once
+    });
+  }
+
+  dispatch(eventName) {
+    const eventListeners = this._listeners[eventName];
+
+    if (!eventListeners || eventListeners.length === 0) {
+      if (this._isInAutomation) {
+        const args = Array.prototype.slice.call(arguments, 1);
+        dispatchDOMEvent(eventName, args);
+      }
+
+      return;
+    }
+
+    const args = Array.prototype.slice.call(arguments, 1);
+    let externalListeners;
+    eventListeners.slice(0).forEach(({
+      listener,
+      external,
+      once
+    }) => {
+      if (once) {
+        this._off(eventName, listener);
+      }
+
+      if (external) {
+        (externalListeners || (externalListeners = [])).push(listener);
+        return;
+      }
+
+      listener.apply(null, args);
+    });
+
+    if (externalListeners) {
+      externalListeners.forEach(listener => {
+        listener.apply(null, args);
+      });
+      externalListeners = null;
+    }
+
+    if (this._isInAutomation) {
+      dispatchDOMEvent(eventName, args);
+    }
+  }
+
+  _on(eventName, listener, options = null) {
+    var _this$_listeners;
+
+    const eventListeners = (_this$_listeners = this._listeners)[eventName] || (_this$_listeners[eventName] = []);
+    eventListeners.push({
+      listener,
+      external: options?.external === true,
+      once: options?.once === true
+    });
+  }
+
+  _off(eventName, listener, options = null) {
+    const eventListeners = this._listeners[eventName];
+
+    if (!eventListeners) {
+      return;
+    }
+
+    for (let i = 0, ii = eventListeners.length; i < ii; i++) {
+      if (eventListeners[i].listener === listener) {
+        eventListeners.splice(i, 1);
+        return;
+      }
+    }
+  }
+
+}
+
+exports.EventBus = EventBus;
+
+function clamp(v, min, max) {
+  return Math.min(Math.max(v, min), max);
+}
+
+class ProgressBar {
+  constructor(id, {
+    height,
+    width,
+    units
+  } = {}) {
+    this.visible = true;
+    this.div = document.querySelector(id + " .progress");
+    this.bar = this.div.parentNode;
+    this.height = height || 100;
+    this.width = width || 100;
+    this.units = units || "%";
+    this.div.style.height = this.height + this.units;
+    this.percent = 0;
+  }
+
+  _updateBar() {
+    if (this._indeterminate) {
+      this.div.classList.add("indeterminate");
+      this.div.style.width = this.width + this.units;
+      return;
+    }
+
+    this.div.classList.remove("indeterminate");
+    const progressSize = this.width * this._percent / 100;
+    this.div.style.width = progressSize + this.units;
+  }
+
+  get percent() {
+    return this._percent;
+  }
+
+  set percent(val) {
+    this._indeterminate = isNaN(val);
+    this._percent = clamp(val, 0, 100);
+
+    this._updateBar();
+  }
+
+  setWidth(viewer) {
+    if (!viewer) {
+      return;
+    }
+
+    const container = viewer.parentNode;
+    const scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
+
+    if (scrollbarWidth > 0) {
+      const doc = document.documentElement;
+      doc.style.setProperty(LOADINGBAR_END_OFFSET_VAR, `${scrollbarWidth}px`);
+    }
+  }
+
+  hide() {
+    if (!this.visible) {
+      return;
+    }
+
+    this.visible = false;
+    this.bar.classList.add("hidden");
+  }
+
+  show() {
+    if (this.visible) {
+      return;
+    }
+
+    this.visible = true;
+    this.bar.classList.remove("hidden");
+  }
+
+}
+
+exports.ProgressBar = ProgressBar;
+
+function moveToEndOfArray(arr, condition) {
+  const moved = [],
+        len = arr.length;
+  let write = 0;
+
+  for (let read = 0; read < len; ++read) {
+    if (condition(arr[read])) {
+      moved.push(arr[read]);
+    } else {
+      arr[write] = arr[read];
+      ++write;
+    }
+  }
+
+  for (let read = 0; write < len; ++read, ++write) {
+    arr[write] = moved[read];
+  }
+}
+
+function getActiveOrFocusedElement() {
+  let curRoot = document;
+  let curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
+
+  while (curActiveOrFocused && curActiveOrFocused.shadowRoot) {
+    curRoot = curActiveOrFocused.shadowRoot;
+    curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
+  }
+
+  return curActiveOrFocused;
+}
+
+/***/ }),
+/* 5 */
+/***/ ((module) => {
+
+
+
+let pdfjsLib;
+
+if (typeof window !== "undefined" && window["pdfjs-dist/build/pdf"]) {
+  pdfjsLib = window["pdfjs-dist/build/pdf"];
+} else {
+  pdfjsLib = require("../build/pdf.js");
+}
+
+module.exports = pdfjsLib;
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFCursorTools = exports.CursorTool = void 0;
+
+var _grab_to_pan = __webpack_require__(7);
+
+var _ui_utils = __webpack_require__(4);
+
+const CursorTool = {
+  SELECT: 0,
+  HAND: 1,
+  ZOOM: 2
+};
+exports.CursorTool = CursorTool;
+
+class PDFCursorTools {
+  constructor({
+    container,
+    eventBus,
+    cursorToolOnLoad = CursorTool.SELECT
+  }) {
+    this.container = container;
+    this.eventBus = eventBus;
+    this.active = CursorTool.SELECT;
+    this.activeBeforePresentationMode = null;
+    this.handTool = new _grab_to_pan.GrabToPan({
+      element: this.container
+    });
+
+    this._addEventListeners();
+
+    Promise.resolve().then(() => {
+      this.switchTool(cursorToolOnLoad);
+    });
+  }
+
+  get activeTool() {
+    return this.active;
+  }
+
+  switchTool(tool) {
+    if (this.activeBeforePresentationMode !== null) {
+      return;
+    }
+
+    if (tool === this.active) {
+      return;
+    }
+
+    const disableActiveTool = () => {
+      switch (this.active) {
+        case CursorTool.SELECT:
+          break;
+
+        case CursorTool.HAND:
+          this.handTool.deactivate();
+          break;
+
+        case CursorTool.ZOOM:
+      }
+    };
+
+    switch (tool) {
+      case CursorTool.SELECT:
+        disableActiveTool();
+        break;
+
+      case CursorTool.HAND:
+        disableActiveTool();
+        this.handTool.activate();
+        break;
+
+      case CursorTool.ZOOM:
+      default:
+        console.error(`switchTool: "${tool}" is an unsupported value.`);
+        return;
+    }
+
+    this.active = tool;
+
+    this._dispatchEvent();
+  }
+
+  _dispatchEvent() {
+    this.eventBus.dispatch("cursortoolchanged", {
+      source: this,
+      tool: this.active
+    });
+  }
+
+  _addEventListeners() {
+    this.eventBus._on("switchcursortool", evt => {
+      this.switchTool(evt.tool);
+    });
+
+    this.eventBus._on("presentationmodechanged", evt => {
+      switch (evt.state) {
+        case _ui_utils.PresentationModeState.CHANGING:
+          break;
+
+        case _ui_utils.PresentationModeState.FULLSCREEN:
+          {
+            const previouslyActive = this.active;
+            this.switchTool(CursorTool.SELECT);
+            this.activeBeforePresentationMode = previouslyActive;
+            break;
+          }
+
+        case _ui_utils.PresentationModeState.NORMAL:
+          {
+            const previouslyActive = this.activeBeforePresentationMode;
+            this.activeBeforePresentationMode = null;
+            this.switchTool(previouslyActive);
+            break;
+          }
+      }
+    });
+  }
+
+}
+
+exports.PDFCursorTools = PDFCursorTools;
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.GrabToPan = GrabToPan;
+
+function GrabToPan(options) {
+  this.element = options.element;
+  this.document = options.element.ownerDocument;
+
+  if (typeof options.ignoreTarget === "function") {
+    this.ignoreTarget = options.ignoreTarget;
+  }
+
+  this.onActiveChanged = options.onActiveChanged;
+  this.activate = this.activate.bind(this);
+  this.deactivate = this.deactivate.bind(this);
+  this.toggle = this.toggle.bind(this);
+  this._onmousedown = this._onmousedown.bind(this);
+  this._onmousemove = this._onmousemove.bind(this);
+  this._endPan = this._endPan.bind(this);
+  const overlay = this.overlay = document.createElement("div");
+  overlay.className = "grab-to-pan-grabbing";
+}
+
+GrabToPan.prototype = {
+  CSS_CLASS_GRAB: "grab-to-pan-grab",
+  activate: function GrabToPan_activate() {
+    if (!this.active) {
+      this.active = true;
+      this.element.addEventListener("mousedown", this._onmousedown, true);
+      this.element.classList.add(this.CSS_CLASS_GRAB);
+
+      if (this.onActiveChanged) {
+        this.onActiveChanged(true);
+      }
+    }
+  },
+  deactivate: function GrabToPan_deactivate() {
+    if (this.active) {
+      this.active = false;
+      this.element.removeEventListener("mousedown", this._onmousedown, true);
+
+      this._endPan();
+
+      this.element.classList.remove(this.CSS_CLASS_GRAB);
+
+      if (this.onActiveChanged) {
+        this.onActiveChanged(false);
+      }
+    }
+  },
+  toggle: function GrabToPan_toggle() {
+    if (this.active) {
+      this.deactivate();
+    } else {
+      this.activate();
+    }
+  },
+  ignoreTarget: function GrabToPan_ignoreTarget(node) {
+    return node[matchesSelector]("a[href], a[href] *, input, textarea, button, button *, select, option");
+  },
+  _onmousedown: function GrabToPan__onmousedown(event) {
+    if (event.button !== 0 || this.ignoreTarget(event.target)) {
+      return;
+    }
+
+    if (event.originalTarget) {
+      try {
+        event.originalTarget.tagName;
+      } catch (e) {
+        return;
+      }
+    }
+
+    this.scrollLeftStart = this.element.scrollLeft;
+    this.scrollTopStart = this.element.scrollTop;
+    this.clientXStart = event.clientX;
+    this.clientYStart = event.clientY;
+    this.document.addEventListener("mousemove", this._onmousemove, true);
+    this.document.addEventListener("mouseup", this._endPan, true);
+    this.element.addEventListener("scroll", this._endPan, true);
+    event.preventDefault();
+    event.stopPropagation();
+    const focusedElement = document.activeElement;
+
+    if (focusedElement && !focusedElement.contains(event.target)) {
+      focusedElement.blur();
+    }
+  },
+  _onmousemove: function GrabToPan__onmousemove(event) {
+    this.element.removeEventListener("scroll", this._endPan, true);
+
+    if (isLeftMouseReleased(event)) {
+      this._endPan();
+
+      return;
+    }
+
+    const xDiff = event.clientX - this.clientXStart;
+    const yDiff = event.clientY - this.clientYStart;
+    const scrollTop = this.scrollTopStart - yDiff;
+    const scrollLeft = this.scrollLeftStart - xDiff;
+
+    if (this.element.scrollTo) {
+      this.element.scrollTo({
+        top: scrollTop,
+        left: scrollLeft,
+        behavior: "instant"
+      });
+    } else {
+      this.element.scrollTop = scrollTop;
+      this.element.scrollLeft = scrollLeft;
+    }
+
+    if (!this.overlay.parentNode) {
+      document.body.appendChild(this.overlay);
+    }
+  },
+  _endPan: function GrabToPan__endPan() {
+    this.element.removeEventListener("scroll", this._endPan, true);
+    this.document.removeEventListener("mousemove", this._onmousemove, true);
+    this.document.removeEventListener("mouseup", this._endPan, true);
+    this.overlay.remove();
+  }
+};
+let matchesSelector;
+["webkitM", "mozM", "m"].some(function (prefix) {
+  let name = prefix + "atches";
+
+  if (name in document.documentElement) {
+    matchesSelector = name;
+  }
+
+  name += "Selector";
+
+  if (name in document.documentElement) {
+    matchesSelector = name;
+  }
+
+  return matchesSelector;
+});
+const isNotIEorIsIE10plus = !document.documentMode || document.documentMode > 9;
+const chrome = window.chrome;
+const isChrome15OrOpera15plus = chrome && (chrome.webstore || chrome.app);
+const isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator.userAgent);
+
+function isLeftMouseReleased(event) {
+  if ("buttons" in event && isNotIEorIsIE10plus) {
+    return !(event.buttons & 1);
+  }
+
+  if (isChrome15OrOpera15plus || isSafari6plus) {
+    return event.which === 0;
+  }
+
+  return false;
+}
+
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.RenderingStates = exports.PDFRenderingQueue = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+const CLEANUP_TIMEOUT = 30000;
+const RenderingStates = {
+  INITIAL: 0,
+  RUNNING: 1,
+  PAUSED: 2,
+  FINISHED: 3
+};
+exports.RenderingStates = RenderingStates;
+
+class PDFRenderingQueue {
+  constructor() {
+    this.pdfViewer = null;
+    this.pdfThumbnailViewer = null;
+    this.onIdle = null;
+    this.highestPriorityPage = null;
+    this.idleTimeout = null;
+    this.printing = false;
+    this.isThumbnailViewEnabled = false;
+  }
+
+  setViewer(pdfViewer) {
+    this.pdfViewer = pdfViewer;
+  }
+
+  setThumbnailViewer(pdfThumbnailViewer) {
+    this.pdfThumbnailViewer = pdfThumbnailViewer;
+  }
+
+  isHighestPriority(view) {
+    return this.highestPriorityPage === view.renderingId;
+  }
+
+  renderHighestPriority(currentlyVisiblePages) {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+
+    if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
+      return;
+    }
+
+    if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
+      if (this.pdfThumbnailViewer.forceRendering()) {
+        return;
+      }
+    }
+
+    if (this.printing) {
+      return;
+    }
+
+    if (this.onIdle) {
+      this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
+    }
+  }
+
+  getHighestPriority(visible, views, scrolledDown) {
+    const visibleViews = visible.views;
+    const numVisible = visibleViews.length;
+
+    if (numVisible === 0) {
+      return null;
+    }
+
+    for (let i = 0; i < numVisible; ++i) {
+      const view = visibleViews[i].view;
+
+      if (!this.isViewFinished(view)) {
+        return view;
+      }
+    }
+
+    if (scrolledDown) {
+      const nextPageIndex = visible.last.id;
+
+      if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
+        return views[nextPageIndex];
+      }
+    } else {
+      const previousPageIndex = visible.first.id - 2;
+
+      if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
+        return views[previousPageIndex];
+      }
+    }
+
+    return null;
+  }
+
+  isViewFinished(view) {
+    return view.renderingState === RenderingStates.FINISHED;
+  }
+
+  renderView(view) {
+    switch (view.renderingState) {
+      case RenderingStates.FINISHED:
+        return false;
+
+      case RenderingStates.PAUSED:
+        this.highestPriorityPage = view.renderingId;
+        view.resume();
+        break;
+
+      case RenderingStates.RUNNING:
+        this.highestPriorityPage = view.renderingId;
+        break;
+
+      case RenderingStates.INITIAL:
+        this.highestPriorityPage = view.renderingId;
+        view.draw().finally(() => {
+          this.renderHighestPriority();
+        }).catch(reason => {
+          if (reason instanceof _pdfjsLib.RenderingCancelledException) {
+            return;
+          }
+
+          console.error(`renderView: "${reason}"`);
+        });
+        break;
+    }
+
+    return true;
+  }
+
+}
+
+exports.PDFRenderingQueue = PDFRenderingQueue;
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.OverlayManager = void 0;
+
+class OverlayManager {
+  constructor() {
+    this._overlays = {};
+    this._active = null;
+    this._keyDownBound = this._keyDown.bind(this);
+  }
+
+  get active() {
+    return this._active;
+  }
+
+  async register(name, element, callerCloseMethod = null, canForceClose = false) {
+    let container;
+
+    if (!name || !element || !(container = element.parentNode)) {
+      throw new Error("Not enough parameters.");
+    } else if (this._overlays[name]) {
+      throw new Error("The overlay is already registered.");
+    }
+
+    this._overlays[name] = {
+      element,
+      container,
+      callerCloseMethod,
+      canForceClose
+    };
+  }
+
+  async unregister(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (this._active === name) {
+      throw new Error("The overlay cannot be removed while it is active.");
+    }
+
+    delete this._overlays[name];
+  }
+
+  async open(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (this._active) {
+      if (this._overlays[name].canForceClose) {
+        this._closeThroughCaller();
+      } else if (this._active === name) {
+        throw new Error("The overlay is already active.");
+      } else {
+        throw new Error("Another overlay is currently active.");
+      }
+    }
+
+    this._active = name;
+
+    this._overlays[this._active].element.classList.remove("hidden");
+
+    this._overlays[this._active].container.classList.remove("hidden");
+
+    window.addEventListener("keydown", this._keyDownBound);
+  }
+
+  async close(name) {
+    if (!this._overlays[name]) {
+      throw new Error("The overlay does not exist.");
+    } else if (!this._active) {
+      throw new Error("The overlay is currently not active.");
+    } else if (this._active !== name) {
+      throw new Error("Another overlay is currently active.");
+    }
+
+    this._overlays[this._active].container.classList.add("hidden");
+
+    this._overlays[this._active].element.classList.add("hidden");
+
+    this._active = null;
+    window.removeEventListener("keydown", this._keyDownBound);
+  }
+
+  _keyDown(evt) {
+    if (this._active && evt.keyCode === 27) {
+      this._closeThroughCaller();
+
+      evt.preventDefault();
+    }
+  }
+
+  _closeThroughCaller() {
+    if (this._overlays[this._active].callerCloseMethod) {
+      this._overlays[this._active].callerCloseMethod();
+    }
+
+    if (this._active) {
+      this.close(this._active);
+    }
+  }
+
+}
+
+exports.OverlayManager = OverlayManager;
+
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PasswordPrompt = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdfjsLib = __webpack_require__(5);
+
+class PasswordPrompt {
+  constructor(options, overlayManager, l10n = _ui_utils.NullL10n) {
+    this.overlayName = options.overlayName;
+    this.container = options.container;
+    this.label = options.label;
+    this.input = options.input;
+    this.submitButton = options.submitButton;
+    this.cancelButton = options.cancelButton;
+    this.overlayManager = overlayManager;
+    this.l10n = l10n;
+    this.updateCallback = null;
+    this.reason = null;
+    this.submitButton.addEventListener("click", this.verify.bind(this));
+    this.cancelButton.addEventListener("click", this.close.bind(this));
+    this.input.addEventListener("keydown", e => {
+      if (e.keyCode === 13) {
+        this.verify();
+      }
+    });
+    this.overlayManager.register(this.overlayName, this.container, this.close.bind(this), true);
+  }
+
+  open() {
+    this.overlayManager.open(this.overlayName).then(() => {
+      this.input.focus();
+      let promptString;
+
+      if (this.reason === _pdfjsLib.PasswordResponses.INCORRECT_PASSWORD) {
+        promptString = this.l10n.get("password_invalid", null, "Invalid password. Please try again.");
+      } else {
+        promptString = this.l10n.get("password_label", null, "Enter the password to open this PDF file.");
+      }
+
+      promptString.then(msg => {
+        this.label.textContent = msg;
+      });
+    });
+  }
+
+  close() {
+    this.overlayManager.close(this.overlayName).then(() => {
+      this.input.value = "";
+    });
+  }
+
+  verify() {
+    const password = this.input.value;
+
+    if (password && password.length > 0) {
+      this.close();
+      this.updateCallback(password);
+    }
+  }
+
+  setUpdateCallback(updateCallback, reason) {
+    this.updateCallback = updateCallback;
+    this.reason = reason;
+  }
+
+}
+
+exports.PasswordPrompt = PasswordPrompt;
+
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFAttachmentViewer = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _base_tree_viewer = __webpack_require__(12);
+
+var _viewer_compatibility = __webpack_require__(2);
+
+const PdfFileRegExp = /\.pdf$/i;
+
+class PDFAttachmentViewer extends _base_tree_viewer.BaseTreeViewer {
+  constructor(options) {
+    super(options);
+    this.downloadManager = options.downloadManager;
+
+    this.eventBus._on("fileattachmentannotation", this._appendAttachment.bind(this));
+  }
+
+  reset(keepRenderedCapability = false) {
+    super.reset();
+    this._attachments = null;
+
+    if (!keepRenderedCapability) {
+      this._renderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+    }
+
+    if (this._pendingDispatchEvent) {
+      clearTimeout(this._pendingDispatchEvent);
+    }
+
+    this._pendingDispatchEvent = null;
+  }
+
+  _dispatchEvent(attachmentsCount) {
+    this._renderedCapability.resolve();
+
+    if (this._pendingDispatchEvent) {
+      clearTimeout(this._pendingDispatchEvent);
+      this._pendingDispatchEvent = null;
+    }
+
+    if (attachmentsCount === 0) {
+      this._pendingDispatchEvent = setTimeout(() => {
+        this.eventBus.dispatch("attachmentsloaded", {
+          source: this,
+          attachmentsCount: 0
+        });
+        this._pendingDispatchEvent = null;
+      });
+      return;
+    }
+
+    this.eventBus.dispatch("attachmentsloaded", {
+      source: this,
+      attachmentsCount
+    });
+  }
+
+  _bindPdfLink(element, {
+    content,
+    filename
+  }) {
+    let blobUrl;
+
+    element.onclick = () => {
+      if (!blobUrl) {
+        blobUrl = URL.createObjectURL(new Blob([content], {
+          type: "application/pdf"
+        }));
+      }
+
+      let viewerUrl;
+      viewerUrl = blobUrl + "#filename=" + encodeURIComponent(filename);
+
+      try {
+        window.open(viewerUrl);
+      } catch (ex) {
+        console.error(`_bindPdfLink: ${ex}`);
+        URL.revokeObjectURL(blobUrl);
+        blobUrl = null;
+        this.downloadManager.downloadData(content, filename, "application/pdf");
+      }
+
+      return false;
+    };
+  }
+
+  _bindLink(element, {
+    content,
+    filename
+  }) {
+    element.onclick = () => {
+      const contentType = PdfFileRegExp.test(filename) ? "application/pdf" : "";
+      this.downloadManager.downloadData(content, filename, contentType);
+      return false;
+    };
+  }
+
+  render({
+    attachments,
+    keepRenderedCapability = false
+  }) {
+    if (this._attachments) {
+      this.reset(keepRenderedCapability);
+    }
+
+    this._attachments = attachments || null;
+
+    if (!attachments) {
+      this._dispatchEvent(0);
+
+      return;
+    }
+
+    const names = Object.keys(attachments).sort(function (a, b) {
+      return a.toLowerCase().localeCompare(b.toLowerCase());
+    });
+    const fragment = document.createDocumentFragment();
+    let attachmentsCount = 0;
+
+    for (const name of names) {
+      const item = attachments[name];
+      const filename = (0, _pdfjsLib.getFilenameFromUrl)(item.filename);
+      const div = document.createElement("div");
+      div.className = "treeItem";
+      const element = document.createElement("a");
+
+      if (PdfFileRegExp.test(filename) && !_viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL) {
+        this._bindPdfLink(element, {
+          content: item.content,
+          filename
+        });
+      } else {
+        this._bindLink(element, {
+          content: item.content,
+          filename
+        });
+      }
+
+      element.textContent = this._normalizeTextContent(filename);
+      div.appendChild(element);
+      fragment.appendChild(div);
+      attachmentsCount++;
+    }
+
+    this._finishRendering(fragment, attachmentsCount);
+  }
+
+  _appendAttachment({
+    id,
+    filename,
+    content
+  }) {
+    const renderedPromise = this._renderedCapability.promise;
+    renderedPromise.then(() => {
+      if (renderedPromise !== this._renderedCapability.promise) {
+        return;
+      }
+
+      let attachments = this._attachments;
+
+      if (!attachments) {
+        attachments = Object.create(null);
+      } else {
+        for (const name in attachments) {
+          if (id === name) {
+            return;
+          }
+        }
+      }
+
+      attachments[id] = {
+        filename,
+        content
+      };
+      this.render({
+        attachments,
+        keepRenderedCapability: true
+      });
+    });
+  }
+
+}
+
+exports.PDFAttachmentViewer = PDFAttachmentViewer;
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.BaseTreeViewer = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+const TREEITEM_OFFSET_TOP = -100;
+const TREEITEM_SELECTED_CLASS = "selected";
+
+class BaseTreeViewer {
+  constructor(options) {
+    if (this.constructor === BaseTreeViewer) {
+      throw new Error("Cannot initialize BaseTreeViewer.");
+    }
+
+    this.container = options.container;
+    this.eventBus = options.eventBus;
+    this.reset();
+  }
+
+  reset() {
+    this._pdfDocument = null;
+    this._lastToggleIsShow = true;
+    this._currentTreeItem = null;
+    this.container.textContent = "";
+    this.container.classList.remove("treeWithDeepNesting");
+  }
+
+  _dispatchEvent(count) {
+    throw new Error("Not implemented: _dispatchEvent");
+  }
+
+  _bindLink(element, params) {
+    throw new Error("Not implemented: _bindLink");
+  }
+
+  _normalizeTextContent(str) {
+    return (0, _pdfjsLib.removeNullCharacters)(str) || "\u2013";
+  }
+
+  _addToggleButton(div, hidden = false) {
+    const toggler = document.createElement("div");
+    toggler.className = "treeItemToggler";
+
+    if (hidden) {
+      toggler.classList.add("treeItemsHidden");
+    }
+
+    toggler.onclick = evt => {
+      evt.stopPropagation();
+      toggler.classList.toggle("treeItemsHidden");
+
+      if (evt.shiftKey) {
+        const shouldShowAll = !toggler.classList.contains("treeItemsHidden");
+
+        this._toggleTreeItem(div, shouldShowAll);
+      }
+    };
+
+    div.insertBefore(toggler, div.firstChild);
+  }
+
+  _toggleTreeItem(root, show = false) {
+    this._lastToggleIsShow = show;
+
+    for (const toggler of root.querySelectorAll(".treeItemToggler")) {
+      toggler.classList.toggle("treeItemsHidden", !show);
+    }
+  }
+
+  _toggleAllTreeItems() {
+    this._toggleTreeItem(this.container, !this._lastToggleIsShow);
+  }
+
+  _finishRendering(fragment, count, hasAnyNesting = false) {
+    if (hasAnyNesting) {
+      this.container.classList.add("treeWithDeepNesting");
+      this._lastToggleIsShow = !fragment.querySelector(".treeItemsHidden");
+    }
+
+    this.container.appendChild(fragment);
+
+    this._dispatchEvent(count);
+  }
+
+  render(params) {
+    throw new Error("Not implemented: render");
+  }
+
+  _updateCurrentTreeItem(treeItem = null) {
+    if (this._currentTreeItem) {
+      this._currentTreeItem.classList.remove(TREEITEM_SELECTED_CLASS);
+
+      this._currentTreeItem = null;
+    }
+
+    if (treeItem) {
+      treeItem.classList.add(TREEITEM_SELECTED_CLASS);
+      this._currentTreeItem = treeItem;
+    }
+  }
+
+  _scrollToCurrentTreeItem(treeItem) {
+    if (!treeItem) {
+      return;
+    }
+
+    let currentNode = treeItem.parentNode;
+
+    while (currentNode && currentNode !== this.container) {
+      if (currentNode.classList.contains("treeItem")) {
+        const toggler = currentNode.firstElementChild;
+        toggler?.classList.remove("treeItemsHidden");
+      }
+
+      currentNode = currentNode.parentNode;
+    }
+
+    this._updateCurrentTreeItem(treeItem);
+
+    this.container.scrollTo(treeItem.offsetLeft, treeItem.offsetTop + TREEITEM_OFFSET_TOP);
+  }
+
+}
+
+exports.BaseTreeViewer = BaseTreeViewer;
+
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFDocumentProperties = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _ui_utils = __webpack_require__(4);
+
+const DEFAULT_FIELD_CONTENT = "-";
+const NON_METRIC_LOCALES = ["en-us", "en-lr", "my"];
+const US_PAGE_NAMES = {
+  "8.5x11": "Letter",
+  "8.5x14": "Legal"
+};
+const METRIC_PAGE_NAMES = {
+  "297x420": "A3",
+  "210x297": "A4"
+};
+
+function getPageName(size, isPortrait, pageNames) {
+  const width = isPortrait ? size.width : size.height;
+  const height = isPortrait ? size.height : size.width;
+  return pageNames[`${width}x${height}`];
+}
+
+class PDFDocumentProperties {
+  constructor({
+    overlayName,
+    fields,
+    container,
+    closeButton
+  }, overlayManager, eventBus, l10n = _ui_utils.NullL10n) {
+    this.overlayName = overlayName;
+    this.fields = fields;
+    this.container = container;
+    this.overlayManager = overlayManager;
+    this.l10n = l10n;
+
+    this._reset();
+
+    closeButton.addEventListener("click", this.close.bind(this));
+    this.overlayManager.register(this.overlayName, this.container, this.close.bind(this));
+
+    eventBus._on("pagechanging", evt => {
+      this._currentPageNumber = evt.pageNumber;
+    });
+
+    eventBus._on("rotationchanging", evt => {
+      this._pagesRotation = evt.pagesRotation;
+    });
+
+    this._isNonMetricLocale = true;
+    l10n.getLanguage().then(locale => {
+      this._isNonMetricLocale = NON_METRIC_LOCALES.includes(locale);
+    });
+  }
+
+  async open() {
+    const freezeFieldData = data => {
+      Object.defineProperty(this, "fieldData", {
+        value: Object.freeze(data),
+        writable: false,
+        enumerable: true,
+        configurable: true
+      });
+    };
+
+    await Promise.all([this.overlayManager.open(this.overlayName), this._dataAvailableCapability.promise]);
+    const currentPageNumber = this._currentPageNumber;
+    const pagesRotation = this._pagesRotation;
+
+    if (this.fieldData && currentPageNumber === this.fieldData._currentPageNumber && pagesRotation === this.fieldData._pagesRotation) {
+      this._updateUI();
+
+      return;
+    }
+
+    const {
+      info,
+      contentDispositionFilename,
+      contentLength
+    } = await this.pdfDocument.getMetadata();
+    const [fileName, fileSize, creationDate, modificationDate, pageSize, isLinearized] = await Promise.all([contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url), this._parseFileSize(contentLength), this._parseDate(info.CreationDate), this._parseDate(info.ModDate), this.pdfDocument.getPage(currentPageNumber).then(pdfPage => {
+      return this._parsePageSize((0, _ui_utils.getPageSizeInches)(pdfPage), pagesRotation);
+    }), this._parseLinearization(info.IsLinearized)]);
+    freezeFieldData({
+      fileName,
+      fileSize,
+      title: info.Title,
+      author: info.Author,
+      subject: info.Subject,
+      keywords: info.Keywords,
+      creationDate,
+      modificationDate,
+      creator: info.Creator,
+      producer: info.Producer,
+      version: info.PDFFormatVersion,
+      pageCount: this.pdfDocument.numPages,
+      pageSize,
+      linearized: isLinearized,
+      _currentPageNumber: currentPageNumber,
+      _pagesRotation: pagesRotation
+    });
+
+    this._updateUI();
+
+    const {
+      length
+    } = await this.pdfDocument.getDownloadInfo();
+
+    if (contentLength === length) {
+      return;
+    }
+
+    const data = Object.assign(Object.create(null), this.fieldData);
+    data.fileSize = await this._parseFileSize(length);
+    freezeFieldData(data);
+
+    this._updateUI();
+  }
+
+  close() {
+    this.overlayManager.close(this.overlayName);
+  }
+
+  setDocument(pdfDocument, url = null) {
+    if (this.pdfDocument) {
+      this._reset();
+
+      this._updateUI(true);
+    }
+
+    if (!pdfDocument) {
+      return;
+    }
+
+    this.pdfDocument = pdfDocument;
+    this.url = url;
+
+    this._dataAvailableCapability.resolve();
+  }
+
+  _reset() {
+    this.pdfDocument = null;
+    this.url = null;
+    delete this.fieldData;
+    this._dataAvailableCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._currentPageNumber = 1;
+    this._pagesRotation = 0;
+  }
+
+  _updateUI(reset = false) {
+    if (reset || !this.fieldData) {
+      for (const id in this.fields) {
+        this.fields[id].textContent = DEFAULT_FIELD_CONTENT;
+      }
+
+      return;
+    }
+
+    if (this.overlayManager.active !== this.overlayName) {
+      return;
+    }
+
+    for (const id in this.fields) {
+      const content = this.fieldData[id];
+      this.fields[id].textContent = content || content === 0 ? content : DEFAULT_FIELD_CONTENT;
+    }
+  }
+
+  async _parseFileSize(fileSize = 0) {
+    const kb = fileSize / 1024;
+
+    if (!kb) {
+      return undefined;
+    } else if (kb < 1024) {
+      return this.l10n.get("document_properties_kb", {
+        size_kb: (+kb.toPrecision(3)).toLocaleString(),
+        size_b: fileSize.toLocaleString()
+      }, "{{size_kb}} KB ({{size_b}} bytes)");
+    }
+
+    return this.l10n.get("document_properties_mb", {
+      size_mb: (+(kb / 1024).toPrecision(3)).toLocaleString(),
+      size_b: fileSize.toLocaleString()
+    }, "{{size_mb}} MB ({{size_b}} bytes)");
+  }
+
+  async _parsePageSize(pageSizeInches, pagesRotation) {
+    if (!pageSizeInches) {
+      return undefined;
+    }
+
+    if (pagesRotation % 180 !== 0) {
+      pageSizeInches = {
+        width: pageSizeInches.height,
+        height: pageSizeInches.width
+      };
+    }
+
+    const isPortrait = (0, _ui_utils.isPortraitOrientation)(pageSizeInches);
+    let sizeInches = {
+      width: Math.round(pageSizeInches.width * 100) / 100,
+      height: Math.round(pageSizeInches.height * 100) / 100
+    };
+    let sizeMillimeters = {
+      width: Math.round(pageSizeInches.width * 25.4 * 10) / 10,
+      height: Math.round(pageSizeInches.height * 25.4 * 10) / 10
+    };
+    let pageName = null;
+    let rawName = getPageName(sizeInches, isPortrait, US_PAGE_NAMES) || getPageName(sizeMillimeters, isPortrait, METRIC_PAGE_NAMES);
+
+    if (!rawName && !(Number.isInteger(sizeMillimeters.width) && Number.isInteger(sizeMillimeters.height))) {
+      const exactMillimeters = {
+        width: pageSizeInches.width * 25.4,
+        height: pageSizeInches.height * 25.4
+      };
+      const intMillimeters = {
+        width: Math.round(sizeMillimeters.width),
+        height: Math.round(sizeMillimeters.height)
+      };
+
+      if (Math.abs(exactMillimeters.width - intMillimeters.width) < 0.1 && Math.abs(exactMillimeters.height - intMillimeters.height) < 0.1) {
+        rawName = getPageName(intMillimeters, isPortrait, METRIC_PAGE_NAMES);
+
+        if (rawName) {
+          sizeInches = {
+            width: Math.round(intMillimeters.width / 25.4 * 100) / 100,
+            height: Math.round(intMillimeters.height / 25.4 * 100) / 100
+          };
+          sizeMillimeters = intMillimeters;
+        }
+      }
+    }
+
+    if (rawName) {
+      pageName = this.l10n.get("document_properties_page_size_name_" + rawName.toLowerCase(), null, rawName);
+    }
+
+    return Promise.all([this._isNonMetricLocale ? sizeInches : sizeMillimeters, this.l10n.get("document_properties_page_size_unit_" + (this._isNonMetricLocale ? "inches" : "millimeters"), null, this._isNonMetricLocale ? "in" : "mm"), pageName, this.l10n.get("document_properties_page_size_orientation_" + (isPortrait ? "portrait" : "landscape"), null, isPortrait ? "portrait" : "landscape")]).then(([{
+      width,
+      height
+    }, unit, name, orientation]) => {
+      return this.l10n.get("document_properties_page_size_dimension_" + (name ? "name_" : "") + "string", {
+        width: width.toLocaleString(),
+        height: height.toLocaleString(),
+        unit,
+        name,
+        orientation
+      }, "{{width}} × {{height}} {{unit}} (" + (name ? "{{name}}, " : "") + "{{orientation}})");
+    });
+  }
+
+  async _parseDate(inputDate) {
+    const dateObject = _pdfjsLib.PDFDateString.toDateObject(inputDate);
+
+    if (!dateObject) {
+      return undefined;
+    }
+
+    return this.l10n.get("document_properties_date_string", {
+      date: dateObject.toLocaleDateString(),
+      time: dateObject.toLocaleTimeString()
+    }, "{{date}}, {{time}}");
+  }
+
+  _parseLinearization(isLinearized) {
+    return this.l10n.get("document_properties_linearized_" + (isLinearized ? "yes" : "no"), null, isLinearized ? "Yes" : "No");
+  }
+
+}
+
+exports.PDFDocumentProperties = PDFDocumentProperties;
+
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFFindBar = void 0;
+
+var _pdf_find_controller = __webpack_require__(15);
+
+var _ui_utils = __webpack_require__(4);
+
+const MATCHES_COUNT_LIMIT = 1000;
+
+class PDFFindBar {
+  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
+    this.opened = false;
+    this.bar = options.bar || null;
+    this.toggleButton = options.toggleButton || null;
+    this.findField = options.findField || null;
+    this.highlightAll = options.highlightAllCheckbox || null;
+    this.caseSensitive = options.caseSensitiveCheckbox || null;
+    this.entireWord = options.entireWordCheckbox || null;
+    this.findMsg = options.findMsg || null;
+    this.findResultsCount = options.findResultsCount || null;
+    this.findPreviousButton = options.findPreviousButton || null;
+    this.findNextButton = options.findNextButton || null;
+    this.eventBus = eventBus;
+    this.l10n = l10n;
+    this.toggleButton.addEventListener("click", () => {
+      this.toggle();
+    });
+    this.findField.addEventListener("input", () => {
+      this.dispatchEvent("");
+    });
+    this.bar.addEventListener("keydown", e => {
+      switch (e.keyCode) {
+        case 13:
+          if (e.target === this.findField) {
+            this.dispatchEvent("again", e.shiftKey);
+          }
+
+          break;
+
+        case 27:
+          this.close();
+          break;
+      }
+    });
+    this.findPreviousButton.addEventListener("click", () => {
+      this.dispatchEvent("again", true);
+    });
+    this.findNextButton.addEventListener("click", () => {
+      this.dispatchEvent("again", false);
+    });
+    this.highlightAll.addEventListener("click", () => {
+      this.dispatchEvent("highlightallchange");
+    });
+    this.caseSensitive.addEventListener("click", () => {
+      this.dispatchEvent("casesensitivitychange");
+    });
+    this.entireWord.addEventListener("click", () => {
+      this.dispatchEvent("entirewordchange");
+    });
+
+    this.eventBus._on("resize", this._adjustWidth.bind(this));
+  }
+
+  reset() {
+    this.updateUIState();
+  }
+
+  dispatchEvent(type, findPrev) {
+    this.eventBus.dispatch("find", {
+      source: this,
+      type,
+      query: this.findField.value,
+      phraseSearch: true,
+      caseSensitive: this.caseSensitive.checked,
+      entireWord: this.entireWord.checked,
+      highlightAll: this.highlightAll.checked,
+      findPrevious: findPrev
+    });
+  }
+
+  updateUIState(state, previous, matchesCount) {
+    let findMsg = "";
+    let status = "";
+
+    switch (state) {
+      case _pdf_find_controller.FindState.FOUND:
+        break;
+
+      case _pdf_find_controller.FindState.PENDING:
+        status = "pending";
+        break;
+
+      case _pdf_find_controller.FindState.NOT_FOUND:
+        findMsg = this.l10n.get("find_not_found", null, "Phrase not found");
+        status = "notFound";
+        break;
+
+      case _pdf_find_controller.FindState.WRAPPED:
+        if (previous) {
+          findMsg = this.l10n.get("find_reached_top", null, "Reached top of document, continued from bottom");
+        } else {
+          findMsg = this.l10n.get("find_reached_bottom", null, "Reached end of document, continued from top");
+        }
+
+        break;
+    }
+
+    this.findField.setAttribute("data-status", status);
+    Promise.resolve(findMsg).then(msg => {
+      this.findMsg.textContent = msg;
+
+      this._adjustWidth();
+    });
+    this.updateResultsCount(matchesCount);
+  }
+
+  updateResultsCount({
+    current = 0,
+    total = 0
+  } = {}) {
+    if (!this.findResultsCount) {
+      return;
+    }
+
+    const limit = MATCHES_COUNT_LIMIT;
+    let matchesCountMsg = "";
+
+    if (total > 0) {
+      if (total > limit) {
+        matchesCountMsg = this.l10n.get("find_match_count_limit[other]", {
+          limit
+        }, "More than {{limit}} matches");
+      } else {
+        matchesCountMsg = this.l10n.get("find_match_count[other]", {
+          current,
+          total
+        }, "{{current}} of {{total}} matches");
+      }
+    }
+
+    Promise.resolve(matchesCountMsg).then(msg => {
+      this.findResultsCount.textContent = msg;
+      this.findResultsCount.classList.toggle("hidden", !total);
+
+      this._adjustWidth();
+    });
+  }
+
+  open() {
+    if (!this.opened) {
+      this.opened = true;
+      this.toggleButton.classList.add("toggled");
+      this.bar.classList.remove("hidden");
+    }
+
+    this.findField.select();
+    this.findField.focus();
+
+    this._adjustWidth();
+  }
+
+  close() {
+    if (!this.opened) {
+      return;
+    }
+
+    this.opened = false;
+    this.toggleButton.classList.remove("toggled");
+    this.bar.classList.add("hidden");
+    this.eventBus.dispatch("findbarclose", {
+      source: this
+    });
+  }
+
+  toggle() {
+    if (this.opened) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+
+  _adjustWidth() {
+    if (!this.opened) {
+      return;
+    }
+
+    this.bar.classList.remove("wrapContainers");
+    const findbarHeight = this.bar.clientHeight;
+    const inputContainerHeight = this.bar.firstElementChild.clientHeight;
+
+    if (findbarHeight > inputContainerHeight) {
+      this.bar.classList.add("wrapContainers");
+    }
+  }
+
+}
+
+exports.PDFFindBar = PDFFindBar;
+
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFFindController = exports.FindState = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _pdf_find_utils = __webpack_require__(16);
+
+var _ui_utils = __webpack_require__(4);
+
+const FindState = {
+  FOUND: 0,
+  NOT_FOUND: 1,
+  WRAPPED: 2,
+  PENDING: 3
+};
+exports.FindState = FindState;
+const FIND_TIMEOUT = 250;
+const MATCH_SCROLL_OFFSET_TOP = -50;
+const MATCH_SCROLL_OFFSET_LEFT = -400;
+const CHARACTERS_TO_NORMALIZE = {
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201A": "'",
+  "\u201B": "'",
+  "\u201C": '"',
+  "\u201D": '"',
+  "\u201E": '"',
+  "\u201F": '"',
+  "\u00BC": "1/4",
+  "\u00BD": "1/2",
+  "\u00BE": "3/4"
+};
+let normalizationRegex = null;
+
+function normalize(text) {
+  if (!normalizationRegex) {
+    const replace = Object.keys(CHARACTERS_TO_NORMALIZE).join("");
+    normalizationRegex = new RegExp(`[${replace}]`, "g");
+  }
+
+  return text.replace(normalizationRegex, function (ch) {
+    return CHARACTERS_TO_NORMALIZE[ch];
+  });
+}
+
+class PDFFindController {
+  constructor({
+    linkService,
+    eventBus
+  }) {
+    this._linkService = linkService;
+    this._eventBus = eventBus;
+
+    this._reset();
+
+    eventBus._on("findbarclose", this._onFindBarClose.bind(this));
+  }
+
+  get highlightMatches() {
+    return this._highlightMatches;
+  }
+
+  get pageMatches() {
+    return this._pageMatches;
+  }
+
+  get pageMatchesLength() {
+    return this._pageMatchesLength;
+  }
+
+  get selected() {
+    return this._selected;
+  }
+
+  get state() {
+    return this._state;
+  }
+
+  setDocument(pdfDocument) {
+    if (this._pdfDocument) {
+      this._reset();
+    }
+
+    if (!pdfDocument) {
+      return;
+    }
+
+    this._pdfDocument = pdfDocument;
+
+    this._firstPageCapability.resolve();
+  }
+
+  executeCommand(cmd, state) {
+    if (!state) {
+      return;
+    }
+
+    const pdfDocument = this._pdfDocument;
+
+    if (this._state === null || this._shouldDirtyMatch(cmd, state)) {
+      this._dirtyMatch = true;
+    }
+
+    this._state = state;
+
+    if (cmd !== "findhighlightallchange") {
+      this._updateUIState(FindState.PENDING);
+    }
+
+    this._firstPageCapability.promise.then(() => {
+      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
+        return;
+      }
+
+      this._extractText();
+
+      const findbarClosed = !this._highlightMatches;
+      const pendingTimeout = !!this._findTimeout;
+
+      if (this._findTimeout) {
+        clearTimeout(this._findTimeout);
+        this._findTimeout = null;
+      }
+
+      if (cmd === "find") {
+        this._findTimeout = setTimeout(() => {
+          this._nextMatch();
+
+          this._findTimeout = null;
+        }, FIND_TIMEOUT);
+      } else if (this._dirtyMatch) {
+        this._nextMatch();
+      } else if (cmd === "findagain") {
+        this._nextMatch();
+
+        if (findbarClosed && this._state.highlightAll) {
+          this._updateAllPages();
+        }
+      } else if (cmd === "findhighlightallchange") {
+        if (pendingTimeout) {
+          this._nextMatch();
+        } else {
+          this._highlightMatches = true;
+        }
+
+        this._updateAllPages();
+      } else {
+        this._nextMatch();
+      }
+    });
+  }
+
+  scrollMatchIntoView({
+    element = null,
+    pageIndex = -1,
+    matchIndex = -1
+  }) {
+    if (!this._scrollMatches || !element) {
+      return;
+    } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {
+      return;
+    } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {
+      return;
+    }
+
+    this._scrollMatches = false;
+    const spot = {
+      top: MATCH_SCROLL_OFFSET_TOP,
+      left: MATCH_SCROLL_OFFSET_LEFT
+    };
+    (0, _ui_utils.scrollIntoView)(element, spot, true);
+  }
+
+  _reset() {
+    this._highlightMatches = false;
+    this._scrollMatches = false;
+    this._pdfDocument = null;
+    this._pageMatches = [];
+    this._pageMatchesLength = [];
+    this._state = null;
+    this._selected = {
+      pageIdx: -1,
+      matchIdx: -1
+    };
+    this._offset = {
+      pageIdx: null,
+      matchIdx: null,
+      wrapped: false
+    };
+    this._extractTextPromises = [];
+    this._pageContents = [];
+    this._matchesCountTotal = 0;
+    this._pagesToSearch = null;
+    this._pendingFindMatches = Object.create(null);
+    this._resumePageIdx = null;
+    this._dirtyMatch = false;
+    clearTimeout(this._findTimeout);
+    this._findTimeout = null;
+    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+  }
+
+  get _query() {
+    if (this._state.query !== this._rawQuery) {
+      this._rawQuery = this._state.query;
+      this._normalizedQuery = normalize(this._state.query);
+    }
+
+    return this._normalizedQuery;
+  }
+
+  _shouldDirtyMatch(cmd, state) {
+    if (state.query !== this._state.query) {
+      return true;
+    }
+
+    switch (cmd) {
+      case "findagain":
+        const pageNumber = this._selected.pageIdx + 1;
+        const linkService = this._linkService;
+
+        if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
+          return true;
+        }
+
+        return false;
+
+      case "findhighlightallchange":
+        return false;
+    }
+
+    return true;
+  }
+
+  _prepareMatches(matchesWithLength, matches, matchesLength) {
+    function isSubTerm(currentIndex) {
+      const currentElem = matchesWithLength[currentIndex];
+      const nextElem = matchesWithLength[currentIndex + 1];
+
+      if (currentIndex < matchesWithLength.length - 1 && currentElem.match === nextElem.match) {
+        currentElem.skipped = true;
+        return true;
+      }
+
+      for (let i = currentIndex - 1; i >= 0; i--) {
+        const prevElem = matchesWithLength[i];
+
+        if (prevElem.skipped) {
+          continue;
+        }
+
+        if (prevElem.match + prevElem.matchLength < currentElem.match) {
+          break;
+        }
+
+        if (prevElem.match + prevElem.matchLength >= currentElem.match + currentElem.matchLength) {
+          currentElem.skipped = true;
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    matchesWithLength.sort(function (a, b) {
+      return a.match === b.match ? a.matchLength - b.matchLength : a.match - b.match;
+    });
+
+    for (let i = 0, len = matchesWithLength.length; i < len; i++) {
+      if (isSubTerm(i)) {
+        continue;
+      }
+
+      matches.push(matchesWithLength[i].match);
+      matchesLength.push(matchesWithLength[i].matchLength);
+    }
+  }
+
+  _isEntireWord(content, startIdx, length) {
+    if (startIdx > 0) {
+      const first = content.charCodeAt(startIdx);
+      const limit = content.charCodeAt(startIdx - 1);
+
+      if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
+        return false;
+      }
+    }
+
+    const endIdx = startIdx + length - 1;
+
+    if (endIdx < content.length - 1) {
+      const last = content.charCodeAt(endIdx);
+      const limit = content.charCodeAt(endIdx + 1);
+
+      if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(limit)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  _calculatePhraseMatch(query, pageIndex, pageContent, entireWord) {
+    const matches = [];
+    const queryLen = query.length;
+    let matchIdx = -queryLen;
+
+    while (true) {
+      matchIdx = pageContent.indexOf(query, matchIdx + queryLen);
+
+      if (matchIdx === -1) {
+        break;
+      }
+
+      if (entireWord && !this._isEntireWord(pageContent, matchIdx, queryLen)) {
+        continue;
+      }
+
+      matches.push(matchIdx);
+    }
+
+    this._pageMatches[pageIndex] = matches;
+  }
+
+  _calculateWordMatch(query, pageIndex, pageContent, entireWord) {
+    const matchesWithLength = [];
+    const queryArray = query.match(/\S+/g);
+
+    for (let i = 0, len = queryArray.length; i < len; i++) {
+      const subquery = queryArray[i];
+      const subqueryLen = subquery.length;
+      let matchIdx = -subqueryLen;
+
+      while (true) {
+        matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen);
+
+        if (matchIdx === -1) {
+          break;
+        }
+
+        if (entireWord && !this._isEntireWord(pageContent, matchIdx, subqueryLen)) {
+          continue;
+        }
+
+        matchesWithLength.push({
+          match: matchIdx,
+          matchLength: subqueryLen,
+          skipped: false
+        });
+      }
+    }
+
+    this._pageMatchesLength[pageIndex] = [];
+    this._pageMatches[pageIndex] = [];
+
+    this._prepareMatches(matchesWithLength, this._pageMatches[pageIndex], this._pageMatchesLength[pageIndex]);
+  }
+
+  _calculateMatch(pageIndex) {
+    let pageContent = this._pageContents[pageIndex];
+    let query = this._query;
+    const {
+      caseSensitive,
+      entireWord,
+      phraseSearch
+    } = this._state;
+
+    if (query.length === 0) {
+      return;
+    }
+
+    if (!caseSensitive) {
+      pageContent = pageContent.toLowerCase();
+      query = query.toLowerCase();
+    }
+
+    if (phraseSearch) {
+      this._calculatePhraseMatch(query, pageIndex, pageContent, entireWord);
+    } else {
+      this._calculateWordMatch(query, pageIndex, pageContent, entireWord);
+    }
+
+    if (this._state.highlightAll) {
+      this._updatePage(pageIndex);
+    }
+
+    if (this._resumePageIdx === pageIndex) {
+      this._resumePageIdx = null;
+
+      this._nextPageMatch();
+    }
+
+    const pageMatchesCount = this._pageMatches[pageIndex].length;
+
+    if (pageMatchesCount > 0) {
+      this._matchesCountTotal += pageMatchesCount;
+
+      this._updateUIResultsCount();
+    }
+  }
+
+  _extractText() {
+    if (this._extractTextPromises.length > 0) {
+      return;
+    }
+
+    let promise = Promise.resolve();
+
+    for (let i = 0, ii = this._linkService.pagesCount; i < ii; i++) {
+      const extractTextCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._extractTextPromises[i] = extractTextCapability.promise;
+      promise = promise.then(() => {
+        return this._pdfDocument.getPage(i + 1).then(pdfPage => {
+          return pdfPage.getTextContent({
+            normalizeWhitespace: true
+          });
+        }).then(textContent => {
+          const textItems = textContent.items;
+          const strBuf = [];
+
+          for (let j = 0, jj = textItems.length; j < jj; j++) {
+            strBuf.push(textItems[j].str);
+          }
+
+          this._pageContents[i] = normalize(strBuf.join(""));
+          extractTextCapability.resolve(i);
+        }, reason => {
+          console.error(`Unable to get text content for page ${i + 1}`, reason);
+          this._pageContents[i] = "";
+          extractTextCapability.resolve(i);
+        });
+      });
+    }
+  }
+
+  _updatePage(index) {
+    if (this._scrollMatches && this._selected.pageIdx === index) {
+      this._linkService.page = index + 1;
+    }
+
+    this._eventBus.dispatch("updatetextlayermatches", {
+      source: this,
+      pageIndex: index
+    });
+  }
+
+  _updateAllPages() {
+    this._eventBus.dispatch("updatetextlayermatches", {
+      source: this,
+      pageIndex: -1
+    });
+  }
+
+  _nextMatch() {
+    const previous = this._state.findPrevious;
+    const currentPageIndex = this._linkService.page - 1;
+    const numPages = this._linkService.pagesCount;
+    this._highlightMatches = true;
+
+    if (this._dirtyMatch) {
+      this._dirtyMatch = false;
+      this._selected.pageIdx = this._selected.matchIdx = -1;
+      this._offset.pageIdx = currentPageIndex;
+      this._offset.matchIdx = null;
+      this._offset.wrapped = false;
+      this._resumePageIdx = null;
+      this._pageMatches.length = 0;
+      this._pageMatchesLength.length = 0;
+      this._matchesCountTotal = 0;
+
+      this._updateAllPages();
+
+      for (let i = 0; i < numPages; i++) {
+        if (this._pendingFindMatches[i] === true) {
+          continue;
+        }
+
+        this._pendingFindMatches[i] = true;
+
+        this._extractTextPromises[i].then(pageIdx => {
+          delete this._pendingFindMatches[pageIdx];
+
+          this._calculateMatch(pageIdx);
+        });
+      }
+    }
+
+    if (this._query === "") {
+      this._updateUIState(FindState.FOUND);
+
+      return;
+    }
+
+    if (this._resumePageIdx) {
+      return;
+    }
+
+    const offset = this._offset;
+    this._pagesToSearch = numPages;
+
+    if (offset.matchIdx !== null) {
+      const numPageMatches = this._pageMatches[offset.pageIdx].length;
+
+      if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
+        offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;
+
+        this._updateMatch(true);
+
+        return;
+      }
+
+      this._advanceOffsetPage(previous);
+    }
+
+    this._nextPageMatch();
+  }
+
+  _matchesReady(matches) {
+    const offset = this._offset;
+    const numMatches = matches.length;
+    const previous = this._state.findPrevious;
+
+    if (numMatches) {
+      offset.matchIdx = previous ? numMatches - 1 : 0;
+
+      this._updateMatch(true);
+
+      return true;
+    }
+
+    this._advanceOffsetPage(previous);
+
+    if (offset.wrapped) {
+      offset.matchIdx = null;
+
+      if (this._pagesToSearch < 0) {
+        this._updateMatch(false);
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  _nextPageMatch() {
+    if (this._resumePageIdx !== null) {
+      console.error("There can only be one pending page.");
+    }
+
+    let matches = null;
+
+    do {
+      const pageIdx = this._offset.pageIdx;
+      matches = this._pageMatches[pageIdx];
+
+      if (!matches) {
+        this._resumePageIdx = pageIdx;
+        break;
+      }
+    } while (!this._matchesReady(matches));
+  }
+
+  _advanceOffsetPage(previous) {
+    const offset = this._offset;
+    const numPages = this._linkService.pagesCount;
+    offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
+    offset.matchIdx = null;
+    this._pagesToSearch--;
+
+    if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
+      offset.pageIdx = previous ? numPages - 1 : 0;
+      offset.wrapped = true;
+    }
+  }
+
+  _updateMatch(found = false) {
+    let state = FindState.NOT_FOUND;
+    const wrapped = this._offset.wrapped;
+    this._offset.wrapped = false;
+
+    if (found) {
+      const previousPage = this._selected.pageIdx;
+      this._selected.pageIdx = this._offset.pageIdx;
+      this._selected.matchIdx = this._offset.matchIdx;
+      state = wrapped ? FindState.WRAPPED : FindState.FOUND;
+
+      if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {
+        this._updatePage(previousPage);
+      }
+    }
+
+    this._updateUIState(state, this._state.findPrevious);
+
+    if (this._selected.pageIdx !== -1) {
+      this._scrollMatches = true;
+
+      this._updatePage(this._selected.pageIdx);
+    }
+  }
+
+  _onFindBarClose(evt) {
+    const pdfDocument = this._pdfDocument;
+
+    this._firstPageCapability.promise.then(() => {
+      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
+        return;
+      }
+
+      if (this._findTimeout) {
+        clearTimeout(this._findTimeout);
+        this._findTimeout = null;
+      }
+
+      if (this._resumePageIdx) {
+        this._resumePageIdx = null;
+        this._dirtyMatch = true;
+      }
+
+      this._updateUIState(FindState.FOUND);
+
+      this._highlightMatches = false;
+
+      this._updateAllPages();
+    });
+  }
+
+  _requestMatchesCount() {
+    const {
+      pageIdx,
+      matchIdx
+    } = this._selected;
+    let current = 0,
+        total = this._matchesCountTotal;
+
+    if (matchIdx !== -1) {
+      for (let i = 0; i < pageIdx; i++) {
+        current += this._pageMatches[i] && this._pageMatches[i].length || 0;
+      }
+
+      current += matchIdx + 1;
+    }
+
+    if (current < 1 || current > total) {
+      current = total = 0;
+    }
+
+    return {
+      current,
+      total
+    };
+  }
+
+  _updateUIResultsCount() {
+    this._eventBus.dispatch("updatefindmatchescount", {
+      source: this,
+      matchesCount: this._requestMatchesCount()
+    });
+  }
+
+  _updateUIState(state, previous) {
+    this._eventBus.dispatch("updatefindcontrolstate", {
+      source: this,
+      state,
+      previous,
+      matchesCount: this._requestMatchesCount(),
+      rawQuery: this._state ? this._state.query : null
+    });
+  }
+
+}
+
+exports.PDFFindController = PDFFindController;
+
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getCharacterType = getCharacterType;
+exports.CharacterType = void 0;
+const CharacterType = {
+  SPACE: 0,
+  ALPHA_LETTER: 1,
+  PUNCT: 2,
+  HAN_LETTER: 3,
+  KATAKANA_LETTER: 4,
+  HIRAGANA_LETTER: 5,
+  HALFWIDTH_KATAKANA_LETTER: 6,
+  THAI_LETTER: 7
+};
+exports.CharacterType = CharacterType;
+
+function isAlphabeticalScript(charCode) {
+  return charCode < 0x2e80;
+}
+
+function isAscii(charCode) {
+  return (charCode & 0xff80) === 0;
+}
+
+function isAsciiAlpha(charCode) {
+  return charCode >= 0x61 && charCode <= 0x7a || charCode >= 0x41 && charCode <= 0x5a;
+}
+
+function isAsciiDigit(charCode) {
+  return charCode >= 0x30 && charCode <= 0x39;
+}
+
+function isAsciiSpace(charCode) {
+  return charCode === 0x20 || charCode === 0x09 || charCode === 0x0d || charCode === 0x0a;
+}
+
+function isHan(charCode) {
+  return charCode >= 0x3400 && charCode <= 0x9fff || charCode >= 0xf900 && charCode <= 0xfaff;
+}
+
+function isKatakana(charCode) {
+  return charCode >= 0x30a0 && charCode <= 0x30ff;
+}
+
+function isHiragana(charCode) {
+  return charCode >= 0x3040 && charCode <= 0x309f;
+}
+
+function isHalfwidthKatakana(charCode) {
+  return charCode >= 0xff60 && charCode <= 0xff9f;
+}
+
+function isThai(charCode) {
+  return (charCode & 0xff80) === 0x0e00;
+}
+
+function getCharacterType(charCode) {
+  if (isAlphabeticalScript(charCode)) {
+    if (isAscii(charCode)) {
+      if (isAsciiSpace(charCode)) {
+        return CharacterType.SPACE;
+      } else if (isAsciiAlpha(charCode) || isAsciiDigit(charCode) || charCode === 0x5f) {
+        return CharacterType.ALPHA_LETTER;
+      }
+
+      return CharacterType.PUNCT;
+    } else if (isThai(charCode)) {
+      return CharacterType.THAI_LETTER;
+    } else if (charCode === 0xa0) {
+      return CharacterType.SPACE;
+    }
+
+    return CharacterType.ALPHA_LETTER;
+  }
+
+  if (isHan(charCode)) {
+    return CharacterType.HAN_LETTER;
+  } else if (isKatakana(charCode)) {
+    return CharacterType.KATAKANA_LETTER;
+  } else if (isHiragana(charCode)) {
+    return CharacterType.HIRAGANA_LETTER;
+  } else if (isHalfwidthKatakana(charCode)) {
+    return CharacterType.HALFWIDTH_KATAKANA_LETTER;
+  }
+
+  return CharacterType.ALPHA_LETTER;
+}
+
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.isDestArraysEqual = isDestArraysEqual;
+exports.isDestHashesEqual = isDestHashesEqual;
+exports.PDFHistory = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+const HASH_CHANGE_TIMEOUT = 1000;
+const POSITION_UPDATED_THRESHOLD = 50;
+const UPDATE_VIEWAREA_TIMEOUT = 1000;
+
+function getCurrentHash() {
+  return document.location.hash;
+}
+
+class PDFHistory {
+  constructor({
+    linkService,
+    eventBus
+  }) {
+    this.linkService = linkService;
+    this.eventBus = eventBus;
+    this._initialized = false;
+    this._fingerprint = "";
+    this.reset();
+    this._boundEvents = null;
+    this._isViewerInPresentationMode = false;
+
+    this.eventBus._on("presentationmodechanged", evt => {
+      this._isViewerInPresentationMode = evt.state !== _ui_utils.PresentationModeState.NORMAL;
+    });
+
+    this.eventBus._on("pagesinit", () => {
+      this._isPagesLoaded = false;
+
+      this.eventBus._on("pagesloaded", evt => {
+        this._isPagesLoaded = !!evt.pagesCount;
+      }, {
+        once: true
+      });
+    });
+  }
+
+  initialize({
+    fingerprint,
+    resetHistory = false,
+    updateUrl = false
+  }) {
+    if (!fingerprint || typeof fingerprint !== "string") {
+      console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.');
+      return;
+    }
+
+    if (this._initialized) {
+      this.reset();
+    }
+
+    const reInitialized = this._fingerprint !== "" && this._fingerprint !== fingerprint;
+    this._fingerprint = fingerprint;
+    this._updateUrl = updateUrl === true;
+    this._initialized = true;
+
+    this._bindEvents();
+
+    const state = window.history.state;
+    this._popStateInProgress = false;
+    this._blockHashChange = 0;
+    this._currentHash = getCurrentHash();
+    this._numPositionUpdates = 0;
+    this._uid = this._maxUid = 0;
+    this._destination = null;
+    this._position = null;
+
+    if (!this._isValidState(state, true) || resetHistory) {
+      const {
+        hash,
+        page,
+        rotation
+      } = this._parseCurrentHash(true);
+
+      if (!hash || reInitialized || resetHistory) {
+        this._pushOrReplaceState(null, true);
+
+        return;
+      }
+
+      this._pushOrReplaceState({
+        hash,
+        page,
+        rotation
+      }, true);
+
+      return;
+    }
+
+    const destination = state.destination;
+
+    this._updateInternalState(destination, state.uid, true);
+
+    if (destination.rotation !== undefined) {
+      this._initialRotation = destination.rotation;
+    }
+
+    if (destination.dest) {
+      this._initialBookmark = JSON.stringify(destination.dest);
+      this._destination.page = null;
+    } else if (destination.hash) {
+      this._initialBookmark = destination.hash;
+    } else if (destination.page) {
+      this._initialBookmark = `page=${destination.page}`;
+    }
+  }
+
+  reset() {
+    if (this._initialized) {
+      this._pageHide();
+
+      this._initialized = false;
+
+      this._unbindEvents();
+    }
+
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
+
+    this._initialBookmark = null;
+    this._initialRotation = null;
+  }
+
+  push({
+    namedDest = null,
+    explicitDest,
+    pageNumber
+  }) {
+    if (!this._initialized) {
+      return;
+    }
+
+    if (namedDest && typeof namedDest !== "string") {
+      console.error("PDFHistory.push: " + `"${namedDest}" is not a valid namedDest parameter.`);
+      return;
+    } else if (!Array.isArray(explicitDest)) {
+      console.error("PDFHistory.push: " + `"${explicitDest}" is not a valid explicitDest parameter.`);
+      return;
+    } else if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.linkService.pagesCount)) {
+      if (pageNumber !== null || this._destination) {
+        console.error("PDFHistory.push: " + `"${pageNumber}" is not a valid pageNumber parameter.`);
+        return;
+      }
+    }
+
+    const hash = namedDest || JSON.stringify(explicitDest);
+
+    if (!hash) {
+      return;
+    }
+
+    let forceReplace = false;
+
+    if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
+      if (this._destination.page) {
+        return;
+      }
+
+      forceReplace = true;
+    }
+
+    if (this._popStateInProgress && !forceReplace) {
+      return;
+    }
+
+    this._pushOrReplaceState({
+      dest: explicitDest,
+      hash,
+      page: pageNumber,
+      rotation: this.linkService.rotation
+    }, forceReplace);
+
+    if (!this._popStateInProgress) {
+      this._popStateInProgress = true;
+      Promise.resolve().then(() => {
+        this._popStateInProgress = false;
+      });
+    }
+  }
+
+  pushPage(pageNumber) {
+    if (!this._initialized) {
+      return;
+    }
+
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.linkService.pagesCount)) {
+      console.error(`PDFHistory.pushPage: "${pageNumber}" is not a valid page number.`);
+      return;
+    }
+
+    if (this._destination?.page === pageNumber) {
+      return;
+    }
+
+    if (this._popStateInProgress) {
+      return;
+    }
+
+    this._pushOrReplaceState({
+      hash: `page=${pageNumber}`,
+      page: pageNumber,
+      rotation: this.linkService.rotation
+    });
+
+    if (!this._popStateInProgress) {
+      this._popStateInProgress = true;
+      Promise.resolve().then(() => {
+        this._popStateInProgress = false;
+      });
+    }
+  }
+
+  pushCurrentPosition() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
+
+    this._tryPushCurrentPosition();
+  }
+
+  back() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
+
+    const state = window.history.state;
+
+    if (this._isValidState(state) && state.uid > 0) {
+      window.history.back();
+    }
+  }
+
+  forward() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
+
+    const state = window.history.state;
+
+    if (this._isValidState(state) && state.uid < this._maxUid) {
+      window.history.forward();
+    }
+  }
+
+  get popStateInProgress() {
+    return this._initialized && (this._popStateInProgress || this._blockHashChange > 0);
+  }
+
+  get initialBookmark() {
+    return this._initialized ? this._initialBookmark : null;
+  }
+
+  get initialRotation() {
+    return this._initialized ? this._initialRotation : null;
+  }
+
+  _pushOrReplaceState(destination, forceReplace = false) {
+    const shouldReplace = forceReplace || !this._destination;
+    const newState = {
+      fingerprint: this._fingerprint,
+      uid: shouldReplace ? this._uid : this._uid + 1,
+      destination
+    };
+
+    this._updateInternalState(destination, newState.uid);
+
+    let newUrl;
+
+    if (this._updateUrl && destination?.hash) {
+      const baseUrl = document.location.href.split("#")[0];
+
+      if (!baseUrl.startsWith("file://")) {
+        newUrl = `${baseUrl}#${destination.hash}`;
+      }
+    }
+
+    if (shouldReplace) {
+      window.history.replaceState(newState, "", newUrl);
+    } else {
+      window.history.pushState(newState, "", newUrl);
+    }
+  }
+
+  _tryPushCurrentPosition(temporary = false) {
+    if (!this._position) {
+      return;
+    }
+
+    let position = this._position;
+
+    if (temporary) {
+      position = Object.assign(Object.create(null), this._position);
+      position.temporary = true;
+    }
+
+    if (!this._destination) {
+      this._pushOrReplaceState(position);
+
+      return;
+    }
+
+    if (this._destination.temporary) {
+      this._pushOrReplaceState(position, true);
+
+      return;
+    }
+
+    if (this._destination.hash === position.hash) {
+      return;
+    }
+
+    if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
+      return;
+    }
+
+    let forceReplace = false;
+
+    if (this._destination.page >= position.first && this._destination.page <= position.page) {
+      if (this._destination.dest || !this._destination.first) {
+        return;
+      }
+
+      forceReplace = true;
+    }
+
+    this._pushOrReplaceState(position, forceReplace);
+  }
+
+  _isValidState(state, checkReload = false) {
+    if (!state) {
+      return false;
+    }
+
+    if (state.fingerprint !== this._fingerprint) {
+      if (checkReload) {
+        if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
+          return false;
+        }
+
+        const [perfEntry] = performance.getEntriesByType("navigation");
+
+        if (perfEntry?.type !== "reload") {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+
+    if (!Number.isInteger(state.uid) || state.uid < 0) {
+      return false;
+    }
+
+    if (state.destination === null || typeof state.destination !== "object") {
+      return false;
+    }
+
+    return true;
+  }
+
+  _updateInternalState(destination, uid, removeTemporary = false) {
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
+
+    if (removeTemporary && destination?.temporary) {
+      delete destination.temporary;
+    }
+
+    this._destination = destination;
+    this._uid = uid;
+    this._maxUid = Math.max(this._maxUid, uid);
+    this._numPositionUpdates = 0;
+  }
+
+  _parseCurrentHash(checkNameddest = false) {
+    const hash = unescape(getCurrentHash()).substring(1);
+    const params = (0, _ui_utils.parseQueryString)(hash);
+    const nameddest = params.nameddest || "";
+    let page = params.page | 0;
+
+    if (!(Number.isInteger(page) && page > 0 && page <= this.linkService.pagesCount) || checkNameddest && nameddest.length > 0) {
+      page = null;
+    }
+
+    return {
+      hash,
+      page,
+      rotation: this.linkService.rotation
+    };
+  }
+
+  _updateViewarea({
+    location
+  }) {
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
+
+    this._position = {
+      hash: this._isViewerInPresentationMode ? `page=${location.pageNumber}` : location.pdfOpenParams.substring(1),
+      page: this.linkService.page,
+      first: location.pageNumber,
+      rotation: location.rotation
+    };
+
+    if (this._popStateInProgress) {
+      return;
+    }
+
+    if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
+      this._numPositionUpdates++;
+    }
+
+    if (UPDATE_VIEWAREA_TIMEOUT > 0) {
+      this._updateViewareaTimeout = setTimeout(() => {
+        if (!this._popStateInProgress) {
+          this._tryPushCurrentPosition(true);
+        }
+
+        this._updateViewareaTimeout = null;
+      }, UPDATE_VIEWAREA_TIMEOUT);
+    }
+  }
+
+  _popState({
+    state
+  }) {
+    const newHash = getCurrentHash(),
+          hashChanged = this._currentHash !== newHash;
+    this._currentHash = newHash;
+
+    if (!state) {
+      this._uid++;
+
+      const {
+        hash,
+        page,
+        rotation
+      } = this._parseCurrentHash();
+
+      this._pushOrReplaceState({
+        hash,
+        page,
+        rotation
+      }, true);
+
+      return;
+    }
+
+    if (!this._isValidState(state)) {
+      return;
+    }
+
+    this._popStateInProgress = true;
+
+    if (hashChanged) {
+      this._blockHashChange++;
+      (0, _ui_utils.waitOnEventOrTimeout)({
+        target: window,
+        name: "hashchange",
+        delay: HASH_CHANGE_TIMEOUT
+      }).then(() => {
+        this._blockHashChange--;
+      });
+    }
+
+    const destination = state.destination;
+
+    this._updateInternalState(destination, state.uid, true);
+
+    if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
+      this.linkService.rotation = destination.rotation;
+    }
+
+    if (destination.dest) {
+      this.linkService.goToDestination(destination.dest);
+    } else if (destination.hash) {
+      this.linkService.setHash(destination.hash);
+    } else if (destination.page) {
+      this.linkService.page = destination.page;
+    }
+
+    Promise.resolve().then(() => {
+      this._popStateInProgress = false;
+    });
+  }
+
+  _pageHide() {
+    if (!this._destination || this._destination.temporary) {
+      this._tryPushCurrentPosition();
+    }
+  }
+
+  _bindEvents() {
+    if (this._boundEvents) {
+      return;
+    }
+
+    this._boundEvents = {
+      updateViewarea: this._updateViewarea.bind(this),
+      popState: this._popState.bind(this),
+      pageHide: this._pageHide.bind(this)
+    };
+
+    this.eventBus._on("updateviewarea", this._boundEvents.updateViewarea);
+
+    window.addEventListener("popstate", this._boundEvents.popState);
+    window.addEventListener("pagehide", this._boundEvents.pageHide);
+  }
+
+  _unbindEvents() {
+    if (!this._boundEvents) {
+      return;
+    }
+
+    this.eventBus._off("updateviewarea", this._boundEvents.updateViewarea);
+
+    window.removeEventListener("popstate", this._boundEvents.popState);
+    window.removeEventListener("pagehide", this._boundEvents.pageHide);
+    this._boundEvents = null;
+  }
+
+}
+
+exports.PDFHistory = PDFHistory;
+
+function isDestHashesEqual(destHash, pushHash) {
+  if (typeof destHash !== "string" || typeof pushHash !== "string") {
+    return false;
+  }
+
+  if (destHash === pushHash) {
+    return true;
+  }
+
+  const {
+    nameddest
+  } = (0, _ui_utils.parseQueryString)(destHash);
+
+  if (nameddest === pushHash) {
+    return true;
+  }
+
+  return false;
+}
+
+function isDestArraysEqual(firstDest, secondDest) {
+  function isEntryEqual(first, second) {
+    if (typeof first !== typeof second) {
+      return false;
+    }
+
+    if (Array.isArray(first) || Array.isArray(second)) {
+      return false;
+    }
+
+    if (first !== null && typeof first === "object" && second !== null) {
+      if (Object.keys(first).length !== Object.keys(second).length) {
+        return false;
+      }
+
+      for (const key in first) {
+        if (!isEntryEqual(first[key], second[key])) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return first === second || Number.isNaN(first) && Number.isNaN(second);
+  }
+
+  if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {
+    return false;
+  }
+
+  if (firstDest.length !== secondDest.length) {
+    return false;
+  }
+
+  for (let i = 0, ii = firstDest.length; i < ii; i++) {
+    if (!isEntryEqual(firstDest[i], secondDest[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/***/ }),
+/* 18 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFLayerViewer = void 0;
+
+var _base_tree_viewer = __webpack_require__(12);
+
+class PDFLayerViewer extends _base_tree_viewer.BaseTreeViewer {
+  constructor(options) {
+    super(options);
+    this.l10n = options.l10n;
+
+    this.eventBus._on("resetlayers", this._resetLayers.bind(this));
+
+    this.eventBus._on("togglelayerstree", this._toggleAllTreeItems.bind(this));
+  }
+
+  reset() {
+    super.reset();
+    this._optionalContentConfig = null;
+  }
+
+  _dispatchEvent(layersCount) {
+    this.eventBus.dispatch("layersloaded", {
+      source: this,
+      layersCount
+    });
+  }
+
+  _bindLink(element, {
+    groupId,
+    input
+  }) {
+    const setVisibility = () => {
+      this._optionalContentConfig.setVisibility(groupId, input.checked);
+
+      this.eventBus.dispatch("optionalcontentconfig", {
+        source: this,
+        promise: Promise.resolve(this._optionalContentConfig)
+      });
+    };
+
+    element.onclick = evt => {
+      if (evt.target === input) {
+        setVisibility();
+        return true;
+      } else if (evt.target !== element) {
+        return true;
+      }
+
+      input.checked = !input.checked;
+      setVisibility();
+      return false;
+    };
+  }
+
+  async _setNestedName(element, {
+    name = null
+  }) {
+    if (typeof name === "string") {
+      element.textContent = this._normalizeTextContent(name);
+      return;
+    }
+
+    element.textContent = await this.l10n.get("additional_layers", null, "Additional Layers");
+    element.style.fontStyle = "italic";
+  }
+
+  _addToggleButton(div, {
+    name = null
+  }) {
+    super._addToggleButton(div, name === null);
+  }
+
+  _toggleAllTreeItems() {
+    if (!this._optionalContentConfig) {
+      return;
+    }
+
+    super._toggleAllTreeItems();
+  }
+
+  render({
+    optionalContentConfig,
+    pdfDocument
+  }) {
+    if (this._optionalContentConfig) {
+      this.reset();
+    }
+
+    this._optionalContentConfig = optionalContentConfig || null;
+    this._pdfDocument = pdfDocument || null;
+    const groups = optionalContentConfig && optionalContentConfig.getOrder();
+
+    if (!groups) {
+      this._dispatchEvent(0);
+
+      return;
+    }
+
+    const fragment = document.createDocumentFragment(),
+          queue = [{
+      parent: fragment,
+      groups
+    }];
+    let layersCount = 0,
+        hasAnyNesting = false;
+
+    while (queue.length > 0) {
+      const levelData = queue.shift();
+
+      for (const groupId of levelData.groups) {
+        const div = document.createElement("div");
+        div.className = "treeItem";
+        const element = document.createElement("a");
+        div.appendChild(element);
+
+        if (typeof groupId === "object") {
+          hasAnyNesting = true;
+
+          this._addToggleButton(div, groupId);
+
+          this._setNestedName(element, groupId);
+
+          const itemsDiv = document.createElement("div");
+          itemsDiv.className = "treeItems";
+          div.appendChild(itemsDiv);
+          queue.push({
+            parent: itemsDiv,
+            groups: groupId.order
+          });
+        } else {
+          const group = optionalContentConfig.getGroup(groupId);
+          const input = document.createElement("input");
+
+          this._bindLink(element, {
+            groupId,
+            input
+          });
+
+          input.type = "checkbox";
+          input.id = groupId;
+          input.checked = group.visible;
+          const label = document.createElement("label");
+          label.setAttribute("for", groupId);
+          label.textContent = this._normalizeTextContent(group.name);
+          element.appendChild(input);
+          element.appendChild(label);
+          layersCount++;
+        }
+
+        levelData.parent.appendChild(div);
+      }
+    }
+
+    this._finishRendering(fragment, layersCount, hasAnyNesting);
+  }
+
+  async _resetLayers() {
+    if (!this._optionalContentConfig) {
+      return;
+    }
+
+    const optionalContentConfig = await this._pdfDocument.getOptionalContentConfig();
+    this.eventBus.dispatch("optionalcontentconfig", {
+      source: this,
+      promise: Promise.resolve(optionalContentConfig)
+    });
+    this.render({
+      optionalContentConfig,
+      pdfDocument: this._pdfDocument
+    });
+  }
+
+}
+
+exports.PDFLayerViewer = PDFLayerViewer;
+
+/***/ }),
+/* 19 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SimpleLinkService = exports.PDFLinkService = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+class PDFLinkService {
+  constructor({
+    eventBus,
+    externalLinkTarget = null,
+    externalLinkRel = null,
+    externalLinkEnabled = true,
+    ignoreDestinationZoom = false
+  } = {}) {
+    this.eventBus = eventBus;
+    this.externalLinkTarget = externalLinkTarget;
+    this.externalLinkRel = externalLinkRel;
+    this.externalLinkEnabled = externalLinkEnabled;
+    this._ignoreDestinationZoom = ignoreDestinationZoom;
+    this.baseUrl = null;
+    this.pdfDocument = null;
+    this.pdfViewer = null;
+    this.pdfHistory = null;
+    this._pagesRefCache = null;
+  }
+
+  setDocument(pdfDocument, baseUrl = null) {
+    this.baseUrl = baseUrl;
+    this.pdfDocument = pdfDocument;
+    this._pagesRefCache = Object.create(null);
+  }
+
+  setViewer(pdfViewer) {
+    this.pdfViewer = pdfViewer;
+  }
+
+  setHistory(pdfHistory) {
+    this.pdfHistory = pdfHistory;
+  }
+
+  get pagesCount() {
+    return this.pdfDocument ? this.pdfDocument.numPages : 0;
+  }
+
+  get page() {
+    return this.pdfViewer.currentPageNumber;
+  }
+
+  set page(value) {
+    this.pdfViewer.currentPageNumber = value;
+  }
+
+  get rotation() {
+    return this.pdfViewer.pagesRotation;
+  }
+
+  set rotation(value) {
+    this.pdfViewer.pagesRotation = value;
+  }
+
+  navigateTo(dest) {
+    console.error("Deprecated method: `navigateTo`, use `goToDestination` instead.");
+    this.goToDestination(dest);
+  }
+
+  _goToDestinationHelper(rawDest, namedDest = null, explicitDest) {
+    const destRef = explicitDest[0];
+    let pageNumber;
+
+    if (destRef instanceof Object) {
+      pageNumber = this._cachedPageNumber(destRef);
+
+      if (pageNumber === null) {
+        this.pdfDocument.getPageIndex(destRef).then(pageIndex => {
+          this.cachePageRef(pageIndex + 1, destRef);
+
+          this._goToDestinationHelper(rawDest, namedDest, explicitDest);
+        }).catch(() => {
+          console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid page reference, for dest="${rawDest}".`);
+        });
+        return;
+      }
+    } else if (Number.isInteger(destRef)) {
+      pageNumber = destRef + 1;
+    } else {
+      console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid destination reference, for dest="${rawDest}".`);
+      return;
+    }
+
+    if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
+      console.error(`PDFLinkService._goToDestinationHelper: "${pageNumber}" is not ` + `a valid page number, for dest="${rawDest}".`);
+      return;
+    }
+
+    if (this.pdfHistory) {
+      this.pdfHistory.pushCurrentPosition();
+      this.pdfHistory.push({
+        namedDest,
+        explicitDest,
+        pageNumber
+      });
+    }
+
+    this.pdfViewer.scrollPageIntoView({
+      pageNumber,
+      destArray: explicitDest,
+      ignoreDestinationZoom: this._ignoreDestinationZoom
+    });
+  }
+
+  async goToDestination(dest) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    let namedDest, explicitDest;
+
+    if (typeof dest === "string") {
+      namedDest = dest;
+      explicitDest = await this.pdfDocument.getDestination(dest);
+    } else {
+      namedDest = null;
+      explicitDest = await dest;
+    }
+
+    if (!Array.isArray(explicitDest)) {
+      console.error(`PDFLinkService.goToDestination: "${explicitDest}" is not ` + `a valid destination array, for dest="${dest}".`);
+      return;
+    }
+
+    this._goToDestinationHelper(dest, namedDest, explicitDest);
+  }
+
+  goToPage(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    const pageNumber = typeof val === "string" && this.pdfViewer.pageLabelToPageNumber(val) || val | 0;
+
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`PDFLinkService.goToPage: "${val}" is not a valid page.`);
+      return;
+    }
+
+    if (this.pdfHistory) {
+      this.pdfHistory.pushCurrentPosition();
+      this.pdfHistory.pushPage(pageNumber);
+    }
+
+    this.pdfViewer.scrollPageIntoView({
+      pageNumber
+    });
+  }
+
+  getDestinationHash(dest) {
+    if (typeof dest === "string") {
+      if (dest.length > 0) {
+        return this.getAnchorUrl("#" + escape(dest));
+      }
+    } else if (Array.isArray(dest)) {
+      const str = JSON.stringify(dest);
+
+      if (str.length > 0) {
+        return this.getAnchorUrl("#" + escape(str));
+      }
+    }
+
+    return this.getAnchorUrl("");
+  }
+
+  getAnchorUrl(anchor) {
+    return (this.baseUrl || "") + anchor;
+  }
+
+  setHash(hash) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    let pageNumber, dest;
+
+    if (hash.includes("=")) {
+      const params = (0, _ui_utils.parseQueryString)(hash);
+
+      if ("search" in params) {
+        this.eventBus.dispatch("findfromurlhash", {
+          source: this,
+          query: params.search.replace(/"/g, ""),
+          phraseSearch: params.phrase === "true"
+        });
+      }
+
+      if ("page" in params) {
+        pageNumber = params.page | 0 || 1;
+      }
+
+      if ("zoom" in params) {
+        const zoomArgs = params.zoom.split(",");
+        const zoomArg = zoomArgs[0];
+        const zoomArgNumber = parseFloat(zoomArg);
+
+        if (!zoomArg.includes("Fit")) {
+          dest = [null, {
+            name: "XYZ"
+          }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg];
+        } else {
+          if (zoomArg === "Fit" || zoomArg === "FitB") {
+            dest = [null, {
+              name: zoomArg
+            }];
+          } else if (zoomArg === "FitH" || zoomArg === "FitBH" || zoomArg === "FitV" || zoomArg === "FitBV") {
+            dest = [null, {
+              name: zoomArg
+            }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
+          } else if (zoomArg === "FitR") {
+            if (zoomArgs.length !== 5) {
+              console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
+            } else {
+              dest = [null, {
+                name: zoomArg
+              }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0];
+            }
+          } else {
+            console.error(`PDFLinkService.setHash: "${zoomArg}" is not ` + "a valid zoom value.");
+          }
+        }
+      }
+
+      if (dest) {
+        this.pdfViewer.scrollPageIntoView({
+          pageNumber: pageNumber || this.page,
+          destArray: dest,
+          allowNegativeOffset: true
+        });
+      } else if (pageNumber) {
+        this.page = pageNumber;
+      }
+
+      if ("pagemode" in params) {
+        this.eventBus.dispatch("pagemode", {
+          source: this,
+          mode: params.pagemode
+        });
+      }
+
+      if ("nameddest" in params) {
+        this.goToDestination(params.nameddest);
+      }
+    } else {
+      dest = unescape(hash);
+
+      try {
+        dest = JSON.parse(dest);
+
+        if (!Array.isArray(dest)) {
+          dest = dest.toString();
+        }
+      } catch (ex) {}
+
+      if (typeof dest === "string" || isValidExplicitDestination(dest)) {
+        this.goToDestination(dest);
+        return;
+      }
+
+      console.error(`PDFLinkService.setHash: "${unescape(hash)}" is not ` + "a valid destination.");
+    }
+  }
+
+  executeNamedAction(action) {
+    switch (action) {
+      case "GoBack":
+        if (this.pdfHistory) {
+          this.pdfHistory.back();
+        }
+
+        break;
+
+      case "GoForward":
+        if (this.pdfHistory) {
+          this.pdfHistory.forward();
+        }
+
+        break;
+
+      case "NextPage":
+        if (this.page < this.pagesCount) {
+          this.page++;
+        }
+
+        break;
+
+      case "PrevPage":
+        if (this.page > 1) {
+          this.page--;
+        }
+
+        break;
+
+      case "LastPage":
+        this.page = this.pagesCount;
+        break;
+
+      case "FirstPage":
+        this.page = 1;
+        break;
+
+      default:
+        break;
+    }
+
+    this.eventBus.dispatch("namedaction", {
+      source: this,
+      action
+    });
+  }
+
+  cachePageRef(pageNum, pageRef) {
+    if (!pageRef) {
+      return;
+    }
+
+    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
+    this._pagesRefCache[refStr] = pageNum;
+  }
+
+  _cachedPageNumber(pageRef) {
+    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
+    return this._pagesRefCache && this._pagesRefCache[refStr] || null;
+  }
+
+  isPageVisible(pageNumber) {
+    return this.pdfViewer.isPageVisible(pageNumber);
+  }
+
+  isPageCached(pageNumber) {
+    return this.pdfViewer.isPageCached(pageNumber);
+  }
+
+}
+
+exports.PDFLinkService = PDFLinkService;
+
+function isValidExplicitDestination(dest) {
+  if (!Array.isArray(dest)) {
+    return false;
+  }
+
+  const destLength = dest.length;
+
+  if (destLength < 2) {
+    return false;
+  }
+
+  const page = dest[0];
+
+  if (!(typeof page === "object" && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
+    return false;
+  }
+
+  const zoom = dest[1];
+
+  if (!(typeof zoom === "object" && typeof zoom.name === "string")) {
+    return false;
+  }
+
+  let allowNull = true;
+
+  switch (zoom.name) {
+    case "XYZ":
+      if (destLength !== 5) {
+        return false;
+      }
+
+      break;
+
+    case "Fit":
+    case "FitB":
+      return destLength === 2;
+
+    case "FitH":
+    case "FitBH":
+    case "FitV":
+    case "FitBV":
+      if (destLength !== 3) {
+        return false;
+      }
+
+      break;
+
+    case "FitR":
+      if (destLength !== 6) {
+        return false;
+      }
+
+      allowNull = false;
+      break;
+
+    default:
+      return false;
+  }
+
+  for (let i = 2; i < destLength; i++) {
+    const param = dest[i];
+
+    if (!(typeof param === "number" || allowNull && param === null)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+class SimpleLinkService {
+  constructor() {
+    this.externalLinkTarget = null;
+    this.externalLinkRel = null;
+    this.externalLinkEnabled = true;
+    this._ignoreDestinationZoom = false;
+  }
+
+  get pagesCount() {
+    return 0;
+  }
+
+  get page() {
+    return 0;
+  }
+
+  set page(value) {}
+
+  get rotation() {
+    return 0;
+  }
+
+  set rotation(value) {}
+
+  async goToDestination(dest) {}
+
+  goToPage(val) {}
+
+  getDestinationHash(dest) {
+    return "#";
+  }
+
+  getAnchorUrl(hash) {
+    return "#";
+  }
+
+  setHash(hash) {}
+
+  executeNamedAction(action) {}
+
+  cachePageRef(pageNum, pageRef) {}
+
+  isPageVisible(pageNumber) {
+    return true;
+  }
+
+  isPageCached(pageNumber) {
+    return true;
+  }
+
+}
+
+exports.SimpleLinkService = SimpleLinkService;
+
+/***/ }),
+/* 20 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFOutlineViewer = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _base_tree_viewer = __webpack_require__(12);
+
+var _ui_utils = __webpack_require__(4);
+
+class PDFOutlineViewer extends _base_tree_viewer.BaseTreeViewer {
+  constructor(options) {
+    super(options);
+    this.linkService = options.linkService;
+
+    this.eventBus._on("toggleoutlinetree", this._toggleAllTreeItems.bind(this));
+
+    this.eventBus._on("currentoutlineitem", this._currentOutlineItem.bind(this));
+
+    this.eventBus._on("pagechanging", evt => {
+      this._currentPageNumber = evt.pageNumber;
+    });
+
+    this.eventBus._on("pagesloaded", evt => {
+      this._isPagesLoaded = !!evt.pagesCount;
+    });
+
+    this.eventBus._on("sidebarviewchanged", evt => {
+      this._sidebarView = evt.view;
+    });
+  }
+
+  reset() {
+    super.reset();
+    this._outline = null;
+    this._pageNumberToDestHashCapability = null;
+    this._currentPageNumber = 1;
+    this._isPagesLoaded = false;
+  }
+
+  _dispatchEvent(outlineCount) {
+    this.eventBus.dispatch("outlineloaded", {
+      source: this,
+      outlineCount,
+      enableCurrentOutlineItemButton: outlineCount > 0 && !this._pdfDocument?.loadingParams.disableAutoFetch
+    });
+  }
+
+  _bindLink(element, {
+    url,
+    newWindow,
+    dest
+  }) {
+    const {
+      linkService
+    } = this;
+
+    if (url) {
+      (0, _pdfjsLib.addLinkAttributes)(element, {
+        url,
+        target: newWindow ? _pdfjsLib.LinkTarget.BLANK : linkService.externalLinkTarget,
+        rel: linkService.externalLinkRel,
+        enabled: linkService.externalLinkEnabled
+      });
+      return;
+    }
+
+    element.href = linkService.getDestinationHash(dest);
+
+    element.onclick = evt => {
+      this._updateCurrentTreeItem(evt.target.parentNode);
+
+      if (dest) {
+        linkService.goToDestination(dest);
+      }
+
+      return false;
+    };
+  }
+
+  _setStyles(element, {
+    bold,
+    italic
+  }) {
+    if (bold) {
+      element.style.fontWeight = "bold";
+    }
+
+    if (italic) {
+      element.style.fontStyle = "italic";
+    }
+  }
+
+  _addToggleButton(div, {
+    count,
+    items
+  }) {
+    let hidden = false;
+
+    if (count < 0) {
+      let totalCount = items.length;
+
+      if (totalCount > 0) {
+        const queue = [...items];
+
+        while (queue.length > 0) {
+          const {
+            count: nestedCount,
+            items: nestedItems
+          } = queue.shift();
+
+          if (nestedCount > 0 && nestedItems.length > 0) {
+            totalCount += nestedItems.length;
+            queue.push(...nestedItems);
+          }
+        }
+      }
+
+      if (Math.abs(count) === totalCount) {
+        hidden = true;
+      }
+    }
+
+    super._addToggleButton(div, hidden);
+  }
+
+  _toggleAllTreeItems() {
+    if (!this._outline) {
+      return;
+    }
+
+    super._toggleAllTreeItems();
+  }
+
+  render({
+    outline,
+    pdfDocument
+  }) {
+    if (this._outline) {
+      this.reset();
+    }
+
+    this._outline = outline || null;
+    this._pdfDocument = pdfDocument || null;
+
+    if (!outline) {
+      this._dispatchEvent(0);
+
+      return;
+    }
+
+    const fragment = document.createDocumentFragment();
+    const queue = [{
+      parent: fragment,
+      items: outline
+    }];
+    let outlineCount = 0,
+        hasAnyNesting = false;
+
+    while (queue.length > 0) {
+      const levelData = queue.shift();
+
+      for (const item of levelData.items) {
+        const div = document.createElement("div");
+        div.className = "treeItem";
+        const element = document.createElement("a");
+
+        this._bindLink(element, item);
+
+        this._setStyles(element, item);
+
+        element.textContent = this._normalizeTextContent(item.title);
+        div.appendChild(element);
+
+        if (item.items.length > 0) {
+          hasAnyNesting = true;
+
+          this._addToggleButton(div, item);
+
+          const itemsDiv = document.createElement("div");
+          itemsDiv.className = "treeItems";
+          div.appendChild(itemsDiv);
+          queue.push({
+            parent: itemsDiv,
+            items: item.items
+          });
+        }
+
+        levelData.parent.appendChild(div);
+        outlineCount++;
+      }
+    }
+
+    this._finishRendering(fragment, outlineCount, hasAnyNesting);
+  }
+
+  async _currentOutlineItem() {
+    if (!this._isPagesLoaded) {
+      throw new Error("_currentOutlineItem: All pages have not been loaded.");
+    }
+
+    if (!this._outline || !this._pdfDocument) {
+      return;
+    }
+
+    const pageNumberToDestHash = await this._getPageNumberToDestHash(this._pdfDocument);
+
+    if (!pageNumberToDestHash) {
+      return;
+    }
+
+    this._updateCurrentTreeItem(null);
+
+    if (this._sidebarView !== _ui_utils.SidebarView.OUTLINE) {
+      return;
+    }
+
+    for (let i = this._currentPageNumber; i > 0; i--) {
+      const destHash = pageNumberToDestHash.get(i);
+
+      if (!destHash) {
+        continue;
+      }
+
+      const linkElement = this.container.querySelector(`a[href="${destHash}"]`);
+
+      if (!linkElement) {
+        continue;
+      }
+
+      this._scrollToCurrentTreeItem(linkElement.parentNode);
+
+      break;
+    }
+  }
+
+  async _getPageNumberToDestHash(pdfDocument) {
+    if (this._pageNumberToDestHashCapability) {
+      return this._pageNumberToDestHashCapability.promise;
+    }
+
+    this._pageNumberToDestHashCapability = (0, _pdfjsLib.createPromiseCapability)();
+    const pageNumberToDestHash = new Map(),
+          pageNumberNesting = new Map();
+    const queue = [{
+      nesting: 0,
+      items: this._outline
+    }];
+
+    while (queue.length > 0) {
+      const levelData = queue.shift(),
+            currentNesting = levelData.nesting;
+
+      for (const {
+        dest,
+        items
+      } of levelData.items) {
+        let explicitDest, pageNumber;
+
+        if (typeof dest === "string") {
+          explicitDest = await pdfDocument.getDestination(dest);
+
+          if (pdfDocument !== this._pdfDocument) {
+            return null;
+          }
+        } else {
+          explicitDest = dest;
+        }
+
+        if (Array.isArray(explicitDest)) {
+          const [destRef] = explicitDest;
+
+          if (typeof destRef === "object") {
+            pageNumber = this.linkService._cachedPageNumber(destRef);
+
+            if (!pageNumber) {
+              try {
+                pageNumber = (await pdfDocument.getPageIndex(destRef)) + 1;
+
+                if (pdfDocument !== this._pdfDocument) {
+                  return null;
+                }
+
+                this.linkService.cachePageRef(pageNumber, destRef);
+              } catch (ex) {}
+            }
+          } else if (Number.isInteger(destRef)) {
+            pageNumber = destRef + 1;
+          }
+
+          if (Number.isInteger(pageNumber) && (!pageNumberToDestHash.has(pageNumber) || currentNesting > pageNumberNesting.get(pageNumber))) {
+            const destHash = this.linkService.getDestinationHash(dest);
+            pageNumberToDestHash.set(pageNumber, destHash);
+            pageNumberNesting.set(pageNumber, currentNesting);
+          }
+        }
+
+        if (items.length > 0) {
+          queue.push({
+            nesting: currentNesting + 1,
+            items
+          });
+        }
+      }
+    }
+
+    this._pageNumberToDestHashCapability.resolve(pageNumberToDestHash.size > 0 ? pageNumberToDestHash : null);
+
+    return this._pageNumberToDestHashCapability.promise;
+  }
+
+}
+
+exports.PDFOutlineViewer = PDFOutlineViewer;
+
+/***/ }),
+/* 21 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFPresentationMode = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+const DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
+const DELAY_BEFORE_HIDING_CONTROLS = 3000;
+const ACTIVE_SELECTOR = "pdfPresentationMode";
+const CONTROLS_SELECTOR = "pdfPresentationModeControls";
+const MOUSE_SCROLL_COOLDOWN_TIME = 50;
+const PAGE_SWITCH_THRESHOLD = 0.1;
+const SWIPE_MIN_DISTANCE_THRESHOLD = 50;
+const SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
+
+class PDFPresentationMode {
+  constructor({
+    container,
+    pdfViewer,
+    eventBus,
+    contextMenuItems = null
+  }) {
+    this.container = container;
+    this.pdfViewer = pdfViewer;
+    this.eventBus = eventBus;
+    this.active = false;
+    this.args = null;
+    this.contextMenuOpen = false;
+    this.mouseScrollTimeStamp = 0;
+    this.mouseScrollDelta = 0;
+    this.touchSwipeState = null;
+
+    if (contextMenuItems) {
+      contextMenuItems.contextFirstPage.addEventListener("click", () => {
+        this.contextMenuOpen = false;
+        this.eventBus.dispatch("firstpage", {
+          source: this
+        });
+      });
+      contextMenuItems.contextLastPage.addEventListener("click", () => {
+        this.contextMenuOpen = false;
+        this.eventBus.dispatch("lastpage", {
+          source: this
+        });
+      });
+      contextMenuItems.contextPageRotateCw.addEventListener("click", () => {
+        this.contextMenuOpen = false;
+        this.eventBus.dispatch("rotatecw", {
+          source: this
+        });
+      });
+      contextMenuItems.contextPageRotateCcw.addEventListener("click", () => {
+        this.contextMenuOpen = false;
+        this.eventBus.dispatch("rotateccw", {
+          source: this
+        });
+      });
+    }
+  }
+
+  request() {
+    if (this.switchInProgress || this.active || !this.pdfViewer.pagesCount) {
+      return false;
+    }
+
+    this._addFullscreenChangeListeners();
+
+    this._setSwitchInProgress();
+
+    this._notifyStateChange();
+
+    if (this.container.requestFullscreen) {
+      this.container.requestFullscreen();
+    } else if (this.container.mozRequestFullScreen) {
+      this.container.mozRequestFullScreen();
+    } else if (this.container.webkitRequestFullscreen) {
+      this.container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
+    } else {
+      return false;
+    }
+
+    this.args = {
+      page: this.pdfViewer.currentPageNumber,
+      previousScale: this.pdfViewer.currentScaleValue
+    };
+    return true;
+  }
+
+  _mouseWheel(evt) {
+    if (!this.active) {
+      return;
+    }
+
+    evt.preventDefault();
+    const delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
+    const currentTime = new Date().getTime();
+    const storedTime = this.mouseScrollTimeStamp;
+
+    if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
+      return;
+    }
+
+    if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
+      this._resetMouseScrollState();
+    }
+
+    this.mouseScrollDelta += delta;
+
+    if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
+      const totalDelta = this.mouseScrollDelta;
+
+      this._resetMouseScrollState();
+
+      const success = totalDelta > 0 ? this._goToPreviousPage() : this._goToNextPage();
+
+      if (success) {
+        this.mouseScrollTimeStamp = currentTime;
+      }
+    }
+  }
+
+  get isFullscreen() {
+    return !!(document.fullscreenElement || document.mozFullScreen || document.webkitIsFullScreen);
+  }
+
+  _goToPreviousPage() {
+    const page = this.pdfViewer.currentPageNumber;
+
+    if (page <= 1) {
+      return false;
+    }
+
+    this.pdfViewer.currentPageNumber = page - 1;
+    return true;
+  }
+
+  _goToNextPage() {
+    const page = this.pdfViewer.currentPageNumber;
+
+    if (page >= this.pdfViewer.pagesCount) {
+      return false;
+    }
+
+    this.pdfViewer.currentPageNumber = page + 1;
+    return true;
+  }
+
+  _notifyStateChange() {
+    let state = _ui_utils.PresentationModeState.NORMAL;
+
+    if (this.switchInProgress) {
+      state = _ui_utils.PresentationModeState.CHANGING;
+    } else if (this.active) {
+      state = _ui_utils.PresentationModeState.FULLSCREEN;
+    }
+
+    this.eventBus.dispatch("presentationmodechanged", {
+      source: this,
+      state
+    });
+  }
+
+  _setSwitchInProgress() {
+    if (this.switchInProgress) {
+      clearTimeout(this.switchInProgress);
+    }
+
+    this.switchInProgress = setTimeout(() => {
+      this._removeFullscreenChangeListeners();
+
+      delete this.switchInProgress;
+
+      this._notifyStateChange();
+    }, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
+  }
+
+  _resetSwitchInProgress() {
+    if (this.switchInProgress) {
+      clearTimeout(this.switchInProgress);
+      delete this.switchInProgress;
+    }
+  }
+
+  _enter() {
+    this.active = true;
+
+    this._resetSwitchInProgress();
+
+    this._notifyStateChange();
+
+    this.container.classList.add(ACTIVE_SELECTOR);
+    setTimeout(() => {
+      this.pdfViewer.currentPageNumber = this.args.page;
+      this.pdfViewer.currentScaleValue = "page-fit";
+    }, 0);
+
+    this._addWindowListeners();
+
+    this._showControls();
+
+    this.contextMenuOpen = false;
+    this.container.setAttribute("contextmenu", "viewerContextMenu");
+    window.getSelection().removeAllRanges();
+  }
+
+  _exit() {
+    const page = this.pdfViewer.currentPageNumber;
+    this.container.classList.remove(ACTIVE_SELECTOR);
+    setTimeout(() => {
+      this.active = false;
+
+      this._removeFullscreenChangeListeners();
+
+      this._notifyStateChange();
+
+      this.pdfViewer.currentScaleValue = this.args.previousScale;
+      this.pdfViewer.currentPageNumber = page;
+      this.args = null;
+    }, 0);
+
+    this._removeWindowListeners();
+
+    this._hideControls();
+
+    this._resetMouseScrollState();
+
+    this.container.removeAttribute("contextmenu");
+    this.contextMenuOpen = false;
+  }
+
+  _mouseDown(evt) {
+    if (this.contextMenuOpen) {
+      this.contextMenuOpen = false;
+      evt.preventDefault();
+      return;
+    }
+
+    if (evt.button === 0) {
+      const isInternalLink = evt.target.href && evt.target.classList.contains("internalLink");
+
+      if (!isInternalLink) {
+        evt.preventDefault();
+
+        if (evt.shiftKey) {
+          this._goToPreviousPage();
+        } else {
+          this._goToNextPage();
+        }
+      }
+    }
+  }
+
+  _contextMenu() {
+    this.contextMenuOpen = true;
+  }
+
+  _showControls() {
+    if (this.controlsTimeout) {
+      clearTimeout(this.controlsTimeout);
+    } else {
+      this.container.classList.add(CONTROLS_SELECTOR);
+    }
+
+    this.controlsTimeout = setTimeout(() => {
+      this.container.classList.remove(CONTROLS_SELECTOR);
+      delete this.controlsTimeout;
+    }, DELAY_BEFORE_HIDING_CONTROLS);
+  }
+
+  _hideControls() {
+    if (!this.controlsTimeout) {
+      return;
+    }
+
+    clearTimeout(this.controlsTimeout);
+    this.container.classList.remove(CONTROLS_SELECTOR);
+    delete this.controlsTimeout;
+  }
+
+  _resetMouseScrollState() {
+    this.mouseScrollTimeStamp = 0;
+    this.mouseScrollDelta = 0;
+  }
+
+  _touchSwipe(evt) {
+    if (!this.active) {
+      return;
+    }
+
+    if (evt.touches.length > 1) {
+      this.touchSwipeState = null;
+      return;
+    }
+
+    switch (evt.type) {
+      case "touchstart":
+        this.touchSwipeState = {
+          startX: evt.touches[0].pageX,
+          startY: evt.touches[0].pageY,
+          endX: evt.touches[0].pageX,
+          endY: evt.touches[0].pageY
+        };
+        break;
+
+      case "touchmove":
+        if (this.touchSwipeState === null) {
+          return;
+        }
+
+        this.touchSwipeState.endX = evt.touches[0].pageX;
+        this.touchSwipeState.endY = evt.touches[0].pageY;
+        evt.preventDefault();
+        break;
+
+      case "touchend":
+        if (this.touchSwipeState === null) {
+          return;
+        }
+
+        let delta = 0;
+        const dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
+        const dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
+        const absAngle = Math.abs(Math.atan2(dy, dx));
+
+        if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
+          delta = dx;
+        } else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
+          delta = dy;
+        }
+
+        if (delta > 0) {
+          this._goToPreviousPage();
+        } else if (delta < 0) {
+          this._goToNextPage();
+        }
+
+        break;
+    }
+  }
+
+  _addWindowListeners() {
+    this.showControlsBind = this._showControls.bind(this);
+    this.mouseDownBind = this._mouseDown.bind(this);
+    this.mouseWheelBind = this._mouseWheel.bind(this);
+    this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
+    this.contextMenuBind = this._contextMenu.bind(this);
+    this.touchSwipeBind = this._touchSwipe.bind(this);
+    window.addEventListener("mousemove", this.showControlsBind);
+    window.addEventListener("mousedown", this.mouseDownBind);
+    window.addEventListener("wheel", this.mouseWheelBind, {
+      passive: false
+    });
+    window.addEventListener("keydown", this.resetMouseScrollStateBind);
+    window.addEventListener("contextmenu", this.contextMenuBind);
+    window.addEventListener("touchstart", this.touchSwipeBind);
+    window.addEventListener("touchmove", this.touchSwipeBind);
+    window.addEventListener("touchend", this.touchSwipeBind);
+  }
+
+  _removeWindowListeners() {
+    window.removeEventListener("mousemove", this.showControlsBind);
+    window.removeEventListener("mousedown", this.mouseDownBind);
+    window.removeEventListener("wheel", this.mouseWheelBind, {
+      passive: false
+    });
+    window.removeEventListener("keydown", this.resetMouseScrollStateBind);
+    window.removeEventListener("contextmenu", this.contextMenuBind);
+    window.removeEventListener("touchstart", this.touchSwipeBind);
+    window.removeEventListener("touchmove", this.touchSwipeBind);
+    window.removeEventListener("touchend", this.touchSwipeBind);
+    delete this.showControlsBind;
+    delete this.mouseDownBind;
+    delete this.mouseWheelBind;
+    delete this.resetMouseScrollStateBind;
+    delete this.contextMenuBind;
+    delete this.touchSwipeBind;
+  }
+
+  _fullscreenChange() {
+    if (this.isFullscreen) {
+      this._enter();
+    } else {
+      this._exit();
+    }
+  }
+
+  _addFullscreenChangeListeners() {
+    this.fullscreenChangeBind = this._fullscreenChange.bind(this);
+    window.addEventListener("fullscreenchange", this.fullscreenChangeBind);
+    window.addEventListener("mozfullscreenchange", this.fullscreenChangeBind);
+  }
+
+  _removeFullscreenChangeListeners() {
+    window.removeEventListener("fullscreenchange", this.fullscreenChangeBind);
+    window.removeEventListener("mozfullscreenchange", this.fullscreenChangeBind);
+    delete this.fullscreenChangeBind;
+  }
+
+}
+
+exports.PDFPresentationMode = PDFPresentationMode;
+
+/***/ }),
+/* 22 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFSidebar = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+const UI_NOTIFICATION_CLASS = "pdfSidebarNotification";
+
+class PDFSidebar {
+  constructor({
+    elements,
+    pdfViewer,
+    pdfThumbnailViewer,
+    eventBus,
+    l10n = _ui_utils.NullL10n,
+    disableNotification = false
+  }) {
+    this.isOpen = false;
+    this.active = _ui_utils.SidebarView.THUMBS;
+    this.isInitialViewSet = false;
+    this.onToggled = null;
+    this.pdfViewer = pdfViewer;
+    this.pdfThumbnailViewer = pdfThumbnailViewer;
+    this.outerContainer = elements.outerContainer;
+    this.viewerContainer = elements.viewerContainer;
+    this.toggleButton = elements.toggleButton;
+    this.thumbnailButton = elements.thumbnailButton;
+    this.outlineButton = elements.outlineButton;
+    this.attachmentsButton = elements.attachmentsButton;
+    this.layersButton = elements.layersButton;
+    this.thumbnailView = elements.thumbnailView;
+    this.outlineView = elements.outlineView;
+    this.attachmentsView = elements.attachmentsView;
+    this.layersView = elements.layersView;
+    this._outlineOptionsContainer = elements.outlineOptionsContainer;
+    this._currentOutlineItemButton = elements.currentOutlineItemButton;
+    this.eventBus = eventBus;
+    this.l10n = l10n;
+    this._disableNotification = disableNotification;
+
+    this._addEventListeners();
+  }
+
+  reset() {
+    this.isInitialViewSet = false;
+
+    this._hideUINotification(null);
+
+    this.switchView(_ui_utils.SidebarView.THUMBS);
+    this.outlineButton.disabled = false;
+    this.attachmentsButton.disabled = false;
+    this.layersButton.disabled = false;
+    this._currentOutlineItemButton.disabled = true;
+  }
+
+  get visibleView() {
+    return this.isOpen ? this.active : _ui_utils.SidebarView.NONE;
+  }
+
+  get isThumbnailViewVisible() {
+    return this.isOpen && this.active === _ui_utils.SidebarView.THUMBS;
+  }
+
+  get isOutlineViewVisible() {
+    return this.isOpen && this.active === _ui_utils.SidebarView.OUTLINE;
+  }
+
+  get isAttachmentsViewVisible() {
+    return this.isOpen && this.active === _ui_utils.SidebarView.ATTACHMENTS;
+  }
+
+  get isLayersViewVisible() {
+    return this.isOpen && this.active === _ui_utils.SidebarView.LAYERS;
+  }
+
+  setInitialView(view = _ui_utils.SidebarView.NONE) {
+    if (this.isInitialViewSet) {
+      return;
+    }
+
+    this.isInitialViewSet = true;
+
+    if (view === _ui_utils.SidebarView.NONE || view === _ui_utils.SidebarView.UNKNOWN) {
+      this._dispatchEvent();
+
+      return;
+    }
+
+    if (!this._switchView(view, true)) {
+      this._dispatchEvent();
+    }
+  }
+
+  switchView(view, forceOpen = false) {
+    this._switchView(view, forceOpen);
+  }
+
+  _switchView(view, forceOpen = false) {
+    const isViewChanged = view !== this.active;
+    let shouldForceRendering = false;
+
+    switch (view) {
+      case _ui_utils.SidebarView.NONE:
+        if (this.isOpen) {
+          this.close();
+          return true;
+        }
+
+        return false;
+
+      case _ui_utils.SidebarView.THUMBS:
+        if (this.isOpen && isViewChanged) {
+          shouldForceRendering = true;
+        }
+
+        break;
+
+      case _ui_utils.SidebarView.OUTLINE:
+        if (this.outlineButton.disabled) {
+          return false;
+        }
+
+        break;
+
+      case _ui_utils.SidebarView.ATTACHMENTS:
+        if (this.attachmentsButton.disabled) {
+          return false;
+        }
+
+        break;
+
+      case _ui_utils.SidebarView.LAYERS:
+        if (this.layersButton.disabled) {
+          return false;
+        }
+
+        break;
+
+      default:
+        console.error(`PDFSidebar._switchView: "${view}" is not a valid view.`);
+        return false;
+    }
+
+    this.active = view;
+    this.thumbnailButton.classList.toggle("toggled", view === _ui_utils.SidebarView.THUMBS);
+    this.outlineButton.classList.toggle("toggled", view === _ui_utils.SidebarView.OUTLINE);
+    this.attachmentsButton.classList.toggle("toggled", view === _ui_utils.SidebarView.ATTACHMENTS);
+    this.layersButton.classList.toggle("toggled", view === _ui_utils.SidebarView.LAYERS);
+    this.thumbnailView.classList.toggle("hidden", view !== _ui_utils.SidebarView.THUMBS);
+    this.outlineView.classList.toggle("hidden", view !== _ui_utils.SidebarView.OUTLINE);
+    this.attachmentsView.classList.toggle("hidden", view !== _ui_utils.SidebarView.ATTACHMENTS);
+    this.layersView.classList.toggle("hidden", view !== _ui_utils.SidebarView.LAYERS);
+
+    this._outlineOptionsContainer.classList.toggle("hidden", view !== _ui_utils.SidebarView.OUTLINE);
+
+    if (forceOpen && !this.isOpen) {
+      this.open();
+      return true;
+    }
+
+    if (shouldForceRendering) {
+      this._updateThumbnailViewer();
+
+      this._forceRendering();
+    }
+
+    if (isViewChanged) {
+      this._dispatchEvent();
+    }
+
+    this._hideUINotification(this.active);
+
+    return isViewChanged;
+  }
+
+  open() {
+    if (this.isOpen) {
+      return;
+    }
+
+    this.isOpen = true;
+    this.toggleButton.classList.add("toggled");
+    this.outerContainer.classList.add("sidebarMoving", "sidebarOpen");
+
+    if (this.active === _ui_utils.SidebarView.THUMBS) {
+      this._updateThumbnailViewer();
+    }
+
+    this._forceRendering();
+
+    this._dispatchEvent();
+
+    this._hideUINotification(this.active);
+  }
+
+  close() {
+    if (!this.isOpen) {
+      return;
+    }
+
+    this.isOpen = false;
+    this.toggleButton.classList.remove("toggled");
+    this.outerContainer.classList.add("sidebarMoving");
+    this.outerContainer.classList.remove("sidebarOpen");
+
+    this._forceRendering();
+
+    this._dispatchEvent();
+  }
+
+  toggle() {
+    if (this.isOpen) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+
+  _dispatchEvent() {
+    this.eventBus.dispatch("sidebarviewchanged", {
+      source: this,
+      view: this.visibleView
+    });
+  }
+
+  _forceRendering() {
+    if (this.onToggled) {
+      this.onToggled();
+    } else {
+      this.pdfViewer.forceRendering();
+      this.pdfThumbnailViewer.forceRendering();
+    }
+  }
+
+  _updateThumbnailViewer() {
+    const {
+      pdfViewer,
+      pdfThumbnailViewer
+    } = this;
+    const pagesCount = pdfViewer.pagesCount;
+
+    for (let pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
+      const pageView = pdfViewer.getPageView(pageIndex);
+
+      if (pageView && pageView.renderingState === _pdf_rendering_queue.RenderingStates.FINISHED) {
+        const thumbnailView = pdfThumbnailViewer.getThumbnail(pageIndex);
+        thumbnailView.setImage(pageView);
+      }
+    }
+
+    pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
+  }
+
+  _showUINotification(view) {
+    if (this._disableNotification) {
+      return;
+    }
+
+    this.l10n.get("toggle_sidebar_notification2.title", null, "Toggle Sidebar (document contains outline/attachments/layers)").then(msg => {
+      this.toggleButton.title = msg;
+    });
+
+    if (!this.isOpen) {
+      this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
+    } else if (view === this.active) {
+      return;
+    }
+
+    switch (view) {
+      case _ui_utils.SidebarView.OUTLINE:
+        this.outlineButton.classList.add(UI_NOTIFICATION_CLASS);
+        break;
+
+      case _ui_utils.SidebarView.ATTACHMENTS:
+        this.attachmentsButton.classList.add(UI_NOTIFICATION_CLASS);
+        break;
+
+      case _ui_utils.SidebarView.LAYERS:
+        this.layersButton.classList.add(UI_NOTIFICATION_CLASS);
+        break;
+    }
+  }
+
+  _hideUINotification(view) {
+    if (this._disableNotification) {
+      return;
+    }
+
+    const removeNotification = sidebarView => {
+      switch (sidebarView) {
+        case _ui_utils.SidebarView.OUTLINE:
+          this.outlineButton.classList.remove(UI_NOTIFICATION_CLASS);
+          break;
+
+        case _ui_utils.SidebarView.ATTACHMENTS:
+          this.attachmentsButton.classList.remove(UI_NOTIFICATION_CLASS);
+          break;
+
+        case _ui_utils.SidebarView.LAYERS:
+          this.layersButton.classList.remove(UI_NOTIFICATION_CLASS);
+          break;
+      }
+    };
+
+    if (!this.isOpen && view !== null) {
+      return;
+    }
+
+    this.toggleButton.classList.remove(UI_NOTIFICATION_CLASS);
+
+    if (view !== null) {
+      removeNotification(view);
+      return;
+    }
+
+    for (view in _ui_utils.SidebarView) {
+      removeNotification(_ui_utils.SidebarView[view]);
+    }
+
+    this.l10n.get("toggle_sidebar.title", null, "Toggle Sidebar").then(msg => {
+      this.toggleButton.title = msg;
+    });
+  }
+
+  _addEventListeners() {
+    this.viewerContainer.addEventListener("transitionend", evt => {
+      if (evt.target === this.viewerContainer) {
+        this.outerContainer.classList.remove("sidebarMoving");
+      }
+    });
+    this.toggleButton.addEventListener("click", () => {
+      this.toggle();
+    });
+    this.thumbnailButton.addEventListener("click", () => {
+      this.switchView(_ui_utils.SidebarView.THUMBS);
+    });
+    this.outlineButton.addEventListener("click", () => {
+      this.switchView(_ui_utils.SidebarView.OUTLINE);
+    });
+    this.outlineButton.addEventListener("dblclick", () => {
+      this.eventBus.dispatch("toggleoutlinetree", {
+        source: this
+      });
+    });
+    this.attachmentsButton.addEventListener("click", () => {
+      this.switchView(_ui_utils.SidebarView.ATTACHMENTS);
+    });
+    this.layersButton.addEventListener("click", () => {
+      this.switchView(_ui_utils.SidebarView.LAYERS);
+    });
+    this.layersButton.addEventListener("dblclick", () => {
+      this.eventBus.dispatch("resetlayers", {
+        source: this
+      });
+    });
+
+    this._currentOutlineItemButton.addEventListener("click", () => {
+      this.eventBus.dispatch("currentoutlineitem", {
+        source: this
+      });
+    });
+
+    const onTreeLoaded = (count, button, view) => {
+      button.disabled = !count;
+
+      if (count) {
+        this._showUINotification(view);
+      } else if (this.active === view) {
+        this.switchView(_ui_utils.SidebarView.THUMBS);
+      }
+    };
+
+    this.eventBus._on("outlineloaded", evt => {
+      onTreeLoaded(evt.outlineCount, this.outlineButton, _ui_utils.SidebarView.OUTLINE);
+
+      if (evt.enableCurrentOutlineItemButton) {
+        this.pdfViewer.pagesPromise.then(() => {
+          this._currentOutlineItemButton.disabled = !this.isInitialViewSet;
+        });
+      }
+    });
+
+    this.eventBus._on("attachmentsloaded", evt => {
+      onTreeLoaded(evt.attachmentsCount, this.attachmentsButton, _ui_utils.SidebarView.ATTACHMENTS);
+    });
+
+    this.eventBus._on("layersloaded", evt => {
+      onTreeLoaded(evt.layersCount, this.layersButton, _ui_utils.SidebarView.LAYERS);
+    });
+
+    this.eventBus._on("presentationmodechanged", evt => {
+      if (evt.state === _ui_utils.PresentationModeState.NORMAL && this.isThumbnailViewVisible) {
+        this._updateThumbnailViewer();
+      }
+    });
+  }
+
+}
+
+exports.PDFSidebar = PDFSidebar;
+
+/***/ }),
+/* 23 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFSidebarResizer = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+const SIDEBAR_WIDTH_VAR = "--sidebar-width";
+const SIDEBAR_MIN_WIDTH = 200;
+const SIDEBAR_RESIZING_CLASS = "sidebarResizing";
+
+class PDFSidebarResizer {
+  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
+    this.isRTL = false;
+    this.sidebarOpen = false;
+    this.doc = document.documentElement;
+    this._width = null;
+    this._outerContainerWidth = null;
+    this._boundEvents = Object.create(null);
+    this.outerContainer = options.outerContainer;
+    this.resizer = options.resizer;
+    this.eventBus = eventBus;
+    l10n.getDirection().then(dir => {
+      this.isRTL = dir === "rtl";
+    });
+
+    this._addEventListeners();
+  }
+
+  get outerContainerWidth() {
+    if (!this._outerContainerWidth) {
+      this._outerContainerWidth = this.outerContainer.clientWidth;
+    }
+
+    return this._outerContainerWidth;
+  }
+
+  _updateWidth(width = 0) {
+    const maxWidth = Math.floor(this.outerContainerWidth / 2);
+
+    if (width > maxWidth) {
+      width = maxWidth;
+    }
+
+    if (width < SIDEBAR_MIN_WIDTH) {
+      width = SIDEBAR_MIN_WIDTH;
+    }
+
+    if (width === this._width) {
+      return false;
+    }
+
+    this._width = width;
+    this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, `${width}px`);
+    return true;
+  }
+
+  _mouseMove(evt) {
+    let width = evt.clientX;
+
+    if (this.isRTL) {
+      width = this.outerContainerWidth - width;
+    }
+
+    this._updateWidth(width);
+  }
+
+  _mouseUp(evt) {
+    this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+    this.eventBus.dispatch("resize", {
+      source: this
+    });
+    const _boundEvents = this._boundEvents;
+    window.removeEventListener("mousemove", _boundEvents.mouseMove);
+    window.removeEventListener("mouseup", _boundEvents.mouseUp);
+  }
+
+  _addEventListeners() {
+    const _boundEvents = this._boundEvents;
+    _boundEvents.mouseMove = this._mouseMove.bind(this);
+    _boundEvents.mouseUp = this._mouseUp.bind(this);
+    this.resizer.addEventListener("mousedown", evt => {
+      if (evt.button !== 0) {
+        return;
+      }
+
+      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
+      window.addEventListener("mousemove", _boundEvents.mouseMove);
+      window.addEventListener("mouseup", _boundEvents.mouseUp);
+    });
+
+    this.eventBus._on("sidebarviewchanged", evt => {
+      this.sidebarOpen = !!(evt && evt.view);
+    });
+
+    this.eventBus._on("resize", evt => {
+      if (!evt || evt.source !== window) {
+        return;
+      }
+
+      this._outerContainerWidth = null;
+
+      if (!this._width) {
+        return;
+      }
+
+      if (!this.sidebarOpen) {
+        this._updateWidth(this._width);
+
+        return;
+      }
+
+      this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
+
+      const updated = this._updateWidth(this._width);
+
+      Promise.resolve().then(() => {
+        this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
+
+        if (updated) {
+          this.eventBus.dispatch("resize", {
+            source: this
+          });
+        }
+      });
+    });
+  }
+
+}
+
+exports.PDFSidebarResizer = PDFSidebarResizer;
+
+/***/ }),
+/* 24 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFThumbnailViewer = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdf_thumbnail_view = __webpack_require__(25);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+const THUMBNAIL_SCROLL_MARGIN = -19;
+const THUMBNAIL_SELECTED_CLASS = "selected";
+
+class PDFThumbnailViewer {
+  constructor({
+    container,
+    eventBus,
+    linkService,
+    renderingQueue,
+    l10n = _ui_utils.NullL10n
+  }) {
+    this.container = container;
+    this.linkService = linkService;
+    this.renderingQueue = renderingQueue;
+    this.l10n = l10n;
+    this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdated.bind(this));
+
+    this._resetView();
+
+    eventBus._on("optionalcontentconfigchanged", () => {
+      this._setImageDisabled = true;
+    });
+  }
+
+  _scrollUpdated() {
+    this.renderingQueue.renderHighestPriority();
+  }
+
+  getThumbnail(index) {
+    return this._thumbnails[index];
+  }
+
+  _getVisibleThumbs() {
+    return (0, _ui_utils.getVisibleElements)({
+      scrollEl: this.container,
+      views: this._thumbnails
+    });
+  }
+
+  scrollThumbnailIntoView(pageNumber) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    const thumbnailView = this._thumbnails[pageNumber - 1];
+
+    if (!thumbnailView) {
+      console.error('scrollThumbnailIntoView: Invalid "pageNumber" parameter.');
+      return;
+    }
+
+    if (pageNumber !== this._currentPageNumber) {
+      const prevThumbnailView = this._thumbnails[this._currentPageNumber - 1];
+      prevThumbnailView.div.classList.remove(THUMBNAIL_SELECTED_CLASS);
+      thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
+    }
+
+    const visibleThumbs = this._getVisibleThumbs();
+
+    const numVisibleThumbs = visibleThumbs.views.length;
+
+    if (numVisibleThumbs > 0) {
+      const first = visibleThumbs.first.id;
+      const last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
+      let shouldScroll = false;
+
+      if (pageNumber <= first || pageNumber >= last) {
+        shouldScroll = true;
+      } else {
+        visibleThumbs.views.some(function (view) {
+          if (view.id !== pageNumber) {
+            return false;
+          }
+
+          shouldScroll = view.percent < 100;
+          return true;
+        });
+      }
+
+      if (shouldScroll) {
+        (0, _ui_utils.scrollIntoView)(thumbnailView.div, {
+          top: THUMBNAIL_SCROLL_MARGIN
+        });
+      }
+    }
+
+    this._currentPageNumber = pageNumber;
+  }
+
+  get pagesRotation() {
+    return this._pagesRotation;
+  }
+
+  set pagesRotation(rotation) {
+    if (!(0, _ui_utils.isValidRotation)(rotation)) {
+      throw new Error("Invalid thumbnails rotation angle.");
+    }
+
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (this._pagesRotation === rotation) {
+      return;
+    }
+
+    this._pagesRotation = rotation;
+
+    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
+      this._thumbnails[i].update(rotation);
+    }
+  }
+
+  cleanup() {
+    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
+      if (this._thumbnails[i] && this._thumbnails[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+        this._thumbnails[i].reset();
+      }
+    }
+
+    _pdf_thumbnail_view.TempImageFactory.destroyCanvas();
+  }
+
+  _resetView() {
+    this._thumbnails = [];
+    this._currentPageNumber = 1;
+    this._pageLabels = null;
+    this._pagesRotation = 0;
+    this._optionalContentConfigPromise = null;
+    this._pagesRequests = new WeakMap();
+    this._setImageDisabled = false;
+    this.container.textContent = "";
+  }
+
+  setDocument(pdfDocument) {
+    if (this.pdfDocument) {
+      this._cancelRendering();
+
+      this._resetView();
+    }
+
+    this.pdfDocument = pdfDocument;
+
+    if (!pdfDocument) {
+      return;
+    }
+
+    const firstPagePromise = pdfDocument.getPage(1);
+    const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
+    firstPagePromise.then(firstPdfPage => {
+      this._optionalContentConfigPromise = optionalContentConfigPromise;
+      const pagesCount = pdfDocument.numPages;
+      const viewport = firstPdfPage.getViewport({
+        scale: 1
+      });
+
+      const checkSetImageDisabled = () => {
+        return this._setImageDisabled;
+      };
+
+      for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+        const thumbnail = new _pdf_thumbnail_view.PDFThumbnailView({
+          container: this.container,
+          id: pageNum,
+          defaultViewport: viewport.clone(),
+          optionalContentConfigPromise,
+          linkService: this.linkService,
+          renderingQueue: this.renderingQueue,
+          checkSetImageDisabled,
+          disableCanvasToImageConversion: false,
+          l10n: this.l10n
+        });
+
+        this._thumbnails.push(thumbnail);
+      }
+
+      const firstThumbnailView = this._thumbnails[0];
+
+      if (firstThumbnailView) {
+        firstThumbnailView.setPdfPage(firstPdfPage);
+      }
+
+      const thumbnailView = this._thumbnails[this._currentPageNumber - 1];
+      thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
+    }).catch(reason => {
+      console.error("Unable to initialize thumbnail viewer", reason);
+    });
+  }
+
+  _cancelRendering() {
+    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
+      if (this._thumbnails[i]) {
+        this._thumbnails[i].cancelRendering();
+      }
+    }
+  }
+
+  setPageLabels(labels) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (!labels) {
+      this._pageLabels = null;
+    } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
+      this._pageLabels = null;
+      console.error("PDFThumbnailViewer_setPageLabels: Invalid page labels.");
+    } else {
+      this._pageLabels = labels;
+    }
+
+    for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
+      const label = this._pageLabels && this._pageLabels[i];
+
+      this._thumbnails[i].setPageLabel(label);
+    }
+  }
+
+  _ensurePdfPageLoaded(thumbView) {
+    if (thumbView.pdfPage) {
+      return Promise.resolve(thumbView.pdfPage);
+    }
+
+    if (this._pagesRequests.has(thumbView)) {
+      return this._pagesRequests.get(thumbView);
+    }
+
+    const promise = this.pdfDocument.getPage(thumbView.id).then(pdfPage => {
+      if (!thumbView.pdfPage) {
+        thumbView.setPdfPage(pdfPage);
+      }
+
+      this._pagesRequests.delete(thumbView);
+
+      return pdfPage;
+    }).catch(reason => {
+      console.error("Unable to get page for thumb view", reason);
+
+      this._pagesRequests.delete(thumbView);
+    });
+
+    this._pagesRequests.set(thumbView, promise);
+
+    return promise;
+  }
+
+  forceRendering() {
+    const visibleThumbs = this._getVisibleThumbs();
+
+    const thumbView = this.renderingQueue.getHighestPriority(visibleThumbs, this._thumbnails, this.scroll.down);
+
+    if (thumbView) {
+      this._ensurePdfPageLoaded(thumbView).then(() => {
+        this.renderingQueue.renderView(thumbView);
+      });
+
+      return true;
+    }
+
+    return false;
+  }
+
+}
+
+exports.PDFThumbnailViewer = PDFThumbnailViewer;
+
+/***/ }),
+/* 25 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.TempImageFactory = exports.PDFThumbnailView = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+const MAX_NUM_SCALING_STEPS = 3;
+const THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
+const THUMBNAIL_WIDTH = 98;
+
+const TempImageFactory = function TempImageFactoryClosure() {
+  let tempCanvasCache = null;
+  return {
+    getCanvas(width, height) {
+      let tempCanvas = tempCanvasCache;
+
+      if (!tempCanvas) {
+        tempCanvas = document.createElement("canvas");
+        tempCanvasCache = tempCanvas;
+      }
+
+      tempCanvas.width = width;
+      tempCanvas.height = height;
+      tempCanvas.mozOpaque = true;
+      const ctx = tempCanvas.getContext("2d", {
+        alpha: false
+      });
+      ctx.save();
+      ctx.fillStyle = "rgb(255, 255, 255)";
+      ctx.fillRect(0, 0, width, height);
+      ctx.restore();
+      return tempCanvas;
+    },
+
+    destroyCanvas() {
+      const tempCanvas = tempCanvasCache;
+
+      if (tempCanvas) {
+        tempCanvas.width = 0;
+        tempCanvas.height = 0;
+      }
+
+      tempCanvasCache = null;
+    }
+
+  };
+}();
+
+exports.TempImageFactory = TempImageFactory;
+
+class PDFThumbnailView {
+  constructor({
+    container,
+    id,
+    defaultViewport,
+    optionalContentConfigPromise,
+    linkService,
+    renderingQueue,
+    checkSetImageDisabled,
+    disableCanvasToImageConversion = false,
+    l10n = _ui_utils.NullL10n
+  }) {
+    this.id = id;
+    this.renderingId = "thumbnail" + id;
+    this.pageLabel = null;
+    this.pdfPage = null;
+    this.rotation = 0;
+    this.viewport = defaultViewport;
+    this.pdfPageRotate = defaultViewport.rotation;
+    this._optionalContentConfigPromise = optionalContentConfigPromise || null;
+    this.linkService = linkService;
+    this.renderingQueue = renderingQueue;
+    this.renderTask = null;
+    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+    this.resume = null;
+
+    this._checkSetImageDisabled = checkSetImageDisabled || function () {
+      return false;
+    };
+
+    this.disableCanvasToImageConversion = disableCanvasToImageConversion;
+    this.pageWidth = this.viewport.width;
+    this.pageHeight = this.viewport.height;
+    this.pageRatio = this.pageWidth / this.pageHeight;
+    this.canvasWidth = THUMBNAIL_WIDTH;
+    this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
+    this.scale = this.canvasWidth / this.pageWidth;
+    this.l10n = l10n;
+    const anchor = document.createElement("a");
+    anchor.href = linkService.getAnchorUrl("#page=" + id);
+
+    this._thumbPageTitle.then(msg => {
+      anchor.title = msg;
+    });
+
+    anchor.onclick = function () {
+      linkService.goToPage(id);
+      return false;
+    };
+
+    this.anchor = anchor;
+    const div = document.createElement("div");
+    div.className = "thumbnail";
+    div.setAttribute("data-page-number", this.id);
+    this.div = div;
+    const ring = document.createElement("div");
+    ring.className = "thumbnailSelectionRing";
+    const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+    ring.style.width = this.canvasWidth + borderAdjustment + "px";
+    ring.style.height = this.canvasHeight + borderAdjustment + "px";
+    this.ring = ring;
+    div.appendChild(ring);
+    anchor.appendChild(div);
+    container.appendChild(anchor);
+  }
+
+  setPdfPage(pdfPage) {
+    this.pdfPage = pdfPage;
+    this.pdfPageRotate = pdfPage.rotate;
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = pdfPage.getViewport({
+      scale: 1,
+      rotation: totalRotation
+    });
+    this.reset();
+  }
+
+  reset() {
+    this.cancelRendering();
+    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+    this.pageWidth = this.viewport.width;
+    this.pageHeight = this.viewport.height;
+    this.pageRatio = this.pageWidth / this.pageHeight;
+    this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
+    this.scale = this.canvasWidth / this.pageWidth;
+    this.div.removeAttribute("data-loaded");
+    const ring = this.ring;
+    const childNodes = ring.childNodes;
+
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      ring.removeChild(childNodes[i]);
+    }
+
+    const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+    ring.style.width = this.canvasWidth + borderAdjustment + "px";
+    ring.style.height = this.canvasHeight + borderAdjustment + "px";
+
+    if (this.canvas) {
+      this.canvas.width = 0;
+      this.canvas.height = 0;
+      delete this.canvas;
+    }
+
+    if (this.image) {
+      this.image.removeAttribute("src");
+      delete this.image;
+    }
+  }
+
+  update(rotation) {
+    if (typeof rotation !== "undefined") {
+      this.rotation = rotation;
+    }
+
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = this.viewport.clone({
+      scale: 1,
+      rotation: totalRotation
+    });
+    this.reset();
+  }
+
+  cancelRendering() {
+    if (this.renderTask) {
+      this.renderTask.cancel();
+      this.renderTask = null;
+    }
+
+    this.resume = null;
+  }
+
+  _getPageDrawContext() {
+    const canvas = document.createElement("canvas");
+    this.canvas = canvas;
+    canvas.mozOpaque = true;
+    const ctx = canvas.getContext("2d", {
+      alpha: false
+    });
+    const outputScale = (0, _ui_utils.getOutputScale)(ctx);
+    canvas.width = this.canvasWidth * outputScale.sx | 0;
+    canvas.height = this.canvasHeight * outputScale.sy | 0;
+    canvas.style.width = this.canvasWidth + "px";
+    canvas.style.height = this.canvasHeight + "px";
+    const transform = outputScale.scaled ? [outputScale.sx, 0, 0, outputScale.sy, 0, 0] : null;
+    return [ctx, transform];
+  }
+
+  _convertCanvasToImage() {
+    if (!this.canvas) {
+      return;
+    }
+
+    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+      return;
+    }
+
+    const className = "thumbnailImage";
+
+    if (this.disableCanvasToImageConversion) {
+      this.canvas.className = className;
+
+      this._thumbPageCanvas.then(msg => {
+        this.canvas.setAttribute("aria-label", msg);
+      });
+
+      this.div.setAttribute("data-loaded", true);
+      this.ring.appendChild(this.canvas);
+      return;
+    }
+
+    const image = document.createElement("img");
+    image.className = className;
+
+    this._thumbPageCanvas.then(msg => {
+      image.setAttribute("aria-label", msg);
+    });
+
+    image.style.width = this.canvasWidth + "px";
+    image.style.height = this.canvasHeight + "px";
+    image.src = this.canvas.toDataURL();
+    this.image = image;
+    this.div.setAttribute("data-loaded", true);
+    this.ring.appendChild(image);
+    this.canvas.width = 0;
+    this.canvas.height = 0;
+    delete this.canvas;
+  }
+
+  draw() {
+    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
+      console.error("Must be in new state before drawing");
+      return Promise.resolve(undefined);
+    }
+
+    const {
+      pdfPage
+    } = this;
+
+    if (!pdfPage) {
+      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+      return Promise.reject(new Error("pdfPage is not loaded"));
+    }
+
+    this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+
+    const finishRenderTask = async (error = null) => {
+      if (renderTask === this.renderTask) {
+        this.renderTask = null;
+      }
+
+      if (error instanceof _pdfjsLib.RenderingCancelledException) {
+        return;
+      }
+
+      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+
+      this._convertCanvasToImage();
+
+      if (error) {
+        throw error;
+      }
+    };
+
+    const [ctx, transform] = this._getPageDrawContext();
+
+    const drawViewport = this.viewport.clone({
+      scale: this.scale
+    });
+
+    const renderContinueCallback = cont => {
+      if (!this.renderingQueue.isHighestPriority(this)) {
+        this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
+
+        this.resume = () => {
+          this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+          cont();
+        };
+
+        return;
+      }
+
+      cont();
+    };
+
+    const renderContext = {
+      canvasContext: ctx,
+      transform,
+      viewport: drawViewport,
+      optionalContentConfigPromise: this._optionalContentConfigPromise
+    };
+    const renderTask = this.renderTask = pdfPage.render(renderContext);
+    renderTask.onContinue = renderContinueCallback;
+    const resultPromise = renderTask.promise.then(function () {
+      finishRenderTask(null);
+    }, function (error) {
+      finishRenderTask(error);
+    });
+    resultPromise.finally(() => {
+      const pageCached = this.linkService.isPageCached(this.id);
+
+      if (pageCached) {
+        return;
+      }
+
+      this.pdfPage?.cleanup();
+    });
+    return resultPromise;
+  }
+
+  setImage(pageView) {
+    if (this._checkSetImageDisabled()) {
+      return;
+    }
+
+    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
+      return;
+    }
+
+    const img = pageView.canvas;
+
+    if (!img) {
+      return;
+    }
+
+    if (!this.pdfPage) {
+      this.setPdfPage(pageView.pdfPage);
+    }
+
+    this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+
+    const [ctx] = this._getPageDrawContext();
+
+    const canvas = ctx.canvas;
+
+    if (img.width <= 2 * canvas.width) {
+      ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+
+      this._convertCanvasToImage();
+
+      return;
+    }
+
+    let reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
+    let reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
+    const reducedImage = TempImageFactory.getCanvas(reducedWidth, reducedHeight);
+    const reducedImageCtx = reducedImage.getContext("2d");
+
+    while (reducedWidth > img.width || reducedHeight > img.height) {
+      reducedWidth >>= 1;
+      reducedHeight >>= 1;
+    }
+
+    reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0, reducedWidth, reducedHeight);
+
+    while (reducedWidth > 2 * canvas.width) {
+      reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
+      reducedWidth >>= 1;
+      reducedHeight >>= 1;
+    }
+
+    ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, canvas.width, canvas.height);
+
+    this._convertCanvasToImage();
+  }
+
+  get _thumbPageTitle() {
+    return this.l10n.get("thumb_page_title", {
+      page: this.pageLabel ?? this.id
+    }, "Page {{page}}");
+  }
+
+  get _thumbPageCanvas() {
+    return this.l10n.get("thumb_page_canvas", {
+      page: this.pageLabel ?? this.id
+    }, "Thumbnail of Page {{page}}");
+  }
+
+  setPageLabel(label) {
+    this.pageLabel = typeof label === "string" ? label : null;
+
+    this._thumbPageTitle.then(msg => {
+      this.anchor.title = msg;
+    });
+
+    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+      return;
+    }
+
+    this._thumbPageCanvas.then(msg => {
+      if (this.image) {
+        this.image.setAttribute("aria-label", msg);
+      } else if (this.disableCanvasToImageConversion && this.canvas) {
+        this.canvas.setAttribute("aria-label", msg);
+      }
+    });
+  }
+
+}
+
+exports.PDFThumbnailView = PDFThumbnailView;
+
+/***/ }),
+/* 26 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFViewer = void 0;
+
+var _base_viewer = __webpack_require__(27);
+
+var _pdfjsLib = __webpack_require__(5);
+
+class PDFViewer extends _base_viewer.BaseViewer {
+  get _viewerElement() {
+    return (0, _pdfjsLib.shadow)(this, "_viewerElement", this.viewer);
+  }
+
+  _scrollIntoView({
+    pageDiv,
+    pageSpot = null,
+    pageNumber = null
+  }) {
+    if (!pageSpot && !this.isInPresentationMode) {
+      const left = pageDiv.offsetLeft + pageDiv.clientLeft;
+      const right = left + pageDiv.clientWidth;
+      const {
+        scrollLeft,
+        clientWidth
+      } = this.container;
+
+      if (this._isScrollModeHorizontal || left < scrollLeft || right > scrollLeft + clientWidth) {
+        pageSpot = {
+          left: 0,
+          top: 0
+        };
+      }
+    }
+
+    super._scrollIntoView({
+      pageDiv,
+      pageSpot,
+      pageNumber
+    });
+  }
+
+  _getVisiblePages() {
+    if (this.isInPresentationMode) {
+      return this._getCurrentVisiblePage();
+    }
+
+    return super._getVisiblePages();
+  }
+
+  _updateHelper(visiblePages) {
+    if (this.isInPresentationMode) {
+      return;
+    }
+
+    let currentId = this._currentPageNumber;
+    let stillFullyVisible = false;
+
+    for (const page of visiblePages) {
+      if (page.percent < 100) {
+        break;
+      }
+
+      if (page.id === currentId) {
+        stillFullyVisible = true;
+        break;
+      }
+    }
+
+    if (!stillFullyVisible) {
+      currentId = visiblePages[0].id;
+    }
+
+    this._setCurrentPageNumber(currentId);
+  }
+
+}
+
+exports.PDFViewer = PDFViewer;
+
+/***/ }),
+/* 27 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.BaseViewer = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+var _annotation_layer_builder = __webpack_require__(28);
+
+var _pdf_page_view = __webpack_require__(29);
+
+var _pdf_link_service = __webpack_require__(19);
+
+var _text_layer_builder = __webpack_require__(30);
+
+const DEFAULT_CACHE_SIZE = 10;
+
+function PDFPageViewBuffer(size) {
+  const data = [];
+
+  this.push = function (view) {
+    const i = data.indexOf(view);
+
+    if (i >= 0) {
+      data.splice(i, 1);
+    }
+
+    data.push(view);
+
+    if (data.length > size) {
+      data.shift().destroy();
+    }
+  };
+
+  this.resize = function (newSize, pagesToKeep) {
+    size = newSize;
+
+    if (pagesToKeep) {
+      const pageIdsToKeep = new Set();
+
+      for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
+        pageIdsToKeep.add(pagesToKeep[i].id);
+      }
+
+      (0, _ui_utils.moveToEndOfArray)(data, function (page) {
+        return pageIdsToKeep.has(page.id);
+      });
+    }
+
+    while (data.length > size) {
+      data.shift().destroy();
+    }
+  };
+
+  this.has = function (view) {
+    return data.includes(view);
+  };
+}
+
+function isSameScale(oldScale, newScale) {
+  if (newScale === oldScale) {
+    return true;
+  }
+
+  if (Math.abs(newScale - oldScale) < 1e-15) {
+    return true;
+  }
+
+  return false;
+}
+
+class BaseViewer {
+  constructor(options) {
+    if (this.constructor === BaseViewer) {
+      throw new Error("Cannot initialize BaseViewer.");
+    }
+
+    const viewerVersion = '2.7.510';
+
+    if (_pdfjsLib.version !== viewerVersion) {
+      throw new Error(`The API version "${_pdfjsLib.version}" does not match the Viewer version "${viewerVersion}".`);
+    }
+
+    this._name = this.constructor.name;
+    this.container = options.container;
+    this.viewer = options.viewer || options.container.firstElementChild;
+    this.eventBus = options.eventBus;
+    this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService();
+    this.downloadManager = options.downloadManager || null;
+    this.findController = options.findController || null;
+    this.removePageBorders = options.removePageBorders || false;
+    this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE;
+    this.imageResourcesPath = options.imageResourcesPath || "";
+    this.renderInteractiveForms = typeof options.renderInteractiveForms === "boolean" ? options.renderInteractiveForms : true;
+    this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
+    this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
+    this.enableWebGL = options.enableWebGL || false;
+    this.useOnlyCssZoom = options.useOnlyCssZoom || false;
+    this.maxCanvasPixels = options.maxCanvasPixels;
+    this.l10n = options.l10n || _ui_utils.NullL10n;
+    this.enableScripting = options.enableScripting || false;
+    this._mouseState = options.mouseState || null;
+    this.defaultRenderingQueue = !options.renderingQueue;
+
+    if (this.defaultRenderingQueue) {
+      this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
+      this.renderingQueue.setViewer(this);
+    } else {
+      this.renderingQueue = options.renderingQueue;
+    }
+
+    this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this));
+    this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
+    this._onBeforeDraw = this._onAfterDraw = null;
+
+    this._resetView();
+
+    if (this.removePageBorders) {
+      this.viewer.classList.add("removePageBorders");
+    }
+
+    this._initializeScriptingEvents();
+
+    Promise.resolve().then(() => {
+      this.eventBus.dispatch("baseviewerinit", {
+        source: this
+      });
+    });
+  }
+
+  get pagesCount() {
+    return this._pages.length;
+  }
+
+  getPageView(index) {
+    return this._pages[index];
+  }
+
+  get pageViewsReady() {
+    if (!this._pagesCapability.settled) {
+      return false;
+    }
+
+    return this._pages.every(function (pageView) {
+      return pageView && pageView.pdfPage;
+    });
+  }
+
+  get currentPageNumber() {
+    return this._currentPageNumber;
+  }
+
+  set currentPageNumber(val) {
+    if (!Number.isInteger(val)) {
+      throw new Error("Invalid page number.");
+    }
+
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (!this._setCurrentPageNumber(val, true)) {
+      console.error(`${this._name}.currentPageNumber: "${val}" is not a valid page.`);
+    }
+  }
+
+  _setCurrentPageNumber(val, resetCurrentPageView = false) {
+    if (this._currentPageNumber === val) {
+      if (resetCurrentPageView) {
+        this._resetCurrentPageView();
+      }
+
+      return true;
+    }
+
+    if (!(0 < val && val <= this.pagesCount)) {
+      return false;
+    }
+
+    const previous = this._currentPageNumber;
+    this._currentPageNumber = val;
+    this.eventBus.dispatch("pagechanging", {
+      source: this,
+      pageNumber: val,
+      pageLabel: this._pageLabels && this._pageLabels[val - 1],
+      previous
+    });
+
+    if (resetCurrentPageView) {
+      this._resetCurrentPageView();
+    }
+
+    return true;
+  }
+
+  get currentPageLabel() {
+    return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
+  }
+
+  set currentPageLabel(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    let page = val | 0;
+
+    if (this._pageLabels) {
+      const i = this._pageLabels.indexOf(val);
+
+      if (i >= 0) {
+        page = i + 1;
+      }
+    }
+
+    if (!this._setCurrentPageNumber(page, true)) {
+      console.error(`${this._name}.currentPageLabel: "${val}" is not a valid page.`);
+    }
+  }
+
+  get currentScale() {
+    return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
+  }
+
+  set currentScale(val) {
+    if (isNaN(val)) {
+      throw new Error("Invalid numeric scale.");
+    }
+
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    this._setScale(val, false);
+  }
+
+  get currentScaleValue() {
+    return this._currentScaleValue;
+  }
+
+  set currentScaleValue(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    this._setScale(val, false);
+  }
+
+  get pagesRotation() {
+    return this._pagesRotation;
+  }
+
+  set pagesRotation(rotation) {
+    if (!(0, _ui_utils.isValidRotation)(rotation)) {
+      throw new Error("Invalid pages rotation angle.");
+    }
+
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (this._pagesRotation === rotation) {
+      return;
+    }
+
+    this._pagesRotation = rotation;
+    const pageNumber = this._currentPageNumber;
+
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      const pageView = this._pages[i];
+      pageView.update(pageView.scale, rotation);
+    }
+
+    if (this._currentScaleValue) {
+      this._setScale(this._currentScaleValue, true);
+    }
+
+    this.eventBus.dispatch("rotationchanging", {
+      source: this,
+      pagesRotation: rotation,
+      pageNumber
+    });
+
+    if (this.defaultRenderingQueue) {
+      this.update();
+    }
+  }
+
+  get firstPagePromise() {
+    return this.pdfDocument ? this._firstPageCapability.promise : null;
+  }
+
+  get onePageRendered() {
+    return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
+  }
+
+  get pagesPromise() {
+    return this.pdfDocument ? this._pagesCapability.promise : null;
+  }
+
+  get _viewerElement() {
+    throw new Error("Not implemented: _viewerElement");
+  }
+
+  _onePageRenderedOrForceFetch() {
+    if (!this.container.offsetParent || this._getVisiblePages().views.length === 0) {
+      return Promise.resolve();
+    }
+
+    return this._onePageRenderedCapability.promise;
+  }
+
+  setDocument(pdfDocument) {
+    if (this.pdfDocument) {
+      this.eventBus.dispatch("pagesdestroy", {
+        source: this
+      });
+
+      this._cancelRendering();
+
+      this._resetView();
+
+      if (this.findController) {
+        this.findController.setDocument(null);
+      }
+    }
+
+    this.pdfDocument = pdfDocument;
+
+    if (!pdfDocument) {
+      return;
+    }
+
+    const pagesCount = pdfDocument.numPages;
+    const firstPagePromise = pdfDocument.getPage(1);
+    const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
+
+    this._pagesCapability.promise.then(() => {
+      this.eventBus.dispatch("pagesloaded", {
+        source: this,
+        pagesCount
+      });
+    });
+
+    this._onBeforeDraw = evt => {
+      const pageView = this._pages[evt.pageNumber - 1];
+
+      if (!pageView) {
+        return;
+      }
+
+      this._buffer.push(pageView);
+    };
+
+    this.eventBus._on("pagerender", this._onBeforeDraw);
+
+    this._onAfterDraw = evt => {
+      if (evt.cssTransform || this._onePageRenderedCapability.settled) {
+        return;
+      }
+
+      this._onePageRenderedCapability.resolve();
+
+      this.eventBus._off("pagerendered", this._onAfterDraw);
+
+      this._onAfterDraw = null;
+    };
+
+    this.eventBus._on("pagerendered", this._onAfterDraw);
+
+    firstPagePromise.then(firstPdfPage => {
+      this._firstPageCapability.resolve(firstPdfPage);
+
+      this._optionalContentConfigPromise = optionalContentConfigPromise;
+      const scale = this.currentScale;
+      const viewport = firstPdfPage.getViewport({
+        scale: scale * _ui_utils.CSS_UNITS
+      });
+      const textLayerFactory = this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE ? this : null;
+
+      for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+        const pageView = new _pdf_page_view.PDFPageView({
+          container: this._viewerElement,
+          eventBus: this.eventBus,
+          id: pageNum,
+          scale,
+          defaultViewport: viewport.clone(),
+          optionalContentConfigPromise,
+          renderingQueue: this.renderingQueue,
+          textLayerFactory,
+          textLayerMode: this.textLayerMode,
+          annotationLayerFactory: this,
+          imageResourcesPath: this.imageResourcesPath,
+          renderInteractiveForms: this.renderInteractiveForms,
+          renderer: this.renderer,
+          enableWebGL: this.enableWebGL,
+          useOnlyCssZoom: this.useOnlyCssZoom,
+          maxCanvasPixels: this.maxCanvasPixels,
+          l10n: this.l10n,
+          enableScripting: this.enableScripting
+        });
+
+        this._pages.push(pageView);
+      }
+
+      const firstPageView = this._pages[0];
+
+      if (firstPageView) {
+        firstPageView.setPdfPage(firstPdfPage);
+        this.linkService.cachePageRef(1, firstPdfPage.ref);
+      }
+
+      if (this._spreadMode !== _ui_utils.SpreadMode.NONE) {
+        this._updateSpreadMode();
+      }
+
+      this._onePageRenderedOrForceFetch().then(() => {
+        if (this.findController) {
+          this.findController.setDocument(pdfDocument);
+        }
+
+        if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
+          this._pagesCapability.resolve();
+
+          return;
+        }
+
+        let getPagesLeft = pagesCount - 1;
+
+        if (getPagesLeft <= 0) {
+          this._pagesCapability.resolve();
+
+          return;
+        }
+
+        for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
+          pdfDocument.getPage(pageNum).then(pdfPage => {
+            const pageView = this._pages[pageNum - 1];
+
+            if (!pageView.pdfPage) {
+              pageView.setPdfPage(pdfPage);
+            }
+
+            this.linkService.cachePageRef(pageNum, pdfPage.ref);
+
+            if (--getPagesLeft === 0) {
+              this._pagesCapability.resolve();
+            }
+          }, reason => {
+            console.error(`Unable to get page ${pageNum} to initialize viewer`, reason);
+
+            if (--getPagesLeft === 0) {
+              this._pagesCapability.resolve();
+            }
+          });
+        }
+      });
+
+      this.eventBus.dispatch("pagesinit", {
+        source: this
+      });
+
+      if (this.defaultRenderingQueue) {
+        this.update();
+      }
+    }).catch(reason => {
+      console.error("Unable to initialize viewer", reason);
+    });
+  }
+
+  setPageLabels(labels) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (!labels) {
+      this._pageLabels = null;
+    } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
+      this._pageLabels = null;
+      console.error(`${this._name}.setPageLabels: Invalid page labels.`);
+    } else {
+      this._pageLabels = labels;
+    }
+
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      const pageView = this._pages[i];
+      const label = this._pageLabels && this._pageLabels[i];
+      pageView.setPageLabel(label);
+    }
+  }
+
+  _resetView() {
+    this._pages = [];
+    this._currentPageNumber = 1;
+    this._currentScale = _ui_utils.UNKNOWN_SCALE;
+    this._currentScaleValue = null;
+    this._pageLabels = null;
+    this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
+    this._location = null;
+    this._pagesRotation = 0;
+    this._optionalContentConfigPromise = null;
+    this._pagesRequests = new WeakMap();
+    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
+    this._spreadMode = _ui_utils.SpreadMode.NONE;
+    this._pageOpenPendingSet?.clear();
+
+    if (this._onBeforeDraw) {
+      this.eventBus._off("pagerender", this._onBeforeDraw);
+
+      this._onBeforeDraw = null;
+    }
+
+    if (this._onAfterDraw) {
+      this.eventBus._off("pagerendered", this._onAfterDraw);
+
+      this._onAfterDraw = null;
+    }
+
+    this.viewer.textContent = "";
+
+    this._updateScrollMode();
+  }
+
+  _scrollUpdate() {
+    if (this.pagesCount === 0) {
+      return;
+    }
+
+    this.update();
+  }
+
+  _scrollIntoView({
+    pageDiv,
+    pageSpot = null,
+    pageNumber = null
+  }) {
+    (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
+  }
+
+  _setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {
+    this._currentScaleValue = newValue.toString();
+
+    if (isSameScale(this._currentScale, newScale)) {
+      if (preset) {
+        this.eventBus.dispatch("scalechanging", {
+          source: this,
+          scale: newScale,
+          presetValue: newValue
+        });
+      }
+
+      return;
+    }
+
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      this._pages[i].update(newScale);
+    }
+
+    this._currentScale = newScale;
+
+    if (!noScroll) {
+      let page = this._currentPageNumber,
+          dest;
+
+      if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
+        page = this._location.pageNumber;
+        dest = [null, {
+          name: "XYZ"
+        }, this._location.left, this._location.top, null];
+      }
+
+      this.scrollPageIntoView({
+        pageNumber: page,
+        destArray: dest,
+        allowNegativeOffset: true
+      });
+    }
+
+    this.eventBus.dispatch("scalechanging", {
+      source: this,
+      scale: newScale,
+      presetValue: preset ? newValue : undefined
+    });
+
+    if (this.defaultRenderingQueue) {
+      this.update();
+    }
+  }
+
+  get _pageWidthScaleFactor() {
+    if (this.spreadMode !== _ui_utils.SpreadMode.NONE && this.scrollMode !== _ui_utils.ScrollMode.HORIZONTAL && !this.isInPresentationMode) {
+      return 2;
+    }
+
+    return 1;
+  }
+
+  _setScale(value, noScroll = false) {
+    let scale = parseFloat(value);
+
+    if (scale > 0) {
+      this._setScaleUpdatePages(scale, value, noScroll, false);
+    } else {
+      const currentPage = this._pages[this._currentPageNumber - 1];
+
+      if (!currentPage) {
+        return;
+      }
+
+      const noPadding = this.isInPresentationMode || this.removePageBorders;
+      let hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING;
+      let vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING;
+
+      if (!noPadding && this._isScrollModeHorizontal) {
+        [hPadding, vPadding] = [vPadding, hPadding];
+      }
+
+      const pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale / this._pageWidthScaleFactor;
+      const pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
+
+      switch (value) {
+        case "page-actual":
+          scale = 1;
+          break;
+
+        case "page-width":
+          scale = pageWidthScale;
+          break;
+
+        case "page-height":
+          scale = pageHeightScale;
+          break;
+
+        case "page-fit":
+          scale = Math.min(pageWidthScale, pageHeightScale);
+          break;
+
+        case "auto":
+          const horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
+          scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
+          break;
+
+        default:
+          console.error(`${this._name}._setScale: "${value}" is an unknown zoom value.`);
+          return;
+      }
+
+      this._setScaleUpdatePages(scale, value, noScroll, true);
+    }
+  }
+
+  _resetCurrentPageView() {
+    if (this.isInPresentationMode) {
+      this._setScale(this._currentScaleValue, true);
+    }
+
+    const pageView = this._pages[this._currentPageNumber - 1];
+
+    this._scrollIntoView({
+      pageDiv: pageView.div
+    });
+  }
+
+  pageLabelToPageNumber(label) {
+    if (!this._pageLabels) {
+      return null;
+    }
+
+    const i = this._pageLabels.indexOf(label);
+
+    if (i < 0) {
+      return null;
+    }
+
+    return i + 1;
+  }
+
+  scrollPageIntoView({
+    pageNumber,
+    destArray = null,
+    allowNegativeOffset = false,
+    ignoreDestinationZoom = false
+  }) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    const pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
+
+    if (!pageView) {
+      console.error(`${this._name}.scrollPageIntoView: ` + `"${pageNumber}" is not a valid pageNumber parameter.`);
+      return;
+    }
+
+    if (this.isInPresentationMode || !destArray) {
+      this._setCurrentPageNumber(pageNumber, true);
+
+      return;
+    }
+
+    let x = 0,
+        y = 0;
+    let width = 0,
+        height = 0,
+        widthScale,
+        heightScale;
+    const changeOrientation = pageView.rotation % 180 !== 0;
+    const pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS;
+    const pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS;
+    let scale = 0;
+
+    switch (destArray[1].name) {
+      case "XYZ":
+        x = destArray[2];
+        y = destArray[3];
+        scale = destArray[4];
+        x = x !== null ? x : 0;
+        y = y !== null ? y : pageHeight;
+        break;
+
+      case "Fit":
+      case "FitB":
+        scale = "page-fit";
+        break;
+
+      case "FitH":
+      case "FitBH":
+        y = destArray[2];
+        scale = "page-width";
+
+        if (y === null && this._location) {
+          x = this._location.left;
+          y = this._location.top;
+        } else if (typeof y !== "number") {
+          y = pageHeight;
+        }
+
+        break;
+
+      case "FitV":
+      case "FitBV":
+        x = destArray[2];
+        width = pageWidth;
+        height = pageHeight;
+        scale = "page-height";
+        break;
+
+      case "FitR":
+        x = destArray[2];
+        y = destArray[3];
+        width = destArray[4] - x;
+        height = destArray[5] - y;
+        const hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
+        const vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
+        widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS;
+        heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS;
+        scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
+        break;
+
+      default:
+        console.error(`${this._name}.scrollPageIntoView: ` + `"${destArray[1].name}" is not a valid destination type.`);
+        return;
+    }
+
+    if (!ignoreDestinationZoom) {
+      if (scale && scale !== this._currentScale) {
+        this.currentScaleValue = scale;
+      } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
+        this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+      }
+    }
+
+    if (scale === "page-fit" && !destArray[4]) {
+      this._scrollIntoView({
+        pageDiv: pageView.div,
+        pageNumber
+      });
+
+      return;
+    }
+
+    const boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
+    let left = Math.min(boundingRect[0][0], boundingRect[1][0]);
+    let top = Math.min(boundingRect[0][1], boundingRect[1][1]);
+
+    if (!allowNegativeOffset) {
+      left = Math.max(left, 0);
+      top = Math.max(top, 0);
+    }
+
+    this._scrollIntoView({
+      pageDiv: pageView.div,
+      pageSpot: {
+        left,
+        top
+      },
+      pageNumber
+    });
+  }
+
+  _updateLocation(firstPage) {
+    const currentScale = this._currentScale;
+    const currentScaleValue = this._currentScaleValue;
+    const normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
+    const pageNumber = firstPage.id;
+    let pdfOpenParams = "#page=" + pageNumber;
+    pdfOpenParams += "&zoom=" + normalizedScaleValue;
+    const currentPageView = this._pages[pageNumber - 1];
+    const container = this.container;
+    const topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
+    const intLeft = Math.round(topLeft[0]);
+    const intTop = Math.round(topLeft[1]);
+    pdfOpenParams += "," + intLeft + "," + intTop;
+    this._location = {
+      pageNumber,
+      scale: normalizedScaleValue,
+      top: intTop,
+      left: intLeft,
+      rotation: this._pagesRotation,
+      pdfOpenParams
+    };
+  }
+
+  _updateHelper(visiblePages) {
+    throw new Error("Not implemented: _updateHelper");
+  }
+
+  update() {
+    const visible = this._getVisiblePages();
+
+    const visiblePages = visible.views,
+          numVisiblePages = visiblePages.length;
+
+    if (numVisiblePages === 0) {
+      return;
+    }
+
+    const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
+
+    this._buffer.resize(newCacheSize, visiblePages);
+
+    this.renderingQueue.renderHighestPriority(visible);
+
+    this._updateHelper(visiblePages);
+
+    this._updateLocation(visible.first);
+
+    this.eventBus.dispatch("updateviewarea", {
+      source: this,
+      location: this._location
+    });
+  }
+
+  containsElement(element) {
+    return this.container.contains(element);
+  }
+
+  focus() {
+    this.container.focus();
+  }
+
+  get _isScrollModeHorizontal() {
+    return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL;
+  }
+
+  get _isContainerRtl() {
+    return getComputedStyle(this.container).direction === "rtl";
+  }
+
+  get isInPresentationMode() {
+    return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
+  }
+
+  get isChangingPresentationMode() {
+    return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
+  }
+
+  get isHorizontalScrollbarEnabled() {
+    return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
+  }
+
+  get isVerticalScrollbarEnabled() {
+    return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
+  }
+
+  _getCurrentVisiblePage() {
+    if (!this.pagesCount) {
+      return {
+        views: []
+      };
+    }
+
+    const pageView = this._pages[this._currentPageNumber - 1];
+    const element = pageView.div;
+    const view = {
+      id: pageView.id,
+      x: element.offsetLeft + element.clientLeft,
+      y: element.offsetTop + element.clientTop,
+      view: pageView
+    };
+    return {
+      first: view,
+      last: view,
+      views: [view]
+    };
+  }
+
+  _getVisiblePages() {
+    return (0, _ui_utils.getVisibleElements)({
+      scrollEl: this.container,
+      views: this._pages,
+      sortByVisibility: true,
+      horizontal: this._isScrollModeHorizontal,
+      rtl: this._isScrollModeHorizontal && this._isContainerRtl
+    });
+  }
+
+  isPageVisible(pageNumber) {
+    if (!this.pdfDocument) {
+      return false;
+    }
+
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`${this._name}.isPageVisible: "${pageNumber}" is not a valid page.`);
+      return false;
+    }
+
+    return this._getVisiblePages().views.some(function (view) {
+      return view.id === pageNumber;
+    });
+  }
+
+  isPageCached(pageNumber) {
+    if (!this.pdfDocument || !this._buffer) {
+      return false;
+    }
+
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`${this._name}.isPageCached: "${pageNumber}" is not a valid page.`);
+      return false;
+    }
+
+    const pageView = this._pages[pageNumber - 1];
+
+    if (!pageView) {
+      return false;
+    }
+
+    return this._buffer.has(pageView);
+  }
+
+  cleanup() {
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
+        this._pages[i].reset();
+      }
+    }
+  }
+
+  _cancelRendering() {
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      if (this._pages[i]) {
+        this._pages[i].cancelRendering();
+      }
+    }
+  }
+
+  _ensurePdfPageLoaded(pageView) {
+    if (pageView.pdfPage) {
+      return Promise.resolve(pageView.pdfPage);
+    }
+
+    if (this._pagesRequests.has(pageView)) {
+      return this._pagesRequests.get(pageView);
+    }
+
+    const promise = this.pdfDocument.getPage(pageView.id).then(pdfPage => {
+      if (!pageView.pdfPage) {
+        pageView.setPdfPage(pdfPage);
+      }
+
+      this._pagesRequests.delete(pageView);
+
+      return pdfPage;
+    }).catch(reason => {
+      console.error("Unable to get page for page view", reason);
+
+      this._pagesRequests.delete(pageView);
+    });
+
+    this._pagesRequests.set(pageView, promise);
+
+    return promise;
+  }
+
+  forceRendering(currentlyVisiblePages) {
+    const visiblePages = currentlyVisiblePages || this._getVisiblePages();
+
+    const scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down;
+    const pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead);
+
+    if (pageView) {
+      this._ensurePdfPageLoaded(pageView).then(() => {
+        this.renderingQueue.renderView(pageView);
+      });
+
+      return true;
+    }
+
+    return false;
+  }
+
+  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
+    return new _text_layer_builder.TextLayerBuilder({
+      textLayerDiv,
+      eventBus,
+      pageIndex,
+      viewport,
+      findController: this.isInPresentationMode ? null : this.findController,
+      enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
+    });
+  }
+
+  createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderInteractiveForms = false, l10n = _ui_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null) {
+    return new _annotation_layer_builder.AnnotationLayerBuilder({
+      pageDiv,
+      pdfPage,
+      annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage,
+      imageResourcesPath,
+      renderInteractiveForms,
+      linkService: this.linkService,
+      downloadManager: this.downloadManager,
+      l10n,
+      enableScripting,
+      hasJSActionsPromise: hasJSActionsPromise || this.pdfDocument?.hasJSActions(),
+      mouseState: mouseState || this._mouseState
+    });
+  }
+
+  get hasEqualPageSizes() {
+    const firstPageView = this._pages[0];
+
+    for (let i = 1, ii = this._pages.length; i < ii; ++i) {
+      const pageView = this._pages[i];
+
+      if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  getPagesOverview() {
+    const pagesOverview = this._pages.map(function (pageView) {
+      const viewport = pageView.pdfPage.getViewport({
+        scale: 1
+      });
+      return {
+        width: viewport.width,
+        height: viewport.height,
+        rotation: viewport.rotation
+      };
+    });
+
+    if (!this.enablePrintAutoRotate) {
+      return pagesOverview;
+    }
+
+    return pagesOverview.map(function (size) {
+      if ((0, _ui_utils.isPortraitOrientation)(size)) {
+        return size;
+      }
+
+      return {
+        width: size.height,
+        height: size.width,
+        rotation: (size.rotation + 90) % 360
+      };
+    });
+  }
+
+  get optionalContentConfigPromise() {
+    if (!this.pdfDocument) {
+      return Promise.resolve(null);
+    }
+
+    if (!this._optionalContentConfigPromise) {
+      return this.pdfDocument.getOptionalContentConfig();
+    }
+
+    return this._optionalContentConfigPromise;
+  }
+
+  set optionalContentConfigPromise(promise) {
+    if (!(promise instanceof Promise)) {
+      throw new Error(`Invalid optionalContentConfigPromise: ${promise}`);
+    }
+
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    if (!this._optionalContentConfigPromise) {
+      return;
+    }
+
+    this._optionalContentConfigPromise = promise;
+
+    for (const pageView of this._pages) {
+      pageView.update(pageView.scale, pageView.rotation, promise);
+    }
+
+    this.update();
+    this.eventBus.dispatch("optionalcontentconfigchanged", {
+      source: this,
+      promise
+    });
+  }
+
+  get scrollMode() {
+    return this._scrollMode;
+  }
+
+  set scrollMode(mode) {
+    if (this._scrollMode === mode) {
+      return;
+    }
+
+    if (!(0, _ui_utils.isValidScrollMode)(mode)) {
+      throw new Error(`Invalid scroll mode: ${mode}`);
+    }
+
+    this._scrollMode = mode;
+    this.eventBus.dispatch("scrollmodechanged", {
+      source: this,
+      mode
+    });
+
+    this._updateScrollMode(this._currentPageNumber);
+  }
+
+  _updateScrollMode(pageNumber = null) {
+    const scrollMode = this._scrollMode,
+          viewer = this.viewer;
+    viewer.classList.toggle("scrollHorizontal", scrollMode === _ui_utils.ScrollMode.HORIZONTAL);
+    viewer.classList.toggle("scrollWrapped", scrollMode === _ui_utils.ScrollMode.WRAPPED);
+
+    if (!this.pdfDocument || !pageNumber) {
+      return;
+    }
+
+    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+      this._setScale(this._currentScaleValue, true);
+    }
+
+    this._setCurrentPageNumber(pageNumber, true);
+
+    this.update();
+  }
+
+  get spreadMode() {
+    return this._spreadMode;
+  }
+
+  set spreadMode(mode) {
+    if (this._spreadMode === mode) {
+      return;
+    }
+
+    if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
+      throw new Error(`Invalid spread mode: ${mode}`);
+    }
+
+    this._spreadMode = mode;
+    this.eventBus.dispatch("spreadmodechanged", {
+      source: this,
+      mode
+    });
+
+    this._updateSpreadMode(this._currentPageNumber);
+  }
+
+  _updateSpreadMode(pageNumber = null) {
+    if (!this.pdfDocument) {
+      return;
+    }
+
+    const viewer = this.viewer,
+          pages = this._pages;
+    viewer.textContent = "";
+
+    if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
+      for (let i = 0, iMax = pages.length; i < iMax; ++i) {
+        viewer.appendChild(pages[i].div);
+      }
+    } else {
+      const parity = this._spreadMode - 1;
+      let spread = null;
+
+      for (let i = 0, iMax = pages.length; i < iMax; ++i) {
+        if (spread === null) {
+          spread = document.createElement("div");
+          spread.className = "spread";
+          viewer.appendChild(spread);
+        } else if (i % 2 === parity) {
+          spread = spread.cloneNode(false);
+          viewer.appendChild(spread);
+        }
+
+        spread.appendChild(pages[i].div);
+      }
+    }
+
+    if (!pageNumber) {
+      return;
+    }
+
+    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+      this._setScale(this._currentScaleValue, true);
+    }
+
+    this._setCurrentPageNumber(pageNumber, true);
+
+    this.update();
+  }
+
+  _initializeScriptingEvents() {
+    if (!this.enableScripting) {
+      return;
+    }
+
+    const eventBus = this.eventBus,
+          pageOpenPendingSet = this._pageOpenPendingSet || (this._pageOpenPendingSet = new Set());
+
+    const dispatchPageClose = pageNumber => {
+      if (pageOpenPendingSet.has(pageNumber)) {
+        return;
+      }
+
+      eventBus.dispatch("pageclose", {
+        source: this,
+        pageNumber
+      });
+    };
+
+    const dispatchPageOpen = (pageNumber, force = false) => {
+      const pageView = this._pages[pageNumber - 1];
+
+      if (force || pageView?.renderingState === _pdf_rendering_queue.RenderingStates.FINISHED) {
+        pageOpenPendingSet.delete(pageNumber);
+        eventBus.dispatch("pageopen", {
+          source: this,
+          pageNumber
+        });
+      } else {
+        pageOpenPendingSet.add(pageNumber);
+      }
+    };
+
+    eventBus._on("pagechanging", ({
+      pageNumber,
+      previous
+    }) => {
+      if (pageNumber === previous) {
+        return;
+      }
+
+      dispatchPageClose(previous);
+      dispatchPageOpen(pageNumber);
+    });
+
+    eventBus._on("pagerendered", ({
+      pageNumber
+    }) => {
+      if (!pageOpenPendingSet.has(pageNumber)) {
+        return;
+      }
+
+      if (pageNumber !== this._currentPageNumber) {
+        return;
+      }
+
+      dispatchPageOpen(pageNumber, true);
+    });
+
+    eventBus._on("pagesinit", () => {
+      dispatchPageOpen(this._currentPageNumber);
+    });
+
+    eventBus._on("pagesdestroy", () => {
+      dispatchPageClose(this._currentPageNumber);
+    });
+  }
+
+}
+
+exports.BaseViewer = BaseViewer;
+
+/***/ }),
+/* 28 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.DefaultAnnotationLayerFactory = exports.AnnotationLayerBuilder = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdf_link_service = __webpack_require__(19);
+
+class AnnotationLayerBuilder {
+  constructor({
+    pageDiv,
+    pdfPage,
+    linkService,
+    downloadManager,
+    annotationStorage = null,
+    imageResourcesPath = "",
+    renderInteractiveForms = true,
+    l10n = _ui_utils.NullL10n,
+    enableScripting = false,
+    hasJSActionsPromise = null,
+    mouseState = null
+  }) {
+    this.pageDiv = pageDiv;
+    this.pdfPage = pdfPage;
+    this.linkService = linkService;
+    this.downloadManager = downloadManager;
+    this.imageResourcesPath = imageResourcesPath;
+    this.renderInteractiveForms = renderInteractiveForms;
+    this.l10n = l10n;
+    this.annotationStorage = annotationStorage;
+    this.enableScripting = enableScripting;
+    this._hasJSActionsPromise = hasJSActionsPromise;
+    this._mouseState = mouseState;
+    this.div = null;
+    this._cancelled = false;
+  }
+
+  render(viewport, intent = "display") {
+    return Promise.all([this.pdfPage.getAnnotations({
+      intent
+    }), this._hasJSActionsPromise]).then(([annotations, hasJSActions = false]) => {
+      if (this._cancelled) {
+        return;
+      }
+
+      if (annotations.length === 0) {
+        return;
+      }
+
+      const parameters = {
+        viewport: viewport.clone({
+          dontFlip: true
+        }),
+        div: this.div,
+        annotations,
+        page: this.pdfPage,
+        imageResourcesPath: this.imageResourcesPath,
+        renderInteractiveForms: this.renderInteractiveForms,
+        linkService: this.linkService,
+        downloadManager: this.downloadManager,
+        annotationStorage: this.annotationStorage,
+        enableScripting: this.enableScripting,
+        hasJSActions,
+        mouseState: this._mouseState
+      };
+
+      if (this.div) {
+        _pdfjsLib.AnnotationLayer.update(parameters);
+      } else {
+        this.div = document.createElement("div");
+        this.div.className = "annotationLayer";
+        this.pageDiv.appendChild(this.div);
+        parameters.div = this.div;
+
+        _pdfjsLib.AnnotationLayer.render(parameters);
+
+        this.l10n.translate(this.div);
+      }
+    });
+  }
+
+  cancel() {
+    this._cancelled = true;
+  }
+
+  hide() {
+    if (!this.div) {
+      return;
+    }
+
+    this.div.setAttribute("hidden", "true");
+  }
+
+}
+
+exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
+
+class DefaultAnnotationLayerFactory {
+  createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderInteractiveForms = true, l10n = _ui_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null) {
+    return new AnnotationLayerBuilder({
+      pageDiv,
+      pdfPage,
+      imageResourcesPath,
+      renderInteractiveForms,
+      linkService: new _pdf_link_service.SimpleLinkService(),
+      l10n,
+      annotationStorage,
+      enableScripting,
+      hasJSActionsPromise,
+      mouseState
+    });
+  }
+
+}
+
+exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
+
+/***/ }),
+/* 29 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFPageView = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _pdf_rendering_queue = __webpack_require__(8);
+
+var _viewer_compatibility = __webpack_require__(2);
+
+const MAX_CANVAS_PIXELS = _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels || 16777216;
+
+class PDFPageView {
+  constructor(options) {
+    const container = options.container;
+    const defaultViewport = options.defaultViewport;
+    this.id = options.id;
+    this.renderingId = "page" + this.id;
+    this.pdfPage = null;
+    this.pageLabel = null;
+    this.rotation = 0;
+    this.scale = options.scale || _ui_utils.DEFAULT_SCALE;
+    this.viewport = defaultViewport;
+    this.pdfPageRotate = defaultViewport.rotation;
+    this._optionalContentConfigPromise = options.optionalContentConfigPromise || null;
+    this.hasRestrictedScaling = false;
+    this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE;
+    this.imageResourcesPath = options.imageResourcesPath || "";
+    this.renderInteractiveForms = typeof options.renderInteractiveForms === "boolean" ? options.renderInteractiveForms : true;
+    this.useOnlyCssZoom = options.useOnlyCssZoom || false;
+    this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS;
+    this.eventBus = options.eventBus;
+    this.renderingQueue = options.renderingQueue;
+    this.textLayerFactory = options.textLayerFactory;
+    this.annotationLayerFactory = options.annotationLayerFactory;
+    this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
+    this.enableWebGL = options.enableWebGL || false;
+    this.l10n = options.l10n || _ui_utils.NullL10n;
+    this.enableScripting = options.enableScripting || false;
+    this.paintTask = null;
+    this.paintedViewportMap = new WeakMap();
+    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+    this.resume = null;
+    this._renderError = null;
+    this.annotationLayer = null;
+    this.textLayer = null;
+    this.zoomLayer = null;
+    const div = document.createElement("div");
+    div.className = "page";
+    div.style.width = Math.floor(this.viewport.width) + "px";
+    div.style.height = Math.floor(this.viewport.height) + "px";
+    div.setAttribute("data-page-number", this.id);
+    this.div = div;
+    container.appendChild(div);
+  }
+
+  setPdfPage(pdfPage) {
+    this.pdfPage = pdfPage;
+    this.pdfPageRotate = pdfPage.rotate;
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = pdfPage.getViewport({
+      scale: this.scale * _ui_utils.CSS_UNITS,
+      rotation: totalRotation
+    });
+    this.reset();
+  }
+
+  destroy() {
+    this.reset();
+
+    if (this.pdfPage) {
+      this.pdfPage.cleanup();
+    }
+  }
+
+  async _renderAnnotationLayer() {
+    let error = null;
+
+    try {
+      await this.annotationLayer.render(this.viewport, "display");
+    } catch (ex) {
+      error = ex;
+    } finally {
+      this.eventBus.dispatch("annotationlayerrendered", {
+        source: this,
+        pageNumber: this.id,
+        error
+      });
+    }
+  }
+
+  _resetZoomLayer(removeFromDOM = false) {
+    if (!this.zoomLayer) {
+      return;
+    }
+
+    const zoomLayerCanvas = this.zoomLayer.firstChild;
+    this.paintedViewportMap.delete(zoomLayerCanvas);
+    zoomLayerCanvas.width = 0;
+    zoomLayerCanvas.height = 0;
+
+    if (removeFromDOM) {
+      this.zoomLayer.remove();
+    }
+
+    this.zoomLayer = null;
+  }
+
+  reset(keepZoomLayer = false, keepAnnotations = false) {
+    this.cancelRendering(keepAnnotations);
+    this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
+    const div = this.div;
+    div.style.width = Math.floor(this.viewport.width) + "px";
+    div.style.height = Math.floor(this.viewport.height) + "px";
+    const childNodes = div.childNodes;
+    const currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null;
+    const currentAnnotationNode = keepAnnotations && this.annotationLayer && this.annotationLayer.div || null;
+
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      const node = childNodes[i];
+
+      if (currentZoomLayerNode === node || currentAnnotationNode === node) {
+        continue;
+      }
+
+      div.removeChild(node);
+    }
+
+    div.removeAttribute("data-loaded");
+
+    if (currentAnnotationNode) {
+      this.annotationLayer.hide();
+    } else if (this.annotationLayer) {
+      this.annotationLayer.cancel();
+      this.annotationLayer = null;
+    }
+
+    if (!currentZoomLayerNode) {
+      if (this.canvas) {
+        this.paintedViewportMap.delete(this.canvas);
+        this.canvas.width = 0;
+        this.canvas.height = 0;
+        delete this.canvas;
+      }
+
+      this._resetZoomLayer();
+    }
+
+    if (this.svg) {
+      this.paintedViewportMap.delete(this.svg);
+      delete this.svg;
+    }
+
+    this.loadingIconDiv = document.createElement("div");
+    this.loadingIconDiv.className = "loadingIcon";
+    div.appendChild(this.loadingIconDiv);
+  }
+
+  update(scale, rotation, optionalContentConfigPromise = null) {
+    this.scale = scale || this.scale;
+
+    if (typeof rotation !== "undefined") {
+      this.rotation = rotation;
+    }
+
+    if (optionalContentConfigPromise instanceof Promise) {
+      this._optionalContentConfigPromise = optionalContentConfigPromise;
+    }
+
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = this.viewport.clone({
+      scale: this.scale * _ui_utils.CSS_UNITS,
+      rotation: totalRotation
+    });
+
+    if (this.svg) {
+      this.cssTransform(this.svg, true);
+      this.eventBus.dispatch("pagerendered", {
+        source: this,
+        pageNumber: this.id,
+        cssTransform: true,
+        timestamp: performance.now(),
+        error: this._renderError
+      });
+      return;
+    }
+
+    let isScalingRestricted = false;
+
+    if (this.canvas && this.maxCanvasPixels > 0) {
+      const outputScale = this.outputScale;
+
+      if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
+        isScalingRestricted = true;
+      }
+    }
+
+    if (this.canvas) {
+      if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
+        this.cssTransform(this.canvas, true);
+        this.eventBus.dispatch("pagerendered", {
+          source: this,
+          pageNumber: this.id,
+          cssTransform: true,
+          timestamp: performance.now(),
+          error: this._renderError
+        });
+        return;
+      }
+
+      if (!this.zoomLayer && !this.canvas.hasAttribute("hidden")) {
+        this.zoomLayer = this.canvas.parentNode;
+        this.zoomLayer.style.position = "absolute";
+      }
+    }
+
+    if (this.zoomLayer) {
+      this.cssTransform(this.zoomLayer.firstChild);
+    }
+
+    this.reset(true, true);
+  }
+
+  cancelRendering(keepAnnotations = false) {
+    if (this.paintTask) {
+      this.paintTask.cancel();
+      this.paintTask = null;
+    }
+
+    this.resume = null;
+
+    if (this.textLayer) {
+      this.textLayer.cancel();
+      this.textLayer = null;
+    }
+
+    if (!keepAnnotations && this.annotationLayer) {
+      this.annotationLayer.cancel();
+      this.annotationLayer = null;
+    }
+  }
+
+  cssTransform(target, redrawAnnotations = false) {
+    const width = this.viewport.width;
+    const height = this.viewport.height;
+    const div = this.div;
+    target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + "px";
+    target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + "px";
+    const relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation;
+    const absRotation = Math.abs(relativeRotation);
+    let scaleX = 1,
+        scaleY = 1;
+
+    if (absRotation === 90 || absRotation === 270) {
+      scaleX = height / width;
+      scaleY = width / height;
+    }
+
+    target.style.transform = `rotate(${relativeRotation}deg) scale(${scaleX}, ${scaleY})`;
+
+    if (this.textLayer) {
+      const textLayerViewport = this.textLayer.viewport;
+      const textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
+      const textAbsRotation = Math.abs(textRelativeRotation);
+      let scale = width / textLayerViewport.width;
+
+      if (textAbsRotation === 90 || textAbsRotation === 270) {
+        scale = width / textLayerViewport.height;
+      }
+
+      const textLayerDiv = this.textLayer.textLayerDiv;
+      let transX, transY;
+
+      switch (textAbsRotation) {
+        case 0:
+          transX = transY = 0;
+          break;
+
+        case 90:
+          transX = 0;
+          transY = "-" + textLayerDiv.style.height;
+          break;
+
+        case 180:
+          transX = "-" + textLayerDiv.style.width;
+          transY = "-" + textLayerDiv.style.height;
+          break;
+
+        case 270:
+          transX = "-" + textLayerDiv.style.width;
+          transY = 0;
+          break;
+
+        default:
+          console.error("Bad rotation value.");
+          break;
+      }
+
+      textLayerDiv.style.transform = `rotate(${textAbsRotation}deg) ` + `scale(${scale}) ` + `translate(${transX}, ${transY})`;
+      textLayerDiv.style.transformOrigin = "0% 0%";
+    }
+
+    if (redrawAnnotations && this.annotationLayer) {
+      this._renderAnnotationLayer();
+    }
+  }
+
+  get width() {
+    return this.viewport.width;
+  }
+
+  get height() {
+    return this.viewport.height;
+  }
+
+  getPagePoint(x, y) {
+    return this.viewport.convertToPdfPoint(x, y);
+  }
+
+  draw() {
+    if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
+      console.error("Must be in new state before drawing");
+      this.reset();
+    }
+
+    const {
+      div,
+      pdfPage
+    } = this;
+
+    if (!pdfPage) {
+      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+
+      if (this.loadingIconDiv) {
+        div.removeChild(this.loadingIconDiv);
+        delete this.loadingIconDiv;
+      }
+
+      return Promise.reject(new Error("pdfPage is not loaded"));
+    }
+
+    this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+    const canvasWrapper = document.createElement("div");
+    canvasWrapper.style.width = div.style.width;
+    canvasWrapper.style.height = div.style.height;
+    canvasWrapper.classList.add("canvasWrapper");
+
+    if (this.annotationLayer && this.annotationLayer.div) {
+      div.insertBefore(canvasWrapper, this.annotationLayer.div);
+    } else {
+      div.appendChild(canvasWrapper);
+    }
+
+    let textLayer = null;
+
+    if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
+      const textLayerDiv = document.createElement("div");
+      textLayerDiv.className = "textLayer";
+      textLayerDiv.style.width = canvasWrapper.style.width;
+      textLayerDiv.style.height = canvasWrapper.style.height;
+
+      if (this.annotationLayer && this.annotationLayer.div) {
+        div.insertBefore(textLayerDiv, this.annotationLayer.div);
+      } else {
+        div.appendChild(textLayerDiv);
+      }
+
+      textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus);
+    }
+
+    this.textLayer = textLayer;
+    let renderContinueCallback = null;
+
+    if (this.renderingQueue) {
+      renderContinueCallback = cont => {
+        if (!this.renderingQueue.isHighestPriority(this)) {
+          this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
+
+          this.resume = () => {
+            this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
+            cont();
+          };
+
+          return;
+        }
+
+        cont();
+      };
+    }
+
+    const finishPaintTask = async (error = null) => {
+      if (paintTask === this.paintTask) {
+        this.paintTask = null;
+      }
+
+      if (error instanceof _pdfjsLib.RenderingCancelledException) {
+        this._renderError = null;
+        return;
+      }
+
+      this._renderError = error;
+      this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
+
+      if (this.loadingIconDiv) {
+        div.removeChild(this.loadingIconDiv);
+        delete this.loadingIconDiv;
+      }
+
+      this._resetZoomLayer(true);
+
+      this.eventBus.dispatch("pagerendered", {
+        source: this,
+        pageNumber: this.id,
+        cssTransform: false,
+        timestamp: performance.now(),
+        error: this._renderError
+      });
+
+      if (error) {
+        throw error;
+      }
+    };
+
+    const paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
+    paintTask.onRenderContinue = renderContinueCallback;
+    this.paintTask = paintTask;
+    const resultPromise = paintTask.promise.then(function () {
+      return finishPaintTask(null).then(function () {
+        if (textLayer) {
+          const readableStream = pdfPage.streamTextContent({
+            normalizeWhitespace: true
+          });
+          textLayer.setTextContentStream(readableStream);
+          textLayer.render();
+        }
+      });
+    }, function (reason) {
+      return finishPaintTask(reason);
+    });
+
+    if (this.annotationLayerFactory) {
+      if (!this.annotationLayer) {
+        this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, null, this.imageResourcesPath, this.renderInteractiveForms, this.l10n, this.enableScripting, null, null);
+      }
+
+      this._renderAnnotationLayer();
+    }
+
+    div.setAttribute("data-loaded", true);
+    this.eventBus.dispatch("pagerender", {
+      source: this,
+      pageNumber: this.id
+    });
+    return resultPromise;
+  }
+
+  paintOnCanvas(canvasWrapper) {
+    const renderCapability = (0, _pdfjsLib.createPromiseCapability)();
+    const result = {
+      promise: renderCapability.promise,
+
+      onRenderContinue(cont) {
+        cont();
+      },
+
+      cancel() {
+        renderTask.cancel();
+      }
+
+    };
+    const viewport = this.viewport;
+    const canvas = document.createElement("canvas");
+    this.l10n.get("page_canvas", {
+      page: this.id
+    }, "Page {{page}}").then(msg => {
+      canvas.setAttribute("aria-label", msg);
+    });
+    canvas.setAttribute("hidden", "hidden");
+    let isCanvasHidden = true;
+
+    const showCanvas = function () {
+      if (isCanvasHidden) {
+        canvas.removeAttribute("hidden");
+        isCanvasHidden = false;
+      }
+    };
+
+    canvasWrapper.appendChild(canvas);
+    this.canvas = canvas;
+    canvas.mozOpaque = true;
+    const ctx = canvas.getContext("2d", {
+      alpha: false
+    });
+    const outputScale = (0, _ui_utils.getOutputScale)(ctx);
+    this.outputScale = outputScale;
+
+    if (this.useOnlyCssZoom) {
+      const actualSizeViewport = viewport.clone({
+        scale: _ui_utils.CSS_UNITS
+      });
+      outputScale.sx *= actualSizeViewport.width / viewport.width;
+      outputScale.sy *= actualSizeViewport.height / viewport.height;
+      outputScale.scaled = true;
+    }
+
+    if (this.maxCanvasPixels > 0) {
+      const pixelsInViewport = viewport.width * viewport.height;
+      const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);
+
+      if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
+        outputScale.sx = maxScale;
+        outputScale.sy = maxScale;
+        outputScale.scaled = true;
+        this.hasRestrictedScaling = true;
+      } else {
+        this.hasRestrictedScaling = false;
+      }
+    }
+
+    const sfx = (0, _ui_utils.approximateFraction)(outputScale.sx);
+    const sfy = (0, _ui_utils.approximateFraction)(outputScale.sy);
+    canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0]);
+    canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0]);
+    canvas.style.width = (0, _ui_utils.roundToDivide)(viewport.width, sfx[1]) + "px";
+    canvas.style.height = (0, _ui_utils.roundToDivide)(viewport.height, sfy[1]) + "px";
+    this.paintedViewportMap.set(canvas, viewport);
+    const transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0, outputScale.sy, 0, 0];
+    const renderContext = {
+      canvasContext: ctx,
+      transform,
+      viewport: this.viewport,
+      enableWebGL: this.enableWebGL,
+      renderInteractiveForms: this.renderInteractiveForms,
+      optionalContentConfigPromise: this._optionalContentConfigPromise
+    };
+    const renderTask = this.pdfPage.render(renderContext);
+
+    renderTask.onContinue = function (cont) {
+      showCanvas();
+
+      if (result.onRenderContinue) {
+        result.onRenderContinue(cont);
+      } else {
+        cont();
+      }
+    };
+
+    renderTask.promise.then(function () {
+      showCanvas();
+      renderCapability.resolve(undefined);
+    }, function (error) {
+      showCanvas();
+      renderCapability.reject(error);
+    });
+    return result;
+  }
+
+  paintOnSvg(wrapper) {
+    return {
+      promise: Promise.reject(new Error("SVG rendering is not supported.")),
+
+      onRenderContinue(cont) {},
+
+      cancel() {}
+
+    };
+  }
+
+  setPageLabel(label) {
+    this.pageLabel = typeof label === "string" ? label : null;
+
+    if (this.pageLabel !== null) {
+      this.div.setAttribute("data-page-label", this.pageLabel);
+    } else {
+      this.div.removeAttribute("data-page-label");
+    }
+  }
+
+}
+
+exports.PDFPageView = PDFPageView;
+
+/***/ }),
+/* 30 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.TextLayerBuilder = exports.DefaultTextLayerFactory = void 0;
+
+var _pdfjsLib = __webpack_require__(5);
+
+const EXPAND_DIVS_TIMEOUT = 300;
+
+class TextLayerBuilder {
+  constructor({
+    textLayerDiv,
+    eventBus,
+    pageIndex,
+    viewport,
+    findController = null,
+    enhanceTextSelection = false
+  }) {
+    this.textLayerDiv = textLayerDiv;
+    this.eventBus = eventBus;
+    this.textContent = null;
+    this.textContentItemsStr = [];
+    this.textContentStream = null;
+    this.renderingDone = false;
+    this.pageIdx = pageIndex;
+    this.pageNumber = this.pageIdx + 1;
+    this.matches = [];
+    this.viewport = viewport;
+    this.textDivs = [];
+    this.findController = findController;
+    this.textLayerRenderTask = null;
+    this.enhanceTextSelection = enhanceTextSelection;
+    this._onUpdateTextLayerMatches = null;
+
+    this._bindMouse();
+  }
+
+  _finishRendering() {
+    this.renderingDone = true;
+
+    if (!this.enhanceTextSelection) {
+      const endOfContent = document.createElement("div");
+      endOfContent.className = "endOfContent";
+      this.textLayerDiv.appendChild(endOfContent);
+    }
+
+    this.eventBus.dispatch("textlayerrendered", {
+      source: this,
+      pageNumber: this.pageNumber,
+      numTextDivs: this.textDivs.length
+    });
+  }
+
+  render(timeout = 0) {
+    if (!(this.textContent || this.textContentStream) || this.renderingDone) {
+      return;
+    }
+
+    this.cancel();
+    this.textDivs = [];
+    const textLayerFrag = document.createDocumentFragment();
+    this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
+      textContent: this.textContent,
+      textContentStream: this.textContentStream,
+      container: textLayerFrag,
+      viewport: this.viewport,
+      textDivs: this.textDivs,
+      textContentItemsStr: this.textContentItemsStr,
+      timeout,
+      enhanceTextSelection: this.enhanceTextSelection
+    });
+    this.textLayerRenderTask.promise.then(() => {
+      this.textLayerDiv.appendChild(textLayerFrag);
+
+      this._finishRendering();
+
+      this._updateMatches();
+    }, function (reason) {});
+
+    if (!this._onUpdateTextLayerMatches) {
+      this._onUpdateTextLayerMatches = evt => {
+        if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {
+          this._updateMatches();
+        }
+      };
+
+      this.eventBus._on("updatetextlayermatches", this._onUpdateTextLayerMatches);
+    }
+  }
+
+  cancel() {
+    if (this.textLayerRenderTask) {
+      this.textLayerRenderTask.cancel();
+      this.textLayerRenderTask = null;
+    }
+
+    if (this._onUpdateTextLayerMatches) {
+      this.eventBus._off("updatetextlayermatches", this._onUpdateTextLayerMatches);
+
+      this._onUpdateTextLayerMatches = null;
+    }
+  }
+
+  setTextContentStream(readableStream) {
+    this.cancel();
+    this.textContentStream = readableStream;
+  }
+
+  setTextContent(textContent) {
+    this.cancel();
+    this.textContent = textContent;
+  }
+
+  _convertMatches(matches, matchesLength) {
+    if (!matches) {
+      return [];
+    }
+
+    const {
+      findController,
+      textContentItemsStr
+    } = this;
+    let i = 0,
+        iIndex = 0;
+    const end = textContentItemsStr.length - 1;
+    const queryLen = findController.state.query.length;
+    const result = [];
+
+    for (let m = 0, mm = matches.length; m < mm; m++) {
+      let matchIdx = matches[m];
+
+      while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
+        iIndex += textContentItemsStr[i].length;
+        i++;
+      }
+
+      if (i === textContentItemsStr.length) {
+        console.error("Could not find a matching mapping");
+      }
+
+      const match = {
+        begin: {
+          divIdx: i,
+          offset: matchIdx - iIndex
+        }
+      };
+
+      if (matchesLength) {
+        matchIdx += matchesLength[m];
+      } else {
+        matchIdx += queryLen;
+      }
+
+      while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
+        iIndex += textContentItemsStr[i].length;
+        i++;
+      }
+
+      match.end = {
+        divIdx: i,
+        offset: matchIdx - iIndex
+      };
+      result.push(match);
+    }
+
+    return result;
+  }
+
+  _renderMatches(matches) {
+    if (matches.length === 0) {
+      return;
+    }
+
+    const {
+      findController,
+      pageIdx,
+      textContentItemsStr,
+      textDivs
+    } = this;
+    const isSelectedPage = pageIdx === findController.selected.pageIdx;
+    const selectedMatchIdx = findController.selected.matchIdx;
+    const highlightAll = findController.state.highlightAll;
+    let prevEnd = null;
+    const infinity = {
+      divIdx: -1,
+      offset: undefined
+    };
+
+    function beginText(begin, className) {
+      const divIdx = begin.divIdx;
+      textDivs[divIdx].textContent = "";
+      appendTextToDiv(divIdx, 0, begin.offset, className);
+    }
+
+    function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
+      const div = textDivs[divIdx];
+      const content = textContentItemsStr[divIdx].substring(fromOffset, toOffset);
+      const node = document.createTextNode(content);
+
+      if (className) {
+        const span = document.createElement("span");
+        span.className = className;
+        span.appendChild(node);
+        div.appendChild(span);
+        return;
+      }
+
+      div.appendChild(node);
+    }
+
+    let i0 = selectedMatchIdx,
+        i1 = i0 + 1;
+
+    if (highlightAll) {
+      i0 = 0;
+      i1 = matches.length;
+    } else if (!isSelectedPage) {
+      return;
+    }
+
+    for (let i = i0; i < i1; i++) {
+      const match = matches[i];
+      const begin = match.begin;
+      const end = match.end;
+      const isSelected = isSelectedPage && i === selectedMatchIdx;
+      const highlightSuffix = isSelected ? " selected" : "";
+
+      if (isSelected) {
+        findController.scrollMatchIntoView({
+          element: textDivs[begin.divIdx],
+          pageIndex: pageIdx,
+          matchIndex: selectedMatchIdx
+        });
+      }
+
+      if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
+        if (prevEnd !== null) {
+          appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+        }
+
+        beginText(begin);
+      } else {
+        appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
+      }
+
+      if (begin.divIdx === end.divIdx) {
+        appendTextToDiv(begin.divIdx, begin.offset, end.offset, "highlight" + highlightSuffix);
+      } else {
+        appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, "highlight begin" + highlightSuffix);
+
+        for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
+          textDivs[n0].className = "highlight middle" + highlightSuffix;
+        }
+
+        beginText(end, "highlight end" + highlightSuffix);
+      }
+
+      prevEnd = end;
+    }
+
+    if (prevEnd) {
+      appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+    }
+  }
+
+  _updateMatches() {
+    if (!this.renderingDone) {
+      return;
+    }
+
+    const {
+      findController,
+      matches,
+      pageIdx,
+      textContentItemsStr,
+      textDivs
+    } = this;
+    let clearedUntilDivIdx = -1;
+
+    for (let i = 0, ii = matches.length; i < ii; i++) {
+      const match = matches[i];
+      const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
+
+      for (let n = begin, end = match.end.divIdx; n <= end; n++) {
+        const div = textDivs[n];
+        div.textContent = textContentItemsStr[n];
+        div.className = "";
+      }
+
+      clearedUntilDivIdx = match.end.divIdx + 1;
+    }
+
+    if (!findController || !findController.highlightMatches) {
+      return;
+    }
+
+    const pageMatches = findController.pageMatches[pageIdx] || null;
+    const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;
+    this.matches = this._convertMatches(pageMatches, pageMatchesLength);
+
+    this._renderMatches(this.matches);
+  }
+
+  _bindMouse() {
+    const div = this.textLayerDiv;
+    let expandDivsTimer = null;
+    div.addEventListener("mousedown", evt => {
+      if (this.enhanceTextSelection && this.textLayerRenderTask) {
+        this.textLayerRenderTask.expandTextDivs(true);
+        return;
+      }
+
+      const end = div.querySelector(".endOfContent");
+
+      if (!end) {
+        return;
+      }
+
+      end.classList.add("active");
+    });
+    div.addEventListener("mouseup", () => {
+      if (this.enhanceTextSelection && this.textLayerRenderTask) {
+        this.textLayerRenderTask.expandTextDivs(false);
+        return;
+      }
+
+      const end = div.querySelector(".endOfContent");
+
+      if (!end) {
+        return;
+      }
+
+      end.classList.remove("active");
+    });
+  }
+
+}
+
+exports.TextLayerBuilder = TextLayerBuilder;
+
+class DefaultTextLayerFactory {
+  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
+    return new TextLayerBuilder({
+      textLayerDiv,
+      pageIndex,
+      viewport,
+      enhanceTextSelection,
+      eventBus
+    });
+  }
+
+}
+
+exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
+
+/***/ }),
+/* 31 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SecondaryToolbar = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+var _pdf_cursor_tools = __webpack_require__(6);
+
+var _pdf_single_page_viewer = __webpack_require__(32);
+
+class SecondaryToolbar {
+  constructor(options, mainContainer, eventBus) {
+    this.toolbar = options.toolbar;
+    this.toggleButton = options.toggleButton;
+    this.toolbarButtonContainer = options.toolbarButtonContainer;
+    this.buttons = [{
+      element: options.presentationModeButton,
+      eventName: "presentationmode",
+      close: true
+    }, {
+      element: options.openFileButton,
+      eventName: "openfile",
+      close: true
+    }, {
+      element: options.printButton,
+      eventName: "print",
+      close: true
+    }, {
+      element: options.downloadButton,
+      eventName: "download",
+      close: true
+    }, {
+      element: options.viewBookmarkButton,
+      eventName: null,
+      close: true
+    }, {
+      element: options.firstPageButton,
+      eventName: "firstpage",
+      close: true
+    }, {
+      element: options.lastPageButton,
+      eventName: "lastpage",
+      close: true
+    }, {
+      element: options.pageRotateCwButton,
+      eventName: "rotatecw",
+      close: false
+    }, {
+      element: options.pageRotateCcwButton,
+      eventName: "rotateccw",
+      close: false
+    }, {
+      element: options.cursorSelectToolButton,
+      eventName: "switchcursortool",
+      eventDetails: {
+        tool: _pdf_cursor_tools.CursorTool.SELECT
+      },
+      close: true
+    }, {
+      element: options.cursorHandToolButton,
+      eventName: "switchcursortool",
+      eventDetails: {
+        tool: _pdf_cursor_tools.CursorTool.HAND
+      },
+      close: true
+    }, {
+      element: options.scrollVerticalButton,
+      eventName: "switchscrollmode",
+      eventDetails: {
+        mode: _ui_utils.ScrollMode.VERTICAL
+      },
+      close: true
+    }, {
+      element: options.scrollHorizontalButton,
+      eventName: "switchscrollmode",
+      eventDetails: {
+        mode: _ui_utils.ScrollMode.HORIZONTAL
+      },
+      close: true
+    }, {
+      element: options.scrollWrappedButton,
+      eventName: "switchscrollmode",
+      eventDetails: {
+        mode: _ui_utils.ScrollMode.WRAPPED
+      },
+      close: true
+    }, {
+      element: options.spreadNoneButton,
+      eventName: "switchspreadmode",
+      eventDetails: {
+        mode: _ui_utils.SpreadMode.NONE
+      },
+      close: true
+    }, {
+      element: options.spreadOddButton,
+      eventName: "switchspreadmode",
+      eventDetails: {
+        mode: _ui_utils.SpreadMode.ODD
+      },
+      close: true
+    }, {
+      element: options.spreadEvenButton,
+      eventName: "switchspreadmode",
+      eventDetails: {
+        mode: _ui_utils.SpreadMode.EVEN
+      },
+      close: true
+    }, {
+      element: options.documentPropertiesButton,
+      eventName: "documentproperties",
+      close: true
+    }];
+    this.items = {
+      firstPage: options.firstPageButton,
+      lastPage: options.lastPageButton,
+      pageRotateCw: options.pageRotateCwButton,
+      pageRotateCcw: options.pageRotateCcwButton
+    };
+    this.mainContainer = mainContainer;
+    this.eventBus = eventBus;
+    this.opened = false;
+    this.containerHeight = null;
+    this.previousContainerHeight = null;
+    this.reset();
+
+    this._bindClickListeners();
+
+    this._bindCursorToolsListener(options);
+
+    this._bindScrollModeListener(options);
+
+    this._bindSpreadModeListener(options);
+
+    this.eventBus._on("resize", this._setMaxHeight.bind(this));
+
+    this.eventBus._on("baseviewerinit", evt => {
+      if (evt.source instanceof _pdf_single_page_viewer.PDFSinglePageViewer) {
+        this.toolbarButtonContainer.classList.add("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
+      } else {
+        this.toolbarButtonContainer.classList.remove("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
+      }
+    });
+  }
+
+  get isOpen() {
+    return this.opened;
+  }
+
+  setPageNumber(pageNumber) {
+    this.pageNumber = pageNumber;
+
+    this._updateUIState();
+  }
+
+  setPagesCount(pagesCount) {
+    this.pagesCount = pagesCount;
+
+    this._updateUIState();
+  }
+
+  reset() {
+    this.pageNumber = 0;
+    this.pagesCount = 0;
+
+    this._updateUIState();
+
+    this.eventBus.dispatch("secondarytoolbarreset", {
+      source: this
+    });
+  }
+
+  _updateUIState() {
+    this.items.firstPage.disabled = this.pageNumber <= 1;
+    this.items.lastPage.disabled = this.pageNumber >= this.pagesCount;
+    this.items.pageRotateCw.disabled = this.pagesCount === 0;
+    this.items.pageRotateCcw.disabled = this.pagesCount === 0;
+  }
+
+  _bindClickListeners() {
+    this.toggleButton.addEventListener("click", this.toggle.bind(this));
+
+    for (const {
+      element,
+      eventName,
+      close,
+      eventDetails
+    } of this.buttons) {
+      element.addEventListener("click", evt => {
+        if (eventName !== null) {
+          const details = {
+            source: this
+          };
+
+          for (const property in eventDetails) {
+            details[property] = eventDetails[property];
+          }
+
+          this.eventBus.dispatch(eventName, details);
+        }
+
+        if (close) {
+          this.close();
+        }
+      });
+    }
+  }
+
+  _bindCursorToolsListener(buttons) {
+    this.eventBus._on("cursortoolchanged", function ({
+      tool
+    }) {
+      buttons.cursorSelectToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.SELECT);
+      buttons.cursorHandToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.HAND);
+    });
+  }
+
+  _bindScrollModeListener(buttons) {
+    function scrollModeChanged({
+      mode
+    }) {
+      buttons.scrollVerticalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.VERTICAL);
+      buttons.scrollHorizontalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.HORIZONTAL);
+      buttons.scrollWrappedButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.WRAPPED);
+      const isScrollModeHorizontal = mode === _ui_utils.ScrollMode.HORIZONTAL;
+      buttons.spreadNoneButton.disabled = isScrollModeHorizontal;
+      buttons.spreadOddButton.disabled = isScrollModeHorizontal;
+      buttons.spreadEvenButton.disabled = isScrollModeHorizontal;
+    }
+
+    this.eventBus._on("scrollmodechanged", scrollModeChanged);
+
+    this.eventBus._on("secondarytoolbarreset", evt => {
+      if (evt.source === this) {
+        scrollModeChanged({
+          mode: _ui_utils.ScrollMode.VERTICAL
+        });
+      }
+    });
+  }
+
+  _bindSpreadModeListener(buttons) {
+    function spreadModeChanged({
+      mode
+    }) {
+      buttons.spreadNoneButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.NONE);
+      buttons.spreadOddButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.ODD);
+      buttons.spreadEvenButton.classList.toggle("toggled", mode === _ui_utils.SpreadMode.EVEN);
+    }
+
+    this.eventBus._on("spreadmodechanged", spreadModeChanged);
+
+    this.eventBus._on("secondarytoolbarreset", evt => {
+      if (evt.source === this) {
+        spreadModeChanged({
+          mode: _ui_utils.SpreadMode.NONE
+        });
+      }
+    });
+  }
+
+  open() {
+    if (this.opened) {
+      return;
+    }
+
+    this.opened = true;
+
+    this._setMaxHeight();
+
+    this.toggleButton.classList.add("toggled");
+    this.toolbar.classList.remove("hidden");
+  }
+
+  close() {
+    if (!this.opened) {
+      return;
+    }
+
+    this.opened = false;
+    this.toolbar.classList.add("hidden");
+    this.toggleButton.classList.remove("toggled");
+  }
+
+  toggle() {
+    if (this.opened) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+
+  _setMaxHeight() {
+    if (!this.opened) {
+      return;
+    }
+
+    this.containerHeight = this.mainContainer.clientHeight;
+
+    if (this.containerHeight === this.previousContainerHeight) {
+      return;
+    }
+
+    this.toolbarButtonContainer.style.maxHeight = `${this.containerHeight - _ui_utils.SCROLLBAR_PADDING}px`;
+    this.previousContainerHeight = this.containerHeight;
+  }
+
+}
+
+exports.SecondaryToolbar = SecondaryToolbar;
+
+/***/ }),
+/* 32 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFSinglePageViewer = void 0;
+
+var _base_viewer = __webpack_require__(27);
+
+var _pdfjsLib = __webpack_require__(5);
+
+class PDFSinglePageViewer extends _base_viewer.BaseViewer {
+  constructor(options) {
+    super(options);
+
+    this.eventBus._on("pagesinit", evt => {
+      this._ensurePageViewVisible();
+    });
+  }
+
+  get _viewerElement() {
+    return (0, _pdfjsLib.shadow)(this, "_viewerElement", this._shadowViewer);
+  }
+
+  get _pageWidthScaleFactor() {
+    return 1;
+  }
+
+  _resetView() {
+    super._resetView();
+
+    this._previousPageNumber = 1;
+    this._shadowViewer = document.createDocumentFragment();
+    this._updateScrollDown = null;
+  }
+
+  _ensurePageViewVisible() {
+    const pageView = this._pages[this._currentPageNumber - 1];
+    const previousPageView = this._pages[this._previousPageNumber - 1];
+    const viewerNodes = this.viewer.childNodes;
+
+    switch (viewerNodes.length) {
+      case 0:
+        this.viewer.appendChild(pageView.div);
+        break;
+
+      case 1:
+        if (viewerNodes[0] !== previousPageView.div) {
+          throw new Error("_ensurePageViewVisible: Unexpected previously visible page.");
+        }
+
+        if (pageView === previousPageView) {
+          break;
+        }
+
+        this._shadowViewer.appendChild(previousPageView.div);
+
+        this.viewer.appendChild(pageView.div);
+        this.container.scrollTop = 0;
+        break;
+
+      default:
+        throw new Error("_ensurePageViewVisible: Only one page should be visible at a time.");
+    }
+
+    this._previousPageNumber = this._currentPageNumber;
+  }
+
+  _scrollUpdate() {
+    if (this._updateScrollDown) {
+      this._updateScrollDown();
+    }
+
+    super._scrollUpdate();
+  }
+
+  _scrollIntoView({
+    pageDiv,
+    pageSpot = null,
+    pageNumber = null
+  }) {
+    if (pageNumber) {
+      this._setCurrentPageNumber(pageNumber);
+    }
+
+    const scrolledDown = this._currentPageNumber >= this._previousPageNumber;
+
+    this._ensurePageViewVisible();
+
+    this.update();
+
+    super._scrollIntoView({
+      pageDiv,
+      pageSpot,
+      pageNumber
+    });
+
+    this._updateScrollDown = () => {
+      this.scroll.down = scrolledDown;
+      this._updateScrollDown = null;
+    };
+  }
+
+  _getVisiblePages() {
+    return this._getCurrentVisiblePage();
+  }
+
+  _updateHelper(visiblePages) {}
+
+  get _isScrollModeHorizontal() {
+    return (0, _pdfjsLib.shadow)(this, "_isScrollModeHorizontal", false);
+  }
+
+  _updateScrollMode() {}
+
+  _updateSpreadMode() {}
+
+}
+
+exports.PDFSinglePageViewer = PDFSinglePageViewer;
+
+/***/ }),
+/* 33 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.Toolbar = void 0;
+
+var _ui_utils = __webpack_require__(4);
+
+const PAGE_NUMBER_LOADING_INDICATOR = "visiblePageIsLoading";
+const SCALE_SELECT_CONTAINER_WIDTH = 140;
+const SCALE_SELECT_WIDTH = 162;
+
+class Toolbar {
+  constructor(options, eventBus, l10n = _ui_utils.NullL10n) {
+    this.toolbar = options.container;
+    this.eventBus = eventBus;
+    this.l10n = l10n;
+    this.buttons = [{
+      element: options.previous,
+      eventName: "previouspage"
+    }, {
+      element: options.next,
+      eventName: "nextpage"
+    }, {
+      element: options.zoomIn,
+      eventName: "zoomin"
+    }, {
+      element: options.zoomOut,
+      eventName: "zoomout"
+    }, {
+      element: options.openFile,
+      eventName: "openfile"
+    }, {
+      element: options.print,
+      eventName: "print"
+    }, {
+      element: options.presentationModeButton,
+      eventName: "presentationmode"
+    }, {
+      element: options.download,
+      eventName: "download"
+    }, {
+      element: options.viewBookmark,
+      eventName: null
+    }];
+    this.items = {
+      numPages: options.numPages,
+      pageNumber: options.pageNumber,
+      scaleSelectContainer: options.scaleSelectContainer,
+      scaleSelect: options.scaleSelect,
+      customScaleOption: options.customScaleOption,
+      previous: options.previous,
+      next: options.next,
+      zoomIn: options.zoomIn,
+      zoomOut: options.zoomOut
+    };
+    this._wasLocalized = false;
+    this.reset();
+
+    this._bindListeners();
+  }
+
+  setPageNumber(pageNumber, pageLabel) {
+    this.pageNumber = pageNumber;
+    this.pageLabel = pageLabel;
+
+    this._updateUIState(false);
+  }
+
+  setPagesCount(pagesCount, hasPageLabels) {
+    this.pagesCount = pagesCount;
+    this.hasPageLabels = hasPageLabels;
+
+    this._updateUIState(true);
+  }
+
+  setPageScale(pageScaleValue, pageScale) {
+    this.pageScaleValue = (pageScaleValue || pageScale).toString();
+    this.pageScale = pageScale;
+
+    this._updateUIState(false);
+  }
+
+  reset() {
+    this.pageNumber = 0;
+    this.pageLabel = null;
+    this.hasPageLabels = false;
+    this.pagesCount = 0;
+    this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+    this.pageScale = _ui_utils.DEFAULT_SCALE;
+
+    this._updateUIState(true);
+
+    this.updateLoadingIndicatorState();
+  }
+
+  _bindListeners() {
+    const {
+      pageNumber,
+      scaleSelect
+    } = this.items;
+    const self = this;
+
+    for (const {
+      element,
+      eventName
+    } of this.buttons) {
+      element.addEventListener("click", evt => {
+        if (eventName !== null) {
+          this.eventBus.dispatch(eventName, {
+            source: this
+          });
+        }
+      });
+    }
+
+    pageNumber.addEventListener("click", function () {
+      this.select();
+    });
+    pageNumber.addEventListener("change", function () {
+      self.eventBus.dispatch("pagenumberchanged", {
+        source: self,
+        value: this.value
+      });
+    });
+    scaleSelect.addEventListener("change", function () {
+      if (this.value === "custom") {
+        return;
+      }
+
+      self.eventBus.dispatch("scalechanged", {
+        source: self,
+        value: this.value
+      });
+    });
+    scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;
+
+    this.eventBus._on("localized", () => {
+      this._wasLocalized = true;
+
+      this._adjustScaleWidth();
+
+      this._updateUIState(true);
+    });
+  }
+
+  _updateUIState(resetNumPages = false) {
+    if (!this._wasLocalized) {
+      return;
+    }
+
+    const {
+      pageNumber,
+      pagesCount,
+      pageScaleValue,
+      pageScale,
+      items
+    } = this;
+
+    if (resetNumPages) {
+      if (this.hasPageLabels) {
+        items.pageNumber.type = "text";
+      } else {
+        items.pageNumber.type = "number";
+        this.l10n.get("of_pages", {
+          pagesCount
+        }, "of {{pagesCount}}").then(msg => {
+          items.numPages.textContent = msg;
+        });
+      }
+
+      items.pageNumber.max = pagesCount;
+    }
+
+    if (this.hasPageLabels) {
+      items.pageNumber.value = this.pageLabel;
+      this.l10n.get("page_of_pages", {
+        pageNumber,
+        pagesCount
+      }, "({{pageNumber}} of {{pagesCount}})").then(msg => {
+        items.numPages.textContent = msg;
+      });
+    } else {
+      items.pageNumber.value = pageNumber;
+    }
+
+    items.previous.disabled = pageNumber <= 1;
+    items.next.disabled = pageNumber >= pagesCount;
+    items.zoomOut.disabled = pageScale <= _ui_utils.MIN_SCALE;
+    items.zoomIn.disabled = pageScale >= _ui_utils.MAX_SCALE;
+    const customScale = Math.round(pageScale * 10000) / 100;
+    this.l10n.get("page_scale_percent", {
+      scale: customScale
+    }, "{{scale}}%").then(msg => {
+      let predefinedValueFound = false;
+
+      for (const option of items.scaleSelect.options) {
+        if (option.value !== pageScaleValue) {
+          option.selected = false;
+          continue;
+        }
+
+        option.selected = true;
+        predefinedValueFound = true;
+      }
+
+      if (!predefinedValueFound) {
+        items.customScaleOption.textContent = msg;
+        items.customScaleOption.selected = true;
+      }
+    });
+  }
+
+  updateLoadingIndicatorState(loading = false) {
+    const pageNumberInput = this.items.pageNumber;
+    pageNumberInput.classList.toggle(PAGE_NUMBER_LOADING_INDICATOR, loading);
+  }
+
+  async _adjustScaleWidth() {
+    const {
+      items,
+      l10n
+    } = this;
+    const predefinedValuesPromise = Promise.all([l10n.get("page_scale_auto", null, "Automatic Zoom"), l10n.get("page_scale_actual", null, "Actual Size"), l10n.get("page_scale_fit", null, "Page Fit"), l10n.get("page_scale_width", null, "Page Width")]);
+    let canvas = document.createElement("canvas");
+    canvas.mozOpaque = true;
+    let ctx = canvas.getContext("2d", {
+      alpha: false
+    });
+    await _ui_utils.animationStarted;
+    const {
+      fontSize,
+      fontFamily
+    } = getComputedStyle(items.scaleSelect);
+    ctx.font = `${fontSize} ${fontFamily}`;
+    let maxWidth = 0;
+
+    for (const predefinedValue of await predefinedValuesPromise) {
+      const {
+        width
+      } = ctx.measureText(predefinedValue);
+
+      if (width > maxWidth) {
+        maxWidth = width;
+      }
+    }
+
+    const overflow = SCALE_SELECT_WIDTH - SCALE_SELECT_CONTAINER_WIDTH;
+    maxWidth += 2 * overflow;
+
+    if (maxWidth > SCALE_SELECT_CONTAINER_WIDTH) {
+      items.scaleSelect.style.width = `${maxWidth + overflow}px`;
+      items.scaleSelectContainer.style.width = `${maxWidth}px`;
+    }
+
+    canvas.width = 0;
+    canvas.height = 0;
+    canvas = ctx = null;
+  }
+
+}
+
+exports.Toolbar = Toolbar;
+
+/***/ }),
+/* 34 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.ViewHistory = void 0;
+const DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
+
+class ViewHistory {
+  constructor(fingerprint, cacheSize = DEFAULT_VIEW_HISTORY_CACHE_SIZE) {
+    this.fingerprint = fingerprint;
+    this.cacheSize = cacheSize;
+    this._initializedPromise = this._readFromStorage().then(databaseStr => {
+      const database = JSON.parse(databaseStr || "{}");
+      let index = -1;
+
+      if (!Array.isArray(database.files)) {
+        database.files = [];
+      } else {
+        while (database.files.length >= this.cacheSize) {
+          database.files.shift();
+        }
+
+        for (let i = 0, ii = database.files.length; i < ii; i++) {
+          const branch = database.files[i];
+
+          if (branch.fingerprint === this.fingerprint) {
+            index = i;
+            break;
+          }
+        }
+      }
+
+      if (index === -1) {
+        index = database.files.push({
+          fingerprint: this.fingerprint
+        }) - 1;
+      }
+
+      this.file = database.files[index];
+      this.database = database;
+    });
+  }
+
+  async _writeToStorage() {
+    const databaseStr = JSON.stringify(this.database);
+    sessionStorage.setItem("pdfjs.history", databaseStr);
+  }
+
+  async _readFromStorage() {
+    return sessionStorage.getItem("pdfjs.history");
+  }
+
+  async set(name, val) {
+    await this._initializedPromise;
+    this.file[name] = val;
+    return this._writeToStorage();
+  }
+
+  async setMultiple(properties) {
+    await this._initializedPromise;
+
+    for (const name in properties) {
+      this.file[name] = properties[name];
+    }
+
+    return this._writeToStorage();
+  }
+
+  async get(name, defaultValue) {
+    await this._initializedPromise;
+    const val = this.file[name];
+    return val !== undefined ? val : defaultValue;
+  }
+
+  async getMultiple(properties) {
+    await this._initializedPromise;
+    const values = Object.create(null);
+
+    for (const name in properties) {
+      const val = this.file[name];
+      values[name] = val !== undefined ? val : properties[name];
+    }
+
+    return values;
+  }
+
+}
+
+exports.ViewHistory = ViewHistory;
+
+/***/ }),
+/* 35 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.FirefoxCom = exports.DownloadManager = void 0;
+
+__webpack_require__(36);
+
+var _app = __webpack_require__(3);
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _preferences = __webpack_require__(37);
+
+var _ui_utils = __webpack_require__(4);
+
+;
+
+class FirefoxCom {
+  static requestSync(action, data) {
+    const request = document.createTextNode("");
+    document.documentElement.appendChild(request);
+    const sender = document.createEvent("CustomEvent");
+    sender.initCustomEvent("pdf.js.message", true, false, {
+      action,
+      data,
+      sync: true
+    });
+    request.dispatchEvent(sender);
+    const response = sender.detail.response;
+    request.remove();
+    return response;
+  }
+
+  static requestAsync(action, data) {
+    return new Promise(resolve => {
+      this.request(action, data, resolve);
+    });
+  }
+
+  static request(action, data, callback = null) {
+    const request = document.createTextNode("");
+
+    if (callback) {
+      request.addEventListener("pdf.js.response", event => {
+        const response = event.detail.response;
+        event.target.remove();
+        callback(response);
+      }, {
+        once: true
+      });
+    }
+
+    document.documentElement.appendChild(request);
+    const sender = document.createEvent("CustomEvent");
+    sender.initCustomEvent("pdf.js.message", true, false, {
+      action,
+      data,
+      sync: false,
+      responseExpected: !!callback
+    });
+    request.dispatchEvent(sender);
+  }
+
+}
+
+exports.FirefoxCom = FirefoxCom;
+
+class DownloadManager {
+  downloadUrl(url, filename) {
+    FirefoxCom.request("download", {
+      originalUrl: url,
+      filename
+    });
+  }
+
+  downloadData(data, filename, contentType) {
+    const blobUrl = URL.createObjectURL(new Blob([data], {
+      type: contentType
+    }));
+    FirefoxCom.requestAsync("download", {
+      blobUrl,
+      originalUrl: blobUrl,
+      filename,
+      isAttachment: true
+    }).then(error => {
+      URL.revokeObjectURL(blobUrl);
+    });
+  }
+
+  download(blob, url, filename, sourceEventType = "download") {
+    const blobUrl = URL.createObjectURL(blob);
+    FirefoxCom.requestAsync("download", {
+      blobUrl,
+      originalUrl: url,
+      filename,
+      sourceEventType
+    }).then(error => {
+      if (error) {
+        console.error("`ChromeActions.download` failed.");
+      }
+
+      URL.revokeObjectURL(blobUrl);
+    });
+  }
+
+}
+
+exports.DownloadManager = DownloadManager;
+
+class FirefoxPreferences extends _preferences.BasePreferences {
+  async _writeToStorage(prefObj) {
+    return FirefoxCom.requestAsync("setPreferences", prefObj);
+  }
+
+  async _readFromStorage(prefObj) {
+    const prefStr = await FirefoxCom.requestAsync("getPreferences", prefObj);
+    return JSON.parse(prefStr);
+  }
+
+}
+
+class MozL10n {
+  constructor(mozL10n) {
+    this.mozL10n = mozL10n;
+  }
+
+  async getLanguage() {
+    return this.mozL10n.getLanguage();
+  }
+
+  async getDirection() {
+    return this.mozL10n.getDirection();
+  }
+
+  async get(property, args, fallback) {
+    return this.mozL10n.get(property, args, fallback);
+  }
+
+  async translate(element) {
+    this.mozL10n.translate(element);
+  }
+
+}
+
+(function listenFindEvents() {
+  const events = ["find", "findagain", "findhighlightallchange", "findcasesensitivitychange", "findentirewordchange", "findbarclose"];
+
+  const handleEvent = function ({
+    type,
+    detail
+  }) {
+    if (!_app.PDFViewerApplication.initialized) {
+      return;
+    }
+
+    if (type === "findbarclose") {
+      _app.PDFViewerApplication.eventBus.dispatch(type, {
+        source: window
+      });
+
+      return;
+    }
+
+    _app.PDFViewerApplication.eventBus.dispatch("find", {
+      source: window,
+      type: type.substring("find".length),
+      query: detail.query,
+      phraseSearch: true,
+      caseSensitive: !!detail.caseSensitive,
+      entireWord: !!detail.entireWord,
+      highlightAll: !!detail.highlightAll,
+      findPrevious: !!detail.findPrevious
+    });
+  };
+
+  for (const event of events) {
+    window.addEventListener(event, handleEvent);
+  }
+})();
+
+(function listenZoomEvents() {
+  const events = ["zoomin", "zoomout", "zoomreset"];
+
+  const handleEvent = function ({
+    type,
+    detail
+  }) {
+    if (!_app.PDFViewerApplication.initialized) {
+      return;
+    }
+
+    if (type === "zoomreset" && _app.PDFViewerApplication.pdfViewer.currentScaleValue === _ui_utils.DEFAULT_SCALE_VALUE) {
+      return;
+    }
+
+    _app.PDFViewerApplication.eventBus.dispatch(type, {
+      source: window
+    });
+  };
+
+  for (const event of events) {
+    window.addEventListener(event, handleEvent);
+  }
+})();
+
+(function listenSaveEvent() {
+  const handleEvent = function ({
+    type,
+    detail
+  }) {
+    if (!_app.PDFViewerApplication.initialized) {
+      return;
+    }
+
+    _app.PDFViewerApplication.eventBus.dispatch(type, {
+      source: window
+    });
+  };
+
+  window.addEventListener("save", handleEvent);
+})();
+
+class FirefoxComDataRangeTransport extends _pdfjsLib.PDFDataRangeTransport {
+  requestDataRange(begin, end) {
+    FirefoxCom.request("requestDataRange", {
+      begin,
+      end
+    });
+  }
+
+  abort() {
+    FirefoxCom.requestSync("abortLoading", null);
+  }
+
+}
+
+class FirefoxScripting {
+  static async createSandbox(data) {
+    const success = await FirefoxCom.requestAsync("createSandbox", data);
+
+    if (!success) {
+      throw new Error("Cannot create sandbox.");
+    }
+  }
+
+  static async dispatchEventInSandbox(event) {
+    FirefoxCom.request("dispatchEventInSandbox", event);
+  }
+
+  static async destroySandbox() {
+    FirefoxCom.request("destroySandbox", null);
+  }
+
+}
+
+class FirefoxExternalServices extends _app.DefaultExternalServices {
+  static updateFindControlState(data) {
+    FirefoxCom.request("updateFindControlState", data);
+  }
+
+  static updateFindMatchesCount(data) {
+    FirefoxCom.request("updateFindMatchesCount", data);
+  }
+
+  static initPassiveLoading(callbacks) {
+    let pdfDataRangeTransport;
+    window.addEventListener("message", function windowMessage(e) {
+      if (e.source !== null) {
+        console.warn("Rejected untrusted message from " + e.origin);
+        return;
+      }
+
+      const args = e.data;
+
+      if (typeof args !== "object" || !("pdfjsLoadAction" in args)) {
+        return;
+      }
+
+      switch (args.pdfjsLoadAction) {
+        case "supportsRangedLoading":
+          pdfDataRangeTransport = new FirefoxComDataRangeTransport(args.length, args.data, args.done);
+          callbacks.onOpenWithTransport(args.pdfUrl, args.length, pdfDataRangeTransport);
+          break;
+
+        case "range":
+          pdfDataRangeTransport.onDataRange(args.begin, args.chunk);
+          break;
+
+        case "rangeProgress":
+          pdfDataRangeTransport.onDataProgress(args.loaded);
+          break;
+
+        case "progressiveRead":
+          pdfDataRangeTransport.onDataProgressiveRead(args.chunk);
+          pdfDataRangeTransport.onDataProgress(args.loaded, args.total);
+          break;
+
+        case "progressiveDone":
+          if (pdfDataRangeTransport) {
+            pdfDataRangeTransport.onDataProgressiveDone();
+          }
+
+          break;
+
+        case "progress":
+          callbacks.onProgress(args.loaded, args.total);
+          break;
+
+        case "complete":
+          if (!args.data) {
+            callbacks.onError(args.errorCode);
+            break;
+          }
+
+          callbacks.onOpenWithData(args.data);
+          break;
+      }
+    });
+    FirefoxCom.requestSync("initPassiveLoading", null);
+  }
+
+  static async fallback(data) {
+    return FirefoxCom.requestAsync("fallback", data);
+  }
+
+  static reportTelemetry(data) {
+    FirefoxCom.request("reportTelemetry", JSON.stringify(data));
+  }
+
+  static createDownloadManager(options) {
+    return new DownloadManager();
+  }
+
+  static createPreferences() {
+    return new FirefoxPreferences();
+  }
+
+  static createL10n(options) {
+    const mozL10n = document.mozL10n;
+    return new MozL10n(mozL10n);
+  }
+
+  static createScripting(options) {
+    return FirefoxScripting;
+  }
+
+  static get supportsIntegratedFind() {
+    const support = FirefoxCom.requestSync("supportsIntegratedFind");
+    return (0, _pdfjsLib.shadow)(this, "supportsIntegratedFind", support);
+  }
+
+  static get supportsDocumentFonts() {
+    const support = FirefoxCom.requestSync("supportsDocumentFonts");
+    return (0, _pdfjsLib.shadow)(this, "supportsDocumentFonts", support);
+  }
+
+  static get supportedMouseWheelZoomModifierKeys() {
+    const support = FirefoxCom.requestSync("supportedMouseWheelZoomModifierKeys");
+    return (0, _pdfjsLib.shadow)(this, "supportedMouseWheelZoomModifierKeys", support);
+  }
+
+  static get isInAutomation() {
+    const isInAutomation = FirefoxCom.requestSync("isInAutomation");
+    return (0, _pdfjsLib.shadow)(this, "isInAutomation", isInAutomation);
+  }
+
+}
+
+_app.PDFViewerApplication.externalServices = FirefoxExternalServices;
+document.mozL10n.setExternalLocalizerServices({
+  getLocale() {
+    return FirefoxCom.requestSync("getLocale", null);
+  },
+
+  getStrings(key) {
+    return FirefoxCom.requestSync("getStrings", key);
+  }
+
+});
+
+/***/ }),
+/* 36 */
+/***/ (() => {
+
+
+
+(function (window) {
+  var gLanguage = "";
+  var gExternalLocalizerServices = null;
+  var gReadyState = "loading";
+
+  function getL10nData(key) {
+    var response = gExternalLocalizerServices.getStrings(key);
+    var data = JSON.parse(response);
+
+    if (!data) {
+      console.warn("[l10n] #" + key + " missing for [" + gLanguage + "]");
+    }
+
+    return data;
+  }
+
+  function substArguments(text, args) {
+    if (!args) {
+      return text;
+    }
+
+    return text.replace(/\{\{\s*(\w+)\s*\}\}/g, function (all, name) {
+      return name in args ? args[name] : "{{" + name + "}}";
+    });
+  }
+
+  function translateString(key, args, fallback) {
+    var i = key.lastIndexOf(".");
+    var name, property;
+
+    if (i >= 0) {
+      name = key.substring(0, i);
+      property = key.substring(i + 1);
+    } else {
+      name = key;
+      property = "textContent";
+    }
+
+    var data = getL10nData(name);
+    var value = data && data[property] || fallback;
+
+    if (!value) {
+      return "{{" + key + "}}";
+    }
+
+    return substArguments(value, args);
+  }
+
+  function translateElement(element) {
+    if (!element || !element.dataset) {
+      return;
+    }
+
+    var key = element.dataset.l10nId;
+    var data = getL10nData(key);
+
+    if (!data) {
+      return;
+    }
+
+    var args;
+
+    if (element.dataset.l10nArgs) {
+      try {
+        args = JSON.parse(element.dataset.l10nArgs);
+      } catch (e) {
+        console.warn("[l10n] could not parse arguments for #" + key + "");
+      }
+    }
+
+    for (var k in data) {
+      element[k] = substArguments(data[k], args);
+    }
+  }
+
+  function translateFragment(element) {
+    element = element || document.querySelector("html");
+    var children = element.querySelectorAll("*[data-l10n-id]");
+    var elementCount = children.length;
+
+    for (var i = 0; i < elementCount; i++) {
+      translateElement(children[i]);
+    }
+
+    if (element.dataset.l10nId) {
+      translateElement(element);
+    }
+  }
+
+  document.mozL10n = {
+    get: translateString,
+
+    getLanguage() {
+      return gLanguage;
+    },
+
+    getDirection() {
+      var rtlList = ["ar", "he", "fa", "ps", "ur"];
+      var shortCode = gLanguage.split("-")[0];
+      return rtlList.includes(shortCode) ? "rtl" : "ltr";
+    },
+
+    getReadyState() {
+      return gReadyState;
+    },
+
+    setExternalLocalizerServices(externalLocalizerServices) {
+      gExternalLocalizerServices = externalLocalizerServices;
+      gLanguage = gExternalLocalizerServices.getLocale();
+      gReadyState = "complete";
+    },
+
+    translate: translateFragment
+  };
+})(void 0);
+
+/***/ }),
+/* 37 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.BasePreferences = void 0;
+
+var _app_options = __webpack_require__(1);
+
+class BasePreferences {
+  constructor() {
+    if (this.constructor === BasePreferences) {
+      throw new Error("Cannot initialize BasePreferences.");
+    }
+
+    Object.defineProperty(this, "defaults", {
+      value: Object.freeze({
+        "cursorToolOnLoad": 0,
+        "defaultZoomValue": "",
+        "disablePageLabels": false,
+        "enablePermissions": false,
+        "enablePrintAutoRotate": false,
+        "enableScripting": false,
+        "enableWebGL": false,
+        "externalLinkTarget": 0,
+        "historyUpdateUrl": false,
+        "ignoreDestinationZoom": false,
+        "pdfBugEnabled": false,
+        "renderer": "canvas",
+        "renderInteractiveForms": true,
+        "sidebarViewOnLoad": -1,
+        "scrollModeOnLoad": -1,
+        "spreadModeOnLoad": -1,
+        "textLayerMode": 1,
+        "useOnlyCssZoom": false,
+        "viewerCssTheme": 0,
+        "viewOnLoad": 0,
+        "disableAutoFetch": false,
+        "disableFontFace": false,
+        "disableRange": false,
+        "disableStream": false
+      }),
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    this.prefs = Object.assign(Object.create(null), this.defaults);
+    this._initializedPromise = this._readFromStorage(this.defaults).then(prefs => {
+      if (!prefs) {
+        return;
+      }
+
+      for (const name in prefs) {
+        const defaultValue = this.defaults[name],
+              prefValue = prefs[name];
+
+        if (defaultValue === undefined || typeof prefValue !== typeof defaultValue) {
+          continue;
+        }
+
+        this.prefs[name] = prefValue;
+      }
+    });
+  }
+
+  async _writeToStorage(prefObj) {
+    throw new Error("Not implemented: _writeToStorage");
+  }
+
+  async _readFromStorage(prefObj) {
+    throw new Error("Not implemented: _readFromStorage");
+  }
+
+  async reset() {
+    await this._initializedPromise;
+    this.prefs = Object.assign(Object.create(null), this.defaults);
+    return this._writeToStorage(this.defaults);
+  }
+
+  async set(name, value) {
+    await this._initializedPromise;
+    const defaultValue = this.defaults[name];
+
+    if (defaultValue === undefined) {
+      throw new Error(`Set preference: "${name}" is undefined.`);
+    } else if (value === undefined) {
+      throw new Error("Set preference: no value is specified.");
+    }
+
+    const valueType = typeof value;
+    const defaultType = typeof defaultValue;
+
+    if (valueType !== defaultType) {
+      if (valueType === "number" && defaultType === "string") {
+        value = value.toString();
+      } else {
+        throw new Error(`Set preference: "${value}" is a ${valueType}, ` + `expected a ${defaultType}.`);
+      }
+    } else {
+      if (valueType === "number" && !Number.isInteger(value)) {
+        throw new Error(`Set preference: "${value}" must be an integer.`);
+      }
+    }
+
+    this.prefs[name] = value;
+    return this._writeToStorage(this.prefs);
+  }
+
+  async get(name) {
+    await this._initializedPromise;
+    const defaultValue = this.defaults[name];
+
+    if (defaultValue === undefined) {
+      throw new Error(`Get preference: "${name}" is undefined.`);
+    } else {
+      const prefValue = this.prefs[name];
+
+      if (prefValue !== undefined) {
+        return prefValue;
+      }
+    }
+
+    return defaultValue;
+  }
+
+  async getAll() {
+    await this._initializedPromise;
+    return Object.assign(Object.create(null), this.defaults, this.prefs);
+  }
+
+}
+
+exports.BasePreferences = BasePreferences;
+
+/***/ }),
+/* 38 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.FirefoxPrintService = FirefoxPrintService;
+
+var _pdfjsLib = __webpack_require__(5);
+
+var _ui_utils = __webpack_require__(4);
+
+var _app = __webpack_require__(3);
+
+function composePage(pdfDocument, pageNumber, size, printContainer, printResolution, optionalContentConfigPromise) {
+  const canvas = document.createElement("canvas");
+  const PRINT_UNITS = printResolution / 72.0;
+  canvas.width = Math.floor(size.width * PRINT_UNITS);
+  canvas.height = Math.floor(size.height * PRINT_UNITS);
+  canvas.style.width = Math.floor(size.width * _ui_utils.CSS_UNITS) + "px";
+  canvas.style.height = Math.floor(size.height * _ui_utils.CSS_UNITS) + "px";
+  const canvasWrapper = document.createElement("div");
+  canvasWrapper.appendChild(canvas);
+  printContainer.appendChild(canvasWrapper);
+  let currentRenderTask = null;
+
+  canvas.mozPrintCallback = function (obj) {
+    const ctx = obj.context;
+    ctx.save();
+    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    ctx.restore();
+    let thisRenderTask = null;
+    pdfDocument.getPage(pageNumber).then(function (pdfPage) {
+      if (currentRenderTask) {
+        currentRenderTask.cancel();
+        currentRenderTask = null;
+      }
+
+      const renderContext = {
+        canvasContext: ctx,
+        transform: [PRINT_UNITS, 0, 0, PRINT_UNITS, 0, 0],
+        viewport: pdfPage.getViewport({
+          scale: 1,
+          rotation: size.rotation
+        }),
+        intent: "print",
+        annotationStorage: pdfDocument.annotationStorage,
+        optionalContentConfigPromise
+      };
+      currentRenderTask = thisRenderTask = pdfPage.render(renderContext);
+      return thisRenderTask.promise;
+    }).then(function () {
+      if (currentRenderTask === thisRenderTask) {
+        currentRenderTask = null;
+      }
+
+      obj.done();
+    }, function (reason) {
+      if (!(reason instanceof _pdfjsLib.RenderingCancelledException)) {
+        console.error(reason);
+      }
+
+      if (currentRenderTask === thisRenderTask) {
+        currentRenderTask.cancel();
+        currentRenderTask = null;
+      }
+
+      if ("abort" in obj) {
+        obj.abort();
+      } else {
+        obj.done();
+      }
+    });
+  };
+}
+
+function FirefoxPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise = null) {
+  this.pdfDocument = pdfDocument;
+  this.pagesOverview = pagesOverview;
+  this.printContainer = printContainer;
+  this._printResolution = printResolution || 150;
+  this._optionalContentConfigPromise = optionalContentConfigPromise || pdfDocument.getOptionalContentConfig();
+}
+
+FirefoxPrintService.prototype = {
+  layout() {
+    const {
+      pdfDocument,
+      pagesOverview,
+      printContainer,
+      _printResolution,
+      _optionalContentConfigPromise
+    } = this;
+    const body = document.querySelector("body");
+    body.setAttribute("data-pdfjsprinting", true);
+
+    for (let i = 0, ii = pagesOverview.length; i < ii; ++i) {
+      composePage(pdfDocument, i + 1, pagesOverview[i], printContainer, _printResolution, _optionalContentConfigPromise);
+    }
+  },
+
+  destroy() {
+    this.printContainer.textContent = "";
+    const body = document.querySelector("body");
+    body.removeAttribute("data-pdfjsprinting");
+  }
+
+};
+_app.PDFPrintServiceFactory.instance = {
+  get supportsPrinting() {
+    const canvas = document.createElement("canvas");
+    const value = ("mozPrintCallback" in canvas);
+    return (0, _pdfjsLib.shadow)(this, "supportsPrinting", value);
+  },
+
+  createPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise) {
+    return new FirefoxPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise);
+  }
+
+};
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		if(__webpack_module_cache__[moduleId]) {
+/******/ 			return __webpack_module_cache__[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	// startup
+/******/ 	// Load entry module
+/******/ 	__webpack_require__(0);
+/******/ 	// This entry module used 'exports' so it can't be inlined
+/******/ })()
+;
\ No newline at end of file
diff --git a/toolkit/components/pdfjs/jar.mn b/toolkit/components/pdfjs/jar.mn
new file mode 100644
index 0000000000..ca1148155e
--- /dev/null
+++ b/toolkit/components/pdfjs/jar.mn
@@ -0,0 +1,3 @@
+pdfjs.jar:
+% resource pdf.js %content/
+ content/	(content/*)
diff --git a/toolkit/components/pdfjs/moz.build b/toolkit/components/pdfjs/moz.build
new file mode 100644
index 0000000000..8156aa0a07
--- /dev/null
+++ b/toolkit/components/pdfjs/moz.build
@@ -0,0 +1,20 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Firefox", "PDF Viewer")
+
+BROWSER_CHROME_MANIFESTS += ["test/browser.ini"]
+
+JAR_MANIFESTS += ["jar.mn"]
+
+EXTRA_JS_MODULES += [
+    "pdfjs.js",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/toolkit/components/pdfjs/moz.yaml b/toolkit/components/pdfjs/moz.yaml
new file mode 100644
index 0000000000..aa48fcda6a
--- /dev/null
+++ b/toolkit/components/pdfjs/moz.yaml
@@ -0,0 +1,29 @@
+# Version of this schema
+schema: 1
+
+bugzilla:
+  # Bugzilla product and component for this directory and subdirectories
+  product: Firefox
+  component: PDF Viewer
+
+# Document the source of externally hosted code
+origin:
+
+  # Short name of the package/library
+  name: PDF.js
+
+  description: Portable Document Format (PDF) viewer that is built with HTML5
+
+  # Full URL for the package's homepage/etc
+  # Usually different from repository url
+  url: https://github.com/mozilla/pdf.js
+
+  # Human-readable identifier for this version/release
+  # Generally "version NNN", "tag SSS", "bookmark SSS"
+  release: version 2.7.510
+
+  # The package's license, where possible using the mnemonic from
+  # https://spdx.org/licenses/
+  # Multiple licenses can be specified (as a YAML list)
+  # A "LICENSE" file must exist containing the full license text
+  license: Apache-2.0
diff --git a/toolkit/components/pdfjs/pdfjs.js b/toolkit/components/pdfjs/pdfjs.js
new file mode 100644
index 0000000000..f19ad2227a
--- /dev/null
+++ b/toolkit/components/pdfjs/pdfjs.js
@@ -0,0 +1,34 @@
+/* Copyright 2018 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "PdfStreamConverter",
+  "resource://pdf.js/PdfStreamConverter.jsm"
+);
+
+// Register/unregister a constructor as a factory.
+function StreamConverterFactory() {
+  if (!Services.prefs.getBoolPref("pdfjs.disabled", false)) {
+    return new PdfStreamConverter();
+  }
+  throw Components.Exception("", Cr.NS_ERROR_FACTORY_NOT_REGISTERED);
+}
+
+var EXPORTED_SYMBOLS = ["StreamConverterFactory"];
diff --git a/toolkit/components/pdfjs/test/.eslintrc.js b/toolkit/components/pdfjs/test/.eslintrc.js
new file mode 100644
index 0000000000..1779fd7f1c
--- /dev/null
+++ b/toolkit/components/pdfjs/test/.eslintrc.js
@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = {
+  extends: ["plugin:mozilla/browser-test"],
+};
diff --git a/toolkit/components/pdfjs/test/browser.ini b/toolkit/components/pdfjs/test/browser.ini
new file mode 100644
index 0000000000..1edf4699cc
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser.ini
@@ -0,0 +1,35 @@
+[DEFAULT]
+support-files =
+  file_pdfjs_test.pdf
+  head.js
+
+[browser_pdfjs_fill_login.js]
+support-files =
+  file_pdfjs_form.pdf
+[browser_pdfjs_find.js]
+support-files =
+  file_pdfjs_object_stream.pdf
+  file_pdfjs_object_stream.pdf^headers^
+[browser_pdfjs_force_opening_files.js]
+[browser_pdfjs_form.js]
+support-files =
+  file_pdfjs_form.pdf
+[browser_pdfjs_main.js]
+[browser_pdfjs_navigation.js]
+[browser_pdfjs_not_default.js]
+support-files =
+  file_pdfjs_object_stream.pdf
+  file_pdfjs_object_stream.pdf^headers^
+[browser_pdfjs_notification_close_on_navigation.js]
+[browser_pdfjs_octet_stream.js]
+support-files =
+  file_pdfjs_object_stream.pdf
+  file_pdfjs_object_stream.pdf^headers^
+[browser_pdfjs_savedialog.js]
+skip-if = verify
+[browser_pdfjs_saveas.js]
+support-files =
+  !/toolkit/content/tests/browser/common/mockTransfer.js
+[browser_pdfjs_views.js]
+[browser_pdfjs_zoom.js]
+skip-if = (verify && debug && (os == 'win'))
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_fill_login.js b/toolkit/components/pdfjs/test/browser_pdfjs_fill_login.js
new file mode 100644
index 0000000000..8d9c022705
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_fill_login.js
@@ -0,0 +1,108 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+// This is a modified version from browser_contextmenuFillLogins.js.
+async function openContextMenuForSelector(browser, selector) {
+  const doc = browser.ownerDocument;
+  const CONTEXT_MENU = doc.getElementById("contentAreaContextMenu");
+
+  let contextMenuShownPromise = BrowserTestUtils.waitForEvent(
+    CONTEXT_MENU,
+    "popupshown"
+  );
+
+  let inputCoords = await SpecialPowers.spawn(
+    browser,
+    [selector],
+    async selector => {
+      let input = content.document.querySelector(selector);
+      input.focus();
+      let inputRect = input.getBoundingClientRect();
+
+      // listen for the contextmenu event so we can assert on receiving it
+      // and examine the target
+      content.contextmenuPromise = new Promise(resolve => {
+        content.document.body.addEventListener(
+          "contextmenu",
+          event => {
+            info(
+              `Received event on target: ${event.target.nodeName}, type: ${event.target.type}`
+            );
+            content.console.log("got contextmenu event: ", event);
+            resolve(event);
+          },
+          { once: true }
+        );
+      });
+
+      let coords = {
+        x: inputRect.x + inputRect.width / 2,
+        y: inputRect.y + inputRect.height / 2,
+      };
+      return coords;
+    }
+  );
+
+  // add the offsets of the <browser> in the chrome window
+  let browserOffsets = browser.getBoundingClientRect();
+  let offsetX = browserOffsets.x + inputCoords.x;
+  let offsetY = browserOffsets.y + inputCoords.y;
+
+  // Synthesize a right mouse click over the input element, we have to trigger
+  // both events because formfill code relies on this event happening before the contextmenu
+  // (which it does for real user input) in order to not show the password autocomplete.
+  let eventDetails = { type: "mousedown", button: 2 };
+  await EventUtils.synthesizeMouseAtPoint(offsetX, offsetY, eventDetails);
+
+  // Synthesize a contextmenu event to actually open the context menu.
+  eventDetails = { type: "contextmenu", button: 2 };
+  await EventUtils.synthesizeMouseAtPoint(offsetX, offsetY, eventDetails);
+
+  await SpecialPowers.spawn(browser, [], async () => {
+    await content.contextmenuPromise;
+  });
+
+  info("waiting for contextMenuShownPromise");
+
+  await contextMenuShownPromise;
+  return CONTEXT_MENU;
+}
+
+/**
+ * Ensure the fill login context menu is not shown for PDF.js forms.
+ */
+add_task(async function test_filllogin() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["pdfjs.renderInteractiveForms", true]],
+  });
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+
+      let contextMenu = await openContextMenuForSelector(
+        browser,
+        "#viewerContainer input"
+      );
+      let fillItem = contextMenu.querySelector("#fill-login");
+      ok(fillItem, "fill menu item exists");
+      ok(fillItem && EventUtils.isHidden(fillItem), "fill menu item is hidden");
+
+      let promiseHidden = BrowserTestUtils.waitForEvent(
+        contextMenu,
+        "popuphidden"
+      );
+      info("Calling hidePopup on contextMenu");
+      contextMenu.hidePopup();
+      info("waiting for promiseHidden");
+      await promiseHidden;
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_find.js b/toolkit/components/pdfjs/test/browser_pdfjs_find.js
new file mode 100644
index 0000000000..27502a2d26
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_find.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TESTROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "http://mochi.test:8888/"
+);
+
+// Get a ref to the pdf we want to open.
+const PDF_URL = TESTROOT + "file_pdfjs_object_stream.pdf";
+
+add_task(async function test_find_octet_stream_pdf() {
+  await BrowserTestUtils.withNewTab(PDF_URL, async browser => {
+    let findEls = ["cmd_find", "cmd_findAgain", "cmd_findPrevious"].map(id =>
+      document.getElementById(id)
+    );
+    for (let el of findEls) {
+      ok(!el.hasAttribute("disabled"), `${el.id} should be enabled`);
+    }
+  });
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_force_opening_files.js b/toolkit/components/pdfjs/test/browser_pdfjs_force_opening_files.js
new file mode 100644
index 0000000000..722a884e8b
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_force_opening_files.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(async function test_file_opening() {
+  // Get a ref to the pdf we want to open.
+  let dirFileObj = getChromeDir(getResolvedURI(gTestPath));
+  dirFileObj.append("file_pdfjs_test.pdf");
+
+  // Change the defaults.
+  var oldAction = changeMimeHandler(Ci.nsIHandlerInfo.useSystemDefault, true);
+
+  // Test: "Open with" dialog should not come up, despite pdf.js not being
+  // the default - because files from disk should always use pdfjs, unless
+  // it is forcibly disabled.
+  let openedWindow = false;
+  let windowOpenedPromise = new Promise((resolve, reject) => {
+    addWindowListener(
+      "chrome://mozapps/content/downloads/unknownContentType.xhtml",
+      () => {
+        openedWindow = true;
+        resolve();
+      }
+    );
+  });
+
+  // Open the tab with a system principal:
+  var tab = BrowserTestUtils.addTab(gBrowser, dirFileObj.path);
+
+  let pdfjsLoadedPromise = TestUtils.waitForCondition(() => {
+    let { contentPrincipal } = tab.linkedBrowser;
+    return (contentPrincipal?.URI?.spec || "").endsWith("viewer.html");
+  });
+  await Promise.race([pdfjsLoadedPromise, windowOpenedPromise]);
+  ok(!openedWindow, "Shouldn't open an unknownContentType window!");
+
+  registerCleanupFunction(function() {
+    if (listenerCleanup) {
+      listenerCleanup();
+    }
+    changeMimeHandler(oldAction[0], oldAction[1]);
+    gBrowser.removeTab(tab);
+  });
+});
+
+let listenerCleanup;
+function addWindowListener(aURL, aCallback) {
+  let listener = {
+    onOpenWindow(aXULWindow) {
+      info("window opened, waiting for focus");
+      listenerCleanup();
+      listenerCleanup = null;
+
+      var domwindow = aXULWindow.docShell.domWindow;
+      waitForFocus(function() {
+        is(
+          domwindow.document.location.href,
+          aURL,
+          "should have seen the right window open"
+        );
+        domwindow.close();
+        aCallback();
+      }, domwindow);
+    },
+    onCloseWindow(aXULWindow) {},
+  };
+  Services.wm.addListener(listener);
+  listenerCleanup = () => Services.wm.removeListener(listener);
+}
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_form.js b/toolkit/components/pdfjs/test/browser_pdfjs_form.js
new file mode 100644
index 0000000000..f424a1ebdb
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_form.js
@@ -0,0 +1,85 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+async function checkFormState(formsEnabled) {
+  ok(
+    content.document.querySelector("div#viewer"),
+    "document content has viewer UI"
+  );
+
+  let formInput = content.document.querySelector("#viewerContainer input");
+
+  if (formsEnabled) {
+    ok(formInput, "Form input available");
+  } else {
+    ok(!formInput, "Form input not available");
+  }
+  let viewer = content.wrappedJSObject.PDFViewerApplication;
+  await viewer.close();
+}
+
+add_task(async function test_defaults() {
+  // Ensure the default preference is set to the expected value.
+  let defaultBranch = Services.prefs.getDefaultBranch("pdfjs.");
+  let prefType = defaultBranch.getPrefType("renderInteractiveForms");
+  let renderForms = Services.prefs.getBoolPref("pdfjs.renderInteractiveForms");
+
+  is(
+    prefType,
+    Ci.nsIPrefBranch.PREF_BOOL,
+    "The form pref is defined by default"
+  );
+
+  ok(renderForms, "Forms are enabled");
+
+  // Test that the forms state matches the pref.
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+
+      await SpecialPowers.spawn(browser, [true], checkFormState);
+    }
+  );
+});
+
+// Test disabling forms with pref.
+add_task(async function test_disabling() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      // First, make sure they are enabled.
+      await SpecialPowers.pushPrefEnv({
+        set: [["pdfjs.renderInteractiveForms", true]],
+      });
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+      await SpecialPowers.spawn(
+        browser,
+        [true /* formsEnabled */],
+        checkFormState
+      );
+      // Now disable the forms.
+      await SpecialPowers.pushPrefEnv({
+        set: [["pdfjs.renderInteractiveForms", false]],
+      });
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+      await SpecialPowers.spawn(
+        browser,
+        [false /* formsEnabled */],
+        checkFormState
+      );
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_main.js b/toolkit/components/pdfjs/test/browser_pdfjs_main.js
new file mode 100644
index 0000000000..dda1615c0b
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_main.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+add_task(async function test() {
+  let mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+  let handlerInfo = mimeService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  info("Pref action: " + handlerInfo.preferredAction);
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(newTabBrowser) {
+      await waitForPdfJS(newTabBrowser, TESTROOT + "file_pdfjs_test.pdf");
+
+      await SpecialPowers.spawn(newTabBrowser, [], async function() {
+        // Overall sanity tests
+        Assert.ok(
+          content.document.querySelector("div#viewer"),
+          "document content has viewer UI"
+        );
+
+        // Sidebar: open
+        var sidebar = content.document.querySelector("button#sidebarToggle"),
+          outerContainer = content.document.querySelector("div#outerContainer");
+
+        sidebar.click();
+        Assert.ok(
+          outerContainer.classList.contains("sidebarOpen"),
+          "sidebar opens on click"
+        );
+
+        // Sidebar: close
+        sidebar.click();
+        Assert.ok(
+          !outerContainer.classList.contains("sidebarOpen"),
+          "sidebar closes on click"
+        );
+
+        // Verify that initial page is 1
+        var pgNumber = content.document.querySelector("input#pageNumber").value;
+        Assert.equal(parseInt(pgNumber, 10), 1, "initial page is 1");
+
+        // Bookmark button
+        var viewBookmark = content.document.querySelector("a#viewBookmark");
+        viewBookmark.click();
+
+        Assert.ok(!!viewBookmark.href.length, "viewBookmark button has href");
+
+        var viewer = content.wrappedJSObject.PDFViewerApplication;
+        await viewer.close();
+      });
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_navigation.js b/toolkit/components/pdfjs/test/browser_pdfjs_navigation.js
new file mode 100644
index 0000000000..7e106e745e
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_navigation.js
@@ -0,0 +1,320 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+
+requestLongerTimeout(2);
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+const PDF_OUTLINE_ITEMS = 17;
+const TESTS = [
+  {
+    action: {
+      selector: "button#next",
+      event: "click",
+    },
+    expectedPage: 2,
+    message: "navigated to next page using NEXT button",
+  },
+  {
+    action: {
+      selector: "button#previous",
+      event: "click",
+    },
+    expectedPage: 1,
+    message: "navigated to previous page using PREV button",
+  },
+  {
+    action: {
+      selector: "button#next",
+      event: "click",
+    },
+    expectedPage: 2,
+    message: "navigated to next page using NEXT button",
+  },
+  {
+    action: {
+      selector: "input#pageNumber",
+      value: 1,
+      event: "change",
+    },
+    expectedPage: 1,
+    message: "navigated to first page using pagenumber",
+  },
+  {
+    action: {
+      selector: "#thumbnailView a:nth-child(4)",
+      event: "click",
+    },
+    expectedPage: 4,
+    message: "navigated to 4th page using thumbnail view",
+  },
+  {
+    action: {
+      selector: "#thumbnailView a:nth-child(2)",
+      event: "click",
+    },
+    expectedPage: 2,
+    message: "navigated to 2nd page using thumbnail view",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 36,
+    },
+    expectedPage: 1,
+    message: "navigated to 1st page using 'home' key",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 34,
+    },
+    expectedPage: 2,
+    message: "navigated to 2nd page using 'Page Down' key",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 33,
+    },
+    expectedPage: 1,
+    message: "navigated to 1st page using 'Page Up' key",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 39,
+    },
+    expectedPage: 2,
+    message: "navigated to 2nd page using 'right' key",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 37,
+    },
+    expectedPage: 1,
+    message: "navigated to 1st page using 'left' key",
+  },
+  {
+    action: {
+      selector: "#viewer",
+      event: "keydown",
+      keyCode: 35,
+    },
+    expectedPage: 5,
+    message: "navigated to last page using 'home' key",
+  },
+  {
+    action: {
+      selector: "#outlineView .treeItem:nth-child(1) a",
+      event: "click",
+    },
+    expectedPage: 1,
+    message: "navigated to 1st page using outline view",
+  },
+  {
+    action: {
+      selector: "#outlineView .treeItem:nth-child(" + PDF_OUTLINE_ITEMS + ") a",
+      event: "click",
+    },
+    expectedPage: 4,
+    message: "navigated to 4th page using outline view",
+  },
+  {
+    action: {
+      selector: "input#pageNumber",
+      value: 5,
+      event: "change",
+    },
+    expectedPage: 5,
+    message: "navigated to 5th page using pagenumber",
+  },
+];
+
+add_task(async function test() {
+  let mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+  let handlerInfo = mimeService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  info("Pref action: " + handlerInfo.preferredAction);
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(newTabBrowser) {
+      await waitForPdfJS(newTabBrowser, TESTROOT + "file_pdfjs_test.pdf");
+
+      await SpecialPowers.spawn(newTabBrowser, [], async function() {
+        // Check if PDF is opened with internal viewer
+        Assert.ok(
+          content.document.querySelector("div#viewer"),
+          "document content has viewer UI"
+        );
+      });
+
+      await SpecialPowers.spawn(newTabBrowser, [], contentSetUp);
+
+      await runTests(newTabBrowser);
+
+      await SpecialPowers.spawn(newTabBrowser, [], async function() {
+        let pageNumber = content.document.querySelector("input#pageNumber");
+        Assert.equal(
+          pageNumber.value,
+          pageNumber.max,
+          "Document is left on the last page"
+        );
+      });
+    }
+  );
+});
+
+async function contentSetUp() {
+  /**
+   * Outline Items gets appended to the document later on we have to
+   * wait for them before we start to navigate though document
+   *
+   * @param document
+   * @returns {deferred.promise|*}
+   */
+  function waitForOutlineItems(document) {
+    return new Promise((resolve, reject) => {
+      document.addEventListener(
+        "outlineloaded",
+        function(evt) {
+          var outlineCount = evt.detail.outlineCount;
+
+          if (
+            document.querySelectorAll("#outlineView .treeItem").length ===
+            outlineCount
+          ) {
+            resolve();
+          } else {
+            reject("Unable to find outline items.");
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+
+  /**
+   * The key navigation has to happen in page-fit, otherwise it won't scroll
+   * through a complete page
+   *
+   * @param document
+   * @returns {deferred.promise|*}
+   */
+  function setZoomToPageFit(document) {
+    return new Promise(resolve => {
+      document.addEventListener(
+        "pagerendered",
+        function(e) {
+          document.querySelector("#viewer").click();
+          resolve();
+        },
+        { once: true }
+      );
+
+      var select = document.querySelector("select#scaleSelect");
+      select.selectedIndex = 2;
+      select.dispatchEvent(new content.Event("change"));
+    });
+  }
+
+  await waitForOutlineItems(content.document);
+  await setZoomToPageFit(content.document);
+}
+
+/**
+ * As the page changes asynchronously, we have to wait for the event after
+ * we trigger the action so we will be at the expected page number after each action
+ *
+ * @param document
+ * @param window
+ * @param test
+ * @param callback
+ */
+async function runTests(browser) {
+  await SpecialPowers.spawn(browser, [TESTS], async function(contentTESTS) {
+    let window = content;
+    let document = window.document;
+
+    for (let test of contentTESTS) {
+      let deferred = {};
+      deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+      });
+
+      let pageNumber = document.querySelector("input#pageNumber");
+
+      // Add an event-listener to wait for page to change, afterwards resolve the promise
+      let timeout = window.setTimeout(() => deferred.reject(), 5000);
+      window.addEventListener("pagechanging", function pageChange() {
+        if (pageNumber.value == test.expectedPage) {
+          window.removeEventListener("pagechanging", pageChange);
+          window.clearTimeout(timeout);
+          deferred.resolve(+pageNumber.value);
+        }
+      });
+
+      // Get the element and trigger the action for changing the page
+      var el = document.querySelector(test.action.selector);
+      Assert.ok(el, "Element '" + test.action.selector + "' has been found");
+
+      // The value option is for input case
+      if (test.action.value) {
+        el.value = test.action.value;
+      }
+
+      // Dispatch the event for changing the page
+      var ev;
+      if (test.action.event == "keydown") {
+        ev = document.createEvent("KeyboardEvent");
+        ev.initKeyEvent(
+          "keydown",
+          true,
+          true,
+          null,
+          false,
+          false,
+          false,
+          false,
+          test.action.keyCode,
+          0
+        );
+        el.dispatchEvent(ev);
+      } else {
+        ev = new content.Event(test.action.event);
+      }
+      el.dispatchEvent(ev);
+
+      let pgNumber = await deferred.promise;
+      Assert.equal(pgNumber, test.expectedPage, test.message);
+    }
+
+    var viewer = content.wrappedJSObject.PDFViewerApplication;
+    await viewer.close();
+  });
+}
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_not_default.js b/toolkit/components/pdfjs/test/browser_pdfjs_not_default.js
new file mode 100644
index 0000000000..ea05348bc9
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_not_default.js
@@ -0,0 +1,26 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_task(async function test_pdfjs_not_default() {
+  var oldAction = changeMimeHandler(Ci.nsIHandlerInfo.useSystemDefault, true);
+  let dirFileObj = getChromeDir(getResolvedURI(gTestPath));
+  dirFileObj.append("file_pdfjs_test.pdf");
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    dirFileObj.path
+  );
+
+  // If we don't have the Pdfjs actor loaded, this will throw
+  await getPdfjsActor();
+
+  changeMimeHandler(oldAction[0], oldAction[1]);
+
+  gBrowser.removeTab(tab);
+});
+
+function getPdfjsActor() {
+  let win = Services.wm.getMostRecentWindow("navigator:browser");
+  let selectedBrowser = win.gBrowser.selectedBrowser;
+  return selectedBrowser.browsingContext.currentWindowGlobal.getActor("Pdfjs");
+}
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_notification_close_on_navigation.js b/toolkit/components/pdfjs/test/browser_pdfjs_notification_close_on_navigation.js
new file mode 100644
index 0000000000..a6d4cf0a45
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_notification_close_on_navigation.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+add_task(async function test_notification_is_removed_upon_navigation() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+
+      // Trigger the PDFjs fallback notification bar
+      await ContentTask.spawn(browser, null, async () => {
+        content.wrappedJSObject.PDFViewerApplication.fallback();
+      });
+
+      let notification = await TestUtils.waitForCondition(
+        () =>
+          browser &&
+          gBrowser.getNotificationBox(browser) &&
+          gBrowser.getNotificationBox(browser).currentNotification,
+        "waiting for notification"
+      );
+      ok(notification, "A notification should be shown");
+      is(
+        notification.getAttribute("value"),
+        "pdfjs-fallback",
+        "Notification should be pdfjs-fallback"
+      );
+
+      BrowserTestUtils.loadURI(browser, "https://example.com");
+
+      await TestUtils.waitForCondition(
+        () => !notification.parentNode,
+        "notification should be removed upon navigation to example.com"
+      );
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_octet_stream.js b/toolkit/components/pdfjs/test/browser_pdfjs_octet_stream.js
new file mode 100644
index 0000000000..bb6a228532
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_octet_stream.js
@@ -0,0 +1,81 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TESTROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content/",
+  "http://mochi.test:8888/"
+);
+
+// Get a ref to the pdf we want to open.
+const PDF_URL = TESTROOT + "file_pdfjs_object_stream.pdf";
+
+var gMIMEService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+
+/**
+ * Check that if we open a PDF with octet-stream mimetype, it can load
+ * PDF.js .
+ */
+add_task(async function test_octet_stream_opens_pdfjs() {
+  await SpecialPowers.pushPrefEnv({ set: [["pdfjs.handleOctetStream", true]] });
+  let handlerInfo = gMIMEService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(newTabBrowser) {
+      await waitForPdfJS(newTabBrowser, PDF_URL);
+      is(newTabBrowser.currentURI.spec, PDF_URL, "Should load pdfjs");
+    }
+  );
+});
+
+/**
+ * Check that if the octet-stream thing is in a frame, we don't load it inside
+ * PDF.js
+ */
+add_task(async function test_octet_stream_in_frame_downloads() {
+  await SpecialPowers.pushPrefEnv({ set: [["pdfjs.handleOctetStream", true]] });
+
+  let handlerInfo = gMIMEService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  let dialogPromise = BrowserTestUtils.domWindowOpenedAndLoaded();
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: `data:text/html,<iframe src='${PDF_URL}'>` },
+    async function(newTabBrowser) {
+      let dialogWin = await dialogPromise;
+      ok(dialogWin, "Should have a dialog asking what to do.");
+      dialogWin.close(); // This is going to cancel the dialog.
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_saveas.js b/toolkit/components/pdfjs/test/browser_pdfjs_saveas.js
new file mode 100644
index 0000000000..03ee7012b9
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_saveas.js
@@ -0,0 +1,135 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+var MockFilePicker = SpecialPowers.MockFilePicker;
+MockFilePicker.init(window);
+
+/* import-globals-from ../../../content/tests/browser/common/mockTransfer.js */
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/content/tests/browser/common/mockTransfer.js",
+  this
+);
+
+function createTemporarySaveDirectory() {
+  var saveDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
+  saveDir.append("testsavedir");
+  if (!saveDir.exists()) {
+    saveDir.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+  }
+  return saveDir;
+}
+
+function createPromiseForTransferComplete(expectedFileName, destFile) {
+  return new Promise(resolve => {
+    MockFilePicker.showCallback = fp => {
+      info("Filepicker shown, checking filename");
+      is(fp.defaultString, expectedFileName, "Filename should be correct.");
+      let fileName = fp.defaultString;
+      destFile.append(fileName);
+
+      MockFilePicker.setFiles([destFile]);
+      MockFilePicker.filterIndex = 0; // kSaveAsType_Complete
+
+      MockFilePicker.showCallback = null;
+      mockTransferCallback = function(downloadSuccess) {
+        ok(downloadSuccess, "File should have been downloaded successfully");
+        mockTransferCallback = () => {};
+        resolve();
+      };
+    };
+  });
+}
+
+let tempDir = createTemporarySaveDirectory();
+
+add_task(async function setup() {
+  mockTransferRegisterer.register();
+  registerCleanupFunction(function() {
+    mockTransferRegisterer.unregister();
+    MockFilePicker.cleanup();
+    tempDir.remove(true);
+  });
+});
+
+/**
+ * Check triggering "Save Page As" on a non-forms PDF opens the "Save As" dialog
+ * and successfully saves the file.
+ */
+add_task(async function test_pdf_saveas() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJS(browser, TESTROOT + "file_pdfjs_test.pdf");
+      let destFile = tempDir.clone();
+      MockFilePicker.displayDirectory = tempDir;
+      let fileSavedPromise = createPromiseForTransferComplete(
+        "file_pdfjs_test.pdf",
+        destFile
+      );
+      saveBrowser(browser);
+      await fileSavedPromise;
+    }
+  );
+});
+
+/**
+ * Check triggering "Save Page As" on a PDF with forms that has been modified
+ * does the following:
+ * 1) opens the "Save As" dialog
+ * 2) successfully saves the file
+ * 3) the new file contains the new form data
+ */
+add_task(async function test_pdf_saveas_forms() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["pdfjs.renderInteractiveForms", true]],
+  });
+  let destFile = tempDir.clone();
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJSAnnotationLayer(
+        browser,
+        TESTROOT + "file_pdfjs_form.pdf"
+      );
+      // Fill in the form input field.
+      await SpecialPowers.spawn(browser, [], async function() {
+        let formInput = content.document.querySelector(
+          "#viewerContainer input"
+        );
+        ok(formInput, "PDF contains text field.");
+        is(formInput.value, "", "Text field is empty to start.");
+        formInput.value = "test";
+        formInput.dispatchEvent(new content.window.Event("input"));
+      });
+
+      MockFilePicker.displayDirectory = tempDir;
+      let fileSavedPromise = createPromiseForTransferComplete(
+        "file_pdfjs_form.pdf",
+        destFile
+      );
+      saveBrowser(browser);
+      await fileSavedPromise;
+    }
+  );
+
+  // Now that the file has been modified and saved, load it to verify the form
+  // data persisted.
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      await waitForPdfJSAnnotationLayer(browser, NetUtil.newURI(destFile).spec);
+      await SpecialPowers.spawn(browser, [], async function() {
+        let formInput = content.document.querySelector(
+          "#viewerContainer input"
+        );
+        ok(formInput, "PDF contains text field.");
+        is(formInput.value, "test", "Text field is filled in.");
+      });
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_savedialog.js b/toolkit/components/pdfjs/test/browser_pdfjs_savedialog.js
new file mode 100644
index 0000000000..c59985a5cf
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_savedialog.js
@@ -0,0 +1,43 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+function test() {
+  var oldAction = changeMimeHandler(Ci.nsIHandlerInfo.useSystemDefault, true);
+  var tab = BrowserTestUtils.addTab(gBrowser, TESTROOT + "file_pdfjs_test.pdf");
+  // Test: "Open with" dialog comes up when pdf.js is not selected as the default
+  // handler.
+  addWindowListener(
+    "chrome://mozapps/content/downloads/unknownContentType.xhtml",
+    finish
+  );
+
+  waitForExplicitFinish();
+  registerCleanupFunction(function() {
+    changeMimeHandler(oldAction[0], oldAction[1]);
+    gBrowser.removeTab(tab);
+  });
+}
+
+function addWindowListener(aURL, aCallback) {
+  Services.wm.addListener({
+    onOpenWindow(aXULWindow) {
+      info("window opened, waiting for focus");
+      Services.wm.removeListener(this);
+
+      var domwindow = aXULWindow.docShell.domWindow;
+      waitForFocus(function() {
+        is(
+          domwindow.document.location.href,
+          aURL,
+          "should have seen the right window open"
+        );
+        domwindow.close();
+        aCallback();
+      }, domwindow);
+    },
+    onCloseWindow(aXULWindow) {},
+  });
+}
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_views.js b/toolkit/components/pdfjs/test/browser_pdfjs_views.js
new file mode 100644
index 0000000000..f2d95c02a6
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_views.js
@@ -0,0 +1,108 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+add_task(async function test() {
+  let mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+  let handlerInfo = mimeService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  info("Pref action: " + handlerInfo.preferredAction);
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(browser) {
+      // check that PDF is opened with internal viewer
+      await waitForPdfJS(browser, TESTROOT + "file_pdfjs_test.pdf");
+
+      await SpecialPowers.spawn(browser, [], async function() {
+        Assert.ok(
+          content.document.querySelector("div#viewer"),
+          "document content has viewer UI"
+        );
+
+        // open sidebar
+        var sidebar = content.document.querySelector("button#sidebarToggle");
+        var outerContainer = content.document.querySelector(
+          "div#outerContainer"
+        );
+
+        sidebar.click();
+        Assert.ok(
+          outerContainer.classList.contains("sidebarOpen"),
+          "sidebar opens on click"
+        );
+
+        // check that thumbnail view is open
+        var thumbnailView = content.document.querySelector("div#thumbnailView");
+        var outlineView = content.document.querySelector("div#outlineView");
+
+        Assert.equal(
+          thumbnailView.getAttribute("class"),
+          null,
+          "Initial view is thumbnail view"
+        );
+        Assert.equal(
+          outlineView.getAttribute("class"),
+          "hidden",
+          "Outline view is hidden initially"
+        );
+
+        // switch to outline view
+        var viewOutlineButton = content.document.querySelector(
+          "button#viewOutline"
+        );
+        viewOutlineButton.click();
+
+        Assert.equal(
+          thumbnailView.getAttribute("class"),
+          "hidden",
+          "Thumbnail view is hidden when outline is selected"
+        );
+        Assert.equal(
+          outlineView.getAttribute("class"),
+          "",
+          "Outline view is visible when selected"
+        );
+
+        // switch back to thumbnail view
+        var viewThumbnailButton = content.document.querySelector(
+          "button#viewThumbnail"
+        );
+        viewThumbnailButton.click();
+
+        Assert.equal(
+          thumbnailView.getAttribute("class"),
+          "",
+          "Thumbnail view is visible when selected"
+        );
+        Assert.equal(
+          outlineView.getAttribute("class"),
+          "hidden",
+          "Outline view is hidden when thumbnail is selected"
+        );
+
+        sidebar.click();
+
+        var viewer = content.wrappedJSObject.PDFViewerApplication;
+        await viewer.close();
+      });
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/browser_pdfjs_zoom.js b/toolkit/components/pdfjs/test/browser_pdfjs_zoom.js
new file mode 100644
index 0000000000..0d55c30fb8
--- /dev/null
+++ b/toolkit/components/pdfjs/test/browser_pdfjs_zoom.js
@@ -0,0 +1,272 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+requestLongerTimeout(2);
+
+const RELATIVE_DIR = "toolkit/components/pdfjs/test/";
+const TESTROOT = "http://example.com/browser/" + RELATIVE_DIR;
+
+const TESTS = [
+  {
+    action: {
+      selector: "button#zoomIn",
+      event: "click",
+    },
+    expectedZoom: 1, // 1 - zoom in
+    message: "Zoomed in using the '+' (zoom in) button",
+  },
+
+  {
+    action: {
+      selector: "button#zoomOut",
+      event: "click",
+    },
+    expectedZoom: -1, // -1 - zoom out
+    message: "Zoomed out using the '-' (zoom out) button",
+  },
+
+  {
+    action: {
+      keyboard: true,
+      keyCode: 61,
+      event: "+",
+    },
+    expectedZoom: 1, // 1 - zoom in
+    message: "Zoomed in using the CTRL++ keys",
+  },
+
+  {
+    action: {
+      keyboard: true,
+      keyCode: 109,
+      event: "-",
+    },
+    expectedZoom: -1, // -1 - zoom out
+    message: "Zoomed out using the CTRL+- keys",
+  },
+
+  {
+    action: {
+      selector: "select#scaleSelect",
+      index: 5,
+      event: "change",
+    },
+    expectedZoom: -1, // -1 - zoom out
+    message: "Zoomed using the zoom picker",
+  },
+];
+
+add_task(async function test() {
+  let mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+  let handlerInfo = mimeService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+
+  // Make sure pdf.js is the default handler.
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    false,
+    "pdf handler defaults to always-ask is false"
+  );
+  is(
+    handlerInfo.preferredAction,
+    Ci.nsIHandlerInfo.handleInternally,
+    "pdf handler defaults to internal"
+  );
+
+  info("Pref action: " + handlerInfo.preferredAction);
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(newTabBrowser) {
+      await waitForPdfJS(
+        newTabBrowser,
+        TESTROOT + "file_pdfjs_test.pdf#zoom=100"
+      );
+
+      await SpecialPowers.spawn(newTabBrowser, [TESTS], async function(
+        contentTESTS
+      ) {
+        let document = content.document;
+
+        function waitForRender() {
+          return new Promise(resolve => {
+            document.addEventListener(
+              "pagerendered",
+              function onPageRendered(e) {
+                if (e.detail.pageNumber !== 1) {
+                  return;
+                }
+
+                document.removeEventListener(
+                  "pagerendered",
+                  onPageRendered,
+                  true
+                );
+                resolve();
+              },
+              true
+            );
+          });
+        }
+
+        // check that PDF is opened with internal viewer
+        Assert.ok(
+          content.document.querySelector("div#viewer"),
+          "document content has viewer UI"
+        );
+
+        let initialWidth, previousWidth;
+        initialWidth = previousWidth = parseInt(
+          content.document.querySelector("div.page[data-page-number='1']").style
+            .width
+        );
+
+        for (let subTest of contentTESTS) {
+          // We zoom using an UI element
+          var ev;
+          if (subTest.action.selector) {
+            // Get the element and trigger the action for changing the zoom
+            var el = document.querySelector(subTest.action.selector);
+            Assert.ok(
+              el,
+              "Element '" + subTest.action.selector + "' has been found"
+            );
+
+            if (subTest.action.index) {
+              el.selectedIndex = subTest.action.index;
+            }
+
+            // Dispatch the event for changing the zoom
+            ev = new content.Event(subTest.action.event);
+          } else {
+            // We zoom using keyboard
+            // Simulate key press
+            ev = new content.KeyboardEvent("keydown", {
+              key: subTest.action.event,
+              keyCode: subTest.action.keyCode,
+              ctrlKey: true,
+            });
+            el = content;
+          }
+
+          el.dispatchEvent(ev);
+          await waitForRender();
+
+          var pageZoomScale = content.document.querySelector(
+            "select#scaleSelect"
+          );
+
+          // The zoom value displayed in the zoom select
+          var zoomValue =
+            pageZoomScale.options[pageZoomScale.selectedIndex].innerHTML;
+
+          let pageContainer = content.document.querySelector(
+            "div.page[data-page-number='1']"
+          );
+          let actualWidth = parseInt(pageContainer.style.width);
+
+          // the actual zoom of the PDF document
+          let computedZoomValue =
+            parseInt((actualWidth / initialWidth).toFixed(2) * 100) + "%";
+          Assert.equal(
+            computedZoomValue,
+            zoomValue,
+            "Content has correct zoom"
+          );
+
+          // Check that document zooms in the expected way (in/out)
+          let zoom = (actualWidth - previousWidth) * subTest.expectedZoom;
+          Assert.ok(zoom > 0, subTest.message);
+
+          previousWidth = actualWidth;
+        }
+
+        var viewer = content.wrappedJSObject.PDFViewerApplication;
+        await viewer.close();
+      });
+    }
+  );
+});
+
+// Performs a SpecialPowers.spawn round-trip to ensure that any setup
+// that needs to be done in the content process by any pending tasks has
+// a chance to complete before continuing.
+function waitForRoundTrip(browser) {
+  return SpecialPowers.spawn(browser, [], () => {});
+}
+
+async function waitForRenderAndGetWidth(newTabBrowser) {
+  return SpecialPowers.spawn(newTabBrowser, [], async function() {
+    function waitForRender(document) {
+      return new Promise(resolve => {
+        document.addEventListener(
+          "pagerendered",
+          function onPageRendered(e) {
+            if (e.detail.pageNumber !== 1) {
+              return;
+            }
+
+            document.removeEventListener("pagerendered", onPageRendered, true);
+            resolve();
+          },
+          true
+        );
+      });
+    }
+    // check that PDF is opened with internal viewer
+    Assert.ok(
+      content.document.querySelector("div#viewer"),
+      "document content has viewer UI"
+    );
+
+    await waitForRender(content.document);
+
+    return parseInt(
+      content.document.querySelector("div.page[data-page-number='1']").style
+        .width
+    );
+  });
+}
+
+add_task(async function test_browser_zoom() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function(newTabBrowser) {
+      await waitForPdfJS(newTabBrowser, TESTROOT + "file_pdfjs_test.pdf");
+
+      const initialWidth = await waitForRenderAndGetWidth(newTabBrowser);
+
+      // Zoom in
+      let newWidthPromise = waitForRenderAndGetWidth(newTabBrowser);
+      await waitForRoundTrip(newTabBrowser);
+      FullZoom.enlarge();
+      ok(
+        (await newWidthPromise) > initialWidth,
+        "Zoom in makes the page bigger."
+      );
+
+      // Reset
+      newWidthPromise = waitForRenderAndGetWidth(newTabBrowser);
+      await waitForRoundTrip(newTabBrowser);
+      FullZoom.reset();
+      is(await newWidthPromise, initialWidth, "Zoom reset restores page.");
+
+      // Zoom out
+      newWidthPromise = waitForRenderAndGetWidth(newTabBrowser);
+      await waitForRoundTrip(newTabBrowser);
+      FullZoom.reduce();
+      ok(
+        (await newWidthPromise) < initialWidth,
+        "Zoom out makes the page smaller."
+      );
+
+      // Clean-up after the PDF viewer.
+      await SpecialPowers.spawn(newTabBrowser, [], function() {
+        const viewer = content.wrappedJSObject.PDFViewerApplication;
+        return viewer.close();
+      });
+    }
+  );
+});
diff --git a/toolkit/components/pdfjs/test/file_pdfjs_form.pdf b/toolkit/components/pdfjs/test/file_pdfjs_form.pdf
new file mode 100644
index 0000000000..c6eff988a6
--- /dev/null
+++ b/toolkit/components/pdfjs/test/file_pdfjs_form.pdf
diff --git a/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf b/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf
new file mode 100644
index 0000000000..89066463f1
--- /dev/null
+++ b/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf
diff --git a/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf^headers^ b/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf^headers^
new file mode 100644
index 0000000000..ff8fb3126e
--- /dev/null
+++ b/toolkit/components/pdfjs/test/file_pdfjs_object_stream.pdf^headers^
@@ -0,0 +1,2 @@
+Content-Type: application/octet-stream
+
diff --git a/toolkit/components/pdfjs/test/file_pdfjs_test.pdf b/toolkit/components/pdfjs/test/file_pdfjs_test.pdf
new file mode 100644
index 0000000000..7ad87e3c2e
--- /dev/null
+++ b/toolkit/components/pdfjs/test/file_pdfjs_test.pdf
diff --git a/toolkit/components/pdfjs/test/head.js b/toolkit/components/pdfjs/test/head.js
new file mode 100644
index 0000000000..bca608e1f0
--- /dev/null
+++ b/toolkit/components/pdfjs/test/head.js
@@ -0,0 +1,71 @@
+async function waitForPdfJS(browser, url) {
+  await SpecialPowers.pushPrefEnv({
+    set: [["pdfjs.eventBusDispatchToDOM", true]],
+  });
+  // Runs tests after all "load" event handlers have fired off
+  let loadPromise = BrowserTestUtils.waitForContentEvent(
+    browser,
+    "documentloaded",
+    false,
+    null,
+    true
+  );
+  await SpecialPowers.spawn(browser, [url], contentUrl => {
+    content.location = contentUrl;
+  });
+  return loadPromise;
+}
+
+async function waitForPdfJSAnnotationLayer(browser, url) {
+  await SpecialPowers.pushPrefEnv({
+    set: [["pdfjs.eventBusDispatchToDOM", true]],
+  });
+  let loadPromise = BrowserTestUtils.waitForContentEvent(
+    browser,
+    "annotationlayerrendered",
+    false,
+    null,
+    true
+  );
+  await SpecialPowers.spawn(browser, [url], contentUrl => {
+    content.location = contentUrl;
+  });
+  return loadPromise;
+}
+
+function changeMimeHandler(preferredAction, alwaysAskBeforeHandling) {
+  let handlerService = Cc[
+    "@mozilla.org/uriloader/handler-service;1"
+  ].getService(Ci.nsIHandlerService);
+  let mimeService = Cc["@mozilla.org/mime;1"].getService(Ci.nsIMIMEService);
+  let handlerInfo = mimeService.getFromTypeAndExtension(
+    "application/pdf",
+    "pdf"
+  );
+  var oldAction = [
+    handlerInfo.preferredAction,
+    handlerInfo.alwaysAskBeforeHandling,
+  ];
+
+  // Change and save mime handler settings
+  handlerInfo.alwaysAskBeforeHandling = alwaysAskBeforeHandling;
+  handlerInfo.preferredAction = preferredAction;
+  handlerService.store(handlerInfo);
+
+  // Refresh data
+  handlerInfo = mimeService.getFromTypeAndExtension("application/pdf", "pdf");
+
+  // Test: Mime handler was updated
+  is(
+    handlerInfo.alwaysAskBeforeHandling,
+    alwaysAskBeforeHandling,
+    "always-ask prompt change successful"
+  );
+  is(
+    handlerInfo.preferredAction,
+    preferredAction,
+    "mime handler change successful"
+  );
+
+  return oldAction;
+}