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

package/dist/browser/index.js

@@ -8,6 +8,7 @@ import {
   AnnotationPrefix,
   AnnotationType,
   BaseException,
+  DrawOPS,
   FONT_IDENTITY_MATRIX,
   FeatureTest,
   FormatError,
@@ -15,6 +16,7 @@ import {
   ImageKind,
   InvalidPDFException,
   LINE_FACTOR,
+  MathClamp,
   MessageHandler,
   MurmurHash3_64,
   OPS,
@@ -25,6 +27,7 @@ import {
   TextRenderingMode,
   Util,
   VerbosityLevel,
+  _isValidExplicitDest,
   assert,
   convertBlackAndWhiteToRGBA,
   createValidAbsoluteUrl,
@@ -43,7 +46,7 @@ import {
   unreachable,
   warn,
   wrapReason
-} from "./chunk-DYHYQ33L.js";
+} from "./chunk-KKGFKVEF.js";
 import {
   __privateAdd,
   __privateGet,
@@ -491,9 +494,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 +506,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 +3200,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 +3245,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 +3832,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 +4022,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 +4059,7 @@ var _AnnotationEditor = class _AnnotationEditor {
       }));
     }
     this._uiManager._editorUndoBar?.hide();
-    return this.div;
+    return div;
   }
   /**
    * Onpointerdown callback.
@@ -4312,7 +4349,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 +4490,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 +4895,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);
@@ -6037,6 +6071,9 @@ var BaseShadingPattern = class {
       unreachable("Cannot initialize BaseShadingPattern.");
     }
   }
+  isModifyingCurrentTransform() {
+    return false;
+  }
   getPattern() {
     unreachable("Abstract method `getPattern` called.");
   }
@@ -6335,6 +6372,9 @@ var MeshShadingPattern = class extends BaseShadingPattern {
       scaleY
     };
   }
+  isModifyingCurrentTransform() {
+    return true;
+  }
   getPattern(ctx, owner, inverse, pathType) {
     applyBoundingBox(ctx, this._bbox);
     let scale;
@@ -6387,7 +6427,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];
@@ -6395,7 +6436,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;
@@ -6567,6 +6607,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) {
@@ -6601,6 +6644,7 @@ var EXECUTION_TIME = 15;
 var EXECUTION_STEPS = 10;
 var MAX_SIZE_TO_COMPILE = 1e3;
 var FULL_CHUNK_HEIGHT = 16;
+var SCALE_MATRIX = new DOMMatrix();
 function mirrorContextOperations(ctx, destCtx) {
   if (ctx._removeMirroring) {
     throw new Error("Context is already forwarding operations.");
@@ -6786,10 +6830,11 @@ function compileType3Glyph(imgData) {
     0
   ]);
   const width1 = width + 1;
-  let points = new Uint8Array(width1 * (height + 1));
+  const points = new Uint8Array(width1 * (height + 1));
   let i, j, j0;
   const lineSize = width + 7 & ~7;
-  let data = new Uint8Array(lineSize * height), pos = 0;
+  const data = new Uint8Array(lineSize * height);
+  let pos = 0;
   for (const elem of imgData.data) {
     let mask = 128;
     while (mask > 0) {
@@ -6860,6 +6905,7 @@ function compileType3Glyph(imgData) {
   }
   const steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
   const path = new SvgPath2D();
+  const { a, b, c, d, e, f } = new DOMMatrix().scaleSelf(1 / width, -1 / height).translateSelf(0, -height);
   for (i = 0; count && i <= height; i++) {
     let p = i * width1;
     const end = p + width;
@@ -6869,7 +6915,9 @@ function compileType3Glyph(imgData) {
     if (p === end) {
       continue;
     }
-    path.moveTo(p % width1, i);
+    let x = p % width1;
+    let y = i;
+    path.moveTo(a * x + c * y + e, b * x + d * y + f);
     const p0 = p;
     let type = points[p];
     do {
@@ -6885,24 +6933,16 @@ function compileType3Glyph(imgData) {
         type = pp & 51 * type >> 4;
         points[p] &= type >> 2 | type << 2;
       }
-      path.lineTo(p % width1, p / width1 | 0);
+      x = p % width1;
+      y = p / width1 | 0;
+      path.lineTo(a * x + c * y + e, b * x + d * y + f);
       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;
+  return path;
 }
 var CanvasExtraState = class {
   constructor(width, height) {
@@ -6938,17 +6978,6 @@ var CanvasExtraState = class {
     clone.clipBox = this.clipBox.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);
@@ -6959,20 +6988,6 @@ var CanvasExtraState = class {
     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];
     if (pathType === PathType.STROKE) {
@@ -7180,7 +7195,7 @@ function getImageSmoothingEnabled(transform, interpolate) {
   scale[0] = Math.fround(scale[0]);
   scale[1] = Math.fround(scale[1]);
   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;
 }
@@ -7550,8 +7565,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;
@@ -7600,16 +7614,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) {
@@ -7729,31 +7738,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);
@@ -7761,145 +7767,56 @@ 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);
+    this.current.updateRectMinMax(getCurrentTransform(this.ctx), 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,
@@ -7907,33 +7824,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,
@@ -7941,48 +7874,54 @@ 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);
   }
   // Clipping
   clip() {
@@ -8374,9 +8313,7 @@ var _CanvasGraphics = class _CanvasGraphics {
       const operatorList = font.charProcOperatorList[glyph.operatorListId];
       if (!operatorList) {
         warn(`Type3 character "${glyph.operatorListId}" is not available.`);
-        continue;
-      }
-      if (this.contentVisible) {
+      } else if (this.contentVisible) {
         this.processingType3 = glyph;
         this.save();
         ctx.scale(fontSize, fontSize);
@@ -8404,7 +8341,6 @@ var _CanvasGraphics = class _CanvasGraphics {
   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(
@@ -8421,7 +8357,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       };
       pattern = new TilingPattern(
         IR,
-        color,
         this.ctx,
         canvasGraphicsFactory,
         baseTransform
@@ -8583,6 +8518,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,
@@ -8715,7 +8659,7 @@ var _CanvasGraphics = class _CanvasGraphics {
         glyph.compiled = compileType3Glyph(img);
       }
       if (glyph.compiled) {
-        glyph.compiled(ctx);
+        ctx.fill(glyph.compiled);
         return;
       }
     }
@@ -8992,7 +8936,7 @@ var _CanvasGraphics = class _CanvasGraphics {
   endCompat() {
   }
   // Helper functions
-  consumePath(clipBox) {
+  consumePath(path, clipBox) {
     const isEmpty = this.current.isEmptyClip();
     if (this.pendingClip) {
       this.current.updateClipFromPath();
@@ -9004,9 +8948,9 @@ 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;
@@ -9072,13 +9016,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();
@@ -9086,12 +9032,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();
     }
@@ -11142,7 +11093,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,
@@ -11220,7 +11171,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?.();
@@ -11600,6 +11551,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);
@@ -11671,6 +11623,7 @@ function getDocument(src = {}) {
       useWasm,
       useWorkerFetch,
       cMapUrl,
+      iccUrl,
       standardFontDataUrl,
       wasmUrl
     }
@@ -11804,19 +11757,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.
@@ -11851,6 +11839,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);
@@ -13027,6 +13024,7 @@ var _PDFWorker = class _PDFWorker {
   }
   /**
    * @param {PDFWorkerParameters} params - The worker initialization parameters.
+   * @returns {PDFWorker}
    */
   static fromPort(params) {
     if (false) {
@@ -13062,7 +13060,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());
@@ -17591,7 +17589,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;
@@ -18441,35 +18439,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];
@@ -18477,14 +18464,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];
 };
 
@@ -18509,10 +18496,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) {
@@ -18523,15 +18507,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)) {
@@ -19060,6 +19041,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);
@@ -19574,6 +19556,7 @@ var _HighlightEditor = class _HighlightEditor extends AnnotationEditor {
         clipPathId
       });
       __privateMethod(_d = editor, _HighlightEditor_instances, addToDrawLayer_fn).call(_d);
+      editor.rotate(editor.parentRotation);
     }
     return editor;
   }
@@ -21483,11 +21466,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;
     }
@@ -21500,10 +21479,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];
 };
@@ -21557,6 +21536,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) {
@@ -22450,6 +22430,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) {
@@ -22513,7 +22494,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 {
@@ -22539,6 +22519,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);
       }
@@ -22605,6 +22589,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();
@@ -22785,6 +22770,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) {
@@ -22926,7 +22912,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)) {
@@ -23074,10 +23059,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;
@@ -23393,7 +23374,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) {
@@ -24622,7 +24603,8 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
         let currentFillColor = null;
         let currentLineWidth = null;
         for (const { fn, args } of opList) {
-          if (fn === OPS.fill) {
+          const finalFn = fn === OPS.constructPath ? args[0] : fn;
+          if (finalFn === OPS.fill) {
             if (currentFillColor) {
               annotation.interiorColor = currentFillColor;
               currentFillColor = null;
@@ -24634,7 +24616,7 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
             firstFill = false;
             continue;
           }
-          if (fn === OPS.stroke || fn === OPS.closeStroke) {
+          if (finalFn === OPS.stroke || finalFn === OPS.closeStroke) {
             if (currentLineWidth === null) {
               annotation.borderStyle.width = 1;
             }
@@ -24642,7 +24624,7 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
             currentLineWidth = null;
             continue;
           }
-          if (fn === OPS.fillStroke || fn === OPS.closeFillStroke) {
+          if (finalFn === OPS.fillStroke || finalFn === OPS.closeFillStroke) {
             if (currentFillColor) {
               annotation.interiorColor = currentFillColor;
               currentFillColor = null;
@@ -26211,6 +26193,7 @@ export {
   GlobalWorkerOptions,
   ImageKind,
   InvalidPDFException,
+  MathClamp,
   OPS,
   OutputScale,
   PDFDataRangeTransport,
@@ -26277,6 +26260,7 @@ export {
   isThreeDAnnotation,
   isTrapNetAnnotation,
   isUnderlineAnnotation,
+  isValidExplicitDest,
   isWatermarkAnnotation,
   isWidgetAnnotation,
   loadDefaultFonts,