web-doc 0.6.2 → 0.7.0

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

@@ -0,0 +1,108 @@
+import { ViewerError } from "../../../errors.js";
+import { pdfOperationSchemas } from "../schemas.js";
+import { PdfEditDocument } from "./document.js";
+import { AssetStore } from "../../assets.js";
+import { FontLibrary } from "./fonts.js";
+/**
+ * Serves the edit worker protocol for one PDF document. It runs inside the
+ * edit worker in the browser and directly in Node tests; the host supplies
+ * how WebAssembly and fonts are obtained.
+ */
+export function createPdfEditHandler(host) {
+    let pdfium;
+    let state;
+    const fonts = new FontLibrary((url) => host.fetchBytes(url));
+    const assets = new AssetStore();
+    const engine = () => {
+        if (!state)
+            throw new ViewerError("lifecycle-error", "No PDF is open for editing");
+        return state;
+    };
+    return async (operation, payload) => {
+        switch (operation) {
+            case "edit-init": {
+                const init = payload;
+                pdfium ??= await host.loadPdfium(init.wasmUrl);
+                fonts.setFallbackUrl(init.fallbackFontUrl);
+                return undefined;
+            }
+            case "edit-open": {
+                if (!pdfium)
+                    throw new ViewerError("lifecycle-error", "PDFium is not initialised");
+                const open = payload;
+                state?.dispose();
+                fonts.register(open.fonts ?? []);
+                state = new PdfEditDocument(pdfium, new Uint8Array(open.data), fonts, open.limits, assets, host.compact);
+                const result = { pageCount: state.pageCount };
+                return result;
+            }
+            case "edit-validate": {
+                const { operations } = payload;
+                await fonts.prepare(engine().fontRequests(operations));
+                await engine().images.prepare(operations, host.decodeImage, assets);
+                return engine().validate(operations);
+            }
+            case "edit-apply": {
+                const { batch } = payload;
+                await fonts.prepare(engine().fontRequests(batch.operations));
+                await engine().images.prepare(batch.operations, host.decodeImage, assets);
+                return engine().apply(batch);
+            }
+            case "edit-put-asset": {
+                const { id, data } = payload;
+                assets.set(id, new Uint8Array(data));
+                return undefined;
+            }
+            case "edit-materialize": {
+                const { purpose, options } = (payload ?? {});
+                const mode = options?.mode;
+                const { bytes, warnings } = engine().materializeDocument(purpose ?? "show", mode === "full" || mode === "incremental" ? mode : undefined);
+                return { data: bytes.buffer, warnings };
+            }
+            case "edit-restore": {
+                const { batches, base } = payload;
+                const operations = batches.flatMap((batch) => batch.operations);
+                await fonts.prepare(engine().fontRequests(operations));
+                await engine().images.prepare(operations, host.decodeImage, assets);
+                engine().restore({
+                    batches,
+                    ...(base ? { base: new Uint8Array(base) } : {}),
+                });
+                return undefined;
+            }
+            case "edit-elements":
+                return engine().getElements(payload.query);
+            case "edit-element":
+                return engine().getElement(payload.id);
+            case "edit-elements-at": {
+                const { pageIndex, point } = payload;
+                return engine().elementsAt(pageIndex, point);
+            }
+            case "edit-find-text": {
+                const { query, options } = payload;
+                return engine().findText(query, options);
+            }
+            case "edit-text-layout":
+                return engine().textLayout(payload.id);
+            case "edit-position-at": {
+                const { pageIndex, point } = payload;
+                return engine().positionAt(pageIndex, point);
+            }
+            case "edit-range-rects":
+                return engine().rangeRects(payload.range);
+            case "edit-render-without": {
+                const { pageIndex, elementIds, scale } = payload;
+                return engine().renderPageWithout(pageIndex, elementIds, scale);
+            }
+            case "edit-page-layout":
+                return engine().pageLayout(payload.pageIndex);
+            case "edit-dispose":
+                state?.dispose();
+                state = undefined;
+                return undefined;
+            default:
+                throw new ViewerError("internal", `The PDF edit worker does not handle ${operation}`);
+        }
+    };
+}
+export { pdfOperationSchemas };

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

@@ -0,0 +1,33 @@
+import { type AssetSource } from "../../assets.js";
+import type { EditOperation } from "../../types.js";
+import type { InsertImageOperation } from "../types.js";
+import type { OperationHandler } from "./operations.js";
+export interface DecodedImage {
+    readonly width: number;
+    readonly height: number;
+    /** Row-major RGBA, 4 bytes per pixel. */
+    readonly rgba: Uint8Array;
+}
+export type ImageDecoder = (bytes: Uint8Array, mimeType: "image/png" | "image/jpeg") => Promise<DecodedImage>;
+/**
+ * Decoded pixels for the PNG operations of a batch, keyed by content, so the
+ * synchronous apply never decodes. Only the last few images are kept.
+ */
+export declare class ImageCache {
+    #private;
+    /** Decodes every PNG the batch inserts; must run before validate or apply. */
+    prepare(operations: readonly EditOperation[], decode: ImageDecoder, assets: AssetSource): Promise<void>;
+    get(bytes: Uint8Array): DecodedImage | undefined;
+}
+export declare const insertImage: OperationHandler<InsertImageOperation>;
+export declare function isPng(bytes: Uint8Array): boolean;
+/** Width and height from the IHDR chunk. */
+export declare function pngSize(bytes: Uint8Array): {
+    width: number;
+    height: number;
+} | undefined;
+/** Width and height from the first SOF marker of a baseline or progressive JPEG. */
+export declare function jpegSize(bytes: Uint8Array): {
+    width: number;
+    height: number;
+} | undefined;

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

@@ -0,0 +1,188 @@
+import { ViewerError } from "../../../errors.js";
+import { resolveBinary } from "../../assets.js";
+import { OBJECT_IMAGE } from "./elements.js";
+import { pageToUser } from "./geometry.js";
+import { validateRect } from "./text-box.js";
+/*
+ * Raster images. JPEG data is handed to PDFium as it is, so the file keeps
+ * the original stream; PNG data is decoded by the host (createImageBitmap in
+ * the worker) into pixels PDFium stores losslessly, alpha included.
+ */
+/** FPDFBitmap_CreateEx pixel format with alpha. */
+const BITMAP_BGRA = 4;
+/**
+ * Decoded pixels for the PNG operations of a batch, keyed by content, so the
+ * synchronous apply never decodes. Only the last few images are kept.
+ */
+export class ImageCache {
+    #decoded = new Map();
+    /** Decodes every PNG the batch inserts; must run before validate or apply. */
+    async prepare(operations, decode, assets) {
+        for (const raw of operations) {
+            const operation = raw;
+            if (operation.op !== "insertImage" || operation.mimeType !== "image/png")
+                continue;
+            const bytes = resolveBinary(operation.data, assets);
+            if (!isPng(bytes))
+                continue;
+            const key = contentKey(bytes);
+            if (this.#decoded.has(key))
+                continue;
+            this.#decoded.set(key, await decode(bytes, "image/png"));
+            while (this.#decoded.size > 8)
+                this.#decoded.delete(this.#decoded.keys().next().value);
+        }
+    }
+    get(bytes) {
+        return this.#decoded.get(contentKey(bytes));
+    }
+}
+export const insertImage = {
+    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);
+        const bytes = resolveBinary(operation.data, context.assets);
+        if (bytes.byteLength > context.limits.maxInputBytes)
+            throw new ViewerError("resource-limit", "Image data exceeds maxInputBytes", {
+                details: {
+                    bytes: bytes.byteLength,
+                    limit: context.limits.maxInputBytes,
+                },
+            });
+        const size = operation.mimeType === "image/png" ? pngSize(bytes) : jpegSize(bytes);
+        if (!size) {
+            issue("/data", "invalid-data", `The data is not a readable ${operation.mimeType} image`);
+            return;
+        }
+        const pixels = size.width * size.height;
+        if (!Number.isSafeInteger(pixels) ||
+            pixels > context.limits.maxDecodedPixels)
+            throw new ViewerError("resource-limit", "Decoded image exceeds maxDecodedPixels", { details: { pixels, limit: context.limits.maxDecodedPixels } });
+        if (operation.mimeType === "image/png" && !context.images.get(bytes))
+            issue("/data", "invalid-data", "The PNG could not be decoded");
+    },
+    apply(operation, context) {
+        const { pdfium } = context;
+        const { lib } = pdfium;
+        const bytes = resolveBinary(operation.data, context.assets);
+        const id = context.newId(operation.pageIndex);
+        const geometry = context.geometry(operation.pageIndex);
+        const image = lib.FPDFPageObj_NewImageObj(context.document);
+        if (operation.mimeType === "image/jpeg") {
+            const loaded = pdfium.withFileAccess(bytes, (fileAccess) => lib.FPDFImageObj_LoadJpegFileInline(0, 0, image, fileAccess));
+            if (!loaded)
+                throw new ViewerError("edit-failed", "PDFium could not read the JPEG", {
+                    details: { stage: "apply" },
+                });
+        }
+        else {
+            const decoded = context.images.get(bytes);
+            setBitmap(context.pdfium, image, decoded);
+        }
+        // The unit square maps onto the page-space rectangle, upright on screen:
+        // its bottom-left and the two edges leaving it, in user space.
+        const { rect } = operation;
+        const origin = pageToUser(geometry, rect.x, rect.y + rect.height);
+        const right = pageToUser(geometry, rect.x + rect.width, rect.y + rect.height);
+        const up = pageToUser(geometry, rect.x, rect.y);
+        lib.FPDFImageObj_SetMatrix(image, right.x - origin.x, right.y - origin.y, up.x - origin.x, up.y - origin.y, origin.x, origin.y);
+        context.withPage(operation.pageIndex, (page) => {
+            lib.FPDFPage_InsertObject(page, image);
+        });
+        context.appendObjects(operation.pageIndex, [{ id, type: OBJECT_IMAGE }]);
+        return {
+            createdIds: [id],
+            changedPages: [operation.pageIndex],
+            warnings: [],
+        };
+    },
+};
+function setBitmap(pdfium, image, decoded) {
+    const { lib } = pdfium;
+    const stride = decoded.width * 4;
+    const bgra = new Uint8Array(decoded.rgba.byteLength);
+    for (let offset = 0; offset < bgra.byteLength; offset += 4) {
+        bgra[offset] = decoded.rgba[offset + 2];
+        bgra[offset + 1] = decoded.rgba[offset + 1];
+        bgra[offset + 2] = decoded.rgba[offset];
+        bgra[offset + 3] = decoded.rgba[offset + 3];
+    }
+    const buffer = pdfium.writeBytes(bgra);
+    try {
+        const bitmap = lib.FPDFBitmap_CreateEx(decoded.width, decoded.height, BITMAP_BGRA, buffer, stride);
+        if (!bitmap)
+            throw new ViewerError("edit-failed", "PDFium could not create the bitmap", {
+                details: { stage: "apply" },
+            });
+        try {
+            if (!lib.FPDFImageObj_SetBitmap(0, 0, image, bitmap))
+                throw new ViewerError("edit-failed", "PDFium could not store the image", {
+                    details: { stage: "apply" },
+                });
+        }
+        finally {
+            lib.FPDFBitmap_Destroy(bitmap);
+        }
+    }
+    finally {
+        pdfium.free(buffer);
+    }
+}
+export function isPng(bytes) {
+    return (bytes.length > 24 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47);
+}
+/** Width and height from the IHDR chunk. */
+export function pngSize(bytes) {
+    if (!isPng(bytes))
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const width = view.getUint32(16);
+    const height = view.getUint32(20);
+    return width > 0 && height > 0 ? { width, height } : undefined;
+}
+/** Width and height from the first SOF marker of a baseline or progressive JPEG. */
+export function jpegSize(bytes) {
+    if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8)
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 2;
+    while (offset + 9 < bytes.length) {
+        if (bytes[offset] !== 0xff)
+            return undefined;
+        const marker = bytes[offset + 1];
+        if (marker === 0xd8 ||
+            (marker >= 0xd0 && marker <= 0xd7) ||
+            marker === 0x01) {
+            offset += 2;
+            continue;
+        }
+        const length = view.getUint16(offset + 2);
+        if (marker >= 0xc0 &&
+            marker <= 0xcf &&
+            marker !== 0xc4 &&
+            marker !== 0xc8 &&
+            marker !== 0xcc) {
+            const height = view.getUint16(offset + 5);
+            const width = view.getUint16(offset + 7);
+            return width > 0 && height > 0 ? { width, height } : undefined;
+        }
+        if (marker === 0xda)
+            return undefined;
+        offset += 2 + length;
+    }
+    return undefined;
+}
+/** Cheap content key: length plus an FNV-1a hash of the bytes. */
+function contentKey(bytes) {
+    let hash = 0x811c9dc5;
+    for (const byte of bytes)
+        hash = Math.imul(hash ^ byte, 0x01000193) >>> 0;
+    return `${bytes.byteLength}:${hash.toString(16)}`;
+}

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

@@ -0,0 +1,23 @@
+import type { PagePoint, PageRect, TextPosition, TextRange } from "../../types.js";
+import type { PdfElement, TextLayout } from "../types.js";
+import { type PageGeometry } from "./geometry.js";
+import type { Pdfium } from "./pdfium.js";
+/** A loaded page with its text page and the character-to-element mapping. */
+export interface TextPageScan {
+    readonly page: number;
+    readonly textPage: number;
+    readonly geometry: PageGeometry;
+    /** Object handle → element id, in drawing order. */
+    readonly byObject: ReadonlyMap<number, string>;
+    readonly elements: readonly PdfElement[];
+    /** Per character of the text page: its element and offset, when an object draws it. */
+    readonly offsets: readonly (TextPosition | undefined)[];
+}
+/** The layout of one element, or `undefined` when it draws no text. */
+export declare function layoutOf(pdfium: Pdfium, scan: TextPageScan, element: PdfElement): TextLayout | undefined;
+/** The layouts of every text element of the page, in reading order, from one pass. */
+export declare function layoutsOf(pdfium: Pdfium, scan: TextPageScan): TextLayout[];
+/** The caret position nearest to a page-space point, or none without text. */
+export declare function positionIn(pdfium: Pdfium, scan: TextPageScan, point: PagePoint): TextPosition | undefined;
+/** The rectangles a range covers: one per line fragment, in reading order. */
+export declare function rectsOf(pdfium: Pdfium, scan: TextPageScan, range: TextRange): PageRect[];

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

@@ -0,0 +1,177 @@
+import { textStyle } from "./elements.js";
+import { pageToUser, rectContains, round, roundRect, unionRects, userRectToPage, userToPage, } from "./geometry.js";
+/** How far a point may be from a glyph for `FPDFText_GetCharIndexAtPos`. */
+const HIT_TOLERANCE = 2;
+const TEXT_KINDS = new Set(["text", "textBox", "table"]);
+/** The layout of one element, or `undefined` when it draws no text. */
+export function layoutOf(pdfium, scan, element) {
+    if (!TEXT_KINDS.has(element.kind))
+        return undefined;
+    const glyphs = glyphsOf(pdfium, scan, (position) => position.elementId === element.id);
+    return {
+        elementId: element.id,
+        pageIndex: element.pageIndex,
+        lines: linesOf(pdfium, scan, glyphs),
+    };
+}
+/** The layouts of every text element of the page, in reading order, from one pass. */
+export function layoutsOf(pdfium, scan) {
+    const glyphs = glyphsOf(pdfium, scan, () => true);
+    const byElement = new Map();
+    for (const glyph of glyphs) {
+        const own = byElement.get(glyph.position.elementId);
+        if (own)
+            own.push(glyph);
+        else
+            byElement.set(glyph.position.elementId, [glyph]);
+    }
+    const layouts = [];
+    for (const element of scan.elements) {
+        const own = byElement.get(element.id);
+        if (!own || !TEXT_KINDS.has(element.kind))
+            continue;
+        layouts.push({
+            elementId: element.id,
+            pageIndex: element.pageIndex,
+            lines: linesOf(pdfium, scan, own),
+        });
+    }
+    return layouts;
+}
+/** The caret position nearest to a page-space point, or none without text. */
+export function positionIn(pdfium, scan, point) {
+    const glyphs = glyphsOf(pdfium, scan, () => true);
+    if (glyphs.length === 0)
+        return undefined;
+    const user = pageToUser(scan.geometry, point.x, point.y);
+    const hit = pdfium.lib.FPDFText_GetCharIndexAtPos(scan.textPage, user.x, user.y, HIT_TOLERANCE, HIT_TOLERANCE);
+    let glyph = glyphs.find((entry) => entry.index === hit);
+    if (!glyph) {
+        let best = Number.POSITIVE_INFINITY;
+        for (const entry of glyphs) {
+            const distance = distanceToRect(point, entry.box);
+            if (distance < best) {
+                best = distance;
+                glyph = entry;
+            }
+        }
+    }
+    // Past the glyph's middle along the reading direction, the caret goes after it.
+    const after = alongReading(point, glyph.box, scan.geometry.rotation) > 0.5;
+    return {
+        elementId: glyph.position.elementId,
+        offset: glyph.position.offset + (after ? 1 : 0),
+    };
+}
+/** The rectangles a range covers: one per line fragment, in reading order. */
+export function rectsOf(pdfium, scan, range) {
+    const order = scan.elements.map((element) => element.id);
+    const first = order.indexOf(range.start.elementId);
+    const last = order.indexOf(range.end.elementId);
+    if (first < 0 || last < 0 || first > last)
+        return [];
+    const glyphs = glyphsOf(pdfium, scan, (position) => {
+        const at = order.indexOf(position.elementId);
+        if (at < first || at > last)
+            return false;
+        const from = at === first ? range.start.offset : 0;
+        const to = at === last ? range.end.offset : Number.POSITIVE_INFINITY;
+        return position.offset >= from && position.offset < to;
+    });
+    return linesOf(pdfium, scan, glyphs).map((line) => line.bounds);
+}
+function glyphsOf(pdfium, scan, keep) {
+    const { lib } = pdfium;
+    const { textPage, geometry, offsets } = scan;
+    const glyphs = [];
+    for (let index = 0; index < offsets.length; index += 1) {
+        const position = offsets[index];
+        if (!position || !keep(position))
+            continue;
+        const object = lib.FPDFText_GetTextObject(textPage, index);
+        const tight = pdfium.readNumbers(4, "double", ([l, r, b, t]) => lib.FPDFText_GetCharBox(textPage, index, l, r, b, t));
+        // FS_RECTF: left, top, right, bottom.
+        const loose = pdfium.readNumbers(4, "float", ([pointer]) => lib.FPDFText_GetLooseCharBox(textPage, index, pointer));
+        const origin = pdfium.readNumbers(2, "double", ([x, y]) => lib.FPDFText_GetCharOrigin(textPage, index, x, y));
+        if (!loose || !origin)
+            continue;
+        const [looseLeft, looseTop, looseRight, looseBottom] = loose;
+        const [left, right, bottom, top] = tight && tight[0] !== tight[1] && tight[2] !== tight[3]
+            ? tight
+            : [looseLeft, looseRight, looseBottom, looseTop];
+        glyphs.push({
+            index,
+            object,
+            position,
+            char: String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, index)),
+            box: roundRect(userRectToPage(geometry, left, bottom, right, top)),
+            advance: round(Math.abs(looseRight - looseLeft)),
+            origin: roundPoint(userToPage(geometry, origin[0], origin[1])),
+        });
+    }
+    return glyphs;
+}
+/** Groups glyphs into lines, one per text object, in drawing order. */
+function linesOf(pdfium, scan, glyphs) {
+    const byObject = new Map();
+    for (const glyph of glyphs) {
+        const line = byObject.get(glyph.object);
+        if (line)
+            line.push(glyph);
+        else
+            byObject.set(glyph.object, [glyph]);
+    }
+    const lines = [];
+    for (const object of scan.byObject.keys()) {
+        const members = byObject.get(object);
+        if (!members)
+            continue;
+        members.sort((a, b) => a.position.offset - b.position.offset);
+        const style = textStyle(pdfium, object);
+        const { elementId } = members[0].position;
+        lines.push({
+            range: {
+                start: { elementId, offset: members[0].position.offset },
+                end: { elementId, offset: members.at(-1).position.offset + 1 },
+            },
+            text: members.map((glyph) => glyph.char).join(""),
+            bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
+            baseline: members[0].origin,
+            glyphs: members.map(({ position, box, advance }) => ({
+                offset: position.offset,
+                box,
+                advance,
+            })),
+            fontFamily: style.fontFamily,
+            fontSize: style.fontSize,
+            color: style.color,
+        });
+    }
+    return lines;
+}
+/** Where a point falls along a glyph in reading direction, 0 before it to 1 after. */
+function alongReading(point, box, rotation) {
+    const dx = box.width > 0 ? (point.x - box.x) / box.width : 0.5;
+    const dy = box.height > 0 ? (point.y - box.y) / box.height : 0.5;
+    // Page rotation turns the reading direction: 0 → right, 1 → down, 2 → left, 3 → up.
+    switch (rotation) {
+        case 1:
+            return dy;
+        case 2:
+            return 1 - dx;
+        case 3:
+            return 1 - dy;
+        default:
+            return dx;
+    }
+}
+function distanceToRect(point, rect) {
+    if (rectContains(rect, point))
+        return 0;
+    const dx = Math.max(rect.x - point.x, 0, point.x - (rect.x + rect.width));
+    const dy = Math.max(rect.y - point.y, 0, point.y - (rect.y + rect.height));
+    return Math.hypot(dx, dy);
+}
+function roundPoint(point) {
+    return { x: round(point.x), y: round(point.y) };
+}

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

@@ -0,0 +1,67 @@
+import type { ResourceLimits, ViewerWarning } from "../../../contracts.js";
+import type { AssetSource } from "../../assets.js";
+import type { ImageCache } from "./images.js";
+import type { OperationIssue } from "../../types.js";
+import type { PdfElement, PdfOperation } from "../types.js";
+import type { PageGeometry } from "./geometry.js";
+import type { ObjectRecord } from "./elements.js";
+import type { Pdfium } from "./pdfium.js";
+import type { FontLibrary, TextMeasurer } from "./fonts.js";
+/** What an operation sees of the document while validating or applying. */
+export interface OperationContext {
+    readonly pdfium: Pdfium;
+    readonly document: number;
+    readonly measurer: TextMeasurer;
+    readonly fonts: FontLibrary;
+    readonly images: ImageCache;
+    readonly limits: ResourceLimits;
+    /** Bytes behind `asset:` references. */
+    readonly assets: AssetSource;
+    readonly pageCount: number;
+    /** Geometry of a page; loads it if needed. */
+    geometry(pageIndex: number): PageGeometry;
+    /** Element id for something this operation creates. */
+    newId(pageIndex: number, suffix?: string): string;
+    /** Loads a page for writing; its content is regenerated afterwards. */
+    withPage<T>(pageIndex: number, use: (page: number) => T): T;
+    /** Records objects appended to a page by this operation. */
+    appendObjects(pageIndex: number, records: readonly ObjectRecord[]): void;
+    /** Where an element's objects sit: their page and their indexes in drawing order. */
+    locate(id: string): ElementLocation | undefined;
+    /** The element as a query would return it. */
+    element(id: string): PdfElement | undefined;
+    /** Ids of every element on a page, for what a page deletion removes. */
+    pageElementIds(pageIndex: number): readonly string[];
+    /** Displayed size of a page in points. */
+    pageSize(pageIndex: number): {
+        readonly width: number;
+        readonly height: number;
+    };
+    /** Records a page created at `index`; returns its stable key. */
+    insertPageRecord(index: number): string;
+    removePageRecord(index: number): void;
+    movePageRecord(from: number, to: number): void;
+    /** Drops what the model cached about a page after its geometry changed. */
+    invalidatePage(index: number): void;
+    /** Replaces `count` object records from `start` with `records`. */
+    spliceObjects(pageIndex: number, start: number, count: number, records: readonly ObjectRecord[]): void;
+}
+export interface ElementLocation {
+    readonly pageIndex: number;
+    /** Indexes of the element's objects in the page's drawing order, ascending. */
+    readonly indexes: readonly number[];
+    readonly record: ObjectRecord;
+}
+export interface OperationResult {
+    readonly createdIds: readonly string[];
+    /** Ids the operation made disappear. */
+    readonly removedIds?: readonly string[];
+    readonly changedPages: readonly number[];
+    readonly warnings: readonly ViewerWarning[];
+}
+export interface OperationHandler<T extends PdfOperation = PdfOperation> {
+    validate(operation: T, context: OperationContext, issue: (path: string, code: string, message: string) => void): void;
+    apply(operation: T, context: OperationContext): OperationResult;
+}
+export type Issue = (path: string, code: string, message: string) => void;
+export declare function issueCollector(operationIndex: number, issues: OperationIssue[]): Issue;

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

@@ -0,0 +1,3 @@
+export function issueCollector(operationIndex, issues) {
+    return (path, code, message) => issues.push({ operationIndex, path, code, message });
+}

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

@@ -0,0 +1,6 @@
+import type { DeletePageOperation, InsertPageOperation, MovePageOperation, RotatePageOperation } from "../types.js";
+import type { OperationHandler } from "./operations.js";
+export declare const insertPage: OperationHandler<InsertPageOperation>;
+export declare const deletePage: OperationHandler<DeletePageOperation>;
+export declare const movePage: OperationHandler<MovePageOperation>;
+export declare const rotatePage: OperationHandler<RotatePageOperation>;