kviewer 0.0.1

package/dist/runtime/annotation/pdf-export/export-form-fields.js

@@ -0,0 +1,90 @@
+export async function writeFormFieldsToPdf(pdfDoc, fieldValues) {
+  const form = pdfDoc.getForm();
+  for (const field of fieldValues) {
+    try {
+      switch (field.fieldType) {
+        case "text": {
+          const textField = form.getTextField(field.fieldName);
+          textField.setText(typeof field.value === "string" ? field.value : String(field.value));
+          break;
+        }
+        case "checkbox": {
+          const checkBox = form.getCheckBox(field.fieldName);
+          if (field.value === true) {
+            checkBox.check();
+          } else {
+            checkBox.uncheck();
+          }
+          break;
+        }
+        case "radio": {
+          if (typeof field.value === "string" && field.value !== "") {
+            const radioGroup = form.getRadioGroup(field.fieldName);
+            radioGroup.select(field.value);
+          }
+          break;
+        }
+        case "dropdown": {
+          const dropdown = form.getDropdown(field.fieldName);
+          if (Array.isArray(field.value)) {
+            for (const v of field.value) {
+              dropdown.select(v);
+            }
+          } else if (typeof field.value === "string" && field.value !== "") {
+            dropdown.select(field.value);
+          }
+          break;
+        }
+        case "signature": {
+          if (typeof field.value === "string" && field.value.startsWith("data:image")) {
+            await embedSignatureImage(pdfDoc, field);
+          }
+          break;
+        }
+      }
+    } catch (err) {
+      console.warn(
+        `Failed to write form field "${field.fieldName}" (${field.fieldType}):`,
+        err
+      );
+    }
+  }
+}
+async function embedSignatureImage(pdfDoc, field) {
+  const dataUrl = field.value;
+  const match = dataUrl.match(/^data:(image\/[a-zA-Z0-9.+-]+);base64,(.+)$/);
+  if (!match) return;
+  const mimeType = match[1] ?? "";
+  const base64 = match[2] ?? "";
+  let image;
+  if (mimeType.includes("jpeg") || mimeType.includes("jpg")) {
+    image = await pdfDoc.embedJpg(base64);
+  } else {
+    image = await pdfDoc.embedPng(base64);
+  }
+  const form = pdfDoc.getForm();
+  try {
+    const sigField = form.getSignature(field.fieldName);
+    const widgets = sigField.acroField.getWidgets();
+    if (widgets.length > 0) {
+      const widget = widgets[0];
+      const rect = widget.getRectangle();
+      const pages = pdfDoc.getPages();
+      for (const page of pages) {
+        const pageRef = page.ref;
+        const widgetPage = widget.P();
+        if (widgetPage === pageRef || !widgetPage) {
+          page.drawImage(image, {
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height
+          });
+          break;
+        }
+      }
+    }
+  } catch {
+    console.warn(`Could not embed signature for field "${field.fieldName}"`);
+  }
+}

package/dist/runtime/annotation/pdf-export/export.d.ts

@@ -0,0 +1,15 @@
+import { type IAnnotationStore, type FormFieldValue } from '../engine/types.js';
+export interface ExportPdfOptions {
+    flatten?: boolean;
+    download?: boolean;
+    fileName?: string;
+    preserveOriginalAnnotations?: boolean;
+}
+interface ExportPdfParams {
+    pdfData: Uint8Array | ArrayBuffer;
+    annotations: IAnnotationStore[];
+    options?: ExportPdfOptions;
+    formFieldValues?: FormFieldValue[];
+}
+export declare function exportAnnotationsToPdf({ pdfData, annotations, options, formFieldValues, }: ExportPdfParams): Promise<Uint8Array>;
+export {};

package/dist/runtime/annotation/pdf-export/export.js

@@ -0,0 +1,145 @@
+import { PDFDocument, PDFName } from "pdf-lib";
+import { PdfjsAnnotationType } from "../engine/types.js";
+import { writeFormFieldsToPdf } from "./export-form-fields.js";
+import { CircleParser } from "./parse_circle.js";
+import { FreeTextParser } from "./parse_freetext.js";
+import { HighlightParser } from "./parse_highlight.js";
+import { InkParser } from "./parse_ink.js";
+import { LineParser } from "./parse_line.js";
+import { PolylineParser } from "./parse_polyline.js";
+import { SquareParser } from "./parse_square.js";
+import { StampParser } from "./parse_stamp.js";
+import { StrikeOutParser } from "./parse_strikeout.js";
+import { TextParser } from "./parse_text.js";
+import { UnderlineParser } from "./parse_underline.js";
+const parserMap = {
+  [PdfjsAnnotationType.TEXT]: TextParser,
+  [PdfjsAnnotationType.HIGHLIGHT]: HighlightParser,
+  [PdfjsAnnotationType.UNDERLINE]: UnderlineParser,
+  [PdfjsAnnotationType.STRIKEOUT]: StrikeOutParser,
+  [PdfjsAnnotationType.SQUARE]: SquareParser,
+  [PdfjsAnnotationType.CIRCLE]: CircleParser,
+  [PdfjsAnnotationType.INK]: InkParser,
+  [PdfjsAnnotationType.POLYLINE]: PolylineParser,
+  [PdfjsAnnotationType.FREETEXT]: FreeTextParser,
+  [PdfjsAnnotationType.STAMP]: StampParser,
+  [PdfjsAnnotationType.LINE]: LineParser
+};
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  return new Uint8Array(data);
+}
+function clearAllAnnotations(pdfDoc) {
+  for (const page of pdfDoc.getPages()) {
+    const annotsKey = PDFName.of("Annots");
+    if (page.node.has(annotsKey)) {
+      page.node.set(annotsKey, pdfDoc.context.obj([]));
+    }
+  }
+}
+async function parseAnnotationToPdf(annotation, page, pdfDoc) {
+  const ParserClass = parserMap[annotation.pdfjsType];
+  if (!ParserClass) {
+    console.warn(`Unsupported annotation type for PDF export: ${annotation.pdfjsType}`);
+    return;
+  }
+  const parser = new ParserClass(pdfDoc, page, annotation);
+  await parser.parse();
+}
+async function embedDataUrlImage(pdfDoc, dataUrl) {
+  const match = dataUrl.match(/^data:(image\/[a-zA-Z0-9.+-]+);base64,(.+)$/);
+  if (!match) {
+    throw new TypeError("Invalid data URL for flatten export image");
+  }
+  const mimeType = match[1] || "";
+  const base64 = match[2] || "";
+  if (mimeType.includes("jpeg") || mimeType.includes("jpg")) {
+    return pdfDoc.embedJpg(base64);
+  }
+  return pdfDoc.embedPng(base64);
+}
+async function flattenPageAnnotations(pdfDoc, page, annotations) {
+  if (annotations.length === 0) return;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new TypeError("Flatten export requires a browser environment");
+  }
+  const Konva = (await import("konva")).default;
+  const width = Math.floor(page.getWidth());
+  const height = Math.floor(page.getHeight());
+  const stage = new Konva.Stage({
+    container: document.createElement("div"),
+    width,
+    height,
+    listening: false
+  });
+  const layer = new Konva.Layer({ listening: false });
+  stage.add(layer);
+  for (const annotation of annotations) {
+    try {
+      const node = Konva.Node.create(annotation.konvaString);
+      if (node instanceof Konva.Node) {
+        layer.add(node);
+      }
+    } catch {
+      console.warn(`Unable to flatten annotation ${annotation.id}; skipping`);
+    }
+  }
+  layer.draw();
+  const dataUrl = stage.toDataURL({ pixelRatio: 2 });
+  stage.destroy();
+  const image = await embedDataUrlImage(pdfDoc, dataUrl);
+  page.drawImage(image, {
+    x: 0,
+    y: 0,
+    width: page.getWidth(),
+    height: page.getHeight()
+  });
+}
+function groupByPage(annotations) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const annotation of annotations) {
+    const list = grouped.get(annotation.pageNumber);
+    if (list) {
+      list.push(annotation);
+    } else {
+      grouped.set(annotation.pageNumber, [annotation]);
+    }
+  }
+  return grouped;
+}
+export async function exportAnnotationsToPdf({
+  pdfData,
+  annotations,
+  options,
+  formFieldValues
+}) {
+  const flatten = options?.flatten ?? false;
+  const preserveOriginalAnnotations = options?.preserveOriginalAnnotations ?? false;
+  const pdfDoc = await PDFDocument.load(toUint8Array(pdfData));
+  if (formFieldValues && formFieldValues.length > 0) {
+    await writeFormFieldsToPdf(pdfDoc, formFieldValues);
+  }
+  if (!preserveOriginalAnnotations) {
+    clearAllAnnotations(pdfDoc);
+  }
+  if (flatten) {
+    const pages = pdfDoc.getPages();
+    const grouped = groupByPage(annotations);
+    for (const [pageNumber, pageAnnotations] of grouped.entries()) {
+      const page = pages[pageNumber - 1];
+      if (!page) continue;
+      await flattenPageAnnotations(pdfDoc, page, pageAnnotations);
+    }
+  } else {
+    const pages = pdfDoc.getPages();
+    for (const annotation of annotations) {
+      const page = pages[annotation.pageNumber - 1];
+      if (!page) {
+        console.warn(`Skipping annotation ${annotation.id}; page ${annotation.pageNumber} missing`);
+        continue;
+      }
+      await parseAnnotationToPdf(annotation, page, pdfDoc);
+    }
+  }
+  return pdfDoc.save();
+}

package/dist/runtime/annotation/pdf-export/parse.d.ts

@@ -0,0 +1,10 @@
+import type { PDFDocument, PDFPage, PDFRef } from 'pdf-lib';
+import type { IAnnotationStore } from '../engine/types.js';
+export declare abstract class AnnotationParser {
+    protected annotation: IAnnotationStore;
+    protected page: PDFPage;
+    protected pdfDoc: PDFDocument;
+    constructor(pdfDoc: PDFDocument, page: PDFPage, annotation: IAnnotationStore);
+    protected addAnnotationToPage(page: PDFPage, annotRef: PDFRef): void;
+    abstract parse(): Promise<void>;
+}

package/dist/runtime/annotation/pdf-export/parse.js

@@ -0,0 +1,19 @@
+import { PDFName } from "pdf-lib";
+export class AnnotationParser {
+  annotation;
+  page;
+  pdfDoc;
+  constructor(pdfDoc, page, annotation) {
+    this.pdfDoc = pdfDoc;
+    this.page = page;
+    this.annotation = annotation;
+  }
+  addAnnotationToPage(page, annotRef) {
+    const annots = page.node.lookup(PDFName.of("Annots"));
+    if (annots) {
+      annots.push(annotRef);
+    } else {
+      page.node.set(PDFName.of("Annots"), page.doc.context.obj([annotRef]));
+    }
+  }
+}

package/dist/runtime/annotation/pdf-export/parse_circle.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationParser } from './parse.js';
+export declare class CircleParser extends AnnotationParser {
+    parse(): Promise<void>;
+}

package/dist/runtime/annotation/pdf-export/parse_circle.js

@@ -0,0 +1,41 @@
+import { PDFName, PDFString } from "pdf-lib";
+import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { AnnotationParser } from "./parse.js";
+const UNKNOWN_USER = "Unknown user";
+export class CircleParser extends AnnotationParser {
+  async parse() {
+    const { annotation, page, pdfDoc } = this;
+    const context = pdfDoc.context;
+    const pageHeight = page.getHeight();
+    const mainAnn = context.obj({
+      Type: PDFName.of("Annot"),
+      Subtype: PDFName.of("Circle"),
+      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+      C: rgbToPdfColor(annotation.color || void 0),
+      T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
+      Contents: stringToPDFHexString(annotation.contentsObj?.text || ""),
+      M: PDFString.of(annotation.date || ""),
+      NM: PDFString.of(annotation.id),
+      Border: [0, 0, 1]
+    });
+    const mainAnnRef = context.register(mainAnn);
+    this.addAnnotationToPage(page, mainAnnRef);
+    for (const comment of annotation.comments || []) {
+      const replyAnn = context.obj({
+        Type: PDFName.of("Annot"),
+        Subtype: PDFName.of("Text"),
+        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+        Contents: stringToPDFHexString(comment.content),
+        T: stringToPDFHexString(comment.title || UNKNOWN_USER),
+        M: PDFString.of(comment.date || ""),
+        C: rgbToPdfColor(annotation.color || void 0),
+        IRT: mainAnnRef,
+        RT: PDFName.of("R"),
+        NM: PDFString.of(comment.id),
+        Open: false
+      });
+      const replyAnnRef = context.register(replyAnn);
+      this.addAnnotationToPage(page, replyAnnRef);
+    }
+  }
+}

package/dist/runtime/annotation/pdf-export/parse_freetext.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationParser } from './parse.js';
+export declare class FreeTextParser extends AnnotationParser {
+    parse(): Promise<void>;
+}

package/dist/runtime/annotation/pdf-export/parse_freetext.js

@@ -0,0 +1,54 @@
+import { PDFName, PDFNumber, PDFString } from "pdf-lib";
+import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { AnnotationParser } from "./parse.js";
+const UNKNOWN_USER = "Unknown user";
+export class FreeTextParser extends AnnotationParser {
+  async parse() {
+    const { annotation, page, pdfDoc } = this;
+    const [x1, , , y2] = convertKonvaRectToPdfRect(annotation.konvaClientRect, page.getHeight());
+    const context = pdfDoc.context;
+    const pageWidth = page.getWidth();
+    const pageHeight = page.getHeight();
+    const iconSize = 20;
+    const xLeft = Math.max(0, Math.min(x1, pageWidth - iconSize));
+    const yTop = Math.min(pageHeight, Math.max(y2, iconSize));
+    const yBottom = yTop - iconSize;
+    const rect = [
+      PDFNumber.of(xLeft),
+      PDFNumber.of(yBottom),
+      PDFNumber.of(xLeft + iconSize),
+      PDFNumber.of(yTop)
+    ];
+    const mainAnn = context.obj({
+      Type: PDFName.of("Annot"),
+      Subtype: PDFName.of("Text"),
+      Rect: rect,
+      NM: PDFString.of(annotation.id),
+      Contents: stringToPDFHexString(annotation.contentsObj?.text || ""),
+      Name: PDFName.of("Comment"),
+      T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
+      M: PDFString.of(annotation.date || ""),
+      C: rgbToPdfColor(annotation.color || void 0),
+      Open: false
+    });
+    const mainAnnRef = context.register(mainAnn);
+    this.addAnnotationToPage(page, mainAnnRef);
+    for (const comment of annotation.comments || []) {
+      const replyAnn = context.obj({
+        Type: PDFName.of("Annot"),
+        Subtype: PDFName.of("Text"),
+        Rect: rect,
+        Contents: stringToPDFHexString(comment.content),
+        T: stringToPDFHexString(comment.title || UNKNOWN_USER),
+        M: PDFString.of(comment.date || ""),
+        C: rgbToPdfColor(annotation.color || void 0),
+        IRT: mainAnnRef,
+        RT: PDFName.of("R"),
+        NM: PDFString.of(comment.id),
+        Open: false
+      });
+      const replyAnnRef = context.register(replyAnn);
+      this.addAnnotationToPage(page, replyAnnRef);
+    }
+  }
+}

package/dist/runtime/annotation/pdf-export/parse_highlight.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationParser } from './parse.js';
+export declare class HighlightParser extends AnnotationParser {
+    parse(): Promise<void>;
+}

package/dist/runtime/annotation/pdf-export/parse_highlight.js

@@ -0,0 +1,134 @@
+import { PDFName, PDFNumber, PDFRawStream, PDFString } from "pdf-lib";
+import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { AnnotationParser } from "./parse.js";
+const UNKNOWN_USER = "Unknown user";
+function formatPdfNumber(value) {
+  if (!Number.isFinite(value)) return "0";
+  return Number(value.toFixed(3)).toString();
+}
+function parseHighlightRects(konvaString) {
+  const konvaGroup = JSON.parse(konvaString);
+  const groupX = konvaGroup.attrs?.x ?? 0;
+  const groupY = konvaGroup.attrs?.y ?? 0;
+  const scaleX = konvaGroup.attrs?.scaleX ?? 1;
+  const scaleY = konvaGroup.attrs?.scaleY ?? 1;
+  const rects = (konvaGroup.children ?? []).filter((item) => item.className === "Rect");
+  return rects.map((rect) => {
+    const x = groupX + (rect.attrs?.x ?? 0) * scaleX;
+    const y = groupY + (rect.attrs?.y ?? 0) * scaleY;
+    const width = (rect.attrs?.width ?? 0) * scaleX;
+    const height = (rect.attrs?.height ?? 0) * scaleY;
+    return { x, y, width, height };
+  }).filter((rect) => rect.width > 0 && rect.height > 0);
+}
+function buildQuadPoints(rects, pageHeight) {
+  const quadPoints = [];
+  for (const rect of rects) {
+    const x = rect.x;
+    const y = rect.y;
+    const width = rect.width;
+    const height = rect.height;
+    const x1 = x;
+    const y1 = pageHeight - y;
+    const x2 = x + width;
+    const y2 = pageHeight - (y + height);
+    quadPoints.push(x1, y1, x2, y1, x1, y2, x2, y2);
+  }
+  return quadPoints;
+}
+export class HighlightParser extends AnnotationParser {
+  async parse() {
+    const { annotation, page, pdfDoc } = this;
+    const context = pdfDoc.context;
+    const pageHeight = page.getHeight();
+    let highlightRects = [];
+    try {
+      highlightRects = parseHighlightRects(annotation.konvaString);
+    } catch {
+      console.warn(`Invalid konva JSON for Highlight annotation ${annotation.id}`);
+    }
+    if (highlightRects.length === 0) {
+      highlightRects = [{
+        x: annotation.konvaClientRect.x,
+        y: annotation.konvaClientRect.y,
+        width: annotation.konvaClientRect.width,
+        height: annotation.konvaClientRect.height
+      }];
+    }
+    const quadPoints = buildQuadPoints(highlightRects, pageHeight);
+    const rect = convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight);
+    const color = rgbToPdfColor(annotation.color || void 0);
+    const [x1, y1, x2, y2] = rect;
+    const appearanceWidth = Math.max(1, x2 - x1);
+    const appearanceHeight = Math.max(1, y2 - y1);
+    const [r, g, b] = color;
+    const commands = [
+      "q",
+      "/GS1 gs",
+      `${formatPdfNumber(r)} ${formatPdfNumber(g)} ${formatPdfNumber(b)} rg`
+    ];
+    for (const highlightRect of highlightRects) {
+      const pageX = highlightRect.x;
+      const pageY = pageHeight - highlightRect.y - highlightRect.height;
+      const localX = pageX - x1;
+      const localY = pageY - y1;
+      commands.push(
+        `${formatPdfNumber(localX)} ${formatPdfNumber(localY)} ${formatPdfNumber(highlightRect.width)} ${formatPdfNumber(highlightRect.height)} re`,
+        "f"
+      );
+    }
+    commands.push("Q");
+    const appearanceStream = PDFRawStream.of(
+      context.obj({
+        Type: PDFName.of("XObject"),
+        Subtype: PDFName.of("Form"),
+        BBox: context.obj([0, 0, appearanceWidth, appearanceHeight]),
+        Resources: context.obj({
+          ExtGState: context.obj({
+            GS1: context.obj({
+              Type: PDFName.of("ExtGState"),
+              ca: PDFNumber.of(0.35),
+              CA: PDFNumber.of(0.35),
+              BM: PDFName.of("Multiply")
+            })
+          })
+        })
+      }),
+      new TextEncoder().encode(commands.join("\n"))
+    );
+    const appearanceRef = context.register(appearanceStream);
+    const ap = context.obj({ N: appearanceRef });
+    const mainAnn = context.obj({
+      Type: PDFName.of("Annot"),
+      Subtype: PDFName.of("Highlight"),
+      Rect: rect,
+      QuadPoints: context.obj(quadPoints),
+      C: context.obj(color),
+      T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
+      Contents: stringToPDFHexString(annotation.contentsObj?.text || ""),
+      M: PDFString.of(annotation.date || ""),
+      NM: PDFString.of(annotation.id),
+      CA: PDFNumber.of(0.35),
+      AP: ap
+    });
+    const mainAnnRef = context.register(mainAnn);
+    this.addAnnotationToPage(page, mainAnnRef);
+    for (const comment of annotation.comments || []) {
+      const replyAnn = context.obj({
+        Type: PDFName.of("Annot"),
+        Subtype: PDFName.of("Text"),
+        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+        Contents: stringToPDFHexString(comment.content),
+        T: stringToPDFHexString(comment.title || UNKNOWN_USER),
+        M: PDFString.of(comment.date || ""),
+        C: rgbToPdfColor(annotation.color || void 0),
+        IRT: mainAnnRef,
+        RT: PDFName.of("R"),
+        NM: PDFString.of(comment.id),
+        Open: false
+      });
+      const replyAnnRef = context.register(replyAnn);
+      this.addAnnotationToPage(page, replyAnnRef);
+    }
+  }
+}

package/dist/runtime/annotation/pdf-export/parse_ink.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationParser } from './parse.js';
+export declare class InkParser extends AnnotationParser {
+    parse(): Promise<void>;
+}

package/dist/runtime/annotation/pdf-export/parse_ink.js

@@ -0,0 +1,124 @@
+import { PDFName, PDFNumber, PDFRawStream, PDFString } from "pdf-lib";
+import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { AnnotationParser } from "./parse.js";
+const UNKNOWN_USER = "Unknown user";
+function formatPdfNumber(value) {
+  if (!Number.isFinite(value)) return "0";
+  return Number(value.toFixed(3)).toString();
+}
+export class InkParser extends AnnotationParser {
+  async parse() {
+    const { annotation, page, pdfDoc } = this;
+    const context = pdfDoc.context;
+    const pageHeight = page.getHeight();
+    let konvaGroup;
+    try {
+      konvaGroup = JSON.parse(annotation.konvaString);
+    } catch {
+      console.warn(`Invalid konva JSON for Ink annotation ${annotation.id}`);
+      return;
+    }
+    const lines = (konvaGroup.children ?? []).filter((item) => item.className === "Line");
+    const groupX = konvaGroup.attrs?.x || 0;
+    const groupY = konvaGroup.attrs?.y || 0;
+    const scaleX = konvaGroup.attrs?.scaleX || 1;
+    const scaleY = konvaGroup.attrs?.scaleY || 1;
+    const transformedPaths = [];
+    for (const line of lines) {
+      const points = line.attrs?.points ?? [];
+      if (points.length < 4) continue;
+      const transformedPoints = [];
+      for (let i = 0; i < points.length; i += 2) {
+        const x = groupX + points[i] * scaleX;
+        const y = groupY + points[i + 1] * scaleY;
+        transformedPoints.push(x, pageHeight - y);
+      }
+      transformedPaths.push(transformedPoints);
+    }
+    if (transformedPaths.length === 0) {
+      console.warn(`Ink annotation ${annotation.id} has no drawable paths`);
+      return;
+    }
+    const inkList = context.obj(
+      transformedPaths.map((path) => context.obj(path))
+    );
+    const firstLine = lines[0]?.attrs || {};
+    const strokeWidth = firstLine.strokeWidth ?? 1;
+    const opacity = firstLine.opacity ?? 1;
+    const color = firstLine.stroke ?? annotation.color ?? "rgb(255, 0, 0)";
+    const [r, g, b] = rgbToPdfColor(color);
+    const bs = context.obj({
+      W: PDFNumber.of(strokeWidth),
+      S: PDFName.of("S")
+    });
+    const rect = convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight);
+    const [x1, y1, x2, y2] = rect;
+    const appearanceWidth = Math.max(1, x2 - x1);
+    const appearanceHeight = Math.max(1, y2 - y1);
+    const commands = [
+      "q",
+      `${formatPdfNumber(r)} ${formatPdfNumber(g)} ${formatPdfNumber(b)} RG`,
+      `${formatPdfNumber(Math.max(0.1, strokeWidth))} w`,
+      "1 J",
+      "1 j"
+    ];
+    for (const path of transformedPaths) {
+      if (path.length < 4) continue;
+      commands.push(
+        `${formatPdfNumber(path[0] - x1)} ${formatPdfNumber(path[1] - y1)} m`
+      );
+      for (let i = 2; i < path.length; i += 2) {
+        commands.push(
+          `${formatPdfNumber(path[i] - x1)} ${formatPdfNumber(path[i + 1] - y1)} l`
+        );
+      }
+      commands.push("S");
+    }
+    commands.push("Q");
+    const appearanceStream = PDFRawStream.of(
+      context.obj({
+        Type: PDFName.of("XObject"),
+        Subtype: PDFName.of("Form"),
+        BBox: context.obj([0, 0, appearanceWidth, appearanceHeight]),
+        Resources: context.obj({})
+      }),
+      new TextEncoder().encode(commands.join("\n"))
+    );
+    const appearanceRef = context.register(appearanceStream);
+    const ap = context.obj({ N: appearanceRef });
+    const mainAnn = context.obj({
+      Type: PDFName.of("Annot"),
+      Subtype: PDFName.of("Ink"),
+      Rect: rect,
+      InkList: inkList,
+      C: context.obj([PDFNumber.of(r), PDFNumber.of(g), PDFNumber.of(b)]),
+      T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
+      Contents: stringToPDFHexString(annotation.contentsObj?.text || ""),
+      M: PDFString.of(annotation.date || ""),
+      NM: PDFString.of(annotation.id),
+      Border: context.obj([0, 0, 0]),
+      BS: bs,
+      CA: PDFNumber.of(opacity),
+      AP: ap
+    });
+    const mainAnnRef = context.register(mainAnn);
+    this.addAnnotationToPage(page, mainAnnRef);
+    for (const comment of annotation.comments || []) {
+      const replyAnn = context.obj({
+        Type: PDFName.of("Annot"),
+        Subtype: PDFName.of("Text"),
+        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+        Contents: stringToPDFHexString(comment.content),
+        T: stringToPDFHexString(comment.title || UNKNOWN_USER),
+        M: PDFString.of(comment.date || ""),
+        C: context.obj([PDFNumber.of(r), PDFNumber.of(g), PDFNumber.of(b)]),
+        IRT: mainAnnRef,
+        RT: PDFName.of("R"),
+        NM: PDFString.of(comment.id),
+        Open: false
+      });
+      const replyAnnRef = context.register(replyAnn);
+      this.addAnnotationToPage(page, replyAnnRef);
+    }
+  }
+}

package/dist/runtime/annotation/pdf-export/parse_line.d.ts

@@ -0,0 +1,4 @@
+import { AnnotationParser } from './parse.js';
+export declare class LineParser extends AnnotationParser {
+    parse(): Promise<void>;
+}