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

package/dist/node/index.js

@@ -46,7 +46,7 @@ import {
   unreachable,
   warn,
   wrapReason
-} from "./chunk-PWUBNK7D.js";
+} from "./chunk-XZBSEIET.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 {
@@ -7035,15 +7041,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,
@@ -7114,12 +7122,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);
@@ -7300,9 +7308,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.");
@@ -7463,145 +7471,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;
@@ -7637,10 +7506,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]);
@@ -7652,9 +7525,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;
@@ -7849,13 +7722,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"];
@@ -7880,7 +7751,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     this.canvasFactory = canvasFactory;
     this.filterFactory = filterFactory;
     this.groupStack = [];
-    this.processingType3 = null;
     this.baseTransform = null;
     this.baseTransformStack = [];
     this.groupLevel = 0;
@@ -8581,6 +8451,9 @@ var _CanvasGraphics = class _CanvasGraphics {
   endPath(path) {
     this.consumePath(path);
   }
+  rawFillPath(path) {
+    this.ctx.fill(path);
+  }
   // Clipping
   clip() {
     this.pendingClip = NORMAL_CLIP;
@@ -8599,7 +8472,6 @@ var _CanvasGraphics = class _CanvasGraphics {
     const paths = this.pendingTextPaths;
     const ctx = this.ctx;
     if (paths === void 0) {
-      ctx.beginPath();
       return;
     }
     const newPath = new SvgPath2D();
@@ -8611,7 +8483,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       );
     }
     ctx.clip(newPath);
-    ctx.beginPath();
     delete this.pendingTextPaths;
   }
   setCharSpacing(spacing) {
@@ -8730,8 +8601,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)
           );
@@ -8972,27 +8843,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
@@ -9110,11 +8981,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();
     }
   }
@@ -9258,9 +9129,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
@@ -9277,14 +9146,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(
@@ -9311,16 +9180,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();
@@ -9356,8 +9215,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();
@@ -9614,7 +9472,6 @@ var _CanvasGraphics = class _CanvasGraphics {
       this.pendingClip = null;
     }
     this.current.startNewPathAndClipBox(this.current.clipBox);
-    ctx.beginPath();
   }
   getSinglePixelWidth() {
     if (!this._cachedGetSinglePixelWidth) {
@@ -24910,12 +24767,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;
             }
@@ -24927,7 +24785,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;
@@ -24935,11 +24793,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;
@@ -24972,6 +24830,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;
+          }
         }
       }
     }
@@ -25596,8 +25464,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");
     }
   }
@@ -25908,7 +25793,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);
@@ -25939,9 +25823,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(",")}`;