@chialab/pdfjs-lib 1.0.0-alpha.0 → 1.0.0-alpha.10

package/dist/node/index.js

@@ -8,13 +8,14 @@ import {
   AnnotationPrefix,
   AnnotationType,
   BaseException,
+  DrawOPS,
   FONT_IDENTITY_MATRIX,
   FeatureTest,
   FormatError,
-  IDENTITY_MATRIX,
   ImageKind,
   InvalidPDFException,
   LINE_FACTOR,
+  MathClamp,
   MessageHandler,
   MurmurHash3_64,
   OPS,
@@ -25,6 +26,7 @@ import {
   TextRenderingMode,
   Util,
   VerbosityLevel,
+  _isValidExplicitDest,
   assert,
   convertBlackAndWhiteToRGBA,
   createValidAbsoluteUrl,
@@ -43,7 +45,7 @@ import {
   unreachable,
   warn,
   wrapReason
-} from "./chunk-KTTVPO2G.js";
+} from "./chunk-WL32POZ2.js";
 import {
   __privateAdd,
   __privateGet,
@@ -237,7 +239,9 @@ var PageViewport = class _PageViewport {
    * @see {@link convertToViewportRectangle}
    */
   convertToViewportPoint(x, y) {
-    return Util.applyTransform([x, y], this.transform);
+    const p = [x, y];
+    Util.applyTransform(p, this.transform);
+    return p;
   }
   /**
    * Converts PDF rectangle to the viewport coordinates.
@@ -247,8 +251,10 @@ var PageViewport = class _PageViewport {
    * @see {@link convertToViewportPoint}
    */
   convertToViewportRectangle(rect) {
-    const topLeft = Util.applyTransform([rect[0], rect[1]], this.transform);
-    const bottomRight = Util.applyTransform([rect[2], rect[3]], this.transform);
+    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]];
   }
   /**
@@ -261,7 +267,9 @@ var PageViewport = class _PageViewport {
    * @see {@link convertToViewportPoint}
    */
   convertToPdfPoint(x, y) {
-    return Util.applyInverseTransform([x, y], this.transform);
+    const p = [x, y];
+    Util.applyInverseTransform(p, this.transform);
+    return p;
   }
 };
 var RenderingCancelledException = class extends BaseException {
@@ -491,9 +499,9 @@ function setLayerDimensions(div, viewport, mustFlip = false, mustRotate = true)
     div.setAttribute("data-main-rotation", viewport.rotation);
   }
 }
-var OutputScale = class {
+var OutputScale = class _OutputScale {
   constructor() {
-    const pixelRatio = window.devicePixelRatio || 1;
+    const { pixelRatio } = _OutputScale;
     this.sx = pixelRatio;
     this.sy = pixelRatio;
   }
@@ -503,9 +511,37 @@ var OutputScale = class {
   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) {
+    let maxAreaScale = Infinity, maxWidthScale = Infinity, maxHeightScale = Infinity;
+    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;
+  }
 };
 var SupportedImageMimeTypes = [
   "image/apng",
@@ -3169,7 +3205,7 @@ setState_fn = async function() {
   if (!tooltip.parentNode) {
     button.append(tooltip);
   }
-  const element = __privateGet(this, _editor2).getImageForAltText();
+  const element = __privateGet(this, _editor2).getElementForAltText();
   element?.setAttribute("aria-describedby", tooltip.id);
 };
 __privateAdd(_AltText, _l10nNewButton, null);
@@ -3214,12 +3250,12 @@ var _TouchManager = class _TouchManager {
       signal: __privateGet(this, _signal)
     });
   }
+  /**
+   * NOTE: Don't shadow this value since `devicePixelRatio` may change if the
+   * window resolution changes, e.g. if the viewer is moved to another monitor.
+   */
   get MIN_TOUCH_DISTANCE_TO_PINCH() {
-    return shadow(
-      this,
-      "MIN_TOUCH_DISTANCE_TO_PINCH",
-      35 / (window.devicePixelRatio || 1)
-    );
+    return 35 / OutputScale.pixelRatio;
   }
   destroy() {
     __privateGet(this, _touchManagerAC)?.abort();
@@ -3801,20 +3837,20 @@ var _AnnotationEditor = class _AnnotationEditor {
     if (this._mustFixPosition) {
       switch (rotation) {
         case 0:
-          x = Math.max(0, Math.min(pageWidth - width, x));
-          y = Math.max(0, Math.min(pageHeight - height, y));
+          x = MathClamp(x, 0, pageWidth - width);
+          y = MathClamp(y, 0, pageHeight - height);
           break;
         case 90:
-          x = Math.max(0, Math.min(pageWidth - height, x));
-          y = Math.min(pageHeight, Math.max(width, y));
+          x = MathClamp(x, 0, pageWidth - height);
+          y = MathClamp(y, width, pageHeight);
           break;
         case 180:
-          x = Math.min(pageWidth, Math.max(width, x));
-          y = Math.min(pageHeight, Math.max(height, y));
+          x = MathClamp(x, width, pageWidth);
+          y = MathClamp(y, height, pageHeight);
           break;
         case 270:
-          x = Math.min(pageWidth, Math.max(height, x));
-          y = Math.max(0, Math.min(pageHeight - width, y));
+          x = MathClamp(x, height, pageWidth);
+          y = MathClamp(y, 0, pageHeight - width);
           break;
       }
     }
@@ -3991,29 +4027,35 @@ var _AnnotationEditor = class _AnnotationEditor {
    * @returns {HTMLDivElement | null}
    */
   render() {
-    this.div = document.createElement("div");
-    this.div.setAttribute("data-editor-rotation", (360 - this.rotation) % 360);
-    this.div.className = this.name;
-    this.div.setAttribute("id", this.id);
-    this.div.tabIndex = __privateGet(this, _disabled) ? -1 : 0;
+    const div = this.div = document.createElement("div");
+    div.setAttribute("data-editor-rotation", (360 - this.rotation) % 360);
+    div.className = this.name;
+    div.setAttribute("id", this.id);
+    div.tabIndex = __privateGet(this, _disabled) ? -1 : 0;
+    div.setAttribute("role", "application");
+    if (this.defaultL10nId) {
+      div.setAttribute("data-l10n-id", this.defaultL10nId);
+    }
     if (!this._isVisible) {
-      this.div.classList.add("hidden");
+      div.classList.add("hidden");
     }
     this.setInForeground();
     __privateMethod(this, _AnnotationEditor_instances, addFocusListeners_fn).call(this);
     const [parentWidth, parentHeight] = this.parentDimensions;
     if (this.parentRotation % 180 !== 0) {
-      this.div.style.maxWidth = `${(100 * parentHeight / parentWidth).toFixed(
+      div.style.maxWidth = `${(100 * parentHeight / parentWidth).toFixed(
+        2
+      )}%`;
+      div.style.maxHeight = `${(100 * parentWidth / parentHeight).toFixed(
         2
       )}%`;
-      this.div.style.maxHeight = `${(100 * parentWidth / parentHeight).toFixed(2)}%`;
     }
     const [tx, ty] = this.getInitialTranslation();
     this.translate(tx, ty);
-    bindEvents(this, this.div, ["pointerdown"]);
+    bindEvents(this, div, ["keydown", "pointerdown"]);
     if (this.isResizable && this._uiManager._supportsPinchToZoom) {
       __privateGet(this, _touchManager) || __privateSet(this, _touchManager, new TouchManager({
-        container: this.div,
+        container: div,
         isPinchingDisabled: () => !this.isSelected,
         onPinchStart: __privateMethod(this, _AnnotationEditor_instances, touchPinchStartCallback_fn).bind(this),
         onPinching: __privateMethod(this, _AnnotationEditor_instances, touchPinchCallback_fn).bind(this),
@@ -4022,7 +4064,7 @@ var _AnnotationEditor = class _AnnotationEditor {
       }));
     }
     this._uiManager._editorUndoBar?.hide();
-    return this.div;
+    return div;
   }
   /**
    * Onpointerdown callback.
@@ -4312,7 +4354,6 @@ var _AnnotationEditor = class _AnnotationEditor {
     if (this.isResizable) {
       __privateMethod(this, _AnnotationEditor_instances, createResizers_fn).call(this);
       __privateGet(this, _resizersDiv).classList.remove("hidden");
-      bindEvents(this, this.div, ["keydown"]);
     }
   }
   get toolbarPosition() {
@@ -4454,8 +4495,8 @@ var _AnnotationEditor = class _AnnotationEditor {
   /**
    * @returns {HTMLElement | null} the element requiring an alt text.
    */
-  getImageForAltText() {
-    return null;
+  getElementForAltText() {
+    return this.div;
   }
   /**
    * Get the div which really contains the displayed content.
@@ -4859,14 +4900,12 @@ resizerPointermove_fn = function(name, event) {
       minHeight / savedHeight
     );
   } else if (isHorizontal) {
-    ratioX = Math.max(
-      minWidth,
-      Math.min(1, Math.abs(oppositePoint[0] - point[0] - deltaX))
-    ) / savedWidth;
+    ratioX = MathClamp(Math.abs(oppositePoint[0] - point[0] - deltaX), minWidth, 1) / savedWidth;
   } else {
-    ratioY = Math.max(
+    ratioY = MathClamp(
+      Math.abs(oppositePoint[1] - point[1] - deltaY),
       minHeight,
-      Math.min(1, Math.abs(oppositePoint[1] - point[1] - deltaY))
+      1
     ) / savedHeight;
   }
   const newWidth = _AnnotationEditor._round(savedWidth * ratioX);
@@ -5332,7 +5371,10 @@ var PrintAnnotationStorage = class extends AnnotationStorage {
 _serializable = new WeakMap();
 
 // src/lib/NodeCanvas.ts
+import { writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 var require2 = createRequire(import.meta.url);
 var {
   createCanvas: create,
@@ -5340,32 +5382,23 @@ var {
   Path2D
 } = require2("@napi-rs/canvas");
 async function createCanvas(width, height) {
+  await loadDefaultFonts();
   return create(width, height);
 }
+var loadingFontPromise = null;
 async function loadDefaultFonts() {
-  const [monoBuffer, sansBuffer, serifBuffer] = await Promise.all([
-    import("./LiberationMono-Regular-KMFXXO3B.js").then(
-      (module) => module.default
-    ),
-    import("./LiberationSans-Regular-CDMMZL5S.js").then(
-      (module) => module.default
-    ),
-    import("./LiberationSerif-Regular-WAOWR76G.js").then(
-      (module) => module.default
-    )
-  ]);
-  GlobalFonts.register(
-    Buffer.from(monoBuffer),
-    "Liberation Mono"
-  );
-  GlobalFonts.register(
-    Buffer.from(sansBuffer),
-    "Liberation Sans"
-  );
-  GlobalFonts.register(
-    Buffer.from(serifBuffer),
-    "Liberation Serif"
-  );
+  if (loadingFontPromise === null) {
+    loadingFontPromise = import("./LiberationSans-Regular-CDMMZL5S.js").then((module) => module.default).then(async (sansBuffer) => {
+      const currentDir = dirname(fileURLToPath(import.meta.url));
+      const fileName = join(currentDir, "LiberationSans-Regular.ttf");
+      await writeFile(fileName, sansBuffer);
+      GlobalFonts.registerFromPath(
+        fileName,
+        "Liberation Sans"
+      );
+    });
+  }
+  return loadingFontPromise;
 }
 
 // src/lib/Path2D.ts
@@ -6701,6 +6734,9 @@ var BaseShadingPattern = class {
       unreachable("Cannot initialize BaseShadingPattern.");
     }
   }
+  isModifyingCurrentTransform() {
+    return false;
+  }
   getPattern() {
     unreachable("Abstract method `getPattern` called.");
   }
@@ -6999,17 +7035,22 @@ var MeshShadingPattern = class extends BaseShadingPattern {
       scaleY
     };
   }
+  isModifyingCurrentTransform() {
+    return true;
+  }
   getPattern(ctx, owner, inverse, pathType) {
     applyBoundingBox(ctx, this._bbox);
-    let scale;
+    const scale = new Float32Array(2);
     if (pathType === PathType.SHADING) {
-      scale = Util.singularValueDecompose2dScale(getCurrentTransform(ctx));
+      Util.singularValueDecompose2dScale(getCurrentTransform(ctx), scale);
+    } else if (this.matrix) {
+      Util.singularValueDecompose2dScale(this.matrix, scale);
+      const [matrixScaleX, matrixScaleY] = scale;
+      Util.singularValueDecompose2dScale(owner.baseTransform, scale);
+      scale[0] *= matrixScaleX;
+      scale[1] *= matrixScaleY;
     } else {
-      scale = Util.singularValueDecompose2dScale(owner.baseTransform);
-      if (this.matrix) {
-        const matrixScale = Util.singularValueDecompose2dScale(this.matrix);
-        scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
-      }
+      Util.singularValueDecompose2dScale(owner.baseTransform, scale);
     }
     const temporaryPatternCanvas = this._createMeshCanvas(
       scale,
@@ -7051,7 +7092,8 @@ var PaintType = {
   UNCOLORED: 2
 };
 var _TilingPattern = class _TilingPattern {
-  constructor(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
+  constructor(IR, ctx, canvasGraphicsFactory, baseTransform) {
+    this.color = IR[1];
     this.operatorList = IR[2];
     this.matrix = IR[3];
     this.bbox = IR[4];
@@ -7059,7 +7101,6 @@ var _TilingPattern = class _TilingPattern {
     this.ystep = IR[6];
     this.paintType = IR[7];
     this.tilingType = IR[8];
-    this.color = color;
     this.ctx = ctx;
     this.canvasGraphicsFactory = canvasGraphicsFactory;
     this.baseTransform = baseTransform;
@@ -7080,12 +7121,12 @@ var _TilingPattern = class _TilingPattern {
     const x0 = bbox[0], y0 = bbox[1], x1 = bbox[2], y1 = bbox[3];
     const width = x1 - x0;
     const height = y1 - y0;
-    const matrixScale = Util.singularValueDecompose2dScale(this.matrix);
-    const curMatrixScale = Util.singularValueDecompose2dScale(
-      this.baseTransform
-    );
-    const combinedScaleX = matrixScale[0] * curMatrixScale[0];
-    const combinedScaleY = matrixScale[1] * curMatrixScale[1];
+    const scale = new Float32Array(2);
+    Util.singularValueDecompose2dScale(this.matrix, scale);
+    const [matrixScaleX, matrixScaleY] = scale;
+    Util.singularValueDecompose2dScale(this.baseTransform, scale);
+    const combinedScaleX = matrixScaleX * scale[0];
+    const combinedScaleY = matrixScaleY * scale[1];
     let canvasWidth = width, canvasHeight = height, redrawHorizontally = false, redrawVertically = false;
     const xScaledStep = Math.ceil(xstep * combinedScaleX);
     const yScaledStep = Math.ceil(ystep * combinedScaleY);
@@ -7201,12 +7242,11 @@ var _TilingPattern = class _TilingPattern {
     const bboxWidth = x1 - x0;
     const bboxHeight = y1 - y0;
     graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
-    graphics.current.updateRectMinMax(getCurrentTransform(graphics.ctx), [
-      x0,
-      y0,
-      x1,
-      y1
-    ]);
+    Util.axialAlignedBoundingBox(
+      [x0, y0, x1, y1],
+      getCurrentTransform(graphics.ctx),
+      graphics.current.minMax
+    );
     graphics.clip();
     graphics.endPath();
   }
@@ -7231,6 +7271,9 @@ var _TilingPattern = class _TilingPattern {
         throw new FormatError(`Unsupported paint type: ${paintType}`);
     }
   }
+  isModifyingCurrentTransform() {
+    return false;
+  }
   getPattern(ctx, owner, inverse, pathType) {
     let matrix = inverse;
     if (pathType !== PathType.SHADING) {
@@ -7263,8 +7306,15 @@ var MIN_FONT_SIZE = 16;
 var MAX_FONT_SIZE = 100;
 var EXECUTION_TIME = 15;
 var EXECUTION_STEPS = 10;
-var MAX_SIZE_TO_COMPILE = 1e3;
 var FULL_CHUNK_HEIGHT = 16;
+var SCALE_MATRIX = new DOMMatrix();
+var XY = new Float32Array(2);
+var MIN_MAX_INIT = new Float32Array([
+  Infinity,
+  Infinity,
+  -Infinity,
+  -Infinity
+]);
 function mirrorContextOperations(ctx, destCtx) {
   if (ctx._removeMirroring) {
     throw new Error("Context is already forwarding operations.");
@@ -7302,39 +7352,39 @@ function mirrorContextOperations(ctx, destCtx) {
     ctx.beginPath = ctx.__originalBeginPath;
     delete ctx._removeMirroring;
   };
-  ctx.save = function ctxSave() {
+  ctx.save = function() {
     destCtx.save();
     this.__originalSave();
   };
-  ctx.restore = function ctxRestore() {
+  ctx.restore = function() {
     destCtx.restore();
     this.__originalRestore();
   };
-  ctx.translate = function ctxTranslate(x, y) {
+  ctx.translate = function(x, y) {
     destCtx.translate(x, y);
     this.__originalTranslate(x, y);
   };
-  ctx.scale = function ctxScale(x, y) {
+  ctx.scale = function(x, y) {
     destCtx.scale(x, y);
     this.__originalScale(x, y);
   };
-  ctx.transform = function ctxTransform(a, b, c, d, e, f) {
+  ctx.transform = function(a, b, c, d, e, f) {
     destCtx.transform(a, b, c, d, e, f);
     this.__originalTransform(a, b, c, d, e, f);
   };
-  ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
+  ctx.setTransform = function(a, b, c, d, e, f) {
     destCtx.setTransform(a, b, c, d, e, f);
     this.__originalSetTransform(a, b, c, d, e, f);
   };
-  ctx.resetTransform = function ctxResetTransform() {
+  ctx.resetTransform = function() {
     destCtx.resetTransform();
     this.__originalResetTransform();
   };
-  ctx.rotate = function ctxRotate(angle) {
+  ctx.rotate = function(angle) {
     destCtx.rotate(angle);
     this.__originalRotate(angle);
   };
-  ctx.clip = function ctxRotate(rule) {
+  ctx.clip = function(rule) {
     destCtx.clip(rule);
     this.__originalClip(rule);
   };
@@ -7425,227 +7475,57 @@ function drawImageAtIntegerCoords(ctx, srcImg, srcX, srcY, srcW, srcH, destX, de
   const scaleY = Math.hypot(c, d);
   return [scaleX * destW, scaleY * destH];
 }
-function compileType3Glyph(imgData) {
-  const { width, height } = imgData;
-  if (width > MAX_SIZE_TO_COMPILE || height > MAX_SIZE_TO_COMPILE) {
-    return null;
-  }
-  const POINT_TO_PROCESS_LIMIT = 1e3;
-  const POINT_TYPES = new Uint8Array([
-    0,
-    2,
-    4,
-    0,
-    1,
-    0,
-    5,
-    4,
-    8,
-    10,
-    0,
-    8,
-    0,
-    2,
-    1,
-    0
-  ]);
-  const width1 = width + 1;
-  let points = new Uint8Array(width1 * (height + 1));
-  let i, j, j0;
-  const lineSize = width + 7 & ~7;
-  let data = new Uint8Array(lineSize * height), pos = 0;
-  for (const elem of imgData.data) {
-    let mask = 128;
-    while (mask > 0) {
-      data[pos++] = elem & mask ? 0 : 255;
-      mask >>= 1;
-    }
-  }
-  let count = 0;
-  pos = 0;
-  if (data[pos] !== 0) {
-    points[0] = 1;
-    ++count;
-  }
-  for (j = 1; j < width; j++) {
-    if (data[pos] !== data[pos + 1]) {
-      points[j] = data[pos] ? 2 : 1;
-      ++count;
-    }
-    pos++;
-  }
-  if (data[pos] !== 0) {
-    points[j] = 2;
-    ++count;
-  }
-  for (i = 1; i < height; i++) {
-    pos = i * lineSize;
-    j0 = i * width1;
-    if (data[pos - lineSize] !== data[pos]) {
-      points[j0] = data[pos] ? 1 : 8;
-      ++count;
-    }
-    let sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
-    for (j = 1; j < width; j++) {
-      sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
-      if (POINT_TYPES[sum]) {
-        points[j0 + j] = POINT_TYPES[sum];
-        ++count;
-      }
-      pos++;
-    }
-    if (data[pos - lineSize] !== data[pos]) {
-      points[j0 + j] = data[pos] ? 2 : 4;
-      ++count;
-    }
-    if (count > POINT_TO_PROCESS_LIMIT) {
-      return null;
-    }
-  }
-  pos = lineSize * (height - 1);
-  j0 = i * width1;
-  if (data[pos] !== 0) {
-    points[j0] = 8;
-    ++count;
-  }
-  for (j = 1; j < width; j++) {
-    if (data[pos] !== data[pos + 1]) {
-      points[j0 + j] = data[pos] ? 4 : 8;
-      ++count;
-    }
-    pos++;
-  }
-  if (data[pos] !== 0) {
-    points[j0 + j] = 4;
-    ++count;
-  }
-  if (count > POINT_TO_PROCESS_LIMIT) {
-    return null;
-  }
-  const steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
-  const path = new SvgPath2D();
-  for (i = 0; count && i <= height; i++) {
-    let p = i * width1;
-    const end = p + width;
-    while (p < end && !points[p]) {
-      p++;
-    }
-    if (p === end) {
-      continue;
-    }
-    path.moveTo(p % width1, i);
-    const p0 = p;
-    let type = points[p];
-    do {
-      const step = steps[type];
-      do {
-        p += step;
-      } while (!points[p]);
-      const pp = points[p];
-      if (pp !== 5 && pp !== 10) {
-        type = pp;
-        points[p] = 0;
-      } else {
-        type = pp & 51 * type >> 4;
-        points[p] &= type >> 2 | type << 2;
-      }
-      path.lineTo(p % width1, p / width1 | 0);
-      if (!points[p]) {
-        --count;
-      }
-    } while (p0 !== p);
-    --i;
-  }
-  data = null;
-  points = null;
-  const drawOutline = function(c) {
-    c.save();
-    c.scale(1 / width, -1 / height);
-    c.translate(0, -height);
-    c.fill(path);
-    c.beginPath();
-    c.restore();
-  };
-  return drawOutline;
-}
 var CanvasExtraState = class {
   constructor(width, height) {
-    this.alphaIsShape = false;
-    this.fontSize = 0;
-    this.fontSizeScale = 1;
-    this.textMatrix = IDENTITY_MATRIX;
-    this.textMatrixScale = 1;
-    this.fontMatrix = FONT_IDENTITY_MATRIX;
-    this.leading = 0;
-    this.x = 0;
-    this.y = 0;
-    this.lineX = 0;
-    this.lineY = 0;
-    this.charSpacing = 0;
-    this.wordSpacing = 0;
-    this.textHScale = 1;
-    this.textRenderingMode = TextRenderingMode.FILL;
-    this.textRise = 0;
-    this.fillColor = "#000000";
-    this.strokeColor = "#000000";
-    this.patternFill = false;
-    this.patternStroke = false;
-    this.fillAlpha = 1;
-    this.strokeAlpha = 1;
-    this.lineWidth = 1;
-    this.activeSMask = null;
-    this.transferMaps = "none";
-    this.startNewPathAndClipBox([0, 0, width, height]);
+    // Are soft masks and alpha values shapes or opacities?
+    __publicField(this, "alphaIsShape", false);
+    __publicField(this, "fontSize", 0);
+    __publicField(this, "fontSizeScale", 1);
+    __publicField(this, "textMatrix", null);
+    __publicField(this, "textMatrixScale", 1);
+    __publicField(this, "fontMatrix", FONT_IDENTITY_MATRIX);
+    __publicField(this, "leading", 0);
+    // Current point (in user coordinates)
+    __publicField(this, "x", 0);
+    __publicField(this, "y", 0);
+    // Start of text line (in text coordinates)
+    __publicField(this, "lineX", 0);
+    __publicField(this, "lineY", 0);
+    // Character and word spacing
+    __publicField(this, "charSpacing", 0);
+    __publicField(this, "wordSpacing", 0);
+    __publicField(this, "textHScale", 1);
+    __publicField(this, "textRenderingMode", TextRenderingMode.FILL);
+    __publicField(this, "textRise", 0);
+    // Default fore and background colors
+    __publicField(this, "fillColor", "#000000");
+    __publicField(this, "strokeColor", "#000000");
+    __publicField(this, "patternFill", false);
+    __publicField(this, "patternStroke", false);
+    // Note: fill alpha applies to all non-stroking operations
+    __publicField(this, "fillAlpha", 1);
+    __publicField(this, "strokeAlpha", 1);
+    __publicField(this, "lineWidth", 1);
+    __publicField(this, "activeSMask", null);
+    __publicField(this, "transferMaps", "none");
+    this.clipBox = new Float32Array([0, 0, width, height]);
+    this.minMax = MIN_MAX_INIT.slice();
   }
   clone() {
     const clone = Object.create(this);
     clone.clipBox = this.clipBox.slice();
+    clone.minMax = this.minMax.slice();
     return clone;
   }
-  setCurrentPoint(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-  updatePathMinMax(transform, x, y) {
-    [x, y] = Util.applyTransform([x, y], transform);
-    this.minX = Math.min(this.minX, x);
-    this.minY = Math.min(this.minY, y);
-    this.maxX = Math.max(this.maxX, x);
-    this.maxY = Math.max(this.maxY, y);
-  }
-  updateRectMinMax(transform, rect) {
-    const p1 = Util.applyTransform(rect, transform);
-    const p2 = Util.applyTransform(rect.slice(2), transform);
-    const p3 = Util.applyTransform([rect[0], rect[3]], transform);
-    const p4 = Util.applyTransform([rect[2], rect[1]], transform);
-    this.minX = Math.min(this.minX, p1[0], p2[0], p3[0], p4[0]);
-    this.minY = Math.min(this.minY, p1[1], p2[1], p3[1], p4[1]);
-    this.maxX = Math.max(this.maxX, p1[0], p2[0], p3[0], p4[0]);
-    this.maxY = Math.max(this.maxY, p1[1], p2[1], p3[1], p4[1]);
-  }
-  updateScalingPathMinMax(transform, minMax) {
-    Util.scaleMinMax(transform, minMax);
-    this.minX = Math.min(this.minX, minMax[0]);
-    this.minY = Math.min(this.minY, minMax[1]);
-    this.maxX = Math.max(this.maxX, minMax[2]);
-    this.maxY = Math.max(this.maxY, minMax[3]);
-  }
-  updateCurvePathMinMax(transform, x0, y0, x1, y1, x2, y2, x3, y3, minMax) {
-    const box = Util.bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3, minMax);
-    if (minMax) {
-      return;
-    }
-    this.updateRectMinMax(transform, box);
-  }
   getPathBoundingBox(pathType = PathType.FILL, transform = null) {
-    const box = [this.minX, this.minY, this.maxX, this.maxY];
+    const box = this.minMax.slice();
     if (pathType === PathType.STROKE) {
       if (!transform) {
         unreachable("Stroke bounding box must include transform.");
       }
-      const scale = Util.singularValueDecompose2dScale(transform);
-      const xStrokePad = scale[0] * this.lineWidth / 2;
-      const yStrokePad = scale[1] * this.lineWidth / 2;
+      Util.singularValueDecompose2dScale(transform, XY);
+      const xStrokePad = XY[0] * this.lineWidth / 2;
+      const yStrokePad = XY[1] * this.lineWidth / 2;
       box[0] -= xStrokePad;
       box[1] -= yStrokePad;
       box[2] += xStrokePad;
@@ -7658,14 +7538,11 @@ var CanvasExtraState = class {
     this.startNewPathAndClipBox(intersect || [0, 0, 0, 0]);
   }
   isEmptyClip() {
-    return this.minX === Infinity;
+    return this.minMax[0] === Infinity;
   }
   startNewPathAndClipBox(box) {
-    this.clipBox = box;
-    this.minX = Infinity;
-    this.minY = Infinity;
-    this.maxX = 0;
-    this.maxY = 0;
+    this.clipBox.set(box, 0);
+    this.minMax.set(MIN_MAX_INIT, 0);
   }
   getClippedPathBoundingBox(pathType = PathType.FILL, transform = null) {
     return Util.intersect(
@@ -7829,24 +7706,20 @@ function resetCtxToDefault(ctx) {
     ctx.setLineDash([]);
     ctx.lineDashOffset = 0;
   }
-  if (!isNodeJS) {
-    const { filter } = ctx;
-    if (filter !== "none" && filter !== "") {
-      ctx.filter = "none";
-    }
+  const { filter } = ctx;
+  if (filter !== "none" && filter !== "") {
+    ctx.filter = "none";
   }
 }
 function getImageSmoothingEnabled(transform, interpolate) {
   if (interpolate) {
     return true;
   }
-  const scale = Util.singularValueDecompose2dScale(transform);
-  scale[0] = Math.fround(scale[0]);
-  scale[1] = Math.fround(scale[1]);
+  Util.singularValueDecompose2dScale(transform, XY);
   const actualScale = Math.fround(
-    (globalThis.devicePixelRatio || 1) * PixelsPerInch.PDF_TO_CSS_UNITS
+    OutputScale.pixelRatio * PixelsPerInch.PDF_TO_CSS_UNITS
   );
-  return scale[0] <= actualScale && scale[1] <= actualScale;
+  return XY[0] <= actualScale && XY[1] <= actualScale;
 }
 var LINE_CAP_STYLES = ["butt", "round", "square"];
 var LINE_JOIN_STYLES = ["miter", "round", "bevel"];
@@ -7871,7 +7744,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.canvasFactory = canvasFactory;
     this.filterFactory = filterFactory;
     this.groupStack = [];
-    this.processingType3 = null;
     this.baseTransform = null;
     this.baseTransformStack = [];
     this.groupLevel = 0;
@@ -8092,10 +7964,9 @@ var _CanvasGraphics = class _CanvasGraphics {
       0
     ]);
     maskToCanvas = Util.transform(maskToCanvas, [1, 0, 0, 1, 0, -height]);
-    const [minX, minY, maxX, maxY] = Util.getAxialAlignedBoundingBox(
-      [0, 0, width, height],
-      maskToCanvas
-    );
+    const minMax = MIN_MAX_INIT.slice();
+    Util.axialAlignedBoundingBox([0, 0, width, height], maskToCanvas, minMax);
+    const [minX, minY, maxX, maxY] = minMax;
     const drawnWidth = Math.round(maxX - minX) || 1;
     const drawnHeight = Math.round(maxY - minY) || 1;
     const fillCanvas = this.cachedCanvases.getCanvas(
@@ -8214,8 +8085,7 @@ var _CanvasGraphics = class _CanvasGraphics {
           this.current.strokeAlpha = value;
           break;
         case "ca":
-          this.current.fillAlpha = value;
-          this.ctx.globalAlpha = value;
+          this.ctx.globalAlpha = this.current.fillAlpha = value;
           break;
         case "BM":
           this.ctx.globalCompositeOperation = value;
@@ -8264,16 +8134,11 @@ var _CanvasGraphics = class _CanvasGraphics {
       drawnHeight
     );
     this.suspendedCtx = this.ctx;
-    this.ctx = scratchCanvas.context;
-    const ctx = this.ctx;
-    ctx.setTransform(...getCurrentTransform(this.suspendedCtx));
+    const ctx = this.ctx = scratchCanvas.context;
+    ctx.setTransform(this.suspendedCtx.getTransform());
     copyCtxState(this.suspendedCtx, ctx);
     mirrorContextOperations(ctx, this.suspendedCtx);
-    this.setGState([
-      ["BM", "source-over"],
-      ["ca", 1],
-      ["CA", 1]
-    ]);
+    this.setGState([["BM", "source-over"]]);
   }
   endSMaskMode() {
     if (!this.inSMaskMode) {
@@ -8393,31 +8258,28 @@ var _CanvasGraphics = class _CanvasGraphics {
   save() {
     if (this.inSMaskMode) {
       copyCtxState(this.ctx, this.suspendedCtx);
-      this.suspendedCtx.save();
-    } else {
-      this.ctx.save();
     }
+    this.ctx.save();
     const old = this.current;
     this.stateStack.push(old);
     this.current = old.clone();
   }
   restore() {
-    if (this.stateStack.length === 0 && this.inSMaskMode) {
-      this.endSMaskMode();
-    }
-    if (this.stateStack.length !== 0) {
-      this.current = this.stateStack.pop();
+    if (this.stateStack.length === 0) {
       if (this.inSMaskMode) {
-        this.suspendedCtx.restore();
-        copyCtxState(this.suspendedCtx, this.ctx);
-      } else {
-        this.ctx.restore();
+        this.endSMaskMode();
       }
-      this.checkSMaskState();
-      this.pendingClip = null;
-      this._cachedScaleForStroking[0] = -1;
-      this._cachedGetSinglePixelWidth = null;
+      return;
+    }
+    this.current = this.stateStack.pop();
+    this.ctx.restore();
+    if (this.inSMaskMode) {
+      copyCtxState(this.suspendedCtx, this.ctx);
     }
+    this.checkSMaskState();
+    this.pendingClip = null;
+    this._cachedScaleForStroking[0] = -1;
+    this._cachedGetSinglePixelWidth = null;
   }
   transform(a, b, c, d, e, f) {
     this.ctx.transform(a, b, c, d, e, f);
@@ -8425,145 +8287,60 @@ var _CanvasGraphics = class _CanvasGraphics {
     this._cachedGetSinglePixelWidth = null;
   }
   // Path
-  constructPath(ops, args, minMax) {
-    const ctx = this.ctx;
-    const current = this.current;
-    let x = current.x, y = current.y;
-    let startX, startY;
-    const currentTransform = getCurrentTransform(ctx);
-    const isScalingMatrix = currentTransform[0] === 0 && currentTransform[3] === 0 || currentTransform[1] === 0 && currentTransform[2] === 0;
-    const minMaxForBezier = isScalingMatrix ? minMax.slice(0) : null;
-    for (let i = 0, j = 0, ii = ops.length; i < ii; i++) {
-      switch (ops[i] | 0) {
-        case OPS.rectangle:
-          x = args[j++];
-          y = args[j++];
-          const width = args[j++];
-          const height = args[j++];
-          const xw = x + width;
-          const yh = y + height;
-          ctx.moveTo(x, y);
-          if (width === 0 || height === 0) {
-            ctx.lineTo(xw, yh);
-          } else {
-            ctx.lineTo(xw, y);
-            ctx.lineTo(xw, yh);
-            ctx.lineTo(x, yh);
-          }
-          if (!isScalingMatrix) {
-            current.updateRectMinMax(currentTransform, [x, y, xw, yh]);
-          }
-          ctx.closePath();
-          break;
-        case OPS.moveTo:
-          x = args[j++];
-          y = args[j++];
-          ctx.moveTo(x, y);
-          if (!isScalingMatrix) {
-            current.updatePathMinMax(currentTransform, x, y);
-          }
-          break;
-        case OPS.lineTo:
-          x = args[j++];
-          y = args[j++];
-          ctx.lineTo(x, y);
-          if (!isScalingMatrix) {
-            current.updatePathMinMax(currentTransform, x, y);
-          }
-          break;
-        case OPS.curveTo:
-          startX = x;
-          startY = y;
-          x = args[j + 4];
-          y = args[j + 5];
-          ctx.bezierCurveTo(
-            args[j],
-            args[j + 1],
-            args[j + 2],
-            args[j + 3],
-            x,
-            y
-          );
-          current.updateCurvePathMinMax(
-            currentTransform,
-            startX,
-            startY,
-            args[j],
-            args[j + 1],
-            args[j + 2],
-            args[j + 3],
-            x,
-            y,
-            minMaxForBezier
-          );
-          j += 6;
-          break;
-        case OPS.curveTo2:
-          startX = x;
-          startY = y;
-          ctx.bezierCurveTo(
-            x,
-            y,
-            args[j],
-            args[j + 1],
-            args[j + 2],
-            args[j + 3]
-          );
-          current.updateCurvePathMinMax(
-            currentTransform,
-            startX,
-            startY,
-            x,
-            y,
-            args[j],
-            args[j + 1],
-            args[j + 2],
-            args[j + 3],
-            minMaxForBezier
-          );
-          x = args[j + 2];
-          y = args[j + 3];
-          j += 4;
-          break;
-        case OPS.curveTo3:
-          startX = x;
-          startY = y;
-          x = args[j + 2];
-          y = args[j + 3];
-          ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
-          current.updateCurvePathMinMax(
-            currentTransform,
-            startX,
-            startY,
-            args[j],
-            args[j + 1],
-            x,
-            y,
-            x,
-            y,
-            minMaxForBezier
-          );
-          j += 4;
-          break;
-        case OPS.closePath:
-          ctx.closePath();
-          break;
-      }
+  constructPath(op, data, minMax) {
+    let [path] = data;
+    if (!minMax) {
+      path || (path = data[0] = new SvgPath2D());
+      this[op](path);
+      return;
     }
-    if (isScalingMatrix) {
-      current.updateScalingPathMinMax(currentTransform, minMaxForBezier);
+    if (!(path instanceof SvgPath2D)) {
+      const path2d = data[0] = new SvgPath2D();
+      for (let i = 0, ii = path.length; i < ii; ) {
+        switch (path[i++]) {
+          case DrawOPS.moveTo:
+            path2d.moveTo(path[i++], path[i++]);
+            break;
+          case DrawOPS.lineTo:
+            path2d.lineTo(path[i++], path[i++]);
+            break;
+          case DrawOPS.curveTo:
+            path2d.bezierCurveTo(
+              path[i++],
+              path[i++],
+              path[i++],
+              path[i++],
+              path[i++],
+              path[i++]
+            );
+            break;
+          case DrawOPS.closePath:
+            path2d.closePath();
+            break;
+          default:
+            warn(`Unrecognized drawing path operator: ${path[i - 1]}`);
+            break;
+        }
+      }
+      path = path2d;
     }
-    current.setCurrentPoint(x, y);
+    Util.axialAlignedBoundingBox(
+      minMax,
+      getCurrentTransform(this.ctx),
+      this.current.minMax
+    );
+    this[op](path);
   }
   closePath() {
     this.ctx.closePath();
   }
-  stroke(consumePath = true) {
+  stroke(path, consumePath = true) {
     const ctx = this.ctx;
     const strokeColor = this.current.strokeColor;
     ctx.globalAlpha = this.current.strokeAlpha;
     if (this.contentVisible) {
       if (typeof strokeColor === "object" && strokeColor?.getPattern) {
+        const baseTransform = strokeColor.isModifyingCurrentTransform() ? ctx.getTransform() : null;
         ctx.save();
         ctx.strokeStyle = strokeColor.getPattern(
           ctx,
@@ -8571,33 +8348,49 @@ var _CanvasGraphics = class _CanvasGraphics {
           getCurrentTransformInverse(ctx),
           PathType.STROKE
         );
+        if (baseTransform) {
+          const newPath = new SvgPath2D();
+          newPath.addPath(
+            path,
+            ctx.getTransform().invertSelf().multiplySelf(baseTransform)
+          );
+          path = newPath;
+        }
         this.rescaleAndStroke(
+          path,
           /* saveRestore */
           false
         );
         ctx.restore();
       } else {
         this.rescaleAndStroke(
+          path,
           /* saveRestore */
           true
         );
       }
     }
     if (consumePath) {
-      this.consumePath(this.current.getClippedPathBoundingBox());
+      this.consumePath(
+        path,
+        this.current.getClippedPathBoundingBox(
+          PathType.STROKE,
+          getCurrentTransform(this.ctx)
+        )
+      );
     }
     ctx.globalAlpha = this.current.fillAlpha;
   }
-  closeStroke() {
-    this.closePath();
-    this.stroke();
+  closeStroke(path) {
+    this.stroke(path);
   }
-  fill(consumePath = true) {
+  fill(path, consumePath = true) {
     const ctx = this.ctx;
     const fillColor = this.current.fillColor;
     const isPatternFill = this.current.patternFill;
     let needRestore = false;
     if (isPatternFill) {
+      const baseTransform = fillColor.isModifyingCurrentTransform() ? ctx.getTransform() : null;
       ctx.save();
       ctx.fillStyle = fillColor.getPattern(
         ctx,
@@ -8605,48 +8398,57 @@ var _CanvasGraphics = class _CanvasGraphics {
         getCurrentTransformInverse(ctx),
         PathType.FILL
       );
+      if (baseTransform) {
+        const newPath = new SvgPath2D();
+        newPath.addPath(
+          path,
+          ctx.getTransform().invertSelf().multiplySelf(baseTransform)
+        );
+        path = newPath;
+      }
       needRestore = true;
     }
     const intersect = this.current.getClippedPathBoundingBox();
     if (this.contentVisible && intersect !== null) {
       if (this.pendingEOFill) {
-        ctx.fill("evenodd");
+        ctx.fill(path, "evenodd");
         this.pendingEOFill = false;
       } else {
-        ctx.fill();
+        ctx.fill(path);
       }
     }
     if (needRestore) {
       ctx.restore();
     }
     if (consumePath) {
-      this.consumePath(intersect);
+      this.consumePath(path, intersect);
     }
   }
-  eoFill() {
+  eoFill(path) {
     this.pendingEOFill = true;
-    this.fill();
+    this.fill(path);
   }
-  fillStroke() {
-    this.fill(false);
-    this.stroke(false);
-    this.consumePath();
+  fillStroke(path) {
+    this.fill(path, false);
+    this.stroke(path, false);
+    this.consumePath(path);
   }
-  eoFillStroke() {
+  eoFillStroke(path) {
     this.pendingEOFill = true;
-    this.fillStroke();
+    this.fillStroke(path);
   }
-  closeFillStroke() {
-    this.closePath();
-    this.fillStroke();
+  closeFillStroke(path) {
+    this.fillStroke(path);
   }
-  closeEOFillStroke() {
+  closeEOFillStroke(path) {
     this.pendingEOFill = true;
-    this.closePath();
-    this.fillStroke();
+    this.fillStroke(path);
   }
-  endPath() {
-    this.consumePath();
+  endPath(path) {
+    this.consumePath(path);
+  }
+  rawFillPath(path) {
+    this.ctx.fill(path);
   }
   // Clipping
   clip() {
@@ -8657,7 +8459,7 @@ var _CanvasGraphics = class _CanvasGraphics {
   }
   // Text
   beginText() {
-    this.current.textMatrix = IDENTITY_MATRIX;
+    this.current.textMatrix = null;
     this.current.textMatrixScale = 1;
     this.current.x = this.current.lineX = 0;
     this.current.y = this.current.lineY = 0;
@@ -8666,7 +8468,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     const paths = this.pendingTextPaths;
     const ctx = this.ctx;
     if (paths === void 0) {
-      ctx.beginPath();
       return;
     }
     const newPath = new SvgPath2D();
@@ -8678,7 +8479,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       );
     }
     ctx.clip(newPath);
-    ctx.beginPath();
     delete this.pendingTextPaths;
   }
   setCharSpacing(spacing) {
@@ -8746,11 +8546,12 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.setLeading(-y);
     this.moveText(x, y);
   }
-  setTextMatrix(a, b, c, d, e, f) {
-    this.current.textMatrix = [a, b, c, d, e, f];
-    this.current.textMatrixScale = Math.hypot(a, b);
-    this.current.x = this.current.lineX = 0;
-    this.current.y = this.current.lineY = 0;
+  setTextMatrix(matrix) {
+    const { current } = this;
+    current.textMatrix = matrix;
+    current.textMatrixScale = Math.hypot(matrix[0], matrix[1]);
+    current.x = current.lineX = 0;
+    current.y = current.lineY = 0;
   }
   nextLine() {
     this.moveText(0, this.current.leading);
@@ -8797,8 +8598,8 @@ var _CanvasGraphics = class _CanvasGraphics {
             [a, b, c, d, 0, 0],
             invPatternTransform
           );
-          const [sx, sy] = Util.singularValueDecompose2dScale(transf);
-          ctx.lineWidth *= Math.max(sx, sy) / fontSize;
+          Util.singularValueDecompose2dScale(transf, XY);
+          ctx.lineWidth *= Math.max(XY[0], XY[1]) / fontSize;
           ctx.stroke(
             __privateMethod(this, _CanvasGraphics_instances, getScaledPath_fn).call(this, path, currentTransform, patternStrokeTransform)
           );
@@ -8868,7 +8669,9 @@ var _CanvasGraphics = class _CanvasGraphics {
     const widthAdvanceScale = fontSize * current.fontMatrix[0];
     const simpleFillText = current.textRenderingMode === TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
     ctx.save();
-    ctx.transform(...current.textMatrix);
+    if (current.textMatrix) {
+      ctx.transform(...current.textMatrix);
+    }
     ctx.translate(current.x, current.y + current.textRise);
     if (fontDirection > 0) {
       ctx.scale(textHScale, -1);
@@ -9023,7 +8826,9 @@ var _CanvasGraphics = class _CanvasGraphics {
     this._cachedScaleForStroking[0] = -1;
     this._cachedGetSinglePixelWidth = null;
     ctx.save();
-    ctx.transform(...current.textMatrix);
+    if (current.textMatrix) {
+      ctx.transform(...current.textMatrix);
+    }
     ctx.translate(current.x, current.y + current.textRise);
     ctx.scale(textHScale, fontDirection);
     for (i = 0; i < glyphsLength; ++i) {
@@ -9038,37 +8843,34 @@ var _CanvasGraphics = class _CanvasGraphics {
       const operatorList = font.charProcOperatorList[glyph.operatorListId];
       if (!operatorList) {
         warn(`Type3 character "${glyph.operatorListId}" is not available.`);
-        continue;
-      }
-      if (this.contentVisible) {
-        this.processingType3 = glyph;
+      } else if (this.contentVisible) {
         this.save();
         ctx.scale(fontSize, fontSize);
         ctx.transform(...fontMatrix);
         this.executeOperatorList(operatorList);
         this.restore();
       }
-      const transformed = Util.applyTransform([glyph.width, 0], fontMatrix);
-      width = transformed[0] * fontSize + spacing;
+      const p = [glyph.width, 0];
+      Util.applyTransform(p, fontMatrix);
+      width = p[0] * fontSize + spacing;
       ctx.translate(width, 0);
       current.x += width * textHScale;
     }
     ctx.restore();
-    this.processingType3 = null;
   }
   // Type3 fonts
   setCharWidth(xWidth, yWidth) {
   }
   setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
-    this.ctx.rect(llx, lly, urx - llx, ury - lly);
-    this.ctx.clip();
+    const clip = new SvgPath2D();
+    clip.rect(llx, lly, urx - llx, ury - lly);
+    this.ctx.clip(clip);
     this.endPath();
   }
   // Color
   getColorN_Pattern(IR) {
     let pattern;
     if (IR[0] === "TilingPattern") {
-      const color = IR[1];
       const baseTransform = this.baseTransform || getCurrentTransform(this.ctx);
       const canvasGraphicsFactory = {
         createCanvasGraphics: (ctx) => new _CanvasGraphics(
@@ -9085,7 +8887,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       };
       pattern = new TilingPattern(
         IR,
-        color,
         this.ctx,
         canvasGraphicsFactory,
         baseTransform
@@ -9152,10 +8953,9 @@ var _CanvasGraphics = class _CanvasGraphics {
     const inv = getCurrentTransformInverse(ctx);
     if (inv) {
       const { width, height } = ctx.canvas;
-      const [x0, y0, x1, y1] = Util.getAxialAlignedBoundingBox(
-        [0, 0, width, height],
-        inv
-      );
+      const minMax = MIN_MAX_INIT.slice();
+      Util.axialAlignedBoundingBox([0, 0, width, height], inv, minMax);
+      const [x0, y0, x1, y1] = minMax;
       this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
     } else {
       this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
@@ -9181,11 +8981,15 @@ var _CanvasGraphics = class _CanvasGraphics {
     }
     this.baseTransform = getCurrentTransform(this.ctx);
     if (bbox) {
-      const width = bbox[2] - bbox[0];
-      const height = bbox[3] - bbox[1];
-      this.ctx.rect(bbox[0], bbox[1], width, height);
-      this.current.updateRectMinMax(getCurrentTransform(this.ctx), bbox);
-      this.clip();
+      Util.axialAlignedBoundingBox(
+        bbox,
+        this.baseTransform,
+        this.current.minMax
+      );
+      const [x0, y0, x1, y1] = bbox;
+      const clip = new SvgPath2D();
+      clip.rect(x0, y0, x1 - x0, y1 - y0);
+      this.ctx.clip(clip);
       this.endPath();
     }
   }
@@ -9219,9 +9023,11 @@ var _CanvasGraphics = class _CanvasGraphics {
     if (!group.bbox) {
       throw new Error("Bounding box is required.");
     }
-    let bounds = Util.getAxialAlignedBoundingBox(
+    let bounds = MIN_MAX_INIT.slice();
+    Util.axialAlignedBoundingBox(
       group.bbox,
-      getCurrentTransform(currentCtx)
+      getCurrentTransform(currentCtx),
+      bounds
     );
     const canvasBounds = [
       0,
@@ -9247,6 +9053,15 @@ var _CanvasGraphics = class _CanvasGraphics {
     const groupCtx = scratchCanvas.context;
     groupCtx.translate(-offsetX, -offsetY);
     groupCtx.transform(...currentTransform);
+    let clip = new SvgPath2D();
+    const [x0, y0, x1, y1] = group.bbox;
+    clip.rect(x0, y0, x1 - x0, y1 - y0);
+    if (group.matrix) {
+      const path = new SvgPath2D();
+      path.addPath(clip, new DOMMatrix(group.matrix));
+      clip = path;
+    }
+    groupCtx.clip(clip);
     if (group.smask) {
       this.smaskStack.push({
         canvas: scratchCanvas.canvas,
@@ -9292,9 +9107,11 @@ var _CanvasGraphics = class _CanvasGraphics {
       this.restore();
       this.ctx.save();
       this.ctx.setTransform(...currentMtx);
-      const dirtyBox = Util.getAxialAlignedBoundingBox(
+      const dirtyBox = MIN_MAX_INIT.slice();
+      Util.axialAlignedBoundingBox(
         [0, 0, groupCtx.canvas.width, groupCtx.canvas.height],
-        currentMtx
+        currentMtx,
+        dirtyBox
       );
       this.ctx.drawImage(groupCtx.canvas, 0, 0);
       this.ctx.restore();
@@ -9320,9 +9137,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         rect[0] = rect[1] = 0;
         rect[2] = width;
         rect[3] = height;
-        const [scaleX, scaleY] = Util.singularValueDecompose2dScale(
-          getCurrentTransform(this.ctx)
-        );
+        Util.singularValueDecompose2dScale(getCurrentTransform(this.ctx), XY);
         const { viewportScale } = this;
         const canvasWidth = Math.ceil(
           width * this.outputScaleX * viewportScale
@@ -9339,14 +9154,14 @@ var _CanvasGraphics = class _CanvasGraphics {
         this.annotationCanvas.savedCtx = this.ctx;
         this.ctx = context;
         this.ctx.save();
-        this.ctx.setTransform(scaleX, 0, 0, -scaleY, 0, height * scaleY);
+        this.ctx.setTransform(XY[0], 0, 0, -XY[1], 0, height * XY[1]);
         resetCtxToDefault(this.ctx);
       } else {
         resetCtxToDefault(this.ctx);
         this.endPath();
-        this.ctx.rect(rect[0], rect[1], width, height);
-        this.ctx.clip();
-        this.ctx.beginPath();
+        const clip = new SvgPath2D();
+        clip.rect(rect[0], rect[1], width, height);
+        this.ctx.clip(clip);
       }
     }
     this.current = new CanvasExtraState(
@@ -9373,16 +9188,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     img = this.getObject(img.data, img);
     img.count = count;
     const ctx = this.ctx;
-    const glyph = this.processingType3;
-    if (glyph) {
-      if (glyph.compiled === void 0) {
-        glyph.compiled = compileType3Glyph(img);
-      }
-      if (glyph.compiled) {
-        glyph.compiled(ctx);
-        return;
-      }
-    }
     const mask = this._createMaskCanvas(img);
     const maskCanvas = mask.canvas;
     ctx.save();
@@ -9418,8 +9223,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         positions[i],
         positions[i + 1]
       ]);
-      const [x, y] = Util.applyTransform([0, 0], trans);
-      ctx.drawImage(mask.canvas, x, y);
+      ctx.drawImage(mask.canvas, trans[4], trans[5]);
     }
     ctx.restore();
     this.compose();
@@ -9536,11 +9340,9 @@ var _CanvasGraphics = class _CanvasGraphics {
     const height = imgData.height;
     const ctx = this.ctx;
     this.save();
-    if (!isNodeJS) {
-      const { filter } = ctx;
-      if (filter !== "none" && filter !== "") {
-        ctx.filter = "none";
-      }
+    const { filter } = ctx;
+    if (filter !== "none" && filter !== "") {
+      ctx.filter = "none";
     }
     ctx.scale(1 / width, -1 / height);
     let imgToPaint;
@@ -9656,7 +9458,7 @@ var _CanvasGraphics = class _CanvasGraphics {
   endCompat() {
   }
   // Helper functions
-  consumePath(clipBox) {
+  consumePath(path, clipBox) {
     const isEmpty = this.current.isEmptyClip();
     if (this.pendingClip) {
       this.current.updateClipFromPath();
@@ -9668,15 +9470,14 @@ var _CanvasGraphics = class _CanvasGraphics {
     if (this.pendingClip) {
       if (!isEmpty) {
         if (this.pendingClip === EO_CLIP) {
-          ctx.clip("evenodd");
+          ctx.clip(path, "evenodd");
         } else {
-          ctx.clip();
+          ctx.clip(path);
         }
       }
       this.pendingClip = null;
     }
     this.current.startNewPathAndClipBox(this.current.clipBox);
-    ctx.beginPath();
   }
   getSinglePixelWidth() {
     if (!this._cachedGetSinglePixelWidth) {
@@ -9736,13 +9537,15 @@ var _CanvasGraphics = class _CanvasGraphics {
   }
   // Rescale before stroking in order to have a final lineWidth
   // with both thicknesses greater or equal to 1.
-  rescaleAndStroke(saveRestore) {
-    const { ctx } = this;
-    const { lineWidth } = this.current;
+  rescaleAndStroke(path, saveRestore) {
+    const {
+      ctx,
+      current: { lineWidth }
+    } = this;
     const [scaleX, scaleY] = this.getScaleForStroking();
-    ctx.lineWidth = lineWidth || 1;
-    if (scaleX === 1 && scaleY === 1) {
-      ctx.stroke();
+    if (scaleX === scaleY) {
+      ctx.lineWidth = (lineWidth || 1) * scaleX;
+      ctx.stroke(path);
       return;
     }
     const dashes = ctx.getLineDash();
@@ -9750,12 +9553,17 @@ var _CanvasGraphics = class _CanvasGraphics {
       ctx.save();
     }
     ctx.scale(scaleX, scaleY);
+    SCALE_MATRIX.a = 1 / scaleX;
+    SCALE_MATRIX.d = 1 / scaleY;
+    const newPath = new SvgPath2D();
+    newPath.addPath(path, SCALE_MATRIX);
     if (dashes.length > 0) {
       const scale = Math.max(scaleX, scaleY);
       ctx.setLineDash(dashes.map((x) => x / scale));
       ctx.lineDashOffset /= scale;
     }
-    ctx.stroke();
+    ctx.lineWidth = lineWidth || 1;
+    ctx.stroke(newPath);
     if (saveRestore) {
       ctx.restore();
     }
@@ -11458,7 +11266,7 @@ var _TextLayer = class _TextLayer {
       throw new Error('No "textContentSource" parameter specified.');
     }
     __privateSet(this, _container3, __privateSet(this, _rootContainer, container));
-    __privateSet(this, _scale, viewport.scale * (globalThis.devicePixelRatio || 1));
+    __privateSet(this, _scale, viewport.scale * OutputScale.pixelRatio);
     __privateSet(this, _rotation, viewport.rotation);
     __privateSet(this, _layoutTextParams, {
       div: null,
@@ -11536,7 +11344,7 @@ var _TextLayer = class _TextLayer {
    */
   update({ viewport, onBefore = null }) {
     var _a2;
-    const scale = viewport.scale * (globalThis.devicePixelRatio || 1);
+    const scale = viewport.scale * OutputScale.pixelRatio;
     const rotation = viewport.rotation;
     if (rotation !== __privateGet(this, _rotation)) {
       onBefore?.();
@@ -11916,6 +11724,7 @@ function getDocument(src = {}) {
   const cMapUrl = getFactoryUrlProp(src.cMapUrl);
   const cMapPacked = src.cMapPacked !== false;
   const CMapReaderFactory = src.CMapReaderFactory || (isNodeJS ? NodeCMapReaderFactory : DOMCMapReaderFactory);
+  const iccUrl = getFactoryUrlProp(src.iccUrl);
   const standardFontDataUrl = getFactoryUrlProp(src.standardFontDataUrl);
   const StandardFontDataFactory2 = src.StandardFontDataFactory || (isNodeJS ? NodeStandardFontDataFactory : DOMStandardFontDataFactory);
   const wasmUrl = getFactoryUrlProp(src.wasmUrl);
@@ -11987,6 +11796,7 @@ function getDocument(src = {}) {
       useWasm,
       useWorkerFetch,
       cMapUrl,
+      iccUrl,
       standardFontDataUrl,
       wasmUrl
     }
@@ -12120,19 +11930,54 @@ function getFactoryUrlProp(val) {
   }
   throw new Error(`Invalid factory url: "${val}" must include trailing slash.`);
 }
-function isRefProxy(ref) {
-  return typeof ref === "object" && Number.isInteger(ref?.num) && ref.num >= 0 && Number.isInteger(ref?.gen) && ref.gen >= 0;
-}
+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() {
-    this._capability = Promise.withResolvers();
-    this._transport = null;
-    this._worker = null;
-    this.docId = `d${__privateWrapper(_PDFDocumentLoadingTask, _docId2)._++}`;
-    this.destroyed = false;
-    this.onPassword = null;
-    this.onProgress = null;
+    /**
+     * @private
+     */
+    __publicField(this, "_capability", Promise.withResolvers());
+    /**
+     * @private
+     */
+    __publicField(this, "_transport", null);
+    /**
+     * @private
+     */
+    __publicField(this, "_worker", null);
+    /**
+     * Unique identifier for the document loading task.
+     * @type {string}
+     */
+    __publicField(this, "docId", `d${__privateWrapper(_PDFDocumentLoadingTask, _docId2)._++}`);
+    /**
+     * Whether the loading task is destroyed or not.
+     * @type {boolean}
+     */
+    __publicField(this, "destroyed", false);
+    /**
+     * Callback to request a password if a wrong or no password was provided.
+     * The callback receives two parameters: a function that should be called
+     * with the new password, and a reason (see {@link PasswordResponses}).
+     * @type {function}
+     */
+    __publicField(this, "onPassword", null);
+    /**
+     * Callback to be able to monitor the loading progress of the PDF file
+     * (necessary to implement e.g. a loading bar).
+     * The callback receives an {@link OnProgressParameters} argument.
+     * @type {function}
+     */
+    __publicField(this, "onProgress", null);
   }
   /**
    * Promise for document loading task completion.
@@ -12167,6 +12012,15 @@ var _PDFDocumentLoadingTask = class _PDFDocumentLoadingTask {
     this._worker?.destroy();
     this._worker = null;
   }
+  /**
+   * Attempt to fetch the raw data of the PDF document, when e.g.
+   *  - An exception was thrown during document initialization.
+   *  - An `onPassword` callback is delaying initialization.
+   * @returns {Promise<Uint8Array>}
+   */
+  async getData() {
+    return this._transport.getData();
+  }
 };
 _docId2 = new WeakMap();
 __privateAdd(_PDFDocumentLoadingTask, _docId2, 0);
@@ -13343,6 +13197,7 @@ var _PDFWorker = class _PDFWorker {
   }
   /**
    * @param {PDFWorkerParameters} params - The worker initialization parameters.
+   * @returns {PDFWorker}
    */
   static fromPort(params) {
     if (false) {
@@ -13378,7 +13233,7 @@ 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 __non_webpack_import__(this.workerSrc);
+      const worker = true ? await import("./worker.js") : await __raw_import__(this.workerSrc);
       return worker.WorkerMessageHandler;
     };
     return shadow(this, "_setupFakeWorkerGlobal", loader());
@@ -17907,7 +17762,7 @@ var _FreeTextEditor = class _FreeTextEditor extends AnnotationEditor {
     __privateSet(this, _content, `${bufferBefore.join("\n")}${paste}${bufferAfter.join("\n")}`);
     __privateMethod(this, _FreeTextEditor_instances, setContent_fn).call(this);
     const newRange = new Range();
-    let beforeLength = bufferBefore.reduce((acc, line) => acc + line.length, 0);
+    let beforeLength = Math.sumPrecise(bufferBefore.map((line) => line.length));
     for (const { firstChild } of this.editorDiv.childNodes) {
       if (firstChild.nodeType === Node.TEXT_NODE) {
         const length = firstChild.nodeValue.length;
@@ -18757,35 +18612,24 @@ computeMinMax_fn = function(isLTR) {
   const outline = __privateGet(this, _outline);
   let lastX = outline[4];
   let lastY = outline[5];
-  let minX = lastX;
-  let minY = lastY;
-  let maxX = lastX;
-  let maxY = lastY;
+  const minMax = [lastX, lastY, lastX, lastY];
   let lastPointX = lastX;
   let lastPointY = lastY;
   const ltrCallback = isLTR ? Math.max : Math.min;
   for (let i = 6, ii = outline.length; i < ii; i += 6) {
+    const x = outline[i + 4], y = outline[i + 5];
     if (isNaN(outline[i])) {
-      minX = Math.min(minX, outline[i + 4]);
-      minY = Math.min(minY, outline[i + 5]);
-      maxX = Math.max(maxX, outline[i + 4]);
-      maxY = Math.max(maxY, outline[i + 5]);
-      if (lastPointY < outline[i + 5]) {
-        lastPointX = outline[i + 4];
-        lastPointY = outline[i + 5];
-      } else if (lastPointY === outline[i + 5]) {
-        lastPointX = ltrCallback(lastPointX, outline[i + 4]);
+      Util.pointBoundingBox(x, y, minMax);
+      if (lastPointY < y) {
+        lastPointX = x;
+        lastPointY = y;
+      } else if (lastPointY === y) {
+        lastPointX = ltrCallback(lastPointX, x);
       }
     } else {
-      const bbox2 = Util.bezierBoundingBox(
-        lastX,
-        lastY,
-        ...outline.slice(i, i + 6)
-      );
-      minX = Math.min(minX, bbox2[0]);
-      minY = Math.min(minY, bbox2[1]);
-      maxX = Math.max(maxX, bbox2[2]);
-      maxY = Math.max(maxY, bbox2[3]);
+      const bbox2 = [Infinity, Infinity, -Infinity, -Infinity];
+      Util.bezierBoundingBox(lastX, lastY, ...outline.slice(i, i + 6), bbox2);
+      Util.rectBoundingBox(...bbox2, minMax);
       if (lastPointY < bbox2[3]) {
         lastPointX = bbox2[2];
         lastPointY = bbox2[3];
@@ -18793,14 +18637,14 @@ computeMinMax_fn = function(isLTR) {
         lastPointX = ltrCallback(lastPointX, bbox2[2]);
       }
     }
-    lastX = outline[i + 4];
-    lastY = outline[i + 5];
+    lastX = x;
+    lastY = y;
   }
   const bbox = __privateGet(this, _bbox);
-  bbox[0] = minX - __privateGet(this, _innerMargin2);
-  bbox[1] = minY - __privateGet(this, _innerMargin2);
-  bbox[2] = maxX - minX + 2 * __privateGet(this, _innerMargin2);
-  bbox[3] = maxY - minY + 2 * __privateGet(this, _innerMargin2);
+  bbox[0] = minMax[0] - __privateGet(this, _innerMargin2);
+  bbox[1] = minMax[1] - __privateGet(this, _innerMargin2);
+  bbox[2] = minMax[2] - minMax[0] + 2 * __privateGet(this, _innerMargin2);
+  bbox[3] = minMax[3] - minMax[1] + 2 * __privateGet(this, _innerMargin2);
   this.lastPoint = [lastPointX, lastPointY];
 };
 
@@ -18825,10 +18669,7 @@ var HighlightOutliner = class {
     __privateAdd(this, _lastPoint);
     __privateAdd(this, _verticalEdges, []);
     __privateAdd(this, _intervals, []);
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
+    const minMax = [Infinity, Infinity, -Infinity, -Infinity];
     const NUMBER_OF_DIGITS = 4;
     const EPSILON = 10 ** -NUMBER_OF_DIGITS;
     for (const { x, y, width, height } of boxes) {
@@ -18839,15 +18680,12 @@ var HighlightOutliner = class {
       const left = [x1, y1, y2, true];
       const right = [x2, y1, y2, false];
       __privateGet(this, _verticalEdges).push(left, right);
-      minX = Math.min(minX, x1);
-      maxX = Math.max(maxX, x2);
-      minY = Math.min(minY, y1);
-      maxY = Math.max(maxY, y2);
-    }
-    const bboxWidth = maxX - minX + 2 * innerMargin;
-    const bboxHeight = maxY - minY + 2 * innerMargin;
-    const shiftedMinX = minX - innerMargin;
-    const shiftedMinY = minY - innerMargin;
+      Util.rectBoundingBox(x1, y1, x2, y2, minMax);
+    }
+    const bboxWidth = minMax[2] - minMax[0] + 2 * innerMargin;
+    const bboxHeight = minMax[3] - minMax[1] + 2 * innerMargin;
+    const shiftedMinX = minMax[0] - innerMargin;
+    const shiftedMinY = minMax[1] - innerMargin;
     const lastEdge = __privateGet(this, _verticalEdges).at(isLTR ? -1 : -2);
     const lastPoint = [lastEdge[0], lastEdge[2]];
     for (const edge of __privateGet(this, _verticalEdges)) {
@@ -19376,6 +19214,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
     __privateSet(this, _methodOfCreation, params.methodOfCreation || "");
     __privateSet(this, _text, params.text || "");
     this._isDraggable = false;
+    this.defaultL10nId = "pdfjs-editor-highlight-editor";
     if (params.highlightId > -1) {
       __privateSet(this, _isFreeHighlight, true);
       __privateMethod(this, _HighlightEditor_instances, createFreeOutlines_fn).call(this, params);
@@ -19890,6 +19729,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
         clipPathId
       });
       __privateMethod(_d = editor, _HighlightEditor_instances, addToDrawLayer_fn).call(_d);
+      editor.rotate(editor.parentRotation);
     }
     return editor;
   }
@@ -21799,11 +21639,7 @@ computeBbox_fn = function() {
   for (const { line } of __privateGet(this, _lines2)) {
     if (line.length <= 12) {
       for (let i = 4, ii = line.length; i < ii; i += 6) {
-        const [x, y] = line.subarray(i, i + 2);
-        bbox[0] = Math.min(bbox[0], x);
-        bbox[1] = Math.min(bbox[1], y);
-        bbox[2] = Math.max(bbox[2], x);
-        bbox[3] = Math.max(bbox[3], y);
+        Util.pointBoundingBox(line[i], line[i + 1], bbox);
       }
       continue;
     }
@@ -21816,10 +21652,10 @@ computeBbox_fn = function() {
     }
   }
   const [marginX, marginY] = __privateMethod(this, _InkDrawOutline_instances, getMarginComponents_fn).call(this);
-  bbox[0] = Math.min(1, Math.max(0, bbox[0] - marginX));
-  bbox[1] = Math.min(1, Math.max(0, bbox[1] - marginY));
-  bbox[2] = Math.min(1, Math.max(0, bbox[2] + marginX));
-  bbox[3] = Math.min(1, Math.max(0, bbox[3] + marginY));
+  bbox[0] = MathClamp(bbox[0] - marginX, 0, 1);
+  bbox[1] = MathClamp(bbox[1] - marginY, 0, 1);
+  bbox[2] = MathClamp(bbox[2] + marginX, 0, 1);
+  bbox[3] = MathClamp(bbox[3] + marginY, 0, 1);
   bbox[2] -= bbox[0];
   bbox[3] -= bbox[1];
 };
@@ -21873,6 +21709,7 @@ var _InkEditor = class _InkEditor extends DrawingEditor {
     super({ ...params, name: "inkEditor" });
     __privateAdd(this, _InkEditor_instances);
     this._willKeepAspectRatio = true;
+    this.defaultL10nId = "pdfjs-editor-ink-editor";
   }
   /** @inheritdoc */
   static initialize(l10n, uiManager) {
@@ -22766,6 +22603,7 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
     this._willKeepAspectRatio = true;
     __privateSet(this, _signatureData, params.signatureData || null);
     __privateSet(this, _description, null);
+    this.defaultL10nId = "pdfjs-editor-signature-editor1";
   }
   /** @inheritdoc */
   static initialize(l10n, uiManager) {
@@ -22829,7 +22667,6 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
       baseY = this.y;
     }
     super.render();
-    this.div.setAttribute("role", "figure");
     if (this._drawId === null) {
       if (__privateGet(this, _signatureData)) {
         const {
@@ -22855,6 +22692,10 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
         });
         this.addSignature(outline, heightInPage, description, uuid);
       } else {
+        this.div.setAttribute(
+          "data-l10n-args",
+          JSON.stringify({ description: "" })
+        );
         this.div.hidden = true;
         this._uiManager.getSignature(this);
       }
@@ -22921,6 +22762,7 @@ var _SignatureEditor = class _SignatureEditor extends DrawingEditor {
     const { outline } = __privateSet(this, _signatureData, data);
     __privateSet(this, _isExtracted, outline instanceof ContourDrawOutline);
     __privateSet(this, _description, description);
+    this.div.setAttribute("data-l10n-args", JSON.stringify({ description }));
     let drawingOptions;
     if (__privateGet(this, _isExtracted)) {
       drawingOptions = _SignatureEditor.getDefaultDrawingOptions();
@@ -23101,6 +22943,7 @@ var StampEditor = class extends AnnotationEditor {
     __privateAdd(this, _hasBeenAddedInUndoStack, false);
     __privateSet(this, _bitmapUrl, params.bitmapUrl);
     __privateSet(this, _bitmapFile, params.bitmapFile);
+    this.defaultL10nId = "pdfjs-editor-stamp-editor";
   }
   /** @inheritdoc */
   static initialize(l10n, uiManager) {
@@ -23242,7 +23085,6 @@ var StampEditor = class extends AnnotationEditor {
     }
     super.render();
     this.div.hidden = true;
-    this.div.setAttribute("role", "figure");
     this.addAltTextButton();
     if (!__privateGet(this, _missingCanvas)) {
       if (__privateGet(this, _bitmap)) {
@@ -23390,10 +23232,6 @@ var StampEditor = class extends AnnotationEditor {
     return { canvas, width, height, imageData };
   }
   /** @inheritdoc */
-  getImageForAltText() {
-    return __privateGet(this, _canvas);
-  }
-  /** @inheritdoc */
   static async deserialize(data, parent, uiManager) {
     let initialData = null;
     let missingCanvas = false;
@@ -23709,7 +23547,7 @@ createCanvas_fn = function() {
     action: "inserted_image"
   });
   if (__privateGet(this, _bitmapFileName)) {
-    canvas.setAttribute("aria-label", __privateGet(this, _bitmapFileName));
+    this.div.setAttribute("aria-description", __privateGet(this, _bitmapFileName));
   }
 };
 scaleBitmap_fn = function(width, height) {
@@ -24832,319 +24670,39 @@ if (false) {
   };
 }
 
-// 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");
+// src/lib/AnnotationOperatorsList.ts
+var AnnotationOperatorsList = class {
+  /**
+   * The list of operators to be executed.
+   * @param operatorList The list of operators to be executed.
+   */
+  constructor(operatorList) {
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+    let currentId = null;
+    let currentList = [];
+    for (const [index, op] of operatorList.fnArray.entries()) {
+      const args = operatorList.argsArray[index];
+      if (op === OPS.beginAnnotation) {
+        currentId = args[0];
+        currentList.push({ fn: op, args });
+      } else if (op === OPS.endAnnotation && currentId) {
+        currentList.push({ fn: op, args });
+        this.map.set(currentId, currentList);
+        currentList = [];
+      } else if (currentId) {
+        currentList.push({ fn: op, args });
+      }
     }
-    return new Uint8Array(await blob.arrayBuffer());
   }
-  return canvas.encode("png");
-}
-async function toDataUrl(data) {
-  if (typeof FileReader !== "undefined") {
-    return new Promise((resolve) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        resolve(reader.result);
-      };
-      reader.readAsDataURL(new Blob([data], { type: "image/png" }));
-    });
+  /**
+   * Get the list of operators for the given annotation id.
+   * @param id The id of the annotation.
+   * @return The list of operators for the given annotation id.
+   */
+  get(id) {
+    return this.map.get(id) ?? [];
   }
-  return `data:image/png;base64,${Buffer.from(data).toString("base64")}`;
-}
-
-// src/lib/PDFPageProxy.ts
-var getAnnotations = PDFPageProxy.prototype.getAnnotations;
-PDFPageProxy.prototype.getAnnotations = async function(params) {
-  const annotations = await getAnnotations.call(this, params);
-  const operatorList = await this.getOperatorList({
-    annotationMode: AnnotationMode.ENABLE_FORMS
-  });
-  const annotationsOperatorList = /* @__PURE__ */ new Map();
-  let currentId = null;
-  let currentList = [];
-  for (const [index, op] of operatorList.fnArray.entries()) {
-    const args = operatorList.argsArray[index];
-    if (op === OPS.beginAnnotation) {
-      currentId = args[0];
-      currentList.push({ fn: op, args });
-    } else if (op === OPS.endAnnotation && currentId) {
-      currentList.push({ fn: op, args });
-      annotationsOperatorList.set(currentId, currentList);
-      currentList = [];
-    } else if (currentId) {
-      currentList.push({ fn: op, args });
-    }
-  }
-  for (const annotation of annotations) {
-    const opList = annotationsOperatorList.get(annotation.id);
-    if (opList) {
-      if (annotation.subtype === "Stamp") {
-        try {
-          const canvasFactory = isNodeJS ? new NodeCanvasFactory({}) : new DOMCanvasFactory({});
-          const scale = 2;
-          const viewport = this.getViewport({ scale });
-          const { context: canvasContext } = canvasFactory.create(
-            viewport.width,
-            viewport.height
-          );
-          const gsx = new CanvasGraphics(
-            canvasContext,
-            this.commonObjs,
-            this.objs,
-            canvasFactory,
-            this.filterFactory,
-            { optionalContentConfig: null }
-          );
-          gsx.beginDrawing({
-            transform: null,
-            viewport
-          });
-          canvasContext.clearRect(0, 0, viewport.width, viewport.height);
-          gsx.executeOperatorList({
-            fnArray: opList.map((op) => op.fn),
-            argsArray: opList.map((op) => op.args)
-          });
-          const width = annotation.rect[2] - annotation.rect[0];
-          const height = annotation.rect[3] - annotation.rect[1];
-          const { context: croppedCanvasContext } = canvasFactory.create(
-            width * scale,
-            height * scale
-          );
-          croppedCanvasContext.drawImage(
-            canvasContext.canvas,
-            annotation.rect[0] * scale,
-            (this.view[3] - annotation.rect[1] - height) * scale,
-            width * scale,
-            height * scale,
-            0,
-            0,
-            width * scale,
-            height * scale
-          );
-          annotation.graphics = await canvasToData(croppedCanvasContext.canvas);
-        } catch (e) {
-          console.error(e);
-        }
-      } else {
-        let firstStroke = true;
-        let firstFill = true;
-        let currentFillColor = null;
-        let currentLineWidth = null;
-        for (const { fn, args } of opList) {
-          if (fn === OPS.fill) {
-            if (currentFillColor) {
-              annotation.interiorColor = currentFillColor;
-              currentFillColor = null;
-            }
-            firstFill = false;
-            continue;
-          }
-          if (fn === OPS.beginText) {
-            firstFill = false;
-            continue;
-          }
-          if (fn === OPS.stroke) {
-            if (currentLineWidth === null) {
-              annotation.borderStyle.width = 1;
-            }
-            firstStroke = false;
-            currentLineWidth = null;
-            continue;
-          }
-          if (fn === OPS.fillStroke) {
-            if (currentFillColor) {
-              annotation.interiorColor = currentFillColor;
-              currentFillColor = null;
-            }
-            if (currentLineWidth === null) {
-              annotation.borderStyle.width = 1;
-            }
-            firstStroke = false;
-            currentLineWidth = null;
-            break;
-          }
-          if (!firstFill && !firstStroke) {
-            break;
-          }
-          if (fn === OPS.setLineWidth && firstStroke) {
-            currentLineWidth = args[0];
-            annotation.borderStyle.width = currentLineWidth;
-          }
-          if (fn === OPS.setStrokeRGBColor && firstStroke) {
-            if (!annotation.borderStyle.width) {
-              annotation.borderStyle.width = 1;
-            }
-            annotation.color = args;
-          }
-          if (fn === OPS.setFillRGBColor && firstFill) {
-            currentFillColor = args;
-          }
-          if (fn === OPS.setGState) {
-            for (const entry of args[0]) {
-              if (!Array.isArray(entry)) {
-                continue;
-              }
-              if (entry[0] === "ca" && firstFill) {
-                annotation.interiorColorOpacity = entry[1];
-              }
-              if (entry[0] === "CA" && firstStroke) {
-                annotation.borderColorOpacity = entry[1];
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return annotations;
-};
-
-// src/lib/StandardFontDataFactory.ts
-var StandardFontDataFactory = class extends BaseStandardFontDataFactory {
-  constructor() {
-    super({
-      baseUrl: null
-    });
-  }
-  /**
-   * Fetch the corresponding standard font data.
-   * We need to use specific dynamic imports for each font file for the bundler to include them.
-   */
-  async fetch({ filename }) {
-    switch (filename) {
-      case "FoxitDingbats.pfb":
-        return import("./FoxitDingbats-65AZ2Z2V.js").then((module) => module.default);
-      case "FoxitFixed.pfb":
-        return import("./FoxitFixed-OZGLVVOQ.js").then(
-          (module) => module.default
-        );
-      case "FoxitFixedBold.pfb":
-        return import("./FoxitFixedBold-37OOYMV7.js").then((module) => module.default);
-      case "FoxitFixedBoldItalic.pfb":
-        return import("./FoxitFixedBoldItalic-XYFHEG2V.js").then((module) => module.default);
-      case "FoxitFixedItalic.pfb":
-        return import("./FoxitFixedItalic-MM7OSGS6.js").then((module) => module.default);
-      case "FoxitSerif.pfb":
-        return import("./FoxitSerif-MLMJQPRP.js").then(
-          (module) => module.default
-        );
-      case "FoxitSerifBold.pfb":
-        return import("./FoxitSerifBold-AC7RJQWJ.js").then((module) => module.default);
-      case "FoxitSerifBoldItalic.pfb":
-        return import("./FoxitSerifBoldItalic-YCQ4CLKE.js").then((module) => module.default);
-      case "FoxitSerifItalic.pfb":
-        return import("./FoxitSerifItalic-CXVTCST4.js").then((module) => module.default);
-      case "FoxitSymbol.pfb":
-        return import("./FoxitSymbol-VUGMZN5C.js").then(
-          (module) => module.default
-        );
-      case "LiberationSans-Bold.ttf":
-        return import("./LiberationSans-Bold-XSHQQBWB.js").then((module) => module.default);
-      case "LiberationSans-BoldItalic.ttf":
-        return import("./LiberationSans-BoldItalic-CTAZRFRL.js").then((module) => module.default);
-      case "LiberationSans-Italic.ttf":
-        return import("./LiberationSans-Italic-WIOTUKLC.js").then((module) => module.default);
-      case "LiberationSans-Regular.ttf":
-        return import("./LiberationSans-Regular-CDMMZL5S.js").then((module) => module.default);
-    }
-    return Uint8Array.from([]);
-  }
-};
-
-// src/lib/AnnotationData.ts
-function isTextAnnotation(annotation) {
-  return annotation.subtype === "Text";
-}
-function isLinkAnnotation(annotation) {
-  return annotation.subtype === "Link";
-}
-function isFreeTextAnnotation(annotation) {
-  return annotation.subtype === "FreeText";
-}
-function isLineAnnotation(annotation) {
-  return annotation.subtype === "Line";
-}
-function isSquareAnnotation(annotation) {
-  return annotation.subtype === "Square";
-}
-function isCircleAnnotation(annotation) {
-  return annotation.subtype === "Circle";
-}
-function isPolygonAnnotation(annotation) {
-  return annotation.subtype === "Polygon";
-}
-function isPolylineAnnotation(annotation) {
-  return annotation.subtype === "PolyLine";
-}
-function isHighlightAnnotation(annotation) {
-  return annotation.subtype === "Highlight";
-}
-function isUnderlineAnnotation(annotation) {
-  return annotation.subtype === "Underline";
-}
-function isSquigglyAnnotation(annotation) {
-  return annotation.subtype === "Squiggly";
-}
-function isStrikeOutAnnotation(annotation) {
-  return annotation.subtype === "StrikeOut";
-}
-function isStampAnnotation(annotation) {
-  return annotation.subtype === "Stamp";
-}
-function isCaretAnnotation(annotation) {
-  return annotation.subtype === "Caret";
-}
-function isInkAnnotation(annotation) {
-  return annotation.subtype === "Ink";
-}
-function isPopupAnnotation(annotation) {
-  return annotation.subtype === "Popup";
-}
-function isFileAttachmentAnnotation(annotation) {
-  return annotation.subtype === "FileAttachment";
-}
-function isSoundAnnotation(annotation) {
-  return annotation.subtype === "Sound";
-}
-function isMovieAnnotation(annotation) {
-  return annotation.subtype === "Movie";
-}
-function isWidgetAnnotation(annotation) {
-  return annotation.subtype === "Widget";
-}
-function isTextWidgetAnnotation(annotation) {
-  return annotation.subtype === "Widget" && annotation.fieldType === "Tx";
-}
-function isChoiceWidgetAnnotation(annotation) {
-  return annotation.subtype === "Widget" && annotation.fieldType === "Ch";
-}
-function isButtonWidgetAnnotation(annotation) {
-  return annotation.subtype === "Widget" && annotation.fieldType === "Btn";
-}
-function isScreenAnnotation(annotation) {
-  return annotation.subtype === "Screen";
-}
-function isPrinterMarkAnnotation(annotation) {
-  return annotation.subtype === "PrinterMark";
-}
-function isTrapNetAnnotation(annotation) {
-  return annotation.subtype === "TrapNet";
-}
-function isWatermarkAnnotation(annotation) {
-  return annotation.subtype === "Watermark";
-}
-function isThreeDAnnotation(annotation) {
-  return annotation.subtype === "3D";
-}
-function isRedactAnnotation(annotation) {
-  return annotation.subtype === "Redact";
-}
+};
 
 // src/lib/SvgCanvasContext.ts
 function parseTransformMatrix(transformString) {
@@ -25439,19 +24997,33 @@ var SvgCanvasContext = class {
     this._styleStack.push(this._getStyleState());
     this._transformMatrixStack.push(this.getTransform());
   }
+  clearRect(x, y, width, height) {
+    if (x !== 0 || y !== 0 || this._width !== width || this._height !== height) {
+      throw new Error("clearRect is not supported in SVG");
+    }
+    this._clearCanvas();
+  }
   restore() {
-    const group = this._groupStack.pop();
-    if (!this._isTransformationGroup(this._currentGroup)) {
-      group.children = group.children.filter(
-        (child) => child !== this._currentGroup
-      );
-      group.children.push(...this._currentGroup.children);
+    if (this._groupStack.length) {
+      const group = this._groupStack.pop();
+      if (!this._isTransformationGroup(this._currentGroup)) {
+        group.children = group.children.filter(
+          (child) => child !== this._currentGroup
+        );
+        group.children.push(...this._currentGroup.children);
+      }
+      this._currentGroup = group;
+    } else {
+      this._currentGroup = this._root;
+    }
+    if (this._styleStack.length) {
+      const state = this._styleStack.pop();
+      this._applyStyleState(state);
+    }
+    if (this._transformMatrixStack.length) {
+      const { a, b, c, d, e, f } = this._transformMatrixStack.pop();
+      this.setTransform(a, b, c, d, e, f);
     }
-    this._currentGroup = group;
-    const state = this._styleStack.pop();
-    this._applyStyleState(state);
-    const { a, b, c, d, e, f } = this._transformMatrixStack.pop();
-    this.setTransform(a, b, c, d, e, f);
   }
   beginPath() {
     this._currentPosition = {};
@@ -25622,8 +25194,25 @@ var SvgCanvasContext = class {
     );
     this._currentPosition = { x: endX, y: endY };
   }
-  stroke() {
-    if (this._currentElement) {
+  stroke(path) {
+    if (path instanceof SvgPath2D) {
+      const d = toCommands(path);
+      if (d && d !== "Z") {
+        const parent = this._currentGroup;
+        const pathElement = {
+          tag: "path",
+          attrs: {
+            d,
+            fill: "none",
+            stroke: "none",
+            "stroke-width": "0"
+          }
+        };
+        this._applyTransformation(pathElement);
+        this._applyStyle(pathElement, "stroke");
+        parent.children.push(pathElement);
+      }
+    } else if (this._currentElement) {
       this._applyStyle(this._currentElement, "stroke");
     }
   }
@@ -25772,6 +25361,9 @@ var SvgCanvasContext = class {
       const fillRuleValue = fillRule ?? path;
       this._currentStyle.fillRule = fillRuleValue;
     }
+    if (path instanceof SvgPath2D && path.commands.length === 0) {
+      return;
+    }
     const id = `clip_${crypto.randomUUID()}`;
     const clipPath = {
       tag: "clipPath",
@@ -25934,7 +25526,6 @@ var SvgCanvasContext = class {
       }
     } else {
       const strokeStyle = this._currentStyle.strokeStyle;
-      const lineWidth = this._currentStyle.lineWidth * Math.max(scale.x, scale.y);
       if (strokeStyle instanceof SvgPattern) {
         const path = transformPath(commands, transform);
         const bbox = calculateBoundingBox(path);
@@ -25965,9 +25556,7 @@ var SvgCanvasContext = class {
         currentElement.attrs["stroke-miterlimit"] = `${this._currentStyle.miterLimit}`;
       }
       if (this._currentStyle.lineWidth !== 1) {
-        currentElement.attrs["stroke-width"] = `${lineWidth}`;
-      } else {
-        currentElement.attrs["vector-effect"] = "non-scaling-stroke";
+        currentElement.attrs["stroke-width"] = `${this._currentStyle.lineWidth}`;
       }
       if (this._currentStyle.lineDash.length > 0) {
         currentElement.attrs["stroke-dasharray"] = `${this._currentStyle.lineDash.map((entry) => `${entry * Math.max(scale.x, scale.y)}`).join(",")}`;
@@ -26011,21 +25600,13 @@ var SvgCanvasContext = class {
     parent.children.push(textElement);
   }
   _clearCanvas() {
-    const rootGroup = this._root.children[1];
     this._defs.children = [];
-    this._root.children = this._root.children.filter(
-      (child) => child === rootGroup
-    );
-    this._currentGroup = {
-      tag: "g",
-      attrs: {},
-      children: []
-    };
-    this._root.children.push(this._currentGroup);
+    this._root.children = [this._defs];
+    this._currentGroup = this._root;
     this._groupStack = [];
   }
 };
-async function createContext(width, height) {
+async function createSvgContext(width, height) {
   const canvas = await createCanvas(width, height);
   return new SvgCanvasContext(
     width,
@@ -26040,6 +25621,359 @@ 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) {
+  const annotations = await getAnnotations.call(this, params);
+  const operatorList = await this.getOperatorList({
+    annotationMode: AnnotationMode.ENABLE_FORMS
+  });
+  const annotationOperatorsList = new AnnotationOperatorsList(operatorList);
+  for (const annotation of annotations) {
+    const opList = annotationOperatorsList.get(annotation.id);
+    if (opList) {
+      if (annotation.subtype === "Stamp") {
+        try {
+          const canvasFactory = isNodeJS ? new NodeCanvasFactory({}) : new DOMCanvasFactory({});
+          const scale = 2;
+          const viewport = this.getViewport({ scale });
+          const svgContext = await createSvgContext(
+            viewport.width,
+            viewport.height
+          );
+          const gsx = new CanvasGraphics(
+            svgContext,
+            this.commonObjs,
+            this.objs,
+            canvasFactory,
+            this.filterFactory,
+            { optionalContentConfig: null }
+          );
+          gsx.beginDrawing({
+            transform: null,
+            viewport
+          });
+          svgContext.clearRect(0, 0, viewport.width, viewport.height);
+          gsx.executeOperatorList({
+            fnArray: opList.map((op) => op.fn),
+            argsArray: opList.map((op) => op.args)
+          });
+          const width = annotation.rect[2] - annotation.rect[0];
+          const height = annotation.rect[3] - annotation.rect[1];
+          annotation.graphics = {
+            tag: "svg",
+            attrs: {
+              version: "1.1",
+              xmlns: "http://www.w3.org/2000/svg",
+              width: `${width}`,
+              height: `${height}`,
+              viewBox: `0 0 ${width * scale} ${height * scale}`,
+              preserveAspectRatio: "none",
+              "xml:space": "preserve"
+            },
+            children: [
+              {
+                tag: "g",
+                attrs: {
+                  transform: `translate(-${annotation.rect[0] * scale}, -${(this.view[3] - annotation.rect[1] - height) * scale})`
+                },
+                children: [await toSvgNode(svgContext)]
+              }
+            ]
+          };
+        } catch (e) {
+          console.error(e);
+        }
+      } else {
+        switch (annotation.subtype) {
+          case "Square":
+          case "Circle":
+          case "Polygon":
+          case "Line":
+          case "PolyLine":
+          case "FreeText":
+          case "Ink": {
+            let firstStroke = true;
+            let firstFill = true;
+            let firstText = true;
+            let currentFillColor = null;
+            let currentLineWidth = null;
+            for (const { fn, args } of opList) {
+              const finalFn = fn === OPS.constructPath ? args[0] : fn;
+              if (finalFn === OPS.fill) {
+                if (currentFillColor && firstFill) {
+                  annotation.interiorColor = currentFillColor;
+                  currentFillColor = null;
+                }
+                firstFill = false;
+                continue;
+              }
+              if (fn === OPS.beginText) {
+                if (firstFill) {
+                  annotation.interiorColor = null;
+                }
+                firstFill = false;
+                currentFillColor = null;
+                continue;
+              }
+              if (finalFn === OPS.stroke || finalFn === OPS.closeStroke) {
+                if (currentLineWidth === null && firstStroke) {
+                  annotation.borderStyle.width = 1;
+                }
+                firstStroke = false;
+                currentLineWidth = null;
+                continue;
+              }
+              if (finalFn === OPS.fillStroke || finalFn === OPS.closeFillStroke) {
+                if (currentFillColor && firstFill) {
+                  annotation.interiorColor = currentFillColor;
+                }
+                if (currentLineWidth === null && firstStroke) {
+                  annotation.borderStyle.width = 1;
+                }
+                firstFill = false;
+                firstStroke = false;
+                currentFillColor = null;
+                currentLineWidth = null;
+                break;
+              }
+              if (!firstFill && !firstStroke) {
+                break;
+              }
+              if (fn === OPS.setLineWidth && firstStroke) {
+                currentLineWidth = args[0];
+                annotation.borderStyle.width = currentLineWidth;
+              }
+              if (fn === OPS.setStrokeRGBColor && firstStroke) {
+                annotation.color = args;
+              }
+              if (fn === OPS.setFillRGBColor && firstFill) {
+                currentFillColor = args;
+              }
+              if (fn === OPS.setGState) {
+                for (const entry of args[0]) {
+                  if (!Array.isArray(entry)) {
+                    continue;
+                  }
+                  if (entry[0] === "ca" && firstFill) {
+                    annotation.interiorColorOpacity = entry[1];
+                  }
+                  if (entry[0] === "CA" && firstStroke) {
+                    annotation.borderColorOpacity = entry[1];
+                  }
+                }
+              }
+              if (fn === OPS.setFont && firstText) {
+                const fontName = args[0];
+                const font = fontName.startsWith("g_") ? this.commonObjs.get(fontName) : this.objs.get(fontName);
+                if (font) {
+                  annotation.defaultAppearanceData.fontName = font.fallbackName;
+                }
+              }
+              if (fn === OPS.endText) {
+                firstText = false;
+              }
+            }
+            if (firstStroke) {
+              annotation.borderStyle.width = 0;
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  return makeSerializable(annotations);
+};
+
+// src/lib/StandardFontDataFactory.ts
+var StandardFontDataFactory = class extends BaseStandardFontDataFactory {
+  constructor() {
+    super({
+      baseUrl: null
+    });
+  }
+  /**
+   * Fetch the corresponding standard font data.
+   * We need to use specific dynamic imports for each font file for the bundler to include them.
+   */
+  async fetch({ filename }) {
+    switch (filename) {
+      case "FoxitDingbats.pfb":
+        return import("./FoxitDingbats-65AZ2Z2V.js").then((module) => module.default);
+      case "FoxitFixed.pfb":
+        return import("./FoxitFixed-OZGLVVOQ.js").then(
+          (module) => module.default
+        );
+      case "FoxitFixedBold.pfb":
+        return import("./FoxitFixedBold-37OOYMV7.js").then((module) => module.default);
+      case "FoxitFixedBoldItalic.pfb":
+        return import("./FoxitFixedBoldItalic-XYFHEG2V.js").then((module) => module.default);
+      case "FoxitFixedItalic.pfb":
+        return import("./FoxitFixedItalic-MM7OSGS6.js").then((module) => module.default);
+      case "FoxitSerif.pfb":
+        return import("./FoxitSerif-MLMJQPRP.js").then(
+          (module) => module.default
+        );
+      case "FoxitSerifBold.pfb":
+        return import("./FoxitSerifBold-AC7RJQWJ.js").then((module) => module.default);
+      case "FoxitSerifBoldItalic.pfb":
+        return import("./FoxitSerifBoldItalic-YCQ4CLKE.js").then((module) => module.default);
+      case "FoxitSerifItalic.pfb":
+        return import("./FoxitSerifItalic-CXVTCST4.js").then((module) => module.default);
+      case "FoxitSymbol.pfb":
+        return import("./FoxitSymbol-VUGMZN5C.js").then(
+          (module) => module.default
+        );
+      case "LiberationSans-Bold.ttf":
+        return import("./LiberationSans-Bold-XSHQQBWB.js").then((module) => module.default);
+      case "LiberationSans-BoldItalic.ttf":
+        return import("./LiberationSans-BoldItalic-CTAZRFRL.js").then((module) => module.default);
+      case "LiberationSans-Italic.ttf":
+        return import("./LiberationSans-Italic-WIOTUKLC.js").then((module) => module.default);
+      case "LiberationSans-Regular.ttf":
+        return import("./LiberationSans-Regular-CDMMZL5S.js").then((module) => module.default);
+    }
+    return Uint8Array.from([]);
+  }
+};
+
+// src/lib/AnnotationData.ts
+function isTextAnnotation(annotation) {
+  return annotation.subtype === "Text";
+}
+function isLinkAnnotation(annotation) {
+  return annotation.subtype === "Link";
+}
+function isFreeTextAnnotation(annotation) {
+  return annotation.subtype === "FreeText";
+}
+function isLineAnnotation(annotation) {
+  return annotation.subtype === "Line";
+}
+function isSquareAnnotation(annotation) {
+  return annotation.subtype === "Square";
+}
+function isCircleAnnotation(annotation) {
+  return annotation.subtype === "Circle";
+}
+function isPolygonAnnotation(annotation) {
+  return annotation.subtype === "Polygon";
+}
+function isPolylineAnnotation(annotation) {
+  return annotation.subtype === "PolyLine";
+}
+function isHighlightAnnotation(annotation) {
+  return annotation.subtype === "Highlight";
+}
+function isUnderlineAnnotation(annotation) {
+  return annotation.subtype === "Underline";
+}
+function isSquigglyAnnotation(annotation) {
+  return annotation.subtype === "Squiggly";
+}
+function isStrikeOutAnnotation(annotation) {
+  return annotation.subtype === "StrikeOut";
+}
+function isStampAnnotation(annotation) {
+  return annotation.subtype === "Stamp";
+}
+function isCaretAnnotation(annotation) {
+  return annotation.subtype === "Caret";
+}
+function isInkAnnotation(annotation) {
+  return annotation.subtype === "Ink";
+}
+function isPopupAnnotation(annotation) {
+  return annotation.subtype === "Popup";
+}
+function isFileAttachmentAnnotation(annotation) {
+  return annotation.subtype === "FileAttachment";
+}
+function isSoundAnnotation(annotation) {
+  return annotation.subtype === "Sound";
+}
+function isMovieAnnotation(annotation) {
+  return annotation.subtype === "Movie";
+}
+function isWidgetAnnotation(annotation) {
+  return annotation.subtype === "Widget";
+}
+function isTextWidgetAnnotation(annotation) {
+  return annotation.subtype === "Widget" && annotation.fieldType === "Tx";
+}
+function isChoiceWidgetAnnotation(annotation) {
+  return annotation.subtype === "Widget" && annotation.fieldType === "Ch";
+}
+function isButtonWidgetAnnotation(annotation) {
+  return annotation.subtype === "Widget" && annotation.fieldType === "Btn";
+}
+function isScreenAnnotation(annotation) {
+  return annotation.subtype === "Screen";
+}
+function isPrinterMarkAnnotation(annotation) {
+  return annotation.subtype === "PrinterMark";
+}
+function isTrapNetAnnotation(annotation) {
+  return annotation.subtype === "TrapNet";
+}
+function isWatermarkAnnotation(annotation) {
+  return annotation.subtype === "Watermark";
+}
+function isThreeDAnnotation(annotation) {
+  return annotation.subtype === "3D";
+}
+function isRedactAnnotation(annotation) {
+  return annotation.subtype === "Redact";
+}
+
 // src/lib/TextLayer.ts
 function isTextNode(node) {
   return node.role === "text";
@@ -26054,17 +25988,6 @@ var MAX_TEXT_DIVS_TO_RENDER2 = 1e5;
 var DEFAULT_FONT_SIZE3 = 30;
 var DEFAULT_FONT_ASCENT = 0.8;
 var HYPHEN_REGEX = /-\n+$/;
-function getDefaultFontFamily(type) {
-  switch (type) {
-    case "serif":
-      return "Liberation Serif";
-    case "monospace":
-      return "Liberation Mono";
-    default:
-      return "Liberation Sans";
-  }
-}
-var loadingFontsPromise = null;
 async function createTextLayer(page, {
   canvasFactory,
   viewport = page.getViewport({ scale: 1 }),
@@ -26204,7 +26127,7 @@ async function createTextLayer(page, {
     }
     if (shouldScaleText) {
       if (canvasContext) {
-        canvasContext.font = `${fontHeight * outputScale}px ${getDefaultFontFamily(fontFamily)}`;
+        canvasContext.font = `400 ${fontHeight * outputScale}px 'Liberation Sans'`;
         const { width } = canvasContext.measureText(geom.str);
         if (width > 0) {
           textDiv.scale = (style.vertical ? geom.height : geom.width) * outputScale / width;
@@ -26217,10 +26140,6 @@ async function createTextLayer(page, {
     const lang = inputLang || "";
     let canvasContext2 = canvasCache.get(lang);
     if (!canvasContext2) {
-      if (!loadingFontsPromise) {
-        loadingFontsPromise = loadDefaultFonts();
-      }
-      await loadingFontsPromise;
       const { context } = await canvasFactory.create(100, 100);
       context.canvas.lang = lang;
       canvasContext2 = context;
@@ -26238,7 +26157,7 @@ async function createTextLayer(page, {
     }
     const savedFont = canvasContext.font;
     canvasContext.canvas.width = canvasContext.canvas.height = DEFAULT_FONT_SIZE3;
-    canvasContext.font = `${DEFAULT_FONT_SIZE3}px ${getDefaultFontFamily(fontFamily)}`;
+    canvasContext.font = `400 ${DEFAULT_FONT_SIZE3}px 'Liberation Sans'`;
     const metrics = canvasContext.measureText(" ");
     let ascent = metrics.fontBoundingBoxAscent;
     let descent = Math.abs(metrics.fontBoundingBoxDescent);
@@ -26510,6 +26429,7 @@ async function createTextLayer(page, {
     }
     return null;
   };
+  await loadDefaultFonts();
   const reader = textContentSource.getReader();
   while (true) {
     const { value, done } = await reader.read();
@@ -26543,12 +26463,14 @@ export {
   GlobalWorkerOptions,
   ImageKind,
   InvalidPDFException,
+  MathClamp,
   OPS,
   OutputScale,
   PDFDataRangeTransport,
   PDFDateString,
   PDFWorker,
   PasswordResponses,
+  Path2D,
   PermissionFlag,
   PixelsPerInch,
   RenderingCancelledException,
@@ -26564,11 +26486,11 @@ export {
   XfaLayer,
   build,
   canvasToData,
-  createContext,
+  createCanvas,
+  createSvgContext,
   createTextLayer,
   createValidAbsoluteUrl,
   fetchData,
-  getDefaultFontFamily,
   getDocument,
   getFilenameFromUrl,
   getPdfFilenameFromUrl,
@@ -26608,8 +26530,11 @@ export {
   isThreeDAnnotation,
   isTrapNetAnnotation,
   isUnderlineAnnotation,
+  isValidExplicitDest,
   isWatermarkAnnotation,
   isWidgetAnnotation,
+  loadDefaultFonts,
+  makeSerializable,
   noContextMenu,
   normalizeUnicode,
   setLayerDimensions,