qntjs-lib 1.0.0

package/dist/ta/momentum-oscillators/apo.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Absolute Price Oscillator (APO).
+ * Computes the difference between a short and a long EMA of `src`.
+ * Skips NaNs and seeds EMAs on the first valid value; returns NaN
+ * for indices before both EMAs have filled.
+ * @param src Input series
+ * @param shortPeriod Short EMA period
+ * @param longPeriod Long EMA period
+ * @returns Float64Array of APO values (NaN where undefined)
+ */
+export declare function apo(src: ArrayLike<number>, shortPeriod: number, longPeriod: number): Float64Array;

package/dist/ta/momentum-oscillators/aroon.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Aroon indicator: returns `[up, down]` arrays in percentage form (0-100)
+ * describing the time since the highest/lowest value within the lookback
+ * `period`. Supports NaN-aware and dense fast-paths.
+ * @param high High price series
+ * @param low Low price series
+ * @param period Lookback period (>0)
+ * @param skipna When true ignore NaNs in windows; false forces dense path
+ * @returns Tuple `[up, down]` Float64Array indicators
+ */
+export declare function aroon(high: ArrayLike<number>, low: ArrayLike<number>, period: number, skipna?: boolean): [Float64Array, Float64Array];

package/dist/ta/momentum-oscillators/cmo.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Chande Momentum Oscillator (CMO).
+ * Computes CMO over `period` using percent scaling in [-100, 100].
+ * Ignores NaNs in the input deltas; positions before the first
+ * computable value are NaN.
+ * @param src Input series
+ * @param period Period over which to compute the oscillator
+ * @returns Float64Array of CMO values (NaN where undefined)
+ */
+export declare function cmo(src: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/momentum-oscillators/index.d.ts

@@ -0,0 +1,14 @@
+export * from './ao.js';
+export * from './apo.js';
+export * from './cmo.js';
+export * from './macd.js';
+export * from './mom.js';
+export * from './ppo.js';
+export * from './roc.js';
+export * from './rsi.js';
+export * from './stoch.js';
+export * from './stochrsi.js';
+export * from './ultosc.js';
+export * from './wpr.js';
+export * from './aroon.js';
+export * from './kst.js';

package/dist/ta/momentum-oscillators/kst.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Know Sure Thing (KST) momentum oscillator
+ * Default parameters match common KST configuration
+ */
+export type KstOptions = {
+    r1?: number;
+    r2?: number;
+    r3?: number;
+    r4?: number;
+    n1?: number;
+    n2?: number;
+    n3?: number;
+    n4?: number;
+    w1?: number;
+    w2?: number;
+    w3?: number;
+    w4?: number;
+};
+/**
+ * Know Sure Thing (KST) momentum oscillator.
+ * Computes a weighted sum of smoothed rate-of-change series.
+ * Parameters may be supplied via the `options` object or defaults are used.
+ * The output length equals `src.length`; positions before the required
+ * lookback periods are NaN.
+ * @param src Input series
+ * @param options Optional parameters for ROC and smoothing windows
+ * @returns Float64Array of KST values (NaN where insufficient data)
+ */
+export declare function kst(src: ArrayLike<number>, options?: KstOptions): Float64Array;

package/dist/ta/momentum-oscillators/macd.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Moving Average Convergence Divergence (MACD).
+ * Produces the MACD line (short EMA - long EMA), the signal line (EMA of MACD),
+ * and the histogram (MACD - signal). Skips NaNs and seeds EMAs on first valid
+ * value; outputs are NaN until the EMAs and signal have seeded.
+ * @param src Input series
+ * @param shortPeriod Short EMA period
+ * @param longPeriod Long EMA period
+ * @param signalPeriod Signal EMA period
+ * @returns Tuple `[macdLine, signalLine, histogram]` as Float64Array
+ */
+export declare function macd(src: ArrayLike<number>, shortPeriod: number, longPeriod: number, signalPeriod: number): [Float64Array, Float64Array, Float64Array];

package/dist/ta/momentum-oscillators/mom.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Momentum (difference) indicator.
+ * Computes `src[i] - src[i - period]` for each index; positions where
+ * the lagged value is not available are NaN.
+ * @param src Input series
+ * @param period Lag period (must be > 0)
+ * @returns Float64Array of momentum values (NaN where undefined)
+ */
+export declare function mom(src: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/momentum-oscillators/ppo.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Percentage Price Oscillator (PPO).
+ * PPO = 100 * (EMA_short - EMA_long) / EMA_long.
+ * Skips NaNs and seeds EMAs on first valid value; outputs are NaN until the
+ * long EMA has enough data. When EMA_long is zero, returns 0 to avoid division.
+ * @param src Input series
+ * @param shortPeriod Short EMA period
+ * @param longPeriod Long EMA period
+ * @returns Float64Array of PPO values (NaN where undefined)
+ */
+export declare function ppo(src: ArrayLike<number>, shortPeriod: number, longPeriod: number): Float64Array;

package/dist/ta/momentum-oscillators/roc.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Simple change over `period`.
+ * Computes `src[i] - src[i-period]` for each index `i >= period`.
+ * Outputs NaN for indices before `period` and propagates NaNs for invalid pairs.
+ * @param src Input series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of simple change values (NaN where undefined)
+ */
+export declare function change(src: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Percentage Rate-of-Change (ROC).
+ * Returns 100 * (src[i] - src[i-period]) / src[i-period]. NaN is returned
+ * for indices before `period` or when a denominator is NaN/zero.
+ * @param src Input series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of ROC values (NaN where undefined)
+ */
+export declare function roc(src: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/momentum-oscillators/rsi.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Relative Strength Index (RSI) with optional NaN-aware behavior.
+ * - `skipna=false` (dense path): assumes inputs contain no NaNs or that NaN
+ *   propagation is desired; uses a dense fast-path implementation.
+ * - `skipna=true` (NaN-aware): skips NaNs when computing deltas and preserves
+ *   gaps in the output where insufficient valid data exists.
+ * Seeding: the implementation seeds on the first valid value and uses Wilder
+ * smoothing once the initial window is filled.
+ * @param src Input series
+ * @param period Lookback period for RSI (must be > 0)
+ * @param skipna Whether to ignore NaNs during computation (default: true)
+ * @returns Float64Array of RSI values (NaN where undefined)
+ */
+export declare function rsi(src: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;

package/dist/ta/momentum-oscillators/stoch.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stochastic oscillator (fast %K and %D smoothed outputs).
+ * Computes fast %K based on rolling highest/lowest over `kPeriod`, then
+ * smooths with `kSlow` and `dPeriod` using dense SMA. Assumes input series
+ * length equality and returns NaN when insufficient data exists.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param kPeriod %K lookback period
+ * @param kSlow Smoothing period for %K
+ * @param dPeriod Smoothing period for %D
+ * @returns Tuple `[slowK, slowD]` as Float64Array
+ */
+export declare function stoch(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, kPeriod: number, kSlow: number, dPeriod: number): [Float64Array, Float64Array];

package/dist/ta/momentum-oscillators/stochrsi.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stochastic RSI.
+ * Applies a stochastic calculation to the RSI series, producing values in [0,1].
+ * This implementation is NaN-aware and maintains deques over valid RSI samples.
+ * @param close Close price series
+ * @param period RSI lookback period
+ * @returns Float64Array of StochRSI values (NaN where undefined)
+ */
+export declare function stochrsi(close: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/momentum-oscillators/ultosc.d.ts

@@ -0,0 +1,17 @@
+export type UltoscOptions = {
+    s1?: number;
+    s2?: number;
+    s3?: number;
+};
+/**
+ * Ultimate Oscillator (ULTOSC).
+ * Combines short-, mid-, and long-term averages of the buying pressure / true range
+ * to produce a bounded oscillator in [0,100]. Preserves NaN inputs and returns
+ * NaN for indices before the longest lookback has sufficient data.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param options Optional periods for short/mid/long (s1,s2,s3)
+ * @returns Float64Array of Ultimate Oscillator values (NaN where undefined)
+ */
+export declare function ultosc(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, options?: UltoscOptions): Float64Array;

package/dist/ta/momentum-oscillators/wpr.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Williams %R (WPR).
+ * Computes %R = (highestHigh - close) / (highestHigh - lowestLow) * -100
+ * over a rolling `period`. Uses `rollminmax` to compute window extrema and
+ * returns NaN for indices before `period` or when the range is zero.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of %R values (NaN where undefined)
+ */
+export declare function wpr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/dema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Double Exponential Moving Average (DEMA).
+ * DEMA reduces lag by combining a single EMA and a double-smoothed EMA:
+ * DEMA = 2 * EMA(source, period) - EMA(EMA(source, period), period).
+ * Preserves NaN gaps and follows the same seeding semantics as `ema`.
+ * @param source Input series
+ * @param period Smoothing period (must be > 0)
+ * @returns Float64Array of DEMA values (NaN where undefined)
+ */
+export declare function dema(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/ema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Exponential Moving Average (EMA).
+ * Seeds on the first non-NaN value and uses the standard EMA recurrence.
+ * Preserves NaN gaps in the input: outputs are NaN until enough valid samples
+ * have been seen to initialize the EMA.
+ * @param source Input series
+ * @param period Smoothing period (must be > 0)
+ * @returns Float64Array of EMA values (NaN where undefined)
+ */
+export declare function ema(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/hma.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hull Moving Average (HMA).
+ * Computes a lower-lag smoothing by combining WMAs at different lengths
+ * and then applying a final WMA on the derived series. Pine-compatible
+ * and NaN-aware: NaNs propagate where insufficient valid samples exist.
+ * @param source Input series
+ * @param period Window length (must be > 0)
+ * @returns Float64Array of HMA values (NaN where undefined)
+ */
+export declare function hma(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/index.d.ts

@@ -0,0 +1,11 @@
+export * from './sma.js';
+export * from './ema.js';
+export * from './wma.js';
+export * from './vwma.js';
+export * from './dema.js';
+export * from './trima.js';
+export * from './tema.js';
+export * from './hma.js';
+export * from './kama.js';
+export * from './rma.js';
+export * from './t3.js';

package/dist/ta/moving-averages/kama.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Kaufman Adaptive Moving Average (KAMA).
+ * Adapts smoothing based on the efficiency ratio (market noise vs direction).
+ * This implementation supports NaN-aware and dense fast-paths; when NaNs are
+ * present the compacting + mapping strategy is used, otherwise an O(n)
+ * incremental volatility approach is used for speed.
+ * @param source Input series
+ * @param period Efficiency smoothing lookback (must be > 0)
+ * @param fastPeriod Fast smoothing period (default: 2)
+ * @param slowPeriod Slow smoothing period (default: 30)
+ * @param skipna Whether to ignore NaNs (default: true)
+ * @returns Float64Array of KAMA values (NaN where undefined)
+ */
+export declare function kama(source: ArrayLike<number>, period: number, fastPeriod?: number, slowPeriod?: number, skipna?: boolean): Float64Array;

package/dist/ta/moving-averages/rma.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wilder's Moving Average / RMA.
+ * Implements the Wilder smoothing recurrence (rma = (rma*(period-1) + x)/period).
+ * When `skipna` is true NaNs are ignored during seeding and updates; otherwise
+ * a dense fast-path is used for NaN-free inputs.
+ * @param source Input series
+ * @param period Smoothing period (must be > 0)
+ * @param skipna Whether to ignore NaNs during computation (default: true)
+ * @returns Float64Array of RMA values (NaN before window fills)
+ */
+export declare function rma(source: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;

package/dist/ta/moving-averages/sma.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple Moving Average (SMA).
+ * Computes the arithmetic mean over a sliding window.
+ * When `skipna` is true, NaNs inside the window are ignored; when false
+ * a dense fast-path is used (assumes no NaNs).
+ * @param source Input series
+ * @param period Window length (must be > 0)
+ * @param skipna Whether to ignore NaNs inside windows (default: true)
+ * @returns Float64Array of SMA values (NaN before window fills)
+ */
+export declare function sma(source: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;

package/dist/ta/moving-averages/t3.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Triple Exponential Moving Average (T3)
+ *
+ * T3 is a triple-smoothed moving average developed by Tim Tillson that reduces lag
+ * and smoothing compared to traditional EMAs while maintaining responsiveness to price changes.
+ *
+ * @param source - Input data array
+ * @param period - Smoothing period (default: 5)
+ * @param volumeFactor - Volume factor for smoothing (default: 0.7)
+ * @returns T3 values
+ */
+/**
+ * Triple Exponential Moving Average (T3)
+ *
+ * Implemented following TA‑Lib's algorithm (see TA_T3 C implementation).
+ * This inlines the nested EMA seeding (e1..e6) and performs a single-pass
+ * update, which is significantly faster than calling `ema()` six times.
+ *
+ * Notes:
+ * - Lookback = 6 * (period - 1)
+ * - For inputs containing NaNs we propagate NaN outputs where we cannot
+ *   compute valid seeds or updates.
+ */
+export declare function t3(source: ArrayLike<number>, period: number, volumeFactor: number): Float64Array;

package/dist/ta/moving-averages/tema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Triple Exponential Moving Average (TEMA).
+ * Combines three nested EMAs to reduce lag while smoothing:
+ * TEMA = 3*EMA1 - 3*EMA2 + EMA3. Preserves NaN gaps and seeds
+ * each EMA before emitting values.
+ * @param source Input series
+ * @param period Smoothing period (must be > 0)
+ * @returns Float64Array of TEMA values (NaN where undefined)
+ */
+export declare function tema(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/trima.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Triangular Moving Average (TRIMA).
+ * A triangular-weighted moving average implemented via two `sma` passes.
+ * Preserves NaN handling by delegating to `sma` implementations.
+ * @param source Input series
+ * @param period Window length (must be > 0)
+ * @returns Float64Array of TRIMA values (NaN where undefined)
+ */
+export declare function trima(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/moving-averages/vwma.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Volume Weighted Moving Average (VWMA).
+ * Computes pvSum / vSum over a sliding window, NaN-aware. When `skipna` is
+ * true NaNs in either series are ignored within the window; when false a
+ * dense fast-path is used (assumes no NaNs).
+ * @param price Price series
+ * @param volume Volume series
+ * @param period Window length (>0)
+ * @param skipna Whether to ignore NaNs inside windows (default: true)
+ * @returns Float64Array of VWMA values (NaN before window fills)
+ */
+export declare function vwma(price: ArrayLike<number>, volume: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;
+/**
+ * Fast VWMA for dense data (no NaNs).
+ * O(n) sliding window: classic pvSum / vSum.
+ */
+export declare function vwmaDense(price: ArrayLike<number>, volume: ArrayLike<number>, period: number, result: Float64Array): Float64Array;

package/dist/ta/moving-averages/wma.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Weighted Moving Average (WMA).
+ * Computes a linearly-weighted average over a sliding window with weights
+ * 1..period (oldest..newest). When `skipna` is true NaNs are ignored
+ * within the window; when false a dense fast-path is used.
+ * @param source Input series
+ * @param period Window length (must be > 0)
+ * @param skipna Whether to ignore NaNs inside windows (default: true)
+ * @returns Float64Array of WMA values (NaN before window fills)
+ */
+export declare function wma(source: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;

package/dist/ta/trend/cci.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Commodity Channel Index (CCI).
+ * Computes the typical price (TP) and compares to a moving average and
+ * mean absolute deviation (MAD) scaled by 0.015. Positions before the
+ * full lookback or with invalid inputs are NaN.
+ * Performance: O(n*p) due to MAD recomputation per window.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of CCI values (NaN where undefined)
+ */
+export declare function cci(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/trend/di.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Directional Indicators (DI+ and DI-).
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Tuple `[diplus, diminus]` as Float64Array
+ */
+export declare function di(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): [Float64Array, Float64Array];
+/**
+ * DX (Directional Movement Index).
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of DX values (NaN where undefined)
+ */
+export declare function dx(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Average Directional Index (ADX).
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of ADX values (NaN where undefined)
+ */
+export declare function adx(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;
+/**
+ * ADXR (Average DX Rating) - smoothed ADX.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of ADXR values (NaN where undefined)
+ */
+export declare function adxr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/trend/dpo.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Detrended Price Oscillator (DPO).
+ * Computes DPO[i] = source[i - shift] - SMA(source, period)[i], where
+ * shift = floor(period/2) + 1. Outputs are NaN for indices before the
+ * shift or when insufficient data exists.
+ * @param source Input series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of DPO values (NaN where undefined)
+ */
+export declare function dpo(source: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/trend/ichimoku.d.ts

@@ -0,0 +1,20 @@
+export type IchimokuOptions = {
+    tenkan?: number;
+    kijun?: number;
+    senkouB?: number;
+};
+export declare const DEFAULT_TENKAN = 9;
+export declare const DEFAULT_KIJUN = 26;
+export declare const DEFAULT_SENKOUB = 52;
+/**
+ * Ichimoku Kinko Hyo indicator components.
+ * Returns `[tenkan, kijun, senkouA, senkouB, chikou]` where senkou lines
+ * are shifted forward by the `kijun` displacement and chikou is the close
+ * shifted backward. NaN is produced where rolling inputs are invalid.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param options Optional periods `{ tenkan, kijun, senkouB }`
+ * @returns Tuple of Float64Array: `[tenkan, kijun, senkouA, senkouB, chikou]`
+ */
+export declare function ichimoku(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, options?: IchimokuOptions): [Float64Array, Float64Array, Float64Array, Float64Array, Float64Array];

package/dist/ta/trend/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cci.js';
+export * from './di.js';
+export * from './dpo.js';
+export * from './psar.js';
+export * from './supertrend.js';
+export * from './ichimoku.js';

package/dist/ta/trend/psar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parabolic SAR (PSAR) indicator.
+ * @param high High price series
+ * @param low Low price series
+ * @param step Acceleration step increment (>0)
+ * @param maxStep Maximum acceleration value (>= step)
+ * @param skipna When true ignore NaNs; when false use dense fast-path
+ * @returns Float64Array PSAR values (NaN for undefined positions)
+ */
+export declare function psar(high: ArrayLike<number>, low: ArrayLike<number>, step: number, maxStep: number, skipna?: boolean): Float64Array;

package/dist/ta/trend/supertrend.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Supertrend indicator.
+ * Returns `[supertrend, finalUpper, finalLower, isUpMask]`.
+ * `supertrend` contains the plotted trend line (either finalLower when up or finalUpper when down),
+ * `finalUpper`/`finalLower` are the band values, and `isUpMask` is a Uint8Array mask (1 when up).
+ * NaNs are preserved for invalid inputs or before enough data is available.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period ATR lookback period
+ * @param mult Multiplier applied to ATR to form bands
+ * @returns Tuple `[supertrend, finalUpper, finalLower, isUpMask]`
+ */
+export declare function supertrend(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number, mult: number): [Float64Array, Float64Array, Float64Array, Uint8Array];

package/dist/ta/util.d.ts

@@ -0,0 +1,53 @@
+/**
+ * TA utility helpers for small boolean/rolling operations used by indicators.
+ * Includes functions for detecting rising/falling masks and crosses with
+ * strict NaN-aware semantics by default.
+ */
+/**
+ * Determine whether global dense optimization should be skipped. Useful for
+ * tests that need to exercise NaN-aware code paths by setting
+ * `SKIP_DENSE_OPTIMIZATION=true` in the environment.
+ * @returns `true` when dense optimizations should be skipped
+ */
+export declare function shouldSkipDenseOptimization(): boolean;
+/**
+ * Rising mask: returns a Uint8Array where `1` indicates `source[i]` is
+ * strictly greater than the value `length` periods ago (NaN-aware).
+ * When `skipna` is true, NaNs are tolerated and preserved; when false a
+ * dense fast-path is used (assumes no NaNs).
+ * @param source Input numeric series
+ * @param length Lookback length (>0)
+ * @param skipna Whether to ignore NaNs during computation (default: true)
+ * @returns Uint8Array mask with 0/1 values
+ */
+export declare function rising(source: ArrayLike<number>, length: number, skipna?: boolean): Uint8Array;
+/**
+ * Falling mask: returns a Uint8Array where `1` indicates `source[i]` is
+ * strictly less than the value `length` periods ago (NaN-aware).
+ * When `skipna` is true, NaNs are tolerated and preserved; when false a
+ * dense fast-path is used (assumes no NaNs).
+ * @param source Input numeric series
+ * @param length Lookback length (>0)
+ * @param skipna Whether to ignore NaNs during computation (default: true)
+ * @returns Uint8Array mask with 0/1 values
+ */
+export declare function falling(source: ArrayLike<number>, length: number, skipna?: boolean): Uint8Array;
+/**
+ * Test whether series `a` crosses `b` (or a scalar) between the previous and
+ * current index. By default uses a symmetric cross test that detects both
+ * upward and downward crossings. Comparisons are strict and require non-NaN
+ * current and previous values for both operands.
+ * @param a Left series
+ * @param b Right series or scalar
+ * @param test Optional custom comparator receiving (ai, aim1, bi, bim1)
+ * @returns Uint8Array mask where 1 indicates a crossing at that index
+ */
+export declare function cross(a: ArrayLike<number>, b: ArrayLike<number> | number, test?: (ai: number, aim1: number, bi: number, bim1: number) => boolean): Uint8Array;
+/**
+ * Detect an upward crossover (a crosses above b).
+ */
+export declare function crossover(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Detect a downward crossunder (a crosses below b).
+ */
+export declare function crossunder(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;

package/dist/ta/volatility/atr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * True Range (TR).
+ * TR[i] = max(high[i]-low[i], |high[i]-close[i-1]|, |low[i]-close[i-1]|).
+ * Preserves NaNs and returns NaN where inputs are invalid.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @returns Float64Array of TR values
+ */
+export declare function tr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>): Float64Array;
+/**
+ * Average True Range (ATR).
+ * Computes ATR using Wilder's RMA over the true-range series. Handles NaNs
+ * via the `rma` NaN-aware implementation; returns NaN for indices before the
+ * lookback is filled.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @returns Float64Array of ATR values
+ */
+export declare function atr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;
+export declare function natr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number): Float64Array;

package/dist/ta/volatility/bb.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bollinger Bands (BB).
+ * Returns `[middle, upper, lower]` where `middle` is the SMA, and `upper`/`lower`
+ * are `middle ± mult * stddev`. Uses a NaN-aware or dense `rollstdev` depending
+ * on input; positions before the window fills are NaN.
+ * @param source Input series
+ * @param period Window length (must be > 0)
+ * @param mult Standard-deviation multiplier
+ * @returns Tuple `[middle, upper, lower]` as Float64Array
+ */
+export declare function bb(source: ArrayLike<number>, period: number, mult: number): [Float64Array, Float64Array, Float64Array];

package/dist/ta/volatility/bbw.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bollinger Band Width (BBW).
+ * Returns the normalized width of the Bollinger Bands as percentage: `100*(upper-lower)/middle`.
+ * NaNs propagate and positions with `middle === 0` leave the output unchanged (NaN or 0).
+ * @param source Input series
+ * @param period Window length
+ * @param mult Standard-deviation multiplier used for BB
+ * @returns Float64Array of BB width percentages
+ */
+export declare function bbw(source: ArrayLike<number>, period: number, mult: number): Float64Array;

package/dist/ta/volatility/donchian.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Donchian Channels.
+ * Returns `[upper, lower, middle]` where `upper` is the highest high
+ * and `lower` the lowest low over the lookback `period`. `middle` is the
+ * midpoint. NaNs propagate when inputs are invalid.
+ * @param high High price series
+ * @param low Low price series
+ * @param period Lookback period (must be > 0)
+ * @returns Tuple `[upper, lower, middle]` as Float64Array
+ */
+export declare function donchian(high: ArrayLike<number>, low: ArrayLike<number>, period: number): [Float64Array, Float64Array, Float64Array];

package/dist/ta/volatility/index.d.ts

@@ -0,0 +1,5 @@
+export * from './atr.js';
+export * from './bb.js';
+export * from './bbw.js';
+export * from './donchian.js';
+export * from './keltner.js';

package/dist/ta/volatility/keltner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Keltner Channels.
+ * Returns `[middle(EMA of typical price), upper, lower]` where upper/lower are `middle ± mult * ATR`.
+ * Preserves NaNs when inputs are invalid.
+ * @param high High price series
+ * @param low Low price series
+ * @param close Close price series
+ * @param period Lookback period (must be > 0)
+ * @param mult Multiplier applied to ATR
+ * @returns Tuple `[middle, upper, lower]` as Float64Array
+ */
+export declare function keltner(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period: number, mult: number): [Float64Array, Float64Array, Float64Array];