@iyulab/u-numflow 0.8.0 → 0.10.0

package/README.md

@@ -16,13 +16,14 @@ u-numflow provides foundational mathematical, statistical, and probabilistic bui
 | Module | Description |
 |--------|-------------|
 | `stats` | Descriptive statistics (mean, variance, skewness, kurtosis) with Welford's online algorithm and Neumaier summation |
-| `distributions` | Probability distributions: Uniform, Triangular, PERT, Normal, LogNormal |
+| `distributions` | Probability distributions: Uniform, Triangular, PERT, Normal, LogNormal, Weibull, Exponential, Gamma, Beta, χ² |
 | `special` | Special functions: normal CDF and tail-precise survival function (and their inverses), t/F/chi² CDF and quantiles, the noncentral t CDF (Lenth AS 243 — the distribution power is computed from), regularized incomplete beta/gamma, erf |
 | `transforms` | Data transformations: Box-Cox (λ via MLE golden-section search), inverse Box-Cox |
 | `fourier` | Discrete Fourier transform of any length (radix-2 for powers of two, Bluestein otherwise): `fft`, `ifft`, `rfft`, `Complex` |
 | `matrix` | Dense matrix operations: determinant, inverse, Cholesky decomposition, Jacobi eigenvalue decomposition |
 | `random` | Seeded RNG, Fisher-Yates shuffle, weighted sampling, random subset selection |
-| `collections` | Specialized data structures: Union-Find with path compression and union-by-rank |
+| `distributions::Sample` | Random variates from every continuous distribution — `sample(&mut rng)` and reproducible `sample_n(n, seed)`; inversion where the quantile is direct, Marsaglia–Tsang for the gamma family (Gamma, χ², Beta, PERT); uniforms from the open interval (0, 1), so no variate is infinite |
+| `collections` | Specialized data structures: Union-Find with path compression and union-by-rank; `IntervalSet` — unions of half-open intervals with union, intersection, difference, clip and a measure that counts overlapping input once |
 
 ## Design Philosophy
 
@@ -34,7 +35,7 @@ u-numflow provides foundational mathematical, statistical, and probabilistic bui
 
 ```toml
 [dependencies]
-u-numflow = "0.8"
+u-numflow = "0.10"
 ```
 
 ```rust
@@ -49,11 +50,14 @@ for x in [1.0, 2.0, 3.0, 4.0, 5.0] {
 }
 assert_eq!(stats.mean(), Some(3.0));
 
-// PERT distribution: moments and quantiles; sample by inverting a uniform draw
+// PERT distribution: moments, quantiles and reproducible samples
+use u_numflow::distributions::Sample;
 let pert = Pert::new(1.0, 4.0, 7.0).unwrap();
 assert_eq!(pert.mean(), 4.0);
 let p90 = pert.quantile(0.9).unwrap();
 assert!(p90 > 4.0 && p90 < 7.0);
+let draws = pert.sample_n(1000, 7); // same (n, seed), same draws
+assert!(draws.iter().all(|&x| (1.0..=7.0).contains(&x)));
 
 // Seeded shuffling for reproducibility
 let mut rng = create_rng(42);
@@ -72,8 +76,22 @@ use u_numflow::fourier::rfft;
 let signal: Vec<f64> = (0..30).map(|j| (2.0 * std::f64::consts::PI * 3.0 * j as f64 / 30.0).sin()).collect();
 let spectrum = rfft(&signal);           // 30 complex bins; bin 3 carries the energy
 assert!(spectrum[3].norm() > 14.0);
+
+// Interval sets: overlapping stops are down-time once, not twice
+use u_numflow::collections::IntervalSet;
+let planned = IntervalSet::from_intervals([(0.0, 24.0)]).unwrap();
+let unplanned = IntervalSet::from_intervals([(10.0, 30.0)]).unwrap();
+let week = IntervalSet::from_intervals([(0.0, 168.0)]).unwrap();
+let up = week.difference(&planned.union(&unplanned));
+assert_eq!(up.measure(), 138.0);
 ```
 
+`IntervalSet<T>` works over `f32`, `f64` and every primitive integer type. Its
+measure has the type of a distance — the unsigned type of the same width for
+integers (as `i64::abs_diff` returns `u64`), so it cannot overflow. A reversed
+interval (`start > end`) or a NaN/infinite bound is refused with its position,
+never swapped or dropped.
+
 ## Build & Test
 
 ```bash
@@ -83,13 +101,24 @@ cargo test
 
 ## Dependencies
 
-- `rand` 0.9 — Random number generation
+- `rand` 0.10 — Random number generation
 - `proptest` 1.4 — Property-based testing (dev only)
 
 ## License
 
 MIT License — see [LICENSE](LICENSE).
 
+## .NET (NuGet)
+
+```bash
+dotnet add package UNumflow
+```
+
+The distributions (CDF, quantile, moments, seeded sampling) and interval sets,
+backed by this crate through its C ABI (the `ffi` feature) — see
+[bindings/csharp/README.md](bindings/csharp/README.md). Refusals carry the same
+`code` and fields as the WebAssembly binding's.
+
 ## npm (WebAssembly)
 
 ```bash
@@ -137,6 +166,50 @@ const { t_distribution_quantile } = require("@iyulab/u-numflow");
 t_distribution_quantile(0.975, 10); // 2.2281…
 ```
 
+Any of the crate's distributions by specification — `distribution` is an object
+`{ kind, ...parameters }`, declared as the union type `DistributionSpec`:
+
+| `kind` | Parameters |
+|---|---|
+| `uniform` | `min`, `max` |
+| `triangular` | `min`, `mode`, `max` |
+| `pert` | `min`, `mode`, `max`, `lambda?` (default 4) |
+| `normal` / `lognormal` | `mu`, `sigma` |
+| `weibull` | `shape`, `scale` |
+| `exponential` | `rate` |
+| `gamma` | `shape`, `rate` |
+| `beta` | `alpha`, `beta` |
+| `chi_squared` | `k` |
+
+| Function | Returns |
+|---|---|
+| `distribution_cdf(distribution, x)` | `P(X ≤ x)` |
+| `distribution_quantile(distribution, p)` | `x` with `P(X ≤ x) = p`, `p` strictly inside (0, 1) |
+| `distribution_sample(distribution, n, seed)` | `Float64Array` of `n` variates — the same `(distribution, n, seed)` always gives the same values |
+
+```js
+const { distribution_quantile, distribution_sample } = require("@iyulab/u-numflow");
+distribution_quantile({ kind: "chi_squared", k: 4 }, 0.95);              // 9.4877…
+const lives = distribution_sample({ kind: "weibull", shape: 2, scale: 100 }, 1000, 42);
+console.log(lives.length);                                                // 1000
+```
+
+Interval sets — each argument is a `[start, end][]` of half-open intervals, and every
+result is in normal form (sorted, disjoint, touching pieces merged, empty ones dropped):
+
+| Function | Returns |
+|---|---|
+| `interval_normalize(intervals)` | The union of `intervals`, as `[number, number][]` |
+| `interval_measure(intervals)` | Its total length — each point counted once, however many rows cover it |
+| `interval_union(a, b)` / `interval_intersection(a, b)` / `interval_difference(a, b)` | Set operations, as `[number, number][]`; clip to a window with `interval_intersection(a, [[from, to]])` |
+
+```js
+const { interval_union, interval_difference, interval_measure } = require("@iyulab/u-numflow");
+const down = interval_union([[0, 24]], [[10, 30]]);       // [[0, 30]] — the overlap counts once
+const up = interval_difference([[0, 168]], down);          // [[30, 168]]
+console.log(interval_measure(up));                         // 138
+```
+
 **Errors.** A refusal throws an `Error` whose `message` is readable text and which
 carries a `code` naming the reason, next to the values behind it:
 
@@ -151,14 +224,17 @@ try {
 
 | `code` | Fields | Meaning |
 |---|---|---|
-| `parameter_out_of_range` | `parameter`, `min`, `max` (or `null`), `got` | `p` not strictly inside (0, 1), or a degrees of freedom that is not a finite number `> 0` (both bounds excluded) |
-| `malformed_input` | `parameter`, `index` (or absent) | A `data` argument that is not an array or `Float64Array`, or an element that is not a number |
-| `value_not_finite` | `parameter`, `index` for an array element | A NaN argument, or a NaN or infinity in any `data` array |
+| `parameter_out_of_range` | `parameter`, `min`, `max` (or `null`), `got` | `p` not strictly inside (0, 1), or a degrees of freedom that is not a finite number `> 0` (both bounds excluded); a distribution parameter that must be `> 0` (`parameter` is its path, e.g. `distribution.sigma`); `n` or `seed` not a whole number in range |
+| `unknown_option` | `parameter`, `got`, `expected` | A `distribution.kind` the crate does not have |
+| `invalid_option` | `parameter` | Distribution parameters out of order: `min < max`, `min ≤ mode ≤ max` |
+| `malformed_input` | `parameter`, `index` (or absent) | A `data` argument that is not an array or `Float64Array`, or an element that is not a number; a `distribution` that is not an object with a string `kind`, lacks a parameter or has one its kind does not take; an interval row that is not two numbers (`parameter` is its path, e.g. `a[2]`) |
+| `reversed_interval` | `parameter`, `index` | An interval row with start > end — refused, not swapped |
+| `value_not_finite` | `parameter`, `index` for an array element | A NaN argument, or a NaN or infinity in any `data` array or interval row (`parameter` is the row's path) |
 | `empty_input` | `parameter` | `mean` of no values |
-| `non_positive_data` | — | Box-Cox data with a value `≤ 0` |
-| `insufficient_data` | `parameter`, `min`, `got` for `std_dev`/`variance`; — for Box-Cox | Fewer values than the function needs (`std_dev`/`variance` 2, Box-Cox 2) |
+| `non_positive_data` | `parameter`, `index`, `got` | Box-Cox data with a value `≤ 0` — `index` is the first such value |
+| `insufficient_data` | `parameter`, `min`, `got` | Fewer values than the function needs (`std_dev`/`variance` 2, Box-Cox 2) |
 | `invalid_transform` | — | A Box-Cox result that is not finite |
-| `invalid_lambda_range` | — | `estimate_lambda` bounds that are not finite with `lambda_min < lambda_max` |
+| `invalid_lambda_range` | `parameter`, `min`, `max` | `estimate_lambda` bounds that are not finite with `lambda_min < lambda_max` (`min`/`max` are the bounds given) |
 
 ### TypeScript
 

package/node/u_numflow.cjs

@@ -61,6 +61,91 @@ function chi_squared_quantile(p, k) {
 }
 exports.chi_squared_quantile = chi_squared_quantile;
 
+/**
+ * `P(X ≤ x)` for the distribution `{ kind, ...parameters }`.
+ *
+ * # Errors
+ * As every `distribution` argument: `malformed_input` for a value that is
+ * not such an object, `unknown_option` for an unknown `kind` (with
+ * `expected`), `value_not_finite` for a NaN or infinite parameter,
+ * `parameter_out_of_range` for a parameter that must be `> 0`, and
+ * `invalid_option` for parameters out of order (`min < max`,
+ * `min ≤ mode ≤ max`). `x` NaN throws `value_not_finite`.
+ * @param {DistributionSpec} distribution
+ * @param {number} x
+ * @returns {number}
+ */
+function distribution_cdf(distribution, x) {
+    const ret = wasm.distribution_cdf(distribution, x);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.distribution_cdf = distribution_cdf;
+
+/**
+ * Mean and variance of `distribution` — also the way to check a
+ * specification before using it.
+ *
+ * # Errors
+ * As [`distribution_cdf`] for `distribution`.
+ * @param {DistributionSpec} distribution
+ * @returns {MomentsDto}
+ */
+function distribution_moments(distribution) {
+    const ret = wasm.distribution_moments(distribution);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.distribution_moments = distribution_moments;
+
+/**
+ * The `x` with `P(X ≤ x) = p`.
+ *
+ * # Errors
+ * As [`distribution_cdf`] for `distribution`; `p` outside `(0, 1)` throws
+ * `parameter_out_of_range`.
+ * @param {DistributionSpec} distribution
+ * @param {number} p
+ * @returns {number}
+ */
+function distribution_quantile(distribution, p) {
+    const ret = wasm.distribution_quantile(distribution, p);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.distribution_quantile = distribution_quantile;
+
+/**
+ * `n` random variates, reproducible from `seed`: the same `(distribution, n,
+ * seed)` always returns the same values. Uniforms are drawn from the open
+ * interval (0, 1), so no variate is infinite.
+ *
+ * # Errors
+ * As [`distribution_cdf`] for `distribution`; `n` not a whole number in
+ * `[0, 2³² − 1]` or `seed` not a whole number in `[0, 2⁵³]` throws
+ * `parameter_out_of_range`.
+ * @param {DistributionSpec} distribution
+ * @param {number} n
+ * @param {number} seed
+ * @returns {Float64Array}
+ */
+function distribution_sample(distribution, n, seed) {
+    const ret = wasm.distribution_sample(distribution, n, seed);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+exports.distribution_sample = distribution_sample;
+
 /**
  * Estimate the optimal Box-Cox lambda via profile maximum likelihood.
  *
@@ -126,6 +211,101 @@ function f_distribution_quantile(p, df1, df2) {
 }
 exports.f_distribution_quantile = f_distribution_quantile;
 
+/**
+ * Points in `a` but not in `b`, in normal form — e.g. a reporting window
+ * minus down-time is up-time.
+ *
+ * # Errors
+ * As [`interval_normalize`], naming `a` or `b`.
+ * @param {[number, number][]} a
+ * @param {[number, number][]} b
+ * @returns {[number, number][]}
+ */
+function interval_difference(a, b) {
+    const ret = wasm.interval_difference(a, b);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.interval_difference = interval_difference;
+
+/**
+ * Points in both `a` and `b`, in normal form. Clipping to a window is
+ * `interval_intersection(a, [[from, to]])`.
+ *
+ * # Errors
+ * As [`interval_normalize`], naming `a` or `b`.
+ * @param {[number, number][]} a
+ * @param {[number, number][]} b
+ * @returns {[number, number][]}
+ */
+function interval_intersection(a, b) {
+    const ret = wasm.interval_intersection(a, b);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.interval_intersection = interval_intersection;
+
+/**
+ * Total length of the union of `intervals`: each point counts once, however
+ * many rows cover it.
+ *
+ * # Errors
+ * As [`interval_normalize`].
+ * @param {[number, number][]} intervals
+ * @returns {number}
+ */
+function interval_measure(intervals) {
+    const ret = wasm.interval_measure(intervals);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+exports.interval_measure = interval_measure;
+
+/**
+ * The union of `intervals` (each `[start, end]`, half-open) in normal form:
+ * sorted, disjoint, touching pieces merged, empty ones dropped.
+ *
+ * # Errors
+ * Throws `malformed_input` for a row that is not two numbers (`parameter` is
+ * the row's path, e.g. `intervals[2]`), `value_not_finite` for a NaN or
+ * ±Infinity bound, and `reversed_interval` (`parameter`, `index`) for a row
+ * with start > end — reversed rows are refused, not swapped.
+ * @param {[number, number][]} intervals
+ * @returns {[number, number][]}
+ */
+function interval_normalize(intervals) {
+    const ret = wasm.interval_normalize(intervals);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.interval_normalize = interval_normalize;
+
+/**
+ * Points in `a` or `b`, in normal form.
+ *
+ * # Errors
+ * As [`interval_normalize`], naming `a` or `b`.
+ * @param {[number, number][]} a
+ * @param {[number, number][]} b
+ * @returns {[number, number][]}
+ */
+function interval_union(a, b) {
+    const ret = wasm.interval_union(a, b);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.interval_union = interval_union;
+
 /**
  * Standard normal quantile Φ⁻¹(p): the `z` with `P(Z ≤ z) = p`.
  *
@@ -290,6 +470,10 @@ exports.variance = variance;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_String_8564e559799eccda: function(arg0, arg1) {
             const ret = String(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -297,10 +481,53 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_bigint_get_as_i64_a2383202b9353e4c: 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_5b446f51afd21013: function(arg0) {
+            const v = arg0;
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: 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_92f62ee1427d9e49: function(arg0, arg1) {
+            const ret = arg0 in arg1;
+            return ret;
+        },
+        __wbg___wbindgen_is_bigint_b123553bed3bb382: function(arg0) {
+            const ret = typeof(arg0) === 'bigint';
+            return ret;
+        },
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
         __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
             const ret = arg0 === null;
             return ret;
         },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_02babf21faa37971: function(arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_677f21e468d6b461: function(arg0, arg1) {
+            const ret = arg0 == arg1;
+            return ret;
+        },
         __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -322,10 +549,44 @@ function __wbg_get_imports() {
             const ret = typeof arg0;
             return ret;
         },
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_done_b41a1d26cdb37fb6: function(arg0) {
+            const ret = arg0.done;
+            return ret;
+        },
+        __wbg_entries_fb6397112b1de25f: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
         __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Float64Array_8a59377f9eec1b8b: function(arg0) {
             let result;
             try {
@@ -336,10 +597,42 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
+        __wbg_isSafeInteger_717808ad6a54bd9e: function(arg0) {
+            const ret = Number.isSafeInteger(arg0);
+            return ret;
+        },
+        __wbg_iterator_e3c31c892080e444: function() {
+            const ret = Symbol.iterator;
+            return ret;
+        },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_b5f0008bbf60cf59: function(arg0) {
             const ret = arg0.length;
             return ret;
@@ -348,6 +641,10 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
         __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
@@ -356,9 +653,32 @@ function __wbg_get_imports() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_next_33784799010f1bbe: function(arg0) {
+            const ret = arg0.next;
+            return ret;
+        },
+        __wbg_next_f4aac29c42af995c: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_of_20798cb14708764f: function(arg0, arg1) {
+            const ret = Array.of(arg0, arg1);
+            return ret;
+        },
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
         __wbg_prototypesetcall_d49a4fab5ca427bc: function(arg0, arg1, arg2) {
             Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
         __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -366,16 +686,30 @@ function __wbg_get_imports() {
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
+        __wbg_value_f3c585ee8f5ba40c: function(arg0) {
+            const ret = arg0.value;
+            return ret;
+        },
         __wbindgen_generic_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000002: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_generic_0000000000000004: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -398,11 +732,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)) {