@pdfluent/sdk-wasm 1.0.0-beta.8 → 1.1.0

package/xfa_wasm.js

@@ -1,5 +1,5 @@
 /* @ts-self-types="./xfa_wasm.d.ts" */
-import { __pdfluent_error_ctor } from './snippets/xfa-wasm-312742e1abcfad9e/inline0.js';
+import { __pdfluent_error_ctor } from './snippets/xfa-wasm-d1985887593da269/inline0.js';
 
 
 /**
@@ -25,77 +25,6 @@ export const ChromaSampling = Object.freeze({
     Cs400: 3, "3": "Cs400",
 });
 
-/**
- * Status of the currently-active license.
- */
-export class LicenseStatus {
-    static __wrap(ptr) {
-        const obj = Object.create(LicenseStatus.prototype);
-        obj.__wbg_ptr = ptr;
-        LicenseStatusFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        LicenseStatusFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_licensestatus_free(ptr, 0);
-    }
-    /**
-     * Whether output is marked via `/Producer` metadata (Trial tier).
-     * @returns {boolean}
-     */
-    get outputIsMarked() {
-        const ret = wasm.licensestatus_outputIsMarked(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Source: `"Default" | "EnvVar" | "Explicit"`.
-     * @returns {string}
-     */
-    get source() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.licensestatus_source(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * Tier name: `"Trial" | "Developer" | "Team" | "Business" | "Enterprise"`.
-     * @returns {string}
-     */
-    get tier() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.licensestatus_tier(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) LicenseStatus.prototype[Symbol.dispose] = LicenseStatus.prototype.free;
-
 /**
  * PDF document handle for analysis and text extraction.
  *
@@ -239,6 +168,8 @@ export class PdfDoc {
     /**
      * Apply a diagonal text watermark to every page.
      * `opacity` in 0.0..=1.0. Default rotation 45 deg, default colour gray.
+     *
+     * Kept for compatibility; `addWatermark` takes the full set of options.
      * @param {string} text
      * @param {number} opacity
      * @returns {Uint8Array}
@@ -263,6 +194,31 @@ export class PdfDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Apply a text watermark with full control over text or preset, size,
+     * rotation, opacity, colour, position, layer, tiling and pages. Returns
+     * the new PDF bytes. Text only: there is no image watermark.
+     * @param {WatermarkOptions} options
+     * @returns {Uint8Array}
+     */
+    addWatermark(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_addWatermark(retptr, this.__wbg_ptr, addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Re-encode all content streams with deflate compression. Removes
      * no-op overhead. Returns the optimised PDF as a `Uint8Array`.
@@ -359,6 +315,139 @@ export class PdfDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The document's blocks as JSON, in reading order (#573).
+     *
+     * Preview: output quality is still improving and the API may change in a minor release.
+     *
+     * `{"blocks": [...]}`, one entry per paragraph, heading, list item, table
+     * cell and running head, each with its kind, page, box, text, spans and
+     * place in the reading order. `docs/STRUCTURED_EXTRACTION.md` is the key
+     * to every field.
+     *
+     * A JSON string and not a structured value, which is what every other
+     * structured reader in this binding hands back: one shape crosses the
+     * boundary, `JSON.parse` is what the caller already does for
+     * `getTextPositions` and the annotations, and a `serde` mirror of the
+     * block model would be a second definition of it to keep in step.
+     *
+     * An XFA form is read from its flattened form, for the reason
+     * `extractMarkdown` above gives.
+     * @param {number | null} [first_page]
+     * @param {number | null} [page_count]
+     * @returns {string}
+     */
+    extractBlocks(first_page, page_count) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_extractBlocks(retptr, this.__wbg_ptr, isLikeNone(first_page) ? Number.MAX_SAFE_INTEGER : (first_page) >>> 0, isLikeNone(page_count) ? Number.MAX_SAFE_INTEGER : (page_count) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * The document as a Docling `DoclingDocument`, as JSON (#629).
+     *
+     * Preview: output quality is still improving and the API may change in a minor release.
+     *
+     * The schema version the engine pins, which docling-core's
+     * `DoclingDocument.model_validate_json` loads as it is. `name` is
+     * `DoclingDocument.name`, which Docling fills with the file's stem;
+     * absent means `"document"`. An XFA form is read from its flattened form,
+     * for the reason `extractMarkdown` above gives.
+     * @param {number | null} [first_page]
+     * @param {number | null} [page_count]
+     * @param {string | null} [name]
+     * @returns {string}
+     */
+    extractDocling(first_page, page_count, name) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.pdfdoc_extractDocling(retptr, this.__wbg_ptr, isLikeNone(first_page) ? Number.MAX_SAFE_INTEGER : (first_page) >>> 0, isLikeNone(page_count) ? Number.MAX_SAFE_INTEGER : (page_count) >>> 0, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * The document as markdown, in reading order (#573).
+     *
+     * Preview: output quality is still improving and the API may change in a minor release.
+     *
+     * Headings become `#` to `###`, list items `-` and `1.`, a table a pipe
+     * table or an HTML one where markdown cannot hold its shape, and a change
+     * of page an HTML comment. The running heads a document repeats are not in
+     * it; they are in `extractBlocks`.
+     *
+     * `firstPage` and `pageCount` choose a window of pages; leave both out for
+     * the whole document. The document is read whole whatever the window is,
+     * because what a block IS is decided against the rest of the document.
+     *
+     * AN XFA FORM IS READ FROM ITS FLATTENED FORM, the way `text` and
+     * `getTextPositions` read one: a dynamic XFA document draws its fields
+     * from a template rather than from page content, so the blocks of the
+     * unflattened file are the blocks of an empty page.
+     * @param {number | null} [first_page]
+     * @param {number | null} [page_count]
+     * @returns {string}
+     */
+    extractMarkdown(first_page, page_count) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_extractMarkdown(retptr, this.__wbg_ptr, isLikeNone(first_page) ? Number.MAX_SAFE_INTEGER : (first_page) >>> 0, isLikeNone(page_count) ? Number.MAX_SAFE_INTEGER : (page_count) >>> 0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Extract the listed pages (0-based) into a new document.
      * Used to implement "split" workflows in the browser.
@@ -659,6 +748,37 @@ export class PdfDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Replace this document's content with new bytes in-place.
+     *
+     * Call this after [`PdfDocMut.save`] to update the render handle with
+     * the mutated PDF bytes so that subsequent [`renderPage`] calls reflect
+     * the changes, without needing to create a new `PdfDoc` object.
+     *
+     * ```js
+     * const handle = PdfDocMut.open(bytes);
+     * handle.replaceTextSpan(1, "old", "new");
+     * const newBytes = handle.save();
+     * doc.refresh(newBytes);          // engine now renders the edited content
+     * doc.renderPage(0, 1.5);         // ← shows "new" instead of "old"
+     * ```
+     * @param {Uint8Array} data
+     */
+    refresh(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.pdfdoc_refresh(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Render a page to RGBA pixels.
      *
@@ -824,7 +944,14 @@ export class PdfDoc {
         }
     }
     /**
-     * Set a single AcroForm text-field value. Returns the new PDF bytes.
+     * Set a single AcroForm **text** field value. Returns the new PDF bytes.
+     *
+     * Updates `/V` (ASCII literal or UTF-16BE+BOM), per-widget `/AS`, and
+     * regenerates the `/AP` appearance stream so the fill is visible without
+     * `/NeedAppearances` processing. Read-only fields throw.
+     *
+     * **Text fields only.** For checkbox, radio, and choice fields use
+     * `PdfDocMut.setFormField`, which runs the full type-aware dispatch.
      * @param {string} path
      * @param {string} value
      * @returns {Uint8Array}
@@ -852,7 +979,7 @@ export class PdfDoc {
         }
     }
     /**
-     * Bulk-set multiple AcroForm text fields from a JSON object
+     * Bulk-set multiple AcroForm **text** fields from a JSON object
      * `{"field.path": "value", ...}`. Returns the new PDF bytes.
      * @param {string} fields_json
      * @returns {Uint8Array}
@@ -921,6 +1048,79 @@ export class PdfDoc {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Convert this PDF to a Word `.docx` package.
+     *
+     * Returns the package as a `Uint8Array`.
+     *
+     * The browser SDK could not do this until 23-08-2026: the conversion
+     * crates were excluded from wasm32 by a comment that applied to the
+     * renderer, not to them.
+     * @returns {Uint8Array}
+     */
+    toDocx() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_toDocx(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Convert this PDF to a PowerPoint `.pptx` deck, one slide per page.
+     * See [`Self::to_docx`].
+     * @returns {Uint8Array}
+     */
+    toPptx() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_toPptx(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Convert this PDF to an Excel `.xlsx` workbook. See [`Self::to_docx`].
+     * @returns {Uint8Array}
+     */
+    toXlsx() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pdfdoc_toXlsx(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Validate against a PDF/A level. Returns compliance report as JSON.
      * @param {string} level
@@ -1478,13 +1678,12 @@ export class PdfDocMut {
         }
     }
     /**
-     * Set a single AcroForm text-field value.
+     * Set a single AcroForm field value (text, checkbox, radio, or choice).
      *
-     * Note: pdfluent's high-level `PdfFormMut` requires a
-     * `pdfluent::PdfDocument`. To stay in-place on this handle, we use
-     * the lower-level lopdf walk via the `pdf-forms` engine. For 1.0,
-     * this supports flat top-level field hierarchies (no `/Kids`
-     * recursion) — same constraint as the Rust core.
+     * Delegates to [`pdf_forms::apply_field_value`] — the single SDK
+     * writeback chain. It keeps `/V` (ASCII literal else UTF-16BE+BOM),
+     * per-widget `/AS`, and regenerated `/AP` streams consistent, resolves
+     * fully-qualified names through `/Kids`, and rejects read-only fields.
      * @param {string} path
      * @param {string} value
      */
@@ -1506,7 +1705,7 @@ export class PdfDocMut {
         }
     }
     /**
-     * Bulk-set multiple AcroForm text fields from a JSON object
+     * Bulk-set multiple AcroForm fields from a JSON object
      * `{"field.path": "value", ...}`.
      * @param {string} fields_json
      */
@@ -1525,6 +1724,35 @@ export class PdfDocMut {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Select multiple options on a multi-select list box.
+     *
+     * Delegates to [`pdf_forms::apply_choice_multi`]: writes `/V` as an array
+     * of text strings and rebuilds `/I` (the sorted selected-index cache) to
+     * match what Adobe Acrobat produces. `values` is a JS array of strings;
+     * pass an empty array to clear the selection. The field must be a
+     * multi-select list box (`/Ff` MultiSelect flag); for non-editable list
+     * boxes every value must be one of the field's `/Opt` options.
+     * @param {string} path
+     * @param {string[]} values
+     */
+    setMultiSelect(path, values) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(values, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_setMultiSelect(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Apply bold/italic style to a text run on `page_num` (1-based).
      * @param {number} page_num
@@ -1563,6 +1791,215 @@ export class PdfDocMut {
 }
 if (Symbol.dispose) PdfDocMut.prototype[Symbol.dispose] = PdfDocMut.prototype.free;
 
+/**
+ * Find-and-replace editor over a PDF document (SDK surface).
+ */
+export class TextEditor {
+    static __wrap(ptr) {
+        const obj = Object.create(TextEditor.prototype);
+        obj.__wbg_ptr = ptr;
+        TextEditorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TextEditorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_texteditor_free(ptr, 0);
+    }
+    /**
+     * Find text occurrences. `query_json` is a JSON object:
+     *
+     * ```json
+     * {
+     *   "text": "Acme B.V.",          // required
+     *   "caseInsensitive": false,      // optional
+     *   "pages": [1, 5],               // optional inclusive 1-based range
+     *   "region": {                    // optional
+     *     "page": 1,
+     *     "rect": [x0, y0, x1, y1],
+     *     "relation": "intersects"     // or "contained"
+     *   },
+     *   "limit": 100                   // optional
+     * }
+     * ```
+     *
+     * Returns a JSON array of matches; each match carries an opaque `id`
+     * token valid until the next applied edit on this document.
+     * @param {string} query_json
+     * @returns {string}
+     */
+    findText(query_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.texteditor_findText(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Open a PDF from raw bytes.
+     * @param {Uint8Array} data
+     * @returns {TextEditor}
+     */
+    static open(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.texteditor_open(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return TextEditor.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Number of pages.
+     * @returns {number}
+     */
+    pageCount() {
+        const ret = wasm.texteditor_pageCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Apply per-match replacements located earlier with `findText`.
+     *
+     * `edits_json` is a JSON array of `{"id": "<match token>", "text":
+     * "<replacement>"}`. All edits commit in one atomic transaction under
+     * `options_json` (see [`TextEditor::replace_text`]); the default is
+     * all-or-nothing. Returns the JSON replacement report.
+     * @param {string} edits_json
+     * @param {string} options_json
+     * @returns {string}
+     */
+    replaceMatches(edits_json, options_json) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(edits_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.texteditor_replaceMatches(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Find and replace in one call. Returns the JSON replacement report.
+     *
+     * `options_json` may be empty/`"{}"` for defaults, or:
+     *
+     * ```json
+     * {
+     *   "fontFallback": "deny" | "injectStandard" | {"explicit": "F1"},
+     *   "signaturePolicy": "reject" | "allowPostSignatureChange",
+     *   "commitPolicy": "allOrNothing" | "bestEffort"
+     * }
+     * ```
+     * @param {string} query_json
+     * @param {string} replacement
+     * @param {string} options_json
+     * @returns {string}
+     */
+    replaceText(query_json, replacement, options_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(query_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(replacement, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.texteditor_replaceText(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr4 = r0;
+            var len4 = r1;
+            if (r3) {
+                ptr4 = 0; len4 = 0;
+                throw takeObject(r2);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * Serialize the (possibly edited) document to PDF bytes.
+     * @returns {Uint8Array}
+     */
+    save() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.texteditor_save(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) TextEditor.prototype[Symbol.dispose] = TextEditor.prototype.free;
+
 /**
  * The main XFA processing engine for WASM.
  *
@@ -1834,44 +2271,152 @@ export class XfaEngine {
 if (Symbol.dispose) XfaEngine.prototype[Symbol.dispose] = XfaEngine.prototype.free;
 
 /**
- * Activate the process-global license from a key string.
+ * Remove the password from a PDF whose password you know, and return the
+ * unprotected bytes; open them with `PdfDoc.open`.
  *
- * Throws on invalid key or if the process has already been activated to a
- * different tier this session.
- * @param {string} key
+ * The owner password always works. The user password works only when the
+ * file has no permission restrictions. Throws `PdfluentError` with
+ * `E-SECURITY-DECRYPTION-FAILED` for a password that does not entitle the
+ * caller, and `E-WASM-INVALID-ARGUMENT` for a PDF without a password.
+ * @param {Uint8Array} bytes
+ * @param {string} password
+ * @returns {Uint8Array}
  */
-export function activateLicenseKey(key) {
+export function decryptPdf(bytes, password) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        wasm.activateLicenseKey(retptr, ptr0, len0);
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.decryptPdf(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        if (r1) {
-            throw takeObject(r0);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v3 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v3;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Encrypt a PDF with AES-256 and return the encrypted bytes.
+ *
+ * `userPassword` is needed to open the file (may be empty: then anyone can
+ * open it, and the permissions apply); `ownerPassword` lifts the permissions
+ * (empty: the user password serves as both). Refuses a PDF that is already
+ * encrypted. Throws `PdfluentError` with `E-WASM-INVALID-ARGUMENT` or
+ * `E-PARSE-INVALID-PDF`.
+ * @param {Uint8Array} bytes
+ * @param {string} user_password
+ * @param {string} owner_password
+ * @param {EncryptPermissions | null} [permissions]
+ * @returns {Uint8Array}
+ */
+export function encryptPdf(bytes, user_password, owner_password, permissions) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(user_password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(owner_password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.encryptPdf(retptr, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(permissions) ? 0 : addHeapObject(permissions));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v4 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v4;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Extract the images of a PDF as PNG or JPEG files.
+ *
+ * Returns `{ images, skipped }`. An image that could not be exported exactly
+ * as it looks -- JPEG 2000, JBIG2 or fax compression, a transparency mask, a
+ * Decode array, CMYK, an ICC profile other than sRGB -- is listed in `skipped`
+ * with the reason, never emitted wrong. Each image is listed once, on the
+ * first page (0-based) that uses it.
+ * @param {Uint8Array} bytes
+ * @returns {ImageExtraction}
+ */
+export function extractImages(bytes) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.extractImages(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
         }
+        return takeObject(r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Return the current license status. Always succeeds; defaults to Trial.
- * @returns {LicenseStatus}
+ * Sign a PDF with your own certificate (a .p12/.pfx file and its password)
+ * and return the signed bytes. The private key never leaves the page.
+ *
+ * This is a cryptographic PAdES signature (ETSI.CAdES.detached), appended as
+ * an incremental update so earlier signatures stay valid. Without a
+ * timestamp authority: no TSA or LTV in the browser. A self-signed
+ * certificate verifies, but readers such as Acrobat show its validity as
+ * unknown because they do not trust the issuer. Throws `PdfluentError` with
+ * `E-SECURITY-DECRYPTION-FAILED` for a wrong certificate password.
+ * @param {Uint8Array} bytes
+ * @param {Uint8Array} pkcs12
+ * @param {string} password
+ * @param {SignPdfOptions | null} [options]
+ * @returns {Uint8Array}
  */
-export function licenseStatus() {
-    const ret = wasm.licenseStatus();
-    return LicenseStatus.__wrap(ret);
+export function signPdf(bytes, pkcs12, password, options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(pkcs12, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.signPdf(retptr, ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(options) ? 0 : addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v4 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v4;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_bce6d499ff0a4aff: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg___pdfluent_error_ctor_eea54aa1c0fd64d9: function() {
+        __wbg___pdfluent_error_ctor_17e86bb485874967: function() {
             const ret = __pdfluent_error_ctor();
             return addHeapObject(ret);
         },
@@ -1886,6 +2431,22 @@ function __wbg_get_imports() {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
         },
+        __wbg___wbindgen_is_null_2042690d351e14f0: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_d109740c0d18f4d7: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
@@ -1921,7 +2482,7 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         }, arguments); },
-        __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
+        __wbg_getRandomValues_76dfc69825c9c552: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
         __wbg_instanceof_CanvasRenderingContext2d_d4be74cff7165c1e: function(arg0) {
@@ -1943,6 +2504,10 @@ function __wbg_get_imports() {
         __wbg_moveTo_11bf5a977e6b8610: function(arg0, arg1, arg2) {
             getObject(arg0).moveTo(arg1, arg2);
         },
+        __wbg_new_02d162bc6cf02f60: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
         __wbg_new_1f236d63ba0c4784: function(arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -1951,10 +2516,18 @@ function __wbg_get_imports() {
             const ret = new Array();
             return addHeapObject(ret);
         },
+        __wbg_new_from_slice_269e35316ed2d061: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_with_u8_clamped_array_and_sh_13504c3c5394c7c9: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_now_81363d44c96dd239: function() {
+            const ret = Date.now();
+            return ret;
+        },
         __wbg_push_b77c476b01548d0a: function(arg0, arg1) {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
@@ -2020,6 +2593,10 @@ function __wbg_get_imports() {
         __wbg_set_width_25112eb6bf1148df: function(arg0, arg1) {
             getObject(arg0).width = arg1 >>> 0;
         },
+        __wbg_stringify_ef0c105b1ccc3849: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_strokeRect_3430a0df4158ba67: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).strokeRect(arg1, arg2, arg3, arg4);
         },
@@ -2056,15 +2633,15 @@ function __wbg_get_imports() {
 }
 
 const __wbindgen_enum_CanvasWindingRule = ["nonzero", "evenodd"];
-const LicenseStatusFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_licensestatus_free(ptr, 1));
 const PdfDocFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pdfdoc_free(ptr, 1));
 const PdfDocMutFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pdfdocmut_free(ptr, 1));
+const TextEditorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_texteditor_free(ptr, 1));
 const XfaEngineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_xfaengine_free(ptr, 1));
@@ -2234,6 +2811,16 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);