@chialab/pdfjs-lib 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/browser/{chunk-DYHYQ33L.js → chunk-AQCSGHG6.js}

@@ -2,7 +2,8 @@ import {
   __privateAdd,
   __privateGet,
   __privateMethod,
-  __privateSet
+  __privateSet,
+  __publicField
 } from "./chunk-O4UKW7AD.js";
 
 // src/lib/polyfills.ts
@@ -48,7 +49,6 @@ if (!("try" in Promise)) {
 
 // src/pdf.js/src/shared/util.js
 var isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
-var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
 var FONT_IDENTITY_MATRIX = [1e-3, 0, 0, 1e-3, 0, 0];
 var LINE_FACTOR = 1.35;
 var LINE_DESCENT_FACTOR = 0.35;
@@ -78,7 +78,9 @@ var AnnotationEditorType = {
   HIGHLIGHT: 9,
   STAMP: 13,
   INK: 15,
-  SIGNATURE: 101
+  POPUP: 16,
+  SIGNATURE: 101,
+  COMMENT: 102
 };
 var AnnotationEditorParamsType = {
   RESIZE: 1,
@@ -90,10 +92,9 @@ var AnnotationEditorParamsType = {
   INK_THICKNESS: 22,
   INK_OPACITY: 23,
   HIGHLIGHT_COLOR: 31,
-  HIGHLIGHT_DEFAULT_COLOR: 32,
-  HIGHLIGHT_THICKNESS: 33,
-  HIGHLIGHT_FREE: 34,
-  HIGHLIGHT_SHOW_ALL: 35,
+  HIGHLIGHT_THICKNESS: 32,
+  HIGHLIGHT_FREE: 33,
+  HIGHLIGHT_SHOW_ALL: 34,
   DRAW_STEP: 41
 };
 var PermissionFlag = {
@@ -324,7 +325,14 @@ var OPS = {
   paintSolidColorImageMask: 90,
   constructPath: 91,
   setStrokeTransparent: 92,
-  setFillTransparent: 93
+  setFillTransparent: 93,
+  rawFillPath: 94
+};
+var DrawOPS = {
+  moveTo: 0,
+  lineTo: 1,
+  curveTo: 2,
+  closePath: 3
 };
 var PasswordResponses = {
   NEED_PASSWORD: 1,
@@ -341,12 +349,12 @@ function getVerbosityLevel() {
 }
 function info(msg) {
   if (verbosity >= VerbosityLevel.INFOS) {
-    console.log(`Info: ${msg}`);
+    console.info(`Info: ${msg}`);
   }
 }
 function warn(msg) {
   if (verbosity >= VerbosityLevel.WARNINGS) {
-    console.log(`Warning: ${msg}`);
+    console.warn(`Warning: ${msg}`);
   }
 }
 function unreachable(msg) {
@@ -390,6 +398,17 @@ function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
   const absoluteUrl = baseUrl ? URL.parse(url, baseUrl) : URL.parse(url);
   return _isValidProtocol(absoluteUrl) ? absoluteUrl : null;
 }
+function updateUrlHash(url, hash, allowRel = false) {
+  const res = URL.parse(url);
+  if (res) {
+    res.hash = hash;
+    return res.href;
+  }
+  if (allowRel && createValidAbsoluteUrl(url, "http://example.com")) {
+    return url.split("#", 1)[0] + `${hash ? `#${hash}` : ""}`;
+  }
+  return "";
+}
 function shadow(obj, prop, value, nonSerializable = false) {
   if (false) {
     assert(
@@ -405,7 +424,7 @@ function shadow(obj, prop, value, nonSerializable = false) {
   });
   return value;
 }
-var BaseException = function BaseExceptionClosure() {
+var BaseException = (function BaseExceptionClosure() {
   function BaseException2(message, name) {
     if (false) {
       unreachable("Cannot initialize BaseException.");
@@ -416,7 +435,7 @@ var BaseException = function BaseExceptionClosure() {
   BaseException2.prototype = new Error();
   BaseException2.constructor = BaseException2;
   return BaseException2;
-}();
+})();
 var PasswordException = class extends BaseException {
   constructor(msg, code) {
     super(msg, "PasswordException");
@@ -496,13 +515,6 @@ function string32(value) {
 function objectSize(obj) {
   return Object.keys(obj).length;
 }
-function objectFromMap(map) {
-  const obj = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of map) {
-    obj[key] = value;
-  }
-  return obj;
-}
 function isLittleEndian() {
   const buffer8 = new Uint8Array(4);
   buffer8[0] = 1;
@@ -539,22 +551,13 @@ var FeatureTest = class {
     );
   }
   static get platform() {
-    if (typeof navigator !== "undefined" && typeof navigator?.platform === "string" && typeof navigator?.userAgent === "string") {
-      const { platform, userAgent } = navigator;
-      return shadow(this, "platform", {
-        isAndroid: userAgent.includes("Android"),
-        isLinux: platform.includes("Linux"),
-        isMac: platform.includes("Mac"),
-        isWindows: platform.includes("Win"),
-        isFirefox: userAgent.includes("Firefox")
-      });
-    }
+    const { platform, userAgent } = navigator;
     return shadow(this, "platform", {
-      isAndroid: false,
-      isLinux: false,
-      isMac: false,
-      isWindows: false,
-      isFirefox: false
+      isAndroid: userAgent.includes("Android"),
+      isLinux: platform.includes("Linux"),
+      isMac: platform.includes("Mac"),
+      isWindows: platform.includes("Win"),
+      isFirefox: userAgent.includes("Firefox")
     });
   }
   static get isCSSRoundSupported() {
@@ -574,6 +577,9 @@ var Util = class {
   static makeHexColor(r, g, b) {
     return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
   }
+  static domMatrixToTransform(dm) {
+    return [dm.a, dm.b, dm.c, dm.d, dm.e, dm.f];
+  }
   // Apply a scaling matrix to some min/max values.
   // If a scaling factor is negative then min and max must be
   // swapped.
@@ -632,31 +638,84 @@ var Util = class {
       m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
     ];
   }
+  // Multiplies m (an array-based transform) by md (a DOMMatrix transform).
+  static multiplyByDOMMatrix(m, md) {
+    return [
+      m[0] * md.a + m[2] * md.b,
+      m[1] * md.a + m[3] * md.b,
+      m[0] * md.c + m[2] * md.d,
+      m[1] * md.c + m[3] * md.d,
+      m[0] * md.e + m[2] * md.f + m[4],
+      m[1] * md.e + m[3] * md.f + m[5]
+    ];
+  }
   // 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];
-    return [xt, yt];
+  static applyTransform(p, m, pos = 0) {
+    const p0 = p[pos];
+    const p1 = p[pos + 1];
+    p[pos] = p0 * m[0] + p1 * m[2] + m[4];
+    p[pos + 1] = p0 * m[1] + p1 * m[3] + m[5];
+  }
+  static applyTransformToBezier(p, transform, pos = 0) {
+    const m0 = transform[0];
+    const m1 = transform[1];
+    const m2 = transform[2];
+    const m3 = transform[3];
+    const m4 = transform[4];
+    const m5 = transform[5];
+    for (let i = 0; i < 6; i += 2) {
+      const pI = p[pos + i];
+      const pI1 = p[pos + i + 1];
+      p[pos + i] = pI * m0 + pI1 * m2 + m4;
+      p[pos + i + 1] = pI * m1 + pI1 * m3 + m5;
+    }
   }
   static applyInverseTransform(p, m) {
+    const p0 = p[0];
+    const p1 = p[1];
     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];
+    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
   }
   // Applies the transform to the rectangle and finds the minimum axially
   // aligned bounding box.
-  static getAxialAlignedBoundingBox(r, m) {
-    const p1 = this.applyTransform(r, m);
-    const p2 = this.applyTransform(r.slice(2, 4), m);
-    const p3 = this.applyTransform([r[0], r[3]], m);
-    const p4 = this.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 axialAlignedBoundingBox(rect, transform, output) {
+    const m0 = transform[0];
+    const m1 = transform[1];
+    const m2 = transform[2];
+    const m3 = transform[3];
+    const m4 = transform[4];
+    const m5 = transform[5];
+    const r0 = rect[0];
+    const r1 = rect[1];
+    const r2 = rect[2];
+    const r3 = rect[3];
+    let a0 = m0 * r0 + m4;
+    let a2 = a0;
+    let a1 = m0 * r2 + m4;
+    let a3 = a1;
+    let b0 = m3 * r1 + m5;
+    let b2 = b0;
+    let b1 = m3 * r3 + m5;
+    let b3 = b1;
+    if (m1 !== 0 || m2 !== 0) {
+      const m1r0 = m1 * r0;
+      const m1r2 = m1 * r2;
+      const m2r1 = m2 * r1;
+      const m2r3 = m2 * r3;
+      a0 += m2r1;
+      a3 += m2r1;
+      a1 += m2r3;
+      a2 += m2r3;
+      b0 += m1r0;
+      b3 += m1r0;
+      b1 += m1r2;
+      b2 += m1r2;
+    }
+    output[0] = Math.min(output[0], a0, a1, a2, a3);
+    output[1] = Math.min(output[1], b0, b1, b2, b3);
+    output[2] = Math.max(output[2], a0, a1, a2, a3);
+    output[3] = Math.max(output[3], b0, b1, b2, b3);
   }
   static inverseTransform(m) {
     const d = m[0] * m[3] - m[1] * m[2];
@@ -672,17 +731,18 @@ var Util = class {
   // 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 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) ** 2 - 4 * (a * d - c * b)) / 2;
-    const sx = first + second || 1;
-    const sy = first - second || 1;
-    return [Math.sqrt(sx), Math.sqrt(sy)];
+  static singularValueDecompose2dScale(matrix, output) {
+    const m0 = matrix[0];
+    const m1 = matrix[1];
+    const m2 = matrix[2];
+    const m3 = matrix[3];
+    const a = m0 ** 2 + m1 ** 2;
+    const b = m0 * m2 + m1 * m3;
+    const c = m2 ** 2 + m3 ** 2;
+    const first = (a + c) / 2;
+    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
+    output[0] = Math.sqrt(first + second || 1);
+    output[1] = Math.sqrt(first - second || 1);
   }
   // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
   // For coordinate systems whose origin lies in the bottom-left, this
@@ -728,24 +788,26 @@ var Util = class {
     }
     return [xLow, yLow, xHigh, yHigh];
   }
+  static pointBoundingBox(x, y, minMax) {
+    minMax[0] = Math.min(minMax[0], x);
+    minMax[1] = Math.min(minMax[1], y);
+    minMax[2] = Math.max(minMax[2], x);
+    minMax[3] = Math.max(minMax[3], y);
+  }
+  static rectBoundingBox(x0, y0, x1, y1, minMax) {
+    minMax[0] = Math.min(minMax[0], x0, x1);
+    minMax[1] = Math.min(minMax[1], y0, y1);
+    minMax[2] = Math.max(minMax[2], x0, x1);
+    minMax[3] = Math.max(minMax[3], y0, y1);
+  }
   // From https://github.com/adobe-webplatform/Snap.svg/blob/b365287722a72526000ac4bfcf0ce4cac2faa015/src/path.js#L852
   static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
-    if (minMax) {
-      minMax[0] = Math.min(minMax[0], x0, x3);
-      minMax[1] = Math.min(minMax[1], y0, y3);
-      minMax[2] = Math.max(minMax[2], x0, x3);
-      minMax[3] = Math.max(minMax[3], y0, y3);
-    } else {
-      minMax = [
-        Math.min(x0, x3),
-        Math.min(y0, y3),
-        Math.max(x0, x3),
-        Math.max(y0, y3)
-      ];
-    }
+    minMax[0] = Math.min(minMax[0], x0, x3);
+    minMax[1] = Math.min(minMax[1], y0, y3);
+    minMax[2] = Math.max(minMax[2], x0, x3);
+    minMax[3] = Math.max(minMax[3], y0, y3);
     __privateMethod(this, _Util_static, getExtremum_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, 3 * (-x0 + 3 * (x1 - x2) + x3), 6 * (x0 - 2 * x1 + x2), 3 * (x1 - x0), minMax);
     __privateMethod(this, _Util_static, getExtremum_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, 3 * (-y0 + 3 * (y1 - y2) + y3), 6 * (y0 - 2 * y1 + y2), 3 * (y1 - y0), minMax);
-    return minMax;
   }
 };
 _Util_static = new WeakSet();
@@ -943,7 +1005,7 @@ var PDFStringTranslateTable = [
   0,
   8364
 ];
-function stringToPDFString(str) {
+function stringToPDFString(str, keepEscapeSequence = false) {
   if (str[0] >= "\xEF") {
     let encoding;
     if (str[0] === "\xFE" && str[1] === "\xFF") {
@@ -964,7 +1026,7 @@ function stringToPDFString(str) {
         const decoder = new TextDecoder(encoding, { fatal: true });
         const buffer = stringToBytes(str);
         const decoded = decoder.decode(buffer);
-        if (!decoded.includes("\x1B")) {
+        if (keepEscapeSequence || !decoded.includes("\x1B")) {
           return decoded;
         }
         return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
@@ -976,7 +1038,7 @@ function stringToPDFString(str) {
   const strBuf = [];
   for (let i = 0, ii = str.length; i < ii; i++) {
     const charCode = str.charCodeAt(i);
-    if (charCode === 27) {
+    if (!keepEscapeSequence && charCode === 27) {
       while (++i < ii && str.charCodeAt(i) !== 27) {
       }
       continue;
@@ -1004,6 +1066,9 @@ function isArrayEqual(arr1, arr2) {
   return true;
 }
 function getModificationDate(date = /* @__PURE__ */ new Date()) {
+  if (!(date instanceof Date)) {
+    date = new Date(date);
+  }
   const buffer = [
     date.getUTCFullYear().toString(),
     (date.getUTCMonth() + 1).toString().padStart(2, "0"),
@@ -1035,6 +1100,56 @@ function getUuid() {
   return bytesToString(buf);
 }
 var AnnotationPrefix = "pdfjs_internal_id_";
+function _isValidExplicitDest(validRef, validName, dest) {
+  if (!Array.isArray(dest) || dest.length < 2) {
+    return false;
+  }
+  const [page, zoom, ...args] = dest;
+  if (!validRef(page) && !Number.isInteger(page)) {
+    return false;
+  }
+  if (!validName(zoom)) {
+    return false;
+  }
+  const argsLen = args.length;
+  let allowNull = true;
+  switch (zoom.name) {
+    case "XYZ":
+      if (argsLen < 2 || argsLen > 3) {
+        return false;
+      }
+      break;
+    case "Fit":
+    case "FitB":
+      return argsLen === 0;
+    case "FitH":
+    case "FitBH":
+    case "FitV":
+    case "FitBV":
+      if (argsLen > 1) {
+        return false;
+      }
+      break;
+    case "FitR":
+      if (argsLen !== 4) {
+        return false;
+      }
+      allowNull = false;
+      break;
+    default:
+      return false;
+  }
+  for (const arg of args) {
+    if (typeof arg === "number" || allowNull && arg === null) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function MathClamp(v, min, max) {
+  return Math.min(Math.max(v, min), max);
+}
 function toHexUtil(arr) {
   if (Uint8Array.prototype.toHex) {
     return arr.toHex();
@@ -1060,6 +1175,34 @@ if (false) {
     });
   };
 }
+if (typeof Math.sumPrecise !== "function") {
+  Math.sumPrecise = function(numbers) {
+    return numbers.reduce((a, b) => a + b, 0);
+  };
+}
+if (false) {
+  AbortSignal.any = function(iterable) {
+    const ac = new AbortController();
+    const { signal } = ac;
+    for (const s of iterable) {
+      if (s.aborted) {
+        ac.abort(s.reason);
+        return signal;
+      }
+    }
+    for (const s of iterable) {
+      s.addEventListener(
+        "abort",
+        () => {
+          ac.abort(s.reason);
+        },
+        { signal }
+        // Automatically remove the listener.
+      );
+    }
+    return signal;
+  };
+}
 
 // src/pdf.js/src/shared/message_handler.js
 var CallbackKind = {
@@ -1516,6 +1659,1351 @@ deleteStreamController_fn = async function(streamController, streamId) {
   delete this.streamControllers[streamId];
 };
 
+// src/pdf.js/src/shared/obj-bin-transform.js
+var _buffer, _view, _decoder, _CssFontInfo_instances, readString_fn;
+var _CssFontInfo = class _CssFontInfo {
+  constructor(buffer) {
+    __privateAdd(this, _CssFontInfo_instances);
+    __privateAdd(this, _buffer);
+    __privateAdd(this, _view);
+    __privateAdd(this, _decoder);
+    __privateSet(this, _buffer, buffer);
+    __privateSet(this, _view, new DataView(__privateGet(this, _buffer)));
+    __privateSet(this, _decoder, new TextDecoder());
+  }
+  static write(info2) {
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _CssFontInfo.strings) {
+      const encoded = encoder.encode(info2[prop]);
+      encodedStrings[prop] = encoded;
+      stringsLength += 4 + encoded.length;
+    }
+    const buffer = new ArrayBuffer(stringsLength);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    for (const prop of _CssFontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    assert(offset === buffer.byteLength, "CssFontInfo.write: Buffer overflow");
+    return buffer;
+  }
+  get fontFamily() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 0);
+  }
+  get fontWeight() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 1);
+  }
+  get italicAngle() {
+    return __privateMethod(this, _CssFontInfo_instances, readString_fn).call(this, 2);
+  }
+};
+_buffer = new WeakMap();
+_view = new WeakMap();
+_decoder = new WeakMap();
+_CssFontInfo_instances = new WeakSet();
+readString_fn = function(index) {
+  assert(index < _CssFontInfo.strings.length, "Invalid string index");
+  let offset = 0;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view).getUint32(offset);
+  return __privateGet(this, _decoder).decode(
+    new Uint8Array(__privateGet(this, _buffer), offset + 4, length)
+  );
+};
+__publicField(_CssFontInfo, "strings", ["fontFamily", "fontWeight", "italicAngle"]);
+var CssFontInfo = _CssFontInfo;
+var _buffer2, _view2, _decoder2, _SystemFontInfo_instances, readString_fn2;
+var _SystemFontInfo = class _SystemFontInfo {
+  constructor(buffer) {
+    __privateAdd(this, _SystemFontInfo_instances);
+    __privateAdd(this, _buffer2);
+    __privateAdd(this, _view2);
+    __privateAdd(this, _decoder2);
+    __privateSet(this, _buffer2, buffer);
+    __privateSet(this, _view2, new DataView(__privateGet(this, _buffer2)));
+    __privateSet(this, _decoder2, new TextDecoder());
+  }
+  static write(info2) {
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _SystemFontInfo.strings) {
+      const encoded = encoder.encode(info2[prop]);
+      encodedStrings[prop] = encoded;
+      stringsLength += 4 + encoded.length;
+    }
+    stringsLength += 4;
+    let encodedStyleStyle, encodedStyleWeight, lengthEstimate = 1 + stringsLength;
+    if (info2.style) {
+      encodedStyleStyle = encoder.encode(info2.style.style);
+      encodedStyleWeight = encoder.encode(info2.style.weight);
+      lengthEstimate += 4 + encodedStyleStyle.length + 4 + encodedStyleWeight.length;
+    }
+    const buffer = new ArrayBuffer(lengthEstimate);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    view.setUint8(offset++, info2.guessFallback ? 1 : 0);
+    view.setUint32(offset, 0);
+    offset += 4;
+    stringsLength = 0;
+    for (const prop of _SystemFontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      stringsLength += 4 + length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    view.setUint32(offset - stringsLength - 4, stringsLength);
+    if (info2.style) {
+      view.setUint32(offset, encodedStyleStyle.length);
+      data.set(encodedStyleStyle, offset + 4);
+      offset += 4 + encodedStyleStyle.length;
+      view.setUint32(offset, encodedStyleWeight.length);
+      data.set(encodedStyleWeight, offset + 4);
+      offset += 4 + encodedStyleWeight.length;
+    }
+    assert(
+      offset <= buffer.byteLength,
+      "SubstitionInfo.write: Buffer overflow"
+    );
+    return buffer.transferToFixedLength(offset);
+  }
+  get guessFallback() {
+    return __privateGet(this, _view2).getUint8(0) !== 0;
+  }
+  get css() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 0);
+  }
+  get loadedName() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 1);
+  }
+  get baseFontName() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 2);
+  }
+  get src() {
+    return __privateMethod(this, _SystemFontInfo_instances, readString_fn2).call(this, 3);
+  }
+  get style() {
+    let offset = 1;
+    offset += 4 + __privateGet(this, _view2).getUint32(offset);
+    const styleLength = __privateGet(this, _view2).getUint32(offset);
+    const style = __privateGet(this, _decoder2).decode(
+      new Uint8Array(__privateGet(this, _buffer2), offset + 4, styleLength)
+    );
+    offset += 4 + styleLength;
+    const weightLength = __privateGet(this, _view2).getUint32(offset);
+    const weight = __privateGet(this, _decoder2).decode(
+      new Uint8Array(__privateGet(this, _buffer2), offset + 4, weightLength)
+    );
+    return { style, weight };
+  }
+};
+_buffer2 = new WeakMap();
+_view2 = new WeakMap();
+_decoder2 = new WeakMap();
+_SystemFontInfo_instances = new WeakSet();
+readString_fn2 = function(index) {
+  assert(index < _SystemFontInfo.strings.length, "Invalid string index");
+  let offset = 5;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view2).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view2).getUint32(offset);
+  return __privateGet(this, _decoder2).decode(
+    new Uint8Array(__privateGet(this, _buffer2), offset + 4, length)
+  );
+};
+__publicField(_SystemFontInfo, "strings", ["css", "loadedName", "baseFontName", "src"]);
+var SystemFontInfo = _SystemFontInfo;
+var _OFFSET_NUMBERS, _OFFSET_BBOX, _OFFSET_FONT_MATRIX, _OFFSET_DEFAULT_VMETRICS, _OFFSET_STRINGS, _buffer3, _decoder3, _view3, _FontInfo_instances, readBoolean_fn, readNumber_fn, readString_fn3;
+var _FontInfo = class _FontInfo {
+  constructor({ data, extra }) {
+    __privateAdd(this, _FontInfo_instances);
+    __privateAdd(this, _buffer3);
+    __privateAdd(this, _decoder3);
+    __privateAdd(this, _view3);
+    __privateSet(this, _buffer3, data);
+    __privateSet(this, _decoder3, new TextDecoder());
+    __privateSet(this, _view3, new DataView(__privateGet(this, _buffer3)));
+    if (extra) {
+      Object.assign(this, extra);
+    }
+  }
+  get black() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 0);
+  }
+  get bold() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 1);
+  }
+  get disableFontFace() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 2);
+  }
+  get fontExtraProperties() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 3);
+  }
+  get isInvalidPDFjsFont() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 4);
+  }
+  get isType3Font() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 5);
+  }
+  get italic() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 6);
+  }
+  get missingFile() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 7);
+  }
+  get remeasure() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 8);
+  }
+  get vertical() {
+    return __privateMethod(this, _FontInfo_instances, readBoolean_fn).call(this, 9);
+  }
+  get ascent() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 0);
+  }
+  get defaultWidth() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 1);
+  }
+  get descent() {
+    return __privateMethod(this, _FontInfo_instances, readNumber_fn).call(this, 2);
+  }
+  get bbox() {
+    let offset = __privateGet(_FontInfo, _OFFSET_BBOX);
+    const numCoords = __privateGet(this, _view3).getUint8(offset);
+    if (numCoords === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const bbox = [];
+    for (let i = 0; i < 4; i++) {
+      bbox.push(__privateGet(this, _view3).getInt16(offset, true));
+      offset += 2;
+    }
+    return bbox;
+  }
+  get fontMatrix() {
+    let offset = __privateGet(_FontInfo, _OFFSET_FONT_MATRIX);
+    const numPoints = __privateGet(this, _view3).getUint8(offset);
+    if (numPoints === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const fontMatrix = [];
+    for (let i = 0; i < 6; i++) {
+      fontMatrix.push(__privateGet(this, _view3).getFloat64(offset, true));
+      offset += 8;
+    }
+    return fontMatrix;
+  }
+  get defaultVMetrics() {
+    let offset = __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS);
+    const numMetrics = __privateGet(this, _view3).getUint8(offset);
+    if (numMetrics === 0) {
+      return void 0;
+    }
+    offset += 1;
+    const defaultVMetrics = [];
+    for (let i = 0; i < 3; i++) {
+      defaultVMetrics.push(__privateGet(this, _view3).getInt16(offset, true));
+      offset += 2;
+    }
+    return defaultVMetrics;
+  }
+  get fallbackName() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 0);
+  }
+  get loadedName() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 1);
+  }
+  get mimetype() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 2);
+  }
+  get name() {
+    return __privateMethod(this, _FontInfo_instances, readString_fn3).call(this, 3);
+  }
+  get data() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + cssFontInfoLength;
+    const length = __privateGet(this, _view3).getUint32(offset);
+    if (length === 0) {
+      return void 0;
+    }
+    return new Uint8Array(__privateGet(this, _buffer3), offset + 4, length);
+  }
+  clearData() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + cssFontInfoLength;
+    const length = __privateGet(this, _view3).getUint32(offset);
+    const data = new Uint8Array(__privateGet(this, _buffer3), offset + 4, length);
+    data.fill(0);
+    __privateGet(this, _view3).setUint32(offset, 0);
+  }
+  get cssFontInfo() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + systemFontInfoLength;
+    const cssFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    if (cssFontInfoLength === 0) {
+      return null;
+    }
+    const cssFontInfoData = new Uint8Array(cssFontInfoLength);
+    cssFontInfoData.set(
+      new Uint8Array(__privateGet(this, _buffer3), offset + 4, cssFontInfoLength)
+    );
+    return new CssFontInfo(cssFontInfoData.buffer);
+  }
+  get systemFontInfo() {
+    let offset = __privateGet(_FontInfo, _OFFSET_STRINGS);
+    const stringsLength = __privateGet(this, _view3).getUint32(offset);
+    offset += 4 + stringsLength;
+    const systemFontInfoLength = __privateGet(this, _view3).getUint32(offset);
+    if (systemFontInfoLength === 0) {
+      return null;
+    }
+    const systemFontInfoData = new Uint8Array(systemFontInfoLength);
+    systemFontInfoData.set(
+      new Uint8Array(__privateGet(this, _buffer3), offset + 4, systemFontInfoLength)
+    );
+    return new SystemFontInfo(systemFontInfoData.buffer);
+  }
+  static write(font) {
+    const systemFontInfoBuffer = font.systemFontInfo ? SystemFontInfo.write(font.systemFontInfo) : null;
+    const cssFontInfoBuffer = font.cssFontInfo ? CssFontInfo.write(font.cssFontInfo) : null;
+    const encoder = new TextEncoder();
+    const encodedStrings = {};
+    let stringsLength = 0;
+    for (const prop of _FontInfo.strings) {
+      encodedStrings[prop] = encoder.encode(font[prop]);
+      stringsLength += 4 + encodedStrings[prop].length;
+    }
+    const lengthEstimate = __privateGet(_FontInfo, _OFFSET_STRINGS) + 4 + stringsLength + 4 + (systemFontInfoBuffer ? systemFontInfoBuffer.byteLength : 0) + 4 + (cssFontInfoBuffer ? cssFontInfoBuffer.byteLength : 0) + 4 + (font.data ? font.data.length : 0);
+    const buffer = new ArrayBuffer(lengthEstimate);
+    const data = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    let offset = 0;
+    const numBools = _FontInfo.bools.length;
+    let boolByte = 0, boolBit = 0;
+    for (let i = 0; i < numBools; i++) {
+      const value = font[_FontInfo.bools[i]];
+      const bits = value === void 0 ? 0 : value ? 2 : 1;
+      boolByte |= bits << boolBit;
+      boolBit += 2;
+      if (boolBit === 8 || i === numBools - 1) {
+        view.setUint8(offset++, boolByte);
+        boolByte = 0;
+        boolBit = 0;
+      }
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_NUMBERS),
+      "FontInfo.write: Boolean properties offset mismatch"
+    );
+    for (const prop of _FontInfo.numbers) {
+      view.setFloat64(offset, font[prop]);
+      offset += 8;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_BBOX),
+      "FontInfo.write: Number properties offset mismatch"
+    );
+    if (font.bbox) {
+      view.setUint8(offset++, 4);
+      for (const coord of font.bbox) {
+        view.setInt16(offset, coord, true);
+        offset += 2;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 2 * 4;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_FONT_MATRIX),
+      "FontInfo.write: BBox properties offset mismatch"
+    );
+    if (font.fontMatrix) {
+      view.setUint8(offset++, 6);
+      for (const point of font.fontMatrix) {
+        view.setFloat64(offset, point, true);
+        offset += 8;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 8 * 6;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS),
+      "FontInfo.write: FontMatrix properties offset mismatch"
+    );
+    if (font.defaultVMetrics) {
+      view.setUint8(offset++, 1);
+      for (const metric of font.defaultVMetrics) {
+        view.setInt16(offset, metric, true);
+        offset += 2;
+      }
+    } else {
+      view.setUint8(offset++, 0);
+      offset += 3 * 2;
+    }
+    assert(
+      offset === __privateGet(_FontInfo, _OFFSET_STRINGS),
+      "FontInfo.write: DefaultVMetrics properties offset mismatch"
+    );
+    view.setUint32(__privateGet(_FontInfo, _OFFSET_STRINGS), 0);
+    offset += 4;
+    for (const prop of _FontInfo.strings) {
+      const encoded = encodedStrings[prop];
+      const length = encoded.length;
+      view.setUint32(offset, length);
+      data.set(encoded, offset + 4);
+      offset += 4 + length;
+    }
+    view.setUint32(
+      __privateGet(_FontInfo, _OFFSET_STRINGS),
+      offset - __privateGet(_FontInfo, _OFFSET_STRINGS) - 4
+    );
+    if (!systemFontInfoBuffer) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      const length = systemFontInfoBuffer.byteLength;
+      view.setUint32(offset, length);
+      assert(
+        offset + 4 + length <= buffer.byteLength,
+        "FontInfo.write: Buffer overflow at systemFontInfo"
+      );
+      data.set(new Uint8Array(systemFontInfoBuffer), offset + 4);
+      offset += 4 + length;
+    }
+    if (!cssFontInfoBuffer) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      const length = cssFontInfoBuffer.byteLength;
+      view.setUint32(offset, length);
+      assert(
+        offset + 4 + length <= buffer.byteLength,
+        "FontInfo.write: Buffer overflow at cssFontInfo"
+      );
+      data.set(new Uint8Array(cssFontInfoBuffer), offset + 4);
+      offset += 4 + length;
+    }
+    if (font.data === void 0) {
+      view.setUint32(offset, 0);
+      offset += 4;
+    } else {
+      view.setUint32(offset, font.data.length);
+      data.set(font.data, offset + 4);
+      offset += 4 + font.data.length;
+    }
+    assert(offset <= buffer.byteLength, "FontInfo.write: Buffer overflow");
+    return buffer.transferToFixedLength(offset);
+  }
+};
+_OFFSET_NUMBERS = new WeakMap();
+_OFFSET_BBOX = new WeakMap();
+_OFFSET_FONT_MATRIX = new WeakMap();
+_OFFSET_DEFAULT_VMETRICS = new WeakMap();
+_OFFSET_STRINGS = new WeakMap();
+_buffer3 = new WeakMap();
+_decoder3 = new WeakMap();
+_view3 = new WeakMap();
+_FontInfo_instances = new WeakSet();
+readBoolean_fn = function(index) {
+  assert(index < _FontInfo.bools.length, "Invalid boolean index");
+  const byteOffset = Math.floor(index / 4);
+  const bitOffset = index * 2 % 8;
+  const value = __privateGet(this, _view3).getUint8(byteOffset) >> bitOffset & 3;
+  return value === 0 ? void 0 : value === 2;
+};
+readNumber_fn = function(index) {
+  assert(index < _FontInfo.numbers.length, "Invalid number index");
+  return __privateGet(this, _view3).getFloat64(__privateGet(_FontInfo, _OFFSET_NUMBERS) + index * 8);
+};
+readString_fn3 = function(index) {
+  assert(index < _FontInfo.strings.length, "Invalid string index");
+  let offset = __privateGet(_FontInfo, _OFFSET_STRINGS) + 4;
+  for (let i = 0; i < index; i++) {
+    offset += __privateGet(this, _view3).getUint32(offset) + 4;
+  }
+  const length = __privateGet(this, _view3).getUint32(offset);
+  const stringData = new Uint8Array(length);
+  stringData.set(new Uint8Array(__privateGet(this, _buffer3), offset + 4, length));
+  return __privateGet(this, _decoder3).decode(stringData);
+};
+__publicField(_FontInfo, "bools", [
+  "black",
+  "bold",
+  "disableFontFace",
+  "fontExtraProperties",
+  "isInvalidPDFjsFont",
+  "isType3Font",
+  "italic",
+  "missingFile",
+  "remeasure",
+  "vertical"
+]);
+__publicField(_FontInfo, "numbers", ["ascent", "defaultWidth", "descent"]);
+__publicField(_FontInfo, "strings", ["fallbackName", "loadedName", "mimetype", "name"]);
+__privateAdd(_FontInfo, _OFFSET_NUMBERS, Math.ceil(_FontInfo.bools.length * 2 / 8));
+__privateAdd(_FontInfo, _OFFSET_BBOX, __privateGet(_FontInfo, _OFFSET_NUMBERS) + _FontInfo.numbers.length * 8);
+__privateAdd(_FontInfo, _OFFSET_FONT_MATRIX, __privateGet(_FontInfo, _OFFSET_BBOX) + 1 + 2 * 4);
+__privateAdd(_FontInfo, _OFFSET_DEFAULT_VMETRICS, __privateGet(_FontInfo, _OFFSET_FONT_MATRIX) + 1 + 8 * 6);
+__privateAdd(_FontInfo, _OFFSET_STRINGS, __privateGet(_FontInfo, _OFFSET_DEFAULT_VMETRICS) + 1 + 2 * 3);
+var FontInfo = _FontInfo;
+
+// src/pdf.js/src/core/bidi.js
+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) {
+  let j, jj;
+  for (j = start, jj = arr.length; j < jj; ++j) {
+    if (arr[j] !== value) {
+      return j;
+    }
+  }
+  return j;
+}
+function reverseValues(arr, start, end) {
+  for (let i = start, j = end - 1; i < j; ++i, --j) {
+    const 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 = -1, vertical = false) {
+  let isLTR = true;
+  const strLength = str.length;
+  if (strLength === 0 || vertical) {
+    return createBidiText(str, isLTR, vertical);
+  }
+  chars.length = strLength;
+  types.length = strLength;
+  let numBidi = 0;
+  let i, ii;
+  for (i = 0; i < strLength; ++i) {
+    chars[i] = str.charAt(i);
+    const charCode = str.charCodeAt(i);
+    let charType = "L";
+    if (charCode <= 255) {
+      charType = baseTypes[charCode];
+    } else if (1424 <= charCode && charCode <= 1524) {
+      charType = "R";
+    } else if (1536 <= charCode && charCode <= 1791) {
+      charType = arabicTypes[charCode & 255];
+      if (!charType) {
+        warn("Bidi: invalid Unicode character " + charCode.toString(16));
+      }
+    } else if (1792 <= charCode && charCode <= 2220 || 64336 <= charCode && charCode <= 65023 || 65136 <= charCode && charCode <= 65279) {
+      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 && strLength > 4) {
+      isLTR = true;
+      startLevel = 0;
+    } else {
+      isLTR = false;
+      startLevel = 1;
+    }
+  }
+  const levels = [];
+  for (i = 0; i < strLength; ++i) {
+    levels[i] = startLevel;
+  }
+  const e = isOdd(startLevel) ? "R" : "L";
+  const sor = e;
+  const eor = sor;
+  let lastType = sor;
+  for (i = 0; i < strLength; ++i) {
+    if (types[i] === "NSM") {
+      types[i] = lastType;
+    } else {
+      lastType = types[i];
+    }
+  }
+  lastType = sor;
+  let 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") {
+      for (let j = i - 1; j >= 0; --j) {
+        if (types[j] !== "ET") {
+          break;
+        }
+        types[j] = "EN";
+      }
+      for (let 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") {
+      const end = findUnequal(types, i + 1, "ON");
+      let before = sor;
+      if (i > 0) {
+        before = types[i - 1];
+      }
+      let after = eor;
+      if (end + 1 < strLength) {
+        after = types[end + 1];
+      }
+      if (before !== "L") {
+        before = "R";
+      }
+      if (after !== "L") {
+        after = "R";
+      }
+      if (before === after) {
+        types.fill(before, i, end);
+      }
+      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 (
+      /* isOdd && */
+      t === "L" || t === "AN" || t === "EN"
+    ) {
+      levels[i] += 1;
+    }
+  }
+  let highestLevel = -1;
+  let lowestOddLevel = 99;
+  let 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) {
+    let 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) {
+    const ch = chars[i];
+    if (ch === "<" || ch === ">") {
+      chars[i] = "";
+    }
+  }
+  return createBidiText(chars.join(""), isLTR);
+}
+
+// src/pdf.js/src/shared/scripting_utils.js
+function makeColorComp(n) {
+  return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
+}
+function scaleAndClamp(x) {
+  return Math.max(0, Math.min(255, 255 * x));
+}
+var ColorConverters = class {
+  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_rgb([g]) {
+    g = scaleAndClamp(g);
+    return [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_rgb(color) {
+    return color.map(scaleAndClamp);
+  }
+  static RGB_HTML(color) {
+    return `#${color.map(makeColorComp).join("")}`;
+  }
+  static T_HTML() {
+    return "#00000000";
+  }
+  static T_rgb() {
+    return [null];
+  }
+  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_rgb([c, y, m, k]) {
+    return [
+      scaleAndClamp(1 - Math.min(1, c + k)),
+      scaleAndClamp(1 - Math.min(1, m + k)),
+      scaleAndClamp(1 - Math.min(1, y + k))
+    ];
+  }
+  static CMYK_HTML(components) {
+    const rgb = this.CMYK_RGB(components).slice(1);
+    return this.RGB_HTML(rgb);
+  }
+  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];
+  }
+};
+var 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"
+];
+var TimeFormats = ["HH:MM", "h:MM tt", "HH:MM:ss", "h:MM:ss tt"];
+
 // src/pdf.js/src/shared/murmurhash3.js
 var SEED = 3285377520;
 var MASK_HIGH = 4294901760;
@@ -1709,7 +3197,6 @@ function grayToRGBA(src, dest) {
 
 export {
   isNodeJS,
-  IDENTITY_MATRIX,
   FONT_IDENTITY_MATRIX,
   LINE_FACTOR,
   LINE_DESCENT_FACTOR,
@@ -1732,6 +3219,7 @@ export {
   PageActionEventType,
   VerbosityLevel,
   OPS,
+  DrawOPS,
   PasswordResponses,
   setVerbosityLevel,
   getVerbosityLevel,
@@ -1740,6 +3228,7 @@ export {
   unreachable,
   assert,
   createValidAbsoluteUrl,
+  updateUrlHash,
   shadow,
   BaseException,
   PasswordException,
@@ -1751,7 +3240,6 @@ export {
   stringToBytes,
   string32,
   objectSize,
-  objectFromMap,
   FeatureTest,
   hexNumbers,
   Util,
@@ -1763,6 +3251,8 @@ export {
   normalizeUnicode,
   getUuid,
   AnnotationPrefix,
+  _isValidExplicitDest,
+  MathClamp,
   toHexUtil,
   toBase64Util,
   fromBase64Util,
@@ -1771,5 +3261,10 @@ export {
   MessageHandler,
   convertToRGBA,
   convertBlackAndWhiteToRGBA,
-  grayToRGBA
+  grayToRGBA,
+  FontInfo,
+  bidi,
+  ColorConverters,
+  DateFormats,
+  TimeFormats
 };