@chialab/pdfjs-lib 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/browser/index.js

@@ -1,43 +1,3 @@
-import {
-  ColorConverters,
-  MessageHandler,
-  MurmurHash3_64,
-  convertBlackAndWhiteToRGBA,
-  wrapReason
-} from "./chunk-5IWODJWD.js";
-import {
-  DOMCanvasFactory,
-  DOMFilterFactory,
-  OutputScale,
-  PDFDateString,
-  PageViewport,
-  PixelsPerInch,
-  RenderingCancelledException,
-  SVG_NS,
-  StatTimer,
-  SupportedImageMimeTypes,
-  canvasToData,
-  colorToRgb,
-  deprecated,
-  fetchData,
-  getColorValues,
-  getCurrentTransform,
-  getCurrentTransformInverse,
-  getFilenameFromUrl,
-  getPdfFilenameFromUrl,
-  getRGB,
-  getXfaPageViewport,
-  isDataScheme,
-  isPdfFile,
-  isValidFetchUrl,
-  makeSerializable,
-  noContextMenu,
-  parseRgbaColor,
-  rgbToHex,
-  setLayerDimensions,
-  stopEvent,
-  toDataUrl
-} from "./chunk-ELOUEWKT.js";
 import {
   AbortException,
   AnnotationBorderStyleType,
@@ -47,6 +7,8 @@ import {
   AnnotationMode,
   AnnotationPrefix,
   AnnotationType,
+  BaseException,
+  ColorConverters,
   DrawOPS,
   FONT_IDENTITY_MATRIX,
   FeatureTest,
@@ -55,6 +17,8 @@ import {
   InvalidPDFException,
   LINE_FACTOR,
   MathClamp,
+  MessageHandler,
+  MurmurHash3_64,
   OPS,
   PasswordResponses,
   PermissionFlag,
@@ -65,6 +29,7 @@ import {
   VerbosityLevel,
   _isValidExplicitDest,
   assert,
+  convertBlackAndWhiteToRGBA,
   createValidAbsoluteUrl,
   fromBase64Util,
   getUuid,
@@ -79,8 +44,16 @@ import {
   toBase64Util,
   unreachable,
   updateUrlHash,
-  warn
-} from "./chunk-NJUB3B5A.js";
+  warn,
+  wrapReason
+} from "./chunk-W3YEFTNG.js";
+import {
+  NodeCMapReaderFactory,
+  NodeCanvasFactory,
+  NodeFilterFactory,
+  NodeStandardFontDataFactory,
+  NodeWasmFactory
+} from "./chunk-3ZTAZS2X.js";
 import {
   __privateAdd,
   __privateGet,
@@ -90,6 +63,569 @@ import {
   __publicField
 } from "./chunk-O4UKW7AD.js";
 
+// src/pdf.js/src/display/display_utils.js
+var SVG_NS = "http://www.w3.org/2000/svg";
+var _PixelsPerInch = class _PixelsPerInch {
+};
+__publicField(_PixelsPerInch, "CSS", 96);
+__publicField(_PixelsPerInch, "PDF", 72);
+__publicField(_PixelsPerInch, "PDF_TO_CSS_UNITS", _PixelsPerInch.CSS / _PixelsPerInch.PDF);
+var PixelsPerInch = _PixelsPerInch;
+async function fetchData(url, type = "text") {
+  if (isValidFetchUrl(url, document.baseURI)) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    switch (type) {
+      case "arraybuffer":
+        return response.arrayBuffer();
+      case "blob":
+        return response.blob();
+      case "json":
+        return response.json();
+    }
+    return response.text();
+  }
+  return new Promise((resolve, reject) => {
+    const request = new XMLHttpRequest();
+    request.open(
+      "GET",
+      url,
+      /* async = */
+      true
+    );
+    request.responseType = type;
+    request.onreadystatechange = () => {
+      if (request.readyState !== XMLHttpRequest.DONE) {
+        return;
+      }
+      if (request.status === 200 || request.status === 0) {
+        switch (type) {
+          case "arraybuffer":
+          case "blob":
+          case "json":
+            resolve(request.response);
+            return;
+        }
+        resolve(request.responseText);
+        return;
+      }
+      reject(new Error(request.statusText));
+    };
+    request.send(null);
+  });
+}
+var PageViewport = class _PageViewport {
+  /**
+   * @param {PageViewportParameters}
+   */
+  constructor({
+    viewBox,
+    userUnit,
+    scale,
+    rotation,
+    offsetX = 0,
+    offsetY = 0,
+    dontFlip = false
+  }) {
+    this.viewBox = viewBox;
+    this.userUnit = userUnit;
+    this.scale = scale;
+    this.rotation = rotation;
+    this.offsetX = offsetX;
+    this.offsetY = offsetY;
+    scale *= userUnit;
+    const centerX = (viewBox[2] + viewBox[0]) / 2;
+    const centerY = (viewBox[3] + viewBox[1]) / 2;
+    let rotateA, rotateB, rotateC, rotateD;
+    rotation %= 360;
+    if (rotation < 0) {
+      rotation += 360;
+    }
+    switch (rotation) {
+      case 180:
+        rotateA = -1;
+        rotateB = 0;
+        rotateC = 0;
+        rotateD = 1;
+        break;
+      case 90:
+        rotateA = 0;
+        rotateB = 1;
+        rotateC = 1;
+        rotateD = 0;
+        break;
+      case 270:
+        rotateA = 0;
+        rotateB = -1;
+        rotateC = -1;
+        rotateD = 0;
+        break;
+      case 0:
+        rotateA = 1;
+        rotateB = 0;
+        rotateC = 0;
+        rotateD = -1;
+        break;
+      default:
+        throw new Error(
+          "PageViewport: Invalid rotation, must be a multiple of 90 degrees."
+        );
+    }
+    if (dontFlip) {
+      rotateC = -rotateC;
+      rotateD = -rotateD;
+    }
+    let offsetCanvasX, offsetCanvasY;
+    let width, height;
+    if (rotateA === 0) {
+      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
+      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
+      width = (viewBox[3] - viewBox[1]) * scale;
+      height = (viewBox[2] - viewBox[0]) * scale;
+    } else {
+      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
+      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
+      width = (viewBox[2] - viewBox[0]) * scale;
+      height = (viewBox[3] - viewBox[1]) * scale;
+    }
+    this.transform = [
+      rotateA * scale,
+      rotateB * scale,
+      rotateC * scale,
+      rotateD * scale,
+      offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,
+      offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY
+    ];
+    this.width = width;
+    this.height = height;
+  }
+  /**
+   * The original, un-scaled, viewport dimensions.
+   * @type {Object}
+   */
+  get rawDims() {
+    const dims = this.viewBox;
+    return shadow(this, "rawDims", {
+      pageWidth: dims[2] - dims[0],
+      pageHeight: dims[3] - dims[1],
+      pageX: dims[0],
+      pageY: dims[1]
+    });
+  }
+  /**
+   * Clones viewport, with optional additional properties.
+   * @param {PageViewportCloneParameters} [params]
+   * @returns {PageViewport} Cloned viewport.
+   */
+  clone({
+    scale = this.scale,
+    rotation = this.rotation,
+    offsetX = this.offsetX,
+    offsetY = this.offsetY,
+    dontFlip = false
+  } = {}) {
+    return new _PageViewport({
+      viewBox: this.viewBox.slice(),
+      userUnit: this.userUnit,
+      scale,
+      rotation,
+      offsetX,
+      offsetY,
+      dontFlip
+    });
+  }
+  /**
+   * Converts PDF point to the viewport coordinates. For examples, useful for
+   * converting PDF location into canvas pixel coordinates.
+   * @param {number} x - The x-coordinate.
+   * @param {number} y - The y-coordinate.
+   * @returns {Array} Array containing `x`- and `y`-coordinates of the
+   *   point in the viewport coordinate space.
+   * @see {@link convertToPdfPoint}
+   * @see {@link convertToViewportRectangle}
+   */
+  convertToViewportPoint(x, y) {
+    const p = [x, y];
+    Util.applyTransform(p, this.transform);
+    return p;
+  }
+  /**
+   * Converts PDF rectangle to the viewport coordinates.
+   * @param {Array} rect - The xMin, yMin, xMax and yMax coordinates.
+   * @returns {Array} Array containing corresponding coordinates of the
+   *   rectangle in the viewport coordinate space.
+   * @see {@link convertToViewportPoint}
+   */
+  convertToViewportRectangle(rect) {
+    const topLeft = [rect[0], rect[1]];
+    Util.applyTransform(topLeft, this.transform);
+    const bottomRight = [rect[2], rect[3]];
+    Util.applyTransform(bottomRight, this.transform);
+    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
+  }
+  /**
+   * Converts viewport coordinates to the PDF location. For examples, useful
+   * for converting canvas pixel location into PDF one.
+   * @param {number} x - The x-coordinate.
+   * @param {number} y - The y-coordinate.
+   * @returns {Array} Array containing `x`- and `y`-coordinates of the
+   *   point in the PDF coordinate space.
+   * @see {@link convertToViewportPoint}
+   */
+  convertToPdfPoint(x, y) {
+    const p = [x, y];
+    Util.applyInverseTransform(p, this.transform);
+    return p;
+  }
+};
+var RenderingCancelledException = class extends BaseException {
+  constructor(msg, extraDelay = 0) {
+    super(msg, "RenderingCancelledException");
+    this.extraDelay = extraDelay;
+  }
+};
+function isDataScheme(url) {
+  const ii = url.length;
+  let i = 0;
+  while (i < ii && url[i].trim() === "") {
+    i++;
+  }
+  return url.substring(i, i + 5).toLowerCase() === "data:";
+}
+function isPdfFile(filename) {
+  return typeof filename === "string" && /\.pdf$/i.test(filename);
+}
+function getFilenameFromUrl(url) {
+  [url] = url.split(/[#?]/, 1);
+  return url.substring(url.lastIndexOf("/") + 1);
+}
+function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
+  if (typeof url !== "string") {
+    return defaultFilename;
+  }
+  if (isDataScheme(url)) {
+    warn('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
+    return defaultFilename;
+  }
+  const getURL = (urlString) => {
+    try {
+      return new URL(urlString);
+    } catch {
+      try {
+        return new URL(decodeURIComponent(urlString));
+      } catch {
+        try {
+          return new URL(urlString, "https://foo.bar");
+        } catch {
+          try {
+            return new URL(decodeURIComponent(urlString), "https://foo.bar");
+          } catch {
+            return null;
+          }
+        }
+      }
+    }
+  };
+  const newURL = getURL(url);
+  if (!newURL) {
+    return defaultFilename;
+  }
+  const decode = (name) => {
+    try {
+      let decoded = decodeURIComponent(name);
+      if (decoded.includes("/")) {
+        decoded = decoded.split("/").at(-1);
+        if (decoded.test(/^\.pdf$/i)) {
+          return decoded;
+        }
+        return name;
+      }
+      return decoded;
+    } catch {
+      return name;
+    }
+  };
+  const pdfRegex = /\.pdf$/i;
+  const filename = newURL.pathname.split("/").at(-1);
+  if (pdfRegex.test(filename)) {
+    return decode(filename);
+  }
+  if (newURL.searchParams.size > 0) {
+    const values = Array.from(newURL.searchParams.values()).reverse();
+    for (const value of values) {
+      if (pdfRegex.test(value)) {
+        return decode(value);
+      }
+    }
+    const keys = Array.from(newURL.searchParams.keys()).reverse();
+    for (const key of keys) {
+      if (pdfRegex.test(key)) {
+        return decode(key);
+      }
+    }
+  }
+  if (newURL.hash) {
+    const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
+    const hashFilename = reFilename.exec(newURL.hash);
+    if (hashFilename) {
+      return decode(hashFilename[0]);
+    }
+  }
+  return defaultFilename;
+}
+var StatTimer = class {
+  constructor() {
+    __publicField(this, "started", /* @__PURE__ */ Object.create(null));
+    __publicField(this, "times", []);
+  }
+  time(name) {
+    if (name in this.started) {
+      warn(`Timer is already running for ${name}`);
+    }
+    this.started[name] = Date.now();
+  }
+  timeEnd(name) {
+    if (!(name in this.started)) {
+      warn(`Timer has not been started for ${name}`);
+    }
+    this.times.push({
+      name,
+      start: this.started[name],
+      end: Date.now()
+    });
+    delete this.started[name];
+  }
+  toString() {
+    const outBuf = [];
+    let longest = 0;
+    for (const { name } of this.times) {
+      longest = Math.max(name.length, longest);
+    }
+    for (const { name, start, end } of this.times) {
+      outBuf.push(`${name.padEnd(longest)} ${end - start}ms
+`);
+    }
+    return outBuf.join("");
+  }
+};
+function isValidFetchUrl(url, baseUrl) {
+  if (false) {
+    throw new Error("Not implemented: isValidFetchUrl");
+  }
+  const res = baseUrl ? URL.parse(url, baseUrl) : URL.parse(url);
+  return res?.protocol === "http:" || res?.protocol === "https:";
+}
+function noContextMenu(e) {
+  e.preventDefault();
+}
+function stopEvent(e) {
+  e.preventDefault();
+  e.stopPropagation();
+}
+function deprecated(details) {
+  console.log("Deprecated API usage: " + details);
+}
+var _regex;
+var PDFDateString = class {
+  /**
+   * Convert a PDF date string to a JavaScript `Date` object.
+   *
+   * The PDF date string format is described in section 7.9.4 of the official
+   * PDF 32000-1:2008 specification. However, in the PDF 1.7 reference (sixth
+   * edition) Adobe describes the same format including a trailing apostrophe.
+   * This syntax in incorrect, but Adobe Acrobat creates PDF files that contain
+   * them. We ignore all apostrophes as they are not necessary for date parsing.
+   *
+   * Moreover, Adobe Acrobat doesn't handle changing the date to universal time
+   * and doesn't use the user's time zone (effectively ignoring the HH' and mm'
+   * parts of the date string).
+   *
+   * @param {string} input
+   * @returns {Date|null}
+   */
+  static toDateObject(input) {
+    if (!input || typeof input !== "string") {
+      return null;
+    }
+    __privateGet(this, _regex) || __privateSet(this, _regex, new RegExp(
+      "^D:(\\d{4})(\\d{2})?(\\d{2})?(\\d{2})?(\\d{2})?(\\d{2})?([Z|+|-])?(\\d{2})?'?(\\d{2})?'?"
+      // Trailing apostrophe (optional)
+    ));
+    const matches = __privateGet(this, _regex).exec(input);
+    if (!matches) {
+      return null;
+    }
+    const year = parseInt(matches[1], 10);
+    let month = parseInt(matches[2], 10);
+    month = month >= 1 && month <= 12 ? month - 1 : 0;
+    let day = parseInt(matches[3], 10);
+    day = day >= 1 && day <= 31 ? day : 1;
+    let hour = parseInt(matches[4], 10);
+    hour = hour >= 0 && hour <= 23 ? hour : 0;
+    let minute = parseInt(matches[5], 10);
+    minute = minute >= 0 && minute <= 59 ? minute : 0;
+    let second = parseInt(matches[6], 10);
+    second = second >= 0 && second <= 59 ? second : 0;
+    const universalTimeRelation = matches[7] || "Z";
+    let offsetHour = parseInt(matches[8], 10);
+    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
+    let offsetMinute = parseInt(matches[9], 10) || 0;
+    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
+    if (universalTimeRelation === "-") {
+      hour += offsetHour;
+      minute += offsetMinute;
+    } else if (universalTimeRelation === "+") {
+      hour -= offsetHour;
+      minute -= offsetMinute;
+    }
+    return new Date(Date.UTC(year, month, day, hour, minute, second));
+  }
+};
+_regex = new WeakMap();
+__privateAdd(PDFDateString, _regex);
+function getXfaPageViewport(xfaPage, { scale = 1, rotation = 0 }) {
+  const { width, height } = xfaPage.attributes.style;
+  const viewBox = [0, 0, parseInt(width), parseInt(height)];
+  return new PageViewport({
+    viewBox,
+    userUnit: 1,
+    scale,
+    rotation
+  });
+}
+function getRGB(color) {
+  if (color.startsWith("#")) {
+    const colorRGB = parseInt(color.slice(1), 16);
+    return [
+      (colorRGB & 16711680) >> 16,
+      (colorRGB & 65280) >> 8,
+      colorRGB & 255
+    ];
+  }
+  if (color.startsWith("rgb(")) {
+    return color.slice(
+      /* "rgb(".length */
+      4,
+      -1
+    ).split(",").map((x) => parseInt(x));
+  }
+  if (color.startsWith("rgba(")) {
+    return color.slice(
+      /* "rgba(".length */
+      5,
+      -1
+    ).split(",").map((x) => parseInt(x)).slice(0, 3);
+  }
+  warn(`Not a valid color format: "${color}"`);
+  return [0, 0, 0];
+}
+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;
+    const computedColor = window.getComputedStyle(span).color;
+    colors.set(name, getRGB(computedColor));
+  }
+  span.remove();
+}
+function getCurrentTransform(ctx) {
+  const { a, b, c, d, e, f } = ctx.getTransform();
+  return [a, b, c, d, e, f];
+}
+function getCurrentTransformInverse(ctx) {
+  const { a, b, c, d, e, f } = ctx.getTransform().invertSelf();
+  return [a, b, c, d, e, f];
+}
+function setLayerDimensions(div, viewport, mustFlip = false, mustRotate = true) {
+  if (viewport instanceof PageViewport) {
+    const { pageWidth, pageHeight } = viewport.rawDims;
+    const { style } = div;
+    const useRound = FeatureTest.isCSSRoundSupported;
+    const w = `var(--total-scale-factor) * ${pageWidth}px`, h = `var(--total-scale-factor) * ${pageHeight}px`;
+    const widthStr = useRound ? `round(down, ${w}, var(--scale-round-x))` : `calc(${w})`, heightStr = useRound ? `round(down, ${h}, var(--scale-round-y))` : `calc(${h})`;
+    if (!mustFlip || viewport.rotation % 180 === 0) {
+      style.width = widthStr;
+      style.height = heightStr;
+    } else {
+      style.width = heightStr;
+      style.height = widthStr;
+    }
+  }
+  if (mustRotate) {
+    div.setAttribute("data-main-rotation", viewport.rotation);
+  }
+}
+var OutputScale = class _OutputScale {
+  constructor() {
+    const { pixelRatio } = _OutputScale;
+    this.sx = pixelRatio;
+    this.sy = pixelRatio;
+  }
+  /**
+   * @type {boolean} Returns `true` when scaling is required, `false` otherwise.
+   */
+  get scaled() {
+    return this.sx !== 1 || this.sy !== 1;
+  }
+  /**
+   * @type {boolean} Returns `true` when scaling is symmetric,
+   *   `false` otherwise.
+   */
+  get symmetric() {
+    return this.sx === this.sy;
+  }
+  /**
+   * @returns {boolean} Returns `true` if scaling was limited,
+   *   `false` otherwise.
+   */
+  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));
+    }
+    if (maxDim !== -1) {
+      maxWidthScale = maxDim / width;
+      maxHeightScale = maxDim / height;
+    }
+    const maxScale = Math.min(maxAreaScale, maxWidthScale, maxHeightScale);
+    if (this.sx > maxScale || this.sy > maxScale) {
+      this.sx = maxScale;
+      this.sy = maxScale;
+      return true;
+    }
+    return false;
+  }
+  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",
+  "image/avif",
+  "image/bmp",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp",
+  "image/x-icon"
+];
+
 // src/pdf.js/src/display/editor/toolbar.js
 var _toolbar, _colorPicker, _editor, _buttons, _altText, _signatureDescriptionButton, _l10nRemove, _EditorToolbar_static, pointerDown_fn, _EditorToolbar_instances, focusIn_fn, focusOut_fn, addListenersToElement_fn, divider_get;
 var _EditorToolbar = class _EditorToolbar {
@@ -5790,18 +6326,6 @@ var LoopbackPort = class {
 _listeners = new WeakMap();
 _deferred = new WeakMap();
 
-// src/lib/NodeUtilsStabs.ts
-var NodeCanvasFactory = class {
-};
-var NodeCMapReaderFactory = class {
-};
-var NodeStandardFontDataFactory = class {
-};
-var NodeFilterFactory = class {
-};
-var NodeWasmFactory = class {
-};
-
 // src/pdf.js/src/display/pattern_helper.js
 var PathType = {
   FILL: "Fill",
@@ -8702,6 +9226,71 @@ for (const op in OPS) {
   }
 }
 
+// src/pdf.js/src/display/canvas_factory.js
+var _enableHWA;
+var BaseCanvasFactory = class {
+  constructor({ enableHWA = false }) {
+    __privateAdd(this, _enableHWA, false);
+    if (false) {
+      unreachable("Cannot initialize BaseCanvasFactory.");
+    }
+    __privateSet(this, _enableHWA, enableHWA);
+  }
+  create(width, height) {
+    if (width <= 0 || height <= 0) {
+      throw new Error("Invalid canvas size");
+    }
+    const canvas = this._createCanvas(width, height);
+    return {
+      canvas,
+      context: canvas.getContext("2d", {
+        willReadFrequently: !__privateGet(this, _enableHWA)
+      })
+    };
+  }
+  reset(canvasAndContext, width, height) {
+    if (!canvasAndContext.canvas) {
+      throw new Error("Canvas is not specified");
+    }
+    if (width <= 0 || height <= 0) {
+      throw new Error("Invalid canvas size");
+    }
+    canvasAndContext.canvas.width = width;
+    canvasAndContext.canvas.height = height;
+  }
+  destroy(canvasAndContext) {
+    if (!canvasAndContext.canvas) {
+      throw new Error("Canvas is not specified");
+    }
+    canvasAndContext.canvas.width = 0;
+    canvasAndContext.canvas.height = 0;
+    canvasAndContext.canvas = null;
+    canvasAndContext.context = null;
+  }
+  /**
+   * @ignore
+   */
+  _createCanvas(width, height) {
+    unreachable("Abstract method `_createCanvas` called.");
+  }
+};
+_enableHWA = new WeakMap();
+var DOMCanvasFactory = class extends BaseCanvasFactory {
+  constructor({ ownerDocument = globalThis.document, enableHWA = false }) {
+    super({ enableHWA });
+    this._document = ownerDocument;
+  }
+  /**
+   * @ignore
+   */
+  _createCanvas(width, height) {
+    const canvas = this._document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+  }
+};
+
 // src/pdf.js/src/display/cmap_reader_factory.js
 var BaseCMapReaderFactory = class {
   constructor({ baseUrl = null, isCompressed = true }) {
@@ -8749,6 +9338,380 @@ var DOMCMapReaderFactory = class extends BaseCMapReaderFactory {
   }
 };
 
+// src/pdf.js/src/display/filter_factory.js
+var BaseFilterFactory = class {
+  constructor() {
+    if (false) {
+      unreachable("Cannot initialize BaseFilterFactory.");
+    }
+  }
+  addFilter(maps) {
+    return "none";
+  }
+  addHCMFilter(fgColor, bgColor) {
+    return "none";
+  }
+  addAlphaFilter(map) {
+    return "none";
+  }
+  addLuminosityFilter(map) {
+    return "none";
+  }
+  addHighlightHCMFilter(filterName, fgColor, bgColor, newFgColor, newBgColor) {
+    return "none";
+  }
+  destroy(keepHCM = false) {
+  }
+};
+var _baseUrl, __cache, __defs, _docId, _document, __hcmCache, _id3, _DOMFilterFactory_instances, cache_get, hcmCache_get, defs_get, createTables_fn, createUrl_fn, addLuminosityConversion_fn, addGrayConversion_fn, createFilter_fn, appendFeFunc_fn, addTransferMapConversion_fn, addTransferMapAlphaConversion_fn, getRGB_fn;
+var DOMFilterFactory = class extends BaseFilterFactory {
+  constructor({ docId, ownerDocument = globalThis.document }) {
+    super();
+    __privateAdd(this, _DOMFilterFactory_instances);
+    __privateAdd(this, _baseUrl);
+    __privateAdd(this, __cache);
+    __privateAdd(this, __defs);
+    __privateAdd(this, _docId);
+    __privateAdd(this, _document);
+    __privateAdd(this, __hcmCache);
+    __privateAdd(this, _id3, 0);
+    __privateSet(this, _docId, docId);
+    __privateSet(this, _document, ownerDocument);
+  }
+  addFilter(maps) {
+    if (!maps) {
+      return "none";
+    }
+    let value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(maps);
+    if (value) {
+      return value;
+    }
+    const [tableR, tableG, tableB] = __privateMethod(this, _DOMFilterFactory_instances, createTables_fn).call(this, maps);
+    const key = maps.length === 1 ? tableR : `${tableR}${tableG}${tableB}`;
+    value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(key);
+    if (value) {
+      __privateGet(this, _DOMFilterFactory_instances, cache_get).set(maps, value);
+      return value;
+    }
+    const id2 = `g_${__privateGet(this, _docId)}_transfer_map_${__privateWrapper(this, _id3)._++}`;
+    const url = __privateMethod(this, _DOMFilterFactory_instances, createUrl_fn).call(this, id2);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(maps, url);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(key, url);
+    const filter = __privateMethod(this, _DOMFilterFactory_instances, createFilter_fn).call(this, id2);
+    __privateMethod(this, _DOMFilterFactory_instances, addTransferMapConversion_fn).call(this, tableR, tableG, tableB, filter);
+    return url;
+  }
+  addHCMFilter(fgColor, bgColor) {
+    const key = `${fgColor}-${bgColor}`;
+    const filterName = "base";
+    let info2 = __privateGet(this, _DOMFilterFactory_instances, hcmCache_get).get(filterName);
+    if (info2?.key === key) {
+      return info2.url;
+    }
+    if (info2) {
+      info2.filter?.remove();
+      info2.key = key;
+      info2.url = "none";
+      info2.filter = null;
+    } else {
+      info2 = {
+        key,
+        url: "none",
+        filter: null
+      };
+      __privateGet(this, _DOMFilterFactory_instances, hcmCache_get).set(filterName, info2);
+    }
+    if (!fgColor || !bgColor) {
+      return info2.url;
+    }
+    const fgRGB = __privateMethod(this, _DOMFilterFactory_instances, getRGB_fn).call(this, fgColor);
+    fgColor = Util.makeHexColor(...fgRGB);
+    const bgRGB = __privateMethod(this, _DOMFilterFactory_instances, getRGB_fn).call(this, bgColor);
+    bgColor = Util.makeHexColor(...bgRGB);
+    __privateGet(this, _DOMFilterFactory_instances, defs_get).style.color = "";
+    if (fgColor === "#000000" && bgColor === "#ffffff" || fgColor === bgColor) {
+      return info2.url;
+    }
+    const map = new Array(256);
+    for (let i = 0; i <= 255; i++) {
+      const x = i / 255;
+      map[i] = x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+    }
+    const table = map.join(",");
+    const id2 = `g_${__privateGet(this, _docId)}_hcm_filter`;
+    const filter = info2.filter = __privateMethod(this, _DOMFilterFactory_instances, createFilter_fn).call(this, id2);
+    __privateMethod(this, _DOMFilterFactory_instances, addTransferMapConversion_fn).call(this, table, table, table, filter);
+    __privateMethod(this, _DOMFilterFactory_instances, addGrayConversion_fn).call(this, filter);
+    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.join(",");
+    };
+    __privateMethod(this, _DOMFilterFactory_instances, addTransferMapConversion_fn).call(this, getSteps(0, 5), getSteps(1, 5), getSteps(2, 5), filter);
+    info2.url = __privateMethod(this, _DOMFilterFactory_instances, createUrl_fn).call(this, id2);
+    return info2.url;
+  }
+  addAlphaFilter(map) {
+    let value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(map);
+    if (value) {
+      return value;
+    }
+    const [tableA] = __privateMethod(this, _DOMFilterFactory_instances, createTables_fn).call(this, [map]);
+    const key = `alpha_${tableA}`;
+    value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(key);
+    if (value) {
+      __privateGet(this, _DOMFilterFactory_instances, cache_get).set(map, value);
+      return value;
+    }
+    const id2 = `g_${__privateGet(this, _docId)}_alpha_map_${__privateWrapper(this, _id3)._++}`;
+    const url = __privateMethod(this, _DOMFilterFactory_instances, createUrl_fn).call(this, id2);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(map, url);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(key, url);
+    const filter = __privateMethod(this, _DOMFilterFactory_instances, createFilter_fn).call(this, id2);
+    __privateMethod(this, _DOMFilterFactory_instances, addTransferMapAlphaConversion_fn).call(this, tableA, filter);
+    return url;
+  }
+  addLuminosityFilter(map) {
+    let value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(map || "luminosity");
+    if (value) {
+      return value;
+    }
+    let tableA, key;
+    if (map) {
+      [tableA] = __privateMethod(this, _DOMFilterFactory_instances, createTables_fn).call(this, [map]);
+      key = `luminosity_${tableA}`;
+    } else {
+      key = "luminosity";
+    }
+    value = __privateGet(this, _DOMFilterFactory_instances, cache_get).get(key);
+    if (value) {
+      __privateGet(this, _DOMFilterFactory_instances, cache_get).set(map, value);
+      return value;
+    }
+    const id2 = `g_${__privateGet(this, _docId)}_luminosity_map_${__privateWrapper(this, _id3)._++}`;
+    const url = __privateMethod(this, _DOMFilterFactory_instances, createUrl_fn).call(this, id2);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(map, url);
+    __privateGet(this, _DOMFilterFactory_instances, cache_get).set(key, url);
+    const filter = __privateMethod(this, _DOMFilterFactory_instances, createFilter_fn).call(this, id2);
+    __privateMethod(this, _DOMFilterFactory_instances, addLuminosityConversion_fn).call(this, filter);
+    if (map) {
+      __privateMethod(this, _DOMFilterFactory_instances, addTransferMapAlphaConversion_fn).call(this, tableA, filter);
+    }
+    return url;
+  }
+  addHighlightHCMFilter(filterName, fgColor, bgColor, newFgColor, newBgColor) {
+    const key = `${fgColor}-${bgColor}-${newFgColor}-${newBgColor}`;
+    let info2 = __privateGet(this, _DOMFilterFactory_instances, hcmCache_get).get(filterName);
+    if (info2?.key === key) {
+      return info2.url;
+    }
+    if (info2) {
+      info2.filter?.remove();
+      info2.key = key;
+      info2.url = "none";
+      info2.filter = null;
+    } else {
+      info2 = {
+        key,
+        url: "none",
+        filter: null
+      };
+      __privateGet(this, _DOMFilterFactory_instances, hcmCache_get).set(filterName, info2);
+    }
+    if (!fgColor || !bgColor) {
+      return info2.url;
+    }
+    const [fgRGB, bgRGB] = [fgColor, bgColor].map(__privateMethod(this, _DOMFilterFactory_instances, getRGB_fn).bind(this));
+    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]
+    );
+    let [newFgRGB, newBgRGB] = [newFgColor, newBgColor].map(
+      __privateMethod(this, _DOMFilterFactory_instances, getRGB_fn).bind(this)
+    );
+    if (bgGray < fgGray) {
+      [fgGray, bgGray, newFgRGB, newBgRGB] = [
+        bgGray,
+        fgGray,
+        newBgRGB,
+        newFgRGB
+      ];
+    }
+    __privateGet(this, _DOMFilterFactory_instances, defs_get).style.color = "";
+    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.join(",");
+    };
+    const id2 = `g_${__privateGet(this, _docId)}_hcm_${filterName}_filter`;
+    const filter = info2.filter = __privateMethod(this, _DOMFilterFactory_instances, createFilter_fn).call(this, id2);
+    __privateMethod(this, _DOMFilterFactory_instances, addGrayConversion_fn).call(this, filter);
+    __privateMethod(this, _DOMFilterFactory_instances, addTransferMapConversion_fn).call(this, getSteps(newFgRGB[0], newBgRGB[0], 5), getSteps(newFgRGB[1], newBgRGB[1], 5), getSteps(newFgRGB[2], newBgRGB[2], 5), filter);
+    info2.url = __privateMethod(this, _DOMFilterFactory_instances, createUrl_fn).call(this, id2);
+    return info2.url;
+  }
+  destroy(keepHCM = false) {
+    if (keepHCM && __privateGet(this, __hcmCache)?.size) {
+      return;
+    }
+    __privateGet(this, __defs)?.parentNode.parentNode.remove();
+    __privateSet(this, __defs, null);
+    __privateGet(this, __cache)?.clear();
+    __privateSet(this, __cache, null);
+    __privateGet(this, __hcmCache)?.clear();
+    __privateSet(this, __hcmCache, null);
+    __privateSet(this, _id3, 0);
+  }
+};
+_baseUrl = new WeakMap();
+__cache = new WeakMap();
+__defs = new WeakMap();
+_docId = new WeakMap();
+_document = new WeakMap();
+__hcmCache = new WeakMap();
+_id3 = new WeakMap();
+_DOMFilterFactory_instances = new WeakSet();
+cache_get = function() {
+  return __privateGet(this, __cache) || __privateSet(this, __cache, /* @__PURE__ */ new Map());
+};
+hcmCache_get = function() {
+  return __privateGet(this, __hcmCache) || __privateSet(this, __hcmCache, /* @__PURE__ */ new Map());
+};
+defs_get = function() {
+  if (!__privateGet(this, __defs)) {
+    const div = __privateGet(this, _document).createElement("div");
+    const { style } = div;
+    style.visibility = "hidden";
+    style.contain = "strict";
+    style.width = style.height = 0;
+    style.position = "absolute";
+    style.top = style.left = 0;
+    style.zIndex = -1;
+    const svg = __privateGet(this, _document).createElementNS(SVG_NS, "svg");
+    svg.setAttribute("width", 0);
+    svg.setAttribute("height", 0);
+    __privateSet(this, __defs, __privateGet(this, _document).createElementNS(SVG_NS, "defs"));
+    div.append(svg);
+    svg.append(__privateGet(this, __defs));
+    __privateGet(this, _document).body.append(div);
+  }
+  return __privateGet(this, __defs);
+};
+createTables_fn = function(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;
+    }
+    const table = buffer.join(",");
+    return [table, table, table];
+  }
+  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.join(","), bufferG.join(","), bufferB.join(",")];
+};
+createUrl_fn = function(id2) {
+  if (__privateGet(this, _baseUrl) === void 0) {
+    __privateSet(this, _baseUrl, "");
+    const url = __privateGet(this, _document).URL;
+    if (url !== __privateGet(this, _document).baseURI) {
+      if (isDataScheme(url)) {
+        warn('#createUrl: ignore "data:"-URL for performance reasons.');
+      } else {
+        __privateSet(this, _baseUrl, updateUrlHash(url, ""));
+      }
+    }
+  }
+  return `url(${__privateGet(this, _baseUrl)}#${id2})`;
+};
+addLuminosityConversion_fn = function(filter) {
+  const feColorMatrix = __privateGet(this, _document).createElementNS(
+    SVG_NS,
+    "feColorMatrix"
+  );
+  feColorMatrix.setAttribute("type", "matrix");
+  feColorMatrix.setAttribute(
+    "values",
+    "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.3 0.59 0.11 0 0"
+  );
+  filter.append(feColorMatrix);
+};
+addGrayConversion_fn = function(filter) {
+  const feColorMatrix = __privateGet(this, _document).createElementNS(
+    SVG_NS,
+    "feColorMatrix"
+  );
+  feColorMatrix.setAttribute("type", "matrix");
+  feColorMatrix.setAttribute(
+    "values",
+    "0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0 0 0 1 0"
+  );
+  filter.append(feColorMatrix);
+};
+createFilter_fn = function(id2) {
+  const filter = __privateGet(this, _document).createElementNS(SVG_NS, "filter");
+  filter.setAttribute("color-interpolation-filters", "sRGB");
+  filter.setAttribute("id", id2);
+  __privateGet(this, _DOMFilterFactory_instances, defs_get).append(filter);
+  return filter;
+};
+appendFeFunc_fn = function(feComponentTransfer, func, table) {
+  const feFunc = __privateGet(this, _document).createElementNS(SVG_NS, func);
+  feFunc.setAttribute("type", "discrete");
+  feFunc.setAttribute("tableValues", table);
+  feComponentTransfer.append(feFunc);
+};
+addTransferMapConversion_fn = function(rTable, gTable, bTable, filter) {
+  const feComponentTransfer = __privateGet(this, _document).createElementNS(
+    SVG_NS,
+    "feComponentTransfer"
+  );
+  filter.append(feComponentTransfer);
+  __privateMethod(this, _DOMFilterFactory_instances, appendFeFunc_fn).call(this, feComponentTransfer, "feFuncR", rTable);
+  __privateMethod(this, _DOMFilterFactory_instances, appendFeFunc_fn).call(this, feComponentTransfer, "feFuncG", gTable);
+  __privateMethod(this, _DOMFilterFactory_instances, appendFeFunc_fn).call(this, feComponentTransfer, "feFuncB", bTable);
+};
+addTransferMapAlphaConversion_fn = function(aTable, filter) {
+  const feComponentTransfer = __privateGet(this, _document).createElementNS(
+    SVG_NS,
+    "feComponentTransfer"
+  );
+  filter.append(feComponentTransfer);
+  __privateMethod(this, _DOMFilterFactory_instances, appendFeFunc_fn).call(this, feComponentTransfer, "feFuncA", aTable);
+};
+getRGB_fn = function(color) {
+  __privateGet(this, _DOMFilterFactory_instances, defs_get).style.color = color;
+  return getRGB(getComputedStyle(__privateGet(this, _DOMFilterFactory_instances, defs_get)).getPropertyValue("color"));
+};
+
 // src/pdf.js/src/display/standard_fontdata_factory.js
 var BaseStandardFontDataFactory = class {
   constructor({ baseUrl = null }) {
@@ -10947,7 +11910,7 @@ function getDocument(src = {}) {
   }).catch(task._capability.reject);
   return task;
 }
-var _docId;
+var _docId2;
 var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
   constructor() {
     /**
@@ -10966,7 +11929,7 @@ var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
      * Unique identifier for the document loading task.
      * @type {string}
      */
-    __publicField(this, "docId", `d${__privateWrapper(_PDFDocumentLoadingTask, _docId)._++}`);
+    __publicField(this, "docId", `d${__privateWrapper(_PDFDocumentLoadingTask, _docId2)._++}`);
     /**
      * Whether the loading task is destroyed or not.
      * @type {boolean}
@@ -11026,8 +11989,8 @@ var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
     return this._transport.getData();
   }
 };
-_docId = new WeakMap();
-__privateAdd(_PDFDocumentLoadingTask, _docId, 0);
+_docId2 = new WeakMap();
+__privateAdd(_PDFDocumentLoadingTask, _docId2, 0);
 var PDFDocumentLoadingTask = _PDFDocumentLoadingTask;
 var _capability2, _progressiveDoneListeners, _progressiveReadListeners, _progressListeners, _rangeListeners;
 var PDFDataRangeTransport = class {
@@ -18055,7 +19018,7 @@ __privateAdd(_ColorPicker, _l10nColor, null);
 var ColorPicker = _ColorPicker;
 
 // src/pdf.js/src/display/editor/highlight.js
-var _anchorNode, _anchorOffset, _boxes, _clipPathId, _colorPicker2, _focusOutlines, _focusNode, _focusOffset, _highlightDiv, _highlightOutlines, _id3, _isFreeHighlight, _lastPoint2, _opacity, _outlineId, _text, _thickness2, _methodOfCreation, _HighlightEditor_instances, createOutlines_fn, createFreeOutlines_fn, updateColor_fn2, updateThickness_fn, changeThickness_fn, cleanDrawLayer_fn, addToDrawLayer_fn, _HighlightEditor_static, rotateBbox_fn, keydown_fn, setCaret_fn, getRotation_fn, serializeBoxes_fn, serializeOutlines_fn, highlightMove_fn, endHighlight_fn, hasElementChanged_fn2;
+var _anchorNode, _anchorOffset, _boxes, _clipPathId, _colorPicker2, _focusOutlines, _focusNode, _focusOffset, _highlightDiv, _highlightOutlines, _id4, _isFreeHighlight, _lastPoint2, _opacity, _outlineId, _text, _thickness2, _methodOfCreation, _HighlightEditor_instances, createOutlines_fn, createFreeOutlines_fn, updateColor_fn2, updateThickness_fn, changeThickness_fn, cleanDrawLayer_fn, addToDrawLayer_fn, _HighlightEditor_static, rotateBbox_fn, keydown_fn, setCaret_fn, getRotation_fn, serializeBoxes_fn, serializeOutlines_fn, highlightMove_fn, endHighlight_fn, hasElementChanged_fn2;
 var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
   constructor(params) {
     super({ ...params, name: "highlightEditor" });
@@ -18070,7 +19033,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     __privateAdd(this, _focusOffset, 0);
     __privateAdd(this, _highlightDiv, null);
     __privateAdd(this, _highlightOutlines, null);
-    __privateAdd(this, _id3, null);
+    __privateAdd(this, _id4, null);
     __privateAdd(this, _isFreeHighlight, false);
     __privateAdd(this, _lastPoint2, null);
     __privateAdd(this, _opacity);
@@ -18284,7 +19247,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     } else {
       box = __privateMethod(_b = _HighlightEditor, _HighlightEditor_static, rotateBbox_fn).call(_b, [this.x, this.y, this.width, this.height], angle);
     }
-    drawLayer.updateProperties(__privateGet(this, _id3), {
+    drawLayer.updateProperties(__privateGet(this, _id4), {
       bbox: box,
       root: {
         "data-main-rotation": angle
@@ -18404,7 +19367,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
   show(visible = this._isVisible) {
     super.show(visible);
     if (this.parent) {
-      this.parent.drawLayer.updateProperties(__privateGet(this, _id3), {
+      this.parent.drawLayer.updateProperties(__privateGet(this, _id4), {
         rootClass: {
           hidden: !visible
         }
@@ -18655,7 +19618,7 @@ _focusNode = new WeakMap();
 _focusOffset = new WeakMap();
 _highlightDiv = new WeakMap();
 _highlightOutlines = new WeakMap();
-_id3 = new WeakMap();
+_id4 = new WeakMap();
 _isFreeHighlight = new WeakMap();
 _lastPoint2 = new WeakMap();
 _opacity = new WeakMap();
@@ -18699,7 +19662,7 @@ createFreeOutlines_fn = function({ highlightOutlines, highlightId, clipPathId })
     25e-4
   ));
   if (highlightId >= 0) {
-    __privateSet(this, _id3, highlightId);
+    __privateSet(this, _id4, highlightId);
     __privateSet(this, _clipPathId, clipPathId);
     this.parent.drawLayer.finalizeDraw(highlightId, {
       bbox: highlightOutlines.box,
@@ -18723,7 +19686,7 @@ createFreeOutlines_fn = function({ highlightOutlines, highlightId, clipPathId })
     ));
   } else if (this.parent) {
     const angle = this.parent.viewport.rotation;
-    this.parent.drawLayer.updateProperties(__privateGet(this, _id3), {
+    this.parent.drawLayer.updateProperties(__privateGet(this, _id4), {
       bbox: __privateMethod(_a2 = _HighlightEditor, _HighlightEditor_static, rotateBbox_fn).call(_a2, __privateGet(this, _highlightOutlines).box, (angle - this.rotation + 360) % 360),
       path: {
         d: highlightOutlines.toSVGPath()
@@ -18778,7 +19741,7 @@ updateColor_fn2 = function(color) {
   const setColorAndOpacity = (col, opa) => {
     this.color = col;
     __privateSet(this, _opacity, opa);
-    this.parent?.drawLayer.updateProperties(__privateGet(this, _id3), {
+    this.parent?.drawLayer.updateProperties(__privateGet(this, _id4), {
       root: {
         fill: col,
         "fill-opacity": opa
@@ -18847,19 +19810,19 @@ changeThickness_fn = function(thickness) {
   this.setDims(this.width * parentWidth, this.height * parentHeight);
 };
 cleanDrawLayer_fn = function() {
-  if (__privateGet(this, _id3) === null || !this.parent) {
+  if (__privateGet(this, _id4) === null || !this.parent) {
     return;
   }
-  this.parent.drawLayer.remove(__privateGet(this, _id3));
-  __privateSet(this, _id3, null);
+  this.parent.drawLayer.remove(__privateGet(this, _id4));
+  __privateSet(this, _id4, null);
   this.parent.drawLayer.remove(__privateGet(this, _outlineId));
   __privateSet(this, _outlineId, null);
 };
 addToDrawLayer_fn = function(parent = this.parent) {
-  if (__privateGet(this, _id3) !== null) {
+  if (__privateGet(this, _id4) !== null) {
     return;
   }
-  ({ id: __privateWrapper(this, _id3)._, clipPathId: __privateWrapper(this, _clipPathId)._ } = parent.drawLayer.draw(
+  ({ id: __privateWrapper(this, _id4)._, clipPathId: __privateWrapper(this, _clipPathId)._ } = parent.drawLayer.draw(
     {
       bbox: __privateGet(this, _highlightOutlines).box,
       root: {
@@ -23380,7 +24343,7 @@ __privateAdd(_AnnotationEditorLayer, _editorTypes2, new Map(
 var AnnotationEditorLayer = _AnnotationEditorLayer;
 
 // src/pdf.js/src/display/draw_layer.js
-var _parent2, _mapping, _toUpdate, _id4, _DrawLayer_static, setBox_fn, _DrawLayer_instances, createSVG_fn, createClipPath_fn, updateProperties_fn;
+var _parent2, _mapping, _toUpdate, _id5, _DrawLayer_static, setBox_fn, _DrawLayer_instances, createSVG_fn, createClipPath_fn, updateProperties_fn;
 var _DrawLayer = class _DrawLayer {
   constructor({ pageIndex }) {
     __privateAdd(this, _DrawLayer_instances);
@@ -23408,7 +24371,7 @@ var _DrawLayer = class _DrawLayer {
     return shadow(this, "_svgFactory", new DOMSVGFactory());
   }
   draw(properties, isPathUpdatable = false, hasClip = false) {
-    const id2 = __privateWrapper(_DrawLayer, _id4)._++;
+    const id2 = __privateWrapper(_DrawLayer, _id5)._++;
     const root = __privateMethod(this, _DrawLayer_instances, createSVG_fn).call(this);
     const defs = _DrawLayer._svgFactory.createElement("defs");
     root.append(defs);
@@ -23429,7 +24392,7 @@ var _DrawLayer = class _DrawLayer {
     return { id: id2, clipPathId: `url(#${clipPathId})` };
   }
   drawOutline(properties, mustRemoveSelfIntersections) {
-    const id2 = __privateWrapper(_DrawLayer, _id4)._++;
+    const id2 = __privateWrapper(_DrawLayer, _id5)._++;
     const root = __privateMethod(this, _DrawLayer_instances, createSVG_fn).call(this);
     const defs = _DrawLayer._svgFactory.createElement("defs");
     root.append(defs);
@@ -23536,7 +24499,7 @@ var _DrawLayer = class _DrawLayer {
 _parent2 = new WeakMap();
 _mapping = new WeakMap();
 _toUpdate = new WeakMap();
-_id4 = new WeakMap();
+_id5 = new WeakMap();
 _DrawLayer_static = new WeakSet();
 setBox_fn = function(element, [x, y, width, height]) {
   const { style } = element;
@@ -23579,7 +24542,7 @@ updateProperties_fn = function(element, properties) {
   }
 };
 __privateAdd(_DrawLayer, _DrawLayer_static);
-__privateAdd(_DrawLayer, _id4, 0);
+__privateAdd(_DrawLayer, _id5, 0);
 var DrawLayer = _DrawLayer;
 
 // src/pdf.js/src/pdf.js
@@ -24006,6 +24969,94 @@ function renderSvgNode(node) {
   return `<${node.tag}${renderAttributes(node.attrs)} />`;
 }
 
+// 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.toBuffer("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)
+    ])
+  );
+}
+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)}`;
+}
+function parseRgbaColor(color) {
+  const match = color.match(
+    /^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)$/
+  );
+  if (!match) {
+    return { r: 0, g: 0, b: 0, a: 1 };
+  }
+  return {
+    r: Number.parseInt(match[1], 10),
+    g: Number.parseInt(match[2], 10),
+    b: Number.parseInt(match[3], 10),
+    a: match[4] ? Number.parseFloat(match[4]) : 1
+  };
+}
+
 // src/lib/SvgCanvasContext.ts
 function isCanvas(img) {
   return "toDataURL" in img;
@@ -24972,7 +26023,7 @@ async function toSvgString(ctx) {
 
 // src/lib/PDFPageProxy.ts
 async function loadNodeCanvasFactory() {
-  const { NodeCanvasFactory: NodeCanvasFactory2 } = await import("./NodeCanvasFactory-ONRE5YYL.js");
+  const { NodeCanvasFactory: NodeCanvasFactory2 } = await import("./NodeUtilsStabs-MUAXKISB.js");
   return new NodeCanvasFactory2({});
 }
 var getAnnotations = PDFPageProxy.prototype.getAnnotations;