@chialab/pdfjs-lib 1.0.0-alpha.37 → 1.0.0-alpha.39

package/dist/node/{chunk-7NGJYFOM.js → chunk-FGBCMLPZ.js}

@@ -1,3 +1,15 @@
+import {
+  AbortException,
+  FeatureTest,
+  ImageKind,
+  InvalidPDFException,
+  PasswordException,
+  ResponseException,
+  UnknownErrorException,
+  assert,
+  unreachable,
+  warn
+} from "./chunk-T2JWSGAF.js";
 import {
   __privateAdd,
   __privateGet,
@@ -6,1161 +18,45 @@ import {
   __publicField
 } from "./chunk-ZFIGV5OT.js";
 
-// 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 FONT_IDENTITY_MATRIX = [1e-3, 0, 0, 1e-3, 0, 0];
-var LINE_FACTOR = 1.35;
-var LINE_DESCENT_FACTOR = 0.35;
-var BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
-var RenderingIntentFlag = {
-  ANY: 1,
-  DISPLAY: 2,
-  PRINT: 4,
-  SAVE: 8,
-  ANNOTATIONS_FORMS: 16,
-  ANNOTATIONS_STORAGE: 32,
-  ANNOTATIONS_DISABLE: 64,
-  IS_EDITING: 128,
-  OPLIST: 256
-};
-var AnnotationMode = {
-  DISABLE: 0,
-  ENABLE: 1,
-  ENABLE_FORMS: 2,
-  ENABLE_STORAGE: 3
-};
-var AnnotationEditorPrefix = "pdfjs_internal_editor_";
-var AnnotationEditorType = {
-  DISABLE: -1,
-  NONE: 0,
-  FREETEXT: 3,
-  HIGHLIGHT: 9,
-  STAMP: 13,
-  INK: 15,
-  POPUP: 16,
-  SIGNATURE: 101,
-  COMMENT: 102
-};
-var AnnotationEditorParamsType = {
-  RESIZE: 1,
-  CREATE: 2,
-  FREETEXT_SIZE: 11,
-  FREETEXT_COLOR: 12,
-  FREETEXT_OPACITY: 13,
-  INK_COLOR: 21,
-  INK_THICKNESS: 22,
-  INK_OPACITY: 23,
-  HIGHLIGHT_COLOR: 31,
-  HIGHLIGHT_THICKNESS: 32,
-  HIGHLIGHT_FREE: 33,
-  HIGHLIGHT_SHOW_ALL: 34,
-  DRAW_STEP: 41
-};
-var PermissionFlag = {
-  PRINT: 4,
-  MODIFY_CONTENTS: 8,
-  COPY: 16,
-  MODIFY_ANNOTATIONS: 32,
-  FILL_INTERACTIVE_FORMS: 256,
-  COPY_FOR_ACCESSIBILITY: 512,
-  ASSEMBLE: 1024,
-  PRINT_HIGH_QUALITY: 2048
-};
-var 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
-};
-var ImageKind = {
-  GRAYSCALE_1BPP: 1,
-  RGB_24BPP: 2,
-  RGBA_32BPP: 3
-};
-var 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
-};
-var AnnotationReplyType = {
-  GROUP: "Group",
-  REPLY: "R"
-};
-var AnnotationFlag = {
-  INVISIBLE: 1,
-  HIDDEN: 2,
-  PRINT: 4,
-  NOZOOM: 8,
-  NOROTATE: 16,
-  NOVIEW: 32,
-  READONLY: 64,
-  LOCKED: 128,
-  TOGGLENOVIEW: 256,
-  LOCKEDCONTENTS: 512
-};
-var AnnotationFieldFlag = {
-  READONLY: 1,
-  REQUIRED: 2,
-  NOEXPORT: 4,
-  MULTILINE: 4096,
-  PASSWORD: 8192,
-  NOTOGGLETOOFF: 16384,
-  RADIO: 32768,
-  PUSHBUTTON: 65536,
-  COMBO: 131072,
-  EDIT: 262144,
-  SORT: 524288,
-  FILESELECT: 1048576,
-  MULTISELECT: 2097152,
-  DONOTSPELLCHECK: 4194304,
-  DONOTSCROLL: 8388608,
-  COMB: 16777216,
-  RICHTEXT: 33554432,
-  RADIOSINUNISON: 33554432,
-  COMMITONSELCHANGE: 67108864
-};
-var AnnotationBorderStyleType = {
-  SOLID: 1,
-  DASHED: 2,
-  BEVELED: 3,
-  INSET: 4,
-  UNDERLINE: 5
-};
-var AnnotationActionEventType = {
-  E: "Mouse Enter",
-  X: "Mouse Exit",
-  D: "Mouse Down",
-  U: "Mouse Up",
-  Fo: "Focus",
-  Bl: "Blur",
-  PO: "PageOpen",
-  PC: "PageClose",
-  PV: "PageVisible",
-  PI: "PageInvisible",
-  K: "Keystroke",
-  F: "Format",
-  V: "Validate",
-  C: "Calculate"
-};
-var DocumentActionEventType = {
-  WC: "WillClose",
-  WS: "WillSave",
-  DS: "DidSave",
-  WP: "WillPrint",
-  DP: "DidPrint"
-};
-var PageActionEventType = {
-  O: "PageOpen",
-  C: "PageClose"
-};
-var VerbosityLevel = {
-  ERRORS: 0,
-  WARNINGS: 1,
-  INFOS: 5
-};
-var OPS = {
-  // Intentionally start from 1 so it is easy to spot bad operators that will be
-  // 0's.
-  // PLEASE NOTE: We purposely keep any removed operators commented out, since
-  //              re-numbering the list would risk breaking third-party users.
-  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,
-  setStrokeTransparent: 92,
-  setFillTransparent: 93,
-  rawFillPath: 94
-};
-var DrawOPS = {
-  moveTo: 0,
-  lineTo: 1,
-  curveTo: 2,
-  closePath: 3
-};
-var PasswordResponses = {
-  NEED_PASSWORD: 1,
-  INCORRECT_PASSWORD: 2
-};
-var verbosity = VerbosityLevel.WARNINGS;
-function setVerbosityLevel(level) {
-  if (Number.isInteger(level)) {
-    verbosity = level;
-  }
-}
-function getVerbosityLevel() {
-  return verbosity;
-}
-function info(msg) {
-  if (verbosity >= VerbosityLevel.INFOS) {
-    console.info(`Info: ${msg}`);
-  }
-}
-function warn(msg) {
-  if (verbosity >= VerbosityLevel.WARNINGS) {
-    console.warn(`Warning: ${msg}`);
-  }
-}
-function unreachable(msg) {
-  throw new Error(msg);
-}
-function assert(cond, msg) {
-  if (!cond) {
-    unreachable(msg);
-  }
-}
-function _isValidProtocol(url) {
-  switch (url?.protocol) {
-    case "http:":
-    case "https:":
-    case "ftp:":
-    case "mailto:":
-    case "tel:":
-      return true;
-    default:
-      return false;
-  }
-}
-function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
-  if (!url) {
-    return null;
-  }
-  if (options && typeof url === "string") {
-    if (options.addDefaultProtocol && url.startsWith("www.")) {
-      const dots = url.match(/\./g);
-      if (dots?.length >= 2) {
-        url = `http://${url}`;
-      }
-    }
-    if (options.tryConvertEncoding) {
-      try {
-        url = stringToUTF8String(url);
-      } catch {
-      }
-    }
-  }
-  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(
-      prop in obj,
-      `shadow: Property "${prop && prop.toString()}" not found in object.`
-    );
-  }
-  Object.defineProperty(obj, prop, {
-    value,
-    enumerable: !nonSerializable,
-    configurable: true,
-    writable: false
+// src/lib/polyfills.ts
+if (!Array.prototype.at) {
+  Object.defineProperty(Array.prototype, "at", {
+    value: function at(index) {
+      return this[index >= 0 ? index : this.length + index];
+    },
+    enumerable: false
   });
-  return value;
-}
-var BaseException = (function BaseExceptionClosure() {
-  function BaseException2(message, name) {
-    if (false) {
-      unreachable("Cannot initialize BaseException.");
-    }
-    this.message = message;
-    this.name = name;
-  }
-  BaseException2.prototype = new Error();
-  BaseException2.constructor = BaseException2;
-  return BaseException2;
-})();
-var PasswordException = class extends BaseException {
-  constructor(msg, code) {
-    super(msg, "PasswordException");
-    this.code = code;
-  }
-};
-var UnknownErrorException = class extends BaseException {
-  constructor(msg, details) {
-    super(msg, "UnknownErrorException");
-    this.details = details;
-  }
-};
-var InvalidPDFException = class extends BaseException {
-  constructor(msg) {
-    super(msg, "InvalidPDFException");
-  }
-};
-var ResponseException = class extends BaseException {
-  constructor(msg, status, missing) {
-    super(msg, "ResponseException");
-    this.status = status;
-    this.missing = missing;
-  }
-};
-var FormatError = class extends BaseException {
-  constructor(msg) {
-    super(msg, "FormatError");
-  }
-};
-var AbortException = class extends BaseException {
-  constructor(msg) {
-    super(msg, "AbortException");
-  }
-};
-function bytesToString(bytes) {
-  if (typeof bytes !== "object" || bytes?.length === void 0) {
-    unreachable("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) {
-  if (typeof str !== "string") {
-    unreachable("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) & 255;
-  }
-  return bytes;
-}
-function string32(value) {
-  if (false) {
-    assert(
-      typeof value === "number" && Math.abs(value) < 2 ** 32,
-      `string32: Unexpected input "${value}".`
-    );
-  }
-  return String.fromCharCode(
-    value >> 24 & 255,
-    value >> 16 & 255,
-    value >> 8 & 255,
-    value & 255
-  );
-}
-function objectSize(obj) {
-  return Object.keys(obj).length;
-}
-function isLittleEndian() {
-  const buffer8 = new Uint8Array(4);
-  buffer8[0] = 1;
-  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
-  return view32[0] === 1;
-}
-function isEvalSupported() {
-  try {
-    new Function("");
-    return true;
-  } catch {
-    return false;
-  }
-}
-var FeatureTest = class {
-  static get isLittleEndian() {
-    return shadow(this, "isLittleEndian", isLittleEndian());
-  }
-  static get isEvalSupported() {
-    return shadow(this, "isEvalSupported", isEvalSupported());
-  }
-  static get isOffscreenCanvasSupported() {
-    return shadow(
-      this,
-      "isOffscreenCanvasSupported",
-      typeof OffscreenCanvas !== "undefined"
-    );
-  }
-  static get isImageDecoderSupported() {
-    return shadow(
-      this,
-      "isImageDecoderSupported",
-      typeof ImageDecoder !== "undefined"
-    );
-  }
-  static get platform() {
-    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")
-    });
-  }
-  static get isCSSRoundSupported() {
-    return shadow(
-      this,
-      "isCSSRoundSupported",
-      globalThis.CSS?.supports?.("width: round(1.5px, 1px)")
-    );
-  }
-};
-var hexNumbers = Array.from(
-  Array(256).keys(),
-  (n) => n.toString(16).padStart(2, "0")
-);
-var _Util_static, getExtremumOnCurve_fn, getExtremum_fn;
-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.
-  static scaleMinMax(transform, minMax) {
-    let temp;
-    if (transform[0]) {
-      if (transform[0] < 0) {
-        temp = minMax[0];
-        minMax[0] = minMax[2];
-        minMax[2] = temp;
-      }
-      minMax[0] *= transform[0];
-      minMax[2] *= transform[0];
-      if (transform[3] < 0) {
-        temp = minMax[1];
-        minMax[1] = minMax[3];
-        minMax[3] = temp;
-      }
-      minMax[1] *= transform[3];
-      minMax[3] *= transform[3];
-    } else {
-      temp = minMax[0];
-      minMax[0] = minMax[1];
-      minMax[1] = temp;
-      temp = minMax[2];
-      minMax[2] = minMax[3];
-      minMax[3] = temp;
-      if (transform[1] < 0) {
-        temp = minMax[1];
-        minMax[1] = minMax[3];
-        minMax[3] = temp;
-      }
-      minMax[1] *= transform[1];
-      minMax[3] *= transform[1];
-      if (transform[2] < 0) {
-        temp = minMax[0];
-        minMax[0] = minMax[2];
-        minMax[2] = temp;
-      }
-      minMax[0] *= transform[2];
-      minMax[2] *= transform[2];
-    }
-    minMax[0] += transform[4];
-    minMax[1] += transform[5];
-    minMax[2] += transform[4];
-    minMax[3] += transform[5];
-  }
-  // 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]
-    ];
-  }
-  // 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, 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];
-    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 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];
-    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
-    ];
-  }
-  // 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(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
-  // 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);
-    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
-  // intersection of rect1 and rect2. If no intersection, returns 'null'
-  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
-  static intersect(rect1, rect2) {
-    const xLow = Math.max(
-      Math.min(rect1[0], rect1[2]),
-      Math.min(rect2[0], rect2[2])
-    );
-    const xHigh = Math.min(
-      Math.max(rect1[0], rect1[2]),
-      Math.max(rect2[0], rect2[2])
-    );
-    if (xLow > xHigh) {
-      return null;
-    }
-    const yLow = Math.max(
-      Math.min(rect1[1], rect1[3]),
-      Math.min(rect2[1], rect2[3])
-    );
-    const yHigh = Math.min(
-      Math.max(rect1[1], rect1[3]),
-      Math.max(rect2[1], rect2[3])
-    );
-    if (yLow > yHigh) {
-      return null;
-    }
-    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) {
-    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);
-  }
-};
-_Util_static = new WeakSet();
-getExtremumOnCurve_fn = function(x0, x1, x2, x3, y0, y1, y2, y3, t, minMax) {
-  if (t <= 0 || t >= 1) {
-    return;
-  }
-  const mt = 1 - t;
-  const tt = t * t;
-  const ttt = tt * t;
-  const x = mt * (mt * (mt * x0 + 3 * t * x1) + 3 * tt * x2) + ttt * x3;
-  const y = mt * (mt * (mt * y0 + 3 * t * y1) + 3 * tt * y2) + ttt * y3;
-  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);
-};
-getExtremum_fn = function(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
-  if (Math.abs(a) < 1e-12) {
-    if (Math.abs(b) >= 1e-12) {
-      __privateMethod(this, _Util_static, getExtremumOnCurve_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, -c / b, minMax);
-    }
-    return;
-  }
-  const delta = b ** 2 - 4 * c * a;
-  if (delta < 0) {
-    return;
-  }
-  const sqrtDelta = Math.sqrt(delta);
-  const a2 = 2 * a;
-  __privateMethod(this, _Util_static, getExtremumOnCurve_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
-  __privateMethod(this, _Util_static, getExtremumOnCurve_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
-};
-__privateAdd(Util, _Util_static);
-var 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,
-  728,
-  711,
-  710,
-  729,
-  733,
-  731,
-  730,
-  732,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  8226,
-  8224,
-  8225,
-  8230,
-  8212,
-  8211,
-  402,
-  8260,
-  8249,
-  8250,
-  8722,
-  8240,
-  8222,
-  8220,
-  8221,
-  8216,
-  8217,
-  8218,
-  8482,
-  64257,
-  64258,
-  321,
-  338,
-  352,
-  376,
-  381,
-  305,
-  322,
-  339,
-  353,
-  382,
-  0,
-  8364
-];
-function stringToPDFString(str, keepEscapeSequence = false) {
-  if (str[0] >= "\xEF") {
-    let encoding;
-    if (str[0] === "\xFE" && str[1] === "\xFF") {
-      encoding = "utf-16be";
-      if (str.length % 2 === 1) {
-        str = str.slice(0, -1);
-      }
-    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
-      encoding = "utf-16le";
-      if (str.length % 2 === 1) {
-        str = str.slice(0, -1);
-      }
-    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
-      encoding = "utf-8";
-    }
-    if (encoding) {
-      try {
-        const decoder = new TextDecoder(encoding, { fatal: true });
-        const buffer = stringToBytes(str);
-        const decoded = decoder.decode(buffer);
-        if (keepEscapeSequence || !decoded.includes("\x1B")) {
-          return decoded;
-        }
-        return decoded.replaceAll(/\x1b[^\x1b]*(?:\x1b|$)/g, "");
-      } catch (ex) {
-        warn(`stringToPDFString: "${ex}".`);
-      }
-    }
-  }
-  const strBuf = [];
-  for (let i = 0, ii = str.length; i < ii; i++) {
-    const charCode = str.charCodeAt(i);
-    if (!keepEscapeSequence && charCode === 27) {
-      while (++i < ii && str.charCodeAt(i) !== 27) {
-      }
-      continue;
-    }
-    const code = PDFStringTranslateTable[charCode];
-    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
-  }
-  return strBuf.join("");
-}
-function stringToUTF8String(str) {
-  return decodeURIComponent(escape(str));
-}
-function utf8StringToString(str) {
-  return unescape(encodeURIComponent(str));
-}
-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 = /* @__PURE__ */ new Date()) {
-  if (!(date instanceof Date)) {
-    date = new Date(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("");
-}
-var NormalizeRegex = null;
-var NormalizationMap = null;
-function normalizeUnicode(str) {
-  if (!NormalizeRegex) {
-    NormalizeRegex = /([\u00a0\u00b5\u037e\u0eb3\u2000-\u200a\u202f\u2126\ufb00-\ufb04\ufb06\ufb20-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufba1\ufba4-\ufba9\ufbae-\ufbb1\ufbd3-\ufbdc\ufbde-\ufbe7\ufbea-\ufbf8\ufbfc-\ufbfd\ufc00-\ufc5d\ufc64-\ufcf1\ufcf5-\ufd3d\ufd88\ufdf4\ufdfa-\ufdfb\ufe71\ufe77\ufe79\ufe7b\ufe7d]+)|(\ufb05+)/gu;
-    NormalizationMap = /* @__PURE__ */ new Map([["\uFB05", "\u017Ft"]]);
-  }
-  return str.replaceAll(
-    NormalizeRegex,
-    (_, p1, p2) => p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2)
-  );
-}
-function getUuid() {
-  if (typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  const buf = new Uint8Array(32);
-  crypto.getRandomValues(buf);
-  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();
-  }
-  return Array.from(arr, (num) => hexNumbers[num]).join("");
-}
-function toBase64Util(arr) {
-  if (Uint8Array.prototype.toBase64) {
-    return arr.toBase64();
-  }
-  return btoa(bytesToString(arr));
-}
-function fromBase64Util(str) {
-  if (Uint8Array.fromBase64) {
-    return Uint8Array.fromBase64(str);
-  }
-  return stringToBytes(atob(str));
 }
-if (false) {
-  Promise.try = function(fn, ...args) {
-    return new Promise((resolve) => {
-      resolve(fn(...args));
+if (!Promise.withResolvers) {
+  Promise.withResolvers = function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new this((res, rej) => {
+      resolve = res;
+      reject = rej;
     });
+    return {
+      resolve,
+      reject,
+      promise
+    };
   };
 }
-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.
+if (!("try" in Promise)) {
+  Object.defineProperty(Promise, "try", {
+    value: function tryFn(fn, ...args) {
+      return new this(
+        (resolve, reject) => {
+          try {
+            resolve(fn(...args));
+          } catch (error) {
+            reject(error);
+          }
+        }
       );
-    }
-    return signal;
-  };
+    },
+    enumerable: false
+  });
 }
 
 // src/pdf.js/src/shared/message_handler.js
@@ -1618,91 +514,6 @@ deleteStreamController_fn = async function(streamController, streamId) {
   delete this.streamControllers[streamId];
 };
 
-// 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/obj-bin-transform.js
 var _buffer, _view, _decoder, _CssFontInfo_instances, readString_fn;
 var _CssFontInfo = class _CssFontInfo {
@@ -1715,12 +526,12 @@ var _CssFontInfo = class _CssFontInfo {
     __privateSet(this, _view, new DataView(__privateGet(this, _buffer)));
     __privateSet(this, _decoder, new TextDecoder());
   }
-  static write(info2) {
+  static write(info) {
     const encoder = new TextEncoder();
     const encodedStrings = {};
     let stringsLength = 0;
     for (const prop of _CssFontInfo.strings) {
-      const encoded = encoder.encode(info2[prop]);
+      const encoded = encoder.encode(info[prop]);
       encodedStrings[prop] = encoded;
       stringsLength += 4 + encoded.length;
     }
@@ -1776,27 +587,27 @@ var _SystemFontInfo = class _SystemFontInfo {
     __privateSet(this, _view2, new DataView(__privateGet(this, _buffer2)));
     __privateSet(this, _decoder2, new TextDecoder());
   }
-  static write(info2) {
+  static write(info) {
     const encoder = new TextEncoder();
     const encodedStrings = {};
     let stringsLength = 0;
     for (const prop of _SystemFontInfo.strings) {
-      const encoded = encoder.encode(info2[prop]);
+      const encoded = encoder.encode(info[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);
+    if (info.style) {
+      encodedStyleStyle = encoder.encode(info.style.style);
+      encodedStyleWeight = encoder.encode(info.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.setUint8(offset++, info.guessFallback ? 1 : 0);
     view.setUint32(offset, 0);
     offset += 4;
     stringsLength = 0;
@@ -1809,7 +620,7 @@ var _SystemFontInfo = class _SystemFontInfo {
       offset += 4 + length;
     }
     view.setUint32(offset - stringsLength - 4, stringsLength);
-    if (info2.style) {
+    if (info.style) {
       view.setUint32(offset, encodedStyleStyle.length);
       data.set(encodedStyleStyle, offset + 4);
       offset += 4 + encodedStyleStyle.length;
@@ -2219,6 +1030,835 @@ __privateAdd(_FontInfo, _OFFSET_DEFAULT_VMETRICS, __privateGet(_FontInfo, _OFFSE
 __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;
@@ -2411,74 +2051,15 @@ function grayToRGBA(src, dest) {
 }
 
 export {
-  isNodeJS,
-  FONT_IDENTITY_MATRIX,
-  LINE_FACTOR,
-  LINE_DESCENT_FACTOR,
-  BASELINE_FACTOR,
-  RenderingIntentFlag,
-  AnnotationMode,
-  AnnotationEditorPrefix,
-  AnnotationEditorType,
-  AnnotationEditorParamsType,
-  PermissionFlag,
-  TextRenderingMode,
-  ImageKind,
-  AnnotationType,
-  AnnotationReplyType,
-  AnnotationFlag,
-  AnnotationFieldFlag,
-  AnnotationBorderStyleType,
-  AnnotationActionEventType,
-  DocumentActionEventType,
-  PageActionEventType,
-  VerbosityLevel,
-  OPS,
-  DrawOPS,
-  PasswordResponses,
-  setVerbosityLevel,
-  getVerbosityLevel,
-  info,
-  warn,
-  unreachable,
-  assert,
-  createValidAbsoluteUrl,
-  updateUrlHash,
-  shadow,
-  BaseException,
-  PasswordException,
-  InvalidPDFException,
-  ResponseException,
-  FormatError,
-  AbortException,
-  bytesToString,
-  stringToBytes,
-  string32,
-  objectSize,
-  FeatureTest,
-  hexNumbers,
-  Util,
-  stringToPDFString,
-  stringToUTF8String,
-  utf8StringToString,
-  isArrayEqual,
-  getModificationDate,
-  normalizeUnicode,
-  getUuid,
-  AnnotationPrefix,
-  _isValidExplicitDest,
-  MathClamp,
-  toHexUtil,
-  toBase64Util,
-  fromBase64Util,
   MurmurHash3_64,
   wrapReason,
   MessageHandler,
-  ColorConverters,
-  DateFormats,
-  TimeFormats,
   convertToRGBA,
   convertBlackAndWhiteToRGBA,
   grayToRGBA,
-  FontInfo
+  FontInfo,
+  bidi,
+  ColorConverters,
+  DateFormats,
+  TimeFormats
 };