@chialab/pdfjs-lib 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/node/index.js

@@ -7505,19 +7505,27 @@ var CanvasExtraState = class {
     clone.clipBox = this.clipBox.slice();
     return clone;
   }
-  updateRectMinMax(transform, rect) {
-    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]);
-    this.maxY = Math.max(this.maxY, p1[1], p2[1], p3[1], p4[1]);
+  updateRectMinMax([m0, m1, m2, m3, m4, m5], [r0, r1, r2, r3]) {
+    const m0r0m4 = m0 * r0 + m4;
+    const m0r2m4 = m0 * r2 + m4;
+    const m1r0m5 = m1 * r0 + m5;
+    const m1r2m5 = m1 * r2 + m5;
+    const m2r1 = m2 * r1;
+    const m2r3 = m2 * r3;
+    const m3r1 = m3 * r1;
+    const m3r3 = m3 * r3;
+    const a0 = m0r0m4 + m2r1;
+    const a1 = m0r2m4 + m2r3;
+    const a2 = m0r0m4 + m2r3;
+    const a3 = m0r2m4 + m2r1;
+    const b0 = m1r0m5 + m3r1;
+    const b1 = m1r2m5 + m3r3;
+    const b2 = m1r0m5 + m3r3;
+    const b3 = m1r2m5 + m3r1;
+    this.minX = Math.min(this.minX, a0, a1, a2, a3);
+    this.maxX = Math.max(this.maxX, a0, a1, a2, a3);
+    this.minY = Math.min(this.minY, b0, b1, b2, b3);
+    this.maxY = Math.max(this.maxY, b0, b1, b2, b3);
   }
   getPathBoundingBox(pathType = PathType.FILL, transform = null) {
     const box = [this.minX, this.minY, this.maxX, this.maxY];
@@ -8981,7 +8989,7 @@ var _CanvasGraphics = class _CanvasGraphics {
     }
     this.baseTransform = getCurrentTransform(this.ctx);
     if (bbox) {
-      this.current.updateRectMinMax(getCurrentTransform(this.ctx), bbox);
+      this.current.updateRectMinMax(this.baseTransform, bbox);
       const [x0, y0, x1, y1] = bbox;
       const clip = new SvgPath2D();
       clip.rect(x0, y0, x1 - x0, y1 - y0);
@@ -24664,319 +24672,6 @@ 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");
-    }
-    return new Uint8Array(await blob.arrayBuffer());
-  }
-  const buffer = await canvas.encode("png");
-  return new Uint8Array(buffer);
-}
-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" }));
-    });
-  }
-  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) {
-          const finalFn = fn === OPS.constructPath ? args[0] : fn;
-          if (finalFn === OPS.fill) {
-            if (currentFillColor) {
-              annotation.interiorColor = currentFillColor;
-              currentFillColor = null;
-            }
-            firstFill = false;
-            continue;
-          }
-          if (fn === OPS.beginText) {
-            firstFill = false;
-            continue;
-          }
-          if (finalFn === OPS.stroke || finalFn === OPS.closeStroke) {
-            if (currentLineWidth === null) {
-              annotation.borderStyle.width = 1;
-            }
-            firstStroke = false;
-            currentLineWidth = null;
-            continue;
-          }
-          if (finalFn === OPS.fillStroke || finalFn === OPS.closeFillStroke) {
-            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) {
-            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) {
   const values = transformString.match(/matrix\(([^)]+)\)/)?.[1].split(",").map(Number);
@@ -25270,19 +24965,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 = {};
@@ -25620,6 +25329,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",
@@ -25825,64 +25537,405 @@ var SvgCanvasContext = class {
         if (command === "Z" && this._currentElement.attrs.d.endsWith("Z")) {
           return;
         }
-        this._currentElement.attrs.d += ` ${command}`;
+        this._currentElement.attrs.d += ` ${command}`;
+      } else {
+        this._currentElement.attrs.d = command;
+        this._currentGroup.children.push(this._currentElement);
+      }
+    }
+  }
+  _applyText(text, x, y, action) {
+    const parent = this._currentGroup;
+    const style = parseFontStyle(this._currentStyle.font);
+    const textElement = {
+      tag: "text",
+      attrs: {
+        x: `${x}`,
+        y: `${y}`,
+        "font-family": style.fontFamilies.join(", "),
+        "font-size": style.fontSize,
+        "font-style": style.fontStyle,
+        "font-weight": style.fontWeight,
+        "text-anchor": getTextAnchor(this._currentStyle.textAlign),
+        "dominant-baseline": getDominantBaseline(
+          this._currentStyle.textBaseline
+        )
+      },
+      text
+    };
+    this._applyTransformation(textElement);
+    this._applyStyle(textElement, action);
+    parent.children.push(textElement);
+  }
+  _clearCanvas() {
+    this._defs.children = [];
+    this._root.children = [this._defs];
+    this._currentGroup = this._root;
+    this._groupStack = [];
+  }
+};
+async function createSvgContext(width, height) {
+  const canvas = await createCanvas(width, height);
+  return new SvgCanvasContext(
+    width,
+    height,
+    canvas
+  );
+}
+async function toSvgNode(ctx) {
+  if (!(ctx instanceof SvgCanvasContext)) {
+    throw new Error("Invalid context");
+  }
+  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 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 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 {
-        this._currentElement.attrs.d = command;
-        this._currentGroup.children.push(this._currentElement);
+        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) {
+            firstFill = false;
+            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;
+              currentFillColor = null;
+            }
+            if (currentLineWidth === null && firstStroke) {
+              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) {
+            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;
+          }
+        }
       }
     }
   }
-  _applyText(text, x, y, action) {
-    const parent = this._currentGroup;
-    const style = parseFontStyle(this._currentStyle.font);
-    const textElement = {
-      tag: "text",
-      attrs: {
-        x: `${x}`,
-        y: `${y}`,
-        "font-family": style.fontFamilies.join(", "),
-        "font-size": style.fontSize,
-        "font-style": style.fontStyle,
-        "font-weight": style.fontWeight,
-        "text-anchor": getTextAnchor(this._currentStyle.textAlign),
-        "dominant-baseline": getDominantBaseline(
-          this._currentStyle.textBaseline
-        )
-      },
-      text
-    };
-    this._applyTransformation(textElement);
-    this._applyStyle(textElement, action);
-    parent.children.push(textElement);
+  return makeSerializable(annotations);
+};
+
+// src/lib/StandardFontDataFactory.ts
+var StandardFontDataFactory = class extends BaseStandardFontDataFactory {
+  constructor() {
+    super({
+      baseUrl: null
+    });
   }
-  _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._groupStack = [];
+  /**
+   * 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([]);
   }
 };
-async function createSvgContext(width, height) {
-  const canvas = await createCanvas(width, height);
-  return new SvgCanvasContext(
-    width,
-    height,
-    canvas
-  );
+
+// src/lib/AnnotationData.ts
+function isTextAnnotation(annotation) {
+  return annotation.subtype === "Text";
 }
-async function toSvgNode(ctx) {
-  if (!(ctx instanceof SvgCanvasContext)) {
-    throw new Error("Invalid context");
-  }
-  return ctx.getNode();
+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
@@ -26445,6 +26498,7 @@ export {
   isWatermarkAnnotation,
   isWidgetAnnotation,
   loadDefaultFonts,
+  makeSerializable,
   noContextMenu,
   normalizeUnicode,
   setLayerDimensions,