web-doc 0.6.2 → 0.7.0

package/dist/edit/pdf/engine/text-box.js

@@ -0,0 +1,317 @@
+import { MARK_NAME, MARK_PARAM, OBJECT_TEXT, } from "./elements.js";
+import { displayedSize, pageToUser } from "./geometry.js";
+import { layoutText } from "./text-layout.js";
+import { tableSpecOf, tableText } from "./tables.js";
+export const insertTextBox = {
+    validate(operation, context, issue) {
+        if (operation.pageIndex >= context.pageCount) {
+            issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+            return;
+        }
+        validateRect(operation.rect, context.geometry(operation.pageIndex), issue);
+        validateFont(fontRequest(resolveStyle(operation.style ?? {}), operation.text), context, issue);
+    },
+    apply(operation, context) {
+        const id = context.newId(operation.pageIndex);
+        const spec = {
+            kind: "textBox",
+            id,
+            rect: operation.rect,
+            text: operation.text,
+            style: resolveStyle(operation.style ?? {}),
+        };
+        const drawn = drawTextBox(context, operation.pageIndex, spec);
+        return {
+            createdIds: [id],
+            changedPages: [operation.pageIndex],
+            warnings: warningsFor(drawn, id),
+        };
+    },
+};
+/** `replaceText` for a text box: a rebuild from its inputs with new text. */
+export const textBoxReplaceText = {
+    validate(operation, context, issue) {
+        const target = textBoxTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        validateFont(fontRequest(target.spec.style, operation.text), context, issue);
+    },
+    apply(operation, context) {
+        const { location, spec } = textBoxTarget(operation.target, context);
+        return changed(location, rebuildTextBox(context, location, { ...spec, text: operation.text }));
+    },
+};
+/** `setTextStyle` for a text box: a rebuild with the merged style. */
+export const textBoxSetTextStyle = {
+    validate(operation, context, issue) {
+        const target = textBoxTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        const style = { ...target.spec.style, ...definedFields(operation.style) };
+        validateFont(fontRequest(style, target.spec.text), context, issue);
+    },
+    apply(operation, context) {
+        const { location, spec } = textBoxTarget(operation.target, context);
+        return changed(location, rebuildTextBox(context, location, {
+            ...spec,
+            style: { ...spec.style, ...definedFields(operation.style) },
+        }));
+    },
+};
+/**
+ * Lays the box out and inserts one text object per line, appended to the
+ * page or at `insertAt` in drawing order.
+ */
+export function drawTextBox(context, pageIndex, spec, insertAt) {
+    const { pdfium, measurer } = context;
+    const { lib } = pdfium;
+    const font = context.fonts.resolve(pdfium, context.document, fontRequest(spec.style, spec.text));
+    const { ascent } = measurer.metrics(font.handle, spec.style.fontSize);
+    const layout = layoutText({
+        text: spec.text,
+        width: spec.rect.width,
+        height: spec.rect.height,
+        fontSize: spec.style.fontSize,
+        lineHeight: spec.style.lineHeight,
+        align: spec.style.align,
+        ascent,
+        advance: (text) => measurer.advance(font.handle, spec.style.fontSize, text),
+    });
+    const geometry = context.geometry(pageIndex);
+    const [r, g, b] = parseColor(spec.style.color);
+    const params = JSON.stringify(spec);
+    context.withPage(pageIndex, (page) => {
+        const records = [];
+        let index = insertAt ?? -1;
+        for (const line of layout.lines) {
+            const object = lib.FPDFPageObj_CreateTextObj(context.document, font.handle, spec.style.fontSize);
+            setText(pdfium, object, line.text);
+            lib.FPDFPageObj_SetFillColor(object, r, g, b, 255);
+            placeUpright(pdfium, object, geometry, spec.rect.x + line.x, spec.rect.y + line.baseline);
+            const mark = lib.FPDFPageObj_AddMark(object, MARK_NAME);
+            lib.FPDFPageObjMark_SetStringParam(context.document, object, mark, MARK_PARAM, params);
+            if (insertAt === undefined)
+                lib.FPDFPage_InsertObject(page, object);
+            else
+                lib.FPDFPage_InsertObjectAtIndex(page, object, index++);
+            records.push({ id: spec.id, type: OBJECT_TEXT, mark: spec });
+        }
+        if (insertAt === undefined)
+            context.appendObjects(pageIndex, records);
+        else
+            context.spliceObjects(pageIndex, insertAt, 0, records);
+    });
+    return {
+        overflow: layout.overflow,
+        ...(font.substitution ? { substitution: font.substitution } : {}),
+    };
+}
+/**
+ * Replaces a text box's objects with ones drawn from `spec`, at the same
+ * place in the drawing order so nothing else changes its stacking.
+ */
+export function rebuildTextBox(context, location, spec) {
+    const first = removeObjects(context, location);
+    return drawTextBox(context, location.pageIndex, spec, first);
+}
+/** Removes an element's objects from the page; returns where they started. */
+export function removeObjects(context, location) {
+    const { lib } = context.pdfium;
+    const first = location.indexes[0];
+    context.withPage(location.pageIndex, (page) => {
+        // Highest first, so earlier indexes stay valid while removing.
+        for (const index of [...location.indexes].reverse()) {
+            const object = lib.FPDFPage_GetObject(page, index);
+            lib.FPDFPage_RemoveObject(page, object);
+            lib.FPDFPageObj_Destroy(object);
+        }
+    });
+    context.spliceObjects(location.pageIndex, first, location.indexes.length, []);
+    return first;
+}
+/** The location and stored inputs of a text box, or the issue that stops the edit. */
+export function textBoxTarget(target, context, issue = () => { }) {
+    const location = context.locate(target);
+    if (!location) {
+        issue("/target", "unknown-target", `No element ${target}`);
+        return undefined;
+    }
+    if (location.record.mark?.kind !== "textBox") {
+        issue("/target", "unsupported-target", "Only text boxes created by web-doc can be edited yet");
+        return undefined;
+    }
+    return { location, spec: location.record.mark };
+}
+export function changed(location, drawn) {
+    return {
+        createdIds: [],
+        changedPages: [location.pageIndex],
+        warnings: warningsFor(drawn, location.record.id),
+    };
+}
+function warningsFor(drawn, elementId) {
+    return [
+        ...(drawn.overflow
+            ? [
+                {
+                    code: "fidelity-degraded",
+                    message: "The text does not fit the box's height and runs past it",
+                    details: { elementId },
+                },
+            ]
+            : []),
+        ...(drawn.substitution
+            ? [
+                {
+                    code: "font-substitution",
+                    message: drawn.substitution,
+                    details: { elementId },
+                },
+            ]
+            : []),
+    ];
+}
+/**
+ * The fonts a batch will need: what each operation draws, read from the
+ * operation itself, from the text box it rebuilds, or from the text object
+ * it may have to replace.
+ */
+export function fontRequestsOf(operations, markOf, elementOf) {
+    const requests = [];
+    const spec = (id) => {
+        const mark = markOf(id);
+        return mark?.kind === "textBox"
+            ? mark
+            : undefined;
+    };
+    const table = (id) => tableSpecOf(markOf(id));
+    for (const raw of operations) {
+        const operation = raw;
+        switch (operation.op) {
+            case "insertTextBox":
+                requests.push({
+                    family: operation.style?.fontFamily ?? "Helvetica",
+                    text: operation.text,
+                });
+                break;
+            case "replaceText": {
+                const box = spec(operation.target);
+                if (box) {
+                    requests.push({ family: box.style.fontFamily, text: operation.text });
+                    break;
+                }
+                const element = elementOf(operation.target);
+                if (element?.kind === "text")
+                    requests.push({
+                        family: element.textStyle?.fontFamily ?? "Helvetica",
+                        text: operation.text,
+                    });
+                break;
+            }
+            case "setTextStyle": {
+                const box = spec(operation.target);
+                if (box)
+                    requests.push({
+                        family: operation.style.fontFamily ?? box.style.fontFamily,
+                        text: box.text,
+                    });
+                break;
+            }
+            case "resizeElement":
+            case "moveElement": {
+                const box = spec(operation.target);
+                if (box)
+                    requests.push({ family: box.style.fontFamily, text: box.text });
+                const grid = table(operation.target);
+                if (grid)
+                    requests.push({
+                        family: grid.style.fontFamily,
+                        text: tableText(grid.rows),
+                    });
+                break;
+            }
+            case "insertTable":
+                requests.push({
+                    family: operation.style?.fontFamily ?? "Helvetica",
+                    text: tableText(operation.rows),
+                });
+                break;
+            case "setTableCell": {
+                const grid = table(operation.target);
+                if (grid)
+                    requests.push({
+                        family: grid.style.fontFamily,
+                        text: `${tableText(grid.rows)}\n${operation.text}`,
+                    });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return requests;
+}
+export function fontRequest(style, text) {
+    return {
+        family: style.fontFamily,
+        bold: style.bold,
+        italic: style.italic,
+        text,
+    };
+}
+export function validateFont(request, context, issue) {
+    const problem = context.fonts.problem(request);
+    if (problem)
+        issue(problem.path, problem.code, problem.message);
+}
+/**
+ * Positions an object so it reads upright on the displayed page: the object's
+ * origin goes to the page-space point and it turns against the page's /Rotate.
+ */
+export function placeUpright(pdfium, object, geometry, pageX, pageY) {
+    const [a, b, c, d] = ROTATIONS[geometry.rotation % 4];
+    const origin = pageToUser(geometry, pageX, pageY);
+    pdfium.lib.FPDFPageObj_Transform(object, a, b, c, d, origin.x, origin.y);
+}
+/** Counter-clockwise quarter turns in user space, which cancel the page's clockwise /Rotate. */
+const ROTATIONS = [
+    [1, 0, 0, 1],
+    [0, 1, -1, 0],
+    [-1, 0, 0, -1],
+    [0, -1, 1, 0],
+];
+export function setText(pdfium, object, text) {
+    const wide = pdfium.writeWideString(text);
+    try {
+        pdfium.lib.FPDFText_SetText(object, wide);
+    }
+    finally {
+        pdfium.free(wide);
+    }
+}
+export function parseColor(color) {
+    return [1, 3, 5].map((offset) => Number.parseInt(color.slice(offset, offset + 2), 16));
+}
+export function resolveStyle(style) {
+    return {
+        fontFamily: style.fontFamily ?? "Helvetica",
+        fontSize: style.fontSize ?? 12,
+        bold: style.bold ?? false,
+        italic: style.italic ?? false,
+        color: style.color ?? "#000000",
+        align: style.align ?? "left",
+        lineHeight: style.lineHeight ?? 1.2,
+    };
+}
+function definedFields(style) {
+    return Object.fromEntries(Object.entries(style).filter(([, value]) => value !== undefined));
+}
+export function validateRect(rect, geometry, issue, path = "/rect") {
+    const size = displayedSize(geometry);
+    const tolerance = 0.01;
+    if (rect.x < -tolerance ||
+        rect.y < -tolerance ||
+        rect.x + rect.width > size.width + tolerance ||
+        rect.y + rect.height > size.height + tolerance)
+        issue(path, "range", `The rectangle must lie within the ${size.width}×${size.height} pt page`);
+}

package/dist/edit/pdf/engine/text-layout.d.ts

@@ -0,0 +1,28 @@
+import type { PdfTextAlign } from "../types.js";
+export interface LayoutInput {
+    readonly text: string;
+    readonly width: number;
+    readonly height: number;
+    readonly fontSize: number;
+    /** Multiple of the font size. */
+    readonly lineHeight: number;
+    readonly align: PdfTextAlign;
+    readonly ascent: number;
+    /** Width of a string in points at the font size. */
+    readonly advance: (text: string) => number;
+}
+export interface LayoutLine {
+    readonly text: string;
+    /** Offset of the line's left edge from the box's left edge. */
+    readonly x: number;
+    /** Offset of the baseline from the box's top edge. */
+    readonly baseline: number;
+    readonly width: number;
+}
+export interface Layout {
+    readonly lines: readonly LayoutLine[];
+    /** Height the lines need; may exceed the box. */
+    readonly height: number;
+    readonly overflow: boolean;
+}
+export declare function layoutText(input: LayoutInput): Layout;

package/dist/edit/pdf/engine/text-layout.js

@@ -0,0 +1,67 @@
+export function layoutText(input) {
+    const step = input.fontSize * input.lineHeight;
+    const texts = [];
+    for (const paragraph of input.text.replaceAll("\r\n", "\n").split("\n"))
+        texts.push(...wrapParagraph(paragraph.replaceAll("\t", " "), input));
+    const lines = texts.map((text, index) => {
+        const width = input.advance(text);
+        return {
+            text,
+            x: offset(input.align, input.width, width),
+            baseline: index * step + input.ascent,
+            width,
+        };
+    });
+    const height = lines.length * step;
+    return { lines, height, overflow: height > input.height + 0.001 };
+}
+function wrapParagraph(paragraph, input) {
+    const lines = [];
+    let current = "";
+    const push = () => {
+        lines.push(current.trimEnd());
+        current = "";
+    };
+    // Runs of spaces travel with the line they are in; a word that does not
+    // fit moves to the next line, and one wider than the box is cut.
+    for (const token of paragraph.match(/ +|[^ ]+/g) ?? []) {
+        if (token.startsWith(" ")) {
+            current += token;
+            continue;
+        }
+        const candidate = current + token;
+        if (input.advance(candidate) <= input.width) {
+            current = candidate;
+            continue;
+        }
+        if (current.trim())
+            push();
+        else
+            current = "";
+        if (input.advance(token) <= input.width) {
+            current = token;
+            continue;
+        }
+        for (const character of token) {
+            const next = current + character;
+            if (current && input.advance(next) > input.width) {
+                push();
+                current = character;
+            }
+            else
+                current = next;
+        }
+    }
+    lines.push(current.trimEnd());
+    return lines;
+}
+function offset(align, boxWidth, lineWidth) {
+    switch (align) {
+        case "center":
+            return Math.max(0, (boxWidth - lineWidth) / 2);
+        case "right":
+            return Math.max(0, boxWidth - lineWidth);
+        default:
+            return 0;
+    }
+}

package/dist/edit/pdf/engine/transform.d.ts

@@ -0,0 +1,5 @@
+import type { DeleteElementOperation, MoveElementOperation, ResizeElementOperation } from "../types.js";
+import type { OperationHandler } from "./operations.js";
+export declare const moveElement: OperationHandler<MoveElementOperation>;
+export declare const resizeElement: OperationHandler<ResizeElementOperation>;
+export declare const deleteElement: OperationHandler<DeleteElementOperation>;

package/dist/edit/pdf/engine/transform.js

@@ -0,0 +1,137 @@
+import { pageToUser } from "./geometry.js";
+import { changed, rebuildTextBox, removeObjects, validateRect, } from "./text-box.js";
+import { changedTable, rebuildTable, tableSpecOf } from "./tables.js";
+/*
+ * Geometry operations that apply to any element. Plain objects are moved and
+ * stretched through PDFium matrices in user space; web-doc's own composites
+ * are rebuilt from their stored inputs so the mark stays true.
+ */
+export const moveElement = {
+    validate(operation, context, issue) {
+        const target = anyTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        if ((operation.to === undefined) === (operation.by === undefined)) {
+            issue("", "one-of", "Give exactly one of `to` and `by`");
+            return;
+        }
+        const delta = moveDelta(operation, target.element.bounds);
+        validateRect(shifted(target.element.bounds, delta.dx, delta.dy), context.geometry(target.location.pageIndex), issue, operation.to ? "/to" : "/by");
+    },
+    apply(operation, context) {
+        const { location, element } = anyTarget(operation.target, context);
+        const { dx, dy } = moveDelta(operation, element.bounds);
+        const spec = textBoxSpec(location);
+        if (spec)
+            return changed(location, rebuildTextBox(context, location, {
+                ...spec,
+                rect: shifted(spec.rect, dx, dy),
+            }));
+        const table = tableSpecOf(location.record.mark);
+        if (table)
+            return changedTable(location, rebuildTable(context, location, {
+                ...table,
+                at: { x: table.at.x + dx, y: table.at.y + dy },
+            }));
+        const geometry = context.geometry(location.pageIndex);
+        const from = pageToUser(geometry, 0, 0);
+        const to = pageToUser(geometry, dx, dy);
+        transformObjects(context, location, [
+            1,
+            0,
+            0,
+            1,
+            to.x - from.x,
+            to.y - from.y,
+        ]);
+        return changed(location, { overflow: false });
+    },
+};
+export const resizeElement = {
+    validate(operation, context, issue) {
+        const target = anyTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        if (target.element.kind === "table") {
+            issue("/target", "unsupported-target", "Tables cannot be resized");
+            return;
+        }
+        validateRect(operation.rect, context.geometry(target.location.pageIndex), issue);
+    },
+    apply(operation, context) {
+        const { location, element } = anyTarget(operation.target, context);
+        const spec = textBoxSpec(location);
+        if (spec)
+            return changed(location, rebuildTextBox(context, location, { ...spec, rect: operation.rect }));
+        const geometry = context.geometry(location.pageIndex);
+        const { bounds } = element;
+        // Scale about the top-left corner in page space, then move it into place.
+        const scaleX = operation.rect.width / bounds.width;
+        const scaleY = operation.rect.height / bounds.height;
+        const [userScaleX, userScaleY] = geometry.rotation % 2 === 0 ? [scaleX, scaleY] : [scaleY, scaleX];
+        const anchor = pageToUser(geometry, bounds.x, bounds.y);
+        transformObjects(context, location, [
+            userScaleX,
+            0,
+            0,
+            userScaleY,
+            anchor.x - userScaleX * anchor.x,
+            anchor.y - userScaleY * anchor.y,
+        ]);
+        const from = pageToUser(geometry, 0, 0);
+        const to = pageToUser(geometry, operation.rect.x - bounds.x, operation.rect.y - bounds.y);
+        transformObjects(context, location, [
+            1,
+            0,
+            0,
+            1,
+            to.x - from.x,
+            to.y - from.y,
+        ]);
+        return changed(location, { overflow: false });
+    },
+};
+export const deleteElement = {
+    validate(operation, context, issue) {
+        anyTarget(operation.target, context, issue);
+    },
+    apply(operation, context) {
+        const { location } = anyTarget(operation.target, context);
+        removeObjects(context, location);
+        return {
+            ...changed(location, { overflow: false }),
+            removedIds: [operation.target],
+        };
+    },
+};
+/** Any element, by id, with its location; reports a missing one. */
+function anyTarget(target, context, issue = () => { }) {
+    const location = context.locate(target);
+    const element = location && context.element(target);
+    if (!location || !element) {
+        issue("/target", "unknown-target", `No element ${target}`);
+        return undefined;
+    }
+    return { location, element };
+}
+function textBoxSpec(location) {
+    return location.record.mark?.kind === "textBox"
+        ? location.record.mark
+        : undefined;
+}
+function moveDelta(operation, bounds) {
+    return operation.to
+        ? { dx: operation.to.x - bounds.x, dy: operation.to.y - bounds.y }
+        : { dx: operation.by.dx, dy: operation.by.dy };
+}
+function shifted(rect, dx, dy) {
+    return { ...rect, x: rect.x + dx, y: rect.y + dy };
+}
+/** Concatenates a user-space matrix onto every object of an element. */
+function transformObjects(context, location, [a, b, c, d, e, f]) {
+    const { lib } = context.pdfium;
+    context.withPage(location.pageIndex, (page) => {
+        for (const index of location.indexes)
+            lib.FPDFPageObj_Transform(lib.FPDFPage_GetObject(page, index), a, b, c, d, e, f);
+    });
+}

package/dist/edit/pdf/provider.d.ts

@@ -0,0 +1,35 @@
+import { type WorkerLike } from "../../worker-client.js";
+import type { EditEngineContext } from "../engine.js";
+import type { PagePoint, PageRect, TextPosition, TextRange } from "../types.js";
+import { WorkerEngineClient } from "../worker-engine.js";
+import type { PageBitmap, PageLayout, TextLayout } from "./types.js";
+/** The reads behind the overlay primitives, beyond the core engine interface. */
+export interface PdfEngineReads {
+    textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
+    rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
+    renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;
+    pageLayout(pageIndex: number, signal: AbortSignal): Promise<PageLayout | undefined>;
+}
+export interface PdfEditProviderOptions {
+    readonly workerUrl?: string | URL;
+    readonly wasmUrl?: string | URL;
+    /** TrueType font for text the standard fonts cannot encode. */
+    readonly fallbackFontUrl?: string | URL;
+    /** Test hook: supplies the worker instead of the packaged script. */
+    readonly createWorker?: () => WorkerLike;
+}
+/**
+ * Starts the PDF edit worker for `original` and returns the engine the core
+ * drives. Loaded lazily by the PDF adapter's provider on the first `edit()`.
+ */
+export declare function loadPdfEditEngine(original: Uint8Array, context: EditEngineContext, options?: PdfEditProviderOptions): Promise<PdfEditEngineClient>;
+export declare class PdfEditEngineClient extends WorkerEngineClient implements PdfEngineReads {
+    readonly schemas: import("../types.js").OperationSchemaSet;
+    start(original: Uint8Array, options: PdfEditProviderOptions): Promise<void>;
+    textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
+    rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
+    renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;
+    pageLayout(pageIndex: number, signal: AbortSignal): Promise<PageLayout | undefined>;
+}

package/dist/edit/pdf/provider.js

@@ -0,0 +1,92 @@
+import { ViewerError } from "../../errors.js";
+import { WorkerRpcClient } from "../../worker-client.js";
+import { packageRelativeUrl, resolveAssetUrl, WorkerEngineClient, } from "../worker-engine.js";
+import { pdfOperationSchemas } from "./schemas.js";
+/**
+ * Starts the PDF edit worker for `original` and returns the engine the core
+ * drives. Loaded lazily by the PDF adapter's provider on the first `edit()`.
+ */
+export async function loadPdfEditEngine(original, context, options = {}) {
+    const worker = options.createWorker
+        ? options.createWorker()
+        : createPackagedWorker(options, context);
+    const rpc = new WorkerRpcClient(worker);
+    const engine = new PdfEditEngineClient(rpc, context);
+    try {
+        await engine.start(original, options);
+        return engine;
+    }
+    catch (error) {
+        rpc.destroy();
+        throw error;
+    }
+}
+export class PdfEditEngineClient extends WorkerEngineClient {
+    schemas = pdfOperationSchemas;
+    async start(original, options) {
+        const base = this.context.assetBaseUrl;
+        const init = {
+            wasmUrl: resolveAssetUrl(options.wasmUrl, base, base
+                ? new URL("assets/pdfium/pdfium.wasm", base)
+                : packageRelativeUrl("../../../assets/pdfium/pdfium.wasm", import.meta.url)).href,
+            fallbackFontUrl: resolveAssetUrl(options.fallbackFontUrl, base, base
+                ? new URL("fonts/noto-sans-latin-cyrillic.ttf", base)
+                : packageRelativeUrl("../../../fonts/noto-sans-latin-cyrillic.ttf", import.meta.url)).href,
+        };
+        await this.request("edit-init", init, this.context.signal);
+        const data = original.slice().buffer;
+        const fonts = (this.context.fonts ?? []).map(toWorkerFont);
+        const open = {
+            data,
+            limits: this.context.limits,
+            format: "pdf",
+            ...(this.context.fileName ? { fileName: this.context.fileName } : {}),
+            ...(fonts.length > 0 ? { fonts } : {}),
+        };
+        await this.request("edit-open", open, this.context.signal, [
+            data,
+            ...fonts
+                .map((font) => font.source)
+                .filter((source) => source instanceof ArrayBuffer),
+        ]);
+    }
+    textLayout(id, signal) {
+        return this.request("edit-text-layout", { id }, signal);
+    }
+    positionAt(pageIndex, point, signal) {
+        return this.request("edit-position-at", { pageIndex, point }, signal);
+    }
+    rangeRects(range, signal) {
+        return this.request("edit-range-rects", { range }, signal);
+    }
+    async renderWithout(pageIndex, elementIds, scale, signal) {
+        const bitmap = await this.request("edit-render-without", { pageIndex, elementIds, scale }, signal);
+        return { ...bitmap, data: new Uint8Array(bitmap.data) };
+    }
+    pageLayout(pageIndex, signal) {
+        return this.request("edit-page-layout", { pageIndex }, signal);
+    }
+}
+/** A host font in the worker's shape: bytes are copied, URLs made absolute. */
+function toWorkerFont(font) {
+    const source = font.source instanceof ArrayBuffer
+        ? font.source.slice(0)
+        : font.source instanceof Uint8Array
+            ? font.source.slice().buffer
+            : new URL(font.source, globalThis.location?.href ?? "http://localhost/")
+                .href;
+    return {
+        family: font.family,
+        weight: font.weight ?? 400,
+        style: font.style ?? "normal",
+        source,
+    };
+}
+function createPackagedWorker(options, context) {
+    if (typeof Worker === "undefined")
+        throw new ViewerError("edit-unsupported", "PDF editing requires a browser module Worker", { details: { format: "pdf", reason: "no-worker" } });
+    const url = resolveAssetUrl(options.workerUrl, context.assetBaseUrl, context.assetBaseUrl
+        ? new URL("workers/pdf-edit-worker.js", context.assetBaseUrl)
+        : packageRelativeUrl("../../../workers/pdf-edit-worker.js", import.meta.url));
+    return new Worker(url, { type: "module", name: "web-doc-pdf-edit" });
+}