web-doc 0.6.2 → 0.8.0

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

@@ -0,0 +1,98 @@
+/*
+ * Page structure. The model's page records move with the pages, so element
+ * ids keep pointing at the same content whatever happens to page order.
+ */
+export const insertPage = {
+    validate(operation, context, issue) {
+        if (operation.index > context.pageCount)
+            issue("/index", "range", `The index must be at most the page count (${context.pageCount})`);
+    },
+    apply(operation, context) {
+        const { lib } = context.pdfium;
+        const size = operation.size ?? neighbourSize(operation.index, context);
+        const page = lib.FPDFPage_New(context.document, operation.index, size.width, size.height);
+        lib.FPDFPage_GenerateContent(page);
+        lib.FPDF_ClosePage(page);
+        context.insertPageRecord(operation.index);
+        return {
+            createdIds: [],
+            changedPages: fromIndex(operation.index, context.pageCount + 1),
+            warnings: [],
+        };
+    },
+};
+export const deletePage = {
+    validate(operation, context, issue) {
+        if (operation.pageIndex >= context.pageCount)
+            issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+        else if (context.pageCount === 1)
+            issue("/pageIndex", "last-page", "The last page cannot be deleted");
+    },
+    apply(operation, context) {
+        const removedIds = context.pageElementIds(operation.pageIndex);
+        context.pdfium.lib.FPDFPage_Delete(context.document, operation.pageIndex);
+        context.removePageRecord(operation.pageIndex);
+        return {
+            createdIds: [],
+            removedIds,
+            changedPages: fromIndex(operation.pageIndex, context.pageCount - 1),
+            warnings: [],
+        };
+    },
+};
+export const movePage = {
+    validate(operation, context, issue) {
+        if (operation.from >= context.pageCount)
+            issue("/from", "unknown-target", `No page ${operation.from}`);
+        if (operation.to >= context.pageCount)
+            issue("/to", "range", `The index must be below the page count (${context.pageCount})`);
+    },
+    apply(operation, context) {
+        const { pdfium } = context;
+        if (operation.from !== operation.to) {
+            const indexes = pdfium.writeInt32Array([operation.from]);
+            try {
+                // PDFium takes the page out first, so the destination is the index
+                // the page will have afterwards.
+                pdfium.lib.FPDF_MovePages(context.document, indexes, 1, operation.to);
+            }
+            finally {
+                pdfium.free(indexes);
+            }
+            context.movePageRecord(operation.from, operation.to);
+        }
+        const low = Math.min(operation.from, operation.to);
+        const high = Math.max(operation.from, operation.to);
+        return {
+            createdIds: [],
+            changedPages: Array.from({ length: high - low + 1 }, (_, i) => low + i),
+            warnings: [],
+        };
+    },
+};
+export const rotatePage = {
+    validate(operation, context, issue) {
+        if (operation.pageIndex >= context.pageCount)
+            issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+    },
+    apply(operation, context) {
+        const { lib } = context.pdfium;
+        context.withPage(operation.pageIndex, (page) => {
+            lib.FPDFPage_SetRotation(page, operation.rotation / 90);
+        });
+        context.invalidatePage(operation.pageIndex);
+        return {
+            createdIds: [],
+            changedPages: [operation.pageIndex],
+            warnings: [],
+        };
+    },
+};
+function neighbourSize(index, context) {
+    if (context.pageCount === 0)
+        return { width: 612, height: 792 };
+    return context.pageSize(index > 0 ? index - 1 : 0);
+}
+function fromIndex(start, pageCount) {
+    return Array.from({ length: Math.max(0, pageCount - start) }, (_, i) => start + i);
+}

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

@@ -0,0 +1,195 @@
+/**
+ * The PDFium entry points the PDF edit engine calls, typed from
+ * `@embedpdf/pdfium`'s `functions` table. Pointers and handles are plain
+ * numbers in the WASM address space.
+ */
+export interface PdfiumFunctions {
+    PDFiumExt_Init(): void;
+    PDFiumExt_OpenFileWriter(): number;
+    PDFiumExt_GetFileWriterSize(writer: number): number;
+    PDFiumExt_GetFileWriterData(writer: number, buffer: number, size: number): number;
+    PDFiumExt_CloseFileWriter(writer: number): void;
+    FPDF_GetLastError(): number;
+    FPDF_CreateNewDocument(): number;
+    FPDF_LoadMemDocument(data: number, size: number, password: string): number;
+    FPDF_CloseDocument(document: number): void;
+    FPDF_SaveAsCopy(document: number, writer: number, flags: number): boolean;
+    FPDF_GetPageCount(document: number): number;
+    FPDF_GetSignatureCount(document: number): number;
+    FPDF_StructTree_GetForPage(page: number): number;
+    FPDF_StructTree_CountChildren(tree: number): number;
+    FPDF_StructTree_Close(tree: number): void;
+    FPDF_LoadPage(document: number, pageIndex: number): number;
+    FPDF_ClosePage(page: number): void;
+    FPDF_GetPageWidthF(page: number): number;
+    FPDF_GetPageHeightF(page: number): number;
+    /** Media box ∩ crop box in user space, as an FS_RECTF {left, top, right, bottom}. */
+    FPDF_GetPageBoundingBox(page: number, rect: number): boolean;
+    FPDF_PageToDevice(page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, pageX: number, pageY: number, deviceX: number, deviceY: number): boolean;
+    FPDFPage_SetCropBox(page: number, left: number, bottom: number, right: number, top: number): void;
+    FPDF_MovePages(document: number, pageIndices: number, count: number, destination: number): boolean;
+    FPDFPage_New(document: number, pageIndex: number, width: number, height: number): number;
+    FPDFPage_Delete(document: number, pageIndex: number): void;
+    FPDFPage_GetRotation(page: number): number;
+    FPDFPage_SetRotation(page: number, rotation: number): void;
+    FPDFPage_CountObjects(page: number): number;
+    FPDFPage_GetObject(page: number, index: number): number;
+    FPDFPage_InsertObject(page: number, object: number): void;
+    FPDFPage_InsertObjectAtIndex(page: number, object: number, index: number): boolean;
+    FPDFPage_GenerateContent(page: number): boolean;
+    FPDFPageObj_GetType(object: number): number;
+    /** Four floats: left, bottom, right, top in user space. */
+    FPDFPageObj_GetBounds(object: number, left: number, bottom: number, right: number, top: number): boolean;
+    /** Six floats a, b, c, d, e, f. */
+    FPDFPageObj_GetMatrix(object: number, matrix: number): boolean;
+    FPDFPageObj_GetFillColor(object: number, r: number, g: number, b: number, a: number): boolean;
+    FPDFPageObj_GetStrokeColor(object: number, r: number, g: number, b: number, a: number): boolean;
+    FPDFPageObj_GetStrokeWidth(object: number, width: number): boolean;
+    FPDFPageObj_SetFillColor(object: number, r: number, g: number, b: number, a: number): boolean;
+    FPDFPageObj_SetStrokeColor(object: number, r: number, g: number, b: number, a: number): boolean;
+    FPDFPageObj_SetStrokeWidth(object: number, width: number): boolean;
+    FPDFPageObj_CreateNewRect(x: number, y: number, width: number, height: number): number;
+    FPDFPath_GetDrawMode(path: number, fillMode: number, stroke: number): boolean;
+    FPDFPageObj_CreateNewPath(x: number, y: number): number;
+    FPDFPath_MoveTo(path: number, x: number, y: number): boolean;
+    FPDFPath_LineTo(path: number, x: number, y: number): boolean;
+    FPDFPath_BezierTo(path: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;
+    FPDFPath_Close(path: number): boolean;
+    FPDFPageObj_SetLineJoin(object: number, join: number): boolean;
+    FPDFPath_SetDrawMode(path: number, fillMode: number, stroke: boolean): boolean;
+    FPDFTextObj_GetText(textObject: number, textPage: number, buffer: number, bytes: number): number;
+    FPDFTextObj_GetFontSize(textObject: number, size: number): boolean;
+    FPDFTextObj_GetFont(textObject: number): number;
+    FPDFFont_GetFamilyName(font: number, buffer: number, bytes: number): number;
+    FPDFFont_GetBaseFontName(font: number, buffer: number, bytes: number): number;
+    FPDFFont_GetFlags(font: number): number;
+    FPDFFont_GetIsEmbedded(font: number): number;
+    FPDFFont_GetAscent(font: number, fontSize: number, ascent: number): boolean;
+    FPDFFont_GetDescent(font: number, fontSize: number, descent: number): boolean;
+    FPDFPageObj_Destroy(object: number): void;
+    FPDFPage_RemoveObject(page: number, object: number): boolean;
+    FPDFFont_GetWeight(font: number): number;
+    FPDFText_GetCharBox(textPage: number, index: number, left: number, right: number, bottom: number, top: number): boolean;
+    FPDFText_GetTextObject(textPage: number, index: number): number;
+    FPDFText_GetUnicode(textPage: number, index: number): number;
+    FPDFText_GetCharIndexFromTextIndex(textPage: number, textIndex: number): number;
+    /** Advance box of a character as an FS_RECTF {left, top, right, bottom} of floats. */
+    FPDFText_GetLooseCharBox(textPage: number, index: number, rect: number): boolean;
+    /** Two doubles: the glyph origin in user space. */
+    FPDFText_GetCharOrigin(textPage: number, index: number, x: number, y: number): boolean;
+    /** Char index at a user-space point within the tolerances, -1 for none, -3 on error. */
+    FPDFText_GetCharIndexAtPos(textPage: number, x: number, y: number, xTolerance: number, yTolerance: number): number;
+    FPDFPageObjMark_CountParams(mark: number): number;
+    FPDFPageObj_Transform(object: number, a: number, b: number, c: number, d: number, e: number, f: number): void;
+    FPDFPageObj_CreateTextObj(document: number, font: number, fontSize: number): number;
+    FPDFPageObj_NewImageObj(document: number): number;
+    FPDFPageObj_AddMark(object: number, name: string): number;
+    FPDFPageObj_CountMarks(object: number): number;
+    FPDFPageObj_GetMark(object: number, index: number): number;
+    FPDFPageObjMark_GetName(mark: number, buffer: number, bufferBytes: number, outBytes: number): boolean;
+    FPDFPageObjMark_SetStringParam(document: number, object: number, mark: number, key: string, value: string): boolean;
+    FPDFPageObjMark_GetParamStringValue(mark: number, key: string, buffer: number, bufferBytes: number, outBytes: number): boolean;
+    FPDFImageObj_LoadJpegFileInline(pages: number, count: number, image: number, fileAccess: number): boolean;
+    FPDFImageObj_SetBitmap(pages: number, count: number, image: number, bitmap: number): boolean;
+    FPDFBitmap_CreateEx(width: number, height: number, format: number, buffer: number, stride: number): number;
+    FPDFBitmap_Destroy(bitmap: number): void;
+    FPDFBitmap_FillRect(bitmap: number, left: number, top: number, width: number, height: number, color: number): boolean;
+    FPDFBitmap_GetBuffer(bitmap: number): number;
+    /** Draws the page into the bitmap at the given device rectangle; `rotate` adds quarter turns. */
+    FPDF_RenderPageBitmap(bitmap: number, page: number, startX: number, startY: number, sizeX: number, sizeY: number, rotate: number, flags: number): void;
+    /** Whether an object takes part in rendering and content generation; out param is an int. */
+    FPDFPageObj_GetIsActive(object: number, active: number): boolean;
+    FPDFPageObj_SetIsActive(object: number, active: boolean): boolean;
+    FPDFImageObj_GetImagePixelSize(image: number, width: number, height: number): boolean;
+    FPDFImageObj_SetMatrix(image: number, a: number, b: number, c: number, d: number, e: number, f: number): boolean;
+    FPDFText_LoadStandardFont(document: number, name: string): number;
+    FPDFText_LoadFont(document: number, data: number, size: number, fontType: number, cid: boolean): number;
+    FPDFFont_Close(font: number): void;
+    /** Copies the embedded font program; reports the size needed through `outBytes`. */
+    FPDFFont_GetFontData(font: number, buffer: number, bytes: number, outBytes: number): boolean;
+    FPDFText_SetText(textObject: number, text: number): boolean;
+    FPDFText_LoadPage(page: number): number;
+    FPDFText_ClosePage(textPage: number): void;
+    FPDFText_CountChars(textPage: number): number;
+    FPDFText_GetText(textPage: number, start: number, count: number, buffer: number): number;
+}
+/** The Emscripten runtime helpers `@embedpdf/pdfium` re-exports. */
+export interface PdfiumRuntime {
+    readonly HEAPU8: Uint8Array;
+    readonly wasmExports: {
+        malloc(size: number): number;
+        free(pointer: number): void;
+    };
+    UTF16ToString(pointer: number, maxBytesToRead?: number): string;
+    stringToUTF16(text: string, pointer: number, maxBytesToWrite?: number): number;
+    addFunction(callback: (...args: number[]) => number, signature: string): number;
+    removeFunction(pointer: number): void;
+    getValue(pointer: number, type: "i32" | "float" | "double"): number;
+    setValue(pointer: number, value: number, type: "i32" | "float" | "double"): void;
+}
+export type PdfiumLibrary = PdfiumFunctions & {
+    readonly pdfium: PdfiumRuntime;
+};
+/** `FPDF_SaveAsCopy` flags. */
+export declare const SAVE_INCREMENTAL = 1;
+export declare const SAVE_FULL = 2;
+/**
+ * Owns one PDFium WASM instance and the memory traffic across its boundary.
+ * PDFium keeps global heap state, so an instance must be used by one caller at
+ * a time; the edit worker serializes calls.
+ */
+export declare class Pdfium {
+    #private;
+    readonly lib: PdfiumLibrary;
+    private constructor();
+    /**
+     * Instantiates PDFium from WASM bytes. The bytes are always supplied by the
+     * caller: the package's default would fetch the module from a public CDN.
+     */
+    static load(wasmBinary: ArrayBuffer | Uint8Array): Promise<Pdfium>;
+    malloc(size: number): number;
+    free(pointer: number): void;
+    /** Copies bytes into the WASM heap; the caller frees the pointer. */
+    writeBytes(bytes: Uint8Array): number;
+    readBytes(pointer: number, length: number): Uint8Array;
+    /** Writes a NUL-terminated UTF-16LE string; the caller frees the pointer. */
+    writeWideString(text: string): number;
+    /** Reads a NUL-terminated UTF-16LE string of at most `bytes` bytes. */
+    readWideStringAt(pointer: number, bytes: number): string;
+    /**
+     * Reads a UTF-16LE string from an API that returns the byte size it needs
+     * when called with an empty buffer.
+     */
+    readWideString(read: (buffer: number, bytes: number) => number): string;
+    /**
+     * Reads a UTF-16LE string from an API that reports the byte size it needs
+     * through an `out_buflen` pointer.
+     */
+    readWideStringOut(read: (buffer: number, bytes: number, outBytes: number) => boolean): string;
+    /** Reads a NUL-terminated UTF-8 string from an API that returns the byte size it needs. */
+    readUtf8String(read: (buffer: number, bytes: number) => number): string;
+    /**
+     * Calls `read` with a scratch buffer of `count` numbers of `type` and
+     * returns what was written. Used for the many PDFium out-parameters.
+     */
+    readNumbers(count: number, type: "i32" | "float" | "double", read: (pointers: number[]) => boolean): number[] | undefined;
+    /** Writes 32-bit integers into a fresh array; the caller frees it. */
+    writeInt32Array(values: readonly number[]): number;
+    /**
+     * Runs `use` with an `FPDF_FILEACCESS` that serves `bytes` to PDFium through
+     * a WASM table callback. Only for APIs that read the data before returning,
+     * such as the inline JPEG loader.
+     */
+    withFileAccess<T>(bytes: Uint8Array, use: (fileAccess: number) => T): T;
+    /** Opens a document from bytes; PDFium reads them lazily, so they stay in the heap. */
+    openDocument(bytes: Uint8Array): PdfiumDocument;
+    createDocument(): PdfiumDocument;
+}
+export declare class PdfiumDocument {
+    #private;
+    constructor(pdfium: Pdfium, handle: number, data: number);
+    get handle(): number;
+    /** Serializes the document; `incremental` appends to the bytes it was opened from. */
+    save(mode: "incremental" | "full"): Uint8Array;
+    close(): void;
+}

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

@@ -0,0 +1,249 @@
+import { ViewerError } from "../../../errors.js";
+/** `FPDF_SaveAsCopy` flags. */
+export const SAVE_INCREMENTAL = 1;
+export const SAVE_FULL = 2;
+/** `FPDF_GetLastError` value for a missing or wrong password. */
+const PASSWORD_ERROR = 4;
+/** Size of `FPDF_FILEACCESS` in wasm32: file length, callback, parameter. */
+const FILE_ACCESS_BYTES = 12;
+/**
+ * Owns one PDFium WASM instance and the memory traffic across its boundary.
+ * PDFium keeps global heap state, so an instance must be used by one caller at
+ * a time; the edit worker serializes calls.
+ */
+export class Pdfium {
+    lib;
+    #runtime;
+    constructor(lib) {
+        this.lib = lib;
+        this.#runtime = lib.pdfium;
+    }
+    /**
+     * Instantiates PDFium from WASM bytes. The bytes are always supplied by the
+     * caller: the package's default would fetch the module from a public CDN.
+     */
+    static async load(wasmBinary) {
+        const { init } = (await import("@embedpdf/pdfium"));
+        const lib = await init({ wasmBinary: exactArrayBuffer(wasmBinary) });
+        lib.PDFiumExt_Init();
+        return new Pdfium(lib);
+    }
+    malloc(size) {
+        const pointer = this.#runtime.wasmExports.malloc(Math.max(1, size));
+        if (!pointer)
+            throw new ViewerError("resource-limit", "PDFium is out of memory", {
+                details: { bytes: size },
+            });
+        return pointer;
+    }
+    free(pointer) {
+        if (pointer)
+            this.#runtime.wasmExports.free(pointer);
+    }
+    /** Copies bytes into the WASM heap; the caller frees the pointer. */
+    writeBytes(bytes) {
+        const pointer = this.malloc(bytes.byteLength);
+        this.#runtime.HEAPU8.set(bytes, pointer);
+        return pointer;
+    }
+    readBytes(pointer, length) {
+        // The heap view is replaced when memory grows, so it is read on each call.
+        return this.#runtime.HEAPU8.slice(pointer, pointer + length);
+    }
+    /** Writes a NUL-terminated UTF-16LE string; the caller frees the pointer. */
+    writeWideString(text) {
+        const bytes = (text.length + 1) * 2;
+        const pointer = this.malloc(bytes);
+        this.#runtime.stringToUTF16(text, pointer, bytes);
+        return pointer;
+    }
+    /** Reads a NUL-terminated UTF-16LE string of at most `bytes` bytes. */
+    readWideStringAt(pointer, bytes) {
+        return this.#runtime.UTF16ToString(pointer, bytes);
+    }
+    /**
+     * Reads a UTF-16LE string from an API that returns the byte size it needs
+     * when called with an empty buffer.
+     */
+    readWideString(read) {
+        const bytes = read(0, 0);
+        if (bytes <= 2)
+            return "";
+        const pointer = this.malloc(bytes);
+        try {
+            read(pointer, bytes);
+            return this.#runtime.UTF16ToString(pointer, bytes);
+        }
+        finally {
+            this.free(pointer);
+        }
+    }
+    /**
+     * Reads a UTF-16LE string from an API that reports the byte size it needs
+     * through an `out_buflen` pointer.
+     */
+    readWideStringOut(read) {
+        const outBytes = this.malloc(4);
+        try {
+            if (!read(0, 0, outBytes))
+                return "";
+            const bytes = this.#runtime.getValue(outBytes, "i32");
+            if (bytes <= 2)
+                return "";
+            const pointer = this.malloc(bytes);
+            try {
+                if (!read(pointer, bytes, outBytes))
+                    return "";
+                return this.#runtime.UTF16ToString(pointer, bytes);
+            }
+            finally {
+                this.free(pointer);
+            }
+        }
+        finally {
+            this.free(outBytes);
+        }
+    }
+    /** Reads a NUL-terminated UTF-8 string from an API that returns the byte size it needs. */
+    readUtf8String(read) {
+        const bytes = read(0, 0);
+        if (bytes <= 1)
+            return "";
+        const pointer = this.malloc(bytes);
+        try {
+            read(pointer, bytes);
+            const raw = this.readBytes(pointer, bytes);
+            const end = raw.indexOf(0);
+            return new TextDecoder().decode(end < 0 ? raw : raw.subarray(0, end));
+        }
+        finally {
+            this.free(pointer);
+        }
+    }
+    /**
+     * Calls `read` with a scratch buffer of `count` numbers of `type` and
+     * returns what was written. Used for the many PDFium out-parameters.
+     */
+    readNumbers(count, type, read) {
+        const size = type === "double" ? 8 : 4;
+        const base = this.malloc(count * size);
+        try {
+            const pointers = Array.from({ length: count }, (_, i) => base + i * size);
+            if (!read(pointers))
+                return undefined;
+            return pointers.map((pointer) => this.#runtime.getValue(pointer, type));
+        }
+        finally {
+            this.free(base);
+        }
+    }
+    /** Writes 32-bit integers into a fresh array; the caller frees it. */
+    writeInt32Array(values) {
+        const pointer = this.malloc(values.length * 4);
+        values.forEach((value, index) => this.#runtime.setValue(pointer + index * 4, value, "i32"));
+        return pointer;
+    }
+    /**
+     * Runs `use` with an `FPDF_FILEACCESS` that serves `bytes` to PDFium through
+     * a WASM table callback. Only for APIs that read the data before returning,
+     * such as the inline JPEG loader.
+     */
+    withFileAccess(bytes, use) {
+        const runtime = this.#runtime;
+        const callback = runtime.addFunction((_parameter, position, buffer, size) => {
+            if (position < 0 || size < 0 || position + size > bytes.byteLength)
+                return 0;
+            runtime.HEAPU8.set(bytes.subarray(position, position + size), buffer);
+            return 1;
+        }, "iiiii");
+        const fileAccess = this.malloc(FILE_ACCESS_BYTES);
+        try {
+            runtime.setValue(fileAccess, bytes.byteLength, "i32");
+            runtime.setValue(fileAccess + 4, callback, "i32");
+            runtime.setValue(fileAccess + 8, 0, "i32");
+            return use(fileAccess);
+        }
+        finally {
+            this.free(fileAccess);
+            runtime.removeFunction(callback);
+        }
+    }
+    /** Opens a document from bytes; PDFium reads them lazily, so they stay in the heap. */
+    openDocument(bytes) {
+        const data = this.writeBytes(bytes);
+        const handle = this.lib.FPDF_LoadMemDocument(data, bytes.byteLength, "");
+        if (!handle) {
+            const error = this.lib.FPDF_GetLastError();
+            this.free(data);
+            throw error === PASSWORD_ERROR
+                ? new ViewerError("encrypted-document", "Password-protected PDF documents are not supported")
+                : new ViewerError("invalid-file", "PDFium could not open the PDF", {
+                    details: { pdfiumError: error },
+                });
+        }
+        return new PdfiumDocument(this, handle, data);
+    }
+    createDocument() {
+        const handle = this.lib.FPDF_CreateNewDocument();
+        if (!handle)
+            throw new ViewerError("internal", "PDFium could not create a document");
+        return new PdfiumDocument(this, handle, 0);
+    }
+}
+export class PdfiumDocument {
+    #pdfium;
+    #data;
+    #handle;
+    constructor(pdfium, handle, data) {
+        this.#pdfium = pdfium;
+        this.#handle = handle;
+        this.#data = data;
+    }
+    get handle() {
+        if (!this.#handle)
+            throw new ViewerError("lifecycle-error", "The PDF document is closed");
+        return this.#handle;
+    }
+    /** Serializes the document; `incremental` appends to the bytes it was opened from. */
+    save(mode) {
+        const { lib } = this.#pdfium;
+        const writer = lib.PDFiumExt_OpenFileWriter();
+        if (!writer)
+            throw new ViewerError("internal", "PDFium could not open a file writer");
+        try {
+            const flags = mode === "incremental" ? SAVE_INCREMENTAL : SAVE_FULL;
+            if (!lib.FPDF_SaveAsCopy(this.handle, writer, flags))
+                throw new ViewerError("internal", "PDFium could not save the PDF", {
+                    details: { mode, pdfiumError: lib.FPDF_GetLastError() },
+                });
+            const size = lib.PDFiumExt_GetFileWriterSize(writer);
+            const buffer = this.#pdfium.malloc(size);
+            try {
+                lib.PDFiumExt_GetFileWriterData(writer, buffer, size);
+                return this.#pdfium.readBytes(buffer, size);
+            }
+            finally {
+                this.#pdfium.free(buffer);
+            }
+        }
+        finally {
+            lib.PDFiumExt_CloseFileWriter(writer);
+        }
+    }
+    close() {
+        if (!this.#handle)
+            return;
+        this.#pdfium.lib.FPDF_CloseDocument(this.#handle);
+        this.#handle = 0;
+        this.#pdfium.free(this.#data);
+    }
+}
+function exactArrayBuffer(bytes) {
+    if (bytes instanceof ArrayBuffer)
+        return bytes;
+    return bytes.buffer instanceof ArrayBuffer &&
+        bytes.byteOffset === 0 &&
+        bytes.byteLength === bytes.buffer.byteLength
+        ? bytes.buffer
+        : bytes.slice().buffer;
+}

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

@@ -0,0 +1,4 @@
+import type { InsertShapeOperation, SetShapeStyleOperation } from "../types.js";
+import type { OperationHandler } from "./operations.js";
+export declare const insertShape: OperationHandler<InsertShapeOperation>;
+export declare const setShapeStyle: OperationHandler<SetShapeStyleOperation>;