@winm2m/inferential-stats-js 0.1.0

package/dist/stats-worker.js

@@ -0,0 +1,1126 @@
+(function () {
+    'use strict';
+
+    /**
+     * Python code for descriptive statistics functions.
+     * These are executed inside Pyodide in the Web Worker.
+     */
+    const FREQUENCIES_PY = `
+import json
+import pandas as pd
+
+def run_frequencies(data_json, variable):
+    df = pd.DataFrame(json.loads(data_json))
+    series = df[variable]
+    total = len(series)
+    
+    counts = series.value_counts(dropna=False)
+    pcts = series.value_counts(normalize=True, dropna=False) * 100
+    
+    freqs = []
+    cum_pct = 0
+    for val in counts.index:
+        count = int(counts[val])
+        pct = float(pcts[val])
+        cum_pct += pct
+        freqs.append({
+            'value': str(val) if not isinstance(val, (int, float)) else val,
+            'count': count,
+            'percentage': round(pct, 4),
+            'cumulativePercentage': round(cum_pct, 4)
+        })
+    
+    return json.dumps({
+        'variable': variable,
+        'totalCount': total,
+        'frequencies': freqs
+    })
+`;
+    const DESCRIPTIVES_PY = `
+import json
+import pandas as pd
+from scipy import stats as sp_stats
+
+def run_descriptives(data_json, variables_json):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    results = []
+    for var in variables:
+        col = pd.to_numeric(df[var], errors='coerce').dropna()
+        desc = col.describe()
+        results.append({
+            'variable': var,
+            'count': int(desc['count']),
+            'mean': round(float(desc['mean']), 6),
+            'std': round(float(desc['std']), 6),
+            'min': round(float(desc['min']), 6),
+            'max': round(float(desc['max']), 6),
+            'q25': round(float(desc['25%']), 6),
+            'q50': round(float(desc['50%']), 6),
+            'q75': round(float(desc['75%']), 6),
+            'skewness': round(float(sp_stats.skew(col)), 6),
+            'kurtosis': round(float(sp_stats.kurtosis(col)), 6)
+        })
+    
+    return json.dumps({'statistics': results})
+`;
+    const CROSSTABS_PY = `
+import json
+import pandas as pd
+from scipy.stats import chi2_contingency
+import numpy as np
+
+def run_crosstabs(data_json, row_variable, col_variable):
+    df = pd.DataFrame(json.loads(data_json))
+    
+    ct = pd.crosstab(df[row_variable], df[col_variable])
+    chi2, p, dof, expected = chi2_contingency(ct)
+    
+    n = ct.values.sum()
+    k = min(ct.shape) - 1
+    cramers_v = float(np.sqrt(chi2 / (n * k))) if k > 0 else 0
+    
+    row_labels = [str(x) for x in ct.index.tolist()]
+    col_labels = [str(x) for x in ct.columns.tolist()]
+    
+    table = []
+    row_sums = ct.sum(axis=1)
+    col_sums = ct.sum(axis=0)
+    total = ct.values.sum()
+    
+    for i, rl in enumerate(row_labels):
+        for j, cl in enumerate(col_labels):
+            obs = int(ct.iloc[i, j])
+            exp = float(expected[i, j])
+            table.append({
+                'row': rl,
+                'col': cl,
+                'observed': obs,
+                'expected': round(exp, 4),
+                'rowPercentage': round(obs / float(row_sums.iloc[i]) * 100, 4) if row_sums.iloc[i] > 0 else 0,
+                'colPercentage': round(obs / float(col_sums.iloc[j]) * 100, 4) if col_sums.iloc[j] > 0 else 0,
+                'totalPercentage': round(obs / float(total) * 100, 4) if total > 0 else 0
+            })
+    
+    return json.dumps({
+        'rowVariable': row_variable,
+        'colVariable': col_variable,
+        'table': table,
+        'rowLabels': row_labels,
+        'colLabels': col_labels,
+        'chiSquare': round(float(chi2), 6),
+        'degreesOfFreedom': int(dof),
+        'pValue': float(p),
+        'cramersV': round(cramers_v, 6)
+    })
+`;
+
+    /**
+     * Python code for compare means functions.
+     */
+    const TTEST_INDEPENDENT_PY = `
+import json
+import pandas as pd
+import numpy as np
+from scipy import stats
+
+def run_ttest_independent(data_json, variable, group_variable, group1_value, group2_value):
+    df = pd.DataFrame(json.loads(data_json))
+    
+    g1 = pd.to_numeric(df[df[group_variable] == group1_value][variable], errors='coerce').dropna()
+    g2 = pd.to_numeric(df[df[group_variable] == group2_value][variable], errors='coerce').dropna()
+    
+    # Levene's test for equality of variances
+    levene_stat, levene_p = stats.levene(g1, g2)
+    equal_var = levene_p > 0.05
+    
+    # T-test with equal variance
+    t_eq, p_eq = stats.ttest_ind(g1, g2, equal_var=True)
+    # T-test with unequal variance (Welch's)
+    t_uneq, p_uneq = stats.ttest_ind(g1, g2, equal_var=False)
+    
+    mean_diff = float(g1.mean() - g2.mean())
+    
+    # Degrees of freedom
+    df_eq = len(g1) + len(g2) - 2
+    
+    # Welch df
+    s1_sq = g1.var(ddof=1)
+    s2_sq = g2.var(ddof=1)
+    n1, n2 = len(g1), len(g2)
+    num = (s1_sq/n1 + s2_sq/n2)**2
+    denom = (s1_sq/n1)**2/(n1-1) + (s2_sq/n2)**2/(n2-1)
+    df_welch = float(num/denom)
+    
+    # Confidence intervals
+    se_eq = float(np.sqrt(((n1-1)*s1_sq + (n2-1)*s2_sq)/(n1+n2-2) * (1/n1 + 1/n2)))
+    se_uneq = float(np.sqrt(s1_sq/n1 + s2_sq/n2))
+    
+    ci_eq = stats.t.interval(0.95, df_eq, loc=mean_diff, scale=se_eq)
+    ci_uneq = stats.t.interval(0.95, df_welch, loc=mean_diff, scale=se_uneq)
+    
+    def make_result(t_stat, df_val, p_val, ci):
+        return {
+            'tStatistic': round(float(t_stat), 6),
+            'degreesOfFreedom': round(float(df_val), 6),
+            'pValue': float(p_val),
+            'meanDifference': round(mean_diff, 6),
+            'confidenceInterval': [round(float(ci[0]), 6), round(float(ci[1]), 6)],
+            'group1Mean': round(float(g1.mean()), 6),
+            'group1Std': round(float(g1.std(ddof=1)), 6),
+            'group1N': n1,
+            'group2Mean': round(float(g2.mean()), 6),
+            'group2Std': round(float(g2.std(ddof=1)), 6),
+            'group2N': n2
+        }
+    
+    return json.dumps({
+        'leveneTest': {
+            'statistic': round(float(levene_stat), 6),
+            'pValue': float(levene_p),
+            'equalVariance': bool(equal_var)
+        },
+        'equalVariance': make_result(t_eq, df_eq, p_eq, ci_eq),
+        'unequalVariance': make_result(t_uneq, df_welch, p_uneq, ci_uneq)
+    })
+`;
+    const TTEST_PAIRED_PY = `
+import json
+import pandas as pd
+import numpy as np
+from scipy import stats
+
+def run_ttest_paired(data_json, variable1, variable2):
+    df = pd.DataFrame(json.loads(data_json))
+    
+    v1 = pd.to_numeric(df[variable1], errors='coerce').dropna()
+    v2 = pd.to_numeric(df[variable2], errors='coerce').dropna()
+    
+    # Align by index
+    common = v1.index.intersection(v2.index)
+    v1 = v1.loc[common]
+    v2 = v2.loc[common]
+    
+    diff = v1 - v2
+    n = len(diff)
+    
+    t_stat, p_val = stats.ttest_rel(v1, v2)
+    
+    mean_diff = float(diff.mean())
+    std_diff = float(diff.std(ddof=1))
+    se = std_diff / np.sqrt(n)
+    ci = stats.t.interval(0.95, n-1, loc=mean_diff, scale=se)
+    
+    return json.dumps({
+        'tStatistic': round(float(t_stat), 6),
+        'degreesOfFreedom': n - 1,
+        'pValue': float(p_val),
+        'meanDifference': round(mean_diff, 6),
+        'stdDifference': round(std_diff, 6),
+        'confidenceInterval': [round(float(ci[0]), 6), round(float(ci[1]), 6)],
+        'mean1': round(float(v1.mean()), 6),
+        'mean2': round(float(v2.mean()), 6),
+        'n': n
+    })
+`;
+    const ANOVA_ONEWAY_PY = `
+import json
+import pandas as pd
+import numpy as np
+from scipy import stats
+
+def run_anova_oneway(data_json, variable, group_variable):
+    df = pd.DataFrame(json.loads(data_json))
+    
+    groups = df.groupby(group_variable)[variable].apply(
+        lambda x: pd.to_numeric(x, errors='coerce').dropna().tolist()
+    )
+    
+    group_arrays = [np.array(g) for g in groups.values if len(g) > 0]
+    group_names = [str(name) for name, g in zip(groups.index, groups.values) if len(g) > 0]
+    
+    f_stat, p_val = stats.f_oneway(*group_arrays)
+    
+    # Compute detailed ANOVA table
+    grand_mean = np.concatenate(group_arrays).mean()
+    n_total = sum(len(g) for g in group_arrays)
+    k = len(group_arrays)
+    
+    ss_between = sum(len(g) * (g.mean() - grand_mean)**2 for g in group_arrays)
+    ss_within = sum(((g - g.mean())**2).sum() for g in group_arrays)
+    
+    df_between = k - 1
+    df_within = n_total - k
+    
+    ms_between = ss_between / df_between
+    ms_within = ss_within / df_within
+    
+    ss_total = ss_between + ss_within
+    eta_sq = ss_between / ss_total if ss_total > 0 else 0
+    
+    group_stats = []
+    for name, arr in zip(group_names, group_arrays):
+        group_stats.append({
+            'group': name,
+            'n': len(arr),
+            'mean': round(float(arr.mean()), 6),
+            'std': round(float(arr.std(ddof=1)), 6)
+        })
+    
+    return json.dumps({
+        'fStatistic': round(float(f_stat), 6),
+        'pValue': float(p_val),
+        'degreesOfFreedomBetween': df_between,
+        'degreesOfFreedomWithin': df_within,
+        'sumOfSquaresBetween': round(float(ss_between), 6),
+        'sumOfSquaresWithin': round(float(ss_within), 6),
+        'meanSquareBetween': round(float(ms_between), 6),
+        'meanSquareWithin': round(float(ms_within), 6),
+        'groupStats': group_stats,
+        'etaSquared': round(float(eta_sq), 6)
+    })
+`;
+    const POSTHOC_TUKEY_PY = `
+import json
+import pandas as pd
+import numpy as np
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+
+def run_posthoc_tukey(data_json, variable, group_variable, alpha=0.05):
+    df = pd.DataFrame(json.loads(data_json))
+    
+    df[variable] = pd.to_numeric(df[variable], errors='coerce')
+    df = df.dropna(subset=[variable])
+    
+    result = pairwise_tukeyhsd(df[variable], df[group_variable], alpha=alpha)
+    
+    comparisons = []
+    for i in range(len(result.summary().data) - 1):
+        row = result.summary().data[i + 1]
+        comparisons.append({
+            'group1': str(row[0]),
+            'group2': str(row[1]),
+            'meanDifference': round(float(row[2]), 6),
+            'pValue': round(float(row[3]), 6),
+            'lowerCI': round(float(row[4]), 6),
+            'upperCI': round(float(row[5]), 6),
+            'reject': bool(row[6])
+        })
+    
+    return json.dumps({
+        'comparisons': comparisons,
+        'alpha': alpha
+    })
+`;
+
+    /**
+     * Python code for regression analysis functions.
+     */
+    const LINEAR_REGRESSION_PY = `
+import json
+import pandas as pd
+import numpy as np
+import statsmodels.api as sm
+
+def run_linear_regression(data_json, dependent, independents_json, add_constant=True):
+    df = pd.DataFrame(json.loads(data_json))
+    independents = json.loads(independents_json)
+    
+    y = pd.to_numeric(df[dependent], errors='coerce')
+    X = df[independents].apply(pd.to_numeric, errors='coerce')
+    
+    mask = y.notna() & X.notna().all(axis=1)
+    y = y[mask]
+    X = X[mask]
+    
+    if add_constant:
+        X = sm.add_constant(X)
+    
+    model = sm.OLS(y, X).fit()
+    
+    coefficients = []
+    for i, name in enumerate(model.params.index):
+        ci = model.conf_int().iloc[i]
+        coefficients.append({
+            'variable': str(name),
+            'coefficient': round(float(model.params.iloc[i]), 6),
+            'stdError': round(float(model.bse.iloc[i]), 6),
+            'tStatistic': round(float(model.tvalues.iloc[i]), 6),
+            'pValue': float(model.pvalues.iloc[i]),
+            'confidenceInterval': [round(float(ci[0]), 6), round(float(ci[1]), 6)]
+        })
+    
+    dw = float(sm.stats.stattools.durbin_watson(model.resid))
+    
+    return json.dumps({
+        'rSquared': round(float(model.rsquared), 6),
+        'adjustedRSquared': round(float(model.rsquared_adj), 6),
+        'fStatistic': round(float(model.fvalue), 6),
+        'fPValue': float(model.f_pvalue),
+        'coefficients': coefficients,
+        'residualStdError': round(float(np.sqrt(model.mse_resid)), 6),
+        'observations': int(model.nobs),
+        'degreesOfFreedom': int(model.df_resid),
+        'durbinWatson': round(dw, 6)
+    })
+`;
+    const LOGISTIC_BINARY_PY = `
+import json
+import pandas as pd
+import numpy as np
+import statsmodels.api as sm
+
+def run_logistic_binary(data_json, dependent, independents_json, add_constant=True):
+    df = pd.DataFrame(json.loads(data_json))
+    independents = json.loads(independents_json)
+    
+    y = pd.to_numeric(df[dependent], errors='coerce')
+    X = df[independents].apply(pd.to_numeric, errors='coerce')
+    
+    mask = y.notna() & X.notna().all(axis=1)
+    y = y[mask]
+    X = X[mask]
+    
+    if add_constant:
+        X = sm.add_constant(X)
+    
+    model = sm.Logit(y, X).fit(disp=0)
+    
+    coefficients = []
+    ci = model.conf_int()
+    for i, name in enumerate(model.params.index):
+        coef = float(model.params.iloc[i])
+        coefficients.append({
+            'variable': str(name),
+            'coefficient': round(coef, 6),
+            'stdError': round(float(model.bse.iloc[i]), 6),
+            'zStatistic': round(float(model.tvalues.iloc[i]), 6),
+            'pValue': float(model.pvalues.iloc[i]),
+            'oddsRatio': round(float(np.exp(coef)), 6),
+            'confidenceInterval': [round(float(ci.iloc[i, 0]), 6), round(float(ci.iloc[i, 1]), 6)]
+        })
+    
+    return json.dumps({
+        'coefficients': coefficients,
+        'pseudoRSquared': round(float(model.prsquared), 6),
+        'logLikelihood': round(float(model.llf), 6),
+        'llrPValue': float(model.llr_pvalue),
+        'aic': round(float(model.aic), 6),
+        'bic': round(float(model.bic), 6),
+        'observations': int(model.nobs),
+        'convergence': bool(model.mle_retvals['converged'])
+    })
+`;
+    const LOGISTIC_MULTINOMIAL_PY = `
+import json
+import pandas as pd
+import numpy as np
+import statsmodels.api as sm
+
+def run_logistic_multinomial(data_json, dependent, independents_json, reference_category=None):
+    df = pd.DataFrame(json.loads(data_json))
+    independents = json.loads(independents_json)
+    
+    X = df[independents].apply(pd.to_numeric, errors='coerce')
+    y = df[dependent]
+    
+    mask = X.notna().all(axis=1) & y.notna()
+    X = X[mask]
+    y = y[mask]
+    
+    # Encode categories
+    categories = sorted(y.unique().tolist(), key=str)
+    if reference_category is not None:
+        ref = str(reference_category)
+    else:
+        ref = str(categories[0])
+    
+    y_coded = pd.Categorical(y, categories=categories)
+    y_dummies = pd.get_dummies(y_coded, drop_first=False)
+    
+    X_const = sm.add_constant(X)
+    
+    from sklearn.linear_model import LogisticRegression
+    
+    le_map = {str(c): i for i, c in enumerate(categories)}
+    y_numeric = y.map(lambda x: le_map[str(x)])
+    
+    model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
+    model.fit(X, y_numeric)
+    
+    ref_idx = le_map[ref]
+    non_ref_cats = [c for c in categories if str(c) != ref]
+    
+    coefficients = []
+    for cat in non_ref_cats:
+        cat_idx = le_map[str(cat)]
+        for j, var_name in enumerate(independents):
+            coef = float(model.coef_[cat_idx][j] - model.coef_[ref_idx][j])
+            coefficients.append({
+                'category': str(cat),
+                'variable': var_name,
+                'coefficient': round(coef, 6),
+                'stdError': 0.0,
+                'zStatistic': 0.0,
+                'pValue': 0.0,
+                'oddsRatio': round(float(np.exp(coef)), 6),
+                'confidenceInterval': [0.0, 0.0]
+            })
+    
+    # Log-likelihood
+    proba = model.predict_proba(X)
+    ll = float(np.sum(np.log(proba[np.arange(len(y_numeric)), y_numeric] + 1e-10)))
+    n_params = len(non_ref_cats) * (len(independents) + 1)
+    aic = -2 * ll + 2 * n_params
+    bic_val = -2 * ll + n_params * np.log(len(y))
+    
+    return json.dumps({
+        'coefficients': coefficients,
+        'pseudoRSquared': round(float(model.score(X, y_numeric)), 6),
+        'logLikelihood': round(ll, 6),
+        'llrPValue': 0.0,
+        'aic': round(float(aic), 6),
+        'bic': round(float(bic_val), 6),
+        'categories': [str(c) for c in categories],
+        'referenceCategory': ref,
+        'observations': int(len(y))
+    })
+`;
+
+    /**
+     * Python code for classification/clustering functions.
+     */
+    const KMEANS_PY = `
+import json
+import pandas as pd
+import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler
+
+def run_kmeans(data_json, variables_json, k, max_iterations=300, random_state=42):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    X = df[variables].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+    
+    model = KMeans(n_clusters=k, max_iter=max_iterations, random_state=random_state, n_init=10)
+    labels = model.fit_predict(X_scaled)
+    
+    # Transform centers back to original scale
+    centers_original = scaler.inverse_transform(model.cluster_centers_)
+    
+    centers = []
+    for i in range(k):
+        center = {}
+        for j, var in enumerate(variables):
+            center[var] = round(float(centers_original[i, j]), 6)
+        centers.append({'cluster': i, 'center': center})
+    
+    unique, counts = np.unique(labels, return_counts=True)
+    cluster_sizes = {int(u): int(c) for u, c in zip(unique, counts)}
+    
+    return json.dumps({
+        'labels': [int(l) for l in labels],
+        'centers': centers,
+        'inertia': round(float(model.inertia_), 6),
+        'iterations': int(model.n_iter_),
+        'clusterSizes': cluster_sizes
+    })
+`;
+    const HIERARCHICAL_CLUSTER_PY = `
+import json
+import pandas as pd
+import numpy as np
+from scipy.cluster.hierarchy import linkage, fcluster, dendrogram
+from sklearn.preprocessing import StandardScaler
+
+def run_hierarchical_cluster(data_json, variables_json, method='ward', metric='euclidean', n_clusters=None, distance_threshold=None):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    X = df[variables].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+    
+    Z = linkage(X_scaled, method=method, metric=metric)
+    
+    if n_clusters is not None:
+        labels = fcluster(Z, t=n_clusters, criterion='maxclust')
+    elif distance_threshold is not None:
+        labels = fcluster(Z, t=distance_threshold, criterion='distance')
+    else:
+        labels = fcluster(Z, t=3, criterion='maxclust')
+    
+    labels = labels - 1  # 0-indexed
+    
+    unique, counts = np.unique(labels, return_counts=True)
+    cluster_sizes = {int(u): int(c) for u, c in zip(unique, counts)}
+    
+    # Dendrogram data (truncated for large datasets)
+    trunc = min(30, len(X_scaled))
+    dend = dendrogram(Z, truncate_mode='lastp', p=trunc, no_plot=True)
+    
+    return json.dumps({
+        'labels': [int(l) for l in labels],
+        'nClusters': len(unique),
+        'linkageMatrix': [[round(float(x), 6) for x in row] for row in Z.tolist()],
+        'clusterSizes': cluster_sizes,
+        'dendrogramData': {
+            'icoord': [[round(float(x), 4) for x in row] for row in dend['icoord']],
+            'dcoord': [[round(float(x), 4) for x in row] for row in dend['dcoord']],
+            'leaves': [int(x) for x in dend['leaves']]
+        }
+    })
+`;
+
+    /**
+     * Python code for dimension reduction functions.
+     */
+    const EFA_PY = `
+import json
+import pandas as pd
+import numpy as np
+from factor_analyzer import FactorAnalyzer
+from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity, calculate_kmo
+
+def run_efa(data_json, variables_json, n_factors, rotation='varimax', method='minres'):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    X = df[variables].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    # KMO and Bartlett tests
+    kmo_all, kmo_model = calculate_kmo(X)
+    chi2, p_value = calculate_bartlett_sphericity(X)
+    
+    fa = FactorAnalyzer(n_factors=n_factors, rotation=rotation, method=method)
+    fa.fit(X)
+    
+    loadings = fa.loadings_
+    loadings_dict = {}
+    for i, var in enumerate(variables):
+        loadings_dict[var] = [round(float(x), 6) for x in loadings[i]]
+    
+    ev, v = fa.get_factor_variance()
+    
+    communalities = fa.get_communalities()
+    uniquenesses = fa.get_uniquenesses()
+    
+    comm_dict = {}
+    uniq_dict = {}
+    for i, var in enumerate(variables):
+        comm_dict[var] = round(float(communalities[i]), 6)
+        uniq_dict[var] = round(float(uniquenesses[i]), 6)
+    
+    eigenvalues = fa.get_eigenvalues()[0]
+    
+    return json.dumps({
+        'loadings': loadings_dict,
+        'eigenvalues': [round(float(x), 6) for x in eigenvalues],
+        'variance': [round(float(x), 6) for x in ev],
+        'cumulativeVariance': [round(float(sum(v[:i+1])), 6) for i in range(len(v))],
+        'communalities': comm_dict,
+        'uniquenesses': uniq_dict,
+        'nFactors': n_factors,
+        'rotation': rotation,
+        'kmo': round(float(kmo_model), 6),
+        'bartlettChi2': round(float(chi2), 6),
+        'bartlettPValue': float(p_value)
+    })
+`;
+    const PCA_PY = `
+import json
+import pandas as pd
+import numpy as np
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+
+def run_pca(data_json, variables_json, n_components=None, standardize=True):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    X = df[variables].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    if standardize:
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(X)
+    else:
+        X_scaled = X.values
+    
+    if n_components is None:
+        n_components = min(len(variables), len(X_scaled))
+    
+    pca = PCA(n_components=n_components)
+    transformed = pca.fit_transform(X_scaled)
+    
+    loadings = {}
+    for i, var in enumerate(variables):
+        loadings[var] = [round(float(x), 6) for x in pca.components_[:, i]]
+    
+    cum_var = np.cumsum(pca.explained_variance_ratio_)
+    
+    return json.dumps({
+        'components': [[round(float(x), 6) for x in row] for row in transformed.tolist()],
+        'explainedVariance': [round(float(x), 6) for x in pca.explained_variance_],
+        'explainedVarianceRatio': [round(float(x), 6) for x in pca.explained_variance_ratio_],
+        'cumulativeVarianceRatio': [round(float(x), 6) for x in cum_var],
+        'loadings': loadings,
+        'singularValues': [round(float(x), 6) for x in pca.singular_values_],
+        'nComponents': n_components
+    })
+`;
+    const MDS_PY = `
+import json
+import pandas as pd
+import numpy as np
+from sklearn.manifold import MDS
+from sklearn.preprocessing import StandardScaler
+
+def run_mds(data_json, variables_json, n_components=2, metric=True, max_iterations=300, random_state=42):
+    df = pd.DataFrame(json.loads(data_json))
+    variables = json.loads(variables_json)
+    
+    X = df[variables].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+    
+    mds = MDS(n_components=n_components, metric=metric, max_iter=max_iterations, random_state=random_state, normalized_stress='auto')
+    coords = mds.fit_transform(X_scaled)
+    
+    return json.dumps({
+        'coordinates': [[round(float(x), 6) for x in row] for row in coords.tolist()],
+        'stress': round(float(mds.stress_), 6),
+        'nComponents': n_components
+    })
+`;
+
+    /**
+     * Python code for scale/reliability functions.
+     */
+    const CRONBACH_ALPHA_PY = `
+import json
+import pandas as pd
+import numpy as np
+
+def run_cronbach_alpha(data_json, items_json):
+    df = pd.DataFrame(json.loads(data_json))
+    items = json.loads(items_json)
+    
+    X = df[items].apply(pd.to_numeric, errors='coerce').dropna()
+    
+    n_items = len(items)
+    n_obs = len(X)
+    
+    # Compute Cronbach's Alpha
+    item_vars = X.var(ddof=1)
+    total_var = X.sum(axis=1).var(ddof=1)
+    alpha = (n_items / (n_items - 1)) * (1 - item_vars.sum() / total_var)
+    
+    # Standardized alpha (using correlation matrix)
+    corr_matrix = X.corr()
+    mean_r = (corr_matrix.sum().sum() - n_items) / (n_items * (n_items - 1))
+    std_alpha = (n_items * mean_r) / (1 + (n_items - 1) * mean_r)
+    
+    # Item analysis
+    item_analysis = []
+    total_score = X.sum(axis=1)
+    
+    for item in items:
+        item_col = X[item]
+        other_items = [i for i in items if i != item]
+        other_sum = X[other_items].sum(axis=1)
+        
+        # Corrected item-total correlation
+        citc = float(item_col.corr(other_sum))
+        
+        # Alpha if item deleted
+        if len(other_items) > 1:
+            sub_X = X[other_items]
+            sub_vars = sub_X.var(ddof=1)
+            sub_total_var = sub_X.sum(axis=1).var(ddof=1)
+            k = len(other_items)
+            alpha_deleted = (k / (k - 1)) * (1 - sub_vars.sum() / sub_total_var)
+        else:
+            alpha_deleted = 0.0
+        
+        item_analysis.append({
+            'item': item,
+            'itemMean': round(float(item_col.mean()), 6),
+            'itemStd': round(float(item_col.std(ddof=1)), 6),
+            'correctedItemTotalCorrelation': round(citc, 6),
+            'alphaIfItemDeleted': round(float(alpha_deleted), 6)
+        })
+    
+    return json.dumps({
+        'alpha': round(float(alpha), 6),
+        'standardizedAlpha': round(float(std_alpha), 6),
+        'nItems': n_items,
+        'nObservations': n_obs,
+        'itemAnalysis': item_analysis,
+        'interItemCorrelationMean': round(float(mean_r), 6)
+    })
+`;
+
+    /**
+     * Web Worker for Pyodide-based statistical analysis.
+     * Runs Python code in a WASM sandbox for browser-based computations.
+     */
+    // Import Python code strings - these will be inlined by the bundler
+    // For the worker bundle, we import them directly
+    let pyodide = null;
+    /**
+     * Send progress update to main thread
+     */
+    function sendProgress(id, stage, progress, message) {
+        const response = {
+            id,
+            type: 'progress',
+            progress: { stage, progress, message },
+        };
+        self.postMessage(response);
+    }
+    /**
+     * Send result to main thread
+     */
+    function sendResult(id, data) {
+        const response = {
+            id,
+            type: 'result',
+            data,
+        };
+        self.postMessage(response);
+    }
+    /**
+     * Send error to main thread
+     */
+    function sendError(id, error) {
+        const response = {
+            id,
+            type: 'error',
+            error,
+        };
+        self.postMessage(response);
+    }
+    /**
+     * Deserialize ArrayBuffer to JSON string for Python consumption.
+     * Matches the format produced by serializeToBuffer in bridge/serializer.ts.
+     */
+    function bufferToJsonString(buffer) {
+        const view = new DataView(buffer);
+        const headerLength = view.getUint32(0, true);
+        const headerBytes = new Uint8Array(buffer, 4, headerLength);
+        const header = JSON.parse(new TextDecoder().decode(headerBytes));
+        if (header.rowCount === 0)
+            return '[]';
+        const { rowCount, columns } = header;
+        let offset = 4 + headerLength;
+        // Read columns into arrays
+        const columnData = new Map();
+        for (const col of columns) {
+            if (col.dtype === 'string') {
+                const byteLen = rowCount * 4;
+                const indices = new Int32Array(new Uint8Array(buffer, offset, byteLen).slice().buffer);
+                const values = [];
+                for (let i = 0; i < rowCount; i++) {
+                    values.push(col.stringTable[indices[i]]);
+                }
+                columnData.set(col.name, values);
+                offset += byteLen;
+            }
+            else {
+                const byteLen = rowCount * 8;
+                const arr = new Float64Array(new Uint8Array(buffer, offset, byteLen).slice().buffer);
+                const values = Array.from(arr);
+                columnData.set(col.name, values);
+                offset += byteLen;
+            }
+        }
+        // Build row-oriented JSON
+        const rows = [];
+        for (let i = 0; i < rowCount; i++) {
+            const row = {};
+            for (const col of columns) {
+                row[col.name] = columnData.get(col.name)[i];
+            }
+            rows.push(row);
+        }
+        return JSON.stringify(rows);
+    }
+    /**
+     * Initialize Pyodide with required packages
+     */
+    async function initPyodide(id, pyodideUrl) {
+        const totalSteps = 6;
+        let currentStep = 0;
+        const reportStep = (message) => {
+            currentStep++;
+            sendProgress(id, 'init', Math.round((currentStep / totalSteps) * 100), message);
+        };
+        try {
+            // Step 1: Load Pyodide core
+            sendProgress(id, 'init', 0, 'Loading Pyodide WASM runtime...');
+            // Try to load Pyodide - it should be available via importScripts or already loaded
+            if (typeof loadPyodide === 'undefined') {
+                const pyodideCdnUrl = pyodideUrl || 'https://cdn.jsdelivr.net/pyodide/v0.27.5/full/';
+                importScripts(pyodideCdnUrl + 'pyodide.js');
+            }
+            pyodide = await loadPyodide({
+                indexURL: pyodideUrl || 'https://cdn.jsdelivr.net/pyodide/v0.27.5/full/',
+            });
+            reportStep('Pyodide runtime loaded successfully');
+            // Step 2: Install micropip
+            await pyodide.loadPackagesFromImports('import micropip', {
+                messageCallback: (msg) => {
+                    sendProgress(id, 'init', Math.round((currentStep / totalSteps) * 100), `micropip: ${msg}`);
+                }
+            });
+            reportStep('micropip package manager ready');
+            // Step 3: Install pandas and scipy
+            await pyodide.runPythonAsync(`
+import micropip
+await micropip.install(['pandas', 'scipy'])
+    `);
+            reportStep('pandas and scipy installed');
+            // Step 4: Install statsmodels
+            await pyodide.runPythonAsync(`
+import micropip
+await micropip.install('statsmodels')
+    `);
+            reportStep('statsmodels installed');
+            // Step 5: Install scikit-learn
+            await pyodide.runPythonAsync(`
+import micropip
+await micropip.install('scikit-learn')
+    `);
+            reportStep('scikit-learn installed');
+            // Step 6: Install factor_analyzer
+            await pyodide.runPythonAsync(`
+import micropip
+await micropip.install('factor_analyzer')
+    `);
+            reportStep('factor_analyzer installed - all packages ready');
+            sendResult(id, { initialized: true });
+        }
+        catch (err) {
+            sendError(id, `Initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Run a Python analysis function.
+     * Handles proxy cleanup to prevent memory leaks.
+     */
+    async function runAnalysis(id, pythonCode, functionName, args) {
+        if (!pyodide) {
+            sendError(id, 'Pyodide is not initialized. Call init() first.');
+            return;
+        }
+        try {
+            // Load the Python function
+            await pyodide.runPythonAsync(pythonCode);
+            // Build the function call
+            const argsStr = args.map(a => {
+                // If it looks like a raw Python expression (number, bool), pass as-is
+                if (/^[-+]?\d+(\.\d+)?$/.test(a) || a === 'True' || a === 'False' || a === 'None') {
+                    return a;
+                }
+                // Otherwise, wrap as a Python string
+                // Escape backslashes and single quotes
+                const escaped = a.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+                return `'${escaped}'`;
+            }).join(', ');
+            const callCode = `
+import gc
+_result = ${functionName}(${argsStr})
+_result
+`;
+            const result = await pyodide.runPythonAsync(callCode);
+            // Parse the JSON result from Python
+            const resultStr = String(result);
+            const parsed = JSON.parse(resultStr);
+            // Cleanup Python memory
+            await pyodide.runPythonAsync(`
+del _result
+gc.collect()
+`);
+            sendResult(id, parsed);
+        }
+        catch (err) {
+            // Attempt cleanup even on error
+            try {
+                await pyodide.runPythonAsync('import gc; gc.collect()');
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            sendError(id, `Analysis failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Handle incoming messages from main thread
+     */
+    self.onmessage = async (event) => {
+        const { id, type, payload, params } = event.data;
+        try {
+            // Convert ArrayBuffer payload to JSON string if present
+            let dataJson = '[]';
+            if (payload && payload instanceof ArrayBuffer && payload.byteLength > 0) {
+                dataJson = bufferToJsonString(payload);
+            }
+            else if (params?.data) {
+                dataJson = JSON.stringify(params.data);
+            }
+            switch (type) {
+                case 'init':
+                    await initPyodide(id, params?.pyodideUrl);
+                    break;
+                // === Descriptive Statistics ===
+                case 'frequencies':
+                    await runAnalysis(id, FREQUENCIES_PY, 'run_frequencies', [
+                        dataJson,
+                        String(params?.variable ?? '')
+                    ]);
+                    break;
+                case 'descriptives':
+                    await runAnalysis(id, DESCRIPTIVES_PY, 'run_descriptives', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? [])
+                    ]);
+                    break;
+                case 'crosstabs':
+                    await runAnalysis(id, CROSSTABS_PY, 'run_crosstabs', [
+                        dataJson,
+                        String(params?.rowVariable ?? ''),
+                        String(params?.colVariable ?? '')
+                    ]);
+                    break;
+                // === Compare Means ===
+                case 'ttest_independent':
+                    await runAnalysis(id, TTEST_INDEPENDENT_PY, 'run_ttest_independent', [
+                        dataJson,
+                        String(params?.variable ?? ''),
+                        String(params?.groupVariable ?? ''),
+                        String(params?.group1Value ?? ''),
+                        String(params?.group2Value ?? '')
+                    ]);
+                    break;
+                case 'ttest_paired':
+                    await runAnalysis(id, TTEST_PAIRED_PY, 'run_ttest_paired', [
+                        dataJson,
+                        String(params?.variable1 ?? ''),
+                        String(params?.variable2 ?? '')
+                    ]);
+                    break;
+                case 'anova_oneway':
+                    await runAnalysis(id, ANOVA_ONEWAY_PY, 'run_anova_oneway', [
+                        dataJson,
+                        String(params?.variable ?? ''),
+                        String(params?.groupVariable ?? '')
+                    ]);
+                    break;
+                case 'posthoc_tukey':
+                    await runAnalysis(id, POSTHOC_TUKEY_PY, 'run_posthoc_tukey', [
+                        dataJson,
+                        String(params?.variable ?? ''),
+                        String(params?.groupVariable ?? ''),
+                        String(params?.alpha ?? 0.05)
+                    ]);
+                    break;
+                // === Regression ===
+                case 'linear_regression':
+                    await runAnalysis(id, LINEAR_REGRESSION_PY, 'run_linear_regression', [
+                        dataJson,
+                        String(params?.dependentVariable ?? ''),
+                        JSON.stringify(params?.independentVariables ?? []),
+                        String(params?.addConstant !== false ? 'True' : 'False')
+                    ]);
+                    break;
+                case 'logistic_binary':
+                    await runAnalysis(id, LOGISTIC_BINARY_PY, 'run_logistic_binary', [
+                        dataJson,
+                        String(params?.dependentVariable ?? ''),
+                        JSON.stringify(params?.independentVariables ?? []),
+                        String(params?.addConstant !== false ? 'True' : 'False')
+                    ]);
+                    break;
+                case 'logistic_multinomial':
+                    await runAnalysis(id, LOGISTIC_MULTINOMIAL_PY, 'run_logistic_multinomial', [
+                        dataJson,
+                        String(params?.dependentVariable ?? ''),
+                        JSON.stringify(params?.independentVariables ?? []),
+                        params?.referenceCategory != null ? String(params.referenceCategory) : 'None'
+                    ]);
+                    break;
+                // === Classify ===
+                case 'kmeans':
+                    await runAnalysis(id, KMEANS_PY, 'run_kmeans', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? []),
+                        String(params?.k ?? 3),
+                        String(params?.maxIterations ?? 300),
+                        String(params?.randomState ?? 42)
+                    ]);
+                    break;
+                case 'hierarchical_cluster':
+                    await runAnalysis(id, HIERARCHICAL_CLUSTER_PY, 'run_hierarchical_cluster', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? []),
+                        String(params?.method ?? 'ward'),
+                        String(params?.metric ?? 'euclidean'),
+                        params?.nClusters != null ? String(params.nClusters) : 'None',
+                        params?.distanceThreshold != null ? String(params.distanceThreshold) : 'None'
+                    ]);
+                    break;
+                // === Dimension Reduction ===
+                case 'efa':
+                    await runAnalysis(id, EFA_PY, 'run_efa', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? []),
+                        String(params?.nFactors ?? 2),
+                        String(params?.rotation ?? 'varimax'),
+                        String(params?.method ?? 'minres')
+                    ]);
+                    break;
+                case 'pca':
+                    await runAnalysis(id, PCA_PY, 'run_pca', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? []),
+                        params?.nComponents != null ? String(params.nComponents) : 'None',
+                        String(params?.standardize !== false ? 'True' : 'False')
+                    ]);
+                    break;
+                case 'mds':
+                    await runAnalysis(id, MDS_PY, 'run_mds', [
+                        dataJson,
+                        JSON.stringify(params?.variables ?? []),
+                        String(params?.nComponents ?? 2),
+                        String(params?.metric !== false ? 'True' : 'False'),
+                        String(params?.maxIterations ?? 300),
+                        String(params?.randomState ?? 42)
+                    ]);
+                    break;
+                // === Scale ===
+                case 'cronbach_alpha':
+                    await runAnalysis(id, CRONBACH_ALPHA_PY, 'run_cronbach_alpha', [
+                        dataJson,
+                        JSON.stringify(params?.items ?? [])
+                    ]);
+                    break;
+                default:
+                    sendError(id, `Unknown analysis type: ${type}`);
+            }
+        }
+        catch (err) {
+            sendError(id, `Worker error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    // Signal that the worker is ready
+    self.postMessage({ id: '__worker_ready__', type: 'result', data: { ready: true } });
+
+})();
+//# sourceMappingURL=stats-worker.js.map