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

package/dist/browser/{chunk-KKGFKVEF.js → chunk-LJIJQE3F.js}

@@ -324,7 +324,8 @@ var OPS = {
   paintSolidColorImageMask: 90,
   constructPath: 91,
   setStrokeTransparent: 92,
-  setFillTransparent: 93
+  setFillTransparent: 93,
+  rawFillPath: 94
 };
 var DrawOPS = {
   moveTo: 0,
@@ -576,10 +577,57 @@ var hexNumbers = Array.from(
   (n) => n.toString(16).padStart(2, "0")
 );
 var _Util_static, getExtremumOnCurve_fn, getExtremum_fn;
-var Util = class {
+var _Util = class _Util {
   static makeHexColor(r, g, b) {
     return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
   }
+  // Apply a scaling matrix to some min/max values.
+  // If a scaling factor is negative then min and max must be
+  // swapped.
+  static scaleMinMax(transform, minMax) {
+    let temp;
+    if (transform[0]) {
+      if (transform[0] < 0) {
+        temp = minMax[0];
+        minMax[0] = minMax[2];
+        minMax[2] = temp;
+      }
+      minMax[0] *= transform[0];
+      minMax[2] *= transform[0];
+      if (transform[3] < 0) {
+        temp = minMax[1];
+        minMax[1] = minMax[3];
+        minMax[3] = temp;
+      }
+      minMax[1] *= transform[3];
+      minMax[3] *= transform[3];
+    } else {
+      temp = minMax[0];
+      minMax[0] = minMax[1];
+      minMax[1] = temp;
+      temp = minMax[2];
+      minMax[2] = minMax[3];
+      minMax[3] = temp;
+      if (transform[1] < 0) {
+        temp = minMax[1];
+        minMax[1] = minMax[3];
+        minMax[3] = temp;
+      }
+      minMax[1] *= transform[1];
+      minMax[3] *= transform[1];
+      if (transform[2] < 0) {
+        temp = minMax[0];
+        minMax[0] = minMax[2];
+        minMax[2] = temp;
+      }
+      minMax[0] *= transform[2];
+      minMax[2] *= transform[2];
+    }
+    minMax[0] += transform[4];
+    minMax[1] += transform[5];
+    minMax[2] += transform[4];
+    minMax[3] += transform[5];
+  }
   // Concatenates two transformation matrices together and returns the result.
   static transform(m1, m2) {
     return [
@@ -593,23 +641,36 @@ var Util = class {
   }
   // For 2d affine transforms
   static applyTransform(p, m) {
-    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
-    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
-    return [xt, yt];
+    const [p0, p1] = p;
+    p[0] = p0 * m[0] + p1 * m[2] + m[4];
+    p[1] = p0 * m[1] + p1 * m[3] + m[5];
+  }
+  // For 2d affine transforms
+  static applyTransformToBezier(p, [m0, m1, m2, m3, m4, m5]) {
+    for (let i = 0; i < 6; i += 2) {
+      const pI = p[i];
+      const pI1 = p[i + 1];
+      p[i] = pI * m0 + pI1 * m2 + m4;
+      p[i + 1] = pI * m1 + pI1 * m3 + m5;
+    }
   }
   static applyInverseTransform(p, m) {
+    const [p0, p1] = p;
     const d = m[0] * m[3] - m[1] * m[2];
-    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
-    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
-    return [xt, yt];
+    p[0] = (p0 * m[3] - p1 * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+    p[1] = (-p0 * m[1] + p1 * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
   }
   // Applies the transform to the rectangle and finds the minimum axially
   // aligned bounding box.
   static getAxialAlignedBoundingBox(r, m) {
-    const p1 = this.applyTransform(r, m);
-    const p2 = this.applyTransform(r.slice(2, 4), m);
-    const p3 = this.applyTransform([r[0], r[3]], m);
-    const p4 = this.applyTransform([r[2], r[1]], m);
+    const p1 = [r[0], r[1]];
+    _Util.applyTransform(p1, m);
+    const p2 = [r[2], r[3]];
+    _Util.applyTransform(p2, m);
+    const p3 = [r[0], r[3]];
+    _Util.applyTransform(p3, m);
+    const p4 = [r[2], r[1]];
+    _Util.applyTransform(p4, m);
     return [
       Math.min(p1[0], p2[0], p3[0], p4[0]),
       Math.min(p1[1], p2[1], p3[1], p4[1]),
@@ -631,17 +692,14 @@ var Util = class {
   // This calculation uses Singular Value Decomposition.
   // The SVD can be represented with formula A = USV. We are interested in the
   // matrix S here because it represents the scale values.
-  static singularValueDecompose2dScale(m) {
-    const transpose = [m[0], m[2], m[1], m[3]];
-    const a = m[0] * transpose[0] + m[1] * transpose[2];
-    const b = m[0] * transpose[1] + m[1] * transpose[3];
-    const c = m[2] * transpose[0] + m[3] * transpose[2];
-    const d = m[2] * transpose[1] + m[3] * transpose[3];
-    const first = (a + d) / 2;
-    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
-    const sx = first + second || 1;
-    const sy = first - second || 1;
-    return [Math.sqrt(sx), Math.sqrt(sy)];
+  static singularValueDecompose2dScale([m0, m1, m2, m3], output) {
+    const a = m0 ** 2 + m1 ** 2;
+    const b = m0 * m2 + m1 * m3;
+    const c = m2 ** 2 + m3 ** 2;
+    const first = (a + c) / 2;
+    const second = Math.sqrt(first ** 2 - (a * c - b ** 2));
+    output[0] = Math.sqrt(first + second || 1);
+    output[1] = Math.sqrt(first - second || 1);
   }
   // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
   // For coordinate systems whose origin lies in the bottom-left, this
@@ -740,7 +798,8 @@ getExtremum_fn = function(x0, x1, x2, x3, y0, y1, y2, y3, a, b, c, minMax) {
   __privateMethod(this, _Util_static, getExtremumOnCurve_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, (-b + sqrtDelta) / a2, minMax);
   __privateMethod(this, _Util_static, getExtremumOnCurve_fn).call(this, x0, x1, x2, x3, y0, y1, y2, y3, (-b - sqrtDelta) / a2, minMax);
 };
-__privateAdd(Util, _Util_static);
+__privateAdd(_Util, _Util_static);
+var Util = _Util;
 var PDFStringTranslateTable = [
   0,
   0,

package/dist/browser/index.js

@@ -46,7 +46,7 @@ import {
   unreachable,
   warn,
   wrapReason
-} from "./chunk-KKGFKVEF.js";
+} from "./chunk-LJIJQE3F.js";
 import {
   __privateAdd,
   __privateGet,
@@ -240,7 +240,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.
@@ -250,8 +252,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]];
   }
   /**
@@ -264,7 +268,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 {
@@ -6377,15 +6383,17 @@ var MeshShadingPattern = class extends BaseShadingPattern {
   }
   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,
@@ -6456,12 +6464,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);
@@ -6642,9 +6650,9 @@ 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);
 function mirrorContextOperations(ctx, destCtx) {
   if (ctx._removeMirroring) {
     throw new Error("Context is already forwarding operations.");
@@ -6805,145 +6813,6 @@ 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;
-  const points = new Uint8Array(width1 * (height + 1));
-  let i, j, j0;
-  const lineSize = width + 7 & ~7;
-  const data = new Uint8Array(lineSize * height);
-  let 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();
-  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;
-    while (p < end && !points[p]) {
-      p++;
-    }
-    if (p === end) {
-      continue;
-    }
-    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 {
-      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;
-      }
-      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;
-  }
-  return path;
-}
 var CanvasExtraState = class {
   constructor(width, height) {
     this.alphaIsShape = false;
@@ -6979,10 +6848,14 @@ var CanvasExtraState = class {
     return clone;
   }
   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);
+    const p1 = [rect[0], rect[1]];
+    Util.applyTransform(p1, transform);
+    const p2 = [rect[2], rect[3]];
+    Util.applyTransform(p2, transform);
+    const p3 = [rect[0], rect[3]];
+    Util.applyTransform(p3, transform);
+    const p4 = [rect[2], rect[1]];
+    Util.applyTransform(p4, 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]);
@@ -6994,9 +6867,9 @@ var CanvasExtraState = class {
       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;
@@ -7191,13 +7064,11 @@ 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(
     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"];
@@ -7222,7 +7093,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.canvasFactory = canvasFactory;
     this.filterFactory = filterFactory;
     this.groupStack = [];
-    this.processingType3 = null;
     this.baseTransform = null;
     this.baseTransformStack = [];
     this.groupLevel = 0;
@@ -7923,6 +7793,9 @@ var _CanvasGraphics = class _CanvasGraphics {
   endPath(path) {
     this.consumePath(path);
   }
+  rawFillPath(path) {
+    this.ctx.fill(path);
+  }
   // Clipping
   clip() {
     this.pendingClip = NORMAL_CLIP;
@@ -7941,7 +7814,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     const paths = this.pendingTextPaths;
     const ctx = this.ctx;
     if (paths === void 0) {
-      ctx.beginPath();
       return;
     }
     const newPath = new SvgPath2D();
@@ -7953,7 +7825,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       );
     }
     ctx.clip(newPath);
-    ctx.beginPath();
     delete this.pendingTextPaths;
   }
   setCharSpacing(spacing) {
@@ -8072,8 +7943,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)
           );
@@ -8314,27 +8185,27 @@ var _CanvasGraphics = class _CanvasGraphics {
       if (!operatorList) {
         warn(`Type3 character "${glyph.operatorListId}" is not available.`);
       } else if (this.contentVisible) {
-        this.processingType3 = glyph;
         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
@@ -8452,11 +8323,11 @@ 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();
+      const [x0, y0, x1, y1] = bbox;
+      const clip = new SvgPath2D();
+      clip.rect(x0, y0, x1 - x0, y1 - y0);
+      this.ctx.clip(clip);
       this.endPath();
     }
   }
@@ -8600,9 +8471,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
@@ -8619,14 +8488,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(
@@ -8653,16 +8522,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) {
-        ctx.fill(glyph.compiled);
-        return;
-      }
-    }
     const mask = this._createMaskCanvas(img);
     const maskCanvas = mask.canvas;
     ctx.save();
@@ -8698,8 +8557,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();
@@ -8956,7 +8814,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       this.pendingClip = null;
     }
     this.current.startNewPathAndClipBox(this.current.clipBox);
-    ctx.beginPath();
   }
   getSinglePixelWidth() {
     if (!this._cachedGetSinglePixelWidth) {
@@ -24600,12 +24457,13 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
       } else {
         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) {
+            if (currentFillColor && firstFill) {
               annotation.interiorColor = currentFillColor;
               currentFillColor = null;
             }
@@ -24617,7 +24475,7 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
             continue;
           }
           if (finalFn === OPS.stroke || finalFn === OPS.closeStroke) {
-            if (currentLineWidth === null) {
+            if (currentLineWidth === null && firstStroke) {
               annotation.borderStyle.width = 1;
             }
             firstStroke = false;
@@ -24625,11 +24483,11 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
             continue;
           }
           if (finalFn === OPS.fillStroke || finalFn === OPS.closeFillStroke) {
-            if (currentFillColor) {
+            if (currentFillColor && firstFill) {
               annotation.interiorColor = currentFillColor;
               currentFillColor = null;
             }
-            if (currentLineWidth === null) {
+            if (currentLineWidth === null && firstStroke) {
               annotation.borderStyle.width = 1;
             }
             firstStroke = false;
@@ -24662,6 +24520,16 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
               }
             }
           }
+          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;
+          }
         }
       }
     }
@@ -25286,8 +25154,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");
     }
   }
@@ -25598,7 +25483,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);
@@ -25629,9 +25513,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(",")}`;