@einfach-excel/excel-wasm 0.0.0-stage → 0.2.0

package/full/einfach_wasm.js

@@ -0,0 +1,3698 @@
+/* @ts-self-types="./einfach_wasm.d.ts" */
+
+/**
+ * WASM-exposed spreadsheet. Wraps the Rust Sheet.
+ */
+export class WasmSheet {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSheetFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsheet_free(ptr, 0);
+    }
+    /**
+     * Debug-only panic injection — arms a one-shot flag so the next
+     * JsCallbackListener fire panics inside its microtask. After consumption
+     * the flag clears, so subsequent fires behave normally. Used by
+     * `regression.spec.ts` (Discovered #E.2) to verify console_error_panic_hook
+     * surfaces the panic to console.error AND the wasm instance keeps
+     * working for subsequent set_/get_ calls. Not part of the production
+     * API surface — naming with `__` prefix to flag.
+     */
+    __debugPanicNextCallback() {
+        wasm.wasmsheet___debugPanicNextCallback(this.__wbg_ptr);
+    }
+    /**
+     * Set multiple cells at once (batch). Pass arrays of addresses and values.
+     * @param {string[]} addrs
+     * @param {Float64Array} values
+     */
+    batch_set_numbers(addrs, values) {
+        const ptr0 = passArrayJsValueToWasm0(addrs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(values, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_batch_set_numbers(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Clear a cell to empty. Mirrors ISheet.clear_cell on the JS side.
+     * @param {string} addr
+     */
+    clear_cell(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_clear_cell(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Clear non-empty cells in a zero-based inclusive range. The core scans
+     * sparse entries only and coalesces dirty/subscriber propagation.
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {number}
+     */
+    clear_range(start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmsheet_clear_range(this.__wbg_ptr, start_row, start_col, end_row, end_col);
+        return ret >>> 0;
+    }
+    /**
+     * Number of formula records currently in the `Dirty` cache state.
+     * @returns {number}
+     */
+    debug_dirty_count() {
+        const ret = wasm.wasmsheet_debug_dirty_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total formula evaluations performed since this sheet was created.
+     * @returns {number}
+     */
+    debug_formula_eval_count() {
+        const ret = wasm.wasmsheet_debug_formula_eval_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of formulas registered via `bulk_load` (cumulative).
+     * @returns {number}
+     */
+    debug_imported_formula_count() {
+        const ret = wasm.wasmsheet_debug_imported_formula_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of `CellAddress`es with at least one live listener.
+     * @returns {number}
+     */
+    debug_live_subscription_count() {
+        const ret = wasm.wasmsheet_debug_live_subscription_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of materialized Store geometry roots used by large range
+     * formulas. Small ranges depend on member facades and contribute zero.
+     * @returns {number}
+     */
+    debug_range_dep_count() {
+        const ret = wasm.wasmsheet_debug_range_dep_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} at
+     * @param {number} count
+     */
+    delete_col(at, count) {
+        wasm.wasmsheet_delete_col(this.__wbg_ptr, at, count);
+    }
+    /**
+     * @param {number} at
+     * @param {number} count
+     */
+    delete_row(at, count) {
+        wasm.wasmsheet_delete_row(this.__wbg_ptr, at, count);
+    }
+    /**
+     * Format a cell's value using its effective format. Numeric cells go
+     * through `CellFormat::format_number`; non-numeric cells fall back to
+     * the default display path.
+     *
+     * The error case is intercepted here rather than delegated.
+     * `Sheet::formatted_display` re-implements the display match instead of
+     * calling `value_to_display`, so it renders `Value::Error` through the
+     * engine-internal `Display` and would leak `#TYPE!` / `#ARGS!` — codes
+     * Excel does not have — into this legacy shell's cell text. A number
+     * format can never apply to an error, so short-circuiting the error arm is
+     * behaviour-identical apart from the token map. This is a bridge, not
+     * the fix: the durable one is for `Sheet::formatted_display` to route
+     * its `Value::Error` arm through `error_display_token` too, at which
+     * point this arm becomes redundant (and harmless).
+     * @param {string} addr
+     * @returns {string}
+     */
+    formatted_display(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmsheet_formatted_display(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Get a cell's display value as a string.
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_display(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmsheet_get_display(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Read the effective format for a cell (base + first matching
+     * conditional rule override).
+     * @param {string} addr
+     * @returns {any}
+     */
+    get_effective_format(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_get_effective_format(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Read the base format for a cell (no conditional rules applied).
+     * @param {string} addr
+     * @returns {any}
+     */
+    get_format(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_get_format(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Return a cell's original formula text, or empty string for cells
+     * without a formula. Used by the formula bar / double-click edit so
+     * users edit `=A1*2` instead of the displayed result `20` (D.11).
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_formula(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmsheet_get_formula(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Get a cell's raw numeric value. Returns NaN if not a number.
+     * @param {string} addr
+     * @returns {number}
+     */
+    get_number(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_get_number(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Get the type of a cell's value: "number", "text", "boolean", "null", "error"
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_type(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmsheet_get_type(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} at
+     * @param {number} count
+     */
+    insert_col(at, count) {
+        wasm.wasmsheet_insert_col(this.__wbg_ptr, at, count);
+    }
+    /**
+     * @param {number} at
+     * @param {number} count
+     */
+    insert_row(at, count) {
+        wasm.wasmsheet_insert_row(this.__wbg_ptr, at, count);
+    }
+    /**
+     * Check if a cell contains an error.
+     * @param {string} addr
+     * @returns {boolean}
+     */
+    is_error(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_is_error(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Create a new empty spreadsheet.
+     */
+    constructor() {
+        const ret = wasm.wasmsheet_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmSheetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Every non-empty address on this sheet, as `"A1"`-style strings.
+     * Empty cells are skipped; an address holding both a primitive slot
+     * and a formula appears once (formula dominates). Used by
+     * structural-undo to snapshot only what needs restoring — see
+     * `excel/solid-excel/docs/STRUCTURAL_UNDO.md`.
+     * @returns {string[]}
+     */
+    non_empty_addrs() {
+        const ret = wasm.wasmsheet_non_empty_addrs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * 按属性写入 cellStyle / rowStyle / columnStyle。
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} patch
+     * @param {string} scope
+     * @returns {number}
+     */
+    patch_format_range(start_row, start_col, end_row, end_col, patch, scope) {
+        const ptr0 = passStringToWasm0(scope, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_patch_format_range(this.__wbg_ptr, start_row, start_col, end_row, end_col, patch, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Restore metadata produced by `snapshot_format_range`.
+     * @param {any} snapshot
+     * @returns {number}
+     */
+    restore_format_snapshot(snapshot) {
+        const ret = wasm.wasmsheet_restore_format_snapshot(this.__wbg_ptr, snapshot);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Set a cell to a boolean value.
+     * @param {string} addr
+     * @param {boolean} value
+     */
+    set_boolean(addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_set_boolean(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Set a cell to an error value by its display code. Unknown codes fall
+     * back to #VALUE!, matching the generic invalid-value error.
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_error(addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_set_error(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * @param {string} addr
+     * @param {any} fmt
+     */
+    set_format(addr, fmt) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_set_format(this.__wbg_ptr, ptr0, len0, fmt);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * 兼容旧调用：把完整格式逐格写进 cellStyle。
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} fmt
+     * @returns {number}
+     */
+    set_format_range(start_row, start_col, end_row, end_col, fmt) {
+        const ret = wasm.wasmsheet_set_format_range(this.__wbg_ptr, start_row, start_col, end_row, end_col, fmt);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Set a cell's formula (e.g. "=A1+B1").
+     * Returns `true` if the formula parsed successfully, `false` if it was
+     * invalid (cell becomes `#VALUE!`) or would form a cycle (cell becomes `#CYCLE!`).
+     * @param {string} addr
+     * @param {string} formula
+     * @returns {boolean}
+     */
+    set_formula(addr, formula) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(formula, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_set_formula(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * Set a cell to a numeric value. Subscribers fire automatically via the
+     * store's propagation pass — no manual fire_listeners needed (C.1+C.2).
+     * @param {string} addr
+     * @param {number} value
+     */
+    set_number(addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_set_number(this.__wbg_ptr, ptr0, len0, value);
+    }
+    /**
+     * Set a cell to a text value.
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_text(addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmsheet_set_text(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Snapshot sparse formatting metadata for undoing a later range-format
+     * edit. Does not read cell values or materialize empty cells.
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    snapshot_format_range(start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmsheet_snapshot_format_range(this.__wbg_ptr, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * If `addr` is a dynamic-array spill *anchor*, return the spill
+     * shape as a `[rows, cols]` `Uint32Array`. Returns `undefined` /
+     * `null` (`JsValue::null`) for plain cells, spilled-into cells,
+     * and `#SPILL!` anchors. The JS UI uses this to render the spill
+     * border around the anchor's bounding rectangle.
+     * @param {string} addr
+     * @returns {any}
+     */
+    spillInfo(addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_spillInfo(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Subscribe to changes on a cell. Returns an opaque u32 token to pass
+     * to `unsubscribe`. The callback fires whenever the cell's value
+     * changes — including transitively through formula dependencies (C.2).
+     * @param {string} addr
+     * @param {Function} callback
+     * @returns {number}
+     */
+    subscribe(addr, callback) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsheet_subscribe(this.__wbg_ptr, ptr0, len0, callback);
+        return ret >>> 0;
+    }
+    /**
+     * Cancel a subscription previously returned from `subscribe`.
+     * Idempotent: unknown tokens are ignored.
+     * @param {number} token
+     */
+    unsubscribe(token) {
+        wasm.wasmsheet_unsubscribe(this.__wbg_ptr, token);
+    }
+}
+if (Symbol.dispose) WasmSheet.prototype[Symbol.dispose] = WasmSheet.prototype.free;
+
+/**
+ * WASM-exposed workbook. Wraps the Rust Workbook so browser demos can
+ * evaluate formulas through workbook context, including cross-sheet refs.
+ */
+export class WasmWorkbook {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWorkbookFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmworkbook_free(ptr, 0);
+    }
+    /**
+     * @param {string} name
+     * @returns {number}
+     */
+    add_sheet(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_add_sheet(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * @param {any} targets
+     * @returns {any}
+     */
+    aggregate_selection(targets) {
+        const ret = wasm.wasmworkbook_aggregate_selection(this.__wbg_ptr, targets);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Apply `{ rules: ColumnFilterRule[] }` to `sheetIdx`: run the
+     * predicate ONCE and commit both the rules and the rows they hid.
+     *
+     * Returns `{ ok: true, hiddenRows, scannedRows, predicateCells }`, or
+     * `{ ok: false, code, message? }`. `code: "source-too-large"` is the
+     * engine-side twin of the adapter's `FILTER_SORT_SOURCE_TOO_LARGE` —
+     * the filter does NOT activate and nothing is truncated.
+     *
+     * Visibility is a SNAPSHOT taken here. Later cell edits do not move
+     * it; `reapplyFilter` is the refresh path.
+     * @param {number} sheet_idx
+     * @param {any} payload
+     * @returns {any}
+     */
+    applyFilter(sheet_idx, payload) {
+        const ret = wasm.wasmworkbook_applyFilter(this.__wbg_ptr, sheet_idx, payload);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Preflight and apply one native drag-fill atomically. The payload uses
+     * zero-based inclusive ranges. `infer` derives parameters from native
+     * samples; otherwise explicit detector witnesses remain strictly validated.
+     * @param {any} payload
+     * @returns {any}
+     */
+    apply_auto_fill(payload) {
+        const ret = wasm.wasmworkbook_apply_auto_fill(this.__wbg_ptr, payload);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 浏览器只提供一次文字测量回调；Rust 遍历稀疏数据并在测量全部成功后写尺寸。
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string} axis
+     * @param {number} default_row
+     * @param {number} default_col
+     * @param {Function} measure
+     * @returns {boolean}
+     */
+    auto_fit_dimensions(sheet, start_row, start_col, end_row, end_col, axis, default_row, default_col, measure) {
+        const ptr0 = passStringToWasm0(axis, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_auto_fit_dimensions(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col, ptr0, len0, default_row, default_col, measure);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {any} cells
+     * @returns {any}
+     */
+    bulkImportCellsInstrumented(cells) {
+        const ret = wasm.wasmworkbook_bulkImportCellsInstrumented(this.__wbg_ptr, cells);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} cells
+     * @returns {any}
+     */
+    bulk_import_cells(cells) {
+        const ret = wasm.wasmworkbook_bulk_import_cells(this.__wbg_ptr, cells);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} payload
+     * @returns {any}
+     */
+    bulk_install_workbook(payload) {
+        const ret = wasm.wasmworkbook_bulk_install_workbook(this.__wbg_ptr, payload);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {boolean} cut
+     * @returns {any}
+     */
+    capture_clipboard(sheet_idx, start_row, start_col, end_row, end_col, cut) {
+        const ret = wasm.wasmworkbook_capture_clipboard(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, cut);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 格式刷使用独立快照槽；保持普通剪贴板既有导出签名。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    capture_format_painter(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_capture_format_painter(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @param {string} change_json
+     * @returns {boolean}
+     */
+    change_comment(sheet, row, col, change_json) {
+        const ptr0 = passStringToWasm0(change_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_change_comment(this.__wbg_ptr, sheet, row, col, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {string} action_json
+     * @returns {boolean}
+     */
+    change_custom_formula(sheet, action_json) {
+        const ptr0 = passStringToWasm0(action_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_change_custom_formula(this.__wbg_ptr, sheet, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * 一个原生命令完成显示文字/链接修改及单条撤销记录。
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @param {string | null} [url]
+     * @param {string | null} [text]
+     * @returns {boolean}
+     */
+    change_hyperlink(sheet, row, col, url, text) {
+        var ptr0 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_change_hyperlink(this.__wbg_ptr, sheet, row, col, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} action
+     * @returns {boolean}
+     */
+    change_named_range(sheet, action) {
+        const ret = wasm.wasmworkbook_change_named_range(this.__wbg_ptr, sheet, action);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @param {string | null} [text]
+     * @returns {boolean}
+     */
+    change_note(sheet, row, col, text) {
+        var ptr0 = isLikeNone(text) ? 0 : passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_change_note(this.__wbg_ptr, sheet, row, col, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {string} axis
+     * @param {any} action
+     * @returns {boolean}
+     */
+    change_outline(sheet, axis, action) {
+        const ptr0 = passStringToWasm0(axis, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_change_outline(this.__wbg_ptr, sheet, ptr0, len0, action);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} change
+     * @returns {boolean}
+     */
+    change_protection(sheet, change) {
+        const ret = wasm.wasmworkbook_change_protection(this.__wbg_ptr, sheet, change);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} action
+     * @returns {boolean}
+     */
+    change_table(sheet, action) {
+        const ret = wasm.wasmworkbook_change_table(this.__wbg_ptr, sheet, action);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Clear a cell through the workbook. Local and cross-sheet formulas that
+     * read the cell re-derive through the shared Store graph.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     */
+    clearCellAt(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_clearCellAt(this.__wbg_ptr, sheet_idx, ptr0, len0);
+    }
+    /**
+     * Drop `sheetIdx`'s filter — rules and derived rows both. Scan-free.
+     * @param {number} sheet_idx
+     * @returns {any}
+     */
+    clearFilter(sheet_idx) {
+        const ret = wasm.wasmworkbook_clearFilter(this.__wbg_ptr, sheet_idx);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     */
+    clear_cell(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_clear_cell(this.__wbg_ptr, sheet_idx, ptr0, len0);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {number}
+     */
+    clear_range(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_clear_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        return ret >>> 0;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    clear_selection(request) {
+        const ret = wasm.wasmworkbook_clear_selection(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Define a Table over `[start..=end]` on `sheet_idx`. `name` is
+     * `Some` to use an explicit (validated) name, or `None`/`undefined`
+     * to auto-generate `Table1`, `Table2`, …. Returns the final
+     * (canonical-cased) Table name.
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string | null} [name]
+     * @returns {string}
+     */
+    createTable(sheet_idx, start_row, start_col, end_row, end_col, name) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_createTable(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Number of currently-registered custom formulas. Debug probe so
+     * JS tests can assert their register / unregister calls landed.
+     * @returns {number}
+     */
+    customFormulaCount() {
+        const ret = wasm.wasmworkbook_customFormulaCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * List of registered custom-formula names (upper-cased). Stable
+     * alphabetical ordering not guaranteed — `HashMap::keys()` order.
+     * Used by hosts that want to render a "registered formulas"
+     * inspector. Returns a `JsValue::Array<String>`.
+     * @returns {any}
+     */
+    customFormulaNames() {
+        const ret = wasm.wasmworkbook_customFormulaNames(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Atom-delegation diagnostics aggregated across every sheet. This is a
+     * measurement-only debug surface; hydrated formula/static-range metadata
+     * is O(formula_count), while the legacy point-fanout fields stay zero.
+     *
+     * Returns a JS object with these fields (camelCase):
+     * - `totalFormulaCount` — sum of `formula_cells.len()` over sheets
+     * - `totalPointDepEdges` — always zero; Store owns point dependencies
+     * - `totalRangeDepEntries` — materialized Store geometry roots
+     * - `maxFanout` / `avgFanout` — always zero; no address fanout index
+     * - `rangeFormulaCount` — hydrated formulas with static range metadata
+     * @returns {any}
+     */
+    debugDepGraphStats() {
+        const ret = wasm.wasmworkbook_debugDepGraphStats(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    debugLastBulkImportPhaseMs() {
+        const ret = wasm.wasmworkbook_debugLastBulkImportPhaseMs(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Number of cross-sheet dependent edges currently tracked on the
+     * workbook. Track L's e2e gates fan-out correctness through this
+     * probe.
+     *
+     * Delegates to `Workbook::debug_cross_sheet_reverse_edge_count` —
+     * counts entries in the workbook's cross-sheet reverse dep index.
+     * @returns {number}
+     */
+    debug_cross_sheet_dependents_count() {
+        const ret = wasm.wasmworkbook_debug_cross_sheet_dependents_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {string}
+     */
+    debug_formula_cache_state(sheet_idx, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_debug_formula_cache_state(this.__wbg_ptr, sheet_idx, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Total formula records currently registered across all workbook sheets.
+     * This is a read-only aggregate, not a cell visit across sparse content.
+     * @returns {number}
+     */
+    debug_formula_count() {
+        const ret = wasm.wasmworkbook_debug_formula_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total formula evaluations performed on one workbook sheet since
+     * creation. Used by worker-backed lazy import/read tests.
+     * @param {number} sheet_idx
+     * @returns {number}
+     */
+    debug_formula_eval_count(sheet_idx) {
+        const ret = wasm.wasmworkbook_debug_formula_eval_count(this.__wbg_ptr, sheet_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Total formula evaluations performed across all workbook sheets since
+     * creation. Uses each sheet's `debug_formula_eval_count` without
+     * evaluating any formulas.
+     * @returns {number}
+     */
+    debug_formula_eval_count_total() {
+        const ret = wasm.wasmworkbook_debug_formula_eval_count_total(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of live workbook subscription tokens currently held
+     * in the workbook bookkeeping map.
+     * @returns {number}
+     */
+    debug_live_subscription_count() {
+        const ret = wasm.wasmworkbook_debug_live_subscription_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of formula records currently registered on one workbook sheet.
+     * Returns `0` for missing sheet indexes.
+     * @param {number} sheet_idx
+     * @returns {number}
+     */
+    debug_sheet_formula_count(sheet_idx) {
+        const ret = wasm.wasmworkbook_debug_sheet_formula_count(this.__wbg_ptr, sheet_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Number of live `Sheet` listeners for a specific sheet. This
+     * includes only currently subscribed addresses and maps to the same
+     * contract as `Sheet::debug_live_subscription_count`.
+     * @param {number} sheet_idx
+     * @returns {number}
+     */
+    debug_sheet_live_subscription_count(sheet_idx) {
+        const ret = wasm.wasmworkbook_debug_sheet_live_subscription_count(this.__wbg_ptr, sheet_idx);
+        return ret >>> 0;
+    }
+    /**
+     * @param {string} name
+     * @param {string} formula
+     */
+    defineName(name, formula) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(formula, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_defineName(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Enumerate the workbook's defined names in canonical (user-typed)
+     * casing, sorted alphabetically by uppercased key. Useful for the
+     * W2 name-manager dialog so it doesn't need to subscribe to every
+     * `defineName` call individually.
+     * @returns {string[]}
+     */
+    definedNames() {
+        const ret = wasm.wasmworkbook_definedNames(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * 仅删除低层 Table 注册项；不改写引用公式，不等同于用户的“转换为区域”。
+     * @param {string} name
+     */
+    deleteTable(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_deleteTable(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} at
+     * @param {number} count
+     */
+    delete_col(sheet_idx, at, count) {
+        wasm.wasmworkbook_delete_col(this.__wbg_ptr, sheet_idx, at, count);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} at
+     * @param {number} count
+     */
+    delete_row(sheet_idx, at, count) {
+        wasm.wasmworkbook_delete_row(this.__wbg_ptr, sheet_idx, at, count);
+    }
+    /**
+     * Drain the async custom-formula request queue accumulated since the
+     * last drain. Returns `Array<{ callId: number, name: string,
+     * args: Array<number|string|boolean|null|any[][]> }>` — args marshal
+     * with the same rules as sync callback invocation (ranges arrive as
+     * 2-D row-major arrays). call_id is a u64 exposed as f64: safe below
+     * 2^53 calls. Call after any mutation entry point; empty queue
+     * returns an empty array at negligible cost.
+     * @returns {any}
+     */
+    drainAsyncCustomRequests() {
+        const ret = wasm.wasmworkbook_drainAsyncCustomRequests(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Checked user command; the optional index distinguishes rename from add.
+     * @param {number | null | undefined} index
+     * @param {string} name
+     * @returns {number}
+     */
+    edit_sheet(index, name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_edit_sheet(this.__wbg_ptr, isLikeNone(index) ? 0x100000001 : (index) >>> 0, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * 每次插删只产生一条历史；拒绝时数据、历史游标、剪贴板保持不变。
+     * @param {number} sheet
+     * @param {string} action
+     * @param {number} at
+     * @param {number} count
+     * @returns {boolean}
+     */
+    edit_structure(sheet, action, at, count) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_edit_structure(this.__wbg_ptr, sheet, ptr0, len0, at, count);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    filter_values(request) {
+        const ret = wasm.wasmworkbook_filter_values(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    find_cells(request) {
+        const ret = wasm.wasmworkbook_find_cells(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 双击填充只返回原生判定的末行，不把相邻列值传给 JS 再扫描。
+     * @param {number} sheet
+     * @param {any} source
+     * @param {number} row_limit
+     * @returns {number | undefined}
+     */
+    find_fill_down_end(sheet, source, row_limit) {
+        const ret = wasm.wasmworkbook_find_fill_down_end(this.__wbg_ptr, sheet, source, row_limit);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0x100000001 ? undefined : ret[0];
+    }
+    /**
+     * 成功才提升临时快照；失败立即释放，不复制工作簿或新增历史。
+     * @param {boolean} commit
+     */
+    finish_clipboard_capture(commit) {
+        wasm.wasmworkbook_finish_clipboard_capture(this.__wbg_ptr, commit);
+    }
+    /**
+     * 固定两个整数：[冻结行数, 冻结列数]，零表示该轴不冻结。
+     * @param {number} sheet
+     * @returns {Uint32Array}
+     */
+    frozen_panes(sheet) {
+        const ret = wasm.wasmworkbook_frozen_panes(this.__wbg_ptr, sheet);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Read a cell's display string through the workbook eval path.
+     * Convenience wrapper around `get_display(u32, ...)` with `usize`
+     * for the Phase 3 canonical API shape. The `&mut self` receiver
+     * future-proofs against `Workbook::get_cell` requiring a mutable
+     * borrow once cache promotion lands on the workbook eval provider —
+     * today it is read-only, but flipping the underlying signature
+     * must not break the JS API.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {string}
+     */
+    getCellDisplay(sheet_idx, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_getCellDisplay(this.__wbg_ptr, sheet_idx, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {any}
+     */
+    getDataValidation(sheet, row, col) {
+        const ret = wasm.wasmworkbook_getDataValidation(this.__wbg_ptr, sheet, row, col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Read `sheetIdx`'s committed filter as
+     * `{ rules: ColumnFilterRule[], hiddenRows: number[] }`.
+     *
+     * A WHOLE-SHEET read, deliberately not window-bounded: a host has to
+     * know about hidden rows OUTSIDE the visible window to expand that
+     * window correctly, so answering with a windowed subset would be
+     * circular. Called on sheet activation and after a restore — never per
+     * frame, per scroll, or per revision.
+     * @param {number} sheet_idx
+     * @returns {any}
+     */
+    getFilter(sheet_idx) {
+        const ret = wasm.wasmworkbook_getFilter(this.__wbg_ptr, sheet_idx);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    getLastValidationFailure() {
+        const ret = wasm.wasmworkbook_getLastValidationFailure(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet
+     * @returns {any}
+     */
+    getPrintConfig(sheet) {
+        const ret = wasm.wasmworkbook_getPrintConfig(this.__wbg_ptr, sheet);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * One Table as `TableJSON`, or `null` when no Table is registered under
+     * `name` (case-insensitive).
+     * @param {string} name
+     * @returns {any}
+     */
+    getTable(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_getTable(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_display(sheet_idx, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_get_display(this.__wbg_ptr, sheet_idx, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_formula(sheet_idx, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_get_formula(this.__wbg_ptr, sheet_idx, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {number}
+     */
+    get_number(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_get_number(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {string}
+     */
+    get_type(sheet_idx, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_get_type(this.__wbg_ptr, sheet_idx, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Mark `rows` (0-based) manually hidden on `sheetIdx`, additively.
+     * Returns whether anything changed. Out-of-range `sheetIdx` and rows
+     * that were already hidden are silent `false`s; never throws.
+     * @param {number} sheet_idx
+     * @param {Uint32Array} rows
+     * @returns {boolean}
+     */
+    hideRows(sheet_idx, rows) {
+        const ptr0 = passArray32ToWasm0(rows, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_hideRows(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {string} direction
+     * @returns {boolean}
+     */
+    history_apply(direction) {
+        const ptr0 = passStringToWasm0(direction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_history_apply(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string} label
+     * @param {boolean} content
+     */
+    history_begin(sheet, start_row, start_col, end_row, end_col, label, content) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_history_begin(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col, ptr0, len0, content);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} notice
+     */
+    history_clear(notice) {
+        const ptr0 = passStringToWasm0(notice, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_history_clear(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} success
+     */
+    history_finish(success) {
+        const ret = wasm.wasmworkbook_history_finish(this.__wbg_ptr, success);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    history_state() {
+        const ret = wasm.wasmworkbook_history_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    host_mutation_state() {
+        const ret = wasm.wasmworkbook_host_mutation_state(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} targets
+     * @returns {any}
+     */
+    host_read_ranges(targets) {
+        const ret = wasm.wasmworkbook_host_read_ranges(this.__wbg_ptr, targets);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} cells
+     * @returns {boolean}
+     */
+    host_write_cells(cells) {
+        const ret = wasm.wasmworkbook_host_write_cells(this.__wbg_ptr, cells);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} at
+     * @param {number} count
+     */
+    insert_col(sheet_idx, at, count) {
+        wasm.wasmworkbook_insert_col(this.__wbg_ptr, sheet_idx, at, count);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} at
+     * @param {number} count
+     */
+    insert_row(sheet_idx, at, count) {
+        wasm.wasmworkbook_insert_row(this.__wbg_ptr, sheet_idx, at, count);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {boolean}
+     */
+    is_error(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_is_error(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @returns {any}
+     */
+    listConditionalFormats(sheet) {
+        const ret = wasm.wasmworkbook_listConditionalFormats(this.__wbg_ptr, sheet);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The manually hidden rows on `sheetIdx` as a `number[]`, ascending.
+     * Empty for an out-of-range sheet.
+     * @param {number} sheet_idx
+     * @returns {Uint32Array}
+     */
+    listHiddenRows(sheet_idx) {
+        const ret = wasm.wasmworkbook_listHiddenRows(this.__wbg_ptr, sheet_idx);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Every registered Table as `TableJSON[]`, alphabetical by uppercased
+     * name (the engine's stable order).
+     * @returns {any}
+     */
+    listTables() {
+        const ret = wasm.wasmworkbook_listTables(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    list_named_ranges() {
+        const ret = wasm.wasmworkbook_list_named_ranges(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * List every address that has a primitive value or formula across
+     * the workbook. This is metadata-only and does not evaluate formulas.
+     * @returns {any}
+     */
+    list_non_empty_cells() {
+        const ret = wasm.wasmworkbook_list_non_empty_cells(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    locate_cells(request) {
+        const ret = wasm.wasmworkbook_locate_cells(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 复制、启停与重排都由原生目录一次修改，一次进入历史。
+     * @param {number} sheet
+     * @param {any} request
+     * @returns {any}
+     */
+    manageConditionalFormatRule(sheet, request) {
+        const ret = wasm.wasmworkbook_manageConditionalFormatRule(this.__wbg_ptr, sheet, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string} action
+     * @param {boolean} discard
+     * @returns {boolean}
+     */
+    merge_cells(sheet, start_row, start_col, end_row, end_col, action, discard) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_merge_cells(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col, ptr0, len0, discard);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * 全表稀疏合并矩形，按 [起始行, 起始列, 结束行, 结束列] 连续编码。
+     * 不裁成视口内的小矩形；键盘导航与屏幕外锚点仍使用真实边界。
+     * @param {number} sheet
+     * @returns {Uint32Array}
+     */
+    merged_ranges(sheet) {
+        const ret = wasm.wasmworkbook_merged_ranges(this.__wbg_ptr, sheet);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {number} from
+     * @param {number} to
+     * @returns {boolean}
+     */
+    move_sheet(from, to) {
+        const ret = wasm.wasmworkbook_move_sheet(this.__wbg_ptr, from, to);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.wasmworkbook_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmWorkbookFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * 内部快照或外部 TSV 二选一。剪切只有成功落地后才消费快照。
+     * @param {number} sheet_idx
+     * @param {number} row
+     * @param {number} col
+     * @param {string} text
+     * @param {boolean} internal
+     * @param {any} policy
+     * @returns {Uint32Array}
+     */
+    paste_clipboard(sheet_idx, row, col, text, internal, policy) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_paste_clipboard(this.__wbg_ptr, sheet_idx, row, col, ptr0, len0, internal, policy);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * 按属性写入 cellStyle / rowStyle / columnStyle。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} patch
+     * @param {string} scope
+     * @returns {number}
+     */
+    patch_format_range(sheet_idx, start_row, start_col, end_row, end_col, patch, scope) {
+        const ptr0 = passStringToWasm0(scope, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_patch_format_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, patch, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    patch_format_selection(request) {
+        const ret = wasm.wasmworkbook_patch_format_selection(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 范围位置在 Rust 内计算；调用方用既有格式事务保存一次撤销。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} input
+     * @returns {number}
+     */
+    patch_range_borders(sheet_idx, start_row, start_col, end_row, end_col, input) {
+        const ret = wasm.wasmworkbook_patch_range_borders(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, input);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * 浏览器剪贴板写入可能失败，先暂存，不改变正式快照。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {boolean} cut
+     * @returns {any}
+     */
+    prepare_clipboard(sheet_idx, start_row, start_col, end_row, end_col, cut) {
+        const ret = wasm.wasmworkbook_prepare_clipboard(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, cut);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {any} format
+     * @returns {string}
+     */
+    preview_number_format(sheet_idx, addr, format) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wasmworkbook_preview_number_format(this.__wbg_ptr, sheet_idx, ptr0, len0, format);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    preview_remove_duplicates(request) {
+        const ret = wasm.wasmworkbook_preview_remove_duplicates(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    preview_text_columns(request) {
+        const ret = wasm.wasmworkbook_preview_text_columns(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {string}
+     */
+    read_comment(sheet, row, col) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkbook_read_comment(this.__wbg_ptr, sheet, row, col);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    read_custom_formulas() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wasmworkbook_read_custom_formulas(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} row
+     * @param {number} col
+     * @returns {string | undefined}
+     */
+    read_note(sheet, row, col) {
+        const ret = wasm.wasmworkbook_read_note(this.__wbg_ptr, sheet, row, col);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {number} sheet
+     * @returns {any}
+     */
+    read_protection(sheet) {
+        const ret = wasm.wasmworkbook_read_protection(this.__wbg_ptr, sheet);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Read non-empty cells in a zero-based inclusive range. This is an
+     * explicit read/export path, so formula cells in the range may be
+     * evaluated and promoted to clean cache state.
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    read_sparse_range(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_read_sparse_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * `Data -> Reapply` (Excel `Ctrl+Alt+L`): re-run `sheetIdx`'s ALREADY
+     * COMMITTED rules against current cell values. Carries no rules of its
+     * own, so it can never change WHAT is filtered — only which rows
+     * currently satisfy it.
+     * @param {number} sheet_idx
+     * @returns {any}
+     */
+    reapplyFilter(sheet_idx) {
+        const ret = wasm.wasmworkbook_reapplyFilter(this.__wbg_ptr, sheet_idx);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number | null} [sheet]
+     * @returns {number}
+     */
+    recalculate(sheet) {
+        const ret = wasm.wasmworkbook_recalculate(this.__wbg_ptr, isLikeNone(sheet) ? 0x100000001 : (sheet) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {string} name
+     * @param {Function} callback
+     */
+    registerCustomFormula(name, callback) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_registerCustomFormula(this.__wbg_ptr, ptr0, len0, callback);
+    }
+    /**
+     * Register `name` as an ASYNC custom formula. Name-only: the JS
+     * callback stays in the worker's local map and never crosses into
+     * wasm. During evaluation the engine memoizes per (name, args),
+     * holds the cell at `#BUSY!`, and enqueues a pending request; the
+     * host drains with `drainAsyncCustomRequests`, awaits the callback,
+     * and settles with `resolveAsyncCustomCall`. Registering over an
+     * existing name (sync or async) replaces it and publishes the
+     * registry root like `registerCustomFormula`.
+     * @param {string} name
+     */
+    registerCustomFormulaAsync(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_registerCustomFormulaAsync(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} request
+     * @returns {any}
+     */
+    removeConditionalFormatRule(sheet, request) {
+        const ret = wasm.wasmworkbook_removeConditionalFormatRule(this.__wbg_ptr, sheet, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    remove_duplicates(request) {
+        const ret = wasm.wasmworkbook_remove_duplicates(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} idx
+     * @returns {boolean}
+     */
+    remove_sheet(idx) {
+        const ret = wasm.wasmworkbook_remove_sheet(this.__wbg_ptr, idx);
+        return ret !== 0;
+    }
+    /**
+     * Rename a Table, rewriting every referencing formula's text.
+     * @param {string} name
+     * @param {string} new_name
+     */
+    renameTable(name, new_name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(new_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_renameTable(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Rename one column of a Table, rewriting every referencing formula.
+     * @param {string} name
+     * @param {string} old_column
+     * @param {string} new_column
+     */
+    renameTableColumn(name, old_column, new_column) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(old_column, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(new_column, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_renameTableColumn(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} idx
+     * @param {string} name
+     * @returns {boolean}
+     */
+    rename_sheet(idx, name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_rename_sheet(this.__wbg_ptr, idx, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    replace_by_query(request) {
+        const ret = wasm.wasmworkbook_replace_by_query(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 一次命令修改选区涉及的行/列，尺寸不写入 cellStyle。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string} axis
+     * @param {number} pixels
+     */
+    resize_range(sheet_idx, start_row, start_col, end_row, end_col, axis, pixels) {
+        const ptr0 = passStringToWasm0(axis, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_resize_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, ptr0, len0, pixels);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Settle an async custom-formula call. `value` marshals with the
+     * same rules as a sync callback's return (`js_to_value`): scalars,
+     * error tokens / `{ error }` objects; `#BUSY!` demotes to `#VALUE!`.
+     * The worker maps callback throw/reject to `{ error: "#VALUE!" }`
+     * and calls this same entry — there is no separate reject API.
+     * Returns `false` when the call is unknown or stale (registry
+     * changed while the Promise was in flight); the value is dropped.
+     * Explicit `{ json: scalar_or_rectangular_array }` successes preserve
+     * JSON strings literally; existing `{ error }` objects take precedence.
+     * @param {number} call_id
+     * @param {any} value
+     * @returns {boolean}
+     */
+    resolveAsyncCustomCall(call_id, value) {
+        const ret = wasm.wasmworkbook_resolveAsyncCustomCall(this.__wbg_ptr, call_id, value);
+        return ret !== 0;
+    }
+    /**
+     * Replace every sheet's filter state with a `snapshotFilters` payload,
+     * returning how many sheets ended up with a filter. Restoring an empty
+     * `filters` array CLEARS everything — that is the point of REPLACE, not
+     * a no-op. Entries for sheets that no longer exist are dropped
+     * silently, and no predicate is re-run.
+     * @param {any} value
+     * @returns {number}
+     */
+    restoreFilters(value) {
+        const ret = wasm.wasmworkbook_restoreFilters(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Replace every sheet's manually hidden rows with a `snapshotHidden`
+     * payload, returning how many sheets ended up with at least one hidden
+     * row. Restoring an empty `hidden` array CLEARS everything — that is the
+     * point of REPLACE, not a no-op. Entries for sheets that no longer exist
+     * are dropped silently. A restore that reproduces the current state
+     * fires no epoch and costs no recompute.
+     * @param {any} value
+     * @returns {number}
+     */
+    restoreHidden(value) {
+        const ret = wasm.wasmworkbook_restoreHidden(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Replace the whole Table registry with a `snapshotTables` payload,
+     * returning the number of Tables now registered.
+     *
+     * **REPLACE, not additive** (unlike `restoreSparse`): Tables created
+     * after the snapshot are dropped and Tables deleted since are revived,
+     * which is what makes a Table-definition undo symmetric. Restoring an
+     * empty `tables` array therefore CLEARS the registry — it is not a
+     * no-op.
+     *
+     * All-or-nothing: the payload is fully validated (cap 256, name shape,
+     * the §4.2 name mutex against current defined names, same-sheet range
+     * overlap, column-count vs range width) before anything is swapped, so a
+     * rejection leaves the live registry untouched. Errors are the stable
+     * `table_error_to_js` strings plus `"unsupported-snapshot-version"` and
+     * parse messages for a malformed envelope. Only cell values/formulas are
+     * left alone — the registry is a view over them.
+     *
+     * A restore that changes the registry bumps the tables epoch, so
+     * `=SUM(Table1[Qty])` and friends re-derive against the restored
+     * geometry; a restore that reproduces the current registry exactly
+     * skips the bump.
+     * @param {any} value
+     * @returns {number}
+     */
+    restoreTables(value) {
+        const ret = wasm.wasmworkbook_restoreTables(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Restore a formatting snapshot produced by `snapshot_format_range`.
+     * @param {any} snapshot
+     * @returns {number}
+     */
+    restore_format_snapshot(snapshot) {
+        const ret = wasm.wasmworkbook_restore_format_snapshot(this.__wbg_ptr, snapshot);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Restore a persistence-v1 sparse envelope into this workbook.
+     *
+     * Returns simple restore stats for quick assertions.
+     * @param {any} value
+     * @returns {any}
+     */
+    restore_persistence_v1(value) {
+        const ret = wasm.wasmworkbook_restore_persistence_v1(this.__wbg_ptr, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Restore sparse cell records produced by `snapshot_sparse` or
+     * `snapshot_range_sparse`. Uses workbook bulk-load so formulas are
+     * reinstalled dirty and are not evaluated during restore.
+     *
+     * **Contract: ADDITIVE merge onto the live workbook** (audit B-7).
+     * There is no teardown and no subscription reset — records are
+     * applied on top of whatever the workbook already holds, and a
+     * `"null"`-kind record explicitly clears its cell. The legacy
+     * sheet-store relies on this for large-range-clear undo: it
+     * snapshots only the range's non-empty cells, clears, and undoes
+     * by restoring that sparse snapshot onto the live workbook.
+     *
+     * W2.3 (audit B-1) verdict: because of this additive contract,
+     * `restore_sparse` deliberately STAYS on the legacy per-cell
+     * `WorkbookLoader` path — the storage-primary
+     * `install_workbook_bulk` is a full-sheet REPLACE and would
+     * silently destroy unrelated live content. Routing it would need
+     * the additive install variant Phase 6.4 deferred. The fresh-shell
+     * restore (`restore_persistence_v1`) IS routed storage-primary.
+     * @param {any} cells
+     * @returns {number}
+     */
+    restore_sparse(cells) {
+        const ret = wasm.wasmworkbook_restore_sparse(this.__wbg_ptr, cells);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {string} addr
+     * @param {string} input
+     * @param {boolean} expand_tables
+     */
+    setCellInputConfirmed(sheet, addr, input, expand_tables) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_setCellInputConfirmed(this.__wbg_ptr, sheet, ptr0, len0, ptr1, len1, expand_tables);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} request
+     * @returns {any}
+     */
+    setConditionalFormatRule(sheet, request) {
+        const ret = wasm.wasmworkbook_setConditionalFormatRule(this.__wbg_ptr, sheet, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} rule
+     */
+    setDataValidation(sheet, start_row, start_col, end_row, end_col, rule) {
+        const ret = wasm.wasmworkbook_setDataValidation(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col, rule);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Push the host's per-sheet FILTER-hidden row set as read-only evaluation
+     * input (`design-filter-hidden-rows` §6.5). Additive twin of
+     * `setEvalHiddenRows` — that method is unchanged — carrying the source
+     * distinction Excel's two SUBTOTAL layers need: `SUBTOTAL(1-11)` excludes
+     * THIS set but includes manually hidden rows, `SUBTOTAL(101-111)` excludes
+     * both. Same shape and contract as `setEvalHiddenRows`: `rows` is a
+     * `number[]` of 0-based row indices, full-replace, empty array clears,
+     * out-of-range `sheet_idx` is a silent no-op, never throws.
+     * @param {number} sheet_idx
+     * @param {Uint32Array} rows
+     */
+    setEvalFilterHiddenRows(sheet_idx, rows) {
+        const ptr0 = passArray32ToWasm0(rows, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_setEvalFilterHiddenRows(this.__wbg_ptr, sheet_idx, ptr0, len0);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {Uint32Array} rows
+     */
+    setEvalHiddenRows(sheet_idx, rows) {
+        const ptr0 = passArray32ToWasm0(rows, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_setEvalHiddenRows(this.__wbg_ptr, sheet_idx, ptr0, len0);
+    }
+    /**
+     * Set a cell's formula through the workbook. Returns `true` if the
+     * formula parsed and installed cleanly, `false` if parse failed
+     * (cell becomes `#VALUE!`) or a cycle was detected (cell becomes
+     * `#CYCLE!`).
+     *
+     * The legacy `set_formula(sheet_idx: u32, ...)` routes through the same
+     * workbook method. This `usize`-typed alias is retained for generated
+     * bindings and worker callers.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} src
+     * @returns {boolean}
+     */
+    setFormulaAt(sheet_idx, addr, src) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_setFormulaAt(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {any} config
+     * @returns {any}
+     */
+    setPrintConfig(sheet, config) {
+        const ret = wasm.wasmworkbook_setPrintConfig(this.__wbg_ptr, sheet, config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Set one totals-row column's aggregate (design doc #32 §7). `func` is a
+     * camelCase id: `"none"` (clears the cell) / `"average"` / `"count"`
+     * (COUNTA) / `"countNums"` (COUNT) / `"max"` / `"min"` / `"sum"` /
+     * `"stdDev"` / `"var"`. Non-`none` ids write `=SUBTOTAL(1xx, Table[Col])`
+     * with the 101-111 hidden-excluding code. Requires the totals row to be
+     * enabled first (`"no-totals-row"` otherwise); unknown `func` yields
+     * `"invalid-totals-function"`.
+     * @param {string} name
+     * @param {string} column
+     * @param {string} func
+     */
+    setTableTotalFunction(name, column, func) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(column, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(func, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_setTableTotalFunction(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} name
+     * @param {boolean} enabled
+     */
+    setTableTotalsRow(name, enabled) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_setTableTotalsRow(this.__wbg_ptr, ptr0, len0, enabled);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {boolean} value
+     */
+    set_boolean(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_boolean(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+    }
+    /**
+     * Set a cell to a boolean value through the workbook. Cross-sheet aware.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {boolean} value
+     */
+    set_cell_boolean(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_cell_boolean(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+    }
+    /**
+     * Set a cell to an error value through the workbook. Cross-sheet aware.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_cell_error(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_cell_error(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * 原始编辑与单条历史一起交给 Rust；表头输入复用列名原子操作。
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} input
+     */
+    set_cell_input(sheet_idx, addr, input) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_set_cell_input(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * 保护表可关闭自动扩展；保留原输入 API 的签名，仍只执行一次原生写入。
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} input
+     * @param {boolean} expand_tables
+     */
+    set_cell_input_with_table_expansion(sheet_idx, addr, input, expand_tables) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_set_cell_input_with_table_expansion(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1, expand_tables);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {number} value
+     */
+    set_cell_number(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_cell_number(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+    }
+    /**
+     * Set a cell to a text value through the workbook. Cross-sheet aware.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_cell_text(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_cell_text(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * Persist a sparse column-width fact on a workbook sheet. Empty columns are
+     * not materialized; this only updates sheet metadata.
+     * @param {number} sheet_idx
+     * @param {number} col_index
+     * @param {number} width_px
+     * @returns {boolean}
+     */
+    set_col_width(sheet_idx, col_index, width_px) {
+        const ret = wasm.wasmworkbook_set_col_width(this.__wbg_ptr, sheet_idx, col_index, width_px);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_error(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_error(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * 兼容旧调用：把完整格式逐格写进 cellStyle。
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {any} fmt
+     * @returns {number}
+     */
+    set_format_range(sheet_idx, start_row, start_col, end_row, end_col, fmt) {
+        const ret = wasm.wasmworkbook_set_format_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col, fmt);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} formula
+     * @returns {boolean}
+     */
+    set_formula(sheet_idx, addr, formula) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(formula, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_set_formula(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} sheet
+     * @param {number} rows
+     * @param {number} cols
+     * @returns {boolean}
+     */
+    set_frozen_panes(sheet, rows, cols) {
+        const ret = wasm.wasmworkbook_set_frozen_panes(this.__wbg_ptr, sheet, rows, cols);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {number} value
+     */
+    set_number(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_number(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {number} row_index
+     * @param {number} height_px
+     * @returns {boolean}
+     */
+    set_row_height(sheet_idx, row_index, height_px) {
+        const ret = wasm.wasmworkbook_set_row_height(this.__wbg_ptr, sheet_idx, row_index, height_px);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     */
+    set_text(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasmworkbook_set_text(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * 一次确认只产生一条原生历史；取消隐藏使用原范围，全表范围即恢复全部。
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @param {string} action
+     * @returns {boolean}
+     */
+    set_visibility(sheet, start_row, start_col, end_row, end_col, action) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_set_visibility(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    sheet_count() {
+        const ret = wasm.wasmworkbook_sheet_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Opaque native identity; String avoids JavaScript's integer precision limit.
+     * @param {number} idx
+     * @returns {string}
+     */
+    sheet_key(idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmworkbook_sheet_key(this.__wbg_ptr, idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {number} idx
+     * @returns {string}
+     */
+    sheet_name(idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmworkbook_sheet_name(this.__wbg_ptr, idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * 包括屏幕外索引，几何定位不依赖当前挂载的单元格。
+     * @param {number} sheet
+     * @returns {any}
+     */
+    sheet_visibility(sheet) {
+        const ret = wasm.wasmworkbook_sheet_visibility(this.__wbg_ptr, sheet);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot display/type/error/formula for a single cell with one
+     * workbook read. Worker hydration uses this to avoid evaluating a dirty
+     * formula once for display, again for type, and again for error state.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {any}
+     */
+    snapshotCell(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_snapshotCell(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Capture every sheet's filter state as an undo before-image. Twin of
+     * `snapshotHidden`: pure read, no epoch bump, whole-workbook REPLACE on
+     * the way back through `restoreFilters`. Sheets with no filter are
+     * omitted.
+     * @returns {any}
+     */
+    snapshotFilters() {
+        const ret = wasm.wasmworkbook_snapshotFilters(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Capture every sheet's manually hidden rows as an undo before-image.
+     * Twin of `snapshotTables`: pure read, no epoch bump, whole-workbook
+     * REPLACE on the way back through `restoreHidden`. Sheets with nothing
+     * hidden are omitted.
+     * @returns {any}
+     */
+    snapshotHidden() {
+        const ret = wasm.wasmworkbook_snapshotHidden(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Capture the whole Excel Table registry as an undo before-image
+     * (design doc #32 §11/§12). Returns
+     * `{ version: 1, tables: TableJSON[] }` — the same per-Table shape
+     * `listTables` emits, wrapped in a versioned envelope.
+     *
+     * 此低层快照只包含注册元数据，不包含表头与公式；交互撤销使用 Rust 原生历史，
+     * 不能由宿主把这个快照当成完整 Table 操作。Pure read — no epoch bump.
+     * @returns {any}
+     */
+    snapshotTables() {
+        const ret = wasm.wasmworkbook_snapshotTables(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * 显示专用快照含条件高亮；基础 snapshot_format_range 继续服务复制和持久化。
+     * @param {number} sheet
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    snapshot_display_format_range(sheet, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_snapshot_display_format_range(this.__wbg_ptr, sheet, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot sparse formatting metadata for a workbook sheet. The
+     * snapshot is metadata-only and safe for lazy formula caches.
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    snapshot_format_range(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_snapshot_format_range(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot workbook state as persistence-v1 sparse envelope.
+     *
+     * Format metadata includes range-format and in-range cell formats from each
+     * sheet snapshot, but does not serialize any dense grid materialization.
+     * Formula cells are serialized using their source (`=...`), preserving lazy
+     * evaluation contracts during restore.
+     * @returns {any}
+     */
+    snapshot_persistence_v1() {
+        const ret = wasm.wasmworkbook_snapshot_persistence_v1(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot non-empty cells in a zero-based inclusive range without
+     * reading formula values. Formula cells serialize their source and stay
+     * dirty/uncomputed, so this is safe for large-range undo.
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    snapshot_range_sparse(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_snapshot_range_sparse(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot sparse workbook contents without reading formula values.
+     *
+     * Formula cells serialize their source (`kind: "formula"`) and do
+     * not call the eval path, so dirty formula caches stay dirty.
+     * @returns {any}
+     */
+    snapshot_sparse() {
+        const ret = wasm.wasmworkbook_snapshot_sparse(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Snapshot row/column size metadata for the requested visible window.
+     * @param {number} sheet_idx
+     * @param {number} start_row
+     * @param {number} start_col
+     * @param {number} end_row
+     * @param {number} end_col
+     * @returns {any}
+     */
+    snapshot_viewport_sizes(sheet_idx, start_row, start_col, end_row, end_col) {
+        const ret = wasm.wasmworkbook_snapshot_viewport_sizes(this.__wbg_ptr, sheet_idx, start_row, start_col, end_row, end_col);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Physically sort a range (design-engine-sort S2). Payload:
+     * `{ range, keys: [{ col, direction, caseSensitive }], excludedRows }`
+     * where `range` is an A1 string or a zero-based bounds object. Returns
+     * the `SortRangeReport` witness on success and a structured
+     * `{ ok: false, code, anchor?, message? }` object for every rejection —
+     * engine gates (`invalid-range`, `empty-keys`, `key-out-of-range`,
+     * `spill-in-range`) and payload-parse failures (`invalid-payload`).
+     * The `Err` arm is reserved for a catastrophic report serialization.
+     * @param {number} sheet_idx
+     * @param {any} payload
+     * @returns {any}
+     */
+    sortRange(sheet_idx, payload) {
+        const ret = wasm.wasmworkbook_sortRange(this.__wbg_ptr, sheet_idx, payload);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {any}
+     */
+    spillAnchor(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_spillAnchor(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret;
+    }
+    /**
+     * 碰撞态（`#SPILL!`）锚点是被哪一格挡住的 —— 返回 `"B3"` 形式的地址字符串，
+     * 答不出时 `null`。UI 拿它给用户一句「把 B3 清掉就好了」，这是 `#SPILL!`
+     * 唯一缺的那条线索（`spillInfo` 对碰撞态锚点恒回 `null`，因为它一格都没装上）。
+     *
+     * 答不出的三种情形在 JS 侧不区分，因为处理方式一样 —— 不说话：`addr` 不是碰撞态
+     * 锚点、碰撞原因是矩形跑出表边（没有哪一格该被指责）、矩形大到超出扫描上限。
+     * 语义与上限的完整说明见 `sheet_spill_blocker.rs`。
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {any}
+     */
+    spillBlocker(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_spillBlocker(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Workbook variant of `WasmSheet::spill_info`. See that method for
+     * JS-side semantics. Returns `null` for an unknown sheet index.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {any}
+     */
+    spillInfo(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_spillInfo(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {any} request
+     * @param {boolean} overwrite
+     * @returns {any}
+     */
+    split_text_columns(request, overwrite) {
+        const ret = wasm.wasmworkbook_split_text_columns(this.__wbg_ptr, request, overwrite);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Subscribe to a cell at `sheet_name!addr`. Returns an opaque
+     * `u32` token; pass it back to `unsubscribe_cell` to cancel.
+     *
+     * The callback subscribes to the sheet's stable cell facade. Local and
+     * cross-sheet dependencies both settle through the workbook-scoped Store;
+     * this map only owns the opaque token and sheet-remap lifecycle.
+     * @param {string} sheet_name
+     * @param {string} addr
+     * @param {Function} cb
+     * @returns {number}
+     */
+    subscribe_cell(sheet_name, addr, cb) {
+        const ptr0 = passStringToWasm0(sheet_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_subscribe_cell(this.__wbg_ptr, ptr0, len0, ptr1, len1, cb);
+        return ret >>> 0;
+    }
+    /**
+     * 只读建议：不写入内容、不增加历史，用户确认仍走 set_cell_input。
+     * @param {any} request
+     * @returns {any}
+     */
+    suggest_quick_formula(request) {
+        const ret = wasm.wasmworkbook_suggest_quick_formula(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @returns {any}
+     */
+    tryClearCellAt(sheet_idx, addr) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_tryClearCellAt(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {boolean} value
+     * @returns {any}
+     */
+    trySetCellBoolean(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_trySetCellBoolean(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     * @returns {any}
+     */
+    trySetCellError(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_trySetCellError(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {number} value
+     * @returns {any}
+     */
+    trySetCellNumber(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_trySetCellNumber(this.__wbg_ptr, sheet_idx, ptr0, len0, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} value
+     * @returns {any}
+     */
+    trySetCellText(sheet_idx, addr, value) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_trySetCellText(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Returns the formula install outcome plus an optional spill-write
+     * rejection. JS shape:
+     *   { ok: true, installed: true } | { ok: true, installed: false }
+     *     | { ok: false, code: 'spill-write', anchor: 'A1' }
+     * `installed: false` corresponds to parse failure (`#VALUE!`) or
+     * cycle detection (`#CYCLE!`) — the cell value already reflects
+     * that, and the caller can pick it up via a follow-up snapshot.
+     * @param {number} sheet_idx
+     * @param {string} addr
+     * @param {string} src
+     * @returns {any}
+     */
+    trySetFormulaAt(sheet_idx, addr, src) {
+        const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_trySetFormulaAt(this.__wbg_ptr, sheet_idx, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Remove a previously-registered name. Returns `true` if an entry
+     * was removed; `false` if no entry existed. Publishing the name-version
+     * root makes dependent formula-inner atoms re-derive to `#NAME?` (or any
+     * newly-shadowing definition).
+     * @param {string} name
+     * @returns {boolean}
+     */
+    undefineName(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_undefineName(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Un-hide `rows` (0-based) on `sheetIdx`. Rows that were not hidden are
+     * ignored. Returns whether anything changed; never throws.
+     * @param {number} sheet_idx
+     * @param {Uint32Array} rows
+     * @returns {boolean}
+     */
+    unhideRows(sheet_idx, rows) {
+        const ptr0 = passArray32ToWasm0(rows, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_unhideRows(this.__wbg_ptr, sheet_idx, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Remove a previously-registered custom formula. Returns `true` if
+     * an entry was removed; `false` if no entry existed. The registry Store
+     * root is published only when removal succeeds, so materialized formulas
+     * that consulted it re-derive and may surface `#NAME?`.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    unregisterCustomFormula(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmworkbook_unregisterCustomFormula(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Cancel a subscription previously returned from `subscribe_cell`.
+     * Idempotent: unknown / stale tokens are silently ignored.
+     * @param {number} token
+     */
+    unsubscribe_cell(token) {
+        wasm.wasmworkbook_unsubscribe_cell(this.__wbg_ptr, token);
+    }
+}
+if (Symbol.dispose) WasmWorkbook.prototype[Symbol.dispose] = WasmWorkbook.prototype.free;
+
+/**
+ * @returns {any}
+ */
+export function function_catalog() {
+    const ret = wasm.function_catalog();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_2e59b1b37a9a34c3: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_Number_e6ffdb596c888833: function(arg0) {
+            const ret = Number(arg0);
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_bigint_get_as_i64_2c5082002e4826e2: function(arg0, arg1) {
+            const v = arg1;
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_boolean_get_a86c216575a75c30: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_dd5d2d07ce9e6c57: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_4bd7a57e54337366: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_6c98f7e945dacdde: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_49868bde5eb1e745: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_344c8750a8525473: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_40c5a80572e8f9d3: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_b29b5c5a8065ba1a: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_c0cca72b82b86f4d: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_7d430e744a913d26: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_3a72ae764d46d944: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_7579aab02a8a620c: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_914df97fcfa788f2: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_81fc77679af83bc6: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_3c3b4f651835fbcb: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_call_368fa9c372d473ba: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_call_7f2987183bb62793: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_call_d578befcc3145dee: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_codePointAt_944099a761b59b26: function(arg0, arg1) {
+            const ret = arg0.codePointAt(arg1 >>> 0);
+            return ret;
+        },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_done_547d467e97529006: function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        },
+        __wbg_entries_616b1a459b85be0b: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_getTime_f6ac312467f7cf09: function(arg0) {
+            const ret = arg0.getTime();
+            return ret;
+        },
+        __wbg_getTimezoneOffset_ac5be603b21a5797: function(arg0) {
+            const ret = arg0.getTimezoneOffset();
+            return ret;
+        },
+        __wbg_get_4848e350b40afc16: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_ed0642c4b9d31ddf: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_f96702c6245e4ef9: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_unchecked_7d7babe32e9e6a54: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+            const ret = arg0[arg1];
+            return ret;
+        },
+        __wbg_hasOwnProperty_ab99d709c7d2c3f6: function(arg0, arg1) {
+            const ret = arg0.hasOwnProperty(arg1);
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_ff7c1337a5e3b33a: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Error_e3390d6805733dad: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_a10a2795ef4bfe97: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_4b8da683deb25d72: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_db61795ad004c139: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_isSafeInteger_ea83862ba994770c: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_de403ef31815a3e6: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_0c32cb8543c8e4c8: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_1e701798fdcaa3b4: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_269224948362b9bf: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_6e821edde497a532: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_message_7367f8c7d0fa1589: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_0_bfa2ef4bc447daa2: function() {
+            const ret = new Date();
+            return ret;
+        },
+        __wbg_new_0f6d2ddfe083319b: function(arg0) {
+            const ret = new Date(arg0);
+            return ret;
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_4f9fafbb3909af72: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_99cabae501c0a8a0: function() {
+            const ret = new Map();
+            return ret;
+        },
+        __wbg_new_a560378ea1240b14: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_e3b04b4d53d1b593: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_f3c9df4f38f3f798: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_with_length_41a22191b9bdfd66: function(arg0) {
+            const ret = new Uint32Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_9cedd08484b73942: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_next_01132ed6134b8ef5: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
+        __wbg_next_b3713ec761a9dbfd: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_now_88621c9c9a4f3ffc: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_3e05eb9545565046: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_6bdbc990be5ac37b: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_set_08463b1df38a7e29: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        },
+        __wbg_set_448126769bf7c181: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU32FromWasm0(arg1, arg2));
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_6c60b2e8ad0e9383: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_set_8ee2d34facb8466e: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_a1248013d790bf5f: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_f2e0f995a21329ff: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_24f78b6d23f286ea: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_59fd959c540fe405: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_0f98d3fb634508ad: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_value_7f6052747ccf940f: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbg_warn_2b0a27f629a4bb1e: function(arg0) {
+            console.warn(arg0);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 250, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_5b6c97e6ee3f690b___convert__closures_____invoke_______true_);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000006: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./einfach_wasm_bg.js": import0,
+    };
+}
+
+function wasm_bindgen_5b6c97e6ee3f690b___convert__closures_____invoke_______true_(arg0, arg1) {
+    wasm.wasm_bindgen_5b6c97e6ee3f690b___convert__closures_____invoke_______true_(arg0, arg1);
+}
+
+const WasmSheetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsheet_free(ptr >>> 0, 1));
+const WasmWorkbookFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmworkbook_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('einfach_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };