@pdfluent/sdk-wasm 1.0.0-beta.10 → 1.0.0-beta.12

package/README.md

@@ -4,9 +4,10 @@ WebAssembly distribution of the PDFluent PDF engine. Read, edit, annotate,
 redact, sign, and validate PDFs (including XFA) entirely in the browser —
 zero bytes go to a server.
 
-Published as `@pdfluent/xfa-wasm` on npm. (Crate name reflects historical
-XFA roots; the package now covers the full SDK surface needed for an
-in-browser PDF editor.)
+Published as `@pdfluent/sdk-wasm` on npm. (The crate directory is named
+`xfa-wasm` for historical XFA roots — the published npm package covers the
+full SDK surface needed for an in-browser PDF editor. Previously known as
+`@pdfluent/xfa-wasm`; renamed to `@pdfluent/sdk-wasm`.)
 
 ## Features
 
@@ -31,10 +32,10 @@ in-browser PDF editor.)
 cargo install wasm-pack
 
 # Build the WASM package
-wasm-pack build crates/@pdfluent/wasm --target web
+wasm-pack build crates/xfa-wasm --target web
 
 # Without rendering (smaller bundle)
-wasm-pack build crates/@pdfluent/wasm --target web -- --no-default-features
+wasm-pack build crates/xfa-wasm --target web -- --no-default-features
 ```
 
 ## Quick Start
@@ -148,7 +149,7 @@ const data = forms.exportJson();
 Build without optional features for a smaller WASM binary:
 
 ```bash
-wasm-pack build crates/@pdfluent/wasm --target web -- --no-default-features
+wasm-pack build crates/xfa-wasm --target web -- --no-default-features
 ```
 
 ## API Reference
@@ -175,7 +176,7 @@ is marked via `/Producer` metadata in Trial. Activate a license to remove
 the mark and unlock paid capabilities.
 
 ```js
-import init, { activateLicenseKey, licenseStatus } from '@pdfluent/xfa-wasm';
+import init, { activateLicenseKey, licenseStatus } from '@pdfluent/sdk-wasm';
 
 await init();
 activateLicenseKey('tier:enterprise');
@@ -278,7 +279,7 @@ operations to the same document, **`PdfDocMut` is dramatically faster**:
 #### Editor flow with PdfDocMut
 
 ```js
-import init, { PdfDocMut } from '@pdfluent/xfa-wasm';
+import init, { PdfDocMut } from '@pdfluent/sdk-wasm';
 
 await init();
 const bytes  = new Uint8Array(await (await fetch('/document.pdf')).arrayBuffer());
@@ -304,7 +305,7 @@ are equally fine. They are kept for backward compatibility but the
 recommended path for any multi-step edit is `PdfDocMut`.
 
 ```js
-import init, { PdfDoc } from '@pdfluent/xfa-wasm';
+import init, { PdfDoc } from '@pdfluent/sdk-wasm';
 await init();
 const doc = PdfDoc.open(bytes);
 const merged = doc.merge(otherBytes);   // single op, one-shot

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pdfluent/sdk-wasm",
   "type": "module",
   "description": "PDFluent browser SDK — read, edit, annotate, redact, sign, and validate PDFs (including XFA) entirely client-side via WASM.",
-  "version": "1.0.0-beta.10",
+  "version": "1.0.0-beta.12",
   "license": "SEE LICENSE IN LICENSE",
   "files": [
     "xfa_wasm_bg.wasm",

package/xfa_wasm.d.ts

@@ -49,6 +49,33 @@ export class LicenseStatus {
  *
  * Uses `pdf-syntax` for metadata/geometry/signatures/compliance and
  * `pdf-engine` for text extraction so the WASM path matches native decoding.
+ *
+ * # Memory lifecycle
+ *
+ * `PdfDoc` holds native WASM memory. Call [`PdfDoc.free()`] when done,
+ * or use the `using` keyword (TypeScript 5.2+):
+ *
+ * ```js
+ * using doc = PdfDoc.open(bytes);
+ * // doc.free() is called automatically at end of block
+ * ```
+ *
+ * After `free()`, all method calls throw. Do not hold references across `free()`.
+ *
+ * # Errors
+ *
+ * All fallible methods throw a `PdfluentError` — a standard `Error` subclass with
+ * these properties:
+ * - `code`: stable C8 catalogue identifier in `E-<CATEGORY>-<SPECIFIC>` format
+ *   (e.g. `"E-PARSE-INVALID-PDF"`). Use this for programmatic dispatch.
+ * - `message`: human-readable description (stable for backwards compatibility).
+ * - `operation`: short identifier of the API call that failed.
+ * - `help`: optional actionable hint (may be empty string).
+ * - `docsUrl`: deep-link into `https://pdfluent.com/errors/<code>`.
+ * - `legacyCode`: the original SCREAMING_SNAKE_CASE identifier from the
+ *   pre-1.0 WASM binding, preserved so older user code keeps working.
+ *
+ * JavaScript callers can use `error instanceof PdfluentError` to discriminate.
  */
 export class PdfDoc {
     private constructor();
@@ -121,8 +148,30 @@ export class PdfDoc {
      *
      * ```js
      * const runs = JSON.parse(doc.getTextPositions(0));
-     * // runs[i] = { text: "Hello world", x: 72.0, y: 100.0, width: 96.0, height: 12.0, fontSize: 12.0 }
+     * // runs[i] = {
+     * //   text: "Hello world",
+     * //   x: 72.0, y: 100.0, width: 96.0, height: 12.0, fontSize: 12.0,
+     * //   fontName: "Helvetica-Bold", // G1: stable presence; null when unknown
+     * //   isBold: true, isItalic: false,
+     * //   color: [0, 0, 0, 255],      // G1: omitted when unknown
+     * //   widthSource: "Metric",      // G2: "Metric" | "Estimate"
+     * //   charBounds: [[72,100,80,112], …] // G2: per-glyph bounds (omitted when empty)
+     * // }
      * ```
+     *
+     * `fontName` is always present in the JSON: a known PostScript
+     * name (embedded font, or resolved standard-14 fallback for
+     * non-embedded Type1) emits a string; an unknown name (Type3
+     * glyphs, embedded Type1 without a standard-font fallback)
+     * emits `null`. This stable presence matches the editor
+     * contract; the editor can call `run.fontName ?? "Unknown"`
+     * or do `'fontName' in run` tests without conditional logic.
+     *
+     * `color` is still omitted from the JSON when the source paint
+     * is a pattern/shading or the color space could not be
+     * resolved. `isBold`/`isItalic` are always present so editor
+     * toolbars can render unconditionally. `widthSource` is always
+     * present; `charBounds` is omitted only when the span is empty.
      */
     getTextPositions(page_index: number): string;
     /**
@@ -277,6 +326,16 @@ export class PdfDocMut {
      * Apply a diagonal text watermark to every page.
      */
     addTextWatermark(text: string, opacity: number): void;
+    /**
+     * Convenience: open bytes, format a single run, return new bytes.
+     *
+     * One-shot equivalent of `open → formatTextSpan → save`.
+     */
+    static applyTextFormat(data: Uint8Array, page_num: number, run_index: number, font_size?: number | null, color?: string | null): Uint8Array;
+    /**
+     * Convenience: open bytes, apply style, return new bytes.
+     */
+    static applyTextRunStyle(data: Uint8Array, page_num: number, run_index: number, bold?: boolean | null, italic?: boolean | null): Uint8Array;
     /**
      * Re-encode content streams with deflate compression.
      */
@@ -293,6 +352,26 @@ export class PdfDocMut {
      * set of pages and a subset is exported.
      */
     extractPages(pages: Uint32Array): Uint8Array;
+    /**
+     * Format a single text run on `page_num` (1-based) by changing its font
+     * size and/or fill color. The mutation is scoped so other runs on the
+     * page are unaffected (q…Q isolation injected as needed).
+     *
+     * Parameters:
+     * - `page_num`: 1-based page index.
+     * - `run_index`: 0-based index into `extract_page_text_runs(page_num)`.
+     * - `font_size`: optional new font size (points). Pass `None` to keep.
+     * - `color`: optional hex color string (e.g. `"#FF0000"`); pass `None`
+     *   to keep the existing fill color.
+     *
+     * Returns a JSON string with the canonical `FormatResult` shape:
+     * `{ "formatted": bool, "bytesChanged": usize, "isolationStrategy": str,
+     *   "originalSize": f32?, "originalColor": [f32; 3]?, "code": str? }`.
+     *
+     * Passing both `font_size = None` and `color = None` is a no-op:
+     * `formatted = false`, `bytesChanged = 0`, no error.
+     */
+    formatTextSpan(page_num: number, run_index: number, font_size?: number | null, color?: string | null): string;
     /**
      * Open a PDF for editing.
      */
@@ -314,6 +393,50 @@ export class PdfDocMut {
      * Re-order pages. `new_order` is a permutation of `0..page_count`.
      */
     reorderPages(new_order: Uint32Array): void;
+    /**
+     * G3 — Replace a text span on a page.
+     *
+     * The editor passes the **exact** text it extracted from
+     * `getTextPositions()` as `original_text`, and the desired
+     * replacement as `replacement_text`. The replacement is
+     * re-encoded into the same font used by the matched span
+     * (subset-font fallback applies when the original font cannot
+     * encode the replacement — see
+     * `pdf-manip::text_replace::replace_text`).
+     *
+     * `page_num` is **1-based** to match the rest of the
+     * `pdf-manip` surface (and the existing `formatTextSpan` /
+     * `setTextRunStyle` methods on this handle).
+     *
+     * Returns a JSON string with the following shape:
+     *
+     * ```jsonc
+     * {
+     *   "replaced": false,
+     *   "code": "NO_MATCH",          // only when replaced=false
+     *   "reason": "originalText …",  // only when replaced=false
+     *   "byteLengthBefore": 12345,   // only when replaced=true
+     *   "byteLengthAfter":  12378    // only when replaced=true
+     * }
+     * ```
+     *
+     * Typed unsupported codes (all set `replaced=false`):
+     *
+     * - `"NO_MATCH"` — `original_text` not found on the page.
+     * - `"ENCODING_UNSUPPORTED"` — replacement contains characters
+     *   the matched font cannot encode and no fallback font is
+     *   available.
+     * - `"REPLACE_FAILED"` — anything else (lopdf I/O,
+     *   serialisation, FontMap construction, …). `reason` carries
+     *   the lower-level error message.
+     *
+     * Layout is preserved within the existing run: same font,
+     * same baseline, same `Tj`/`TJ` operator boundaries. Cross-run
+     * matches (where the search text is split across multiple
+     * content-stream operators) are handled by the underlying
+     * `replace_text` cross-run path.
+     */
+    replaceTextSpan(page_num: number, original_text: string, replacement_text: string): string;
     /**
      * Rotate a single page by 90/180/270 (or negative). Multiples of 90 only.
      */
@@ -340,12 +463,43 @@ export class PdfDocMut {
      * `{"field.path": "value", ...}`.
      */
     setFormFields(fields_json: string): void;
+    /**
+     * Apply bold/italic style to a text run on `page_num` (1-based).
+     */
+    setTextRunStyle(page_num: number, runs_json: string, run_index: number, bold?: boolean | null, italic?: boolean | null): string;
 }
 
 /**
  * The main XFA processing engine for WASM.
  *
  * Holds a parsed FormTree and provides methods to extract/import data.
+ *
+ * # Memory lifecycle
+ *
+ * `XfaEngine` holds native WASM memory. Call [`XfaEngine.free()`] when done,
+ * or use the `using` keyword (TypeScript 5.2+, TC39 Explicit Resource Management):
+ *
+ * ```js
+ * using engine = XfaEngine.fromFields(fields);
+ * // engine.free() is called automatically at end of block
+ * ```
+ *
+ * After `free()`, all method calls throw. Do not keep references across blocks.
+ *
+ * # Errors
+ *
+ * All fallible methods throw a `PdfluentError` — a standard `Error` subclass with
+ * these properties:
+ * - `code`: stable C8 catalogue identifier in `E-<CATEGORY>-<SPECIFIC>` format
+ *   (e.g. `"E-PARSE-INVALID-PDF"`). Use this for programmatic dispatch.
+ * - `message`: human-readable description (stable for backwards compatibility).
+ * - `operation`: short identifier of the API call that failed.
+ * - `help`: optional actionable hint (may be empty string).
+ * - `docsUrl`: deep-link into `https://pdfluent.com/errors/<code>`.
+ * - `legacyCode`: the original SCREAMING_SNAKE_CASE identifier from the
+ *   pre-1.0 WASM binding, preserved so older user code keeps working.
+ *
+ * JavaScript callers can use `error instanceof PdfluentError` to discriminate.
  */
 export class XfaEngine {
     private constructor();
@@ -419,6 +573,27 @@ export class XfaEngine {
  */
 export function activateLicenseKey(key: string): void;
 
+/**
+ * Flatten an XFA (XML Forms Architecture) PDF into a static, viewer-agnostic
+ * PDF, entirely in the browser.
+ *
+ * `data` is the raw PDF bytes (a dynamic or static XFA form). `password` is an
+ * optional user password for XFA PDFs protected with PDF user-password
+ * encryption; it is ignored for unencrypted input. A wrong or missing password
+ * on an encrypted document throws an error whose message starts
+ * `E-XFA-ENCRYPTED` and never returns plaintext; a password on an unencrypted
+ * PDF is ignored. This does not crack, remove, or bypass owner-password
+ * permissions.
+ *
+ * ```js
+ * import init, { flattenXfa } from "@pdfluent/sdk-wasm";
+ * await init();
+ * const flat = flattenXfa(new Uint8Array(buf));           // unencrypted
+ * const flatEnc = flattenXfa(new Uint8Array(buf), "secret"); // encrypted
+ * ```
+ */
+export function flattenXfa(data: Uint8Array, password?: string | null): Uint8Array;
+
 /**
  * Return the current license status. Always succeeds; defaults to Trial.
  */
@@ -433,6 +608,7 @@ export interface InitOutput {
     readonly __wbg_pdfdocmut_free: (a: number, b: number) => void;
     readonly __wbg_xfaengine_free: (a: number, b: number) => void;
     readonly activateLicenseKey: (a: number, b: number, c: number) => void;
+    readonly flattenXfa: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly licenseStatus: () => number;
     readonly licensestatus_outputIsMarked: (a: number) => number;
     readonly licensestatus_source: (a: number, b: number) => void;
@@ -474,18 +650,23 @@ export interface InitOutput {
     readonly pdfdocmut_addHighlight: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly pdfdocmut_addStickyNote: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly pdfdocmut_addTextWatermark: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly pdfdocmut_applyTextFormat: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly pdfdocmut_applyTextRunStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly pdfdocmut_compress: (a: number, b: number) => void;
     readonly pdfdocmut_deletePages: (a: number, b: number, c: number, d: number) => void;
     readonly pdfdocmut_extractPages: (a: number, b: number, c: number, d: number) => void;
+    readonly pdfdocmut_formatTextSpan: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly pdfdocmut_open: (a: number, b: number, c: number) => void;
     readonly pdfdocmut_pageCount: (a: number) => number;
     readonly pdfdocmut_redactRegion: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly pdfdocmut_redactSearch: (a: number, b: number, c: number, d: number) => void;
     readonly pdfdocmut_reorderPages: (a: number, b: number, c: number, d: number) => void;
+    readonly pdfdocmut_replaceTextSpan: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly pdfdocmut_rotatePage: (a: number, b: number, c: number, d: number) => void;
     readonly pdfdocmut_save: (a: number, b: number) => void;
     readonly pdfdocmut_setFormField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly pdfdocmut_setFormFields: (a: number, b: number, c: number, d: number) => void;
+    readonly pdfdocmut_setTextRunStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly xfaengine_exportJson: (a: number, b: number) => void;
     readonly xfaengine_exportSchema: (a: number, b: number) => void;
     readonly xfaengine_fromFields: (a: number, b: number, c: number) => void;

package/xfa_wasm.js

@@ -1,4 +1,6 @@
 /* @ts-self-types="./xfa_wasm.d.ts" */
+import { __pdfluent_error_ctor } from './snippets/xfa-wasm-312742e1abcfad9e/inline0.js';
+
 
 /**
  * Chroma subsampling format
@@ -28,7 +30,6 @@ export const ChromaSampling = Object.freeze({
  */
 export class LicenseStatus {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(LicenseStatus.prototype);
         obj.__wbg_ptr = ptr;
         LicenseStatusFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -100,10 +101,36 @@ if (Symbol.dispose) LicenseStatus.prototype[Symbol.dispose] = LicenseStatus.prot
  *
  * Uses `pdf-syntax` for metadata/geometry/signatures/compliance and
  * `pdf-engine` for text extraction so the WASM path matches native decoding.
+ *
+ * # Memory lifecycle
+ *
+ * `PdfDoc` holds native WASM memory. Call [`PdfDoc.free()`] when done,
+ * or use the `using` keyword (TypeScript 5.2+):
+ *
+ * ```js
+ * using doc = PdfDoc.open(bytes);
+ * // doc.free() is called automatically at end of block
+ * ```
+ *
+ * After `free()`, all method calls throw. Do not hold references across `free()`.
+ *
+ * # Errors
+ *
+ * All fallible methods throw a `PdfluentError` — a standard `Error` subclass with
+ * these properties:
+ * - `code`: stable C8 catalogue identifier in `E-<CATEGORY>-<SPECIFIC>` format
+ *   (e.g. `"E-PARSE-INVALID-PDF"`). Use this for programmatic dispatch.
+ * - `message`: human-readable description (stable for backwards compatibility).
+ * - `operation`: short identifier of the API call that failed.
+ * - `help`: optional actionable hint (may be empty string).
+ * - `docsUrl`: deep-link into `https://pdfluent.com/errors/<code>`.
+ * - `legacyCode`: the original SCREAMING_SNAKE_CASE identifier from the
+ *   pre-1.0 WASM binding, preserved so older user code keeps working.
+ *
+ * JavaScript callers can use `error instanceof PdfluentError` to discriminate.
  */
 export class PdfDoc {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(PdfDoc.prototype);
         obj.__wbg_ptr = ptr;
         PdfDocFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -424,8 +451,30 @@ export class PdfDoc {
      *
      * ```js
      * const runs = JSON.parse(doc.getTextPositions(0));
-     * // runs[i] = { text: "Hello world", x: 72.0, y: 100.0, width: 96.0, height: 12.0, fontSize: 12.0 }
+     * // runs[i] = {
+     * //   text: "Hello world",
+     * //   x: 72.0, y: 100.0, width: 96.0, height: 12.0, fontSize: 12.0,
+     * //   fontName: "Helvetica-Bold", // G1: stable presence; null when unknown
+     * //   isBold: true, isItalic: false,
+     * //   color: [0, 0, 0, 255],      // G1: omitted when unknown
+     * //   widthSource: "Metric",      // G2: "Metric" | "Estimate"
+     * //   charBounds: [[72,100,80,112], …] // G2: per-glyph bounds (omitted when empty)
+     * // }
      * ```
+     *
+     * `fontName` is always present in the JSON: a known PostScript
+     * name (embedded font, or resolved standard-14 fallback for
+     * non-embedded Type1) emits a string; an unknown name (Type3
+     * glyphs, embedded Type1 without a standard-font fallback)
+     * emits `null`. This stable presence matches the editor
+     * contract; the editor can call `run.fontName ?? "Unknown"`
+     * or do `'fontName' in run` tests without conditional logic.
+     *
+     * `color` is still omitted from the JSON when the source paint
+     * is a pattern/shading or the color space could not be
+     * resolved. `isBold`/`isItalic` are always present so editor
+     * toolbars can render unconditionally. `widthSource` is always
+     * present; `charBounds` is omitted only when the span is empty.
      * @param {number} page_index
      * @returns {string}
      */
@@ -938,7 +987,6 @@ if (Symbol.dispose) PdfDoc.prototype[Symbol.dispose] = PdfDoc.prototype.free;
  */
 export class PdfDocMut {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(PdfDocMut.prototype);
         obj.__wbg_ptr = ptr;
         PdfDocMutFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -1045,6 +1093,68 @@ export class PdfDocMut {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Convenience: open bytes, format a single run, return new bytes.
+     *
+     * One-shot equivalent of `open → formatTextSpan → save`.
+     * @param {Uint8Array} data
+     * @param {number} page_num
+     * @param {number} run_index
+     * @param {number | null} [font_size]
+     * @param {string | null} [color]
+     * @returns {Uint8Array}
+     */
+    static applyTextFormat(data, page_num, run_index, font_size, color) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(color) ? 0 : passStringToWasm0(color, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_applyTextFormat(retptr, ptr0, len0, page_num, run_index, isLikeNone(font_size) ? Number.MAX_SAFE_INTEGER : Math.fround(font_size), 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);
+            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);
+        }
+    }
+    /**
+     * Convenience: open bytes, apply style, return new bytes.
+     * @param {Uint8Array} data
+     * @param {number} page_num
+     * @param {number} run_index
+     * @param {boolean | null} [bold]
+     * @param {boolean | null} [italic]
+     * @returns {Uint8Array}
+     */
+    static applyTextRunStyle(data, page_num, run_index, bold, italic) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_applyTextRunStyle(retptr, ptr0, len0, page_num, run_index, isLikeNone(bold) ? 0xFFFFFF : bold ? 1 : 0, isLikeNone(italic) ? 0xFFFFFF : italic ? 1 : 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);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Re-encode content streams with deflate compression.
      */
@@ -1109,6 +1219,56 @@ export class PdfDocMut {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Format a single text run on `page_num` (1-based) by changing its font
+     * size and/or fill color. The mutation is scoped so other runs on the
+     * page are unaffected (q…Q isolation injected as needed).
+     *
+     * Parameters:
+     * - `page_num`: 1-based page index.
+     * - `run_index`: 0-based index into `extract_page_text_runs(page_num)`.
+     * - `font_size`: optional new font size (points). Pass `None` to keep.
+     * - `color`: optional hex color string (e.g. `"#FF0000"`); pass `None`
+     *   to keep the existing fill color.
+     *
+     * Returns a JSON string with the canonical `FormatResult` shape:
+     * `{ "formatted": bool, "bytesChanged": usize, "isolationStrategy": str,
+     *   "originalSize": f32?, "originalColor": [f32; 3]?, "code": str? }`.
+     *
+     * Passing both `font_size = None` and `color = None` is a no-op:
+     * `formatted = false`, `bytesChanged = 0`, no error.
+     * @param {number} page_num
+     * @param {number} run_index
+     * @param {number | null} [font_size]
+     * @param {string | null} [color]
+     * @returns {string}
+     */
+    formatTextSpan(page_num, run_index, font_size, color) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(color) ? 0 : passStringToWasm0(color, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_formatTextSpan(retptr, this.__wbg_ptr, page_num, run_index, isLikeNone(font_size) ? Number.MAX_SAFE_INTEGER : Math.fround(font_size), 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 for editing.
      * @param {Uint8Array} bytes
@@ -1199,6 +1359,81 @@ export class PdfDocMut {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * G3 — Replace a text span on a page.
+     *
+     * The editor passes the **exact** text it extracted from
+     * `getTextPositions()` as `original_text`, and the desired
+     * replacement as `replacement_text`. The replacement is
+     * re-encoded into the same font used by the matched span
+     * (subset-font fallback applies when the original font cannot
+     * encode the replacement — see
+     * `pdf-manip::text_replace::replace_text`).
+     *
+     * `page_num` is **1-based** to match the rest of the
+     * `pdf-manip` surface (and the existing `formatTextSpan` /
+     * `setTextRunStyle` methods on this handle).
+     *
+     * Returns a JSON string with the following shape:
+     *
+     * ```jsonc
+     * {
+     *   "replaced": false,
+     *   "code": "NO_MATCH",          // only when replaced=false
+     *   "reason": "originalText …",  // only when replaced=false
+     *   "byteLengthBefore": 12345,   // only when replaced=true
+     *   "byteLengthAfter":  12378    // only when replaced=true
+     * }
+     * ```
+     *
+     * Typed unsupported codes (all set `replaced=false`):
+     *
+     * - `"NO_MATCH"` — `original_text` not found on the page.
+     * - `"ENCODING_UNSUPPORTED"` — replacement contains characters
+     *   the matched font cannot encode and no fallback font is
+     *   available.
+     * - `"REPLACE_FAILED"` — anything else (lopdf I/O,
+     *   serialisation, FontMap construction, …). `reason` carries
+     *   the lower-level error message.
+     *
+     * Layout is preserved within the existing run: same font,
+     * same baseline, same `Tj`/`TJ` operator boundaries. Cross-run
+     * matches (where the search text is split across multiple
+     * content-stream operators) are handled by the underlying
+     * `replace_text` cross-run path.
+     * @param {number} page_num
+     * @param {string} original_text
+     * @param {string} replacement_text
+     * @returns {string}
+     */
+    replaceTextSpan(page_num, original_text, replacement_text) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(original_text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(replacement_text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_replaceTextSpan(retptr, this.__wbg_ptr, page_num, 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);
+        }
+    }
     /**
      * Rotate a single page by 90/180/270 (or negative). Multiples of 90 only.
      * @param {number} page_index
@@ -1290,6 +1525,41 @@ export class PdfDocMut {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Apply bold/italic style to a text run on `page_num` (1-based).
+     * @param {number} page_num
+     * @param {string} runs_json
+     * @param {number} run_index
+     * @param {boolean | null} [bold]
+     * @param {boolean | null} [italic]
+     * @returns {string}
+     */
+    setTextRunStyle(page_num, runs_json, run_index, bold, italic) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(runs_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.pdfdocmut_setTextRunStyle(retptr, this.__wbg_ptr, page_num, ptr0, len0, run_index, isLikeNone(bold) ? 0xFFFFFF : bold ? 1 : 0, isLikeNone(italic) ? 0xFFFFFF : italic ? 1 : 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 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);
+        }
+    }
 }
 if (Symbol.dispose) PdfDocMut.prototype[Symbol.dispose] = PdfDocMut.prototype.free;
 
@@ -1297,10 +1567,36 @@ if (Symbol.dispose) PdfDocMut.prototype[Symbol.dispose] = PdfDocMut.prototype.fr
  * The main XFA processing engine for WASM.
  *
  * Holds a parsed FormTree and provides methods to extract/import data.
+ *
+ * # Memory lifecycle
+ *
+ * `XfaEngine` holds native WASM memory. Call [`XfaEngine.free()`] when done,
+ * or use the `using` keyword (TypeScript 5.2+, TC39 Explicit Resource Management):
+ *
+ * ```js
+ * using engine = XfaEngine.fromFields(fields);
+ * // engine.free() is called automatically at end of block
+ * ```
+ *
+ * After `free()`, all method calls throw. Do not keep references across blocks.
+ *
+ * # Errors
+ *
+ * All fallible methods throw a `PdfluentError` — a standard `Error` subclass with
+ * these properties:
+ * - `code`: stable C8 catalogue identifier in `E-<CATEGORY>-<SPECIFIC>` format
+ *   (e.g. `"E-PARSE-INVALID-PDF"`). Use this for programmatic dispatch.
+ * - `message`: human-readable description (stable for backwards compatibility).
+ * - `operation`: short identifier of the API call that failed.
+ * - `help`: optional actionable hint (may be empty string).
+ * - `docsUrl`: deep-link into `https://pdfluent.com/errors/<code>`.
+ * - `legacyCode`: the original SCREAMING_SNAKE_CASE identifier from the
+ *   pre-1.0 WASM binding, preserved so older user code keeps working.
+ *
+ * JavaScript callers can use `error instanceof PdfluentError` to discriminate.
  */
 export class XfaEngine {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(XfaEngine.prototype);
         obj.__wbg_ptr = ptr;
         XfaEngineFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -1560,6 +1856,51 @@ export function activateLicenseKey(key) {
     }
 }
 
+/**
+ * Flatten an XFA (XML Forms Architecture) PDF into a static, viewer-agnostic
+ * PDF, entirely in the browser.
+ *
+ * `data` is the raw PDF bytes (a dynamic or static XFA form). `password` is an
+ * optional user password for XFA PDFs protected with PDF user-password
+ * encryption; it is ignored for unencrypted input. A wrong or missing password
+ * on an encrypted document throws an error whose message starts
+ * `E-XFA-ENCRYPTED` and never returns plaintext; a password on an unencrypted
+ * PDF is ignored. This does not crack, remove, or bypass owner-password
+ * permissions.
+ *
+ * ```js
+ * import init, { flattenXfa } from "@pdfluent/sdk-wasm";
+ * await init();
+ * const flat = flattenXfa(new Uint8Array(buf));           // unencrypted
+ * const flatEnc = flattenXfa(new Uint8Array(buf), "secret"); // encrypted
+ * ```
+ * @param {Uint8Array} data
+ * @param {string | null} [password]
+ * @returns {Uint8Array}
+ */
+export function flattenXfa(data, password) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(password) ? 0 : passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.flattenXfa(retptr, 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);
+        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);
+    }
+}
+
 /**
  * Return the current license status. Always succeeds; defaults to Trial.
  * @returns {LicenseStatus}
@@ -1568,56 +1909,67 @@ export function licenseStatus() {
     const ret = wasm.licenseStatus();
     return LicenseStatus.__wrap(ret);
 }
-
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
+        __wbg_Error_bce6d499ff0a4aff: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
-        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
+        __wbg___pdfluent_error_ctor_eea54aa1c0fd64d9: function() {
+            const ret = __pdfluent_error_ctor();
+            return addHeapObject(ret);
+        },
+        __wbg___wbindgen_debug_string_edece8177ad01481: function(arg0, arg1) {
             const ret = debugString(getObject(arg1));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+        __wbg___wbindgen_is_function_5cd60d5cf78b4eef: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_throw_9c31b086c2b26051: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_beginPath_596efed55075dbc3: function(arg0) {
+        __wbg_beginPath_0362b3134ed67152: function(arg0) {
             getObject(arg0).beginPath();
         },
-        __wbg_bezierCurveTo_ee956cad5cea25b2: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        __wbg_bezierCurveTo_2d7f81b72815a6e9: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             getObject(arg0).bezierCurveTo(arg1, arg2, arg3, arg4, arg5, arg6);
         },
-        __wbg_clearRect_ea4f3d34d76f4bc5: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_clearRect_1ea64f387215d3b8: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).clearRect(arg1, arg2, arg3, arg4);
         },
-        __wbg_clip_307b93ada960ec4d: function(arg0, arg1) {
+        __wbg_clip_e9791a9cb5940a47: function(arg0, arg1) {
             getObject(arg0).clip(__wbindgen_enum_CanvasWindingRule[arg1]);
         },
-        __wbg_closePath_f96bcae0fc7087a9: function(arg0) {
+        __wbg_closePath_ab8775c8f9ce941f: function(arg0) {
             getObject(arg0).closePath();
         },
-        __wbg_fillRect_4e5596ca954226e7: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_construct_391d7e1e0b4dda3a: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.construct(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_fillRect_4f7134801b257e68: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).fillRect(arg1, arg2, arg3, arg4);
         },
-        __wbg_fillText_b1722b6179692b85: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        __wbg_fillText_b32475d6cb52486d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).fillText(getStringFromWasm0(arg1, arg2), arg3, arg4);
         }, arguments); },
-        __wbg_fill_e228aca002a2bbf7: function(arg0, arg1) {
+        __wbg_fill_b52c5e04a3f6413e: function(arg0, arg1) {
             getObject(arg0).fill(__wbindgen_enum_CanvasWindingRule[arg1]);
         },
-        __wbg_getContext_f04bf8f22dcb2d53: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_getContext_e1463ff7aa682d57: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         }, arguments); },
         __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
-        __wbg_instanceof_CanvasRenderingContext2d_08b9d193c22fa886: function(arg0) {
+        __wbg_instanceof_CanvasRenderingContext2d_d4be74cff7165c1e: function(arg0) {
             let result;
             try {
                 result = getObject(arg0) instanceof CanvasRenderingContext2D;
@@ -1627,94 +1979,105 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_lineTo_8ea7db5b5d763030: function(arg0, arg1, arg2) {
+        __wbg_lineTo_72d6b123d28ab168: function(arg0, arg1, arg2) {
             getObject(arg0).lineTo(arg1, arg2);
         },
-        __wbg_log_524eedafa26daa59: function(arg0) {
+        __wbg_log_eb752234eec406d1: function(arg0) {
             console.log(getObject(arg0));
         },
-        __wbg_moveTo_6d04ca2f71946754: function(arg0, arg1, arg2) {
+        __wbg_moveTo_11bf5a977e6b8610: function(arg0, arg1, arg2) {
             getObject(arg0).moveTo(arg1, arg2);
         },
-        __wbg_new_a70fbab9066b301f: function() {
+        __wbg_new_1f236d63ba0c4784: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_310879b66b6e95e1: function() {
             const ret = new Array();
             return addHeapObject(ret);
         },
-        __wbg_new_with_u8_clamped_array_and_sh_5d9be5b17e50951c: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        __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_push_e87b0e732085a946: function(arg0, arg1) {
+        __wbg_push_b77c476b01548d0a: function(arg0, arg1) {
             const ret = getObject(arg0).push(getObject(arg1));
             return ret;
         },
-        __wbg_putImageData_1750176f4dd07174: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        __wbg_putImageData_947c369295a5768a: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
         }, arguments); },
-        __wbg_quadraticCurveTo_79b47836efb75da7: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_quadraticCurveTo_5f5e011124b8f464: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).quadraticCurveTo(arg1, arg2, arg3, arg4);
         },
-        __wbg_resetTransform_3e32a3e235bd6a64: function() { return handleError(function (arg0) {
+        __wbg_resetTransform_6f10bc77e166b888: function() { return handleError(function (arg0) {
             getObject(arg0).resetTransform();
         }, arguments); },
-        __wbg_restore_ec1ece47cce5dc64: function(arg0) {
+        __wbg_restore_6a7dd2b862e161a3: function(arg0) {
             getObject(arg0).restore();
         },
-        __wbg_save_c4e64a4ec29f000f: function(arg0) {
+        __wbg_save_14924e966ab6b8b7: function(arg0) {
             getObject(arg0).save();
         },
-        __wbg_setLineDash_b22b8de6051bb23a: function() { return handleError(function (arg0, arg1) {
+        __wbg_setLineDash_52c39bb093201720: function() { return handleError(function (arg0, arg1) {
             getObject(arg0).setLineDash(getObject(arg1));
         }, arguments); },
-        __wbg_set_fillStyle_58417b6b548ae475: function(arg0, arg1, arg2) {
+        __wbg_set_a0e911be3da02782: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_fillStyle_ac68c79af375566e: function(arg0, arg1, arg2) {
             getObject(arg0).fillStyle = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_font_b038797b3573ae5e: function(arg0, arg1, arg2) {
+        __wbg_set_font_7d34a66f4488295e: function(arg0, arg1, arg2) {
             getObject(arg0).font = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_globalAlpha_d51aa11e10f40cfc: function(arg0, arg1) {
+        __wbg_set_globalAlpha_b733b0d48d14b1c0: function(arg0, arg1) {
             getObject(arg0).globalAlpha = arg1;
         },
-        __wbg_set_globalCompositeOperation_ba0da38482e6aa11: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_set_globalCompositeOperation_884b1f7507e6f565: function() { return handleError(function (arg0, arg1, arg2) {
             getObject(arg0).globalCompositeOperation = getStringFromWasm0(arg1, arg2);
         }, arguments); },
-        __wbg_set_height_b6548a01bdcb689a: function(arg0, arg1) {
+        __wbg_set_height_bdd58e6b04e88cca: function(arg0, arg1) {
             getObject(arg0).height = arg1 >>> 0;
         },
-        __wbg_set_lineCap_1ecf6c7ca9319eb2: function(arg0, arg1, arg2) {
+        __wbg_set_lineCap_59e3edc93d8a32b9: function(arg0, arg1, arg2) {
             getObject(arg0).lineCap = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_lineDashOffset_3dc747fbfd1e7a15: function(arg0, arg1) {
+        __wbg_set_lineDashOffset_6ac8e5b15c55d7f9: function(arg0, arg1) {
             getObject(arg0).lineDashOffset = arg1;
         },
-        __wbg_set_lineJoin_2c56d0d6bec26d27: function(arg0, arg1, arg2) {
+        __wbg_set_lineJoin_a3878786eac23080: function(arg0, arg1, arg2) {
             getObject(arg0).lineJoin = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_lineWidth_e38550ed429ec417: function(arg0, arg1) {
+        __wbg_set_lineWidth_e101692cb4fcf2b8: function(arg0, arg1) {
             getObject(arg0).lineWidth = arg1;
         },
-        __wbg_set_miterLimit_59600cb9df94059b: function(arg0, arg1) {
+        __wbg_set_miterLimit_75d5333780d1658c: function(arg0, arg1) {
             getObject(arg0).miterLimit = arg1;
         },
-        __wbg_set_strokeStyle_a5baa9565d8b6485: function(arg0, arg1, arg2) {
+        __wbg_set_name_e500733c75ec36b0: function(arg0, arg1, arg2) {
+            getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_strokeStyle_c6ed1f71bc678b73: function(arg0, arg1, arg2) {
             getObject(arg0).strokeStyle = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_width_c0fcaa2da53cd540: function(arg0, arg1) {
+        __wbg_set_width_25112eb6bf1148df: function(arg0, arg1) {
             getObject(arg0).width = arg1 >>> 0;
         },
-        __wbg_strokeRect_2e20ce9870736fad: function(arg0, arg1, arg2, arg3, arg4) {
+        __wbg_strokeRect_3430a0df4158ba67: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).strokeRect(arg1, arg2, arg3, arg4);
         },
-        __wbg_strokeText_9f0af270c9810166: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        __wbg_strokeText_2ada42e0f9d6c857: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).strokeText(getStringFromWasm0(arg1, arg2), arg3, arg4);
         }, arguments); },
-        __wbg_stroke_affa71c0888c6f31: function(arg0) {
+        __wbg_stroke_82139a335b371e81: function(arg0) {
             getObject(arg0).stroke();
         },
-        __wbg_transform_d9d216c58f699bf9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+        __wbg_transform_9f749facb9d7d892: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             getObject(arg0).transform(arg1, arg2, arg3, arg4, arg5, arg6);
         }, arguments); },
-        __wbg_warn_69424c2d92a2fa73: function(arg0) {
+        __wbg_warn_c4e0780980765a86: function(arg0) {
             console.warn(getObject(arg0));
         },
         __wbindgen_cast_0000000000000001: function(arg0) {
@@ -1740,16 +2103,16 @@ 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 >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_licensestatus_free(ptr, 1));
 const PdfDocFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pdfdoc_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_pdfdoc_free(ptr, 1));
 const PdfDocMutFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pdfdocmut_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_pdfdocmut_free(ptr, 1));
 const XfaEngineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_xfaengine_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_xfaengine_free(ptr, 1));
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -1856,8 +2219,7 @@ function getDataViewMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint32ArrayMemory0 = null;
@@ -1991,8 +2353,9 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-let wasmModule, wasm;
+let wasmModule, wasmInstance, wasm;
 function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;