pdf-oxide 0.3.37 → 0.3.39

package/lib/builders/index.d.ts

@@ -4,8 +4,10 @@
  * This module exports builder classes that implement the fluent builder pattern
  * for configuring PDF documents, annotations, search options, metadata, and conversion.
  */
-export * from './pdf-builder';
+export * from './annotation-builder';
 export * from './conversion-options-builder';
+export * from './document-builder';
 export * from './metadata-builder';
-export * from './annotation-builder';
+export * from './pdf-builder';
 export * from './search-options-builder';
+export * from './streaming-table';

package/lib/builders/index.js

@@ -4,8 +4,10 @@
  * This module exports builder classes that implement the fluent builder pattern
  * for configuring PDF documents, annotations, search options, metadata, and conversion.
  */
-export * from './pdf-builder.js';
+export * from './annotation-builder.js';
 export * from './conversion-options-builder.js';
+export * from './document-builder.js';
 export * from './metadata-builder.js';
-export * from './annotation-builder.js';
+export * from './pdf-builder.js';
 export * from './search-options-builder.js';
+export * from './streaming-table.js';

package/lib/builders/pdf-builder.d.ts

@@ -156,6 +156,8 @@ export declare class PdfBuilder {
      * ```
      */
     fromText(text: string): any;
+    fromHtmlCss(html: string, css: string, fontBytes: Buffer | Uint8Array): any;
+    fromHtmlCssWithFonts(html: string, css: string, families: string[], fonts: (Buffer | Uint8Array)[]): any;
     /**
      * Asynchronously creates a PDF document from Markdown content
      * @param markdown - Markdown formatted content

package/lib/builders/pdf-builder.js

@@ -231,6 +231,18 @@ export class PdfBuilder {
         this._applyConfiguration(pdf);
         return pdf;
     }
+    fromHtmlCss(html, css, fontBytes) {
+        const { Pdf } = require('../index.js');
+        const pdf = Pdf.fromHtmlCss(html, css, fontBytes);
+        this._applyConfiguration(pdf);
+        return pdf;
+    }
+    fromHtmlCssWithFonts(html, css, families, fonts) {
+        const { Pdf } = require('../index.js');
+        const pdf = Pdf.fromHtmlCssWithFonts(html, css, families, fonts);
+        this._applyConfiguration(pdf);
+        return pdf;
+    }
     /**
      * Asynchronously creates a PDF document from Markdown content
      * @param markdown - Markdown formatted content

package/lib/builders/streaming-table.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Streaming-table adapter backed by the native row-at-a-time FFI
+ * (`pdf_page_builder_streaming_table_begin_v2` / `_push_row` / `_finish`).
+ *
+ * @example
+ * ```typescript
+ * const t = page.streamingTable({
+ *   columns: [
+ *     { header: 'SKU',  width: 72 },
+ *     { header: 'Item', width: 200 },
+ *     { header: 'Qty',  width: 48, align: Align.Right },
+ *   ],
+ *   repeatHeader: true,
+ *   mode: { kind: 'sample', sampleRows: 30 },
+ * });
+ * for await (const row of readRowsFromDb()) {
+ *   t.pushRow([row.sku, row.item, String(row.qty)]);
+ * }
+ * await t.finish();
+ * ```
+ */
+import type { SpanCell, StreamingTableConfig } from '../types/common.js';
+import type { PageBuilder } from './document-builder.js';
+export declare class StreamingTable {
+    private _page;
+    private _columns;
+    private _opened;
+    private _finished;
+    /** @internal — constructed via `PageBuilder.streamingTable(...)`. */
+    constructor(page: PageBuilder, config: StreamingTableConfig);
+    /** Push a single row (all rowspan=1). Throws if `cells.length !== columns.length`. */
+    pushRow(cells: Array<string | null | undefined>): this;
+    /**
+     * Push a single row with per-cell rowspan values. Each element is either
+     * a `SpanCell` (`{ text, rowspan }`) or a plain string (rowspan=1).
+     * Requires `maxRowspan ≥ 2` in the `StreamingTableConfig`.
+     */
+    pushRowSpan(cells: Array<SpanCell | string | null | undefined>): this;
+    /**
+     * Convenience: consume a sync or async iterable and push each row.
+     */
+    pushAll(rows: Iterable<Array<string | null | undefined>> | AsyncIterable<Array<string | null | undefined>>): Promise<this>;
+    /**
+     * Close the streaming table and return the parent PageBuilder for chaining.
+     */
+    finish(): Promise<PageBuilder>;
+    /** Number of the columns this table was opened with. */
+    get columnCount(): number;
+}

package/lib/builders/streaming-table.js

@@ -0,0 +1,110 @@
+/**
+ * Streaming-table adapter backed by the native row-at-a-time FFI
+ * (`pdf_page_builder_streaming_table_begin_v2` / `_push_row` / `_finish`).
+ *
+ * @example
+ * ```typescript
+ * const t = page.streamingTable({
+ *   columns: [
+ *     { header: 'SKU',  width: 72 },
+ *     { header: 'Item', width: 200 },
+ *     { header: 'Qty',  width: 48, align: Align.Right },
+ *   ],
+ *   repeatHeader: true,
+ *   mode: { kind: 'sample', sampleRows: 30 },
+ * });
+ * for await (const row of readRowsFromDb()) {
+ *   t.pushRow([row.sku, row.item, String(row.qty)]);
+ * }
+ * await t.finish();
+ * ```
+ */
+export class StreamingTable {
+    /** @internal — constructed via `PageBuilder.streamingTable(...)`. */
+    constructor(page, config) {
+        this._opened = false;
+        this._finished = false;
+        if (!config || !Array.isArray(config.columns) || config.columns.length === 0) {
+            throw new Error('StreamingTable requires at least one column');
+        }
+        this._page = page;
+        this._columns = config.columns;
+        const headers = config.columns.map((c) => c.header ?? '');
+        const widths = config.columns.map((c) => c.width);
+        const aligns = config.columns.map((c) => (c.align ?? 0));
+        const repeat = config.repeatHeader !== false;
+        const maxRowspan = config.maxRowspan != null && config.maxRowspan >= 2 ? config.maxRowspan : 1;
+        this._page._streamingTableBeginV2(headers, widths, aligns, repeat, config.mode, maxRowspan);
+        this._opened = true;
+    }
+    /** Push a single row (all rowspan=1). Throws if `cells.length !== columns.length`. */
+    pushRow(cells) {
+        if (this._finished) {
+            throw new Error('StreamingTable already finished');
+        }
+        if (cells.length !== this._columns.length) {
+            throw new Error(`row width ${cells.length} does not match column count ${this._columns.length}`);
+        }
+        this._page._streamingTablePushRow(cells.map((c) => (c == null ? null : String(c))));
+        return this;
+    }
+    /**
+     * Push a single row with per-cell rowspan values. Each element is either
+     * a `SpanCell` (`{ text, rowspan }`) or a plain string (rowspan=1).
+     * Requires `maxRowspan ≥ 2` in the `StreamingTableConfig`.
+     */
+    pushRowSpan(cells) {
+        if (this._finished) {
+            throw new Error('StreamingTable already finished');
+        }
+        if (cells.length !== this._columns.length) {
+            throw new Error(`row width ${cells.length} does not match column count ${this._columns.length}`);
+        }
+        const normalized = cells.map((c) => {
+            if (c == null)
+                return [null, 1];
+            if (typeof c === 'string')
+                return [c, 1];
+            return [c.text, c.rowspan];
+        });
+        this._page._streamingTablePushRowV2(normalized);
+        return this;
+    }
+    /**
+     * Convenience: consume a sync or async iterable and push each row.
+     */
+    async pushAll(rows) {
+        if (this._finished) {
+            throw new Error('StreamingTable already finished');
+        }
+        const anyRows = rows;
+        if (typeof anyRows[Symbol.asyncIterator] === 'function') {
+            for await (const row of rows) {
+                this.pushRow(row);
+            }
+        }
+        else {
+            for (const row of rows) {
+                this.pushRow(row);
+            }
+        }
+        return this;
+    }
+    /**
+     * Close the streaming table and return the parent PageBuilder for chaining.
+     */
+    async finish() {
+        if (this._finished) {
+            throw new Error('StreamingTable already finished');
+        }
+        this._finished = true;
+        if (this._opened) {
+            this._page._streamingTableFinish();
+        }
+        return this._page;
+    }
+    /** Number of the columns this table was opened with. */
+    get columnCount() {
+        return this._columns.length;
+    }
+}

package/lib/document-editor.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Page rotation angles valid for {@link DocumentEditor.setPageRotation}.
+ */
+export type PageRotation = 0 | 90 | 180 | 270;
+/**
+ * PDF editor bound to a concrete file on disk. Open via
+ * {@link DocumentEditor.open}; always pair with {@link close} (or use
+ * `using` / the explicit-resource-management protocol once it's
+ * stable in your toolchain).
+ */
+export declare class DocumentEditor {
+    private _handle;
+    private _closed;
+    private constructor();
+    /** Open a PDF file for editing. */
+    static open(path: string): DocumentEditor;
+    /** Open a PDF from an in-memory buffer for editing. */
+    static openFromBytes(data: Buffer | Uint8Array): DocumentEditor;
+    /** True if the editor has been closed. Subsequent calls will throw. */
+    get closed(): boolean;
+    private _throwIfClosed;
+    /** Current page count. */
+    pageCount(): number;
+    /** True if the editor has unsaved modifications. */
+    isModified(): boolean;
+    setTitle(title: string): void;
+    setAuthor(author: string): void;
+    setSubject(subject: string): void;
+    getKeywords(): string | null;
+    setKeywords(keywords: string): void;
+    getProducer(): string;
+    setProducer(producer: string): void;
+    getCreationDate(): string;
+    setCreationDate(date: string): void;
+    /** Delete the page at `pageIndex` (zero-based). */
+    deletePage(pageIndex: number): void;
+    /** Move a page. Indices refer to positions before the move. */
+    movePage(fromIndex: number, toIndex: number): void;
+    /** Set rotation on a page (0/90/180/270). */
+    setPageRotation(pageIndex: number, degrees: PageRotation): void;
+    /**
+     * Append every page of another PDF to the end of this document.
+     */
+    mergeFrom(sourcePath: string): void;
+    /** Flatten form fields across the entire document. */
+    flattenForms(): void;
+    /**
+     * Return warnings collected during the last form-flattening save.
+     * Each entry names a widget field that had no `/AP` appearance stream;
+     * flattening it produces a blank rectangle.
+     */
+    flattenWarnings(): string[];
+    /** Flatten annotations. If `pageIndex` is omitted, flattens all pages. */
+    flattenAnnotations(pageIndex?: number): void;
+    /** Set a form field value by fully-qualified field name. */
+    setFormFieldValue(fieldName: string, value: string): void;
+    /** Import an FDF file (bytes) into the document's form. */
+    importFdfBytes(fdf: Buffer | Uint8Array): void;
+    /** Import an XFDF file (bytes) into the document's form. */
+    importXfdfBytes(xfdf: Buffer | Uint8Array): void;
+    /**
+     * Append every page of another PDF (supplied as bytes) to this document.
+     * Returns the number of pages added.
+     */
+    mergeFromBytes(data: Buffer | Uint8Array): number;
+    /** Embed a file attachment into the document. */
+    embedFile(name: string, data: Buffer | Uint8Array): void;
+    /** Burn in redaction annotations on a single page (zero-based). */
+    applyPageRedactions(pageIndex: number): void;
+    /** Burn in all pending redaction annotations across the document. */
+    applyAllRedactions(): void;
+    /** Rotate all pages by `degrees` (additive). */
+    rotateAllPages(degrees: number): void;
+    /** Rotate a single page by `degrees` (additive). */
+    rotatePageBy(pageIndex: number, degrees: number): void;
+    /** Get the MediaBox of a page as `{x, y, width, height}`. */
+    getPageMediaBox(pageIndex: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Set the MediaBox of a page. */
+    setPageMediaBox(pageIndex: number, x: number, y: number, width: number, height: number): void;
+    /** Get the CropBox of a page. Returns `{x:0,y:0,width:0,height:0}` if none set. */
+    getPageCropBox(pageIndex: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Set the CropBox of a page. */
+    setPageCropBox(pageIndex: number, x: number, y: number, width: number, height: number): void;
+    /**
+     * Erase rectangular regions on a page.
+     * `rects` is an array of `[x, y, w, h]` tuples.
+     */
+    eraseRegions(pageIndex: number, rects: [number, number, number, number][]): void;
+    /** Clear all pending erase-region entries for a page. */
+    clearEraseRegions(pageIndex: number): void;
+    /** Flatten form fields on a single page. */
+    flattenFormsOnPage(pageIndex: number): void;
+    /** True if the page is marked for annotation-flatten. */
+    isPageMarkedForFlatten(pageIndex: number): boolean;
+    /** Remove the flatten mark from a page. */
+    unmarkPageForFlatten(pageIndex: number): void;
+    /** True if the page is marked for redaction. */
+    isPageMarkedForRedaction(pageIndex: number): boolean;
+    /** Remove the redaction mark from a page. */
+    unmarkPageForRedaction(pageIndex: number): void;
+    /** Save the document to `path`. */
+    save(path: string): void;
+    /** Save with AES-256 encryption (user + owner passwords). */
+    saveEncrypted(path: string, userPassword: string, ownerPassword: string): void;
+    /** Save the document to an in-memory Buffer. */
+    saveToBytes(): Buffer;
+    /** Save to an in-memory Buffer with explicit compression / GC / linearize flags. */
+    saveToBytesWithOptions(compress: boolean, garbageCollect: boolean, linearize: boolean): Buffer;
+    /** Release the native handle. Safe to call multiple times. */
+    close(): void;
+}
+export default DocumentEditor;

package/lib/document-editor.js

@@ -0,0 +1,313 @@
+/**
+ * DocumentEditor — thin TS wrapper around the N-API `editor*` exports
+ * in `binding.cc`. Mirrors the C# `DocumentEditor` / Go
+ * `DocumentEditor` surface.
+ *
+ * Every mutation is a synchronous call into the Rust core; the same
+ * handle is carried until {@link DocumentEditor.close}. Throws plain
+ * `Error` with the native message on failure.
+ *
+ * ```ts
+ * import { DocumentEditor } from 'pdf-oxide';
+ *
+ * const editor = DocumentEditor.open('in.pdf');
+ * try {
+ *   editor.mergeFrom('other.pdf');
+ *   editor.deletePage(0);
+ *   editor.movePage(0, 2);
+ *   editor.setPageRotation(0, 90);
+ *   editor.save('out.pdf');
+ * } finally {
+ *   editor.close();
+ * }
+ * ```
+ */
+// Load the native addon via the shared prebuild-aware loader.
+// Importing `./index.js` would create an ESM cycle (index.js imports
+// us back), so we go through `./native.js` — same resolver, no cycle,
+// resolves against `prebuilds/<triple>/pdf_oxide.node` in the
+// published package.
+import { loadNative } from './native.js';
+const native = loadNative();
+/**
+ * PDF editor bound to a concrete file on disk. Open via
+ * {@link DocumentEditor.open}; always pair with {@link close} (or use
+ * `using` / the explicit-resource-management protocol once it's
+ * stable in your toolchain).
+ */
+export class DocumentEditor {
+    constructor(handle) {
+        this._closed = false;
+        this._handle = handle;
+    }
+    /** Open a PDF file for editing. */
+    static open(path) {
+        if (typeof path !== 'string' || path.length === 0) {
+            throw new TypeError('path must be a non-empty string');
+        }
+        const handle = native.editorOpen(path);
+        return new DocumentEditor(handle);
+    }
+    /** Open a PDF from an in-memory buffer for editing. */
+    static openFromBytes(data) {
+        if (!data || data.length === 0) {
+            throw new TypeError('data must be a non-empty Buffer or Uint8Array');
+        }
+        const handle = native.editorOpenFromBytes(data);
+        return new DocumentEditor(handle);
+    }
+    /** True if the editor has been closed. Subsequent calls will throw. */
+    get closed() {
+        return this._closed;
+    }
+    _throwIfClosed() {
+        if (this._closed)
+            throw new Error('DocumentEditor is closed');
+    }
+    /** Current page count. */
+    pageCount() {
+        this._throwIfClosed();
+        return native.editorGetPageCount(this._handle);
+    }
+    /** True if the editor has unsaved modifications. */
+    isModified() {
+        this._throwIfClosed();
+        return native.editorIsModified(this._handle);
+    }
+    // ----- metadata ---------------------------------------------------
+    setTitle(title) {
+        this._throwIfClosed();
+        native.editorSetTitle(this._handle, title);
+    }
+    setAuthor(author) {
+        this._throwIfClosed();
+        native.editorSetAuthor(this._handle, author);
+    }
+    setSubject(subject) {
+        this._throwIfClosed();
+        native.editorSetSubject(this._handle, subject);
+    }
+    getKeywords() {
+        this._throwIfClosed();
+        return native.editorGetKeywords(this._handle);
+    }
+    setKeywords(keywords) {
+        this._throwIfClosed();
+        native.editorSetKeywords(this._handle, keywords);
+    }
+    getProducer() {
+        this._throwIfClosed();
+        return native.editorGetProducer(this._handle);
+    }
+    setProducer(producer) {
+        this._throwIfClosed();
+        native.editorSetProducer(this._handle, producer);
+    }
+    getCreationDate() {
+        this._throwIfClosed();
+        return native.editorGetCreationDate(this._handle);
+    }
+    setCreationDate(date) {
+        this._throwIfClosed();
+        native.editorSetCreationDate(this._handle, date);
+    }
+    // ----- page mutations ---------------------------------------------
+    /** Delete the page at `pageIndex` (zero-based). */
+    deletePage(pageIndex) {
+        this._throwIfClosed();
+        native.editorDeletePage(this._handle, pageIndex);
+    }
+    /** Move a page. Indices refer to positions before the move. */
+    movePage(fromIndex, toIndex) {
+        this._throwIfClosed();
+        native.editorMovePage(this._handle, fromIndex, toIndex);
+    }
+    /** Set rotation on a page (0/90/180/270). */
+    setPageRotation(pageIndex, degrees) {
+        this._throwIfClosed();
+        native.editorSetPageRotation(this._handle, pageIndex, degrees);
+    }
+    // ----- document-level mutations -----------------------------------
+    /**
+     * Append every page of another PDF to the end of this document.
+     */
+    mergeFrom(sourcePath) {
+        this._throwIfClosed();
+        if (typeof sourcePath !== 'string' || sourcePath.length === 0) {
+            throw new TypeError('sourcePath must be a non-empty string');
+        }
+        native.editorMergeFrom(this._handle, sourcePath);
+    }
+    /** Flatten form fields across the entire document. */
+    flattenForms() {
+        this._throwIfClosed();
+        native.editorFlattenForms(this._handle);
+    }
+    /**
+     * Return warnings collected during the last form-flattening save.
+     * Each entry names a widget field that had no `/AP` appearance stream;
+     * flattening it produces a blank rectangle.
+     */
+    flattenWarnings() {
+        this._throwIfClosed();
+        return native.editorFlattenWarnings(this._handle);
+    }
+    /** Flatten annotations. If `pageIndex` is omitted, flattens all pages. */
+    flattenAnnotations(pageIndex) {
+        this._throwIfClosed();
+        if (pageIndex === undefined) {
+            native.editorFlattenAnnotations(this._handle);
+        }
+        else {
+            native.editorFlattenAnnotations(this._handle, pageIndex);
+        }
+    }
+    /** Set a form field value by fully-qualified field name. */
+    setFormFieldValue(fieldName, value) {
+        this._throwIfClosed();
+        native.editorSetFormFieldValue(this._handle, fieldName, value);
+    }
+    /** Import an FDF file (bytes) into the document's form. */
+    importFdfBytes(fdf) {
+        this._throwIfClosed();
+        native.editorImportFdfBytes(this._handle, fdf);
+    }
+    /** Import an XFDF file (bytes) into the document's form. */
+    importXfdfBytes(xfdf) {
+        this._throwIfClosed();
+        native.editorImportXfdfBytes(this._handle, xfdf);
+    }
+    // ----- byte-level merge / embed -----------------------------------
+    /**
+     * Append every page of another PDF (supplied as bytes) to this document.
+     * Returns the number of pages added.
+     */
+    mergeFromBytes(data) {
+        this._throwIfClosed();
+        return native.editorMergeFromBytes(this._handle, data);
+    }
+    /** Embed a file attachment into the document. */
+    embedFile(name, data) {
+        this._throwIfClosed();
+        native.editorEmbedFile(this._handle, name, data);
+    }
+    // ----- redactions -------------------------------------------------
+    /** Burn in redaction annotations on a single page (zero-based). */
+    applyPageRedactions(pageIndex) {
+        this._throwIfClosed();
+        native.editorApplyPageRedactions(this._handle, pageIndex);
+    }
+    /** Burn in all pending redaction annotations across the document. */
+    applyAllRedactions() {
+        this._throwIfClosed();
+        native.editorApplyAllRedactions(this._handle);
+    }
+    // ----- rotation (additive) ----------------------------------------
+    /** Rotate all pages by `degrees` (additive). */
+    rotateAllPages(degrees) {
+        this._throwIfClosed();
+        native.editorRotateAllPages(this._handle, degrees);
+    }
+    /** Rotate a single page by `degrees` (additive). */
+    rotatePageBy(pageIndex, degrees) {
+        this._throwIfClosed();
+        native.editorRotatePageBy(this._handle, pageIndex, degrees);
+    }
+    // ----- page boxes -------------------------------------------------
+    /** Get the MediaBox of a page as `{x, y, width, height}`. */
+    getPageMediaBox(pageIndex) {
+        this._throwIfClosed();
+        return native.editorGetPageMediaBox(this._handle, pageIndex);
+    }
+    /** Set the MediaBox of a page. */
+    setPageMediaBox(pageIndex, x, y, width, height) {
+        this._throwIfClosed();
+        native.editorSetPageMediaBox(this._handle, pageIndex, x, y, width, height);
+    }
+    /** Get the CropBox of a page. Returns `{x:0,y:0,width:0,height:0}` if none set. */
+    getPageCropBox(pageIndex) {
+        this._throwIfClosed();
+        return native.editorGetPageCropBox(this._handle, pageIndex);
+    }
+    /** Set the CropBox of a page. */
+    setPageCropBox(pageIndex, x, y, width, height) {
+        this._throwIfClosed();
+        native.editorSetPageCropBox(this._handle, pageIndex, x, y, width, height);
+    }
+    // ----- erase regions ----------------------------------------------
+    /**
+     * Erase rectangular regions on a page.
+     * `rects` is an array of `[x, y, w, h]` tuples.
+     */
+    eraseRegions(pageIndex, rects) {
+        this._throwIfClosed();
+        native.editorEraseRegions(this._handle, pageIndex, rects);
+    }
+    /** Clear all pending erase-region entries for a page. */
+    clearEraseRegions(pageIndex) {
+        this._throwIfClosed();
+        native.editorClearEraseRegions(this._handle, pageIndex);
+    }
+    // ----- form flattening on single page ------------------------------
+    /** Flatten form fields on a single page. */
+    flattenFormsOnPage(pageIndex) {
+        this._throwIfClosed();
+        native.editorFlattenFormsOnPage(this._handle, pageIndex);
+    }
+    // ----- page-mark state queries ------------------------------------
+    /** True if the page is marked for annotation-flatten. */
+    isPageMarkedForFlatten(pageIndex) {
+        this._throwIfClosed();
+        return native.editorIsPageMarkedForFlatten(this._handle, pageIndex);
+    }
+    /** Remove the flatten mark from a page. */
+    unmarkPageForFlatten(pageIndex) {
+        this._throwIfClosed();
+        native.editorUnmarkPageForFlatten(this._handle, pageIndex);
+    }
+    /** True if the page is marked for redaction. */
+    isPageMarkedForRedaction(pageIndex) {
+        this._throwIfClosed();
+        return native.editorIsPageMarkedForRedaction(this._handle, pageIndex);
+    }
+    /** Remove the redaction mark from a page. */
+    unmarkPageForRedaction(pageIndex) {
+        this._throwIfClosed();
+        native.editorUnmarkPageForRedaction(this._handle, pageIndex);
+    }
+    // ----- save paths -------------------------------------------------
+    /** Save the document to `path`. */
+    save(path) {
+        this._throwIfClosed();
+        if (typeof path !== 'string' || path.length === 0) {
+            throw new TypeError('path must be a non-empty string');
+        }
+        native.editorSave(this._handle, path);
+    }
+    /** Save with AES-256 encryption (user + owner passwords). */
+    saveEncrypted(path, userPassword, ownerPassword) {
+        this._throwIfClosed();
+        native.editorSaveEncrypted(this._handle, path, userPassword, ownerPassword);
+    }
+    /** Save the document to an in-memory Buffer. */
+    saveToBytes() {
+        this._throwIfClosed();
+        return native.editorSaveToBytes(this._handle);
+    }
+    /** Save to an in-memory Buffer with explicit compression / GC / linearize flags. */
+    saveToBytesWithOptions(compress, garbageCollect, linearize) {
+        this._throwIfClosed();
+        return native.editorSaveToBytesWithOptions(this._handle, compress, garbageCollect, linearize);
+    }
+    // ----- lifecycle --------------------------------------------------
+    /** Release the native handle. Safe to call multiple times. */
+    close() {
+        if (!this._closed) {
+            if (native.editorFree) {
+                native.editorFree(this._handle);
+            }
+            this._closed = true;
+        }
+    }
+}
+export default DocumentEditor;

package/lib/errors.js

@@ -135,9 +135,7 @@ export class PdfException extends Error {
             parts.push(`Context:\n${contextStr}`);
         }
         if (this.recovery.suggestions.length > 0) {
-            const suggestionsStr = this.recovery.suggestions
-                .map((s) => `  • ${s}`)
-                .join('\n');
+            const suggestionsStr = this.recovery.suggestions.map((s) => `  • ${s}`).join('\n');
             parts.push(`Recovery Suggestions:\n${suggestionsStr}`);
         }
         if (this.recovery.alternativeApproach) {
@@ -931,7 +929,8 @@ export function mapFfiErrorCode(errorCode, message) {
         case 11:
             return new AccessibilityException(message ?? 'Accessibility error: Tagging, structure tree, or alt text operation failed');
         case 12:
-            return new OptimizationException(message ?? 'Optimization error: Font subsetting, image downsampling, or deduplication failed');
+            return new OptimizationException(message ??
+                'Optimization error: Font subsetting, image downsampling, or deduplication failed');
         default:
             return new UnknownError(message ?? `Unknown error (code: ${errorCode})`);
     }

package/lib/form-field-manager.js

@@ -560,7 +560,9 @@ export class FormFieldManager extends EventEmitter {
     clearCachePattern(pattern) {
         const regex = new RegExp(pattern);
         const keysToDelete = Array.from(this.resultCache.keys()).filter((key) => regex.test(key));
-        keysToDelete.forEach((key) => this.resultCache.delete(key));
+        keysToDelete.forEach((key) => {
+            this.resultCache.delete(key);
+        });
     }
 }
 export default FormFieldManager;