@vaadin-component-factory/vcf-pdf-viewer 0.9.0 → 0.9.4

package/{src/shared → pdfjs/dist}/util.js

@@ -1,4 +1,26 @@
-/* Copyright 2012 Mozilla Foundation
+/* 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.
+ */
+
+/* globals process */
+// NW.js / Electron is a browser context, but copies some Node.js objects; see
+// http://docs.nwjs.io/en/latest/For%20Users/Advanced/JavaScript%20Contexts%20in%20NW.js/#access-nodejs-and-nwjs-api-in-browser-context
+// https://www.electronjs.org/docs/api/process#processversionselectron-readonly
+// https://www.electronjs.org/docs/api/process#processtype-readonly
+const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
+
+/* Copyright 2017 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,12 +35,125 @@
  * limitations under the License.
  */
 
-import "./compatibility.js";
+if ((typeof PDFJSDev === "undefined" || !PDFJSDev.test("SKIP_BABEL")) && (typeof globalThis === "undefined" || !globalThis._pdfjsCompatibilityChecked)) {
+  // Provides support for globalThis in legacy browsers.
+  // Support: Firefox<65, Chrome<71, Safari<12.1
+  if (typeof globalThis === "undefined" || globalThis.Math !== Math) {
+    // eslint-disable-next-line no-global-assign
+    globalThis = require("core-js/es/global-this");
+  }
+
+  globalThis._pdfjsCompatibilityChecked = true; // Support: Node.js
+
+  (function checkNodeBtoa() {
+    if (globalThis.btoa || !isNodeJS) {
+      return;
+    }
+
+    globalThis.btoa = function (chars) {
+      // eslint-disable-next-line no-undef
+      return Buffer.from(chars, "binary").toString("base64");
+    };
+  })(); // Support: Node.js
+
+
+  (function checkNodeAtob() {
+    if (globalThis.atob || !isNodeJS) {
+      return;
+    }
+
+    globalThis.atob = function (input) {
+      // eslint-disable-next-line no-undef
+      return Buffer.from(input, "base64").toString("binary");
+    };
+  })(); // Support: Node.js
+
 
+  (function checkDOMMatrix() {
+    if (globalThis.DOMMatrix || !isNodeJS) {
+      return;
+    }
+
+    globalThis.DOMMatrix = require("dommatrix/dist/dommatrix.js");
+  })(); // Provides support for Object.fromEntries in legacy browsers.
+  // Support: Firefox<63, Chrome<73, Safari<12.1, Node.js<12.0.0
+
+
+  (function checkObjectFromEntries() {
+    if (Object.fromEntries) {
+      return;
+    }
+
+    require("core-js/es/object/from-entries.js");
+  })(); // Provides support for *recent* additions to the Promise specification,
+  // however basic Promise support is assumed to be available natively.
+  // Support: Firefox<71, Chrome<76, Safari<13, Node.js<12.9.0
+
+
+  (function checkPromise() {
+    if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("IMAGE_DECODERS")) {
+      // The current image decoders are synchronous, hence `Promise` shouldn't
+      // need to be polyfilled for the IMAGE_DECODERS build target.
+      return;
+    }
+
+    if (globalThis.Promise.allSettled) {
+      return;
+    }
+
+    globalThis.Promise = require("core-js/es/promise/index.js");
+  })(); // Support: Node.js
+
+
+  (function checkReadableStream() {
+    if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("IMAGE_DECODERS")) {
+      // The current image decoders are synchronous, hence `ReadableStream`
+      // shouldn't need to be polyfilled for the IMAGE_DECODERS build target.
+      return;
+    }
+
+    let isReadableStreamSupported = false;
+
+    if (typeof ReadableStream !== "undefined") {
+      // MS Edge may say it has ReadableStream but they are not up to spec yet.
+      try {
+        // eslint-disable-next-line no-new
+        new ReadableStream({
+          start(controller) {
+            controller.close();
+          }
+
+        });
+        isReadableStreamSupported = true;
+      } catch (e) {// The ReadableStream constructor cannot be used.
+      }
+    }
+
+    if (isReadableStreamSupported) {
+      return;
+    }
+
+    globalThis.ReadableStream = require("web-streams-polyfill/dist/ponyfill.js").ReadableStream;
+  })();
+}
+
+/* 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.
+ */
 const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
-const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
+const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0]; // Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.
 
-// Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.
 const PermissionFlag = {
   PRINT: 0x04,
   MODIFY_CONTENTS: 0x08,
@@ -27,9 +162,8 @@ const PermissionFlag = {
   FILL_INTERACTIVE_FORMS: 0x100,
   COPY_FOR_ACCESSIBILITY: 0x200,
   ASSEMBLE: 0x400,
-  PRINT_HIGH_QUALITY: 0x800,
+  PRINT_HIGH_QUALITY: 0x800
 };
-
 const TextRenderingMode = {
   FILL: 0,
   STROKE: 1,
@@ -40,15 +174,13 @@ const TextRenderingMode = {
   FILL_STROKE_ADD_TO_PATH: 6,
   ADD_TO_PATH: 7,
   FILL_STROKE_MASK: 3,
-  ADD_TO_PATH_FLAG: 4,
+  ADD_TO_PATH_FLAG: 4
 };
-
 const ImageKind = {
   GRAYSCALE_1BPP: 1,
   RGB_24BPP: 2,
-  RGBA_32BPP: 3,
+  RGBA_32BPP: 3
 };
-
 const AnnotationType = {
   TEXT: 1,
   LINK: 2,
@@ -75,32 +207,12 @@ const AnnotationType = {
   TRAPNET: 23,
   WATERMARK: 24,
   THREED: 25,
-  REDACT: 26,
+  REDACT: 26
 };
-
-const AnnotationStateModelType = {
-  MARKED: "Marked",
-  REVIEW: "Review",
-};
-
-const AnnotationMarkedState = {
-  MARKED: "Marked",
-  UNMARKED: "Unmarked",
-};
-
-const AnnotationReviewState = {
-  ACCEPTED: "Accepted",
-  REJECTED: "Rejected",
-  CANCELLED: "Cancelled",
-  COMPLETED: "Completed",
-  NONE: "None",
-};
-
 const AnnotationReplyType = {
   GROUP: "Group",
-  REPLY: "R",
+  REPLY: "R"
 };
-
 const AnnotationFlag = {
   INVISIBLE: 0x01,
   HIDDEN: 0x02,
@@ -111,9 +223,8 @@ const AnnotationFlag = {
   READONLY: 0x40,
   LOCKED: 0x80,
   TOGGLENOVIEW: 0x100,
-  LOCKEDCONTENTS: 0x200,
+  LOCKEDCONTENTS: 0x200
 };
-
 const AnnotationFieldFlag = {
   READONLY: 0x0000001,
   REQUIRED: 0x0000002,
@@ -133,17 +244,15 @@ const AnnotationFieldFlag = {
   COMB: 0x1000000,
   RICHTEXT: 0x2000000,
   RADIOSINUNISON: 0x2000000,
-  COMMITONSELCHANGE: 0x4000000,
+  COMMITONSELCHANGE: 0x4000000
 };
-
 const AnnotationBorderStyleType = {
   SOLID: 1,
   DASHED: 2,
   BEVELED: 3,
   INSET: 4,
-  UNDERLINE: 5,
+  UNDERLINE: 5
 };
-
 const AnnotationActionEventType = {
   E: "Mouse Enter",
   X: "Mouse Exit",
@@ -158,22 +267,19 @@ const AnnotationActionEventType = {
   K: "Keystroke",
   F: "Format",
   V: "Validate",
-  C: "Calculate",
+  C: "Calculate"
 };
-
 const DocumentActionEventType = {
   WC: "WillClose",
   WS: "WillSave",
   DS: "DidSave",
   WP: "WillPrint",
-  DP: "DidPrint",
+  DP: "DidPrint"
 };
-
 const PageActionEventType = {
   O: "PageOpen",
-  C: "PageClose",
+  C: "PageClose"
 };
-
 const StreamType = {
   UNKNOWN: "UNKNOWN",
   FLATE: "FLATE",
@@ -184,9 +290,9 @@ const StreamType = {
   A85: "A85",
   AHX: "AHX",
   CCF: "CCF",
-  RLX: "RLX", // PDF short name is 'RL', but telemetry requires three chars.
-};
+  RLX: "RLX" // PDF short name is 'RL', but telemetry requires three chars.
 
+};
 const FontType = {
   UNKNOWN: "UNKNOWN",
   TYPE1: "TYPE1",
@@ -199,22 +305,19 @@ const FontType = {
   TYPE3: "TYPE3",
   OPENTYPE: "OPENTYPE",
   TYPE0: "TYPE0",
-  MMTYPE1: "MMTYPE1",
+  MMTYPE1: "MMTYPE1"
 };
-
 const VerbosityLevel = {
   ERRORS: 0,
   WARNINGS: 1,
-  INFOS: 5,
+  INFOS: 5
 };
-
 const CMapCompressionType = {
   NONE: 0,
   BINARY: 1,
-  STREAM: 2,
-};
+  STREAM: 2
+}; // All the possible operations for an operator list.
 
-// All the possible operations for an operator list.
 const OPS = {
   // Intentionally start from 1 so it is easy to spot bad operators that will be
   // 0's.
@@ -308,9 +411,8 @@ const OPS = {
   paintImageXObjectRepeat: 88,
   paintImageMaskXObjectRepeat: 89,
   paintSolidColorImageMask: 90,
-  constructPath: 91,
+  constructPath: 91
 };
-
 const UNSUPPORTED_FEATURES = {
   /** @deprecated unused */
   unknown: "unknown",
@@ -319,6 +421,7 @@ const UNSUPPORTED_FEATURES = {
   signatures: "signatures",
   smask: "smask",
   shadingPattern: "shadingPattern",
+
   /** @deprecated unused */
   font: "font",
   errorTilingPattern: "errorTilingPattern",
@@ -334,14 +437,12 @@ const UNSUPPORTED_FEATURES = {
   errorFontLoadNative: "errorFontLoadNative",
   errorFontBuildPath: "errorFontBuildPath",
   errorFontGetPath: "errorFontGetPath",
-  errorMarkedContent: "errorMarkedContent",
+  errorMarkedContent: "errorMarkedContent"
 };
-
 const PasswordResponses = {
   NEED_PASSWORD: 1,
-  INCORRECT_PASSWORD: 2,
+  INCORRECT_PASSWORD: 2
 };
-
 let verbosity = VerbosityLevel.WARNINGS;
 
 function setVerbosityLevel(level) {
@@ -352,18 +453,18 @@ function setVerbosityLevel(level) {
 
 function getVerbosityLevel() {
   return verbosity;
-}
-
-// A notice for devs. These are good for things that are helpful to devs, such
+} // A notice for devs. These are good for things that are helpful to devs, such
 // as warning that Workers were disabled, which is important to devs but not
 // end users.
+
+
 function info(msg) {
   if (verbosity >= VerbosityLevel.INFOS) {
     console.log(`Info: ${msg}`);
   }
-}
+} // Non-fatal warnings.
+
 
-// Non-fatal warnings.
 function warn(msg) {
   if (verbosity >= VerbosityLevel.WARNINGS) {
     console.log(`Warning: ${msg}`);
@@ -378,13 +479,15 @@ function assert(cond, msg) {
   if (!cond) {
     unreachable(msg);
   }
-}
+} // Checks if URLs have the same origin. For non-HTTP based URLs, returns false.
+
 
-// Checks if URLs have the same origin. For non-HTTP based URLs, returns false.
 function isSameOrigin(baseUrl, otherUrl) {
   let base;
+
   try {
     base = new URL(baseUrl);
+
     if (!base.origin || base.origin === "null") {
       return false; // non-HTTP url
     }
@@ -394,13 +497,14 @@ function isSameOrigin(baseUrl, otherUrl) {
 
   const other = new URL(otherUrl, base);
   return base.origin === other.origin;
-}
+} // Checks if URLs use one of the allowed protocols, e.g. to avoid XSS.
+
 
-// Checks if URLs use one of the allowed protocols, e.g. to avoid XSS.
 function _isValidProtocol(url) {
   if (!url) {
     return false;
   }
+
   switch (url.protocol) {
     case "http:":
     case "https:":
@@ -408,11 +512,11 @@ function _isValidProtocol(url) {
     case "mailto:":
     case "tel:":
       return true;
+
     default:
       return false;
   }
 }
-
 /**
  * Attempts to create a valid absolute URL.
  *
@@ -420,18 +524,23 @@ function _isValidProtocol(url) {
  * @param {URL|string} baseUrl - An absolute URL.
  * @returns Either a valid {URL}, or `null` otherwise.
  */
+
+
 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) {
     /* `new URL()` will throw on incorrect data. */
   }
+
   return null;
 }
 
@@ -440,34 +549,37 @@ function shadow(obj, prop, value) {
     value,
     enumerable: true,
     configurable: true,
-    writable: false,
+    writable: false
   });
   return value;
 }
-
 /**
  * @type {any}
  */
-const BaseException = (function BaseExceptionClosure() {
+
+
+const BaseException = function BaseExceptionClosure() {
   // eslint-disable-next-line no-shadow
   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;
-})();
+}();
 
 class PasswordException extends BaseException {
   constructor(msg, code) {
     super(msg);
     this.code = code;
   }
+
 }
 
 class UnknownErrorException extends BaseException {
@@ -475,6 +587,7 @@ class UnknownErrorException extends BaseException {
     super(msg);
     this.details = details;
   }
+
 }
 
 class InvalidPDFException extends BaseException {}
@@ -486,47 +599,52 @@ class UnexpectedResponseException extends BaseException {
     super(msg);
     this.status = status;
   }
-}
 
+}
 /**
  * Error caused during parsing PDF data.
  */
-class FormatError extends BaseException {}
 
+
+class FormatError extends BaseException {}
 /**
  * Error used to indicate task cancellation.
  */
+
+
 class AbortException extends BaseException {}
 
 const NullCharactersRegExp = /\x00/g;
-
 /**
  * @param {string} str
  */
+
 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"
-  );
+  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("");
 }
 
@@ -534,45 +652,55 @@ 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;
 }
-
 /**
  * Gets length of the array (Array, Uint8Array, or string) in bytes.
  * @param {Array<any>|Uint8Array|string} arr
  * @returns {number}
  */
+
+
 function arrayByteLength(arr) {
   if (arr.length !== undefined) {
     return arr.length;
   }
+
   assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
   return arr.byteLength;
 }
-
 /**
  * Combines array items (arrays) into single Uint8Array object.
  * @param {Array<Array<any>|Uint8Array|string>} arr - the array of the arrays
  *   (Array, Uint8Array, or string).
  * @returns {Uint8Array}
  */
+
+
 function arraysToBytes(arr) {
-  const length = arr.length;
-  // Shortcut: if first and only item is Uint8Array, return it.
+  const length = arr.length; // Shortcut: if first and only item is Uint8Array, return it.
+
   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);
@@ -580,95 +708,83 @@ function arraysToBytes(arr) {
         item = new Uint8Array(item);
       }
     }
+
     const itemLength = item.byteLength;
     data.set(item, pos);
     pos += itemLength;
   }
+
   return data;
 }
 
 function string32(value) {
-  if (
-    typeof PDFJSDev === "undefined" ||
-    PDFJSDev.test("!PRODUCTION || TESTING")
-  ) {
-    assert(
-      typeof value === "number" && Math.abs(value) < 2 ** 32,
-      `string32: Unexpected input "${value}".`
-    );
+  if (typeof PDFJSDev === "undefined" || PDFJSDev.test("!PRODUCTION || TESTING")) {
+    assert(typeof value === "number" && Math.abs(value) < 2 ** 32, `string32: Unexpected input "${value}".`);
   }
-  return String.fromCharCode(
-    (value >> 24) & 0xff,
-    (value >> 16) & 0xff,
-    (value >> 8) & 0xff,
-    value & 0xff
-  );
+
+  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
 }
 
 function objectSize(obj) {
   return Object.keys(obj).length;
-}
-
-// Ensure that the returned Object has a `null` prototype; hence why
+} // Ensure that the returned Object has a `null` prototype; hence why
 // `Object.fromEntries(...)` is not used.
+
+
 function objectFromMap(map) {
   const obj = Object.create(null);
+
   for (const [key, value] of map) {
     obj[key] = value;
   }
+
   return obj;
-}
+} // Checks the endianness of the platform.
+
 
-// Checks the endianness of the platform.
 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());
-  },
-};
+  }
+
+}; // Checks if it's possible to eval JS expressions.
 
-// Checks if it's possible to eval JS expressions.
 function isEvalSupported() {
   try {
     new Function(""); // eslint-disable-line no-new, no-new-func
+
     return true;
   } catch (e) {
     return false;
   }
 }
+
 const IsEvalSupportedCached = {
   get value() {
     return shadow(this, "value", isEvalSupported());
-  },
-};
+  }
 
-const hexNumbers = [...Array(256).keys()].map(n =>
-  n.toString(16).padStart(2, "0")
-);
+};
+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]}`;
-  }
+  } // Concatenates two transformation matrices together and returns the result.
+
 
-  // Concatenates two transformation matrices together and returns the result.
   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],
-    ];
-  }
+    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]];
+  } // For 2d affine transforms
+
 
-  // For 2d affine transforms
   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];
@@ -680,121 +796,97 @@ class Util {
     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];
-  }
-
-  // Applies the transform to the rectangle and finds the minimum axially
+  } // Applies the transform to the rectangle and finds the minimum axially
   // aligned bounding box.
+
+
   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]),
-    ];
+    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,
-    ];
-  }
-
-  // Apply a generic 3d matrix M on a 3-vector v:
+    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];
+  } // Apply a generic 3d matrix M on a 3-vector v:
   //   | a b c |   | X |
   //   | d e f | x | Y |
   //   | g h i |   | Z |
   // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],
   // with v as [X,Y,Z]
-  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],
-    ];
-  }
 
-  // This calculation uses Singular Value Decomposition.
+
+  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]];
+  } // This calculation uses Singular Value Decomposition.
   // The SVD can be represented with formula A = USV. We are interested in the
   // matrix S here because it represents the scale values.
+
+
   static singularValueDecompose2dScale(m) {
-    const transpose = [m[0], m[2], m[1], m[3]];
+    const transpose = [m[0], m[2], m[1], m[3]]; // Multiply matrix m with its transpose.
 
-    // Multiply matrix m with its transpose.
     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 d = m[2] * transpose[1] + m[3] * transpose[3]; // Solve the second degree polynomial to get roots.
 
-    // Solve the second degree polynomial to get roots.
     const first = (a + d) / 2;
     const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
     const sx = first + second || 1;
-    const sy = first - second || 1;
+    const sy = first - second || 1; // Scale values are the square roots of the eigenvalues.
 
-    // Scale values are the square roots of the eigenvalues.
     return [Math.sqrt(sx), Math.sqrt(sy)];
-  }
-
-  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
+  } // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
   // For coordinate systems whose origin lies in the bottom-left, this
   // means normalization to (BL,TR) ordering. For systems with origin in the
   // top-left, this means (TL,BR) ordering.
+
+
   static normalizeRect(rect) {
     const r = rect.slice(0); // clone rect
+
     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;
-  }
 
-  // Returns a rectangle [x1, y1, x2, y2] corresponding to the
+    return r;
+  } // Returns a rectangle [x1, y1, x2, y2] corresponding to the
   // intersection of rect1 and rect2. If no intersection, returns 'false'
   // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
+
+
   static intersect(rect1, rect2) {
     function compare(a, b) {
       return a - b;
-    }
+    } // Order points along the axes
+
 
-    // Order points along the axes
     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);
+    rect2 = Util.normalizeRect(rect2); // X: first and second points belong to different rectangles?
 
-    // X: first and second points belong to different rectangles?
-    if (
-      (orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||
-      (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])
-    ) {
+    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
       // Intersection must be between second and third points
       result[0] = orderedX[1];
       result[2] = orderedX[2];
     } else {
       return null;
-    }
+    } // Y: first and second points belong to different rectangles?
+
 
-    // Y: first and second points belong to different rectangles?
-    if (
-      (orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||
-      (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])
-    ) {
+    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
       // Intersection must be between second and third points
       result[1] = orderedY[1];
       result[3] = orderedY[2];
@@ -804,36 +896,24 @@ class Util {
 
     return result;
   }
+
 }
 
-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,
-];
+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 = [];
+        strBuf = [];
+
   if (str[0] === "\xFE" && str[1] === "\xFF") {
     // UTF16BE BOM
     for (let i = 2; i < length; i += 2) {
-      strBuf.push(
-        String.fromCharCode((str.charCodeAt(i) << 8) | str.charCodeAt(i + 1))
-      );
+      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
     }
   } else if (str[0] === "\xFF" && str[1] === "\xFE") {
     // UTF16LE BOM
     for (let i = 2; i < length; i += 2) {
-      strBuf.push(
-        String.fromCharCode((str.charCodeAt(i + 1) << 8) | str.charCodeAt(i))
-      );
+      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
     }
   } else {
     for (let i = 0; i < length; ++i) {
@@ -841,6 +921,7 @@ function stringToPDFString(str) {
       strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
     }
   }
+
   return strBuf.join("");
 }
 
@@ -854,6 +935,7 @@ function escapeString(str) {
     } else if (match === "\r") {
       return "\\r";
     }
+
     return `\\${match}`;
   });
 }
@@ -864,13 +946,12 @@ function isAscii(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),
-      String.fromCharCode(char & 0xff)
-    );
+    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
   }
+
   return buf.join("");
 }
 
@@ -902,27 +983,20 @@ function isArrayEqual(arr1, arr2) {
   if (arr1.length !== arr2.length) {
     return false;
   }
+
   for (let i = 0, ii = arr1.length; i < ii; i++) {
     if (arr1[i] !== arr2[i]) {
       return false;
     }
   }
+
   return true;
 }
 
 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"),
-  ];
-
+  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("");
 }
-
 /**
  * Promise Capability object.
  *
@@ -939,20 +1013,23 @@ function getModificationDate(date = new Date()) {
  *
  * @returns {PromiseCapability}
  */
+
+
 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);
@@ -963,90 +1040,27 @@ function createPromiseCapability() {
 
 function createObjectURL(data, contentType = "", forceDataSchema = false) {
   if (URL.createObjectURL && !forceDataSchema) {
-    return URL.createObjectURL(new Blob([data], { type: contentType }));
-  }
-  // Blob/createObjectURL is not available, falling back to data schema.
-  const digits =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+    return URL.createObjectURL(new Blob([data], {
+      type: contentType
+    }));
+  } // Blob/createObjectURL is not available, falling back to data schema.
+
 
+  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
   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;
+          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;
 }
 
-export {
-  AbortException,
-  AnnotationActionEventType,
-  AnnotationBorderStyleType,
-  AnnotationFieldFlag,
-  AnnotationFlag,
-  AnnotationMarkedState,
-  AnnotationReplyType,
-  AnnotationReviewState,
-  AnnotationStateModelType,
-  AnnotationType,
-  arrayByteLength,
-  arraysToBytes,
-  assert,
-  BaseException,
-  bytesToString,
-  CMapCompressionType,
-  createObjectURL,
-  createPromiseCapability,
-  createValidAbsoluteUrl,
-  DocumentActionEventType,
-  escapeString,
-  FONT_IDENTITY_MATRIX,
-  FontType,
-  FormatError,
-  getModificationDate,
-  getVerbosityLevel,
-  IDENTITY_MATRIX,
-  ImageKind,
-  info,
-  InvalidPDFException,
-  isArrayBuffer,
-  isArrayEqual,
-  isAscii,
-  isBool,
-  IsEvalSupportedCached,
-  IsLittleEndianCached,
-  isNum,
-  isSameOrigin,
-  isString,
-  MissingPDFException,
-  objectFromMap,
-  objectSize,
-  OPS,
-  PageActionEventType,
-  PasswordException,
-  PasswordResponses,
-  PermissionFlag,
-  removeNullCharacters,
-  setVerbosityLevel,
-  shadow,
-  StreamType,
-  string32,
-  stringToBytes,
-  stringToPDFString,
-  stringToUTF16BEString,
-  stringToUTF8String,
-  TextRenderingMode,
-  UnexpectedResponseException,
-  UnknownErrorException,
-  unreachable,
-  UNSUPPORTED_FEATURES,
-  utf8StringToString,
-  Util,
-  VerbosityLevel,
-  warn,
-};
+export { utf8StringToString as $, AbortException as A, stringToPDFString as B, createObjectURL as C, CMapCompressionType as D, createValidAbsoluteUrl as E, FormatError as F, PasswordResponses as G, PermissionFlag as H, IsEvalSupportedCached as I, removeNullCharacters as J, BaseException as K, isString as L, MissingPDFException as M, objectSize as N, OPS as O, PasswordException as P, arrayByteLength as Q, arraysToBytes as R, StreamType as S, TextRenderingMode as T, UNSUPPORTED_FEATURES as U, VerbosityLevel as V, FontType as W, isBool as X, isArrayEqual as Y, stringToUTF8String as Z, DocumentActionEventType as _, string32 as a, escapeString as a0, AnnotationFlag as a1, AnnotationFieldFlag as a2, isAscii as a3, stringToUTF16BEString as a4, getModificationDate as a5, AnnotationReplyType as a6, AnnotationActionEventType as a7, PageActionEventType as a8, bytesToString as b, assert as c, info as d, Util as e, IDENTITY_MATRIX as f, FONT_IDENTITY_MATRIX as g, isNum as h, isNodeJS as i, ImageKind as j, IsLittleEndianCached as k, createPromiseCapability as l, isArrayBuffer as m, stringToBytes as n, objectFromMap as o, setVerbosityLevel as p, getVerbosityLevel as q, isSameOrigin as r, shadow as s, UnknownErrorException as t, unreachable as u, UnexpectedResponseException as v, warn as w, InvalidPDFException as x, AnnotationType as y, AnnotationBorderStyleType as z };