pdf-oxide-fips 0.3.47

package/lib/document-editor-manager.js

@@ -0,0 +1,256 @@
+/**
+ * DocumentEditorManager for PDF document editing operations
+ *
+ * Provides methods to edit and modify PDF documents including page operations,
+ * content manipulation, and document merging. API is consistent with Python,
+ * Java, C#, Go, and Swift implementations.
+ */
+import { EventEmitter } from 'events';
+/**
+ * Page rotation options
+ */
+export var PageRotation;
+(function (PageRotation) {
+    PageRotation[PageRotation["None"] = 0] = "None";
+    PageRotation[PageRotation["Rotate90"] = 90] = "Rotate90";
+    PageRotation[PageRotation["Rotate180"] = 180] = "Rotate180";
+    PageRotation[PageRotation["Rotate270"] = 270] = "Rotate270";
+})(PageRotation || (PageRotation = {}));
+/**
+ * Document Editor Manager for document manipulation
+ *
+ * Provides methods to:
+ * - Delete, insert, and reorder pages
+ * - Rotate pages
+ * - Extract page ranges to new documents
+ * - Merge multiple documents
+ * - Track edit history
+ */
+export class DocumentEditorManager extends EventEmitter {
+    constructor(document) {
+        super();
+        this.editHistory = [];
+        this.hasUnsavedChanges = false;
+        if (!document) {
+            throw new Error('Document is required');
+        }
+        this.document = document;
+    }
+    /**
+     * Deletes a page from the document
+     * Matches: Python deletePage(), Java deletePage(), C# DeletePage()
+     */
+    async deletePage(pageIndex) {
+        this.validatePageIndex(pageIndex);
+        try {
+            if (this.document?.removePage) {
+                this.document.removePage(pageIndex);
+            }
+            this.recordOperation('deletePage', { pageIndex });
+            this.emit('pageDeleted', pageIndex);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Deletes multiple pages from the document
+     * Matches: Python deletePages(), Java deletePages(), C# DeletePages()
+     */
+    async deletePages(pageIndices) {
+        // Sort in descending order to avoid index shifting issues
+        const sorted = [...pageIndices].sort((a, b) => b - a);
+        for (const pageIndex of sorted) {
+            await this.deletePage(pageIndex);
+        }
+    }
+    /**
+     * Inserts a blank page at the specified position
+     * Matches: Python insertBlankPage(), Java insertBlankPage(), C# InsertBlankPage()
+     */
+    async insertBlankPage(pageIndex, width = 612, height = 792) {
+        try {
+            if (this.document?.insertPage) {
+                this.document.insertPage(pageIndex, width, height);
+            }
+            this.recordOperation('insertBlankPage', { pageIndex, width, height });
+            this.emit('pageInserted', pageIndex);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Rotates a page by the specified angle
+     * Matches: Python rotatePage(), Java rotatePage(), C# RotatePage()
+     */
+    async rotatePage(pageIndex, rotation) {
+        this.validatePageIndex(pageIndex);
+        try {
+            if (this.document?.rotatePage) {
+                this.document.rotatePage(pageIndex, rotation);
+            }
+            this.recordOperation('rotatePage', { pageIndex, rotation });
+            this.emit('pageRotated', pageIndex, rotation);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Rotates multiple pages
+     * Matches: Python rotatePages(), Java rotatePages(), C# RotatePages()
+     */
+    async rotatePages(pageIndices, rotation) {
+        for (const pageIndex of pageIndices) {
+            await this.rotatePage(pageIndex, rotation);
+        }
+    }
+    /**
+     * Moves a page to a new position
+     * Matches: Python movePage(), Java movePage(), C# MovePage()
+     */
+    async movePage(fromIndex, toIndex) {
+        this.validatePageIndex(fromIndex);
+        this.validatePageIndex(toIndex);
+        try {
+            // Implement move by extracting and re-inserting
+            if (this.document?.getPage && this.document?.removePage && this.document?.insertPage) {
+                const page = this.document.getPage(fromIndex);
+                this.document.removePage(fromIndex);
+                // Note: After removal, toIndex may need adjustment
+                const adjustedIndex = toIndex > fromIndex ? toIndex - 1 : toIndex;
+                if (page) {
+                    this.document.insertPage(adjustedIndex, page.getWidth?.(), page.getHeight?.());
+                }
+            }
+            this.recordOperation('movePage', { fromIndex, toIndex });
+            this.emit('pageMoved', fromIndex, toIndex);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Extracts pages to a new document
+     * Matches: Python extractPages(), Java extractPages(), C# ExtractPages()
+     */
+    async extractPages(config) {
+        const { startPage, endPage } = config;
+        this.validatePageIndex(startPage);
+        this.validatePageIndex(endPage);
+        // FFI call placeholder
+        // const newDoc = await FFI.extractPages(this.document.handle, startPage, endPage);
+        this.recordOperation('extractPages', { startPage, endPage });
+        this.emit('pagesExtracted', startPage, endPage);
+        return null; // Placeholder - would return new document
+    }
+    /**
+     * Merges multiple documents into one
+     * Matches: Python mergeDocuments(), Java mergeDocuments(), C# MergeDocuments()
+     */
+    static async mergeDocuments(config) {
+        const { documents, preserveOutlines = true, preserveAnnotations = true } = config;
+        if (!documents || documents.length === 0) {
+            throw new Error('At least one document is required for merging');
+        }
+        // FFI call placeholder
+        // const merged = await FFI.mergeDocuments(documents, preserveOutlines, preserveAnnotations);
+        return null; // Placeholder - would return merged document
+    }
+    /**
+     * Saves the document with all modifications
+     * Matches: Python save(), Java save(), C# Save()
+     */
+    async save(outputPath) {
+        try {
+            if (outputPath) {
+                // Save to file path
+                if (this.document?.save_async) {
+                    await this.document.save_async(outputPath);
+                }
+                else if (this.document?.saveToPath) {
+                    this.document.saveToPath(outputPath);
+                }
+            }
+            else {
+                // Save changes to current document
+                if (this.document?.save_async) {
+                    await this.document.save_async(this.document.filePath || 'output.pdf');
+                }
+            }
+            this.hasUnsavedChanges = false;
+            this.emit('saved', outputPath);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the edit history
+     * Matches: Python getEditHistory(), Java getEditHistory(), C# GetEditHistory()
+     */
+    getEditHistory() {
+        return [...this.editHistory];
+    }
+    /**
+     * Checks if there are unsaved changes
+     * Matches: Python hasUnsavedChanges(), Java hasUnsavedChanges(), C# HasUnsavedChanges()
+     */
+    hasChanges() {
+        return this.hasUnsavedChanges;
+    }
+    /**
+     * Undoes the last operation (if supported)
+     * Matches: Python undo(), Java undo(), C# Undo()
+     */
+    async undo() {
+        if (this.editHistory.length === 0) {
+            return false;
+        }
+        // Placeholder - would implement undo logic
+        this.editHistory.pop();
+        this.emit('undone');
+        return true;
+    }
+    /**
+     * Clears the edit history
+     * Matches: Python clearHistory(), Java clearHistory(), C# ClearHistory()
+     */
+    clearHistory() {
+        this.editHistory = [];
+        this.emit('historyCleared');
+    }
+    /**
+     * Gets the page count after modifications
+     */
+    getPageCount() {
+        try {
+            return this.document.pageCount || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    // Private helper methods
+    validatePageIndex(pageIndex) {
+        const count = this.getPageCount();
+        if (pageIndex < 0 || pageIndex >= count) {
+            throw new Error(`Invalid page index: ${pageIndex}. Document has ${count} pages.`);
+        }
+    }
+    recordOperation(type, details) {
+        this.editHistory.push({
+            type,
+            timestamp: new Date(),
+            details,
+        });
+        this.hasUnsavedChanges = true;
+    }
+}
+export default DocumentEditorManager;

package/lib/document-editor.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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;
+    /** Extract specific pages (by 0-based index) into a new PDF returned as a Buffer. */
+    extractPagesToBytes(pageIndices: number[]): Buffer;
+    /** 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,318 @@
+/**
+ * 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);
+    }
+    /** Extract specific pages (by 0-based index) into a new PDF returned as a Buffer. */
+    extractPagesToBytes(pageIndices) {
+        this._throwIfClosed();
+        return native.editorExtractPagesToBytes(this._handle, pageIndices);
+    }
+    /** 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;