wickra-wasm 0.5.5 → 0.5.6

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=403" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=413" alt="Wickra — streaming-first technical indicators" width="100%"></a>
 </p>
 
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
@@ -48,7 +48,7 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
   [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 403 indicators; start at the
+  every one of the 413 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),
@@ -136,7 +136,7 @@ python -m benchmarks.compare_libraries
 
 ## Indicators
 
-403 streaming-first indicators across twenty-four families. Every one passes the
+413 streaming-first indicators across twenty-four families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
 semantics tests. Each has a per-indicator deep dive (formula, parameters,
 warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
@@ -144,7 +144,7 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 | Family | Indicators |
 |--------|-----------|
 | Moving Averages      | SMA, EMA, WMA, DEMA, TEMA, HMA, KAMA, SMMA, TRIMA, ZLEMA, T3, VWMA, ALMA, McGinley Dynamic, FRAMA, VIDYA, JMA, Alligator, EVWMA, SWMA, GMA, EHMA, Median MA, Adaptive Laguerre, GD, Holt-Winters |
-| Momentum Oscillators | RSI (Wilder), Anchored RSI, Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia, ROC Percentage (ROCP), ROC Ratio (ROCR), ROC Ratio 100 (ROCR100) |
+| Momentum Oscillators | RSI (Wilder), Anchored RSI, Stochastic, CCI, ROC, Williams %R, MFI, Awesome Oscillator, MOM, CMO, TSI, PMO, StochRSI, Ultimate Oscillator, RVI, PGO, KST, SMI, Laguerre RSI, Connors RSI, Inertia, ROC Percentage (ROCP), ROC Ratio (ROCR), ROC Ratio 100 (ROCR100), Disparity Index, Fisher RSI, RSX, Dynamic Momentum Index, Stochastic CCI, RMI, Derivative Oscillator, Elder Ray, Intraday Momentum Index, QQE |
 | Trend & Directional  | MACD, MACD Fixed (MACDFIX), MACD Extended (MACDEXT), ADX (+DI/-DI), ADXR, Aroon, TRIX, Aroon Oscillator, Vortex, Random Walk Index, Trend Intensity Index, Wave Trend Oscillator, Mass Index, Choppiness Index, Vertical Horizontal Filter, Plus DM, Minus DM, Plus DI, Minus DI, DX |
 | Price Oscillators    | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power, APO, AO Histogram, CFO, Zero-Lag MACD, Elder Impulse, STC |
 | Volatility & Bands   | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility, RVI (Relative Volatility Index), Parkinson Volatility, Garman-Klass Volatility, Rogers-Satchell Volatility, Yang-Zhang Volatility |
@@ -245,7 +245,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 403 indicators
+│   ├── wickra-core/         core engine + all 413 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.5.5",
+  "version": "0.5.6",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",

package/wickra_wasm.d.ts

@@ -917,6 +917,17 @@ export class DepthSlope {
     warmupPeriod(): number;
 }
 
+export class DerivativeOscillator {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(rsi_period: number, smooth1: number, smooth2: number, signal_period: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class DetrendedStdDev {
     free(): void;
     [Symbol.dispose](): void;
@@ -928,6 +939,17 @@ export class DetrendedStdDev {
     warmupPeriod(): number;
 }
 
+export class DisparityIndex {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class DistanceSsd {
     free(): void;
     [Symbol.dispose](): void;
@@ -1053,6 +1075,17 @@ export class DrawdownDuration {
     warmupPeriod(): number;
 }
 
+export class DynamicMomentumIndex {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class EHMA {
     free(): void;
     [Symbol.dispose](): void;
@@ -1127,6 +1160,23 @@ export class ElderImpulse {
     warmupPeriod(): number;
 }
 
+export class ElderRay {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns `[bull0, bear0, bull1, bear1, ...]`, length `2 * n`.
+     */
+    batch(high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    /**
+     * Streaming update. Returns `{ bullPower, bearPower }` once warm, else `null`.
+     */
+    update(high: number, low: number, close: number): any;
+    warmupPeriod(): number;
+}
+
 export class EmpiricalModeDecomposition {
     free(): void;
     [Symbol.dispose](): void;
@@ -1303,6 +1353,17 @@ export class FibonacciPivots {
     warmupPeriod(): number;
 }
 
+export class FisherRSI {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class FisherTransform {
     free(): void;
     [Symbol.dispose](): void;
@@ -1735,6 +1796,23 @@ export class HurstExponent {
     warmupPeriod(): number;
 }
 
+export class IMI {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Batch over open/high/low/close arrays; `NaN` during warmup.
+     */
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    /**
+     * Streaming update over one candle's open/high/low/close.
+     */
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class Ichimoku {
     free(): void;
     [Symbol.dispose](): void;
@@ -2842,6 +2920,23 @@ export class ProfitFactor {
     warmupPeriod(): number;
 }
 
+export class QQE {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns `[rsiMa0, trailing0, rsiMa1, trailing1, ...]`, length `2 * n`.
+     */
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(rsi_period: number, smoothing: number, factor: number);
+    reset(): void;
+    /**
+     * Streaming update. Returns `{ rsiMa, trailingLine }` once warm, else `null`.
+     */
+    update(value: number): any;
+    warmupPeriod(): number;
+}
+
 export class QuotedSpread {
     free(): void;
     [Symbol.dispose](): void;
@@ -2852,6 +2947,17 @@ export class QuotedSpread {
     warmupPeriod(): number;
 }
 
+export class RMI {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number, momentum: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class ROC {
     free(): void;
     [Symbol.dispose](): void;
@@ -2907,6 +3013,17 @@ export class RSI {
     warmupPeriod(): number;
 }
 
+export class RSX {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(prices: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period: number);
+    reset(): void;
+    update(value: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class RSquared {
     free(): void;
     [Symbol.dispose](): void;
@@ -3557,6 +3674,15 @@ export class Stochastic {
     warmupPeriod(): number;
 }
 
+export class StochasticCCI {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    constructor(period: number);
+    reset(): void;
+    update(high: number, low: number, close: number): number | undefined;
+}
+
 export class SuperSmoother {
     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, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BodySizePct, BollingerBands, BollingerBandwidth, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, CoefficientOfVariation, Cointegration, ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRSI, Coppock, Counterattack, Crab, CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DEMA, DPO, DX, DayOfWeekProfile, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DepthSlope, DetrendedStdDev, DistanceSsd, Doji, DojiStar, Donchian, DonchianStop, DoubleBollinger, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DrawdownDuration, EHMA, EMA, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, Expectancy, FAMA, FRAMA, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FisherTransform, FlagPennant, Footprint, ForceIndex, FractalChaosBands, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore, GD, GMA, GainLossRatio, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GoldenPocket, GrangerCausality, GravestoneDoji, HMA, HT_DCPHASE, HT_PHASOR, HT_TRENDMODE, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowIndex, HighLowRange, HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, HoltWinters, HomingPigeon, HurstChannel, HurstExponent, Ichimoku, IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KellyCriterion, Keltner, Kicking, KickingByLength, Kurtosis, KylesLambda, LINEARREG_INTERCEPT, LadderBottom, LaguerreRSI, LeadLagCrossCorrelation, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, LiquidationFeatures, LogReturn, LongLeggedDoji, LongLine, LongShortRatio, MACD, MACDEXT, MACDFIX, MAMA, MFI, MIDPOINT, MIDPRICE, MINUS_DI, MINUS_DM, MOM, MaEnvelope, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianMA, MedianPrice, Microprice, MorningDojiStar, MorningEveningStar, NATR, NVI, NewHighsNewLows, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PointAndFigureBars, ProfitFactor, QuotedSpread, ROC, ROCP, ROCR, ROCR100, RSI, RSquared, RVI, RVIVolatility, RWI, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange, RegimeLabel, RelativeStrengthAB, RenkoBars, RenkoTrailingStop, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingPercentileRank, RollingQuantile, RollingVWAP, RoofingFilter, SAREXT, SMA, SMI, SMMA, STC, SWMA, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient, SpreadBollingerBands, SpreadHurst, StalledPattern, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StickSandwich, StochRSI, Stochastic, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TRIMA, TRIX, TSF, TSI, TSV, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TtmSqueeze, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vpin, VwapStdDevBands, WMA, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsAD, WilliamsFractals, WilliamsR, WinRate, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
+    ADL, ADX, ADXR, ALMA, APO, ATR, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, Aroon, AroonOscillator, AtrBands, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BodySizePct, BollingerBands, BollingerBandwidth, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, CoefficientOfVariation, Cointegration, ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRSI, Coppock, Counterattack, Crab, CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DEMA, DPO, DX, DayOfWeekProfile, Decycler, DecyclerOscillator, DemandIndex, DemarkPivots, DepthSlope, DerivativeOscillator, DetrendedStdDev, DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian, DonchianStop, DoubleBollinger, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DrawdownDuration, DynamicMomentumIndex, EHMA, EMA, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, ElderRay, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, Expectancy, FAMA, FRAMA, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FisherRSI, FisherTransform, FlagPennant, Footprint, ForceIndex, FractalChaosBands, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore, GD, GMA, GainLossRatio, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GoldenPocket, GrangerCausality, GravestoneDoji, HMA, HT_DCPHASE, HT_PHASOR, HT_TRENDMODE, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowIndex, HighLowRange, HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, HoltWinters, HomingPigeon, HurstChannel, HurstExponent, IMI, Ichimoku, IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance, InstantaneousTrendline, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KellyCriterion, Keltner, Kicking, KickingByLength, Kurtosis, KylesLambda, LINEARREG_INTERCEPT, LadderBottom, LaguerreRSI, LeadLagCrossCorrelation, LinRegAngle, LinRegChannel, LinRegSlope, LinearRegression, LiquidationFeatures, LogReturn, LongLeggedDoji, LongLine, LongShortRatio, MACD, MACDEXT, MACDFIX, MAMA, MFI, MIDPOINT, MIDPRICE, MINUS_DI, MINUS_DM, MOM, MaEnvelope, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianMA, MedianPrice, Microprice, MorningDojiStar, MorningEveningStar, NATR, NVI, NewHighsNewLows, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PointAndFigureBars, ProfitFactor, QQE, QuotedSpread, RMI, ROC, ROCP, ROCR, ROCR100, RSI, RSX, RSquared, RVI, RVIVolatility, RWI, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange, RegimeLabel, RelativeStrengthAB, RenkoBars, RenkoTrailingStop, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingPercentileRank, RollingQuantile, RollingVWAP, RoofingFilter, SAREXT, SMA, SMI, SMMA, STC, SWMA, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave, Skewness, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient, SpreadBollingerBands, SpreadHurst, StalledPattern, StandardError, StandardErrorBands, StarcBands, StdDev, StepTrailingStop, StickSandwich, StochRSI, Stochastic, StochasticCCI, SuperSmoother, SuperTrend, T3, TDCombo, TDCountdown, TDDeMarker, TDDifferential, TDLines, TDOpen, TDPressure, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TEMA, TII, TRIMA, TRIX, TSF, TSI, TSV, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TtmSqueeze, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vpin, VwapStdDevBands, WMA, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsAD, WilliamsFractals, WilliamsR, WinRate, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
 } from "./wickra_wasm_bg.js";

package/wickra_wasm_bg.js

@@ -6806,6 +6806,85 @@ export class DepthSlope {
 }
 if (Symbol.dispose) DepthSlope.prototype[Symbol.dispose] = DepthSlope.prototype.free;
 
+export class DerivativeOscillator {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DerivativeOscillatorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_derivativeoscillator_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derivativeoscillator_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.derivativeoscillator_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} rsi_period
+     * @param {number} smooth1
+     * @param {number} smooth2
+     * @param {number} signal_period
+     */
+    constructor(rsi_period, smooth1, smooth2, signal_period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.derivativeoscillator_new(retptr, rsi_period, smooth1, smooth2, signal_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;
+            DerivativeOscillatorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.derivativeoscillator_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.derivativeoscillator_update(retptr, this.__wbg_ptr, value);
+            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.derivativeoscillator_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DerivativeOscillator.prototype[Symbol.dispose] = DerivativeOscillator.prototype.free;
+
 export class DetrendedStdDev {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -6882,6 +6961,82 @@ export class DetrendedStdDev {
 }
 if (Symbol.dispose) DetrendedStdDev.prototype[Symbol.dispose] = DetrendedStdDev.prototype.free;
 
+export class DisparityIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DisparityIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_disparityindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.disparityindex_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.disparityindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.disparityindex_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;
+            DisparityIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.disparityindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.disparityindex_update(retptr, this.__wbg_ptr, value);
+            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.disparityindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DisparityIndex.prototype[Symbol.dispose] = DisparityIndex.prototype.free;
+
 export class DistanceSsd {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -7741,6 +7896,82 @@ export class DrawdownDuration {
 }
 if (Symbol.dispose) DrawdownDuration.prototype[Symbol.dispose] = DrawdownDuration.prototype.free;
 
+export class DynamicMomentumIndex {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DynamicMomentumIndexFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dynamicmomentumindex_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dynamicmomentumindex_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.dynamicmomentumindex_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dynamicmomentumindex_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;
+            DynamicMomentumIndexFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.dynamicmomentumindex_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.dynamicmomentumindex_update(retptr, this.__wbg_ptr, value);
+            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.dynamicmomentumindex_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DynamicMomentumIndex.prototype[Symbol.dispose] = DynamicMomentumIndex.prototype.free;
+
 export class EHMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -8291,6 +8522,107 @@ export class ElderImpulse {
 }
 if (Symbol.dispose) ElderImpulse.prototype[Symbol.dispose] = ElderImpulse.prototype.free;
 
+export class ElderRay {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ElderRayFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_elderray_free(ptr, 0);
+    }
+    /**
+     * Returns `[bull0, bear0, bull1, bear1, ...]`, length `2 * n`.
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.elderray_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            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.elderray_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.elderray_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;
+            ElderRayFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.elderray_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update. Returns `{ bullPower, bearPower }` once warm, else `null`.
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {any}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.elderray_update(retptr, this.__wbg_ptr, high, low, close);
+            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 {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.elderray_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ElderRay.prototype[Symbol.dispose] = ElderRay.prototype.free;
+
 export class EmpiricalModeDecomposition {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -9600,6 +9932,82 @@ export class FibonacciPivots {
 }
 if (Symbol.dispose) FibonacciPivots.prototype[Symbol.dispose] = FibonacciPivots.prototype.free;
 
+export class FisherRSI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FisherRSIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fisherrsi_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.fisherrsi_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.fisherrsi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fisherrsi_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;
+            FisherRSIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.fisherrsi_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fisherrsi_update(retptr, this.__wbg_ptr, value);
+            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.fisherrsi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) FisherRSI.prototype[Symbol.dispose] = FisherRSI.prototype.free;
+
 export class FisherTransform {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -12743,6 +13151,112 @@ export class HurstExponent {
 }
 if (Symbol.dispose) HurstExponent.prototype[Symbol.dispose] = HurstExponent.prototype.free;
 
+export class IMI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IMIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imi_free(ptr, 0);
+    }
+    /**
+     * Batch over open/high/low/close arrays; `NaN` during warmup.
+     * @param {Float64Array} open
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(open, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.imi_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            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.imi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.imi_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;
+            IMIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.imi_reset(this.__wbg_ptr);
+    }
+    /**
+     * Streaming update over one candle's open/high/low/close.
+     * @param {number} open
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(open, high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.imi_update(retptr, this.__wbg_ptr, open, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.imi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) IMI.prototype[Symbol.dispose] = IMI.prototype.free;
+
 export class Ichimoku {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -20586,43 +21100,122 @@ export class PointAndFigureBars {
         }
     }
 }
-if (Symbol.dispose) PointAndFigureBars.prototype[Symbol.dispose] = PointAndFigureBars.prototype.free;
+if (Symbol.dispose) PointAndFigureBars.prototype[Symbol.dispose] = PointAndFigureBars.prototype.free;
+
+export class ProfitFactor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfitFactorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profitfactor_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_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;
+            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.profitfactor_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
+            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.profitfactor_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
 
-export class ProfitFactor {
+export class QQE {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ProfitFactorFinalization.unregister(this);
+        QQEFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_profitfactor_free(ptr, 0);
+        wasm.__wbg_qqe_free(ptr, 0);
     }
     /**
+     * Returns `[rsiMa0, trailing0, rsiMa1, trailing1, ...]`, length `2 * n`.
      * @param {Float64Array} prices
      * @returns {Float64Array}
      */
     batch(prices) {
         const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.profitfactor_batch(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.qqe_batch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
      * @returns {boolean}
      */
     isReady() {
-        const ret = wasm.profitfactor_isReady(this.__wbg_ptr);
+        const ret = wasm.qqe_isReady(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-     * @param {number} period
+     * @param {number} rsi_period
+     * @param {number} smoothing
+     * @param {number} factor
      */
-    constructor(period) {
+    constructor(rsi_period, smoothing, factor) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_new(retptr, period);
+            wasm.qqe_new(retptr, rsi_period, smoothing, factor);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -20630,39 +21223,33 @@ export class ProfitFactor {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            ProfitFactorFinalization.register(this, this.__wbg_ptr, this);
+            QQEFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.profitfactor_reset(this.__wbg_ptr);
+        wasm.qqe_reset(this.__wbg_ptr);
     }
     /**
+     * Streaming update. Returns `{ rsiMa, trailingLine }` once warm, else `null`.
      * @param {number} value
-     * @returns {number | undefined}
+     * @returns {any}
      */
     update(value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.profitfactor_update(retptr, this.__wbg_ptr, value);
-            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);
-        }
+        const ret = wasm.qqe_update(this.__wbg_ptr, value);
+        return takeObject(ret);
     }
     /**
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.profitfactor_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.qqe_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) ProfitFactor.prototype[Symbol.dispose] = ProfitFactor.prototype.free;
+if (Symbol.dispose) QQE.prototype[Symbol.dispose] = QQE.prototype.free;
 
 export class QuotedSpread {
     __destroy_into_raw() {
@@ -20732,6 +21319,83 @@ export class QuotedSpread {
 }
 if (Symbol.dispose) QuotedSpread.prototype[Symbol.dispose] = QuotedSpread.prototype.free;
 
+export class RMI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RMIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rmi_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rmi_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rmi_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     * @param {number} momentum
+     */
+    constructor(period, momentum) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rmi_new(retptr, period, momentum);
+            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;
+            RMIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rmi_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rmi_update(retptr, this.__wbg_ptr, value);
+            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.rmi_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RMI.prototype[Symbol.dispose] = RMI.prototype.free;
+
 export class ROC {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -21112,6 +21776,82 @@ export class RSI {
 }
 if (Symbol.dispose) RSI.prototype[Symbol.dispose] = RSI.prototype.free;
 
+export class RSX {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RSXFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rsx_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} prices
+     * @returns {Float64Array}
+     */
+    batch(prices) {
+        const ptr0 = passArrayF64ToWasm0(prices, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rsx_batch(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReady() {
+        const ret = wasm.rsx_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rsx_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;
+            RSXFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.rsx_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} value
+     * @returns {number | undefined}
+     */
+    update(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rsx_update(retptr, this.__wbg_ptr, value);
+            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.rsx_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) RSX.prototype[Symbol.dispose] = RSX.prototype.free;
+
 export class RSquared {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -25722,6 +26462,92 @@ export class Stochastic {
 }
 if (Symbol.dispose) Stochastic.prototype[Symbol.dispose] = Stochastic.prototype.free;
 
+export class StochasticCCI {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StochasticCCIFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stochasticcci_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @param {Float64Array} close
+     * @returns {Float64Array}
+     */
+    batch(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(high, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF64ToWasm0(low, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF64ToWasm0(close, wasm.__wbindgen_export3);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.stochasticcci_batch(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            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);
+        }
+    }
+    /**
+     * @param {number} period
+     */
+    constructor(period) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.stochasticcci_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;
+            StochasticCCIFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.stochasticcci_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @param {number} close
+     * @returns {number | undefined}
+     */
+    update(high, low, close) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+            wasm.stochasticcci_update(retptr, this.__wbg_ptr, high, low, close);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+            var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+            if (r5) {
+                throw takeObject(r4);
+            }
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(32);
+        }
+    }
+}
+if (Symbol.dispose) StochasticCCI.prototype[Symbol.dispose] = StochasticCCI.prototype.free;
+
 export class SuperSmoother {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -33497,9 +34323,15 @@ const DemarkPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
 const DepthSlopeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_depthslope_free(ptr, 1));
+const DerivativeOscillatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_derivativeoscillator_free(ptr, 1));
 const DetrendedStdDevFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_detrendedstddev_free(ptr, 1));
+const DisparityIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_disparityindex_free(ptr, 1));
 const DistanceSsdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_distancessd_free(ptr, 1));
@@ -33536,6 +34368,9 @@ const DrawdownDurationFinalization = (typeof FinalizationRegistry === 'undefined
 const DXFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_dx_free(ptr, 1));
+const DynamicMomentumIndexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_dynamicmomentumindex_free(ptr, 1));
 const EaseOfMovementFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_easeofmovement_free(ptr, 1));
@@ -33551,6 +34386,9 @@ const EHMAFinalization = (typeof FinalizationRegistry === 'undefined')
 const ElderImpulseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_elderimpulse_free(ptr, 1));
+const ElderRayFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_elderray_free(ptr, 1));
 const EMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ema_free(ptr, 1));
@@ -33602,6 +34440,9 @@ const FibTimeZonesFinalization = (typeof FinalizationRegistry === 'undefined')
 const FibonacciPivotsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fibonaccipivots_free(ptr, 1));
+const FisherRSIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fisherrsi_free(ptr, 1));
 const FisherTransformFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_fishertransform_free(ptr, 1));
@@ -33728,6 +34569,9 @@ const IchimokuFinalization = (typeof FinalizationRegistry === 'undefined')
 const IdenticalThreeCrowsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identicalthreecrows_free(ptr, 1));
+const IMIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_imi_free(ptr, 1));
 const InNeckFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_inneck_free(ptr, 1));
@@ -34016,6 +34860,9 @@ const PSARFinalization = (typeof FinalizationRegistry === 'undefined')
 const PVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pvi_free(ptr, 1));
+const QQEFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_qqe_free(ptr, 1));
 const QuotedSpreadFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_quotedspread_free(ptr, 1));
@@ -34052,6 +34899,9 @@ const RickshawManFinalization = (typeof FinalizationRegistry === 'undefined')
 const RisingThreeMethodsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_risingthreemethods_free(ptr, 1));
+const RMIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rmi_free(ptr, 1));
 const ROCFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_roc_free(ptr, 1));
@@ -34094,6 +34944,9 @@ const RoofingFilterFinalization = (typeof FinalizationRegistry === 'undefined')
 const RSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rsi_free(ptr, 1));
+const RSXFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rsx_free(ptr, 1));
 const RVIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rvi_free(ptr, 1));
@@ -34202,6 +35055,9 @@ const StochasticFinalization = (typeof FinalizationRegistry === 'undefined')
 const StochRSIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_stochrsi_free(ptr, 1));
+const StochasticCCIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stochasticcci_free(ptr, 1));
 const SuperSmootherFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_supersmoother_free(ptr, 1));