fastlowess-wasm 0.99.8

package/README.md

@@ -0,0 +1,617 @@
+<!-- markdownlint-disable MD024 MD033 -->
+# LOWESS Project
+
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](LICENSE-MIT)
+[![Docs](https://img.shields.io/badge/docs-readthedocs-blue.svg)](https://lowess.readthedocs.io/)
+[![Crates.io](https://img.shields.io/crates/v/lowess.svg)](https://crates.io/crates/lowess)
+[![PyPI](https://img.shields.io/pypi/v/fastlowess.svg)](https://pypi.org/project/fastlowess/)
+[![Conda](https://anaconda.org/conda-forge/fastlowess/badges/version.svg)](https://anaconda.org/conda-forge/fastlowess)
+[![R-universe](https://thisisamirv.r-universe.dev/badges/rfastlowess)](https://thisisamirv.r-universe.dev/rfastlowess)
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/thisisamirv/lowess-project/main/dev/logo.png" alt="One LOWESS to Rule Them All" width="400">
+  <br>
+  <em>One LOWESS to Rule Them All</em>
+</p>
+
+The fastest, most robust, and most feature-complete language-agnostic LOWESS (Locally Weighted Scatterplot Smoothing) implementation for **Rust**, **Python**, **R**, **Julia**, **JavaScript**, **C++**, and **WebAssembly**.
+
+> [!IMPORTANT]
+>
+> The `lowess-project` contains a complete ecosystem for LOWESS smoothing:
+>
+> - **[`lowess`](https://github.com/thisisamirv/lowess-project/tree/main/crates/lowess)** - Core single-threaded Rust implementation with `no_std` support
+> - **[`fastLowess`](https://github.com/thisisamirv/lowess-project/tree/main/crates/fastLowess)** - Parallel CPU and GPU-accelerated Rust wrapper with ndarray integration  
+> - **[`R bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/r)** - extendr-based R package
+> - **[`Python bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/python)** - PyO3-based Python package
+> - **[`Julia bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/julia)** - Native Julia package with C FFI
+> - **[`JavaScript bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/nodejs)** - Node.js package
+> - **[`WebAssembly bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/wasm)** - WASM package
+> - **[`C++ bindings`](https://github.com/thisisamirv/lowess-project/tree/main/bindings/cpp)** - Native C++ package with CMake integration
+
+## LOESS vs. LOWESS
+
+| Feature               | LOESS (This Crate)                | LOWESS                         |
+|-----------------------|-----------------------------------|--------------------------------|
+| **Polynomial Degree** | Linear, Quadratic, Cubic, Quartic | Linear (Degree 1)              |
+| **Dimensions**        | Multivariate (n-D support)        | Univariate (1-D only)          |
+| **Flexibility**       | High (Distance metrics)           | Standard                       |
+| **Complexity**        | Higher (Matrix inversion)         | Lower (Weighted average/slope) |
+
+> [!TIP]
+> **Note:** For a **LOESS** implementation, use [`loess-project`](https://github.com/thisisamirv/loess-project).
+
+---
+
+## Documentation
+
+> [!NOTE]
+>
+> ### 📚 [View the full documentation](https://lowess.readthedocs.io/)
+
+## Why this package?
+
+### Speed
+
+The `lowess` project crushes the competition in terms of speed, wether in single-threaded or multi-threaded parallel execution.
+
+Speedup relative to Python's `statsmodels.lowess` (higher is better):
+
+| Category                        | statsmodels | R (stats) | Serial | Parallel | GPU     |
+|---------------------------------|-------------|-----------|--------|----------|---------|
+| **Clustered**                   | 163ms       | 83×       | 203×   | **433×** | 32×     |
+| **Constant Y**                  | 134ms       | 92×       | 212×   | **410×** | 18×     |
+| **Delta** (large–none)          | 105ms       | 2×        | 4×     | 6×       | **16×** |
+| **Extreme Outliers**            | 489ms       | 106×      | 201×   | **388×** | 29×     |
+| **Financial** (500–10K)         | 106ms       | 105×      | 252×   | **293×** | 12×     |
+| **Fraction** (0.05–0.67)        | 221ms       | 104×      | 228×   | **391×** | 22×     |
+| **Genomic** (1K–50K)            | 1833ms      | 7×        | 9×     | 20×      | **95×** |
+| **High Noise**                  | 435ms       | 133×      | 134×   | **375×** | 32×     |
+| **Iterations** (0–10)           | 204ms       | 115×      | 224×   | **386×** | 18×     |
+| **Scale** (1K–50K)              | 1841ms      | 264×      | 487×   | **581×** | 98×     |
+| **Scientific** (500–10K)        | 167ms       | 109×      | 205×   | **314×** | 15×     |
+| **Scale Large**\* (100K–2M)     | —           | —         | 1×     | **1.4×** | 0.3×    |
+
+\*Scale Large benchmarks are relative to Serial (statsmodels cannot handle these sizes)
+
+*The numbers are the average across a range of scenarios for each category (e.g., Delta from none, to small, medium, and large).*
+
+### Robustness
+
+This implementation is *more robust* than R's `lowess` and Python's `statsmodels` due to two key design choices:
+
+**MAD-Based Scale Estimation:**
+
+For robustness weight calculations, this crate uses *Median Absolute Deviation (MAD)* for scale estimation:
+
+```text
+s = median(|r_i - median(r)|)
+```
+
+In contrast, `statsmodels` and R's `lowess` uses the median of absolute residuals (MAR):
+
+```text
+s = median(|r_i|)
+```
+
+- MAD is a *breakdown-point-optimal* estimator—it remains valid even when up to 50% of data are outliers.
+- The median-centering step removes asymmetric bias from residual distributions.
+- MAD provides consistent outlier detection regardless of whether residuals are centered around zero.
+
+**Boundary Padding:**
+
+This crate applies a range of different *boundary policies* at dataset edges:
+
+- **Extend**: Repeats edge values to maintain local neighborhood size.
+- **Reflect**: Mirrors data symmetrically around boundaries.
+- **Zero**: Pads with zeros (useful for signal processing).
+- **NoBoundary**: Original Cleveland behavior
+
+`statsmodels` and R's `lowess` do not apply boundary padding, which can lead to:
+
+- Biased estimates near boundaries due to asymmetric local neighborhoods.
+- Increased variance at the edges of the smoothed curve.
+
+### Features
+
+A variety of features, supporting a range of use cases:
+
+| Feature              | This package  | statsmodels  | R (stats)    |
+|----------------------|:-------------:|:------------:|:------------:|
+| Kernel               | 7 options     | only Tricube | only Tricube |
+| Robustness Weighting | 3 options     | only Huber   | only Huber   |
+| Scale Estimation     | 2 options     | only MAR     | only MAR     |
+| Boundary Padding     | 4 options     | no padding   | no padding   |
+| Zero Weight Fallback | 3 options     | no           | no           |
+| Auto Convergence     | yes           | no           | no           |
+| Online Mode          | yes           | no           | no           |
+| Streaming Mode       | yes           | no           | no           |
+| Confidence Intervals | yes           | no           | no           |
+| Prediction Intervals | yes           | no           | no           |
+| Cross-Validation     | 2 options     | no           | no           |
+| Parallel Execution   | yes           | no           | no           |
+| GPU Acceleration     | yes*          | no           | no           |
+| `no-std` Support     | yes           | no           | no           |
+
+\* GPU acceleration is currently in beta and may not be available on all platforms.
+
+## Validation
+
+All implementations are **numerical twins** of R's `lowess`:
+
+| Aspect          | Status         | Details                                       |
+|-----------------|----------------|-----------------------------------------------|
+| **Accuracy**    | ✅ EXACT MATCH | Max diff < 1e-12 across all scenarios         |
+| **Consistency** | ✅ PERFECT     | Multiple scenarios pass with strict tolerance |
+| **Robustness**  | ✅ VERIFIED    | Robust smoothing matches R exactly            |
+
+## Installation
+
+Currently available for R, Python, Julia, and Rust:
+
+**R** (from R-universe, recommended):
+
+```r
+install.packages("rfastlowess", repos = "https://thisisamirv.r-universe.dev")
+```
+
+**Python** (from PyPI):
+
+```bash
+pip install fastlowess
+```
+
+Or from conda-forge:
+
+```bash
+conda install -c conda-forge fastlowess
+```
+
+**Rust** (lowess, no_std compatible):
+
+```toml
+[dependencies]
+lowess = "0.99"
+```
+
+**Rust** (fastLowess, parallel + GPU):
+
+```toml
+[dependencies]
+fastLowess = { version = "0.99", features = ["cpu"] }
+```
+
+**Julia** (from Julia General Registry):
+
+```julia
+using Pkg
+Pkg.add("fastLowess")
+```
+
+**Node.js** (from npm):
+
+```bash
+npm install fastlowess
+```
+
+**WebAssembly** (from npm):
+
+```bash
+npm install fastlowess-wasm
+```
+
+Or via CDN:
+
+```html
+<script type="module">
+  import init, { smooth } from 'https://unpkg.com/fastlowess-wasm@latest';
+  await init();
+</script>
+```
+
+**C++** (build from source):
+
+```bash
+make cpp
+# Links against libfastlowess_cpp.so
+```
+
+## Quick Example
+
+**R:**
+
+```r
+library(rfastlowess)
+
+x <- c(1, 2, 3, 4, 5)
+y <- c(2.0, 4.1, 5.9, 8.2, 9.8)
+
+result <- fastlowess(x, y, fraction = 0.5, iterations = 3)
+print(result$y)
+```
+
+**Python:**
+
+```python
+import fastlowess as fl
+import numpy as np
+
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+y = np.array([2.0, 4.1, 5.9, 8.2, 9.8])
+
+result = fl.smooth(x, y, fraction=0.5, iterations=3)
+print(result["y"])
+```
+
+**Rust:**
+
+```rust
+use lowess::prelude::*;
+
+let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
+let y = vec![2.0, 4.1, 5.9, 8.2, 9.8];
+
+let model = Lowess::new()
+    .fraction(0.5)
+    .iterations(3)
+    .adapter(Batch)
+    .build()?;
+
+let result = model.fit(&x, &y)?;
+println!("{}", result);
+```
+
+**Julia:**
+
+```julia
+using fastlowess
+
+x = [1.0, 2.0, 3.0, 4.0, 5.0]
+y = [2.0, 4.1, 5.9, 8.2, 9.8]
+
+result = smooth(x, y, fraction=0.5, iterations=3)
+println(result.y)
+```
+
+**Node.js:**
+
+```javascript
+const { smooth } = require('fastlowess');
+
+const x = [1.0, 2.0, 3.0, 4.0, 5.0];
+const y = [2.0, 4.1, 5.9, 8.2, 9.8];
+
+const result = smooth(x, y, { fraction: 0.5, iterations: 3 });
+console.log(result.y);
+```
+
+**WebAssembly:**
+
+```javascript
+import init, { smooth } from 'fastlowess-wasm';
+
+await init();
+
+const x = new Float64Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+const y = new Float64Array([2.0, 4.1, 5.9, 8.2, 9.8]);
+
+const result = smooth(x, y, { fraction: 0.5, iterations: 3 });
+console.log(result.y);
+```
+
+**C++:**
+
+```cpp
+#include <fastlowess.hpp>
+
+std::vector<double> x = {1.0, 2.0, 3.0, 4.0, 5.0};
+std::vector<double> y = {2.0, 4.1, 5.9, 8.2, 9.8};
+
+fastlowess::LowessOptions options;
+options.fraction = 0.5;
+options.iterations = 3;
+
+auto result = fastlowess::smooth(x, y, options);
+for (double val : result.y_vector()) std::cout << val << " ";
+```
+
+---
+
+## API Reference
+
+**R:**
+
+```r
+fastlowess(
+    x, y,
+    fraction = 0.5,
+    iterations = 3L,
+    delta = 0.01,
+    weight_function = "tricube",
+    robustness_method = "bisquare",
+    zero_weight_fallback = "use_local_mean",
+    boundary_policy = "extend",
+    confidence_intervals = 0.95,
+    prediction_intervals = 0.95,
+    return_diagnostics = TRUE,
+    return_residuals = TRUE,
+    return_robustness_weights = TRUE,
+    cv_fractions = c(0.3, 0.5, 0.7),
+    cv_method = "kfold",
+    cv_k = 5L,
+    auto_converge = 1e-4,
+    parallel = TRUE
+)
+```
+
+**Python:**
+
+```python
+fastlowess.smooth(
+    x, y,
+    fraction=0.5,
+    iterations=3,
+    delta=0.01,
+    weight_function="tricube",
+    robustness_method="bisquare",
+    zero_weight_fallback="use_local_mean",
+    boundary_policy="extend",
+    confidence_intervals=0.95,
+    prediction_intervals=0.95,
+    return_diagnostics=True,
+    return_residuals=True,
+    return_robustness_weights=True,
+    cv_fractions=[0.3, 0.5, 0.7],
+    cv_method="kfold",
+    cv_k=5,
+    auto_converge=1e-4,
+    parallel=True
+)
+```
+
+**Rust:**
+
+```rust
+Lowess::new()
+    .fraction(0.5)              // Smoothing span (0, 1]
+    .iterations(3)              // Robustness iterations
+    .delta(0.01)                // Interpolation threshold
+    .weight_function(Tricube)   // Kernel selection
+    .robustness_method(Bisquare)
+    .zero_weight_fallback(UseLocalMean)
+    .boundary_policy(Extend)
+    .confidence_intervals(0.95)
+    .prediction_intervals(0.95)
+    .return_diagnostics()
+    .return_residuals()
+    .return_robustness_weights()
+    .cross_validate(KFold(5, &[0.3, 0.5, 0.7]).seed(123))
+    .auto_converge(1e-4)
+    .adapter(Batch)             // or Streaming, Online
+    .parallel(true)             // fastLowess only
+    .backend(CPU)               // fastLowess only: CPU or GPU
+    .build()?;
+```
+
+**Julia:**
+
+```julia
+smooth(
+    x, y,
+    fraction=0.5,
+    iterations=3,
+    delta=NaN,  # NaN for auto
+    weight_function="tricube",
+    robustness_method="bisquare",
+    zero_weight_fallback="use_local_mean",
+    boundary_policy="extend",
+    confidence_intervals=0.95,
+    prediction_intervals=0.95,
+    return_diagnostics=true,
+    return_residuals=true,
+    return_robustness_weights=true,
+    cv_fractions=[0.3, 0.5, 0.7],
+    cv_method="kfold",
+    cv_k=5,
+    auto_converge=1e-4,
+    parallel=true
+)
+```
+
+**Node.js:**
+
+```javascript
+smooth(x, y, {
+    fraction: 0.5,
+    iterations: 3,
+    delta: 0.01,
+    weightFunction: "tricube",
+    robustnessMethod: "bisquare",
+    zeroWeightFallback: "use_local_mean",
+    boundaryPolicy: "extend",
+    confidenceIntervals: 0.95,
+    predictionIntervals: 0.95,
+    returnDiagnostics: true,
+    returnResiduals: true,
+    returnRobustnessWeights: true,
+    cvFractions: [0.3, 0.5, 0.7],
+    cvMethod: "kfold",
+    cvK: 5,
+    autoConverge: 1e-4,
+    parallel: true
+})
+```
+
+**WebAssembly:**
+
+```javascript
+smooth(x, y, {
+    fraction: 0.5,
+    iterations: 3,
+    delta: 0.01,
+    weightFunction: "tricube",
+    robustnessMethod: "bisquare",
+    zeroWeightFallback: "use_local_mean",
+    boundaryPolicy: "extend",
+    confidenceIntervals: 0.95,
+    predictionIntervals: 0.95,
+    returnDiagnostics: true,
+    returnResiduals: true,
+    returnRobustnessWeights: true,
+    cvFractions: [0.3, 0.5, 0.7],
+    cvMethod: "kfold",
+    cvK: 5,
+    autoConverge: 1e-4
+})
+```
+
+**C++:**
+
+```cpp
+fastlowess::LowessOptions options;
+options.fraction = 0.5;
+options.iterations = 3;
+options.delta = 0.01;
+options.weight_function = "tricube";
+options.robustness_method = "bisquare";
+options.zero_weight_fallback = "use_local_mean";
+options.boundary_policy = "extend";
+options.confidence_intervals = 0.95;
+options.prediction_intervals = 0.95;
+options.return_diagnostics = true;
+options.return_residuals = true;
+options.return_robustness_weights = true;
+options.cv_fractions = {0.3, 0.5, 0.7};
+options.cv_method = "kfold";
+options.cv_k = 5;
+options.auto_converge = 1e-4;
+options.parallel = true;
+
+auto result = fastlowess::smooth(x, y, options);
+```
+
+## Result Structure
+
+**R:**
+
+```r
+result$x, result$y, result$standard_errors
+result$confidence_lower, result$confidence_upper
+result$prediction_lower, result$prediction_upper
+result$residuals, result$robustness_weights
+result$diagnostics, result$iterations_used
+result$fraction_used, result$cv_scores
+```
+
+**Python:**
+
+```python
+result.x, result.y, result.standard_errors
+result.confidence_lower, result.confidence_upper
+result.prediction_lower, result.prediction_upper
+result.residuals, result.robustness_weights
+result.diagnostics, result.iterations_used
+result.fraction_used, result.cv_scores
+```
+
+**Rust:**
+
+```rust
+pub struct LowessResult<T> {
+    pub x: Vec<T>,                           // Sorted x values
+    pub y: Vec<T>,                           // Smoothed y values
+    pub standard_errors: Option<Vec<T>>,
+    pub confidence_lower: Option<Vec<T>>,
+    pub confidence_upper: Option<Vec<T>>,
+    pub prediction_lower: Option<Vec<T>>,
+    pub prediction_upper: Option<Vec<T>>,
+    pub residuals: Option<Vec<T>>,
+    pub robustness_weights: Option<Vec<T>>,
+    pub diagnostics: Option<Diagnostics<T>>,
+    pub iterations_used: Option<usize>,
+    pub fraction_used: T,
+    pub cv_scores: Option<Vec<T>>,
+}
+```
+
+**Julia:**
+
+```julia
+result.x, result.y, result.standard_errors
+result.confidence_lower, result.confidence_upper
+result.prediction_lower, result.prediction_upper
+result.residuals, result.robustness_weights
+result.diagnostics, result.iterations_used
+result.fraction_used
+```
+
+**Node.js:**
+
+```javascript
+result.x, result.y, result.standardErrors
+result.confidenceLower, result.confidenceUpper
+result.predictionLower, result.predictionUpper
+result.residuals, result.robustnessWeights
+result.diagnostics, result.iterationsUsed
+result.fractionUsed, result.cvScores
+```
+
+**WebAssembly:**
+
+```javascript
+result.x, result.y, result.standardErrors
+result.confidenceLower, result.confidenceUpper
+result.predictionLower, result.predictionUpper
+result.residuals, result.robustnessWeights
+result.diagnostics, result.iterationsUsed
+result.fractionUsed, result.cvScores
+```
+
+**C++:**
+
+```cpp
+result.y_vector()              // std::vector<double>
+result.confidence_lower()      // std::vector<double>
+result.confidence_upper()      // std::vector<double>
+result.prediction_lower()      // std::vector<double>
+result.prediction_upper()      // std::vector<double>
+result.residuals()             // std::vector<double>
+result.robustness_weights()    // std::vector<double>
+result.diagnostics()           // Diagnostics struct
+result.iterations_used()       // size_t
+result.fraction_used()         // double
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please see the [CONTRIBUTING.md](https://github.com/thisisamirv/lowess-project/blob/main/CONTRIBUTING.md) file for more information.
+
+## License
+
+Licensed under either of:
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or <https://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <https://opensource.org/licenses/MIT>)
+
+at your option.
+
+## References
+
+- Cleveland, W.S. (1979). "Robust Locally Weighted Regression and Smoothing Scatterplots". *JASA*.
+- Cleveland, W.S. (1981). "LOWESS: A Program for Smoothing Scatterplots". *The American Statistician*.
+
+## Citation
+
+If you use this software in your research, please cite it using the [CITATION.cff](https://github.com/thisisamirv/lowess-project/blob/main/CITATION.cff) file or the BibTeX entry below:
+
+```bibtex
+@software{lowess_project,
+  author = {Valizadeh, Amir},
+  title = {LOWESS Project: High-Performance Locally Weighted Scatterplot Smoothing},
+  year = {2026},
+  url = {https://github.com/thisisamirv/lowess-project},
+  license = {MIT OR Apache-2.0}
+}
+```

package/fastlowess_wasm.d.ts

@@ -0,0 +1,126 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Diagnostics {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  rmse: number;
+  mae: number;
+  rSquared: number;
+  get aic(): number | undefined;
+  set aic(value: number | null | undefined);
+  get aicc(): number | undefined;
+  set aicc(value: number | null | undefined);
+  get effectiveDf(): number | undefined;
+  set effectiveDf(value: number | null | undefined);
+  residualSd: number;
+}
+
+export class LowessResultWasm {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly diagnostics: Diagnostics | undefined;
+  readonly fractionUsed: number;
+  readonly iterationsUsed: number | undefined;
+  readonly standardErrors: Float64Array | undefined;
+  readonly confidenceLower: Float64Array | undefined;
+  readonly confidenceUpper: Float64Array | undefined;
+  readonly predictionLower: Float64Array | undefined;
+  readonly predictionUpper: Float64Array | undefined;
+  readonly robustnessWeights: Float64Array | undefined;
+  readonly x: Float64Array;
+  readonly y: Float64Array;
+  readonly cvScores: Float64Array | undefined;
+  readonly residuals: Float64Array | undefined;
+}
+
+export class OnlineLowessWasm {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(options: any, online_opts: any);
+  update(x: number, y: number): number | undefined;
+}
+
+export class StreamingLowessWasm {
+  free(): void;
+  [Symbol.dispose](): void;
+  processChunk(x: Float64Array, y: Float64Array): LowessResultWasm;
+  constructor(options: any, streaming_opts: any);
+  finalize(): LowessResultWasm;
+}
+
+export function smooth(x: Float64Array, y: Float64Array, options: any): LowessResultWasm;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_diagnostics_free: (a: number, b: number) => void;
+  readonly __wbg_get_diagnostics_aic: (a: number) => [number, number];
+  readonly __wbg_get_diagnostics_aicc: (a: number) => [number, number];
+  readonly __wbg_get_diagnostics_effectiveDf: (a: number) => [number, number];
+  readonly __wbg_get_diagnostics_mae: (a: number) => number;
+  readonly __wbg_get_diagnostics_rSquared: (a: number) => number;
+  readonly __wbg_get_diagnostics_residualSd: (a: number) => number;
+  readonly __wbg_get_diagnostics_rmse: (a: number) => number;
+  readonly __wbg_lowessresultwasm_free: (a: number, b: number) => void;
+  readonly __wbg_onlinelowesswasm_free: (a: number, b: number) => void;
+  readonly __wbg_set_diagnostics_aic: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_diagnostics_aicc: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_diagnostics_effectiveDf: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_diagnostics_mae: (a: number, b: number) => void;
+  readonly __wbg_set_diagnostics_rSquared: (a: number, b: number) => void;
+  readonly __wbg_set_diagnostics_residualSd: (a: number, b: number) => void;
+  readonly __wbg_set_diagnostics_rmse: (a: number, b: number) => void;
+  readonly __wbg_streaminglowesswasm_free: (a: number, b: number) => void;
+  readonly lowessresultwasm_confidenceLower: (a: number) => any;
+  readonly lowessresultwasm_confidenceUpper: (a: number) => any;
+  readonly lowessresultwasm_cvScores: (a: number) => any;
+  readonly lowessresultwasm_diagnostics: (a: number) => number;
+  readonly lowessresultwasm_fractionUsed: (a: number) => number;
+  readonly lowessresultwasm_iterationsUsed: (a: number) => number;
+  readonly lowessresultwasm_predictionLower: (a: number) => any;
+  readonly lowessresultwasm_predictionUpper: (a: number) => any;
+  readonly lowessresultwasm_residuals: (a: number) => any;
+  readonly lowessresultwasm_robustnessWeights: (a: number) => any;
+  readonly lowessresultwasm_standardErrors: (a: number) => any;
+  readonly lowessresultwasm_x: (a: number) => any;
+  readonly lowessresultwasm_y: (a: number) => any;
+  readonly onlinelowesswasm_new: (a: any, b: any) => [number, number, number];
+  readonly onlinelowesswasm_update: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly smooth: (a: any, b: any, c: any) => [number, number, number];
+  readonly streaminglowesswasm_finalize: (a: number) => [number, number, number];
+  readonly streaminglowesswasm_new: (a: any, b: any) => [number, number, number];
+  readonly streaminglowesswasm_processChunk: (a: number, b: any, c: any) => [number, number, number];
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/fastlowess_wasm.js

@@ -0,0 +1,640 @@
+let wasm;
+
+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);
+}
+
+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 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;
+
+const DiagnosticsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_diagnostics_free(ptr >>> 0, 1));
+
+const LowessResultWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lowessresultwasm_free(ptr >>> 0, 1));
+
+const OnlineLowessWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_onlinelowesswasm_free(ptr >>> 0, 1));
+
+const StreamingLowessWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_streaminglowesswasm_free(ptr >>> 0, 1));
+
+export class Diagnostics {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Diagnostics.prototype);
+        obj.__wbg_ptr = ptr;
+        DiagnosticsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DiagnosticsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_diagnostics_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get rmse() {
+        const ret = wasm.__wbg_get_diagnostics_rmse(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rmse(arg0) {
+        wasm.__wbg_set_diagnostics_rmse(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get mae() {
+        const ret = wasm.__wbg_get_diagnostics_mae(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set mae(arg0) {
+        wasm.__wbg_set_diagnostics_mae(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get rSquared() {
+        const ret = wasm.__wbg_get_diagnostics_rSquared(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set rSquared(arg0) {
+        wasm.__wbg_set_diagnostics_rSquared(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get aic() {
+        const ret = wasm.__wbg_get_diagnostics_aic(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set aic(arg0) {
+        wasm.__wbg_set_diagnostics_aic(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get aicc() {
+        const ret = wasm.__wbg_get_diagnostics_aicc(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set aicc(arg0) {
+        wasm.__wbg_set_diagnostics_aicc(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get effectiveDf() {
+        const ret = wasm.__wbg_get_diagnostics_effectiveDf(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * @param {number | null} [arg0]
+     */
+    set effectiveDf(arg0) {
+        wasm.__wbg_set_diagnostics_effectiveDf(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+    }
+    /**
+     * @returns {number}
+     */
+    get residualSd() {
+        const ret = wasm.__wbg_get_diagnostics_residualSd(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set residualSd(arg0) {
+        wasm.__wbg_set_diagnostics_residualSd(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) Diagnostics.prototype[Symbol.dispose] = Diagnostics.prototype.free;
+
+export class LowessResultWasm {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(LowessResultWasm.prototype);
+        obj.__wbg_ptr = ptr;
+        LowessResultWasmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LowessResultWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lowessresultwasm_free(ptr, 0);
+    }
+    /**
+     * @returns {Diagnostics | undefined}
+     */
+    get diagnostics() {
+        const ret = wasm.lowessresultwasm_diagnostics(this.__wbg_ptr);
+        return ret === 0 ? undefined : Diagnostics.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get fractionUsed() {
+        const ret = wasm.lowessresultwasm_fractionUsed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get iterationsUsed() {
+        const ret = wasm.lowessresultwasm_iterationsUsed(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get standardErrors() {
+        const ret = wasm.lowessresultwasm_standardErrors(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get confidenceLower() {
+        const ret = wasm.lowessresultwasm_confidenceLower(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get confidenceUpper() {
+        const ret = wasm.lowessresultwasm_confidenceUpper(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get predictionLower() {
+        const ret = wasm.lowessresultwasm_predictionLower(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get predictionUpper() {
+        const ret = wasm.lowessresultwasm_predictionUpper(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get robustnessWeights() {
+        const ret = wasm.lowessresultwasm_robustnessWeights(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get x() {
+        const ret = wasm.lowessresultwasm_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get y() {
+        const ret = wasm.lowessresultwasm_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get cvScores() {
+        const ret = wasm.lowessresultwasm_cvScores(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Float64Array | undefined}
+     */
+    get residuals() {
+        const ret = wasm.lowessresultwasm_residuals(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) LowessResultWasm.prototype[Symbol.dispose] = LowessResultWasm.prototype.free;
+
+export class OnlineLowessWasm {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OnlineLowessWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_onlinelowesswasm_free(ptr, 0);
+    }
+    /**
+     * @param {any} options
+     * @param {any} online_opts
+     */
+    constructor(options, online_opts) {
+        const ret = wasm.onlinelowesswasm_new(options, online_opts);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        OnlineLowessWasmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        const ret = wasm.onlinelowesswasm_update(this.__wbg_ptr, x, y);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+}
+if (Symbol.dispose) OnlineLowessWasm.prototype[Symbol.dispose] = OnlineLowessWasm.prototype.free;
+
+export class StreamingLowessWasm {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StreamingLowessWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_streaminglowesswasm_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {LowessResultWasm}
+     */
+    processChunk(x, y) {
+        const ret = wasm.streaminglowesswasm_processChunk(this.__wbg_ptr, x, y);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return LowessResultWasm.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} options
+     * @param {any} streaming_opts
+     */
+    constructor(options, streaming_opts) {
+        const ret = wasm.streaminglowesswasm_new(options, streaming_opts);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        StreamingLowessWasmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {LowessResultWasm}
+     */
+    finalize() {
+        const ret = wasm.streaminglowesswasm_finalize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return LowessResultWasm.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) StreamingLowessWasm.prototype[Symbol.dispose] = StreamingLowessWasm.prototype.free;
+
+/**
+ * @param {Float64Array} x
+ * @param {Float64Array} y
+ * @param {any} options
+ * @returns {LowessResultWasm}
+ */
+export function smooth(x, y, options) {
+    const ret = wasm.smooth(x, y, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return LowessResultWasm.__wrap(ret[0]);
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+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 && EXPECTED_RESPONSE_TYPES.has(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 __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? v : undefined;
+        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+    };
+    imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = 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);
+    };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_from_29a8414a7a7cd19d = function(arg0) {
+        const ret = Array.from(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_length_406f6daaaa453057 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = arg0.length;
+        return ret;
+    };
+    imports.wbg.__wbg_prototypesetcall_d3c4edbb4ef96ca1 = function(arg0, arg1, arg2) {
+        Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_cast_4af8e60a922bcf35 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(Slice(F64)) -> NamedExternref("Float64Array")`.
+        const ret = getArrayF64FromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__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 imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof 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 (typeof 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 (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('fastlowess_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "fastlowess-wasm",
+  "type": "module",
+  "version": "0.99.8",
+  "license": "MIT OR Apache-2.0",
+  "files": [
+    "fastlowess_wasm_bg.wasm",
+    "fastlowess_wasm.js",
+    "fastlowess_wasm.d.ts"
+  ],
+  "main": "fastlowess_wasm.js",
+  "types": "fastlowess_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}