@cooljapan/scirs2 0.3.4

package/scirs2_wasm_bg.js

@@ -0,0 +1,2490 @@
+/**
+ * Performance timing utilities for benchmarking WASM operations
+ */
+export class PerformanceTimer {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PerformanceTimerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_performancetimer_free(ptr, 0);
+    }
+    /**
+     * Get elapsed time in milliseconds
+     * @returns {number}
+     */
+    elapsed() {
+        const ret = wasm.performancetimer_elapsed(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Log the elapsed time to console
+     */
+    log_elapsed() {
+        const ret = wasm.performancetimer_log_elapsed(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create a new performance timer with a label
+     * @param {string} label
+     */
+    constructor(label) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.performancetimer_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PerformanceTimerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) PerformanceTimer.prototype[Symbol.dispose] = PerformanceTimer.prototype.free;
+
+/**
+ * A wrapper around ndarray for JavaScript interop
+ */
+export class WasmArray {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmArray.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmArrayFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmArrayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmarray_free(ptr, 0);
+    }
+    /**
+     * Create an array with evenly spaced values (like numpy.arange)
+     * @param {number} start
+     * @param {number} end
+     * @param {number} step
+     * @returns {WasmArray}
+     */
+    static arange(start, end, step) {
+        const ret = wasm.wasmarray_arange(start, end, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Clone the array
+     * @returns {WasmArray}
+     */
+    clone() {
+        const ret = wasm.wasmarray_clone(this.__wbg_ptr);
+        return WasmArray.__wrap(ret);
+    }
+    /**
+     * Create an array with a specific shape from flat data
+     * @param {any} shape
+     * @param {any} data
+     * @returns {WasmArray}
+     */
+    static from_shape(shape, data) {
+        const ret = wasm.wasmarray_from_shape(shape, data);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Create an array filled with a constant value
+     * @param {any} shape
+     * @param {number} value
+     * @returns {WasmArray}
+     */
+    static full(shape, value) {
+        const ret = wasm.wasmarray_full(shape, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Get a value at the specified index (flat indexing)
+     * @param {number} index
+     * @returns {number}
+     */
+    get(index) {
+        const ret = wasm.wasmarray_get(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Check if the array is empty
+     * @returns {boolean}
+     */
+    is_empty() {
+        const ret = wasm.wasmarray_is_empty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the total number of elements
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.wasmarray_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create an evenly spaced array (like numpy.linspace)
+     * @param {number} start
+     * @param {number} end
+     * @param {number} num
+     * @returns {WasmArray}
+     */
+    static linspace(start, end, num) {
+        const ret = wasm.wasmarray_linspace(start, end, num);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Get the number of dimensions
+     * @returns {number}
+     */
+    ndim() {
+        const ret = wasm.wasmarray_ndim(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a 1D array from a JavaScript array or typed array
+     * @param {any} data
+     */
+    constructor(data) {
+        const ret = wasm.wasmarray_new(data);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmArrayFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create an array of ones with the given shape
+     * @param {any} shape
+     * @returns {WasmArray}
+     */
+    static ones(shape) {
+        const ret = wasm.wasmarray_ones(shape);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Reshape the array
+     * @param {any} new_shape
+     * @returns {WasmArray}
+     */
+    reshape(new_shape) {
+        const ret = wasm.wasmarray_reshape(this.__wbg_ptr, new_shape);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Set a value at the specified index (flat indexing)
+     * @param {number} index
+     * @param {number} value
+     */
+    set(index, value) {
+        const ret = wasm.wasmarray_set(this.__wbg_ptr, index, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Get the shape of the array
+     * @returns {Array<any>}
+     */
+    shape() {
+        const ret = wasm.wasmarray_shape(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Convert to a flat JavaScript Float64Array
+     * @returns {Float64Array}
+     */
+    to_array() {
+        const ret = wasm.wasmarray_to_array(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Convert to a JavaScript array (nested for multi-dimensional arrays)
+     * @returns {any}
+     */
+    to_nested_array() {
+        const ret = wasm.wasmarray_to_nested_array(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Transpose the array (2D only for now)
+     * @returns {WasmArray}
+     */
+    transpose() {
+        const ret = wasm.wasmarray_transpose(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+    /**
+     * Create an array of zeros with the given shape
+     * @param {any} shape
+     * @returns {WasmArray}
+     */
+    static zeros(shape) {
+        const ret = wasm.wasmarray_zeros(shape);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmArray.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmArray.prototype[Symbol.dispose] = WasmArray.prototype.free;
+
+/**
+ * Add two arrays element-wise
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function add(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.add(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Perform Akima interpolation.
+ *
+ * Akima interpolation is a piecewise cubic method that is designed to be
+ * robust against outliers. Unlike standard cubic splines, Akima interpolation
+ * uses a local scheme for computing derivatives, making it less prone to
+ * oscillations near outliers or abrupt changes in the data.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in strictly ascending order, at least 5 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 5 data points are provided (Akima requires at least 5)
+ * - x values are not sorted in strictly ascending order
+ * - Evaluation points are outside the data range
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Float64Array} x_new
+ * @returns {Float64Array}
+ */
+export function akima(x, y, x_new) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x_new, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.akima(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Find a root of a function using the bisection method.
+ *
+ * Given an interval [a, b] where the function changes sign, repeatedly halves
+ * the interval to converge on the root.
+ *
+ * # Arguments
+ * * `a` - Lower bracket endpoint
+ * * `b` - Upper bracket endpoint
+ * * `fa` - Function value at a: f(a)
+ * * `fb` - Function value at b: f(b)
+ * * `tol` - Convergence tolerance on the interval width
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * Estimated root location as f64
+ * @param {number} a
+ * @param {number} b
+ * @param {number} fa
+ * @param {number} fb
+ * @param {number} tol
+ * @param {number} max_iter
+ * @returns {number}
+ */
+export function bisect_root(a, b, fa, fb, tol, max_iter) {
+    const ret = wasm.bisect_root(a, b, fa, fb, tol, max_iter);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Iterative bisection step: given bracket [a, b] with opposite-sign function values,
+ * and the function value at the midpoint, returns the narrowed bracket.
+ *
+ * # Arguments
+ * * `a` - Lower bracket
+ * * `b` - Upper bracket
+ * * `fa` - f(a)
+ * * `fb` - f(b)
+ * * `f_mid` - f((a+b)/2)
+ *
+ * # Returns
+ * JsValue with:
+ * - `a`, `b`: new bracket bounds
+ * - `fa`, `fb`: function values at new bounds
+ * - `mid`: current midpoint
+ * - `converged`: whether |b - a| < given tol (caller can check)
+ * @param {number} a
+ * @param {number} b
+ * @param {number} fa
+ * @param {number} fb
+ * @param {number} f_mid
+ * @returns {any}
+ */
+export function bisection_step(a, b, fa, fb, f_mid) {
+    const ret = wasm.bisection_step(a, b, fa, fb, f_mid);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Generate a Blackman window of length `n`.
+ *
+ * The Blackman window is a three-term cosine series window providing
+ * excellent sidelobe suppression at the cost of wider main lobe.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ * @param {number} n
+ * @returns {Float64Array}
+ */
+export function blackman(n) {
+    const ret = wasm.blackman(n);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Find a root of a function using Brent's method.
+ *
+ * Given an interval [a, b] where the function changes sign, finds x such that f(x) ~ 0.
+ * The caller provides the function values at the endpoints.
+ *
+ * # Arguments
+ * * `a` - Lower bracket endpoint
+ * * `b` - Upper bracket endpoint
+ * * `fa` - Function value at a: f(a)
+ * * `fb` - Function value at b: f(b)
+ * * `tol` - Convergence tolerance on the root position
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * Estimated root location as f64
+ * @param {number} a
+ * @param {number} b
+ * @param {number} fa
+ * @param {number} fb
+ * @param {number} tol
+ * @param {number} max_iter
+ * @returns {number}
+ */
+export function brent_root(a, b, fa, fb, tol, max_iter) {
+    const ret = wasm.brent_root(a, b, fa, fb, tol, max_iter);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Design a Butterworth digital filter.
+ *
+ * Returns a JSON object with `b` (numerator) and `a` (denominator) coefficients.
+ *
+ * # Arguments
+ *
+ * * `order` - Filter order (positive integer)
+ * * `cutoff` - Cutoff frequency, normalized 0..1 where 1 is Nyquist
+ * * `btype` - Filter type: "lowpass", "highpass", "bandpass", or "bandstop"
+ * * `fs` - Sampling frequency in Hz (cutoff will be normalized by fs/2)
+ *
+ * # Returns
+ *
+ * A JsValue containing a JSON object `{ b: number[], a: number[] }`.
+ * @param {number} order
+ * @param {number} cutoff
+ * @param {string} btype
+ * @param {number} fs
+ * @returns {any}
+ */
+export function butter(order, cutoff, btype, fs) {
+    const ptr0 = passStringToWasm0(btype, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.butter(order, cutoff, ptr0, len0, fs);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Get system capabilities and features available in this build
+ * @returns {any}
+ */
+export function capabilities() {
+    const ret = wasm.capabilities();
+    return ret;
+}
+
+/**
+ * Perform 1D convolution of two arrays.
+ *
+ * # Arguments
+ *
+ * * `a` - First input array
+ * * `b` - Second input array
+ * * `mode` - Output mode: "full", "same", or "valid"
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the convolution result.
+ * @param {Float64Array} a
+ * @param {Float64Array} b
+ * @param {string} mode
+ * @returns {Float64Array}
+ */
+export function convolve(a, b, mode) {
+    const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.convolve(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Compute correlation coefficient between two arrays
+ * @param {WasmArray} x
+ * @param {WasmArray} y
+ * @returns {number}
+ */
+export function corrcoef(x, y) {
+    _assertClass(x, WasmArray);
+    _assertClass(y, WasmArray);
+    const ret = wasm.corrcoef(x.__wbg_ptr, y.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Perform 1D cross-correlation of two arrays.
+ *
+ * Cross-correlation is equivalent to convolution with the second array reversed.
+ *
+ * # Arguments
+ *
+ * * `a` - First input array
+ * * `b` - Second input array
+ * * `mode` - Output mode: "full", "same", or "valid"
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the correlation result.
+ * @param {Float64Array} a
+ * @param {Float64Array} b
+ * @param {string} mode
+ * @returns {Float64Array}
+ */
+export function correlate(a, b, mode) {
+    const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.correlate(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Perform natural cubic spline interpolation.
+ *
+ * Constructs a natural cubic spline (zero second derivative at boundaries)
+ * through the given data points and evaluates it at the specified x coordinates.
+ * Provides C2 continuity (continuous second derivatives).
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order, at least 3 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the spline
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 3 data points are provided
+ * - x values are not sorted in ascending order
+ * - Evaluation points are outside the data range
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Float64Array} x_new
+ * @returns {Float64Array}
+ */
+export function cubic_spline(x, y, x_new) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x_new, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.cubic_spline(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Compute cumulative product of an array
+ * @param {WasmArray} arr
+ * @returns {WasmArray}
+ */
+export function cumprod(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.cumprod(arr.__wbg_ptr);
+    return WasmArray.__wrap(ret);
+}
+
+/**
+ * Compute cumulative sum of an array
+ * @param {WasmArray} arr
+ * @returns {WasmArray}
+ */
+export function cumsum(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.cumsum(arr.__wbg_ptr);
+    return WasmArray.__wrap(ret);
+}
+
+/**
+ * Compute the cumulative integral of `y` over `x` using the trapezoidal
+ * rule.
+ *
+ * Returns a `Float64Array` of length `n - 1` where `n = y.len()`, with
+ * each element being the integral from `x[0]` to `x[i+1]`.
+ *
+ * # Errors
+ * Returns a `JsValue` error on mismatched lengths or fewer than 2 points.
+ * @param {any} y_js
+ * @param {any} x_js
+ * @returns {Float64Array}
+ */
+export function cumulative_trapezoid(y_js, x_js) {
+    const ret = wasm.cumulative_trapezoid(y_js, x_js);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the determinant of a square matrix
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function det(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.det(arr.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Divide two arrays element-wise
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function divide(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.divide(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute dot product (1D) or matrix multiplication (2D)
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function dot(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.dot(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute the forward Fast Fourier Transform (FFT) of complex input data.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the FFT result.
+ * The output length equals the input length (same number of interleaved pairs).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even (not valid interleaved complex data)
+ * - The input is empty
+ * - The FFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Signal: [1+0i, 2+0i, 3+0i, 4+0i] as interleaved
+ * const input = new Float64Array([1, 0, 2, 0, 3, 0, 4, 0]);
+ * const result = fft(input);
+ * // result contains interleaved [re, im, re, im, ...]
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function fft(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fft(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Compute the magnitude (absolute value) of complex interleaved data.
+ *
+ * For each complex value `(re, im)`, computes `sqrt(re^2 + im^2)`.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * A vector of magnitudes, one per complex value. Length is `data.len() / 2`.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input length is not even.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Complex values: [3+4i, 0+1i] => magnitudes: [5.0, 1.0]
+ * const data = new Float64Array([3, 4, 0, 1]);
+ * const mags = fft_magnitude(data);
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function fft_magnitude(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fft_magnitude(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Compute the phase angle of complex interleaved data (in radians).
+ *
+ * For each complex value `(re, im)`, computes `atan2(im, re)`.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * A vector of phase angles in radians `[-pi, pi]`, one per complex value.
+ * Length is `data.len() / 2`.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input length is not even.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Complex value: [1+1i] => phase: pi/4 (~0.785)
+ * const data = new Float64Array([1, 1]);
+ * const phases = fft_phase(data);
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function fft_phase(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fft_phase(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Compute the FFT sample frequencies.
+ *
+ * Returns the frequency bin centers in cycles per unit of the sample spacing,
+ * following the same convention as NumPy/SciPy.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of samples in the signal (window length).
+ * * `d` - Sample spacing (inverse of the sampling rate). Must be positive.
+ *
+ * # Returns
+ *
+ * A vector of length `n` containing the sample frequencies.
+ * For even `n`: `[0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n)`
+ * For odd `n`: `[0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)`
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - `n` is 0
+ * - `d` is not positive
+ * - The computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const freqs = fftfreq(8, 0.1);
+ * // freqs = [0.0, 1.25, 2.5, 3.75, -5.0, -3.75, -2.5, -1.25]
+ * ```
+ * @param {number} n
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+export function fftfreq(n, d) {
+    const ret = wasm.fftfreq(n, d);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Shift the zero-frequency component to the center of the spectrum.
+ *
+ * Rearranges the FFT output so that the zero-frequency component is at
+ * the center, with negative frequencies on the left and positive on the right.
+ *
+ * # Arguments
+ *
+ * * `data` - FFT output as a flat f64 array (real-valued, e.g. from `power_spectrum`
+ *   or magnitude array).
+ *
+ * # Returns
+ *
+ * The shifted array with zero-frequency at the center.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input is empty.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const data = new Float64Array([0, 1, 2, 3, 4, -4, -3, -2, -1]);
+ * const shifted = fftshift(data);
+ * // shifted = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function fftshift(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fftshift(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Design an FIR (Finite Impulse Response) lowpass filter using the window method.
+ *
+ * Designs a linear-phase FIR lowpass filter with the specified number of taps
+ * and cutoff frequency, using a Hamming window.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of filter taps (must be >= 3)
+ * * `cutoff` - Cutoff frequency in Hz
+ * * `fs` - Sampling frequency in Hz
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the FIR filter coefficients.
+ * @param {number} n
+ * @param {number} cutoff
+ * @param {number} fs
+ * @returns {Float64Array}
+ */
+export function firwin(n, cutoff, fs) {
+    const ret = wasm.firwin(n, cutoff, fs);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Step-wise golden section search: given bracket [a, b] and two interior
+ * function evaluations, returns the narrowed bracket and next evaluation points.
+ *
+ * # Arguments
+ * * `a` - Current lower bound
+ * * `b` - Current upper bound
+ * * `f_x1` - Function value at interior point x1
+ * * `f_x2` - Function value at interior point x2
+ * * `tol` - Convergence tolerance
+ *
+ * # Returns
+ * JsValue with:
+ * - `a`, `b`: new bracket bounds
+ * - `x1`, `x2`: new interior evaluation points
+ * - `converged`: whether |b - a| < tol
+ * - `x_min`: current best estimate of the minimizer
+ * @param {number} a
+ * @param {number} b
+ * @param {number} f_x1
+ * @param {number} f_x2
+ * @param {number} tol
+ * @returns {any}
+ */
+export function golden_section_step(a, b, f_x1, f_x2, tol) {
+    const ret = wasm.golden_section_step(a, b, f_x1, f_x2, tol);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Generate a Hamming window of length `n`.
+ *
+ * The Hamming window is a raised cosine window with non-zero endpoints,
+ * providing better sidelobe suppression than the Hann window.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ * @param {number} n
+ * @returns {Float64Array}
+ */
+export function hamming(n) {
+    const ret = wasm.hamming(n);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Generate a Hanning (Hann) window of length `n`.
+ *
+ * The Hann window is a raised cosine window with zero values at both endpoints,
+ * providing good frequency resolution and moderate sidelobe suppression.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ * @param {number} n
+ * @returns {Float64Array}
+ */
+export function hanning(n) {
+    const ret = wasm.hanning(n);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Check if WASM SIMD is supported in the current environment
+ * @returns {boolean}
+ */
+export function has_simd_support() {
+    const ret = wasm.has_simd_support();
+    return ret !== 0;
+}
+
+/**
+ * Compute the inverse Fast Fourier Transform (IFFT) of complex input data.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the IFFT result.
+ * The output length equals the input length (same number of interleaved pairs).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even
+ * - The input is empty
+ * - The IFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const spectrum = new Float64Array([10, 0, -2, 2, -2, 0, -2, -2]);
+ * const signal = ifft(spectrum);
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function ifft(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ifft(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Inverse of `fftshift`: shift zero-frequency component back to the beginning.
+ *
+ * This undoes the effect of `fftshift`.
+ *
+ * # Arguments
+ *
+ * * `data` - Shifted spectrum (with zero-frequency at center).
+ *
+ * # Returns
+ *
+ * The unshifted array with zero-frequency at the beginning.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input is empty.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const shifted = new Float64Array([-4, -3, -2, -1, 0, 1, 2, 3, 4]);
+ * const unshifted = ifftshift(shifted);
+ * // unshifted = [0, 1, 2, 3, 4, -4, -3, -2, -1]
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function ifftshift(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ifftshift(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Initialize the WASM module with panic hooks and logging
+ */
+export function init() {
+    wasm.init();
+}
+
+/**
+ * Perform 1D interpolation with a specified method.
+ *
+ * Interpolates between the given (x, y) data points and evaluates the
+ * interpolation at the new x coordinates.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ * * `kind` - Interpolation method: "linear", "nearest", or "quadratic" (uses cubic/Catmull-Rom)
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - x values are not sorted in ascending order
+ * - An unknown interpolation kind is specified
+ * - Insufficient points for the requested method
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Float64Array} x_new
+ * @param {string} kind
+ * @returns {Float64Array}
+ */
+export function interp1d(x, y, x_new, kind) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x_new, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.interp1d(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v5 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v5;
+}
+
+/**
+ * Compute matrix inverse
+ * @param {WasmArray} arr
+ * @returns {WasmArray}
+ */
+export function inv(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.inv(arr.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute the inverse FFT for real-valued output (IRFFT).
+ *
+ * This is the inverse of `rfft`. It takes the positive-frequency half-spectrum
+ * and reconstructs the original real-valued signal.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs of the half-spectrum:
+ *   `[re_0, im_0, re_1, im_1, ...]`. The length must be even.
+ * * `n` - Length of the output real signal. If 0, it is computed as
+ *   `2 * (num_complex - 1)` where `num_complex` is the number of complex values.
+ *
+ * # Returns
+ *
+ * Real-valued output signal as `f64` array.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even
+ * - The input is empty
+ * - The IRFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const spectrum = rfft(new Float64Array([1, 2, 3, 4]));
+ * const signal = irfft(spectrum, 4);  // Recover original 4-element signal
+ * ```
+ * @param {Float64Array} data
+ * @param {number} n
+ * @returns {Float64Array}
+ */
+export function irfft(data, n) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.irfft(ptr0, len0, n);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Perform Lagrange polynomial interpolation.
+ *
+ * Uses barycentric Lagrange interpolation, which is numerically more stable
+ * than the naive Lagrange formula. The order of the polynomial equals
+ * the number of data points minus one.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must have distinct values)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the polynomial
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 2 data points are provided
+ * - x values contain duplicates
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Float64Array} x_new
+ * @returns {Float64Array}
+ */
+export function lagrange(x, y, x_new) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x_new, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.lagrange(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Apply a digital filter to a signal using direct form II transposed structure.
+ *
+ * Implements causal filtering with the inherent group delay of the filter.
+ * Both IIR and FIR filters are supported.
+ *
+ * # Arguments
+ *
+ * * `b` - Numerator (feedforward) coefficients
+ * * `a` - Denominator (feedback) coefficients. For FIR filters, use `[1.0]`.
+ * * `x` - Input signal
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the filtered signal (same length as input).
+ * @param {Float64Array} b
+ * @param {Float64Array} a
+ * @param {Float64Array} x
+ * @returns {Float64Array}
+ */
+export function lfilter(b, a, x) {
+    const ptr0 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.lfilter(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Perform simple linear regression: y = slope * x + intercept.
+ *
+ * # Arguments
+ * * `x` - Independent variable values
+ * * `y` - Dependent variable values
+ *
+ * # Returns
+ * JsValue containing:
+ * - `slope`: regression slope
+ * - `intercept`: regression intercept
+ * - `r_squared`: coefficient of determination (R^2)
+ * - `std_err_slope`: standard error of the slope
+ * - `std_err_intercept`: standard error of the intercept
+ * - `n`: number of data points
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @returns {any}
+ */
+export function linear_regression(x, y) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.linear_regression(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Log a message to the browser console
+ * @param {string} message
+ */
+export function log(message) {
+    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.log(ptr0, len0);
+}
+
+/**
+ * Find the maximum value
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function max(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.max(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Compute the mean of all elements
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function mean(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.mean(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Compute the median of an array
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function median(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.median(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Memory usage information for the WASM module
+ * @returns {any}
+ */
+export function memory_usage() {
+    const ret = wasm.memory_usage();
+    return ret;
+}
+
+/**
+ * Find the minimum value
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function min(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.min(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Minimize a scalar function over a bracketed interval using golden section search.
+ *
+ * This is a derivative-free 1D optimization method. Since WASM cannot pass
+ * function closures, this method works on a tabulated function: the caller provides
+ * sample points and their values, and the algorithm interpolates.
+ *
+ * # Arguments
+ * * `a` - Lower bound of the search interval
+ * * `b` - Upper bound of the search interval
+ * * `tol` - Convergence tolerance on the interval width
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * A JsValue containing:
+ * - `x`: estimated minimizer
+ * - `fun`: estimated function value at minimizer (NaN if unknown)
+ * - `a`: final bracket lower bound
+ * - `b`: final bracket upper bound
+ * - `nit`: number of iterations
+ * - `success`: whether tolerance was achieved
+ * @param {number} a
+ * @param {number} b
+ * @param {number} tol
+ * @param {number} max_iter
+ * @returns {any}
+ */
+export function minimize_golden(a, b, tol, max_iter) {
+    const ret = wasm.minimize_golden(a, b, tol, max_iter);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Minimize a function using the Nelder-Mead simplex algorithm.
+ *
+ * Since WASM cannot pass function closures from JS, this performs the Nelder-Mead
+ * optimization using pre-evaluated simplex vertices and their function values.
+ *
+ * # Arguments
+ * * `f_values` - Function values at the initial simplex vertices (n+1 values for n dimensions)
+ * * `x0` - Flat array of initial simplex vertex coordinates, row-major layout:
+ *   each vertex has `n` coordinates, so total length is `(n+1) * n`
+ * * `tol` - Convergence tolerance (standard deviation of simplex values)
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * A JsValue containing an object with fields:
+ * - `x`: best point found (as array)
+ * - `fun`: function value at best point
+ * - `nit`: number of iterations performed
+ * - `success`: whether convergence was achieved
+ * - `simplex`: final simplex vertices (flat array)
+ * - `simplex_values`: function values at final simplex vertices
+ *
+ * Note: With pre-evaluated data, this performs a single Nelder-Mead step cycle.
+ * For iterative optimization, call repeatedly from JS, re-evaluating the function
+ * at the new simplex points each iteration.
+ * @param {Float64Array} f_values
+ * @param {Float64Array} x0
+ * @param {number} tol
+ * @param {number} max_iter
+ * @returns {any}
+ */
+export function minimize_nelder_mead(f_values, x0, tol, max_iter) {
+    const ptr0 = passArrayF64ToWasm0(f_values, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(x0, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.minimize_nelder_mead(ptr0, len0, ptr1, len1, tol, max_iter);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Multiply two arrays element-wise
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function multiply(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.multiply(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute the Frobenius norm of a matrix
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function norm_frobenius(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.norm_frobenius(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Solve the ODE  dy/dt = -y  (exponential decay) using the classic RK4
+ * method.
+ *
+ * Since JavaScript cannot pass function pointers to WASM, this solver uses
+ * a built-in right-hand side (exponential decay, dy_i/dt = -y_i for every
+ * component).
+ *
+ * * `y0_js`     -- initial state vector (1-D array).
+ * * `t_span_js` -- two-element array `[t_start, t_end]`.
+ * * `n_steps`   -- number of integration steps.
+ *
+ * Returns a serialised JSON object (via `JsValue`) with fields:
+ * * `t`  -- array of time values.
+ * * `y`  -- array of arrays, one per time point (each inner array has the
+ *   same length as `y0`).
+ *
+ * # Errors
+ * Returns a `JsValue` error when inputs are invalid.
+ * @param {any} y0_js
+ * @param {any} t_span_js
+ * @param {number} n_steps
+ * @returns {any}
+ */
+export function ode_solve(y0_js, t_span_js, n_steps) {
+    const ret = wasm.ode_solve(y0_js, t_span_js, n_steps);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Perform PCHIP (Piecewise Cubic Hermite Interpolating Polynomial) interpolation.
+ *
+ * PCHIP produces a monotonicity-preserving interpolant: if the input data is
+ * monotonically increasing (or decreasing) in an interval, the interpolation
+ * will be too. The first derivatives are continuous, but the second derivatives
+ * may have jumps at the knot points.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order, at least 2 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 2 data points are provided
+ * - x values are not sorted in ascending order
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Float64Array} x_new
+ * @returns {Float64Array}
+ */
+export function pchip(x, y, x_new) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(x_new, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.pchip(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
+/**
+ * Compute a percentile of an array
+ * @param {WasmArray} arr
+ * @param {number} q
+ * @returns {number}
+ */
+export function percentile(arr, q) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.percentile(arr.__wbg_ptr, q);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Evaluate a fitted polynomial at given points.
+ *
+ * # Arguments
+ * * `coeffs` - Polynomial coefficients in ascending power order [c_0, c_1, ..., c_d]
+ * * `x` - Points at which to evaluate the polynomial
+ *
+ * # Returns
+ * Evaluated values as `Vec<f64>`
+ * @param {Float64Array} coeffs
+ * @param {Float64Array} x
+ * @returns {Float64Array}
+ */
+export function polynomial_eval(coeffs, x) {
+    const ptr0 = passArrayF64ToWasm0(coeffs, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.polynomial_eval(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Fit a polynomial of given degree to data points using least squares.
+ *
+ * Finds coefficients c_0, c_1, ..., c_d such that:
+ *   y ~ c_0 + c_1*x + c_2*x^2 + ... + c_d*x^d
+ *
+ * # Arguments
+ * * `x` - Independent variable values
+ * * `y` - Dependent variable values
+ * * `degree` - Degree of the polynomial to fit
+ *
+ * # Returns
+ * Coefficients as a `Vec<f64>` in ascending power order: `[c_0, c_1, ..., c_d]`
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} degree
+ * @returns {Float64Array}
+ */
+export function polynomial_fit(x, y, degree) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.polynomial_fit(ptr0, len0, ptr1, len1, degree);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Compute the power spectrum (power spectral density) of a real-valued signal.
+ *
+ * Computes `|FFT(signal)|^2` for each frequency bin. The result represents
+ * the distribution of signal power across frequencies.
+ *
+ * # Arguments
+ *
+ * * `data` - Real-valued input signal as `f64` array.
+ *
+ * # Returns
+ *
+ * A vector of length `n/2 + 1` containing the power at each frequency bin
+ * (only positive frequencies, since the input is real-valued).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input is empty
+ * - The FFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const signal = new Float64Array([1, 0, -1, 0, 1, 0, -1, 0]);
+ * const psd = power_spectrum(signal);
+ * // psd[2] should have the dominant peak (frequency = 2 cycles per 8 samples)
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function power_spectrum(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.power_spectrum(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Generate random numbers from an exponential distribution
+ * @param {any} shape
+ * @param {number} lambda
+ * @returns {WasmArray}
+ */
+export function random_exponential(shape, lambda) {
+    const ret = wasm.random_exponential(shape, lambda);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Generate random integers in the range [low, high)
+ * @param {any} shape
+ * @param {number} low
+ * @param {number} high
+ * @returns {WasmArray}
+ */
+export function random_integers(shape, low, high) {
+    const ret = wasm.random_integers(shape, low, high);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Generate random numbers from a normal (Gaussian) distribution
+ * @param {any} shape
+ * @param {number} mean
+ * @param {number} std_dev
+ * @returns {WasmArray}
+ */
+export function random_normal(shape, mean, std_dev) {
+    const ret = wasm.random_normal(shape, mean, std_dev);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Generate random numbers from a uniform distribution [0, 1)
+ * @param {any} shape
+ * @returns {WasmArray}
+ */
+export function random_uniform(shape) {
+    const ret = wasm.random_uniform(shape);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute the matrix rank
+ * @param {WasmArray} arr
+ * @param {number | null} [tolerance]
+ * @returns {number}
+ */
+export function rank(arr, tolerance) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.rank(arr.__wbg_ptr, !isLikeNone(tolerance), isLikeNone(tolerance) ? 0 : tolerance);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] >>> 0;
+}
+
+/**
+ * Compute the FFT of real-valued input data (RFFT).
+ *
+ * This is optimized for real-valued signals. The output contains only the
+ * positive-frequency half of the spectrum (plus the DC and Nyquist components),
+ * since the negative frequencies are redundant for real input.
+ *
+ * # Arguments
+ *
+ * * `data` - Real-valued input signal as `f64` array.
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the half-spectrum.
+ * Output length is `2 * (n/2 + 1)` where `n` is the input length, because
+ * the result contains `n/2 + 1` complex values stored as interleaved pairs.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input is empty
+ * - The RFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const signal = new Float64Array([1.0, 2.0, 3.0, 4.0]);
+ * const spectrum = rfft(signal);
+ * // spectrum has (4/2 + 1) * 2 = 6 elements: 3 complex values as interleaved pairs
+ * ```
+ * @param {Float64Array} data
+ * @returns {Float64Array}
+ */
+export function rfft(data) {
+    const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rfft(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Compute the FFT sample frequencies for real-valued FFT (RFFT).
+ *
+ * Returns the frequency bin centers for the positive-frequency half of the
+ * spectrum, which is the output of `rfft`.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of samples in the original signal (window length).
+ * * `d` - Sample spacing (inverse of the sampling rate). Must be positive.
+ *
+ * # Returns
+ *
+ * A vector of length `n/2 + 1` containing the sample frequencies for
+ * the positive half of the spectrum.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - `n` is 0
+ * - `d` is not positive
+ * - The computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const freqs = rfftfreq(8, 0.1);
+ * // freqs = [0.0, 1.25, 2.5, 3.75, 5.0]
+ * ```
+ * @param {number} n
+ * @param {number} d
+ * @returns {Float64Array}
+ */
+export function rfftfreq(n, d) {
+    const ret = wasm.rfftfreq(n, d);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
+/**
+ * Perform a single explicit Runge-Kutta 4th order (RK4) step.
+ *
+ * Because JavaScript cannot pass function pointers, the caller must supply
+ * the derivative values pre-computed at the current state.
+ *
+ * * `f_vals_js` -- derivative values dy/dt evaluated at (t, y), one per
+ *   component.
+ * * `t`         -- current time.
+ * * `y_js`      -- current state vector.
+ * * `h`         -- step size.
+ *
+ * The function approximates the next state assuming a *constant* derivative
+ * (i.e. Euler) combined with the classical RK4 weighting using the provided
+ * derivative.  For a full multi-stage RK4 the caller would need to evaluate
+ * the derivative at the intermediate stages; this helper is therefore best
+ * suited for demonstration / simple cases.
+ *
+ * Returns the new state vector `y_{n+1}` as a `Float64Array`.
+ *
+ * # Errors
+ * Returns a `JsValue` error when `f_vals` and `y` have different lengths.
+ * @param {any} f_vals_js
+ * @param {number} _t
+ * @param {any} y_js
+ * @param {number} h
+ * @returns {Float64Array}
+ */
+export function rk4_step(f_vals_js, _t, y_js, h) {
+    const ret = wasm.rk4_step(f_vals_js, _t, y_js, h);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Compute the integral of tabulated data `y` with uniform spacing `dx`
+ * using Romberg integration (Richardson extrapolation of the trapezoidal
+ * rule).
+ *
+ * The number of data points must be of the form `2^k + 1` for some
+ * non-negative integer `k` (e.g. 2, 3, 5, 9, 17, 33, ...).  If the length
+ * does not satisfy this requirement an error is returned.
+ *
+ * # Arguments
+ * * `y_js` -- ordinate values (array of `f64`).
+ * * `dx`   -- uniform spacing between consecutive x-values.
+ *
+ * # Errors
+ * Returns a `JsValue` error when the input length is not `2^k + 1` or when
+ * fewer than 2 points are given.
+ * @param {any} y_js
+ * @param {number} dx
+ * @returns {number}
+ */
+export function romberg(y_js, dx) {
+    const ret = wasm.romberg(y_js, dx);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Set the random seed for reproducibility
+ * @param {bigint} seed
+ * @returns {string}
+ */
+export function set_random_seed(seed) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.set_random_seed(seed);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Compute the definite integral of `y` over `x` using Simpson's rule.
+ *
+ * For segments where three consecutive points are available the classic
+ * Simpson 1/3 rule is used.  A final trapezoidal panel is added when the
+ * number of intervals is odd.
+ *
+ * # Errors
+ * Returns a `JsValue` error on mismatched lengths or fewer than 2 points.
+ * @param {any} y_js
+ * @param {any} x_js
+ * @returns {number}
+ */
+export function simpson(y_js, x_js) {
+    const ret = wasm.simpson(y_js, x_js);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Solve a system of linear equations Ax = b
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function solve(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.solve(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Compute the standard deviation of an array
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function std(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.std(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Compute the standard deviation with specified degrees of freedom
+ * @param {WasmArray} arr
+ * @param {number} ddof
+ * @returns {number}
+ */
+export function std_with_ddof(arr, ddof) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.std_with_ddof(arr.__wbg_ptr, ddof);
+    return ret;
+}
+
+/**
+ * Subtract two arrays element-wise
+ * @param {WasmArray} a
+ * @param {WasmArray} b
+ * @returns {WasmArray}
+ */
+export function subtract(a, b) {
+    _assertClass(a, WasmArray);
+    _assertClass(b, WasmArray);
+    const ret = wasm.subtract(a.__wbg_ptr, b.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmArray.__wrap(ret[0]);
+}
+
+/**
+ * Sum all elements in the array
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function sum(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.sum(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Compute the trace of a matrix (sum of diagonal elements)
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function trace(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.trace(arr.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Compute the definite integral of `y` over `x` using the composite
+ * trapezoidal rule.
+ *
+ * Both `y_js` and `x_js` must be arrays of the same length (>= 2).
+ *
+ * # Errors
+ * Returns a `JsValue` error when the inputs have mismatched lengths or
+ * contain fewer than 2 points.
+ * @param {any} y_js
+ * @param {any} x_js
+ * @returns {number}
+ */
+export function trapezoid(y_js, x_js) {
+    const ret = wasm.trapezoid(y_js, x_js);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Compute the variance of an array
+ * @param {WasmArray} arr
+ * @returns {number}
+ */
+export function variance(arr) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.variance(arr.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Compute the variance with specified degrees of freedom
+ * @param {WasmArray} arr
+ * @param {number} ddof
+ * @returns {number}
+ */
+export function variance_with_ddof(arr, ddof) {
+    _assertClass(arr, WasmArray);
+    const ret = wasm.variance_with_ddof(arr.__wbg_ptr, ddof);
+    return ret;
+}
+
+/**
+ * Get the version of SciRS2-WASM
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+export function __wbg_Error_83742b46f01ce22d(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_String_8564e559799eccda(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);
+}
+export function __wbg___wbindgen_is_object_781bc9f159099513(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_string_7ef6b97b02428fae(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_52709e72fb9f179c(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_34bb9d9dcfa21373(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);
+}
+export function __wbg___wbindgen_throw_6ddd609b62940d55(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_error_a6fa202b58aa1cd3(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);
+    }
+}
+export function __wbg_from_4bdf88943703fd48(arg0) {
+    const ret = Array.from(arg0);
+    return ret;
+}
+export function __wbg_getRandomValues_76dfc69825c9c552() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments); }
+export function __wbg_get_a8ee5c45dabc1b3b(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_instanceof_Float32Array_6f3d6ec9510b72a8(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Float32Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Float64Array_2d1021bf5466d4cb(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Float64Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Window_23e677d2c6843922(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_42f3245bcac28e65(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_length_259ee9d041e381ad(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_550d8a396009cd38(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_b3416cf66a5452c8(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_log_524eedafa26daa59(arg0) {
+    console.log(arg0);
+}
+export function __wbg_new_1db9947b8e01b15f(arg0) {
+    const ret = new Float64Array(arg0);
+    return ret;
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return ret;
+}
+export function __wbg_new_2cb6f455748a4e89(arg0) {
+    const ret = new Float32Array(arg0);
+    return ret;
+}
+export function __wbg_new_49d5571bd3f0c4d4() {
+    const ret = new Map();
+    return ret;
+}
+export function __wbg_new_a70fbab9066b301f() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_new_ab79df5bd7c26067() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_with_length_3259a525196bd8cc(arg0) {
+    const ret = new Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_new_with_length_eae667475c36c4e4(arg0) {
+    const ret = new Float64Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_now_c6d7a7d35f74f6f1(arg0) {
+    const ret = arg0.now();
+    return ret;
+}
+export function __wbg_performance_28be169151161678(arg0) {
+    const ret = arg0.performance;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_prototypesetcall_247ac4333d4d3cb4(arg0, arg1, arg2) {
+    Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_prototypesetcall_79daf97fb14c7a19(arg0, arg1, arg2) {
+    Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_set_282384002438957f(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbg_set_636d1e3e4286e068(arg0, arg1, arg2) {
+    arg0.set(getArrayF64FromWasm0(arg1, arg2));
+}
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+}
+export function __wbg_set_bf7251625df30a02(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+}
+export function __wbg_stack_3b0d974bbf31e44f(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);
+}
+export function __wbg_static_accessor_GLOBAL_8adb955bd33fac2f() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_f207c857566db248() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_bb9f1ba69d61b386() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000003(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    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);
+}
+const PerformanceTimerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_performancetimer_free(ptr >>> 0, 1));
+const WasmArrayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmarray_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + 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 cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+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 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 passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.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 wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}