wickra-wasm 0.4.0 → 0.4.1

package/README.md

@@ -12,6 +12,7 @@
 [![License: PolyForm-NC](https://img.shields.io/badge/license-PolyForm--NC--1.0.0-purple)](LICENSE)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/wickra-lib/wickra/badge)](https://scorecard.dev/viewer/?uri=github.com/wickra-lib/wickra)
 [![Build provenance](https://img.shields.io/badge/provenance-attested-brightgreen?logo=github)](https://github.com/wickra-lib/wickra/attestations)
+[![Docs](https://img.shields.io/badge/docs-docs.wickra.org-0ea5e9?logo=readthedocs&logoColor=white)](https://docs.wickra.org)
 
 **Streaming-first technical indicators. Install with `pip install wickra` — no system dependencies.**
 
@@ -37,6 +38,25 @@ for price in live_feed:
         print("overbought")
 ```
 
+## Documentation
+
+Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
+
+- **Quickstarts** — [Rust](https://docs.wickra.org/Quickstart-Rust),
+  [Python](https://docs.wickra.org/Quickstart-Python),
+  [Node](https://docs.wickra.org/Quickstart-Node),
+  [WASM](https://docs.wickra.org/Quickstart-WASM).
+- **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
+  every one of the 219 indicators; start at the
+  [indicators overview](https://docs.wickra.org/Indicators-Overview).
+- **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods),
+  [streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch),
+  [indicator chaining](https://docs.wickra.org/Indicator-Chaining), the
+  [data layer](https://docs.wickra.org/Data-Layer).
+- **Guides** — [Cookbook](https://docs.wickra.org/Cookbook),
+  [TA-Lib migration](https://docs.wickra.org/TA-Lib-Migration),
+  [FAQ](https://docs.wickra.org/FAQ).
+
 ## Why Wickra exists
 
 The Python TA ecosystem has plenty of libraries — TA-Lib, pandas-ta, finta,
@@ -115,9 +135,10 @@ python -m benchmarks.compare_libraries
 
 ## Indicators
 
-214 streaming-first indicators across sixteen families. Every one passes the
+219 streaming-first indicators across sixteen families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
-semantics tests.
+semantics tests. Each has a per-indicator deep dive (formula, parameters,
+warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 
 | Family | Indicators |
 |--------|-----------|
@@ -129,7 +150,7 @@ semantics tests.
 | Bands & Channels     | MA Envelope, Acceleration Bands, STARC Bands, ATR Bands, Hurst Channel, LinReg Channel, Standard Error Bands, Double Bollinger Bands, TTM Squeeze, Fractal Chaos Bands, VWAP StdDev Bands |
 | Trailing Stops       | Parabolic SAR, SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop |
 | Volume               | OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend, Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement, Klinger Volume Oscillator, Volume Oscillator, NVI, PVI, Williams A/D, Anchored VWAP, Demand Index, TSV, VZO, Market Facilitation Index |
-| Price Statistics     | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle, Variance, Coefficient of Variation, Skewness, Kurtosis, Standard Error, Detrended StdDev, R², Median Absolute Deviation, Autocorrelation, Hurst Exponent, Pearson Correlation, Beta, Spearman Correlation |
+| Price Statistics     | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle, Variance, Coefficient of Variation, Skewness, Kurtosis, Standard Error, Detrended StdDev, R², Median Absolute Deviation, Autocorrelation, Hurst Exponent, Pearson Correlation, Beta, Pairwise Beta, Pair Spread Z-Score, Lead-Lag Cross-Correlation, Cointegration, Relative Strength A-vs-B, Spearman Correlation |
 | Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline |
 | Pivots & S/R         | Classic Pivots, Fibonacci Pivots, Camarilla, Woodie Pivots, DeMark Pivots, Williams Fractals, ZigZag |
 | DeMark               | TD Setup, TD Sequential, TD DeMarker, TD REI, TD Pressure, TD Combo, TD Countdown, TD Lines, TD Range Projection, TD Differential, TD Open, TD Risk Level |
@@ -209,7 +230,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 214 indicators
+│   ├── wickra-core/         core engine + all 219 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   └── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 ├── bindings/

package/package.json

@@ -5,7 +5,7 @@
     "kingchenc <support@wickra.org>"
   ],
   "description": "WASM bindings for the Wickra streaming-first technical indicators library.",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "license": "PolyForm-Noncommercial-1.0.0",
   "repository": {
     "type": "git",

package/wickra_wasm.d.ts

@@ -432,6 +432,24 @@ export class CoefficientOfVariation {
     warmupPeriod(): number;
 }
 
+export class Cointegration {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[hedgeRatio0, spread0, adfStat0, hedgeRatio1, ...]`. Warmup rows are NaN.
+     */
+    batch(a: Float64Array, b: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number, adf_lags: number);
+    reset(): void;
+    /**
+     * Returns `{ hedgeRatio, spread, adfStat }`, or `null` during warmup.
+     */
+    update(a: number, b: number): any;
+    warmupPeriod(): number;
+}
+
 export class ConditionalValueAtRisk {
     free(): void;
     [Symbol.dispose](): void;
@@ -1075,6 +1093,25 @@ export class LaguerreRSI {
     warmupPeriod(): number;
 }
 
+export class LeadLagCrossCorrelation {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Flat `Float64Array` of length `2 * n`: `[lag0, corr0, lag1, corr1, ...]`.
+     * Warmup positions are NaN.
+     */
+    batch(a: Float64Array, b: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(window: number, max_lag: number);
+    reset(): void;
+    /**
+     * Returns `{ lag, correlation }`, or `null` during warmup. Positive lag
+     * means `a` leads `b`.
+     */
+    update(a: number, b: number): any;
+    warmupPeriod(): number;
+}
+
 export class LinRegAngle {
     free(): void;
     [Symbol.dispose](): void;
@@ -1384,6 +1421,36 @@ export class PainIndex {
     warmupPeriod(): number;
 }
 
+export class PairSpreadZScore {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Batch over two equally-sized arrays of prices. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     */
+    batch(a: Float64Array, b: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(beta_period: number, z_period: number);
+    reset(): void;
+    update(a: number, b: number): number | undefined;
+    warmupPeriod(): number;
+}
+
+export class PairwiseBeta {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     */
+    batch(x: Float64Array, y: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    update(x: number, y: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class ParkinsonVolatility {
     free(): void;
     [Symbol.dispose](): void;
@@ -1530,6 +1597,24 @@ export class RecoveryFactor {
     warmupPeriod(): number;
 }
 
+export class RelativeStrengthAB {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[ratio0, ratioMa0, ratioRsi0, ratio1, ...]`. Warmup rows are NaN.
+     */
+    batch(a: Float64Array, b: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(ma_period: number, rsi_period: number);
+    reset(): void;
+    /**
+     * Returns `{ ratio, ratioMa, ratioRsi }`, or `null` during warmup.
+     */
+    update(a: number, b: number): any;
+    warmupPeriod(): number;
+}
+
 export class RenkoTrailingStop {
     free(): void;
     [Symbol.dispose](): void;

package/wickra_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./wickra_wasm_bg.js";
 __wbg_set_wasm(wasm);
 
 export {
-    ADL, ADX, ADXR, ALMA, APO, ATR, AccelerationBands, AcceleratorOscillator, AdaptiveCycle, Alligator, Alpha, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, Autocorrelation, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Beta, BollingerBands, BollingerBandwidth, CCI, CFO, CMO, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CoefficientOfVariation, ConditionalValueAtRisk, ConnorsRSI, Coppock, CyberneticCycle, DEMA, DPO, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DetrendedStdDev, Doji, Donchian, DonchianStop, DoubleBollinger, DrawdownDuration, EMA, EVWMA, EaseOfMovement, EhlersStochastic, ElderImpulse, EmpiricalModeDecomposition, Engulfing, FAMA, FRAMA, FibonacciPivots, FisherTransform, ForceIndex, FractalChaosBands, GainLossRatio, GarmanKlassVolatility, HMA, Hammer, HangingMan, Harami, HeikinAshi, HiLoActivator, HilbertDominantCycle, HistoricalVolatility, HurstChannel, HurstExponent, Ichimoku, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, InverseFisherTransform, InvertedHammer, JMA, KAMA, KST, KVO, KellyCriterion, Keltner, Kurtosis, LaguerreRSI, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, MACD, MAMA, MFI, MOM, MaEnvelope, MarketFacilitationIndex, Marubozu, MassIndex, MaxDrawdown, McGinleyDynamic, MedianAbsoluteDeviation, MedianPrice, MorningEveningStar, NATR, NVI, OBV, OmegaRatio, OpeningRange, PGO, PMO, PPO, PSAR, PVI, PainIndex, ParkinsonVolatility, PearsonCorrelation, PercentB, PercentageTrailingStop, PiercingDarkCloud, ProfitFactor, ROC, RSI, RSquared, RVI, RVIVolatility, RWI, RecoveryFactor, RenkoTrailingStop, RogersSatchellVolatility, RollingVWAP, RoofingFilter, SMA, SMI, SMMA, STC, SharpeRatio, ShootingStar, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StochRSI, Stochastic, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TRIMA, TRIX, TSI, TSV, ThreeInside, ThreeOutside, ThreeSoldiersOrCrows, TreynorRatio, TrueRange, TtmSqueeze, Tweezer, TypicalPrice, UlcerIndex, UltimateOscillator, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VerticalHorizontalFilter, VoltyStop, VolumeOscillator, VolumePriceTrend, Vortex, VwapStdDevBands, WMA, WaveTrend, WeightedClose, WilliamsAD, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
+    ADL, ADX, ADXR, ALMA, APO, ATR, AccelerationBands, AcceleratorOscillator, AdaptiveCycle, Alligator, Alpha, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, Autocorrelation, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Beta, BollingerBands, BollingerBandwidth, CCI, CFO, CMO, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CoefficientOfVariation, Cointegration, ConditionalValueAtRisk, ConnorsRSI, Coppock, CyberneticCycle, DEMA, DPO, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DetrendedStdDev, Doji, Donchian, DonchianStop, DoubleBollinger, DrawdownDuration, EMA, EVWMA, EaseOfMovement, EhlersStochastic, ElderImpulse, EmpiricalModeDecomposition, Engulfing, FAMA, FRAMA, FibonacciPivots, FisherTransform, ForceIndex, FractalChaosBands, GainLossRatio, GarmanKlassVolatility, HMA, Hammer, HangingMan, Harami, HeikinAshi, HiLoActivator, HilbertDominantCycle, HistoricalVolatility, HurstChannel, HurstExponent, Ichimoku, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, InverseFisherTransform, InvertedHammer, JMA, KAMA, KST, KVO, KellyCriterion, Keltner, Kurtosis, LaguerreRSI, LeadLagCrossCorrelation, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, MACD, MAMA, MFI, MOM, MaEnvelope, MarketFacilitationIndex, Marubozu, MassIndex, MaxDrawdown, McGinleyDynamic, MedianAbsoluteDeviation, MedianPrice, MorningEveningStar, NATR, NVI, OBV, OmegaRatio, OpeningRange, PGO, PMO, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentB, PercentageTrailingStop, PiercingDarkCloud, ProfitFactor, ROC, RSI, RSquared, RVI, RVIVolatility, RWI, RecoveryFactor, RelativeStrengthAB, RenkoTrailingStop, RogersSatchellVolatility, RollingVWAP, RoofingFilter, SMA, SMI, SMMA, STC, SharpeRatio, ShootingStar, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StochRSI, Stochastic, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TRIMA, TRIX, TSI, TSV, ThreeInside, ThreeOutside, ThreeSoldiersOrCrows, TreynorRatio, TrueRange, TtmSqueeze, Tweezer, TypicalPrice, UlcerIndex, UltimateOscillator, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VerticalHorizontalFilter, VoltyStop, VolumeOscillator, VolumePriceTrend, Vortex, VwapStdDevBands, WMA, WaveTrend, WeightedClose, WilliamsAD, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
 } from "./wickra_wasm_bg.js";

package/wickra_wasm_bg.js

@@ -3227,6 +3227,94 @@ export class CoefficientOfVariation {
 }
 if (Symbol.dispose) CoefficientOfVariation.prototype[Symbol.dispose] = CoefficientOfVariation.prototype.free;
 
+export class Cointegration {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CointegrationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cointegration_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[hedgeRatio0, spread0, adfStat0, hedgeRatio1, ...]`. Warmup rows are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.cointegration_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.cointegration_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} adf_lags
+     */
+    constructor(period, adf_lags) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.cointegration_new(retptr, period, adf_lags);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            CointegrationFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.cointegration_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ hedgeRatio, spread, adfStat }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.cointegration_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.cointegration_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Cointegration.prototype[Symbol.dispose] = Cointegration.prototype.free;
+
 export class ConditionalValueAtRisk {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7887,6 +7975,95 @@ export class LaguerreRSI {
 }
 if (Symbol.dispose) LaguerreRSI.prototype[Symbol.dispose] = LaguerreRSI.prototype.free;
 
+export class LeadLagCrossCorrelation {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LeadLagCrossCorrelationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_leadlagcrosscorrelation_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `2 * n`: `[lag0, corr0, lag1, corr1, ...]`.
+     * Warmup positions are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.leadlagcrosscorrelation_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.leadlagcrosscorrelation_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} window
+     * @param {number} max_lag
+     */
+    constructor(window, max_lag) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.leadlagcrosscorrelation_new(retptr, window, max_lag);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            LeadLagCrossCorrelationFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.leadlagcrosscorrelation_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ lag, correlation }`, or `null` during warmup. Positive lag
+     * means `a` leads `b`.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.leadlagcrosscorrelation_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.leadlagcrosscorrelation_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) LeadLagCrossCorrelation.prototype[Symbol.dispose] = LeadLagCrossCorrelation.prototype.free;
+
 export class LinRegAngle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -10130,6 +10307,193 @@ export class PainIndex {
 }
 if (Symbol.dispose) PainIndex.prototype[Symbol.dispose] = PainIndex.prototype.free;
 
+export class PairSpreadZScore {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PairSpreadZScoreFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pairspreadzscore_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays of prices. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.pairspreadzscore_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.pairspreadzscore_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} beta_period
+     * @param {number} z_period
+     */
+    constructor(beta_period, z_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pairspreadzscore_new(retptr, beta_period, z_period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            PairSpreadZScoreFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.pairspreadzscore_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} a
+     * @param {number} b
+     * @returns {number | undefined}
+     */
+    update(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pairspreadzscore_update(retptr, this.__wbg_ptr, a, b);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.pairspreadzscore_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PairSpreadZScore.prototype[Symbol.dispose] = PairSpreadZScore.prototype.free;
+
+export class PairwiseBeta {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PairwiseBetaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pairwisebeta_free(ptr, 0);
+    }
+    /**
+     * Batch over two equally-sized arrays. Returns one `f64` per
+     * input position (`NaN` during warmup).
+     * @param {Float64Array} x
+     * @param {Float64Array} y
+     * @returns {Float64Array}
+     */
+    batch(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.pairwisebeta_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.pairwisebeta_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pairwisebeta_new(retptr, period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            PairwiseBetaFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.pairwisebeta_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @returns {number | undefined}
+     */
+    update(x, y) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pairwisebeta_update(retptr, this.__wbg_ptr, x, y);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.pairwisebeta_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PairwiseBeta.prototype[Symbol.dispose] = PairwiseBeta.prototype.free;
+
 export class ParkinsonVolatility {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -11181,6 +11545,94 @@ export class RecoveryFactor {
 }
 if (Symbol.dispose) RecoveryFactor.prototype[Symbol.dispose] = RecoveryFactor.prototype.free;
 
+export class RelativeStrengthAB {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RelativeStrengthABFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_relativestrengthab_free(ptr, 0);
+    }
+    /**
+     * Flat `Float64Array` of length `3 * n`:
+     * `[ratio0, ratioMa0, ratioRsi0, ratio1, ...]`. Warmup rows are NaN.
+     * @param {Float64Array} a
+     * @param {Float64Array} b
+     * @returns {Float64Array}
+     */
+    batch(a, b) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.relativestrengthab_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.relativestrengthab_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} ma_period
+     * @param {number} rsi_period
+     */
+    constructor(ma_period, rsi_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.relativestrengthab_new(retptr, ma_period, rsi_period);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            RelativeStrengthABFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.relativestrengthab_reset(this.__wbg_ptr);
+    }
+    /**
+     * Returns `{ ratio, ratioMa, ratioRsi }`, or `null` during warmup.
+     * @param {number} a
+     * @param {number} b
+     * @returns {any}
+     */
+    update(a, b) {
+        const ret = wasm.relativestrengthab_update(this.__wbg_ptr, a, b);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.relativestrengthab_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RelativeStrengthAB.prototype[Symbol.dispose] = RelativeStrengthAB.prototype.free;
+
 export class RenkoTrailingStop {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -18166,6 +18618,9 @@ const CMOFinalization = (typeof FinalizationRegistry === 'undefined')
 const CoefficientOfVariationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_coefficientofvariation_free(ptr, 1));
+const CointegrationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cointegration_free(ptr, 1));
 const ConditionalValueAtRiskFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_conditionalvalueatrisk_free(ptr, 1));
@@ -18334,6 +18789,9 @@ const KVOFinalization = (typeof FinalizationRegistry === 'undefined')
 const LaguerreRSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_laguerrersi_free(ptr, 1));
+const LeadLagCrossCorrelationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_leadlagcrosscorrelation_free(ptr, 1));
 const LinRegAngleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_linregangle_free(ptr, 1));
@@ -18403,6 +18861,12 @@ const OpeningRangeFinalization = (typeof FinalizationRegistry === 'undefined')
 const PainIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_painindex_free(ptr, 1));
+const PairSpreadZScoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pairspreadzscore_free(ptr, 1));
+const PairwiseBetaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pairwisebeta_free(ptr, 1));
 const ParkinsonVolatilityFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_parkinsonvolatility_free(ptr, 1));
@@ -18442,6 +18906,9 @@ const RSquaredFinalization = (typeof FinalizationRegistry === 'undefined')
 const RecoveryFactorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_recoveryfactor_free(ptr, 1));
+const RelativeStrengthABFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_relativestrengthab_free(ptr, 1));
 const RenkoTrailingStopFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_renkotrailingstop_free(ptr, 1));