wickra-wasm 0.6.6 → 0.6.7

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=467" 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=474" 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 467 indicators; start at the
+  every one of the 474 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),
@@ -66,7 +66,7 @@ an afterthought — **live, tick-by-tick data** — without giving up the breadt
 a full batch library, and without making you reimplement your indicators four
 times to get there.
 
-- **The biggest streaming-native catalogue, period.** 467 indicators across 24
+- **The biggest streaming-native catalogue, period.** 474 indicators across 24
   families — candlesticks, harmonic & chart patterns, market profile, market
   breadth, Renko/Kagi/Point&Figure bars, Ehlers DSP cycles, risk/performance
   metrics — every single one updating in **O(1) per tick**. TA-Lib ships ~150 and
@@ -77,7 +77,7 @@ times to get there.
 - **Correct by construction, not by hope.** Every `update` validates its input,
   runs a real warmup, and returns an `Option` so a single bad tick can't silently
   poison state. `batch == streaming` is **bit-exact, fuzzed and 100 %-line-covered
-  for all 467 indicators**.
+  for all 474 indicators**.
 - **Orders of magnitude faster where it counts.** In streaming Wickra is **9–58×**
   faster than the only other incremental peer and **thousands of times** faster
   than recompute-on-every-tick libraries. On batch it wins several rows outright
@@ -95,7 +95,7 @@ Every other library forces one of those compromises. Wickra doesn't:
 
 | Library          | Install     | Streaming   | Languages                   | Indicators | Active |
 |------------------|-------------|-------------|-----------------------------|-----------:|--------|
-| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Python · Node · WASM · Rust** | **467** | **yes** |
+| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Python · Node · WASM · Rust** | **474** | **yes** |
 | kand             | clean       | yes         | Python · WASM · Rust        |       ~60  | yes    |
 | ta-rs            | clean       | yes         | Rust only                   |       ~30  | stale  |
 | yata             | clean       | partial     | Rust only                   |       ~35  | yes    |
@@ -128,7 +128,7 @@ Full tables (Rust + Python, streaming + batch) and how to reproduce them live in
 
 ## Indicators
 
-467 streaming-first indicators across twenty-four families. Every one passes the
+474 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).
@@ -146,7 +146,7 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 | 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, Mid Price, Mid Point, Average Price, Linear Regression Intercept, Time Series Forecast, Rolling Correlation, Rolling Covariance, OU Half-Life, Spread Hurst, Distance SSD, Beta-Neutral Spread, Variance Ratio, Granger Causality, Kalman Hedge Ratio, Spread Bollinger Bands, Spread AR(1) Coefficient, Jarque-Bera, Rolling Min-Max Scaler, Shannon Entropy, Sample Entropy, Kendall Tau |
 | Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Hilbert Phasor, Hilbert DC Phase, Hilbert Trend Mode, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline, Highpass Filter, Reflex, Trendflex, Correlation Trend Indicator, Adaptive RSI, Universal Oscillator, Adaptive CCI, Bandpass Filter, Even Better Sinewave, Autocorrelation Periodogram |
 | Pivots & S/R         | Classic Pivots, Fibonacci Pivots, Camarilla, Woodie Pivots, DeMark Pivots, Williams Fractals, ZigZag, Central Pivot Range, Murrey Math Lines, Andrews Pitchfork, Volume-Weighted Support/Resistance, Pivot Reversal |
-| 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 |
+| 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, TD Camouflage, TD Clop, TD Clopwin, TD Propulsion, TD Trap, TD D-Wave, TD Moving Averages |
 | Ichimoku & Charts    | Ichimoku Kinko Hyo (Tenkan, Kijun, Senkou A/B, Chikou), Heikin-Ashi |
 | Alt-Chart Bars       | Renko (box-size bricks), Kagi (reversal-amount lines), Point & Figure (X/O columns) |
 | Candlestick Patterns | Doji, Hammer, Inverted Hammer, Hanging Man, Shooting Star, Engulfing, Harami, Morning/Evening Star, Three White Soldiers/Black Crows, Piercing Line/Dark Cloud Cover, Marubozu, Tweezer, Spinning Top, Three Inside Up/Down, Three Outside Up/Down, Two Crows, Upside Gap Two Crows, Identical Three Crows, Three Line Strike, Three Stars in the South, Abandoned Baby, Advance Block, Belt-hold, Breakaway, Counterattack, Doji Star, Dragonfly Doji, Gravestone Doji, Long-Legged Doji, Rickshaw Man, Evening Doji Star, Morning Doji Star, Gap Side-by-Side White, High-Wave, Hikkake, Modified Hikkake, Homing Pigeon, On-Neck, In-Neck, Thrusting, Separating Lines, Kicking, Kicking by Length, Ladder Bottom, Mat Hold, Matching Low, Long Line, Short Line, Rising Three Methods, Falling Three Methods, Upside Gap Three Methods, Downside Gap Three Methods, Stalled Pattern, Stick Sandwich, Takuri, Closing Marubozu, Opening Marubozu, Tasuki Gap, Unique Three River, Concealing Baby Swallow |
@@ -237,7 +237,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 467 indicators
+│   ├── wickra-core/         core engine + all 474 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   ├── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 │   └── wickra-bench/        internal cross-library benchmark harness (not published)

package/package.json

@@ -5,7 +5,7 @@
     "kingchenc <support@wickra.org>"
   ],
   "description": "WASM bindings for the Wickra streaming-first technical indicators library.",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",

package/wickra_wasm.d.ts

@@ -4182,6 +4182,39 @@ export class T3 {
     warmupPeriod(): number;
 }
 
+export class TDCamouflage {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor();
+    reset(): void;
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
+export class TDClop {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor();
+    reset(): void;
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
+export class TDClopwin {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor();
+    reset(): void;
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class TDCombo {
     free(): void;
     [Symbol.dispose](): void;
@@ -4204,6 +4237,17 @@ export class TDCountdown {
     warmupPeriod(): number;
 }
 
+export class TDDWave {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(strength: number);
+    reset(): void;
+    update(high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class TDDeMarker {
     free(): void;
     [Symbol.dispose](): void;
@@ -4243,6 +4287,17 @@ export class TDLines {
     warmupPeriod(): number;
 }
 
+export class TDMovingAverage {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(high: Float64Array, low: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor(period_st1: number, period_st2: number);
+    reset(): void;
+    update(high: number, low: number): any;
+    warmupPeriod(): number;
+}
+
 export class TDOpen {
     free(): void;
     [Symbol.dispose](): void;
@@ -4265,6 +4320,17 @@ export class TDPressure {
     warmupPeriod(): number;
 }
 
+export class TDPropulsion {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor();
+    reset(): void;
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class TDREI {
     free(): void;
     [Symbol.dispose](): void;
@@ -4339,6 +4405,17 @@ export class TDSetup {
     warmupPeriod(): number;
 }
 
+export class TDTrap {
+    free(): void;
+    [Symbol.dispose](): void;
+    batch(open: Float64Array, high: Float64Array, low: Float64Array, close: Float64Array): Float64Array;
+    isReady(): boolean;
+    constructor();
+    reset(): void;
+    update(open: number, high: number, low: number, close: number): number | undefined;
+    warmupPeriod(): number;
+}
+
 export class TEMA {
     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 {
-    ADAPTIVECCI, ADAPTIVERSI, ADL, ADX, ADXR, ALMA, APO, ATR, AUTOCORRPGRAM, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, AndrewsPitchfork, Aroon, AroonOscillator, AtrBands, AtrRatchet, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BANDPASS, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BetterVolume, BipowerVariation, BodySizePct, BollingerBands, BollingerBandwidth, BomarBands, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CTI, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, CentralPivotRange, 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, EVENBETTERSINE, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, ElderRay, ElderSafeZone, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, EwmaVolatility, 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, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GrangerCausality, GravestoneDoji, HIGHPASS, 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, IntradayIntensity, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JARQUEBERA, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KaseDevStop, KasePermissionStochastic, KellyCriterion, Keltner, KendallTau, 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, MacdHistogram, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel, MedianMA, MedianPrice, Microprice, ModifiedMaStop, MorningDojiStar, MorningEveningStar, MurreyMathLines, NATR, NVI, NewHighsNewLows, Nrtr, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, POLARIZED_FRACTAL_EFFICIENCY, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PivotReversal, PointAndFigureBars, PpoHistogram, ProfitFactor, ProjectionBands, ProjectionOscillator, QQE, Qstick, QuartileBands, QuotedSpread, REFLEX, RMI, ROC, ROCP, ROCR, ROCR100, ROLLINGMINMAX, 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, SAMPLEENT, SAREXT, SHANNONENT, 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, TRENDFLEX, TREND_STRENGTH_INDEX, TRIMA, TRIX, TSF, TSI, TSV, TTM_TREND, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeBasedStop, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TradeVolumeIndex, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TsfOscillator, TtmSqueeze, TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice, UNIVERSALOSC, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VolatilityCone, VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, VolumeRsi, VolumeWeightedMacd, VolumeWeightedSr, Vortex, Vpin, VwapStdDevBands, WAVE_PM, WMA, Wad, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsAD, WilliamsFractals, WilliamsR, WinRate, WoodiePivots, YangZhangVolatility, YoyoExit, ZLEMA, ZScore, ZeroLagMACD, ZigZag, installPanicHook, version
+    ADAPTIVECCI, ADAPTIVERSI, ADL, ADX, ADXR, ALMA, APO, ATR, AUTOCORRPGRAM, AVGPRICE, AbandonedBaby, Abcd, AbsoluteBreadthIndex, AccelerationBands, AcceleratorOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerre, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Alligator, Alpha, AmihudIlliquidity, AnchoredRSI, AnchoredVWAP, AndrewsPitchfork, Aroon, AroonOscillator, AtrBands, AtrRatchet, AtrTrailingStop, AutoFib, Autocorrelation, AverageDailyRange, AverageDrawdown, AwesomeOscillator, AwesomeOscillatorHistogram, BANDPASS, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BetterVolume, BipowerVariation, BodySizePct, BollingerBands, BollingerBandwidth, BomarBands, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CCI, CFO, CMO, CTI, CalendarSpread, CalmarRatio, Camarilla, CenterOfGravity, CentralPivotRange, 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, EVENBETTERSINE, EVWMA, EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, ElderRay, ElderSafeZone, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, EwmaVolatility, 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, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GrangerCausality, GravestoneDoji, HIGHPASS, 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, IntradayIntensity, IntradayVolatilityProfile, InverseFisherTransform, InvertedHammer, JARQUEBERA, JMA, JumpIndicator, KAMA, KST, KVO, KagiBars, KalmanHedgeRatio, KaseDevStop, KasePermissionStochastic, KellyCriterion, Keltner, KendallTau, 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, MacdHistogram, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel, MedianMA, MedianPrice, Microprice, ModifiedMaStop, MorningDojiStar, MorningEveningStar, MurreyMathLines, NATR, NVI, NewHighsNewLows, Nrtr, OBV, OIPriceDivergence, OIWeighted, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, PGO, PLUS_DI, PLUS_DM, PMO, POLARIZED_FRACTAL_EFFICIENCY, PPO, PSAR, PVI, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, PiercingDarkCloud, PivotReversal, PointAndFigureBars, PpoHistogram, ProfitFactor, ProjectionBands, ProjectionOscillator, QQE, Qstick, QuartileBands, QuotedSpread, REFLEX, RMI, ROC, ROCP, ROCR, ROCR100, ROLLINGMINMAX, 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, SAMPLEENT, SAREXT, SHANNONENT, 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, TDCamouflage, TDClop, TDClopwin, TDCombo, TDCountdown, TDDWave, TDDeMarker, TDDifferential, TDLines, TDMovingAverage, TDOpen, TDPressure, TDPropulsion, TDREI, TDRangeProjection, TDRiskLevel, TDSequential, TDSetup, TDTrap, TEMA, TII, TRENDFLEX, TREND_STRENGTH_INDEX, TRIMA, TRIX, TSF, TSI, TSV, TTM_TREND, TakerBuySellRatio, Takuri, TasukiGap, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, TimeBasedStop, TimeOfDayReturnProfile, TpoProfile, TradeImbalance, TradeVolumeIndex, TrendLabel, TreynorRatio, Triangle, Trin, TripleTopBottom, TrueRange, TsfOscillator, TtmSqueeze, TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice, UNIVERSALOSC, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, VIDYA, VWAP, VWMA, VZO, ValueArea, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, VolatilityCone, VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, VolumeRsi, VolumeWeightedMacd, VolumeWeightedSr, Vortex, Vpin, VwapStdDevBands, WAVE_PM, WMA, Wad, 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

@@ -29981,6 +29981,276 @@ export class T3 {
 }
 if (Symbol.dispose) T3.prototype[Symbol.dispose] = T3.prototype.free;
 
+export class TDCamouflage {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDCamouflageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdcamouflage_free(ptr, 0);
+    }
+    /**
+     * @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.tdcamouflage_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.tdcamouflage_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tdcamouflage_new();
+        this.__wbg_ptr = ret;
+        TDCamouflageFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tdcamouflage_reset(this.__wbg_ptr);
+    }
+    /**
+     * @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.tdcamouflage_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.tdcamouflage_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDCamouflage.prototype[Symbol.dispose] = TDCamouflage.prototype.free;
+
+export class TDClop {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDClopFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdclop_free(ptr, 0);
+    }
+    /**
+     * @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.tdclop_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.tdclop_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tdclop_new();
+        this.__wbg_ptr = ret;
+        TDClopFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tdclop_reset(this.__wbg_ptr);
+    }
+    /**
+     * @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.tdclop_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.tdclop_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDClop.prototype[Symbol.dispose] = TDClop.prototype.free;
+
+export class TDClopwin {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDClopwinFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdclopwin_free(ptr, 0);
+    }
+    /**
+     * @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.tdclopwin_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.tdclopwin_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tdclopwin_new();
+        this.__wbg_ptr = ret;
+        TDClopwinFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tdclopwin_reset(this.__wbg_ptr);
+    }
+    /**
+     * @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.tdclopwin_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.tdclopwin_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDClopwin.prototype[Symbol.dispose] = TDClopwin.prototype.free;
+
 export class TDCombo {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -30135,10 +30405,110 @@ export class TDCountdown {
      * @param {number} countdown_lookback
      * @param {number} countdown_target
      */
-    constructor(setup_lookback, setup_target, countdown_lookback, countdown_target) {
+    constructor(setup_lookback, setup_target, countdown_lookback, countdown_target) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tdcountdown_new(retptr, setup_lookback, setup_target, countdown_lookback, countdown_target);
+            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;
+            TDCountdownFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.tdcountdown_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.tdcountdown_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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    warmupPeriod() {
+        const ret = wasm.tdcountdown_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDCountdown.prototype[Symbol.dispose] = TDCountdown.prototype.free;
+
+export class TDDWave {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDDWaveFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tddwave_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.tddwave_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.tddwave_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} strength
+     */
+    constructor(strength) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.tdcountdown_new(retptr, setup_lookback, setup_target, countdown_lookback, countdown_target);
+            wasm.tddwave_new(retptr, strength);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -30146,14 +30516,14 @@ export class TDCountdown {
                 throw takeObject(r1);
             }
             this.__wbg_ptr = r0;
-            TDCountdownFinalization.register(this, this.__wbg_ptr, this);
+            TDDWaveFinalization.register(this, this.__wbg_ptr, this);
             return this;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     reset() {
-        wasm.tdcountdown_reset(this.__wbg_ptr);
+        wasm.tddwave_reset(this.__wbg_ptr);
     }
     /**
      * @param {number} high
@@ -30164,7 +30534,7 @@ export class TDCountdown {
     update(high, low, close) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-            wasm.tdcountdown_update(retptr, this.__wbg_ptr, high, low, close);
+            wasm.tddwave_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);
@@ -30181,11 +30551,11 @@ export class TDCountdown {
      * @returns {number}
      */
     warmupPeriod() {
-        const ret = wasm.tdcountdown_warmupPeriod(this.__wbg_ptr);
+        const ret = wasm.tddwave_warmupPeriod(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
-if (Symbol.dispose) TDCountdown.prototype[Symbol.dispose] = TDCountdown.prototype.free;
+if (Symbol.dispose) TDDWave.prototype[Symbol.dispose] = TDDWave.prototype.free;
 
 export class TDDeMarker {
     __destroy_into_raw() {
@@ -30471,6 +30841,102 @@ export class TDLines {
 }
 if (Symbol.dispose) TDLines.prototype[Symbol.dispose] = TDLines.prototype.free;
 
+export class TDMovingAverage {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDMovingAverageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdmovingaverage_free(ptr, 0);
+    }
+    /**
+     * @param {Float64Array} high
+     * @param {Float64Array} low
+     * @returns {Float64Array}
+     */
+    batch(high, low) {
+        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;
+            wasm.tdmovingaverage_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.tdmovingaverage_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} period_st1
+     * @param {number} period_st2
+     */
+    constructor(period_st1, period_st2) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tdmovingaverage_new(retptr, period_st1, period_st2);
+            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;
+            TDMovingAverageFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    reset() {
+        wasm.tdmovingaverage_reset(this.__wbg_ptr);
+    }
+    /**
+     * @param {number} high
+     * @param {number} low
+     * @returns {any}
+     */
+    update(high, low) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tdmovingaverage_update(retptr, this.__wbg_ptr, high, low);
+            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.tdmovingaverage_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDMovingAverage.prototype[Symbol.dispose] = TDMovingAverage.prototype.free;
+
 export class TDOpen {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -30669,6 +31135,96 @@ export class TDPressure {
 }
 if (Symbol.dispose) TDPressure.prototype[Symbol.dispose] = TDPressure.prototype.free;
 
+export class TDPropulsion {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDPropulsionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdpropulsion_free(ptr, 0);
+    }
+    /**
+     * @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.tdpropulsion_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.tdpropulsion_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tdpropulsion_new();
+        this.__wbg_ptr = ret;
+        TDPropulsionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tdpropulsion_reset(this.__wbg_ptr);
+    }
+    /**
+     * @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.tdpropulsion_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.tdpropulsion_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDPropulsion.prototype[Symbol.dispose] = TDPropulsion.prototype.free;
+
 export class TDREI {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -31164,6 +31720,96 @@ export class TDSetup {
 }
 if (Symbol.dispose) TDSetup.prototype[Symbol.dispose] = TDSetup.prototype.free;
 
+export class TDTrap {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TDTrapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tdtrap_free(ptr, 0);
+    }
+    /**
+     * @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.tdtrap_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.tdtrap_isReady(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    constructor() {
+        const ret = wasm.tdtrap_new();
+        this.__wbg_ptr = ret;
+        TDTrapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    reset() {
+        wasm.tdtrap_reset(this.__wbg_ptr);
+    }
+    /**
+     * @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.tdtrap_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.tdtrap_warmupPeriod(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) TDTrap.prototype[Symbol.dispose] = TDTrap.prototype.free;
+
 export class TEMA {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -39778,12 +40424,24 @@ const TakuriFinalization = (typeof FinalizationRegistry === 'undefined')
 const TasukiGapFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tasukigap_free(ptr, 1));
+const TDCamouflageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdcamouflage_free(ptr, 1));
+const TDClopFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdclop_free(ptr, 1));
+const TDClopwinFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdclopwin_free(ptr, 1));
 const TDComboFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdcombo_free(ptr, 1));
 const TDCountdownFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdcountdown_free(ptr, 1));
+const TDDWaveFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tddwave_free(ptr, 1));
 const TDDeMarkerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tddemarker_free(ptr, 1));
@@ -39793,12 +40451,18 @@ const TDDifferentialFinalization = (typeof FinalizationRegistry === 'undefined')
 const TDLinesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdlines_free(ptr, 1));
+const TDMovingAverageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdmovingaverage_free(ptr, 1));
 const TDOpenFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdopen_free(ptr, 1));
 const TDPressureFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdpressure_free(ptr, 1));
+const TDPropulsionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdpropulsion_free(ptr, 1));
 const TDRangeProjectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdrangeprojection_free(ptr, 1));
@@ -39814,6 +40478,9 @@ const TDSequentialFinalization = (typeof FinalizationRegistry === 'undefined')
 const TDSetupFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tdsetup_free(ptr, 1));
+const TDTrapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tdtrap_free(ptr, 1));
 const TEMAFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tema_free(ptr, 1));