fastlowess-wasm 0.99.9 → 1.0.0

package/README.md

@@ -1,13 +1,20 @@
 <!-- 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)
-[![npm](https://img.shields.io/npm/v/fastlowess.svg)](https://www.npmjs.com/package/fastlowess)
+<p align="center">
+  <a href="https://crates.io/crates/lowess"><img src="https://img.shields.io/badge/lowess-000000?logo=rust&logoColor=white" alt="lowess"></a>
+  <a href="https://crates.io/crates/fastLowess"><img src="https://img.shields.io/badge/fastLowess-000000?logo=rust&logoColor=white" alt="fastLowess"></a>
+  <a href="https://pypi.org/project/fastlowess/"><img src="https://img.shields.io/badge/PyPI-3775A9?logo=pypi&logoColor=white" alt="PyPI"></a>
+  <a href="https://thisisamirv.r-universe.dev/rfastlowess"><img src="https://img.shields.io/badge/R--universe-276DC3?logo=r&logoColor=white" alt="R-universe"></a>
+  <a href="https://www.npmjs.com/package/fastlowess"><img src="https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white" alt="npm"></a>
+  <a href="https://juliahub.com/ui/Packages/General/fastlowess_jll"><img src="https://img.shields.io/badge/Julia-9558B2?logo=julia&logoColor=white" alt="Julia"></a>
+  <a href="https://www.npmjs.com/package/fastlowess-wasm"><img src="https://img.shields.io/badge/WASM-654FF0?logo=webassembly&logoColor=white" alt="WASM"></a>
+  <a href="https://github.com/thisisamirv/lowess-project/releases/latest"><img src="https://img.shields.io/badge/C++-00599C?logo=cplusplus&logoColor=white" alt="C++"></a>
+  <br>
+  <a href="https://anaconda.org/conda-forge/fastlowess"><img src="https://img.shields.io/badge/fastlowess_(Python)-44A833?logo=anaconda&logoColor=white" alt="fastlowess (Python)"></a>
+  <a href="https://anaconda.org/conda-forge/libfastlowess"><img src="https://img.shields.io/badge/libfastlowess_(C++)-44A833?logo=anaconda&logoColor=white" alt="libfastlowess (C++)"></a>
+  <a href="https://anaconda.org/conda-forge/r-rfastlowess"><img src="https://img.shields.io/badge/rfastlowess_(R)-44A833?logo=anaconda&logoColor=white" alt="rfastlowess (R)"></a>
+</p>
 
 <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">
@@ -21,14 +28,30 @@ The fastest, most robust, and most feature-complete language-agnostic LOWESS (Lo
 >
 > 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
+> - **[`lowess`](https://crates.io/crates/lowess)** - Core single-threaded Rust implementation with `no_std` support
+> - **[`fastLowess`](https://crates.io/crates/fastLowess)** - Parallel CPU and GPU-accelerated Rust wrapper with ndarray integration  
+> - **[`R bindings`](https://thisisamirv.r-universe.dev/rfastlowess)** - extendr-based R binding
+> - **[`Python bindings`](https://pypi.org/project/fastlowess/)** - PyO3-based Python binding
+> - **[`Julia bindings`](https://juliahub.com/ui/Packages/General/fastlowess_jll)** - Native Julia binding with C FFI
+> - **[`JavaScript bindings`](https://www.npmjs.com/package/fastlowess)** - Node.js binding
+> - **[`WebAssembly bindings`](https://www.npmjs.com/package/fastlowess-wasm)** - WASM binding
+> - **[`C++ bindings`](https://github.com/thisisamirv/lowess-project/releases/latest)** - Native C++ binding with CMake integration
+
+---
+
+## Installation
+
+> [!NOTE]
+>
+> Currently available for R, Python, Rust, Julia, Node.js, WebAssembly, and C++. See [INSTALLATION.md](https://github.com/thisisamirv/lowess-project/blob/main/INSTALLATION.md) for detailed installation instructions.
+
+## Documentation
+
+> [!NOTE]
+>
+> ### 📚 [View the full documentation](https://lowess.readthedocs.io/)
+
+---
 
 ## LOESS vs. LOWESS
 
@@ -44,38 +67,13 @@ The fastest, most robust, and most feature-complete language-agnostic LOWESS (Lo
 
 ---
 
-## 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×    |
+The `lowess` project beats the competition in terms of speed, whether in single-threaded or multi-threaded parallel execution. It is on average **200-327x faster** than Python's `statsmodels.lowess` and **2-3x faster** than R's `lowess`.
 
-\*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).*
+For more details on the performance comparison, see the [BENCHMARKS](https://github.com/thisisamirv/lowess-project/blob/main/BENCHMARKS.md) file.
 
 ### Robustness
 
@@ -146,182 +144,6 @@ All implementations are **numerical twins** of R's `lowess`:
 | **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)
-
-model <- Lowess(fraction = 0.5, iterations = 3)
-result <- model$fit(x, y)
-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 = fit(Lowess(fraction=0.5, iterations=3), x, y)
-println(result.y)
-```
-
-**Node.js:**
-
-```javascript
-const { Lowess } = 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 model = new Lowess({ fraction: 0.5, iterations: 3 });
-const result = model.fit(x, y);
-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;
-
-fastlowess::Lowess model(options);
-auto result = model.fit(x, y);
-
-for (double val : result.y_vector()) std::cout << val << " ";
-```
-
----
-
 ## API Reference
 
 **R:**
@@ -346,13 +168,29 @@ Lowess(
     auto_converge = 1e-4,
     parallel = TRUE
 )$fit(x, y)
+
+# Result structure:
+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
-fastlowess.smooth(
-    x, y,
+from fastlowess import Lowess
+
+model = Lowess(
     fraction=0.5,
     iterations=3,
     delta=0.01,
@@ -371,16 +209,32 @@ fastlowess.smooth(
     auto_converge=1e-4,
     parallel=True
 )
+result = model.fit(x, y)
+
+# Result structure:
+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
 Lowess::new()
-    .fraction(0.5)              // Smoothing span (0, 1]
-    .iterations(3)              // Robustness iterations
-    .delta(0.01)                // Interpolation threshold
-    .weight_function(Tricube)   // Kernel selection
+    .fraction(0.5)
+    .iterations(3)
+    .delta(0.01)
+    .weight_function(Tricube)
     .robustness_method(Bisquare)
     .zero_weight_fallback(UseLocalMean)
     .boundary_policy(Extend)
@@ -391,10 +245,29 @@ Lowess::new()
     .return_robustness_weights()
     .cross_validate(KFold(5, &[0.3, 0.5, 0.7]).seed(123))
     .auto_converge(1e-4)
-    .adapter(Batch)             // or Streaming, Online
+    .adapter(Batch)
     .parallel(true)             // fastLowess only
     .backend(CPU)               // fastLowess only: CPU or GPU
     .build()?;
+
+let result = model.fit(x, y);
+
+// Result structure:
+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:**
@@ -419,6 +292,21 @@ Lowess(;
     auto_converge=NaN,
     parallel=true
 )
+
+# Result structure:
+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
 ```
 
 **Node.js:**
@@ -443,6 +331,21 @@ new Lowess({
     autoConverge: 1e-4,
     parallel: true
 }).fit(x, y)
+
+// Result structure:
+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:**
@@ -464,8 +367,24 @@ smooth(x, y, {
     cvFractions: [0.3, 0.5, 0.7],
     cvMethod: "kfold",
     cvK: 5,
-    autoConverge: 1e-4
+    autoConverge: 1e-4,
+    parallel: true
 })
+
+// Result structure:
+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++:**
@@ -492,98 +411,21 @@ options.parallel = true;
 
 fastlowess::Lowess model(options);
 auto result = model.fit(x, y);
-```
-
-## 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
+// Result structure:
+result.x_vector(),
+result.y_vector(),
+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()
 ```
 
 ---
@@ -594,17 +436,7 @@ Contributions are welcome! Please see the [CONTRIBUTING.md](https://github.com/t
 
 ## 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*.
+Licensed under [MIT](https://github.com/thisisamirv/lowess-project/blob/main/LICENSE-MIT) or [Apache-2.0](https://github.com/thisisamirv/lowess-project/blob/main/LICENSE-APACHE).
 
 ## Citation
 

package/fastlowess_wasm.d.ts

@@ -36,21 +36,43 @@ export class LowessResultWasm {
     readonly y: Float64Array;
 }
 
+/**
+ * Online LOWESS smoother.
+ */
 export class OnlineLowessWasm {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Create a new online smoother.
+     */
     constructor(options: any, online_opts: any);
     update(x: number, y: number): number | undefined;
 }
 
+/**
+ * Streaming LOWESS smoother.
+ */
 export class StreamingLowessWasm {
     free(): void;
     [Symbol.dispose](): void;
     finalize(): LowessResultWasm;
+    /**
+     * Create a new streaming smoother.
+     */
     constructor(options: any, streaming_opts: any);
     processChunk(x: Float64Array, y: Float64Array): LowessResultWasm;
 }
 
+export function init_panic_hook(): void;
+
+/**
+ * Fit the LOWESS model to data.
+ *
+ * @param {Float64Array} x - X coordinates.
+ * @param {Float64Array} y - Y coordinates.
+ * @param {any} [options] - Configuration object.
+ * @returns {LowessResultWasm} The result of the smoothing.
+ */
 export function smooth(x: Float64Array, y: Float64Array, options: any): LowessResultWasm;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -94,11 +116,13 @@ export interface InitOutput {
     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 init_panic_hook: () => void;
     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 __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;
 }

package/fastlowess_wasm.js

@@ -224,6 +224,9 @@ export class LowessResultWasm {
 }
 if (Symbol.dispose) LowessResultWasm.prototype[Symbol.dispose] = LowessResultWasm.prototype.free;
 
+/**
+ * Online LOWESS smoother.
+ */
 export class OnlineLowessWasm {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -236,6 +239,7 @@ export class OnlineLowessWasm {
         wasm.__wbg_onlinelowesswasm_free(ptr, 0);
     }
     /**
+     * Create a new online smoother.
      * @param {any} options
      * @param {any} online_opts
      */
@@ -263,6 +267,9 @@ export class OnlineLowessWasm {
 }
 if (Symbol.dispose) OnlineLowessWasm.prototype[Symbol.dispose] = OnlineLowessWasm.prototype.free;
 
+/**
+ * Streaming LOWESS smoother.
+ */
 export class StreamingLowessWasm {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -285,6 +292,7 @@ export class StreamingLowessWasm {
         return LowessResultWasm.__wrap(ret[0]);
     }
     /**
+     * Create a new streaming smoother.
      * @param {any} options
      * @param {any} streaming_opts
      */
@@ -312,7 +320,17 @@ export class StreamingLowessWasm {
 }
 if (Symbol.dispose) StreamingLowessWasm.prototype[Symbol.dispose] = StreamingLowessWasm.prototype.free;
 
+export function init_panic_hook() {
+    wasm.init_panic_hook();
+}
+
 /**
+ * Fit the LOWESS model to data.
+ *
+ * @param {Float64Array} x - X coordinates.
+ * @param {Float64Array} y - Y coordinates.
+ * @param {any} [options] - Configuration object.
+ * @returns {LowessResultWasm} The result of the smoothing.
  * @param {Float64Array} x
  * @param {Float64Array} y
  * @param {any} options
@@ -329,19 +347,65 @@ export function smooth(x, y, options) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_Number_04624de7d0e8332d: function(arg0) {
+            const ret = Number(arg0);
+            return ret;
+        },
+        __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2: function(arg0, arg1) {
+            const v = arg1;
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
+        __wbg___wbindgen_debug_string_0bc8482c6e3508ae: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_47fa6863be6f2f25: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_31b12575b56f32fc: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_0095a73b8b156f76: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
         __wbg___wbindgen_is_null_ac34f5003991759a: function(arg0) {
             const ret = arg0 === null;
             return ret;
         },
+        __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_9e4d92534c42d778: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
+        __wbg___wbindgen_jsval_eq_11888390b0186270: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
         __wbg___wbindgen_number_get_8ff4255516ccad3e: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -359,10 +423,25 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_from_bddd64e7d5ff6941: function(arg0) {
-            const ret = Array.from(arg0);
+        __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_done_57b39ecd9addfe81: function(arg0) {
+            const ret = arg0.done;
             return ret;
         },
+        __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
         __wbg_get_9b94d73e6221f75c: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -371,6 +450,46 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_get_with_ref_key_1dc361bd10053bfe: function(arg0, arg1) {
+            const ret = arg0[arg1];
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_9b9075935c74707c: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_d314bb98fcf08331: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_isSafeInteger_bfbc7332a9768d2a: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_6ff6560ca1568e55: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_32ed9a279acd054c: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_35a7bace40f36eac: function(arg0) {
             const ret = arg0.length;
             return ret;
@@ -379,9 +498,39 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_new_8a6f238a6ece86ea: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_new_dd2b680c8bf6ae29: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_next_3482f54c49e8af19: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_next_418f80d8f5303233: function(arg0) {
+            const ret = arg0.next;
+            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_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_value_0546255b415e96c1: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(F64)) -> NamedExternref("Float64Array")`.
             const ret = getArrayF64FromWasm0(arg0, arg1);
@@ -392,6 +541,11 @@ function __wbg_get_imports() {
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_cast_0000000000000003: 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);
@@ -427,11 +581,81 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function 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)) {

package/package.json

@@ -5,7 +5,7 @@
     "Amir Valizadeh <thisisamirv@gmail.com>"
   ],
   "description": "High-performance LOWESS (Locally Weighted Scatterplot Smoothing)",
-  "version": "0.99.9",
+  "version": "1.0.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",