@sipemu/anofox-statistics 0.4.0

package/anofox_statistics_js.js

@@ -0,0 +1,1758 @@
+/* @ts-self-types="./anofox_statistics_js.d.ts" */
+
+/**
+ * Alternative hypothesis for JavaScript
+ * @enum {0 | 1 | 2}
+ */
+export const JsAlternative = Object.freeze({
+    TwoSided: 0, "0": "TwoSided",
+    Less: 1, "1": "Less",
+    Greater: 2, "2": "Greater",
+});
+
+/**
+ * ANOVA kind for JavaScript
+ * @enum {0 | 1}
+ */
+export const JsAnovaKind = Object.freeze({
+    Fisher: 0, "0": "Fisher",
+    Welch: 1, "1": "Welch",
+});
+
+/**
+ * Correlation TOST method for JavaScript
+ * @enum {0 | 1}
+ */
+export const JsCorrelationTostMethod = Object.freeze({
+    Pearson: 0, "0": "Pearson",
+    Spearman: 1, "1": "Spearman",
+});
+
+/**
+ * ICC type for JavaScript
+ * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ */
+export const JsICCType = Object.freeze({
+    ICC1: 0, "0": "ICC1",
+    ICC2: 1, "1": "ICC2",
+    ICC3: 2, "2": "ICC3",
+    ICC1k: 3, "3": "ICC1k",
+    ICC2k: 4, "4": "ICC2k",
+    ICC3k: 5, "5": "ICC3k",
+});
+
+/**
+ * Kendall variant for JavaScript
+ * @enum {0 | 1 | 2}
+ */
+export const JsKendallVariant = Object.freeze({
+    TauA: 0, "0": "TauA",
+    TauB: 1, "1": "TauB",
+    TauC: 2, "2": "TauC",
+});
+
+/**
+ * Kernel type for MMD test
+ * @enum {0 | 1 | 2}
+ */
+export const JsKernel = Object.freeze({
+    Gaussian: 0, "0": "Gaussian",
+    Laplacian: 1, "1": "Laplacian",
+    Linear: 2, "2": "Linear",
+});
+
+/**
+ * Loss function for forecast comparison
+ * @enum {0 | 1}
+ */
+export const JsLossFunction = Object.freeze({
+    SquaredError: 0, "0": "SquaredError",
+    AbsoluteError: 1, "1": "AbsoluteError",
+});
+
+/**
+ * MCS statistic type
+ * @enum {0 | 1}
+ */
+export const JsMCSStatistic = Object.freeze({
+    Max: 0, "0": "Max",
+    Range: 1, "1": "Range",
+});
+
+/**
+ * T-test kind for JavaScript
+ * @enum {0 | 1 | 2}
+ */
+export const JsTTestKind = Object.freeze({
+    Welch: 0, "0": "Welch",
+    Student: 1, "1": "Student",
+    Paired: 2, "2": "Paired",
+});
+
+/**
+ * Variance estimator for forecast tests
+ * @enum {0 | 1}
+ */
+export const JsVarEstimator = Object.freeze({
+    Acf: 0, "0": "Acf",
+    Bartlett: 1, "1": "Bartlett",
+});
+
+/**
+ * Exact binomial test.
+ *
+ * @param successes - Number of successes
+ * @param trials - Number of trials
+ * @param p0 - Hypothesized probability (default: 0.5)
+ * @param alternative - Alternative hypothesis direction
+ * @returns Object with p_value, estimate, conf_int_lower, conf_int_upper
+ * @param {number} successes
+ * @param {number} trials
+ * @param {number | null | undefined} p0
+ * @param {JsAlternative} alternative
+ * @returns {any}
+ */
+export function binomTest(successes, trials, p0, alternative) {
+    const ret = wasm.binomTest(successes, trials, !isLikeNone(p0), isLikeNone(p0) ? 0 : p0, alternative);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Brown-Forsythe test for homogeneity of variances.
+ *
+ * @param groups - Array of groups, each group is a Float64Array
+ * @returns Object with statistic, df1, df2, p_value
+ * @param {Array<any>} groups
+ * @returns {any}
+ */
+export function brownForsythe(groups) {
+    const ret = wasm.brownForsythe(groups);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Brunner-Munzel test for stochastic equality.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param alternative - Alternative hypothesis direction
+ * @param alpha - If specified, compute CI at (1-alpha) level (e.g., 0.05 for 95% CI)
+ * @returns Object with statistic, df, p_value, estimate, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsAlternative} alternative
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function brunnerMunzel(x, y, alternative, alpha) {
+    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.brunnerMunzel(ptr0, len0, ptr1, len1, alternative, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Chi-square goodness-of-fit test.
+ *
+ * @param observed - Observed counts as array of numbers
+ * @param expectedProps - Expected proportions as array of numbers (must sum to 1), or null for uniform
+ * @returns Object with statistic, df, p_value
+ * @param {Float64Array} observed
+ * @param {Float64Array | null} [expected_props]
+ * @returns {any}
+ */
+export function chiSquareGoodnessOfFit(observed, expected_props) {
+    const ptr0 = passArrayF64ToWasm0(observed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(expected_props) ? 0 : passArrayF64ToWasm0(expected_props, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.chiSquareGoodnessOfFit(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Chi-square test for independence.
+ *
+ * @param observed - 2D array of observed counts (contingency table)
+ * @param yatesCorrection - Apply Yates continuity correction for 2x2 tables (default: false)
+ * @returns Object with statistic, df, p_value, expected frequencies
+ * @param {Array<any>} observed
+ * @param {boolean | null} [yates_correction]
+ * @returns {any}
+ */
+export function chiSquareTest(observed, yates_correction) {
+    const ret = wasm.chiSquareTest(observed, isLikeNone(yates_correction) ? 0xFFFFFF : yates_correction ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Clark-West test for comparing nested forecast models.
+ *
+ * @param e1 - Forecast errors from restricted model as Float64Array
+ * @param e2 - Forecast errors from unrestricted model as Float64Array
+ * @param horizon - Forecast horizon for HAC variance adjustment
+ * @returns Object with statistic, p_value, p_value_two_sided
+ * @param {Float64Array} e1
+ * @param {Float64Array} e2
+ * @param {number} horizon
+ * @returns {any}
+ */
+export function clarkWest(e1, e2, horizon) {
+    const ptr0 = passArrayF64ToWasm0(e1, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(e2, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.clarkWest(ptr0, len0, ptr1, len1, horizon);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Cohen's Kappa for inter-rater agreement.
+ *
+ * @param table - 2D agreement matrix (square, same categories for both raters)
+ * @param weighted - Use weighted kappa with linear weights (default: false)
+ * @returns Object with kappa, se, z, p_value, conf_int_lower, conf_int_upper, weighted
+ * @param {Array<any>} table
+ * @param {boolean | null} [weighted]
+ * @returns {any}
+ */
+export function cohenKappa(table, weighted) {
+    const ret = wasm.cohenKappa(table, isLikeNone(weighted) ? 0xFFFFFF : weighted ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Contingency coefficient.
+ *
+ * @param observed - 2D array of observed counts
+ * @returns Object with estimate
+ * @param {Array<any>} observed
+ * @returns {any}
+ */
+export function contingencyCoefficient(observed) {
+    const ret = wasm.contingencyCoefficient(observed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Cramér's V measure of association.
+ *
+ * @param observed - 2D array of observed counts
+ * @returns Object with estimate (Cramér's V)
+ * @param {Array<any>} observed
+ * @returns {any}
+ */
+export function cramersV(observed) {
+    const ret = wasm.cramersV(observed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * D'Agostino-Pearson K² test for normality.
+ *
+ * Tests normality using both skewness and kurtosis.
+ *
+ * @param x - Sample data as Float64Array
+ * @returns Object with k2_statistic, p_value, skewness_z, kurtosis_z
+ * @param {Float64Array} x
+ * @returns {any}
+ */
+export function dagostinoKSquared(x) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.dagostinoKSquared(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Diebold-Mariano test for comparing forecast accuracy.
+ *
+ * @param e1 - Forecast errors from model 1 as Float64Array
+ * @param e2 - Forecast errors from model 2 as Float64Array
+ * @param lossFunction - Loss function (SquaredError or AbsoluteError)
+ * @param horizon - Forecast horizon (h=1 for 1-step ahead)
+ * @param alternative - Alternative hypothesis direction
+ * @param varEstimator - Variance estimator (Acf or Bartlett)
+ * @returns Object with statistic, p_value, horizon
+ * @param {Float64Array} e1
+ * @param {Float64Array} e2
+ * @param {JsLossFunction} loss_function
+ * @param {number} horizon
+ * @param {JsAlternative} alternative
+ * @param {JsVarEstimator} var_estimator
+ * @returns {any}
+ */
+export function dieboldMariano(e1, e2, loss_function, horizon, alternative, var_estimator) {
+    const ptr0 = passArrayF64ToWasm0(e1, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(e2, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.dieboldMariano(ptr0, len0, ptr1, len1, loss_function, horizon, alternative, var_estimator);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Distance correlation (measures non-linear dependence).
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @returns Object with dcor, dcov, dvar_x, dvar_y, statistic
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @returns {any}
+ */
+export function distanceCorrelation(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.distanceCorrelation(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Distance correlation with permutation test.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param nPermutations - Number of permutations (default: 999)
+ * @param seed - Random seed (optional)
+ * @returns Object with dcor, statistic, p_value
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function distanceCorrelationTest(x, y, n_permutations, seed) {
+    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.distanceCorrelationTest(ptr0, len0, ptr1, len1, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Energy distance two-sample test (multivariate data).
+ *
+ * @param x - First sample as 2D array (each row is an observation)
+ * @param y - Second sample as 2D array
+ * @param nPermutations - Number of permutations (default: 999)
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value, n_permutations
+ * @param {Array<any>} x
+ * @param {Array<any>} y
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function energyDistanceTest(x, y, n_permutations, seed) {
+    const ret = wasm.energyDistanceTest(x, y, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Energy distance two-sample test (1D data).
+ *
+ * Tests if two samples come from the same distribution using energy distance.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param nPermutations - Number of permutations (default: 999)
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value, n_permutations
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function energyDistanceTest1d(x, y, n_permutations, seed) {
+    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.energyDistanceTest1d(ptr0, len0, ptr1, len1, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Fisher's exact test for 2x2 contingency tables.
+ *
+ * @param table - 2x2 contingency table as [[a, b], [c, d]]
+ * @param alternative - Alternative hypothesis direction
+ * @returns Object with odds_ratio, p_value, conf_int_lower, conf_int_upper
+ * @param {Array<any>} table
+ * @param {JsAlternative} alternative
+ * @returns {any}
+ */
+export function fisherExact(table, alternative) {
+    const ret = wasm.fisherExact(table, alternative);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * G-test (likelihood ratio test) for independence.
+ *
+ * @param observed - 2D array of observed counts (contingency table)
+ * @returns Object with statistic, df, p_value, expected frequencies
+ * @param {Array<any>} observed
+ * @returns {any}
+ */
+export function gTest(observed) {
+    const ret = wasm.gTest(observed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @returns {string}
+ */
+export function getVersion() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.getVersion();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Intraclass correlation coefficient.
+ *
+ * @param data - 2D array where rows are subjects and columns are raters
+ * @param iccType - ICC type (ICC1, ICC2, ICC3, ICC1k, ICC2k, ICC3k)
+ * @returns Object with icc, f_value, df1, df2, p_value, conf_int_lower, conf_int_upper
+ * @param {Array<any>} data
+ * @param {JsICCType} icc_type
+ * @returns {any}
+ */
+export function intraclassCorrelation(data, icc_type) {
+    const ret = wasm.intraclassCorrelation(data, icc_type);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Kendall's tau correlation coefficient.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param variant - Tau variant (TauA, TauB, TauC)
+ * @returns Object with estimate, statistic, p_value, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsKendallVariant} variant
+ * @returns {any}
+ */
+export function kendallCorrelation(x, y, variant) {
+    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.kendallCorrelation(ptr0, len0, ptr1, len1, variant);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Kruskal-Wallis H test (non-parametric one-way ANOVA).
+ *
+ * @param groups - Array of groups, each group is a Float64Array
+ * @returns Object with statistic (H), df, p_value
+ * @param {Array<any>} groups
+ * @returns {any}
+ */
+export function kruskalWallis(groups) {
+    const ret = wasm.kruskalWallis(groups);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Mann-Whitney U test (Wilcoxon rank-sum test).
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param alternative - Alternative hypothesis direction
+ * @param continuityCorrectionParam - Whether to apply continuity correction (default: true)
+ * @param exact - Whether to compute exact p-value (default: false)
+ * @param confLevel - Confidence level for Hodges-Lehmann CI (optional)
+ * @param mu - Location shift under H0 (default: 0)
+ * @returns Object with statistic, p_value, estimate, null_value, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsAlternative} alternative
+ * @param {boolean | null} [continuity_correction]
+ * @param {boolean | null} [exact]
+ * @param {number | null} [conf_level]
+ * @param {number | null} [mu]
+ * @returns {any}
+ */
+export function mannWhitneyU(x, y, alternative, continuity_correction, exact, conf_level, mu) {
+    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.mannWhitneyU(ptr0, len0, ptr1, len1, alternative, isLikeNone(continuity_correction) ? 0xFFFFFF : continuity_correction ? 1 : 0, isLikeNone(exact) ? 0xFFFFFF : exact ? 1 : 0, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level, !isLikeNone(mu), isLikeNone(mu) ? 0 : mu);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * McNemar's exact test for paired proportions (small samples).
+ *
+ * @param table - 2x2 paired table as [[a, b], [c, d]]
+ * @returns Object with p_value, b, c
+ * @param {Array<any>} table
+ * @returns {any}
+ */
+export function mcnemarExact(table) {
+    const ret = wasm.mcnemarExact(table);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * McNemar's test for paired proportions.
+ *
+ * @param table - 2x2 paired table as [[a, b], [c, d]]
+ * @param correction - Apply continuity correction (default: true)
+ * @returns Object with statistic, df, p_value
+ * @param {Array<any>} table
+ * @param {boolean | null} [correction]
+ * @returns {any}
+ */
+export function mcnemarTest(table, correction) {
+    const ret = wasm.mcnemarTest(table, isLikeNone(correction) ? 0xFFFFFF : correction ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Maximum Mean Discrepancy two-sample test (multivariate data).
+ *
+ * @param x - First sample as 2D array
+ * @param y - Second sample as 2D array
+ * @param kernel - Kernel type (Gaussian, Laplacian, or Linear)
+ * @param bandwidth - Kernel bandwidth (required for Gaussian and Laplacian)
+ * @param nPermutations - Number of permutations (default: 999)
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value, n_permutations
+ * @param {Array<any>} x
+ * @param {Array<any>} y
+ * @param {JsKernel} kernel
+ * @param {number | null} [bandwidth]
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function mmdTest(x, y, kernel, bandwidth, n_permutations, seed) {
+    const ret = wasm.mmdTest(x, y, kernel, !isLikeNone(bandwidth), isLikeNone(bandwidth) ? 0 : bandwidth, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Maximum Mean Discrepancy two-sample test (1D data).
+ *
+ * Uses median heuristic for bandwidth selection automatically.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param nPermutations - Number of permutations (default: 999)
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value, n_permutations
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function mmdTest1d(x, y, n_permutations, seed) {
+    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.mmdTest1d(ptr0, len0, ptr1, len1, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Model Confidence Set (MCS) procedure.
+ *
+ * Identifies the set of models that contains the best model with a given confidence.
+ *
+ * @param losses - Array of loss value arrays (one per model)
+ * @param alpha - Significance level (default: 0.1)
+ * @param statistic - MCS statistic (TMax or TR)
+ * @param nBootstrap - Number of bootstrap samples (default: 1000)
+ * @param blockLength - Expected block length for stationary bootstrap
+ * @param seed - Random seed (optional)
+ * @returns Object with included_models, excluded_models, p_values, elimination_order
+ * @param {Array<any>} losses
+ * @param {number | null | undefined} alpha
+ * @param {JsMCSStatistic} statistic
+ * @param {number | null | undefined} n_bootstrap
+ * @param {number} block_length
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function modelConfidenceSet(losses, alpha, statistic, n_bootstrap, block_length, seed) {
+    const ret = wasm.modelConfidenceSet(losses, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha, statistic, isLikeNone(n_bootstrap) ? 0x100000001 : (n_bootstrap) >>> 0, block_length, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * MSPE-adjusted SPA test.
+ *
+ * @param benchmarkErrors - Forecast errors from benchmark model as Float64Array
+ * @param modelErrors - Array of forecast error arrays from alternative models
+ * @param nBootstrap - Number of bootstrap samples (default: 1000)
+ * @param blockLength - Expected block length for stationary bootstrap
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value_consistent, p_value_upper
+ * @param {Float64Array} benchmark_errors
+ * @param {Array<any>} model_errors
+ * @param {number | null | undefined} n_bootstrap
+ * @param {number} block_length
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function mspeAdjustedSpa(benchmark_errors, model_errors, n_bootstrap, block_length, seed) {
+    const ptr0 = passArrayF64ToWasm0(benchmark_errors, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mspeAdjustedSpa(ptr0, len0, model_errors, isLikeNone(n_bootstrap) ? 0x100000001 : (n_bootstrap) >>> 0, block_length, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * One-way ANOVA test.
+ *
+ * @param groups - Array of groups, each group is a Float64Array
+ * @param kind - Type of ANOVA (Fisher or Welch)
+ * @returns Object with statistic, df_between, df_within, p_value, SS and MS components
+ * @param {Array<any>} groups
+ * @param {JsAnovaKind} kind
+ * @returns {any}
+ */
+export function oneWayAnova(groups, kind) {
+    const ret = wasm.oneWayAnova(groups, kind);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Partial correlation controlling for confounders.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param z - Array of confounding variables (each as Float64Array)
+ * @returns Object with estimate, statistic, df, p_value
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Array<any>} z
+ * @returns {any}
+ */
+export function partialCorrelation(x, y, z) {
+    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.partialCorrelation(ptr0, len0, ptr1, len1, z);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Pearson correlation coefficient with significance test.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param confLevel - Confidence level for CI (optional, e.g., 0.95)
+ * @returns Object with estimate, statistic, df, p_value, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null} [conf_level]
+ * @returns {any}
+ */
+export function pearsonCorrelation(x, y, conf_level) {
+    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.pearsonCorrelation(ptr0, len0, ptr1, len1, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Permutation t-test.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param alternative - Alternative hypothesis direction
+ * @param nPermutations - Number of permutations (default: 9999)
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_value, n_permutations
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsAlternative} alternative
+ * @param {number | null} [n_permutations]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function permutationTTest(x, y, alternative, n_permutations, seed) {
+    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.permutationTTest(ptr0, len0, ptr1, len1, alternative, isLikeNone(n_permutations) ? 0x100000001 : (n_permutations) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Phi coefficient for 2x2 tables.
+ *
+ * @param table - 2x2 contingency table as [[a, b], [c, d]]
+ * @returns Object with estimate (phi coefficient)
+ * @param {Array<any>} table
+ * @returns {any}
+ */
+export function phiCoefficient(table) {
+    const ret = wasm.phiCoefficient(table);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * One-sample proportion test.
+ *
+ * @param successes - Number of successes
+ * @param trials - Number of trials
+ * @param p0 - Hypothesized probability
+ * @param alternative - Alternative hypothesis direction
+ * @returns Object with statistic, p_value, estimate, conf_int_lower, conf_int_upper
+ * @param {number} successes
+ * @param {number} trials
+ * @param {number} p0
+ * @param {JsAlternative} alternative
+ * @returns {any}
+ */
+export function propTestOne(successes, trials, p0, alternative) {
+    const ret = wasm.propTestOne(successes, trials, p0, alternative);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Two-sample proportion test.
+ *
+ * @param successes1 - Number of successes in group 1
+ * @param trials1 - Number of trials in group 1
+ * @param successes2 - Number of successes in group 2
+ * @param trials2 - Number of trials in group 2
+ * @param alternative - Alternative hypothesis direction
+ * @param correction - Apply Yates' continuity correction (default: false)
+ * @returns Object with statistic, p_value, estimates, conf_int_lower, conf_int_upper
+ * @param {number} successes1
+ * @param {number} trials1
+ * @param {number} successes2
+ * @param {number} trials2
+ * @param {JsAlternative} alternative
+ * @param {boolean | null} [correction]
+ * @returns {any}
+ */
+export function propTestTwo(successes1, trials1, successes2, trials2, alternative, correction) {
+    const ret = wasm.propTestTwo(successes1, trials1, successes2, trials2, alternative, isLikeNone(correction) ? 0xFFFFFF : correction ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Semi-partial (part) correlation.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param z - Array of confounding variables to control for x only (each as Float64Array)
+ * @returns Object with estimate, statistic, df, p_value
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {Array<any>} z
+ * @returns {any}
+ */
+export function semiPartialCorrelation(x, y, z) {
+    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.semiPartialCorrelation(ptr0, len0, ptr1, len1, z);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Shapiro-Wilk test for normality.
+ *
+ * @param x - Sample data as Float64Array
+ * @returns Object with statistic (W) and p_value
+ * @param {Float64Array} x
+ * @returns {any}
+ */
+export function shapiroWilk(x) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.shapiroWilk(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Superior Predictive Ability (SPA) test.
+ *
+ * Tests if a benchmark forecast is not inferior to a set of alternative forecasts.
+ *
+ * @param benchmarkLosses - Loss values from benchmark model as Float64Array
+ * @param modelLosses - Array of loss value arrays from competing models
+ * @param nBootstrap - Number of bootstrap samples (default: 1000)
+ * @param blockLength - Expected block length for stationary bootstrap
+ * @param seed - Random seed (optional)
+ * @returns Object with statistic, p_values, best_model_idx
+ * @param {Float64Array} benchmark_losses
+ * @param {Array<any>} model_losses
+ * @param {number | null | undefined} n_bootstrap
+ * @param {number} block_length
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function spaTest(benchmark_losses, model_losses, n_bootstrap, block_length, seed) {
+    const ptr0 = passArrayF64ToWasm0(benchmark_losses, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.spaTest(ptr0, len0, model_losses, isLikeNone(n_bootstrap) ? 0x100000001 : (n_bootstrap) >>> 0, block_length, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Spearman rank correlation coefficient with significance test.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param confLevel - Confidence level for CI (optional)
+ * @returns Object with estimate, statistic, df, p_value, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null} [conf_level]
+ * @returns {any}
+ */
+export function spearmanCorrelation(x, y, conf_level) {
+    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.spearmanCorrelation(ptr0, len0, ptr1, len1, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+export function start() {
+    wasm.start();
+}
+
+/**
+ * Perform a t-test comparing two samples.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param kind - Type of t-test (Welch, Student, or Paired)
+ * @param alternative - Alternative hypothesis direction
+ * @param mu - Null hypothesis value (default: 0.0)
+ * @param confLevel - Confidence level for CI (optional, e.g., 0.95)
+ * @returns Object with statistic, df, p_value, mean_x, mean_y, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsTTestKind} kind
+ * @param {JsAlternative} alternative
+ * @param {number | null} [mu]
+ * @param {number | null} [conf_level]
+ * @returns {any}
+ */
+export function tTest(x, y, kind, alternative, mu, conf_level) {
+    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.tTest(ptr0, len0, ptr1, len1, kind, alternative, !isLikeNone(mu), isLikeNone(mu) ? 0 : mu, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST using bootstrap resampling.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @param nBootstrap - Number of bootstrap samples (default: 1000)
+ * @param seed - Random seed (optional)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @param {number | null} [n_bootstrap]
+ * @param {bigint | null} [seed]
+ * @returns {any}
+ */
+export function tostBootstrap(x, y, lower_bound, upper_bound, alpha, n_bootstrap, seed) {
+    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.tostBootstrap(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha, isLikeNone(n_bootstrap) ? 0x100000001 : (n_bootstrap) >>> 0, !isLikeNone(seed), isLikeNone(seed) ? BigInt(0) : seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST for correlation equivalence.
+ *
+ * @param x - First variable as Float64Array
+ * @param y - Second variable as Float64Array
+ * @param rhoNull - Null value for correlation (usually 0)
+ * @param lowerBound - Lower equivalence bound for correlation (e.g., -0.1)
+ * @param upperBound - Upper equivalence bound for correlation (e.g., 0.1)
+ * @param method - Correlation method (Pearson or Spearman)
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} rho_null
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {JsCorrelationTostMethod} method
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostCorrelation(x, y, rho_null, lower_bound, upper_bound, method, alpha) {
+    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.tostCorrelation(ptr0, len0, ptr1, len1, rho_null, lower_bound, upper_bound, method, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST for one-sample proportion.
+ *
+ * @param successes - Number of successes
+ * @param trials - Number of trials
+ * @param p0 - Hypothesized proportion
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {number} successes
+ * @param {number} trials
+ * @param {number} p0
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostPropOne(successes, trials, p0, lower_bound, upper_bound, alpha) {
+    const ret = wasm.tostPropOne(successes, trials, p0, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST for two-sample proportions.
+ *
+ * @param successes1 - Successes in group 1
+ * @param trials1 - Trials in group 1
+ * @param successes2 - Successes in group 2
+ * @param trials2 - Trials in group 2
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {number} successes1
+ * @param {number} trials1
+ * @param {number} successes2
+ * @param {number} trials2
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostPropTwo(successes1, trials1, successes2, trials2, lower_bound, upper_bound, alpha) {
+    const ret = wasm.tostPropTwo(successes1, trials1, successes2, trials2, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST t-test for one sample.
+ *
+ * @param x - Sample data as Float64Array
+ * @param mu - Hypothesized mean
+ * @param lowerBound - Lower equivalence bound (e.g., -0.5)
+ * @param upperBound - Upper equivalence bound (e.g., 0.5)
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {number} mu
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostTTestOneSample(x, mu, lower_bound, upper_bound, alpha) {
+    const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.tostTTestOneSample(ptr0, len0, mu, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST t-test for paired samples.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostTTestPaired(x, y, lower_bound, upper_bound, alpha) {
+    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.tostTTestPaired(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST t-test for two independent samples.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @param pooled - Use pooled variance (default: false for Welch)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @param {boolean | null} [pooled]
+ * @returns {any}
+ */
+export function tostTTestTwoSample(x, y, lower_bound, upper_bound, alpha, pooled) {
+    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.tostTTestTwoSample(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha, isLikeNone(pooled) ? 0xFFFFFF : pooled ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST Wilcoxon test for paired samples.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostWilcoxonPaired(x, y, lower_bound, upper_bound, alpha) {
+    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.tostWilcoxonPaired(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST Wilcoxon test for two independent samples.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostWilcoxonTwoSample(x, y, lower_bound, upper_bound, alpha) {
+    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.tostWilcoxonTwoSample(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * TOST Yuen test using trimmed means.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param lowerBound - Lower equivalence bound
+ * @param upperBound - Upper equivalence bound
+ * @param trim - Trim proportion (default: 0.2)
+ * @param alpha - Significance level (default: 0.05)
+ * @returns TOST result object
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number} lower_bound
+ * @param {number} upper_bound
+ * @param {number | null} [trim]
+ * @param {number | null} [alpha]
+ * @returns {any}
+ */
+export function tostYuen(x, y, lower_bound, upper_bound, trim, alpha) {
+    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.tostYuen(ptr0, len0, ptr1, len1, lower_bound, upper_bound, !isLikeNone(trim), isLikeNone(trim) ? 0 : trim, !isLikeNone(alpha), isLikeNone(alpha) ? 0 : alpha);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Wilcoxon signed-rank test.
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array (optional, for paired test)
+ * @param alternative - Alternative hypothesis direction
+ * @param continuityCorrectionParam - Whether to apply continuity correction (default: true)
+ * @param exact - Whether to compute exact p-value (default: false)
+ * @param confLevel - Confidence level for CI (optional)
+ * @param mu - Null hypothesis value (default: 0.0)
+ * @returns Object with statistic, p_value, estimate, null_value, conf_int
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {JsAlternative} alternative
+ * @param {boolean | null} [continuity_correction]
+ * @param {boolean | null} [exact]
+ * @param {number | null} [conf_level]
+ * @param {number | null} [mu]
+ * @returns {any}
+ */
+export function wilcoxonSignedRank(x, y, alternative, continuity_correction, exact, conf_level, mu) {
+    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.wilcoxonSignedRank(ptr0, len0, ptr1, len1, alternative, isLikeNone(continuity_correction) ? 0xFFFFFF : continuity_correction ? 1 : 0, isLikeNone(exact) ? 0xFFFFFF : exact ? 1 : 0, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level, !isLikeNone(mu), isLikeNone(mu) ? 0 : mu);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Yuen's test for trimmed means (robust alternative to t-test).
+ *
+ * @param x - First sample as Float64Array
+ * @param y - Second sample as Float64Array
+ * @param trim - Trim proportion (default: 0.2 for 20% trimming)
+ * @param alternative - Alternative hypothesis direction
+ * @param confLevel - Confidence level for CI (optional)
+ * @returns Object with statistic, df, p_value, diff, trimmed_mean_x, trimmed_mean_y
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {number | null | undefined} trim
+ * @param {JsAlternative} alternative
+ * @param {number | null} [conf_level]
+ * @returns {any}
+ */
+export function yuenTest(x, y, trim, alternative, conf_level) {
+    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.yuenTest(ptr0, len0, ptr1, len1, !isLikeNone(trim), isLikeNone(trim) ? 0 : trim, alternative, !isLikeNone(conf_level), isLikeNone(conf_level) ? 0 : conf_level);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_String_8f0eb39a4a4c2f66: 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_is_function_0095a73b8b156f76: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_cd444516edc5b180: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_8ff4255516ccad3e: 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_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_call_4708e0c13bdc8e95: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_86f2631e91b51511: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_from_bddd64e7d5ff6941: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_getRandomValues_b3f15fcbfabb0f8b: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_length_32ed9a279acd054c: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_35a7bace40f36eac: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_f7386240689107f3: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_d562bbe83e0d4b91: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_361308b2356cecd0: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_3eb36ae241fe6f44: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_d17d15ba1d2042a1: function(arg0) {
+            const ret = new Float64Array(arg0);
+            return ret;
+        },
+        __wbg_new_no_args_1c7c842f08d00ebb: function(arg0, arg1) {
+            const ret = new Function(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_with_length_a2c39cbe88fd8ff1: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_node_e1f24f89a7336c2e: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_process_3975fd6c72f520aa: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_aefe6319f589ab4b: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_randomFillSync_f8c153b79f285817: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b74f47fc2d022fd6: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_set_3f1d0b984ed272ed: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_f43e577aea94465b: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_static_accessor_GLOBAL_12837167ad935116: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_a621d3dfbb60d0ce: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_f8727f0cf888e0bd: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_a96e1fef17ed23cb: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_versions_4e31226f5e8dc909: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: 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,
+        "./anofox_statistics_js_bg.js": import0,
+    };
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+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 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 wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = 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('anofox_statistics_js_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 };