@chialab/pdfjs-lib 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/node/index.js

@@ -36,16 +36,16 @@ import {
   info,
   isNodeJS,
   normalizeUnicode,
-  objectFromMap,
   setVerbosityLevel,
   shadow,
   string32,
   stringToBytes,
   toBase64Util,
   unreachable,
+  updateUrlHash,
   warn,
   wrapReason
-} from "./chunk-WL32POZ2.js";
+} from "./chunk-MAMMG4XK.js";
 import {
   __privateAdd,
   __privateGet,
@@ -367,6 +367,9 @@ function stopEvent(e) {
   e.preventDefault();
   e.stopPropagation();
 }
+function deprecated(details) {
+  console.log("Deprecated API usage: " + details);
+}
 var _regex;
 var PDFDateString = class {
   /**
@@ -464,6 +467,7 @@ function getRGB(color) {
 function getColorValues(colors) {
   const span = document.createElement("span");
   span.style.visibility = "hidden";
+  span.style.colorScheme = "only light";
   document.body.append(span);
   for (const name of colors.keys()) {
     span.style.color = name;
@@ -522,8 +526,9 @@ var OutputScale = class _OutputScale {
    * @returns {boolean} Returns `true` if scaling was limited,
    *   `false` otherwise.
    */
-  limitCanvas(width, height, maxPixels, maxDim) {
+  limitCanvas(width, height, maxPixels, maxDim, capAreaFactor = -1) {
     let maxAreaScale = Infinity, maxWidthScale = Infinity, maxHeightScale = Infinity;
+    maxPixels = _OutputScale.capPixels(maxPixels, capAreaFactor);
     if (maxPixels > 0) {
       maxAreaScale = Math.sqrt(maxPixels / (width * height));
     }
@@ -542,6 +547,15 @@ var OutputScale = class _OutputScale {
   static get pixelRatio() {
     return globalThis.devicePixelRatio || 1;
   }
+  static capPixels(maxPixels, capAreaFactor) {
+    if (capAreaFactor >= 0) {
+      const winPixels = Math.ceil(
+        (false ? window.innerWidth * window.innerHeight : window.screen.availWidth * window.screen.availHeight) * this.pixelRatio ** 2 * (1 + capAreaFactor / 100)
+      );
+      return maxPixels > 0 ? Math.min(maxPixels, winPixels) : winPixels;
+    }
+    return maxPixels;
+  }
 };
 var SupportedImageMimeTypes = [
   "image/apng",
@@ -1950,6 +1964,7 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
       }
     }
     __privateSet(this, _updateModeCapability, Promise.withResolvers());
+    __privateGet(this, _currentDrawingSession)?.commitOrRemove();
     __privateSet(this, _mode, mode);
     if (mode === AnnotationEditorType.NONE) {
       this.setEditingState(false);
@@ -1975,7 +1990,7 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
       return;
     }
     for (const editor of __privateGet(this, _allEditors).values()) {
-      if (editor.annotationElementId === editId) {
+      if (editor.annotationElementId === editId || editor.id === editId) {
         this.setSelected(editor);
         editor.enterInEditMode();
       } else {
@@ -1991,16 +2006,17 @@ var _AnnotationEditorUIManager = class _AnnotationEditorUIManager {
   }
   /**
    * Update the toolbar if it's required to reflect the tool currently used.
+   * @param {Object} options
    * @param {number} mode
    * @returns {undefined}
    */
-  updateToolbar(mode) {
-    if (mode === __privateGet(this, _mode)) {
+  updateToolbar(options) {
+    if (options.mode === __privateGet(this, _mode)) {
       return;
     }
     this._eventBus.dispatch("switchannotationeditormode", {
       source: this,
-      mode
+      ...options
     });
   }
   /**
@@ -3390,9 +3406,11 @@ onTouchEnd_fn = function(evt) {
   if (evt.touches.length >= 2) {
     return;
   }
-  __privateGet(this, _touchMoveAC).abort();
-  __privateSet(this, _touchMoveAC, null);
-  (_a2 = __privateGet(this, _onPinchEnd)) == null ? void 0 : _a2.call(this);
+  if (__privateGet(this, _touchMoveAC)) {
+    __privateGet(this, _touchMoveAC).abort();
+    __privateSet(this, _touchMoveAC, null);
+    (_a2 = __privateGet(this, _onPinchEnd)) == null ? void 0 : _a2.call(this);
+  }
   if (!__privateGet(this, _touchInfo)) {
     return;
   }
@@ -3432,6 +3450,7 @@ var _AnnotationEditor = class _AnnotationEditor {
     __privateAdd(this, _prevDragY, 0);
     __privateAdd(this, _telemetryTimeouts, null);
     __privateAdd(this, _touchManager, null);
+    __publicField(this, "isSelected", false);
     __publicField(this, "_isCopy", false);
     __publicField(this, "_editToolbar", null);
     __publicField(this, "_initialOptions", /* @__PURE__ */ Object.create(null));
@@ -4052,7 +4071,7 @@ var _AnnotationEditor = class _AnnotationEditor {
     }
     const [tx, ty] = this.getInitialTranslation();
     this.translate(tx, ty);
-    bindEvents(this, div, ["keydown", "pointerdown"]);
+    bindEvents(this, div, ["keydown", "pointerdown", "dblclick"]);
     if (this.isResizable && this._uiManager._supportsPinchToZoom) {
       __privateGet(this, _touchManager) || __privateSet(this, _touchManager, new TouchManager({
         container: div,
@@ -4083,9 +4102,6 @@ var _AnnotationEditor = class _AnnotationEditor {
     }
     __privateMethod(this, _AnnotationEditor_instances, selectOnPointerEvent_fn).call(this, event);
   }
-  get isSelected() {
-    return this._uiManager.isSelected(this);
-  }
   _onStartDragging() {
   }
   _onStopDragging() {
@@ -4192,15 +4208,27 @@ var _AnnotationEditor = class _AnnotationEditor {
   }
   /**
    * Enable edit mode.
+   * @returns {boolean} - true if the edit mode has been enabled.
    */
   enableEditMode() {
+    if (this.isInEditMode()) {
+      return false;
+    }
+    this.parent.setEditingState(false);
     __privateSet(this, _isInEditMode, true);
+    return true;
   }
   /**
    * Disable edit mode.
+   * @returns {boolean} - true if the edit mode has been disabled.
    */
   disableEditMode() {
+    if (!this.isInEditMode()) {
+      return false;
+    }
+    this.parent.setEditingState(true);
     __privateSet(this, _isInEditMode, false);
+    return true;
   }
   /**
    * Check if the editor is edited.
@@ -4441,6 +4469,10 @@ var _AnnotationEditor = class _AnnotationEditor {
    * Select this editor.
    */
   select() {
+    if (this.isSelected && this._editToolbar) {
+      return;
+    }
+    this.isSelected = true;
     this.makeResizable();
     this.div?.classList.add("selectedEditor");
     if (!this._editToolbar) {
@@ -4458,6 +4490,10 @@ var _AnnotationEditor = class _AnnotationEditor {
    * Unselect this editor.
    */
   unselect() {
+    if (!this.isSelected) {
+      return;
+    }
+    this.isSelected = false;
     __privateGet(this, _resizersDiv)?.classList.add("hidden");
     this.div?.classList.remove("selectedEditor");
     if (this.div?.contains(document.activeElement)) {
@@ -4487,10 +4523,35 @@ var _AnnotationEditor = class _AnnotationEditor {
    */
   enableEditing() {
   }
+  /**
+   * Check if the content of this editor can be changed.
+   * For example, a FreeText editor can be changed (the user can change the
+   * text), but a Stamp editor cannot.
+   * @returns {boolean}
+   */
+  get canChangeContent() {
+    return false;
+  }
   /**
    * The editor is about to be edited.
    */
   enterInEditMode() {
+    if (!this.canChangeContent) {
+      return;
+    }
+    this.enableEditMode();
+    this.div.focus();
+  }
+  /**
+   * ondblclick callback.
+   * @param {MouseEvent} event
+   */
+  dblclick(event) {
+    this.enterInEditMode();
+    this.parent.updateToolbar({
+      mode: this.constructor._editorType,
+      editId: this.id
+    });
   }
   /**
    * @returns {HTMLElement | null} the element requiring an alt text.
@@ -5131,6 +5192,15 @@ var AnnotationStorage = class {
     this.onSetModified = null;
     this.onResetModified = null;
     this.onAnnotationEditor = null;
+    if (false) {
+      Object.defineProperty(this, "_setValues", {
+        value: (obj) => {
+          for (const [key, val] of Object.entries(obj)) {
+            this.setValue(key, val);
+          }
+        }
+      });
+    }
   }
   /**
    * Get the value for a given key if it exists, or return the default value.
@@ -5205,20 +5275,6 @@ var AnnotationStorage = class {
   has(key) {
     return __privateGet(this, _storage).has(key);
   }
-  /**
-   * @returns {Object | null}
-   */
-  getAll() {
-    return __privateGet(this, _storage).size > 0 ? objectFromMap(__privateGet(this, _storage)) : null;
-  }
-  /**
-   * @param {Object} obj
-   */
-  setAll(obj) {
-    for (const [key, val] of Object.entries(obj)) {
-      this.setValue(key, val);
-    }
-  }
   get size() {
     return __privateGet(this, _storage).size;
   }
@@ -5325,6 +5381,9 @@ var AnnotationStorage = class {
       hash: ids.join(",")
     });
   }
+  [Symbol.iterator]() {
+    return __privateGet(this, _storage).entries();
+  }
 };
 _modified = new WeakMap();
 _modifiedIds = new WeakMap();
@@ -6050,6 +6109,110 @@ var FontFaceObject = class {
   }
 };
 
+// src/pdf.js/src/display/api_utils.js
+function getUrlProp(val) {
+  if (false) {
+    return null;
+  }
+  if (val instanceof URL) {
+    return val.href;
+  }
+  if (typeof val === "string") {
+    if (isNodeJS) {
+      return val;
+    }
+    const url = URL.parse(val, window.location);
+    if (url) {
+      return url.href;
+    }
+  }
+  throw new Error(
+    "Invalid PDF url data: either string or URL-object is expected in the url property."
+  );
+}
+function getDataProp(val) {
+  if (isNodeJS && typeof Buffer !== "undefined" && // eslint-disable-line no-undef
+  val instanceof Buffer) {
+    throw new Error(
+      "Please provide binary data as `Uint8Array`, rather than `Buffer`."
+    );
+  }
+  if (val instanceof Uint8Array && val.byteLength === val.buffer.byteLength) {
+    return val;
+  }
+  if (typeof val === "string") {
+    return stringToBytes(val);
+  }
+  if (val instanceof ArrayBuffer || ArrayBuffer.isView(val) || typeof val === "object" && !isNaN(val?.length)) {
+    return new Uint8Array(val);
+  }
+  throw new Error(
+    "Invalid PDF binary data: either TypedArray, string, or array-like object is expected in the data property."
+  );
+}
+function getFactoryUrlProp(val) {
+  if (typeof val !== "string") {
+    return null;
+  }
+  if (val.endsWith("/")) {
+    return val;
+  }
+  throw new Error(`Invalid factory url: "${val}" must include trailing slash.`);
+}
+var isRefProxy = (v) => typeof v === "object" && Number.isInteger(v?.num) && v.num >= 0 && Number.isInteger(v?.gen) && v.gen >= 0;
+var isNameProxy = (v) => typeof v === "object" && typeof v?.name === "string";
+var isValidExplicitDest = _isValidExplicitDest.bind(
+  null,
+  /* validRef = */
+  isRefProxy,
+  /* validName = */
+  isNameProxy
+);
+var _listeners, _deferred;
+var LoopbackPort = class {
+  constructor() {
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
+    __privateAdd(this, _deferred, Promise.resolve());
+  }
+  postMessage(obj, transfer) {
+    const event = {
+      data: structuredClone(obj, transfer ? { transfer } : null)
+    };
+    __privateGet(this, _deferred).then(() => {
+      for (const [listener] of __privateGet(this, _listeners)) {
+        listener.call(this, event);
+      }
+    });
+  }
+  addEventListener(name, listener, options = null) {
+    let rmAbort = null;
+    if (options?.signal instanceof AbortSignal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        warn("LoopbackPort - cannot use an `aborted` signal.");
+        return;
+      }
+      const onAbort = () => this.removeEventListener(name, listener);
+      rmAbort = () => signal.removeEventListener("abort", onAbort);
+      signal.addEventListener("abort", onAbort);
+    }
+    __privateGet(this, _listeners).set(listener, rmAbort);
+  }
+  removeEventListener(name, listener) {
+    const rmAbort = __privateGet(this, _listeners).get(listener);
+    rmAbort?.();
+    __privateGet(this, _listeners).delete(listener);
+  }
+  terminate() {
+    for (const [, rmAbort] of __privateGet(this, _listeners)) {
+      rmAbort?.();
+    }
+    __privateGet(this, _listeners).clear();
+  }
+};
+_listeners = new WeakMap();
+_deferred = new WeakMap();
+
 // src/pdf.js/src/display/node_utils.js
 import { createRequire as __createRequire__ } from "module";
 
@@ -6473,7 +6636,7 @@ createUrl_fn = function(id) {
       if (isDataScheme(url)) {
         warn('#createUrl: ignore "data:"-URL for performance reasons.');
       } else {
-        __privateSet(this, _baseUrl, url.split("#", 1)[0]);
+        __privateSet(this, _baseUrl, updateUrlHash(url, ""));
       }
     }
   }
@@ -6668,6 +6831,13 @@ if (isNodeJS) {
         warn("Cannot polyfill `Path2D`, rendering may be broken.");
       }
     }
+    if (!globalThis.navigator?.language) {
+      globalThis.navigator = {
+        language: "en-US",
+        platform: "",
+        userAgent: ""
+      };
+    }
   }
 }
 async function fetchData2(url) {
@@ -6712,77 +6882,441 @@ var NodeWasmFactory = class extends BaseWasmFactory {
   }
 };
 
-// src/pdf.js/src/display/pattern_helper.js
-var PathType = {
-  FILL: "Fill",
-  STROKE: "Stroke",
-  SHADING: "Shading"
-};
-function applyBoundingBox(ctx, bbox) {
-  if (!bbox) {
-    return;
+// src/lib/utils.ts
+async function canvasToData(canvas) {
+  if ("toBlob" in canvas) {
+    const blob = await new Promise(
+      (resolve) => canvas.toBlob((data) => resolve(data))
+    );
+    if (!blob) {
+      throw new Error("Failed to generate graphics");
+    }
+    return new Uint8Array(await blob.arrayBuffer());
   }
-  const width = bbox[2] - bbox[0];
-  const height = bbox[3] - bbox[1];
-  const region = new SvgPath2D();
-  region.rect(bbox[0], bbox[1], width, height);
-  ctx.clip(region);
+  const buffer = await canvas.encode("png");
+  return new Uint8Array(buffer);
 }
-var BaseShadingPattern = class {
-  constructor() {
-    if (false) {
-      unreachable("Cannot initialize BaseShadingPattern.");
-    }
+async function toDataUrl(data, type = "image/png") {
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        resolve(reader.result);
+      };
+      reader.readAsDataURL(new Blob([data], { type }));
+    });
   }
-  isModifyingCurrentTransform() {
-    return false;
+  return `data:${type};base64,${Buffer.from(data).toString("base64")}`;
+}
+function makeSerializable(object) {
+  if (typeof object !== "object" || object === null) {
+    return object;
   }
-  getPattern() {
-    unreachable("Abstract method `getPattern` called.");
+  if (object instanceof Int8Array || object instanceof Uint8Array || object instanceof Uint8ClampedArray || object instanceof Int16Array || object instanceof Uint16Array || object instanceof Int32Array || object instanceof Uint32Array || object instanceof Float32Array || object instanceof Float64Array) {
+    return makeSerializable(Array.from(object));
   }
-};
-var RadialAxialShadingPattern = class extends BaseShadingPattern {
-  constructor(IR) {
-    super();
-    this._type = IR[1];
-    this._bbox = IR[2];
-    this._colorStops = IR[3];
-    this._p0 = IR[4];
-    this._p1 = IR[5];
-    this._r0 = IR[6];
-    this._r1 = IR[7];
-    this.matrix = null;
+  if (object instanceof BigInt64Array || object instanceof BigUint64Array) {
+    return makeSerializable(Array.from(object));
   }
-  _createGradient(ctx) {
-    let grad;
-    if (this._type === "axial") {
-      grad = ctx.createLinearGradient(
-        this._p0[0],
-        this._p0[1],
-        this._p1[0],
-        this._p1[1]
-      );
-    } else if (this._type === "radial") {
-      grad = ctx.createRadialGradient(
-        this._p0[0],
-        this._p0[1],
-        this._r0,
-        this._p1[0],
-        this._p1[1],
-        this._r1
-      );
-    }
-    for (const colorStop of this._colorStops) {
-      grad.addColorStop(colorStop[0], colorStop[1]);
-    }
-    return grad;
+  if (Array.isArray(object)) {
+    return object.map(makeSerializable);
   }
-  getPattern(ctx, owner, inverse, pathType) {
-    let pattern;
-    if (pathType === PathType.STROKE || pathType === PathType.FILL) {
-      const ownerBBox = owner.current.getClippedPathBoundingBox(
-        pathType,
-        getCurrentTransform(ctx)
+  return Object.fromEntries(
+    Object.entries(object).map(([key, value]) => [
+      key,
+      makeSerializable(value)
+    ])
+  );
+}
+function colorToRgb(color) {
+  if (color.startsWith("#")) {
+    const hex = color.slice(1);
+    if (hex.length === 3) {
+      return [
+        Number.parseInt(hex[0] + hex[0], 16),
+        Number.parseInt(hex[1] + hex[1], 16),
+        Number.parseInt(hex[2] + hex[2], 16)
+      ];
+    }
+    if (hex.length === 6) {
+      return [
+        Number.parseInt(hex.slice(0, 2), 16),
+        Number.parseInt(hex.slice(2, 4), 16),
+        Number.parseInt(hex.slice(4, 6), 16)
+      ];
+    }
+  }
+  throw new Error(`Invalid color format: ${color}`);
+}
+function rgbToHex(r, g, b) {
+  const toHex = (value) => value.toString(16).padStart(2, "0");
+  if (Array.isArray(r)) {
+    return `#${toHex(r[0])}${toHex(r[1])}${toHex(r[2])}`;
+  }
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+// src/lib/NodeFilterFactory.ts
+var filtersRegistry = /* @__PURE__ */ new Map();
+function createTables(maps) {
+  if (maps.length === 1) {
+    const mapR2 = maps[0];
+    const buffer = new Array(256);
+    for (let i = 0; i < 256; i++) {
+      buffer[i] = mapR2[i] / 255;
+    }
+    return [buffer, buffer, buffer];
+  }
+  const [mapR, mapG, mapB] = maps;
+  const bufferR = new Array(256);
+  const bufferG = new Array(256);
+  const bufferB = new Array(256);
+  for (let i = 0; i < 256; i++) {
+    bufferR[i] = mapR[i] / 255;
+    bufferG[i] = mapG[i] / 255;
+    bufferB[i] = mapB[i] / 255;
+  }
+  return [bufferR, bufferG, bufferB];
+}
+function createTransferMapAlphaConversion(aTable) {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    const tableSize = aTable.length;
+    for (let i = 0; i < data.length; i += 4) {
+      const alpha = data[i + 3] / 255;
+      const index = alpha * (tableSize - 1);
+      const lower = Math.floor(index);
+      const upper = Math.min(lower + 1, tableSize - 1);
+      const t = index - lower;
+      const newAlpha = (1 - t) * aTable[lower] + t * aTable[upper];
+      data[i + 3] = newAlpha * 255;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createTransferMapConversion(rTable, gTable, bTable) {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    const rSize = rTable.length;
+    const gSize = gTable.length;
+    const bSize = bTable.length;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i] / 255;
+      const g = data[i + 1] / 255;
+      const b = data[i + 2] / 255;
+      const rIndex = r * (rSize - 1);
+      const rLower = Math.floor(rIndex);
+      const rUpper = Math.min(rLower + 1, rSize - 1);
+      const rT = rIndex - rLower;
+      const newR = (1 - rT) * rTable[rLower] + rT * rTable[rUpper];
+      const gIndex = g * (gSize - 1);
+      const gLower = Math.floor(gIndex);
+      const gUpper = Math.min(gLower + 1, gSize - 1);
+      const gT = gIndex - gLower;
+      const newG = (1 - gT) * gTable[gLower] + gT * gTable[gUpper];
+      const bIndex = b * (bSize - 1);
+      const bLower = Math.floor(bIndex);
+      const bUpper = Math.min(bLower + 1, bSize - 1);
+      const bT = bIndex - bLower;
+      const newB = (1 - bT) * bTable[bLower] + bT * bTable[bUpper];
+      data[i] = newR * 255;
+      data[i + 1] = newG * 255;
+      data[i + 2] = newB * 255;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createLuminosityConversion() {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      data[i] = data[i + 1] = data[i + 2] = 0;
+      data[i + 3] = r * 0.3 + g * 0.59 + b * 0.11;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+function createGrayConversion() {
+  return (ctx) => {
+    const imageData = ctx.getImageData(
+      0,
+      0,
+      ctx.canvas.width,
+      ctx.canvas.height
+    );
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      const gray = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      data[i] = data[i + 1] = data[i + 2] = gray;
+    }
+    ctx.putImageData(imageData, 0, 0);
+  };
+}
+var NodeFilterFactory2 = class extends NodeFilterFactory {
+  addFilter(maps) {
+    if (!maps) {
+      return "none";
+    }
+    const [rTable, gTable, bTable] = createTables(maps);
+    const url = `url(#filter_${maps.length === 1 ? rTable.join("_") : `${rTable.join("_")}_${gTable.join("_")}_${bTable.join("_")}`})`;
+    if (!filtersRegistry.has(url)) {
+      filtersRegistry.set(
+        url,
+        createTransferMapConversion(rTable, gTable, bTable)
+      );
+    }
+    return url;
+  }
+  addHCMFilter(fgColor, bgColor) {
+    const fgRGB = colorToRgb(fgColor);
+    const bgRGB = colorToRgb(bgColor);
+    const url = `url(#hcm_${rgbToHex(fgRGB)}_${rgbToHex(bgRGB)})`;
+    if (!filtersRegistry.has(url)) {
+      const table = new Array(256);
+      for (let i = 0; i <= 255; i++) {
+        const x = i / 255;
+        table[i] = x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+      }
+      const transferMapFilter = createTransferMapConversion(
+        table,
+        table,
+        table
+      );
+      const grayFilter = createGrayConversion();
+      const getSteps = (c, n) => {
+        const start = fgRGB[c] / 255;
+        const end = bgRGB[c] / 255;
+        const arr = new Array(n + 1);
+        for (let i = 0; i <= n; i++) {
+          arr[i] = start + i / n * (end - start);
+        }
+        return arr;
+      };
+      const finalTransferMap = createTransferMapConversion(
+        getSteps(0, 5),
+        getSteps(1, 5),
+        getSteps(2, 5)
+      );
+      filtersRegistry.set(url, (ctx) => {
+        transferMapFilter(ctx);
+        grayFilter(ctx);
+        finalTransferMap(ctx);
+      });
+    }
+    return url;
+  }
+  addAlphaFilter(map) {
+    const [tableA] = createTables([map]);
+    const url = `url(#alpha_${tableA.join("_")})`;
+    if (!filtersRegistry.has(url)) {
+      filtersRegistry.set(url, createTransferMapAlphaConversion(map));
+    }
+    return url;
+  }
+  addLuminosityFilter(map) {
+    const url = `url(#luminosity${map ? `_${map.join("_")}` : ""})`;
+    if (!filtersRegistry.has(url)) {
+      const tables = map ? createTables([map]) : null;
+      const alphaFilter = tables ? createTransferMapAlphaConversion(tables[0]) : null;
+      const luminosityFilter = createLuminosityConversion();
+      filtersRegistry.set(url, (ctx) => {
+        luminosityFilter(ctx);
+        alphaFilter?.(ctx);
+      });
+    }
+    return url;
+  }
+  addHighlightHCMFilter(filterName, fgColor, bgColor, newFgColor, newBgColor) {
+    const fgRGB = colorToRgb(fgColor);
+    const bgRGB = colorToRgb(bgColor);
+    let newFgRGB = colorToRgb(newFgColor);
+    let newBgRGB = colorToRgb(newBgColor);
+    const url = `url(#highlight_hcm_${filterName}_${rgbToHex(fgRGB)}_${rgbToHex(bgRGB)}_${rgbToHex(newFgRGB)}_${rgbToHex(newBgRGB)})`;
+    if (!filtersRegistry.has(url)) {
+      let fgGray = Math.round(
+        0.2126 * fgRGB[0] + 0.7152 * fgRGB[1] + 0.0722 * fgRGB[2]
+      );
+      let bgGray = Math.round(
+        0.2126 * bgRGB[0] + 0.7152 * bgRGB[1] + 0.0722 * bgRGB[2]
+      );
+      if (bgGray < fgGray) {
+        [fgGray, bgGray, newFgRGB, newBgRGB] = [
+          bgGray,
+          fgGray,
+          newBgRGB,
+          newFgRGB
+        ];
+      }
+      const grayFilter = createGrayConversion();
+      const getSteps = (fg, bg, n) => {
+        const arr = new Array(256);
+        const step = (bgGray - fgGray) / n;
+        const newStart = fg / 255;
+        const newStep = (bg - fg) / (255 * n);
+        let prev = 0;
+        for (let i = 0; i <= n; i++) {
+          const k = Math.round(fgGray + i * step);
+          const value = newStart + i * newStep;
+          for (let j = prev; j <= k; j++) {
+            arr[j] = value;
+          }
+          prev = k + 1;
+        }
+        for (let i = prev; i < 256; i++) {
+          arr[i] = arr[prev - 1];
+        }
+        return arr;
+      };
+      const transferMapFilter = createTransferMapConversion(
+        getSteps(newFgRGB[0], newBgRGB[0], 5),
+        getSteps(newFgRGB[1], newBgRGB[1], 5),
+        getSteps(newFgRGB[2], newBgRGB[2], 5)
+      );
+      filtersRegistry.set(url, (ctx) => {
+        grayFilter(ctx);
+        transferMapFilter(ctx);
+      });
+    }
+    return url;
+  }
+};
+
+// src/lib/NodeCanvasFactory.ts
+var NodeCanvasFactory2 = class extends NodeCanvasFactory {
+  create(width, height) {
+    const factory = this;
+    const { canvas, context } = super.create(width, height);
+    const drawImage = context.drawImage;
+    let currentFilter = "none";
+    Object.defineProperty(context, "filter", {
+      get() {
+        if (currentFilter.startsWith("url(")) {
+          return "none";
+        }
+        return currentFilter;
+      },
+      set(value) {
+        currentFilter = value;
+      },
+      configurable: true
+    });
+    context.drawImage = function(src, ...args) {
+      const filter = filtersRegistry.get(currentFilter);
+      if (!filter) {
+        drawImage.call(this, src, ...args);
+        return;
+      }
+      const { canvas: canvas2, context: context2 } = factory.create(src.width, src.height);
+      context2.drawImage(src, 0, 0, src.width, src.height);
+      filter(context2);
+      drawImage.call(this, canvas2, ...args);
+      factory.destroy({
+        canvas: canvas2,
+        context: context2
+      });
+    };
+    return {
+      canvas,
+      context
+    };
+  }
+};
+
+// src/pdf.js/src/display/pattern_helper.js
+var PathType = {
+  FILL: "Fill",
+  STROKE: "Stroke",
+  SHADING: "Shading"
+};
+function applyBoundingBox(ctx, bbox) {
+  if (!bbox) {
+    return;
+  }
+  const width = bbox[2] - bbox[0];
+  const height = bbox[3] - bbox[1];
+  const region = new SvgPath2D();
+  region.rect(bbox[0], bbox[1], width, height);
+  ctx.clip(region);
+}
+var BaseShadingPattern = class {
+  constructor() {
+    if (false) {
+      unreachable("Cannot initialize BaseShadingPattern.");
+    }
+  }
+  isModifyingCurrentTransform() {
+    return false;
+  }
+  getPattern() {
+    unreachable("Abstract method `getPattern` called.");
+  }
+};
+var RadialAxialShadingPattern = class extends BaseShadingPattern {
+  constructor(IR) {
+    super();
+    this._type = IR[1];
+    this._bbox = IR[2];
+    this._colorStops = IR[3];
+    this._p0 = IR[4];
+    this._p1 = IR[5];
+    this._r0 = IR[6];
+    this._r1 = IR[7];
+    this.matrix = null;
+  }
+  _createGradient(ctx) {
+    let grad;
+    if (this._type === "axial") {
+      grad = ctx.createLinearGradient(
+        this._p0[0],
+        this._p0[1],
+        this._p1[0],
+        this._p1[1]
+      );
+    } else if (this._type === "radial") {
+      grad = ctx.createRadialGradient(
+        this._p0[0],
+        this._p0[1],
+        this._r0,
+        this._p1[0],
+        this._p1[1],
+        this._r1
+      );
+    }
+    for (const colorStop of this._colorStops) {
+      grad.addColorStop(colorStop[0], colorStop[1]);
+    }
+    return grad;
+  }
+  getPattern(ctx, owner, inverse, pathType) {
+    let pattern;
+    if (pathType === PathType.STROKE || pathType === PathType.FILL) {
+      const ownerBBox = owner.current.getClippedPathBoundingBox(
+        pathType,
+        getCurrentTransform(ctx)
       ) || [0, 0, 0, 0];
       const width = Math.ceil(ownerBBox[2] - ownerBBox[0]) || 1;
       const height = Math.ceil(ownerBBox[3] - ownerBBox[1]) || 1;
@@ -7254,18 +7788,13 @@ var _TilingPattern = class _TilingPattern {
     const context = graphics.ctx, current = graphics.current;
     switch (paintType) {
       case PaintType.COLORED:
-        const ctx = this.ctx;
-        context.fillStyle = ctx.fillStyle;
-        context.strokeStyle = ctx.strokeStyle;
-        current.fillColor = ctx.fillStyle;
-        current.strokeColor = ctx.strokeStyle;
+        const { fillStyle, strokeStyle } = this.ctx;
+        context.fillStyle = current.fillColor = fillStyle;
+        context.strokeStyle = current.strokeColor = strokeStyle;
         break;
       case PaintType.UNCOLORED:
-        const cssColor = Util.makeHexColor(color[0], color[1], color[2]);
-        context.fillStyle = cssColor;
-        context.strokeStyle = cssColor;
-        current.fillColor = cssColor;
-        current.strokeColor = cssColor;
+        context.fillStyle = context.strokeStyle = color;
+        current.fillColor = current.strokeColor = color;
         break;
       default:
         throw new FormatError(`Unsupported paint type: ${paintType}`);
@@ -8202,7 +8731,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     let maskX = layerOffsetX - maskOffsetX;
     let maskY = layerOffsetY - maskOffsetY;
     if (backdrop) {
-      const backdropRGB = Util.makeHexColor(...backdrop);
       if (maskX < 0 || maskY < 0 || maskX + width > maskCanvas.width || maskY + height > maskCanvas.height) {
         const canvas = this.cachedCanvases.getCanvas(
           "maskExtension",
@@ -8212,7 +8740,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         const ctx = canvas.context;
         ctx.drawImage(maskCanvas, -maskX, -maskY);
         ctx.globalCompositeOperation = "destination-atop";
-        ctx.fillStyle = backdropRGB;
+        ctx.fillStyle = backdrop;
         ctx.fillRect(0, 0, width, height);
         ctx.globalCompositeOperation = "source-over";
         maskCanvas = canvas.canvas;
@@ -8225,7 +8753,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         clip2.rect(maskX, maskY, width, height);
         maskCtx.clip(clip2);
         maskCtx.globalCompositeOperation = "destination-atop";
-        maskCtx.fillStyle = backdropRGB;
+        maskCtx.fillStyle = backdrop;
         maskCtx.fillRect(maskX, maskY, width, height);
         maskCtx.restore();
       }
@@ -8904,20 +9432,16 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.current.fillColor = this.getColorN_Pattern(arguments);
     this.current.patternFill = true;
   }
-  setStrokeRGBColor(r, g, b) {
-    this.ctx.strokeStyle = this.current.strokeColor = Util.makeHexColor(
-      r,
-      g,
-      b
-    );
+  setStrokeRGBColor(color) {
+    this.ctx.strokeStyle = this.current.strokeColor = color;
     this.current.patternStroke = false;
   }
   setStrokeTransparent() {
     this.ctx.strokeStyle = this.current.strokeColor = "transparent";
     this.current.patternStroke = false;
   }
-  setFillRGBColor(r, g, b) {
-    this.ctx.fillStyle = this.current.fillColor = Util.makeHexColor(r, g, b);
+  setFillRGBColor(color) {
+    this.ctx.fillStyle = this.current.fillColor = color;
     this.current.patternFill = false;
   }
   setFillTransparent() {
@@ -9667,28 +10191,25 @@ __privateAdd(GlobalWorkerOptions, _port, null);
 __privateAdd(GlobalWorkerOptions, _src, "");
 
 // src/pdf.js/src/display/metadata.js
-var _metadataMap, _data;
+var _map, _data;
 var Metadata = class {
   constructor({ parsedData, rawData }) {
-    __privateAdd(this, _metadataMap);
+    __privateAdd(this, _map);
     __privateAdd(this, _data);
-    __privateSet(this, _metadataMap, parsedData);
+    __privateSet(this, _map, parsedData);
     __privateSet(this, _data, rawData);
   }
   getRaw() {
     return __privateGet(this, _data);
   }
   get(name) {
-    return __privateGet(this, _metadataMap).get(name) ?? null;
-  }
-  getAll() {
-    return objectFromMap(__privateGet(this, _metadataMap));
+    return __privateGet(this, _map).get(name) ?? null;
   }
-  has(name) {
-    return __privateGet(this, _metadataMap).has(name);
+  [Symbol.iterator]() {
+    return __privateGet(this, _map).entries();
   }
 };
-_metadataMap = new WeakMap();
+_map = new WeakMap();
 _data = new WeakMap();
 
 // src/pdf.js/src/display/optional_content_config.js
@@ -9908,9 +10429,6 @@ var OptionalContentConfig = class {
     }
     return [...__privateGet(this, _groups).keys()];
   }
-  getGroups() {
-    return __privateGet(this, _groups).size > 0 ? objectFromMap(__privateGet(this, _groups)) : null;
-  }
   getGroup(id) {
     return __privateGet(this, _groups).get(id) || null;
   }
@@ -9924,6 +10442,9 @@ var OptionalContentConfig = class {
     }
     return __privateSet(this, _cachedGetHash, hash.hexdigest());
   }
+  [Symbol.iterator]() {
+    return __privateGet(this, _groups).entries();
+  }
 };
 _cachedGetHash = new WeakMap();
 _groups = new WeakMap();
@@ -11224,6 +11745,102 @@ var PDFNodeStreamFsRangeReader = class {
   }
 };
 
+// src/pdf.js/src/display/pdf_objects.js
+var INITIAL_DATA = Symbol("INITIAL_DATA");
+var _objs, _PDFObjects_instances, ensureObj_fn;
+var PDFObjects = class {
+  constructor() {
+    __privateAdd(this, _PDFObjects_instances);
+    __privateAdd(this, _objs, /* @__PURE__ */ Object.create(null));
+  }
+  /**
+   * If called *without* callback, this returns the data of `objId` but the
+   * object needs to be resolved. If it isn't, this method throws.
+   *
+   * If called *with* a callback, the callback is called with the data of the
+   * object once the object is resolved. That means, if you call this method
+   * and the object is already resolved, the callback gets called right away.
+   *
+   * @param {string} objId
+   * @param {function} [callback]
+   * @returns {any}
+   */
+  get(objId, callback = null) {
+    if (callback) {
+      const obj2 = __privateMethod(this, _PDFObjects_instances, ensureObj_fn).call(this, objId);
+      obj2.promise.then(() => callback(obj2.data));
+      return null;
+    }
+    const obj = __privateGet(this, _objs)[objId];
+    if (!obj || obj.data === INITIAL_DATA) {
+      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
+    }
+    return obj.data;
+  }
+  /**
+   * @param {string} objId
+   * @returns {boolean}
+   */
+  has(objId) {
+    const obj = __privateGet(this, _objs)[objId];
+    return !!obj && obj.data !== INITIAL_DATA;
+  }
+  /**
+   * @param {string} objId
+   * @returns {boolean}
+   */
+  delete(objId) {
+    const obj = __privateGet(this, _objs)[objId];
+    if (!obj || obj.data === INITIAL_DATA) {
+      return false;
+    }
+    delete __privateGet(this, _objs)[objId];
+    return true;
+  }
+  /**
+   * Resolves the object `objId` with optional `data`.
+   *
+   * @param {string} objId
+   * @param {any} [data]
+   */
+  resolve(objId, data = null) {
+    const obj = __privateMethod(this, _PDFObjects_instances, ensureObj_fn).call(this, objId);
+    obj.data = data;
+    obj.resolve();
+  }
+  clear() {
+    for (const objId in __privateGet(this, _objs)) {
+      const { data } = __privateGet(this, _objs)[objId];
+      data?.bitmap?.close();
+    }
+    __privateSet(this, _objs, /* @__PURE__ */ Object.create(null));
+  }
+  *[Symbol.iterator]() {
+    for (const objId in __privateGet(this, _objs)) {
+      const { data } = __privateGet(this, _objs)[objId];
+      if (data === INITIAL_DATA) {
+        continue;
+      }
+      yield [objId, data];
+    }
+  }
+};
+_objs = new WeakMap();
+_PDFObjects_instances = new WeakSet();
+/**
+ * Ensures there is an object defined for `objId`.
+ *
+ * @param {string} objId
+ * @returns {Object}
+ */
+ensureObj_fn = function(objId) {
+  var _a2;
+  return (_a2 = __privateGet(this, _objs))[objId] || (_a2[objId] = {
+    ...Promise.withResolvers(),
+    data: INITIAL_DATA
+  });
+};
+
 // src/pdf.js/src/display/text_layer.js
 var MAX_TEXT_DIVS_TO_RENDER = 1e5;
 var DEFAULT_FONT_SIZE = 30;
@@ -11699,7 +12316,6 @@ var XfaText = class _XfaText {
 };
 
 // src/pdf.js/src/display/api.js
-var DEFAULT_RANGE_CHUNK_SIZE = 65536;
 var RENDERING_CANCELLED_TIMEOUT = 100;
 function getDocument(src = {}) {
   if (true) {
@@ -11717,7 +12333,7 @@ function getDocument(src = {}) {
   const withCredentials = src.withCredentials === true;
   const password = src.password ?? null;
   const rangeTransport = src.range instanceof PDFDataRangeTransport ? src.range : null;
-  const rangeChunkSize = Number.isInteger(src.rangeChunkSize) && src.rangeChunkSize > 0 ? src.rangeChunkSize : DEFAULT_RANGE_CHUNK_SIZE;
+  const rangeChunkSize = Number.isInteger(src.rangeChunkSize) && src.rangeChunkSize > 0 ? src.rangeChunkSize : 2 ** 16;
   let worker = src.worker instanceof PDFWorker ? src.worker : null;
   const verbosity = src.verbosity;
   const docBaseUrl = typeof src.docBaseUrl === "string" && !isDataScheme(src.docBaseUrl) ? src.docBaseUrl : null;
@@ -11749,8 +12365,8 @@ function getDocument(src = {}) {
   const disableStream = src.disableStream === true;
   const disableAutoFetch = src.disableAutoFetch === true;
   const pdfBug = src.pdfBug === true;
-  const CanvasFactory = src.CanvasFactory || (isNodeJS ? NodeCanvasFactory : DOMCanvasFactory);
-  const FilterFactory = src.FilterFactory || (isNodeJS ? NodeFilterFactory : DOMFilterFactory);
+  const CanvasFactory = src.CanvasFactory || (isNodeJS ? NodeCanvasFactory2 : DOMCanvasFactory);
+  const FilterFactory = src.FilterFactory || (isNodeJS ? NodeFilterFactory2 : DOMFilterFactory);
   const enableHWA = src.enableHWA === true;
   const useWasm = src.useWasm !== false;
   const length = rangeTransport ? rangeTransport.length : src.length ?? NaN;
@@ -11766,11 +12382,10 @@ function getDocument(src = {}) {
     wasmFactory: useWorkerFetch ? null : new WasmFactory2({ baseUrl: wasmUrl })
   };
   if (!worker) {
-    const workerParams = {
+    worker = PDFWorker.create({
       verbosity,
       port: GlobalWorkerOptions.workerPort
-    };
-    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
+    });
     task._worker = worker;
   }
   const docParams = {
@@ -11835,21 +12450,7 @@ function getDocument(src = {}) {
       if (!url) {
         throw new Error("getDocument - no `url` parameter provided.");
       }
-      let NetworkStream;
-      if (isNodeJS) {
-        if (isValidFetchUrl(url)) {
-          if (typeof fetch === "undefined" || typeof Response === "undefined" || !("body" in Response.prototype)) {
-            throw new Error(
-              "getDocument - the Fetch API was disabled in Node.js, see `--no-experimental-fetch`."
-            );
-          }
-          NetworkStream = PDFFetchStream;
-        } else {
-          NetworkStream = PDFNodeStream;
-        }
-      } else {
-        NetworkStream = isValidFetchUrl(url) ? PDFFetchStream : PDFNetworkStream;
-      }
+      const NetworkStream = isValidFetchUrl(url) ? PDFFetchStream : isNodeJS ? PDFNodeStream : PDFNetworkStream;
       networkStream = new NetworkStream({
         url,
         length,
@@ -11881,64 +12482,6 @@ function getDocument(src = {}) {
   }).catch(task._capability.reject);
   return task;
 }
-function getUrlProp(val) {
-  if (false) {
-    return null;
-  }
-  if (val instanceof URL) {
-    return val.href;
-  }
-  if (typeof val === "string") {
-    if (isNodeJS) {
-      return val;
-    }
-    const url = URL.parse(val, window.location);
-    if (url) {
-      return url.href;
-    }
-  }
-  throw new Error(
-    "Invalid PDF url data: either string or URL-object is expected in the url property."
-  );
-}
-function getDataProp(val) {
-  if (isNodeJS && typeof Buffer !== "undefined" && // eslint-disable-line no-undef
-  val instanceof Buffer) {
-    throw new Error(
-      "Please provide binary data as `Uint8Array`, rather than `Buffer`."
-    );
-  }
-  if (val instanceof Uint8Array && val.byteLength === val.buffer.byteLength) {
-    return val;
-  }
-  if (typeof val === "string") {
-    return stringToBytes(val);
-  }
-  if (val instanceof ArrayBuffer || ArrayBuffer.isView(val) || typeof val === "object" && !isNaN(val?.length)) {
-    return new Uint8Array(val);
-  }
-  throw new Error(
-    "Invalid PDF binary data: either TypedArray, string, or array-like object is expected in the data property."
-  );
-}
-function getFactoryUrlProp(val) {
-  if (typeof val !== "string") {
-    return null;
-  }
-  if (val.endsWith("/")) {
-    return val;
-  }
-  throw new Error(`Invalid factory url: "${val}" must include trailing slash.`);
-}
-var isRefProxy = (v) => typeof v === "object" && Number.isInteger(v?.num) && v.num >= 0 && Number.isInteger(v?.gen) && v.gen >= 0;
-var isNameProxy = (v) => typeof v === "object" && typeof v?.name === "string";
-var isValidExplicitDest = _isValidExplicitDest.bind(
-  null,
-  /* validRef = */
-  isRefProxy,
-  /* validName = */
-  isNameProxy
-);
 var _docId2;
 var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
   constructor() {
@@ -11993,20 +12536,16 @@ var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
    */
   async destroy() {
     this.destroyed = true;
-    if (false) {
+    try {
+      if (this._worker?.port) {
+        this._worker._pendingDestroy = true;
+      }
       await this._transport?.destroy();
-    } else {
-      try {
-        if (this._worker?.port) {
-          this._worker._pendingDestroy = true;
-        }
-        await this._transport?.destroy();
-      } catch (ex) {
-        if (this._worker?.port) {
-          delete this._worker._pendingDestroy;
-        }
-        throw ex;
+    } catch (ex) {
+      if (this._worker?.port) {
+        delete this._worker._pendingDestroy;
       }
+      throw ex;
     }
     this._transport = null;
     this._worker?.destroy();
@@ -12025,6 +12564,7 @@ var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
 _docId2 = new WeakMap();
 __privateAdd(_PDFDocumentLoadingTask, _docId2, 0);
 var PDFDocumentLoadingTask = _PDFDocumentLoadingTask;
+var _capability2, _progressiveDoneListeners, _progressiveReadListeners, _progressListeners, _rangeListeners;
 var PDFDataRangeTransport = class {
   /**
    * @param {number} length
@@ -12033,46 +12573,46 @@ var PDFDataRangeTransport = class {
    * @param {string} [contentDispositionFilename]
    */
   constructor(length, initialData, progressiveDone = false, contentDispositionFilename = null) {
+    __privateAdd(this, _capability2, Promise.withResolvers());
+    __privateAdd(this, _progressiveDoneListeners, []);
+    __privateAdd(this, _progressiveReadListeners, []);
+    __privateAdd(this, _progressListeners, []);
+    __privateAdd(this, _rangeListeners, []);
     this.length = length;
     this.initialData = initialData;
     this.progressiveDone = progressiveDone;
     this.contentDispositionFilename = contentDispositionFilename;
-    this._rangeListeners = [];
-    this._progressListeners = [];
-    this._progressiveReadListeners = [];
-    this._progressiveDoneListeners = [];
-    this._readyCapability = Promise.withResolvers();
   }
   /**
    * @param {function} listener
    */
   addRangeListener(listener) {
-    this._rangeListeners.push(listener);
+    __privateGet(this, _rangeListeners).push(listener);
   }
   /**
    * @param {function} listener
    */
   addProgressListener(listener) {
-    this._progressListeners.push(listener);
+    __privateGet(this, _progressListeners).push(listener);
   }
   /**
    * @param {function} listener
    */
   addProgressiveReadListener(listener) {
-    this._progressiveReadListeners.push(listener);
+    __privateGet(this, _progressiveReadListeners).push(listener);
   }
   /**
    * @param {function} listener
    */
   addProgressiveDoneListener(listener) {
-    this._progressiveDoneListeners.push(listener);
+    __privateGet(this, _progressiveDoneListeners).push(listener);
   }
   /**
    * @param {number} begin
    * @param {Uint8Array|null} chunk
    */
   onDataRange(begin, chunk) {
-    for (const listener of this._rangeListeners) {
+    for (const listener of __privateGet(this, _rangeListeners)) {
       listener(begin, chunk);
     }
   }
@@ -12081,8 +12621,8 @@ var PDFDataRangeTransport = class {
    * @param {number|undefined} total
    */
   onDataProgress(loaded, total) {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressListeners) {
+    __privateGet(this, _capability2).promise.then(() => {
+      for (const listener of __privateGet(this, _progressListeners)) {
         listener(loaded, total);
       }
     });
@@ -12091,21 +12631,21 @@ var PDFDataRangeTransport = class {
    * @param {Uint8Array|null} chunk
    */
   onDataProgressiveRead(chunk) {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressiveReadListeners) {
+    __privateGet(this, _capability2).promise.then(() => {
+      for (const listener of __privateGet(this, _progressiveReadListeners)) {
         listener(chunk);
       }
     });
   }
   onDataProgressiveDone() {
-    this._readyCapability.promise.then(() => {
-      for (const listener of this._progressiveDoneListeners) {
+    __privateGet(this, _capability2).promise.then(() => {
+      for (const listener of __privateGet(this, _progressiveDoneListeners)) {
         listener();
       }
     });
   }
   transportReady() {
-    this._readyCapability.resolve();
+    __privateGet(this, _capability2).resolve();
   }
   /**
    * @param {number} begin
@@ -12117,6 +12657,11 @@ var PDFDataRangeTransport = class {
   abort() {
   }
 };
+_capability2 = new WeakMap();
+_progressiveDoneListeners = new WeakMap();
+_progressiveReadListeners = new WeakMap();
+_progressListeners = new WeakMap();
+_rangeListeners = new WeakMap();
 var PDFDocumentProxy = class {
   constructor(pdfInfo, transport) {
     this._pdfInfo = pdfInfo;
@@ -12992,51 +13537,7 @@ tryCleanup_fn = function() {
   __privateSet(this, _pendingCleanup, false);
   return true;
 };
-var _listeners, _deferred;
-var LoopbackPort = class {
-  constructor() {
-    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
-    __privateAdd(this, _deferred, Promise.resolve());
-  }
-  postMessage(obj, transfer) {
-    const event = {
-      data: structuredClone(obj, transfer ? { transfer } : null)
-    };
-    __privateGet(this, _deferred).then(() => {
-      for (const [listener] of __privateGet(this, _listeners)) {
-        listener.call(this, event);
-      }
-    });
-  }
-  addEventListener(name, listener, options = null) {
-    let rmAbort = null;
-    if (options?.signal instanceof AbortSignal) {
-      const { signal } = options;
-      if (signal.aborted) {
-        warn("LoopbackPort - cannot use an `aborted` signal.");
-        return;
-      }
-      const onAbort = () => this.removeEventListener(name, listener);
-      rmAbort = () => signal.removeEventListener("abort", onAbort);
-      signal.addEventListener("abort", onAbort);
-    }
-    __privateGet(this, _listeners).set(listener, rmAbort);
-  }
-  removeEventListener(name, listener) {
-    const rmAbort = __privateGet(this, _listeners).get(listener);
-    rmAbort?.();
-    __privateGet(this, _listeners).delete(listener);
-  }
-  terminate() {
-    for (const [, rmAbort] of __privateGet(this, _listeners)) {
-      rmAbort?.();
-    }
-    __privateGet(this, _listeners).clear();
-  }
-};
-_listeners = new WeakMap();
-_deferred = new WeakMap();
-var _a, _fakeWorkerId, _isWorkerDisabled, _workerPorts, _PDFWorker_instances, resolve_fn, _PDFWorker_static, mainThreadWorkerMessageHandler_get;
+var _a, _capability3, _messageHandler, _port2, _webWorker, _fakeWorkerId, _isWorkerDisabled, _workerPorts, _PDFWorker_instances, resolve_fn, initializeFromPort_fn, initialize_fn, setupFakeWorker_fn, _PDFWorker_static, mainThreadWorkerMessageHandler_get;
 var _PDFWorker = class _PDFWorker {
   constructor({
     name = null,
@@ -13044,173 +13545,73 @@ var _PDFWorker = class _PDFWorker {
     verbosity = getVerbosityLevel()
   } = {}) {
     __privateAdd(this, _PDFWorker_instances);
+    __privateAdd(this, _capability3, Promise.withResolvers());
+    __privateAdd(this, _messageHandler, null);
+    __privateAdd(this, _port2, null);
+    __privateAdd(this, _webWorker, null);
     this.name = name;
     this.destroyed = false;
     this.verbosity = verbosity;
-    this._readyCapability = Promise.withResolvers();
-    this._port = null;
-    this._webWorker = null;
-    this._messageHandler = null;
     if (port) {
-      if (__privateGet(_PDFWorker, _workerPorts)?.has(port)) {
+      if (__privateGet(_PDFWorker, _workerPorts).has(port)) {
         throw new Error("Cannot use more than one PDFWorker per port.");
       }
-      (__privateGet(_PDFWorker, _workerPorts) || __privateSet(_PDFWorker, _workerPorts, /* @__PURE__ */ new WeakMap())).set(port, this);
-      this._initializeFromPort(port);
-      return;
+      __privateGet(_PDFWorker, _workerPorts).set(port, this);
+      __privateMethod(this, _PDFWorker_instances, initializeFromPort_fn).call(this, port);
+    } else {
+      __privateMethod(this, _PDFWorker_instances, initialize_fn).call(this);
+    }
+    if (false) {
+      Object.defineProperty(this, "_webWorker", {
+        get() {
+          return __privateGet(this, _webWorker);
+        }
+      });
     }
-    this._initialize();
   }
   /**
    * Promise for worker initialization completion.
    * @type {Promise<void>}
    */
   get promise() {
-    return this._readyCapability.promise;
+    return __privateGet(this, _capability3).promise;
   }
   /**
    * The current `workerPort`, when it exists.
    * @type {Worker}
    */
   get port() {
-    return this._port;
+    return __privateGet(this, _port2);
   }
   /**
    * The current MessageHandler-instance.
    * @type {MessageHandler}
    */
   get messageHandler() {
-    return this._messageHandler;
-  }
-  _initializeFromPort(port) {
-    if (false) {
-      throw new Error("Not implemented: _initializeFromPort");
-    }
-    this._port = port;
-    this._messageHandler = new MessageHandler("main", "worker", port);
-    this._messageHandler.on("ready", function() {
-    });
-    __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
-  }
-  _initialize() {
-    if (__privateGet(_PDFWorker, _isWorkerDisabled) || __privateGet(_PDFWorker, _PDFWorker_static, mainThreadWorkerMessageHandler_get)) {
-      this._setupFakeWorker();
-      return;
-    }
-    let { workerSrc } = _PDFWorker;
-    try {
-      if (!_PDFWorker._isSameOrigin(window.location, workerSrc)) {
-        workerSrc = _PDFWorker._createCDNWrapper(
-          new URL(workerSrc, window.location).href
-        );
-      }
-      const worker = new Worker(workerSrc, { type: "module" });
-      const messageHandler = new MessageHandler("main", "worker", worker);
-      const terminateEarly = () => {
-        ac.abort();
-        messageHandler.destroy();
-        worker.terminate();
-        if (this.destroyed) {
-          this._readyCapability.reject(new Error("Worker was destroyed"));
-        } else {
-          this._setupFakeWorker();
-        }
-      };
-      const ac = new AbortController();
-      worker.addEventListener(
-        "error",
-        () => {
-          if (!this._webWorker) {
-            terminateEarly();
-          }
-        },
-        { signal: ac.signal }
-      );
-      messageHandler.on("test", (data) => {
-        ac.abort();
-        if (this.destroyed || !data) {
-          terminateEarly();
-          return;
-        }
-        this._messageHandler = messageHandler;
-        this._port = worker;
-        this._webWorker = worker;
-        __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
-      });
-      messageHandler.on("ready", (data) => {
-        ac.abort();
-        if (this.destroyed) {
-          terminateEarly();
-          return;
-        }
-        try {
-          sendTest();
-        } catch {
-          this._setupFakeWorker();
-        }
-      });
-      const sendTest = () => {
-        const testObj = new Uint8Array();
-        messageHandler.send("test", testObj, [testObj.buffer]);
-      };
-      sendTest();
-      return;
-    } catch {
-      info("The worker has been disabled.");
-    }
-    this._setupFakeWorker();
-  }
-  _setupFakeWorker() {
-    if (!__privateGet(_PDFWorker, _isWorkerDisabled)) {
-      warn("Setting up fake worker.");
-      __privateSet(_PDFWorker, _isWorkerDisabled, true);
-    }
-    _PDFWorker._setupFakeWorkerGlobal.then((WorkerMessageHandler) => {
-      if (this.destroyed) {
-        this._readyCapability.reject(new Error("Worker was destroyed"));
-        return;
-      }
-      const port = new LoopbackPort();
-      this._port = port;
-      const id = `fake${__privateWrapper(_PDFWorker, _fakeWorkerId)._++}`;
-      const workerHandler = new MessageHandler(id + "_worker", id, port);
-      WorkerMessageHandler.setup(workerHandler, port);
-      this._messageHandler = new MessageHandler(id, id + "_worker", port);
-      __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
-    }).catch((reason) => {
-      this._readyCapability.reject(
-        new Error(`Setting up fake worker failed: "${reason.message}".`)
-      );
-    });
+    return __privateGet(this, _messageHandler);
   }
   /**
    * Destroys the worker instance.
    */
   destroy() {
     this.destroyed = true;
-    this._webWorker?.terminate();
-    this._webWorker = null;
-    __privateGet(_PDFWorker, _workerPorts)?.delete(this._port);
-    this._port = null;
-    this._messageHandler?.destroy();
-    this._messageHandler = null;
+    __privateGet(this, _webWorker)?.terminate();
+    __privateSet(this, _webWorker, null);
+    __privateGet(_PDFWorker, _workerPorts).delete(__privateGet(this, _port2));
+    __privateSet(this, _port2, null);
+    __privateGet(this, _messageHandler)?.destroy();
+    __privateSet(this, _messageHandler, null);
   }
   /**
    * @param {PDFWorkerParameters} params - The worker initialization parameters.
    * @returns {PDFWorker}
    */
-  static fromPort(params) {
-    if (false) {
-      throw new Error("Not implemented: fromPort");
-    }
-    if (!params?.port) {
-      throw new Error("PDFWorker.fromPort - invalid method signature.");
-    }
-    const cachedPort = __privateGet(this, _workerPorts)?.get(params.port);
+  static create(params) {
+    const cachedPort = __privateGet(this, _workerPorts).get(params?.port);
     if (cachedPort) {
       if (cachedPort._pendingDestroy) {
         throw new Error(
-          "PDFWorker.fromPort - the worker is being destroyed.\nPlease remember to await `PDFDocumentLoadingTask.destroy()`-calls."
+          "PDFWorker.create - the worker is being destroyed.\nPlease remember to await `PDFDocumentLoadingTask.destroy()`-calls."
         );
       }
       return cachedPort;
@@ -13233,20 +13634,122 @@ var _PDFWorker = class _PDFWorker {
       if (__privateGet(this, _PDFWorker_static, mainThreadWorkerMessageHandler_get)) {
         return __privateGet(this, _PDFWorker_static, mainThreadWorkerMessageHandler_get);
       }
-      const worker = true ? await import("./worker.js") : await __raw_import__(this.workerSrc);
-      return worker.WorkerMessageHandler;
+      const worker = true ? await import("./worker.js") : await __raw_import__(this.workerSrc);
+      return worker.WorkerMessageHandler;
+    };
+    return shadow(this, "_setupFakeWorkerGlobal", loader());
+  }
+};
+_capability3 = new WeakMap();
+_messageHandler = new WeakMap();
+_port2 = new WeakMap();
+_webWorker = new WeakMap();
+_fakeWorkerId = new WeakMap();
+_isWorkerDisabled = new WeakMap();
+_workerPorts = new WeakMap();
+_PDFWorker_instances = new WeakSet();
+resolve_fn = function() {
+  __privateGet(this, _capability3).resolve();
+  __privateGet(this, _messageHandler).send("configure", {
+    verbosity: this.verbosity
+  });
+};
+initializeFromPort_fn = function(port) {
+  __privateSet(this, _port2, port);
+  __privateSet(this, _messageHandler, new MessageHandler("main", "worker", port));
+  __privateGet(this, _messageHandler).on("ready", () => {
+  });
+  __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
+};
+initialize_fn = function() {
+  if (__privateGet(_PDFWorker, _isWorkerDisabled) || __privateGet(_PDFWorker, _PDFWorker_static, mainThreadWorkerMessageHandler_get)) {
+    __privateMethod(this, _PDFWorker_instances, setupFakeWorker_fn).call(this);
+    return;
+  }
+  let { workerSrc } = _PDFWorker;
+  try {
+    if (!_PDFWorker._isSameOrigin(window.location, workerSrc)) {
+      workerSrc = _PDFWorker._createCDNWrapper(
+        new URL(workerSrc, window.location).href
+      );
+    }
+    const worker = new Worker(workerSrc, { type: "module" });
+    const messageHandler = new MessageHandler("main", "worker", worker);
+    const terminateEarly = () => {
+      ac.abort();
+      messageHandler.destroy();
+      worker.terminate();
+      if (this.destroyed) {
+        __privateGet(this, _capability3).reject(new Error("Worker was destroyed"));
+      } else {
+        __privateMethod(this, _PDFWorker_instances, setupFakeWorker_fn).call(this);
+      }
+    };
+    const ac = new AbortController();
+    worker.addEventListener(
+      "error",
+      () => {
+        if (!__privateGet(this, _webWorker)) {
+          terminateEarly();
+        }
+      },
+      { signal: ac.signal }
+    );
+    messageHandler.on("test", (data) => {
+      ac.abort();
+      if (this.destroyed || !data) {
+        terminateEarly();
+        return;
+      }
+      __privateSet(this, _messageHandler, messageHandler);
+      __privateSet(this, _port2, worker);
+      __privateSet(this, _webWorker, worker);
+      __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
+    });
+    messageHandler.on("ready", (data) => {
+      ac.abort();
+      if (this.destroyed) {
+        terminateEarly();
+        return;
+      }
+      try {
+        sendTest();
+      } catch {
+        __privateMethod(this, _PDFWorker_instances, setupFakeWorker_fn).call(this);
+      }
+    });
+    const sendTest = () => {
+      const testObj = new Uint8Array();
+      messageHandler.send("test", testObj, [testObj.buffer]);
     };
-    return shadow(this, "_setupFakeWorkerGlobal", loader());
+    sendTest();
+    return;
+  } catch {
+    info("The worker has been disabled.");
   }
+  __privateMethod(this, _PDFWorker_instances, setupFakeWorker_fn).call(this);
 };
-_fakeWorkerId = new WeakMap();
-_isWorkerDisabled = new WeakMap();
-_workerPorts = new WeakMap();
-_PDFWorker_instances = new WeakSet();
-resolve_fn = function() {
-  this._readyCapability.resolve();
-  this._messageHandler.send("configure", {
-    verbosity: this.verbosity
+setupFakeWorker_fn = function() {
+  if (!__privateGet(_PDFWorker, _isWorkerDisabled)) {
+    warn("Setting up fake worker.");
+    __privateSet(_PDFWorker, _isWorkerDisabled, true);
+  }
+  _PDFWorker._setupFakeWorkerGlobal.then((WorkerMessageHandler) => {
+    if (this.destroyed) {
+      __privateGet(this, _capability3).reject(new Error("Worker was destroyed"));
+      return;
+    }
+    const port = new LoopbackPort();
+    __privateSet(this, _port2, port);
+    const id = `fake${__privateWrapper(_PDFWorker, _fakeWorkerId)._++}`;
+    const workerHandler = new MessageHandler(id + "_worker", id, port);
+    WorkerMessageHandler.setup(workerHandler, port);
+    __privateSet(this, _messageHandler, new MessageHandler(id, id + "_worker", port));
+    __privateMethod(this, _PDFWorker_instances, resolve_fn).call(this);
+  }).catch((reason) => {
+    __privateGet(this, _capability3).reject(
+      new Error(`Setting up fake worker failed: "${reason.message}".`)
+    );
   });
 };
 _PDFWorker_static = new WeakSet();
@@ -13260,7 +13763,7 @@ mainThreadWorkerMessageHandler_get = function() {
 __privateAdd(_PDFWorker, _PDFWorker_static);
 __privateAdd(_PDFWorker, _fakeWorkerId, 0);
 __privateAdd(_PDFWorker, _isWorkerDisabled, false);
-__privateAdd(_PDFWorker, _workerPorts);
+__privateAdd(_PDFWorker, _workerPorts, /* @__PURE__ */ new WeakMap());
 (() => {
   if (true) {
     if (isNodeJS) {
@@ -13281,6 +13784,21 @@ __privateAdd(_PDFWorker, _workerPorts);
         new Blob([wrapper], { type: "text/javascript" })
       );
     };
+    _PDFWorker.fromPort = (params) => {
+      deprecated(
+        "`PDFWorker.fromPort` - please use `PDFWorker.create` instead."
+      );
+      if (!params?.port) {
+        throw new Error("PDFWorker.fromPort - invalid method signature.");
+      }
+      return _PDFWorker.create(params);
+    };
+  }
+  if (false) {
+    _PDFWorker._resetGlobalState = () => {
+      __privateSet(_PDFWorker, _isWorkerDisabled, false);
+      delete globalThis.pdfjsWorker;
+    };
   }
 })();
 var PDFWorker = _PDFWorker;
@@ -13846,100 +14364,6 @@ cacheSimpleMethod_fn = function(name, data = null) {
   __privateGet(this, _methodPromises).set(name, promise);
   return promise;
 };
-var INITIAL_DATA = Symbol("INITIAL_DATA");
-var _objs, _PDFObjects_instances, ensureObj_fn;
-var PDFObjects = class {
-  constructor() {
-    __privateAdd(this, _PDFObjects_instances);
-    __privateAdd(this, _objs, /* @__PURE__ */ Object.create(null));
-  }
-  /**
-   * If called *without* callback, this returns the data of `objId` but the
-   * object needs to be resolved. If it isn't, this method throws.
-   *
-   * If called *with* a callback, the callback is called with the data of the
-   * object once the object is resolved. That means, if you call this method
-   * and the object is already resolved, the callback gets called right away.
-   *
-   * @param {string} objId
-   * @param {function} [callback]
-   * @returns {any}
-   */
-  get(objId, callback = null) {
-    if (callback) {
-      const obj2 = __privateMethod(this, _PDFObjects_instances, ensureObj_fn).call(this, objId);
-      obj2.promise.then(() => callback(obj2.data));
-      return null;
-    }
-    const obj = __privateGet(this, _objs)[objId];
-    if (!obj || obj.data === INITIAL_DATA) {
-      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
-    }
-    return obj.data;
-  }
-  /**
-   * @param {string} objId
-   * @returns {boolean}
-   */
-  has(objId) {
-    const obj = __privateGet(this, _objs)[objId];
-    return !!obj && obj.data !== INITIAL_DATA;
-  }
-  /**
-   * @param {string} objId
-   * @returns {boolean}
-   */
-  delete(objId) {
-    const obj = __privateGet(this, _objs)[objId];
-    if (!obj || obj.data === INITIAL_DATA) {
-      return false;
-    }
-    delete __privateGet(this, _objs)[objId];
-    return true;
-  }
-  /**
-   * Resolves the object `objId` with optional `data`.
-   *
-   * @param {string} objId
-   * @param {any} [data]
-   */
-  resolve(objId, data = null) {
-    const obj = __privateMethod(this, _PDFObjects_instances, ensureObj_fn).call(this, objId);
-    obj.data = data;
-    obj.resolve();
-  }
-  clear() {
-    for (const objId in __privateGet(this, _objs)) {
-      const { data } = __privateGet(this, _objs)[objId];
-      data?.bitmap?.close();
-    }
-    __privateSet(this, _objs, /* @__PURE__ */ Object.create(null));
-  }
-  *[Symbol.iterator]() {
-    for (const objId in __privateGet(this, _objs)) {
-      const { data } = __privateGet(this, _objs)[objId];
-      if (data === INITIAL_DATA) {
-        continue;
-      }
-      yield [objId, data];
-    }
-  }
-};
-_objs = new WeakMap();
-_PDFObjects_instances = new WeakSet();
-/**
- * Ensures there is an object defined for `objId`.
- *
- * @param {string} objId
- * @returns {Object}
- */
-ensureObj_fn = function(objId) {
-  var _a2;
-  return (_a2 = __privateGet(this, _objs))[objId] || (_a2[objId] = {
-    ...Promise.withResolvers(),
-    data: INITIAL_DATA
-  });
-};
 var _internalRenderTask;
 var RenderTask = class {
   constructor(internalRenderTask) {
@@ -17455,12 +17879,9 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
   }
   /** @inheritdoc */
   enableEditMode() {
-    if (this.isInEditMode()) {
-      return;
+    if (!super.enableEditMode()) {
+      return false;
     }
-    this.parent.setEditingState(false);
-    this.parent.updateToolbar(AnnotationEditorType.FREETEXT);
-    super.enableEditMode();
     this.overlayDiv.classList.remove("enabled");
     this.editorDiv.contentEditable = true;
     this._isDraggable = false;
@@ -17490,14 +17911,13 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     this.editorDiv.addEventListener("paste", this.editorDivPaste.bind(this), {
       signal
     });
+    return true;
   }
   /** @inheritdoc */
   disableEditMode() {
-    if (!this.isInEditMode()) {
-      return;
+    if (!super.disableEditMode()) {
+      return false;
     }
-    this.parent.setEditingState(true);
-    super.disableEditMode();
     this.overlayDiv.classList.add("enabled");
     this.editorDiv.contentEditable = false;
     this.div.setAttribute("aria-activedescendant", __privateGet(this, _editorDivId));
@@ -17509,6 +17929,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     });
     this.isEditing = false;
     this.parent.div.classList.add("freetextEditing");
+    return true;
   }
   /** @inheritdoc */
   focusin(event) {
@@ -17592,17 +18013,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     this.enableEditMode();
     this.editorDiv.focus();
   }
-  /**
-   * ondblclick callback.
-   * @param {MouseEvent} event
-   */
-  dblclick(event) {
-    this.enterInEditMode();
-  }
-  /**
-   * onkeydown callback.
-   * @param {KeyboardEvent} event
-   */
+  /** @inheritdoc */
   keydown(event) {
     if (event.target === this.div && event.key === "Enter") {
       this.enterInEditMode();
@@ -17632,6 +18043,10 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     this.editorDiv.setAttribute("aria-multiline", true);
   }
   /** @inheritdoc */
+  get canChangeContent() {
+    return true;
+  }
+  /** @inheritdoc */
   render() {
     if (this.div) {
       return this.div;
@@ -17656,7 +18071,6 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     this.overlayDiv = document.createElement("div");
     this.overlayDiv.classList.add("overlay", "enabled");
     this.div.append(this.overlayDiv);
-    bindEvents(this, this.div, ["dblclick", "keydown"]);
     if (this._isCopy || this.annotationElementId) {
       const [parentWidth, parentHeight] = this.parentDimensions;
       if (this.annotationElementId) {
@@ -22487,14 +22901,8 @@ getGrayPixels_fn = function(bitmap) {
     const isteps = Math.floor(steps);
     steps = steps === isteps ? isteps - 1 : isteps;
     for (let i = 0; i < steps; i++) {
-      newWidth = prevWidth;
-      newHeight = prevHeight;
-      if (newWidth > maxDim) {
-        newWidth = Math.ceil(newWidth / 2);
-      }
-      if (newHeight > maxDim) {
-        newHeight = Math.ceil(newHeight / 2);
-      }
+      newWidth = Math.ceil(prevWidth / 2);
+      newHeight = Math.ceil(prevHeight / 2);
       const offscreen2 = new OffscreenCanvas(newWidth, newHeight);
       const ctx2 = offscreen2.getContext("2d");
       ctx2.drawImage(
@@ -22568,7 +22976,7 @@ var SignatureOptions = class _SignatureOptions extends DrawingOptions {
   constructor() {
     super();
     super.updateProperties({
-      fill: "CanvasText",
+      fill: AnnotationEditor._defaultLineColor,
       "stroke-width": 0
     });
   }
@@ -22582,7 +22990,7 @@ var DrawnSignatureOptions = class _DrawnSignatureOptions extends InkDrawingOptio
   constructor(viewerParameters) {
     super(viewerParameters);
     super.updateProperties({
-      stroke: "CanvasText",
+      stroke: AnnotationEditor._defaultLineColor,
       "stroke-width": 1
     });
   }
@@ -22955,9 +23363,10 @@ var StampEditor = class extends AnnotationEditor {
   }
   /** @inheritdoc */
   static paste(item, parent) {
-    parent.pasteEditor(AnnotationEditorType.STAMP, {
-      bitmapFile: item.getAsFile()
-    });
+    parent.pasteEditor(
+      { mode: AnnotationEditorType.STAMP },
+      { bitmapFile: item.getAsFile() }
+    );
   }
   /** @inheritdoc */
   altTextFinish() {
@@ -23722,10 +24131,10 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
   }
   /**
    * Update the toolbar if it's required to reflect the tool currently used.
-   * @param {number} mode
+   * @param {Object} options
    */
-  updateToolbar(mode) {
-    __privateGet(this, _uiManager3).updateToolbar(mode);
+  updateToolbar(options) {
+    __privateGet(this, _uiManager3).updateToolbar(options);
   }
   /**
    * The mode has changed: it must be updated.
@@ -24084,12 +24493,12 @@ var _AnnotationEditorLayer = class _AnnotationEditorLayer {
   }
   /**
    * Paste some content into a new editor.
-   * @param {number} mode
+   * @param {Object} options
    * @param {Object} params
    */
-  async pasteEditor(mode, params) {
-    __privateGet(this, _uiManager3).updateToolbar(mode);
-    await __privateGet(this, _uiManager3).updateMode(mode);
+  async pasteEditor(options, params) {
+    this.updateToolbar(options);
+    await __privateGet(this, _uiManager3).updateMode(options.mode);
     const { offsetX, offsetY } = __privateMethod(this, _AnnotationEditorLayer_instances, getCenterPoint_fn).call(this);
     const id = this.getNextId();
     const editor = __privateMethod(this, _AnnotationEditorLayer_instances, createNewEditor_fn).call(this, {
@@ -24665,10 +25074,63 @@ var DrawLayer = _DrawLayer;
 
 // src/pdf.js/src/pdf.js
 if (false) {
-  globalThis.pdfjsTestingUtils = {
+  globalThis._pdfjsTestingUtils = {
     HighlightOutliner
   };
 }
+globalThis.pdfjsLib = {
+  AbortException,
+  AnnotationEditorLayer,
+  AnnotationEditorParamsType,
+  AnnotationEditorType,
+  AnnotationEditorUIManager,
+  AnnotationLayer,
+  AnnotationMode,
+  AnnotationType,
+  build,
+  ColorPicker,
+  createValidAbsoluteUrl,
+  DOMSVGFactory,
+  DrawLayer,
+  FeatureTest,
+  fetchData,
+  getDocument,
+  getFilenameFromUrl,
+  getPdfFilenameFromUrl,
+  getUuid,
+  getXfaPageViewport,
+  GlobalWorkerOptions,
+  ImageKind,
+  InvalidPDFException,
+  isDataScheme,
+  isPdfFile,
+  isValidExplicitDest,
+  MathClamp,
+  noContextMenu,
+  normalizeUnicode,
+  OPS,
+  OutputScale,
+  PasswordResponses,
+  PDFDataRangeTransport,
+  PDFDateString,
+  PDFWorker,
+  PermissionFlag,
+  PixelsPerInch,
+  RenderingCancelledException,
+  ResponseException,
+  setLayerDimensions,
+  shadow,
+  SignatureExtractor,
+  stopEvent,
+  SupportedImageMimeTypes,
+  TextLayer,
+  TouchManager,
+  updateUrlHash,
+  Util,
+  VerbosityLevel,
+  version,
+  XfaLayer
+};
 
 // src/lib/AnnotationOperatorsList.ts
 var AnnotationOperatorsList = class {
@@ -25621,53 +26083,6 @@ async function toSvgNode(ctx) {
   return ctx.getNode();
 }
 
-// src/lib/utils.ts
-async function canvasToData(canvas) {
-  if ("toBlob" in canvas) {
-    const blob = await new Promise(
-      (resolve) => canvas.toBlob((data) => resolve(data))
-    );
-    if (!blob) {
-      throw new Error("Failed to generate graphics");
-    }
-    return new Uint8Array(await blob.arrayBuffer());
-  }
-  const buffer = await canvas.encode("png");
-  return new Uint8Array(buffer);
-}
-async function toDataUrl(data, type = "image/png") {
-  if (typeof FileReader !== "undefined") {
-    return new Promise((resolve) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        resolve(reader.result);
-      };
-      reader.readAsDataURL(new Blob([data], { type }));
-    });
-  }
-  return `data:${type};base64,${Buffer.from(data).toString("base64")}`;
-}
-function makeSerializable(object) {
-  if (typeof object !== "object" || object === null) {
-    return object;
-  }
-  if (object instanceof Int8Array || object instanceof Uint8Array || object instanceof Uint8ClampedArray || object instanceof Int16Array || object instanceof Uint16Array || object instanceof Int32Array || object instanceof Uint32Array || object instanceof Float32Array || object instanceof Float64Array) {
-    return makeSerializable(Array.from(object));
-  }
-  if (object instanceof BigInt64Array || object instanceof BigUint64Array) {
-    return makeSerializable(Array.from(object));
-  }
-  if (Array.isArray(object)) {
-    return object.map(makeSerializable);
-  }
-  return Object.fromEntries(
-    Object.entries(object).map(([key, value]) => [
-      key,
-      makeSerializable(value)
-    ])
-  );
-}
-
 // src/lib/PDFPageProxy.ts
 var getAnnotations = PDFPageProxy.prototype.getAnnotations;
 PDFPageProxy.prototype.getAnnotations = async function(params) {
@@ -25792,10 +26207,18 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
                 annotation.borderStyle.width = currentLineWidth;
               }
               if (fn === OPS.setStrokeRGBColor && firstStroke) {
-                annotation.color = args;
+                if (typeof args[0] === "string") {
+                  annotation.color = colorToRgb(args[0]);
+                } else {
+                  annotation.color = args;
+                }
               }
               if (fn === OPS.setFillRGBColor && firstFill) {
-                currentFillColor = args;
+                if (typeof args[0] === "string") {
+                  currentFillColor = colorToRgb(args[0]);
+                } else {
+                  currentFillColor = args;
+                }
               }
               if (fn === OPS.setGState) {
                 for (const entry of args[0]) {
@@ -25838,11 +26261,11 @@ var WasmFactory = class {
   async fetch({ filename }) {
     switch (filename) {
       case "openjpeg.wasm":
-        return import("./openjpeg-O3KQE6R6.js").then(
+        return import("./openjpeg-B2WN24QZ.js").then(
           (module) => module.default
         );
       case "qcms_bg":
-        return import("./qcms_bg-5Z325MLG.js").then(
+        return import("./qcms_bg-T4RSHPOQ.js").then(
           (module) => module.default
         );
     }
@@ -26508,6 +26931,7 @@ export {
   XfaLayer,
   build,
   canvasToData,
+  colorToRgb,
   createCanvas,
   createSvgContext,
   createTextLayer,
@@ -26559,10 +26983,12 @@ export {
   makeSerializable,
   noContextMenu,
   normalizeUnicode,
+  rgbToHex,
   setLayerDimensions,
   shadow,
   stopEvent,
   toDataUrl,
   toSvgNode,
+  updateUrlHash,
   version
 };