qntjs-lib 1.0.1 → 1.1.0

package/dist/bundle/index.d.ts

@@ -354,98 +354,98 @@ declare function olsMulti(X: number[][], y: number[]): number[] | null;
  * the `src/math` submodules for convenient imports.
  */
 
-declare const index_d$2_abs: typeof abs;
-declare const index_d$2_add: typeof add;
-declare const index_d$2_and: typeof and;
-declare const index_d$2_argmax: typeof argmax;
-declare const index_d$2_argmin: typeof argmin;
-declare const index_d$2_avg: typeof avg;
-declare const index_d$2_ceil: typeof ceil;
-declare const index_d$2_clamp: typeof clamp;
-declare const index_d$2_cummax: typeof cummax;
-declare const index_d$2_cummin: typeof cummin;
-declare const index_d$2_cumprod: typeof cumprod;
-declare const index_d$2_cumsum: typeof cumsum;
-declare const index_d$2_diff: typeof diff;
-declare const index_d$2_div: typeof div;
-declare const index_d$2_dot: typeof dot;
-declare const index_d$2_eq: typeof eq;
-declare const index_d$2_floor: typeof floor;
-declare const index_d$2_gt: typeof gt;
-declare const index_d$2_gte: typeof gte;
-declare const index_d$2_lt: typeof lt;
-declare const index_d$2_lte: typeof lte;
-declare const index_d$2_max: typeof max;
-declare const index_d$2_min: typeof min;
-declare const index_d$2_mul: typeof mul;
-declare const index_d$2_neq: typeof neq;
-declare const index_d$2_norm: typeof norm;
-declare const index_d$2_not: typeof not;
-declare const index_d$2_ols: typeof ols;
-declare const index_d$2_olsMulti: typeof olsMulti;
-declare const index_d$2_or: typeof or;
-declare const index_d$2_prod: typeof prod;
-declare const index_d$2_randnormal: typeof randnormal;
-declare const index_d$2_randuniform: typeof randuniform;
-declare const index_d$2_rollargmax: typeof rollargmax;
-declare const index_d$2_rollargmin: typeof rollargmin;
-declare const index_d$2_rollmax: typeof rollmax;
-declare const index_d$2_rollmin: typeof rollmin;
-declare const index_d$2_rollminmax: typeof rollminmax;
-declare const index_d$2_rollprod: typeof rollprod;
-declare const index_d$2_rollsum: typeof rollsum;
-declare const index_d$2_round: typeof round;
-declare const index_d$2_scale: typeof scale;
-declare const index_d$2_sign: typeof sign;
-declare const index_d$2_sub: typeof sub;
-declare const index_d$2_sum: typeof sum;
-declare namespace index_d$2 {
+declare const index_d$3_abs: typeof abs;
+declare const index_d$3_add: typeof add;
+declare const index_d$3_and: typeof and;
+declare const index_d$3_argmax: typeof argmax;
+declare const index_d$3_argmin: typeof argmin;
+declare const index_d$3_avg: typeof avg;
+declare const index_d$3_ceil: typeof ceil;
+declare const index_d$3_clamp: typeof clamp;
+declare const index_d$3_cummax: typeof cummax;
+declare const index_d$3_cummin: typeof cummin;
+declare const index_d$3_cumprod: typeof cumprod;
+declare const index_d$3_cumsum: typeof cumsum;
+declare const index_d$3_diff: typeof diff;
+declare const index_d$3_div: typeof div;
+declare const index_d$3_dot: typeof dot;
+declare const index_d$3_eq: typeof eq;
+declare const index_d$3_floor: typeof floor;
+declare const index_d$3_gt: typeof gt;
+declare const index_d$3_gte: typeof gte;
+declare const index_d$3_lt: typeof lt;
+declare const index_d$3_lte: typeof lte;
+declare const index_d$3_max: typeof max;
+declare const index_d$3_min: typeof min;
+declare const index_d$3_mul: typeof mul;
+declare const index_d$3_neq: typeof neq;
+declare const index_d$3_norm: typeof norm;
+declare const index_d$3_not: typeof not;
+declare const index_d$3_ols: typeof ols;
+declare const index_d$3_olsMulti: typeof olsMulti;
+declare const index_d$3_or: typeof or;
+declare const index_d$3_prod: typeof prod;
+declare const index_d$3_randnormal: typeof randnormal;
+declare const index_d$3_randuniform: typeof randuniform;
+declare const index_d$3_rollargmax: typeof rollargmax;
+declare const index_d$3_rollargmin: typeof rollargmin;
+declare const index_d$3_rollmax: typeof rollmax;
+declare const index_d$3_rollmin: typeof rollmin;
+declare const index_d$3_rollminmax: typeof rollminmax;
+declare const index_d$3_rollprod: typeof rollprod;
+declare const index_d$3_rollsum: typeof rollsum;
+declare const index_d$3_round: typeof round;
+declare const index_d$3_scale: typeof scale;
+declare const index_d$3_sign: typeof sign;
+declare const index_d$3_sub: typeof sub;
+declare const index_d$3_sum: typeof sum;
+declare namespace index_d$3 {
   export {
-    index_d$2_abs as abs,
-    index_d$2_add as add,
-    index_d$2_and as and,
-    index_d$2_argmax as argmax,
-    index_d$2_argmin as argmin,
-    index_d$2_avg as avg,
-    index_d$2_ceil as ceil,
-    index_d$2_clamp as clamp,
-    index_d$2_cummax as cummax,
-    index_d$2_cummin as cummin,
-    index_d$2_cumprod as cumprod,
-    index_d$2_cumsum as cumsum,
-    index_d$2_diff as diff,
-    index_d$2_div as div,
-    index_d$2_dot as dot,
-    index_d$2_eq as eq,
-    index_d$2_floor as floor,
-    index_d$2_gt as gt,
-    index_d$2_gte as gte,
-    index_d$2_lt as lt,
-    index_d$2_lte as lte,
-    index_d$2_max as max,
-    index_d$2_min as min,
-    index_d$2_mul as mul,
-    index_d$2_neq as neq,
-    index_d$2_norm as norm,
-    index_d$2_not as not,
-    index_d$2_ols as ols,
-    index_d$2_olsMulti as olsMulti,
-    index_d$2_or as or,
-    index_d$2_prod as prod,
-    index_d$2_randnormal as randnormal,
-    index_d$2_randuniform as randuniform,
-    index_d$2_rollargmax as rollargmax,
-    index_d$2_rollargmin as rollargmin,
-    index_d$2_rollmax as rollmax,
-    index_d$2_rollmin as rollmin,
-    index_d$2_rollminmax as rollminmax,
-    index_d$2_rollprod as rollprod,
-    index_d$2_rollsum as rollsum,
-    index_d$2_round as round,
-    index_d$2_scale as scale,
-    index_d$2_sign as sign,
-    index_d$2_sub as sub,
-    index_d$2_sum as sum,
+    index_d$3_abs as abs,
+    index_d$3_add as add,
+    index_d$3_and as and,
+    index_d$3_argmax as argmax,
+    index_d$3_argmin as argmin,
+    index_d$3_avg as avg,
+    index_d$3_ceil as ceil,
+    index_d$3_clamp as clamp,
+    index_d$3_cummax as cummax,
+    index_d$3_cummin as cummin,
+    index_d$3_cumprod as cumprod,
+    index_d$3_cumsum as cumsum,
+    index_d$3_diff as diff,
+    index_d$3_div as div,
+    index_d$3_dot as dot,
+    index_d$3_eq as eq,
+    index_d$3_floor as floor,
+    index_d$3_gt as gt,
+    index_d$3_gte as gte,
+    index_d$3_lt as lt,
+    index_d$3_lte as lte,
+    index_d$3_max as max,
+    index_d$3_min as min,
+    index_d$3_mul as mul,
+    index_d$3_neq as neq,
+    index_d$3_norm as norm,
+    index_d$3_not as not,
+    index_d$3_ols as ols,
+    index_d$3_olsMulti as olsMulti,
+    index_d$3_or as or,
+    index_d$3_prod as prod,
+    index_d$3_randnormal as randnormal,
+    index_d$3_randuniform as randuniform,
+    index_d$3_rollargmax as rollargmax,
+    index_d$3_rollargmin as rollargmin,
+    index_d$3_rollmax as rollmax,
+    index_d$3_rollmin as rollmin,
+    index_d$3_rollminmax as rollminmax,
+    index_d$3_rollprod as rollprod,
+    index_d$3_rollsum as rollsum,
+    index_d$3_round as round,
+    index_d$3_scale as scale,
+    index_d$3_sign as sign,
+    index_d$3_sub as sub,
+    index_d$3_sum as sum,
   };
 }
 
@@ -1095,65 +1095,65 @@ declare function crossunder(a: ArrayLike<number>, b: ArrayLike<number> | number)
  * volatility indicators, as well as utility helpers.
  */
 
-type index_d$1_IchimokuOptions = IchimokuOptions;
-type index_d$1_KstOptions = KstOptions;
-type index_d$1_UltoscOptions = UltoscOptions;
-declare const index_d$1_ad: typeof ad;
-declare const index_d$1_adosc: typeof adosc;
-declare const index_d$1_adx: typeof adx;
-declare const index_d$1_adxr: typeof adxr;
-declare const index_d$1_ao: typeof ao;
-declare const index_d$1_apo: typeof apo;
-declare const index_d$1_aroon: typeof aroon;
-declare const index_d$1_atr: typeof atr;
-declare const index_d$1_bb: typeof bb;
-declare const index_d$1_bbw: typeof bbw;
-declare const index_d$1_cci: typeof cci;
-declare const index_d$1_change: typeof change;
-declare const index_d$1_cmo: typeof cmo;
-declare const index_d$1_cross: typeof cross;
-declare const index_d$1_crossover: typeof crossover;
-declare const index_d$1_crossunder: typeof crossunder;
-declare const index_d$1_dema: typeof dema;
-declare const index_d$1_di: typeof di;
-declare const index_d$1_donchian: typeof donchian;
-declare const index_d$1_dpo: typeof dpo;
-declare const index_d$1_dx: typeof dx;
-declare const index_d$1_ema: typeof ema;
-declare const index_d$1_falling: typeof falling;
-declare const index_d$1_hma: typeof hma;
-declare const index_d$1_ichimoku: typeof ichimoku;
-declare const index_d$1_kama: typeof kama;
-declare const index_d$1_keltner: typeof keltner;
-declare const index_d$1_kst: typeof kst;
-declare const index_d$1_macd: typeof macd;
-declare const index_d$1_mfi: typeof mfi;
-declare const index_d$1_mom: typeof mom;
-declare const index_d$1_natr: typeof natr;
-declare const index_d$1_obv: typeof obv;
-declare const index_d$1_pnvi: typeof pnvi;
-declare const index_d$1_ppo: typeof ppo;
-declare const index_d$1_psar: typeof psar;
-declare const index_d$1_rising: typeof rising;
-declare const index_d$1_rma: typeof rma;
-declare const index_d$1_roc: typeof roc;
-declare const index_d$1_rsi: typeof rsi;
-declare const index_d$1_sma: typeof sma;
-declare const index_d$1_stoch: typeof stoch;
-declare const index_d$1_stochrsi: typeof stochrsi;
-declare const index_d$1_supertrend: typeof supertrend;
-declare const index_d$1_t3: typeof t3;
-declare const index_d$1_tema: typeof tema;
-declare const index_d$1_tr: typeof tr;
-declare const index_d$1_trima: typeof trima;
-declare const index_d$1_ultosc: typeof ultosc;
-declare const index_d$1_vwma: typeof vwma;
-declare const index_d$1_wad: typeof wad;
-declare const index_d$1_wma: typeof wma;
-declare const index_d$1_wpr: typeof wpr;
-declare namespace index_d$1 {
-  export { index_d$1_ad as ad, index_d$1_adosc as adosc, index_d$1_adx as adx, index_d$1_adxr as adxr, index_d$1_ao as ao, index_d$1_apo as apo, index_d$1_aroon as aroon, index_d$1_atr as atr, index_d$1_bb as bb, index_d$1_bbw as bbw, index_d$1_cci as cci, index_d$1_change as change, index_d$1_cmo as cmo, index_d$1_cross as cross, index_d$1_crossover as crossover, index_d$1_crossunder as crossunder, index_d$1_dema as dema, index_d$1_di as di, index_d$1_donchian as donchian, index_d$1_dpo as dpo, index_d$1_dx as dx, index_d$1_ema as ema, index_d$1_falling as falling, index_d$1_hma as hma, index_d$1_ichimoku as ichimoku, index_d$1_kama as kama, index_d$1_keltner as keltner, index_d$1_kst as kst, index_d$1_macd as macd, index_d$1_mfi as mfi, index_d$1_mom as mom, index_d$1_natr as natr, index_d$1_obv as obv, index_d$1_pnvi as pnvi, index_d$1_ppo as ppo, index_d$1_psar as psar, index_d$1_rising as rising, index_d$1_rma as rma, index_d$1_roc as roc, index_d$1_rsi as rsi, index_d$1_sma as sma, index_d$1_stoch as stoch, index_d$1_stochrsi as stochrsi, index_d$1_supertrend as supertrend, index_d$1_t3 as t3, index_d$1_tema as tema, index_d$1_tr as tr, index_d$1_trima as trima, index_d$1_ultosc as ultosc, index_d$1_vwma as vwma, index_d$1_wad as wad, index_d$1_wma as wma, index_d$1_wpr as wpr };
-  export type { index_d$1_IchimokuOptions as IchimokuOptions, index_d$1_KstOptions as KstOptions, index_d$1_UltoscOptions as UltoscOptions };
+type index_d$2_IchimokuOptions = IchimokuOptions;
+type index_d$2_KstOptions = KstOptions;
+type index_d$2_UltoscOptions = UltoscOptions;
+declare const index_d$2_ad: typeof ad;
+declare const index_d$2_adosc: typeof adosc;
+declare const index_d$2_adx: typeof adx;
+declare const index_d$2_adxr: typeof adxr;
+declare const index_d$2_ao: typeof ao;
+declare const index_d$2_apo: typeof apo;
+declare const index_d$2_aroon: typeof aroon;
+declare const index_d$2_atr: typeof atr;
+declare const index_d$2_bb: typeof bb;
+declare const index_d$2_bbw: typeof bbw;
+declare const index_d$2_cci: typeof cci;
+declare const index_d$2_change: typeof change;
+declare const index_d$2_cmo: typeof cmo;
+declare const index_d$2_cross: typeof cross;
+declare const index_d$2_crossover: typeof crossover;
+declare const index_d$2_crossunder: typeof crossunder;
+declare const index_d$2_dema: typeof dema;
+declare const index_d$2_di: typeof di;
+declare const index_d$2_donchian: typeof donchian;
+declare const index_d$2_dpo: typeof dpo;
+declare const index_d$2_dx: typeof dx;
+declare const index_d$2_ema: typeof ema;
+declare const index_d$2_falling: typeof falling;
+declare const index_d$2_hma: typeof hma;
+declare const index_d$2_ichimoku: typeof ichimoku;
+declare const index_d$2_kama: typeof kama;
+declare const index_d$2_keltner: typeof keltner;
+declare const index_d$2_kst: typeof kst;
+declare const index_d$2_macd: typeof macd;
+declare const index_d$2_mfi: typeof mfi;
+declare const index_d$2_mom: typeof mom;
+declare const index_d$2_natr: typeof natr;
+declare const index_d$2_obv: typeof obv;
+declare const index_d$2_pnvi: typeof pnvi;
+declare const index_d$2_ppo: typeof ppo;
+declare const index_d$2_psar: typeof psar;
+declare const index_d$2_rising: typeof rising;
+declare const index_d$2_rma: typeof rma;
+declare const index_d$2_roc: typeof roc;
+declare const index_d$2_rsi: typeof rsi;
+declare const index_d$2_sma: typeof sma;
+declare const index_d$2_stoch: typeof stoch;
+declare const index_d$2_stochrsi: typeof stochrsi;
+declare const index_d$2_supertrend: typeof supertrend;
+declare const index_d$2_t3: typeof t3;
+declare const index_d$2_tema: typeof tema;
+declare const index_d$2_tr: typeof tr;
+declare const index_d$2_trima: typeof trima;
+declare const index_d$2_ultosc: typeof ultosc;
+declare const index_d$2_vwma: typeof vwma;
+declare const index_d$2_wad: typeof wad;
+declare const index_d$2_wma: typeof wma;
+declare const index_d$2_wpr: typeof wpr;
+declare namespace index_d$2 {
+  export { index_d$2_ad as ad, index_d$2_adosc as adosc, index_d$2_adx as adx, index_d$2_adxr as adxr, index_d$2_ao as ao, index_d$2_apo as apo, index_d$2_aroon as aroon, index_d$2_atr as atr, index_d$2_bb as bb, index_d$2_bbw as bbw, index_d$2_cci as cci, index_d$2_change as change, index_d$2_cmo as cmo, index_d$2_cross as cross, index_d$2_crossover as crossover, index_d$2_crossunder as crossunder, index_d$2_dema as dema, index_d$2_di as di, index_d$2_donchian as donchian, index_d$2_dpo as dpo, index_d$2_dx as dx, index_d$2_ema as ema, index_d$2_falling as falling, index_d$2_hma as hma, index_d$2_ichimoku as ichimoku, index_d$2_kama as kama, index_d$2_keltner as keltner, index_d$2_kst as kst, index_d$2_macd as macd, index_d$2_mfi as mfi, index_d$2_mom as mom, index_d$2_natr as natr, index_d$2_obv as obv, index_d$2_pnvi as pnvi, index_d$2_ppo as ppo, index_d$2_psar as psar, index_d$2_rising as rising, index_d$2_rma as rma, index_d$2_roc as roc, index_d$2_rsi as rsi, index_d$2_sma as sma, index_d$2_stoch as stoch, index_d$2_stochrsi as stochrsi, index_d$2_supertrend as supertrend, index_d$2_t3 as t3, index_d$2_tema as tema, index_d$2_tr as tr, index_d$2_trima as trima, index_d$2_ultosc as ultosc, index_d$2_vwma as vwma, index_d$2_wad as wad, index_d$2_wma as wma, index_d$2_wpr as wpr };
+  export type { index_d$2_IchimokuOptions as IchimokuOptions, index_d$2_KstOptions as KstOptions, index_d$2_UltoscOptions as UltoscOptions };
 }
 
 /**
@@ -1510,64 +1510,324 @@ declare function bootstrap<T>(arr: T[], k: number): T[];
  * Stats barrel: re-export statistical helpers for convenient imports.
  */
 
-declare const index_d_bootstrap: typeof bootstrap;
-declare const index_d_corr: typeof corr;
-declare const index_d_covar: typeof covar;
-declare const index_d_gmean: typeof gmean;
-declare const index_d_hmean: typeof hmean;
-declare const index_d_kurtosis: typeof kurtosis;
-declare const index_d_mad: typeof mad;
-declare const index_d_mean: typeof mean;
-declare const index_d_median: typeof median;
-declare const index_d_norminmax: typeof norminmax;
-declare const index_d_percentiles: typeof percentiles;
-declare const index_d_quantile: typeof quantile;
-declare const index_d_rollcorr: typeof rollcorr;
-declare const index_d_rollcovar: typeof rollcovar;
-declare const index_d_rollkurtosis: typeof rollkurtosis;
-declare const index_d_rollmean: typeof rollmean;
-declare const index_d_rollmedian: typeof rollmedian;
-declare const index_d_rollquantile: typeof rollquantile;
-declare const index_d_rollskew: typeof rollskew;
-declare const index_d_rollstdev: typeof rollstdev;
-declare const index_d_rollvar: typeof rollvar;
-declare const index_d_sample: typeof sample;
-declare const index_d_shuffle: typeof shuffle;
-declare const index_d_skew: typeof skew;
-declare const index_d_stdev: typeof stdev;
-declare const index_d_winsorize: typeof winsorize;
-declare const index_d_zscore: typeof zscore;
-declare namespace index_d {
+declare const index_d$1_bootstrap: typeof bootstrap;
+declare const index_d$1_corr: typeof corr;
+declare const index_d$1_covar: typeof covar;
+declare const index_d$1_gmean: typeof gmean;
+declare const index_d$1_hmean: typeof hmean;
+declare const index_d$1_kurtosis: typeof kurtosis;
+declare const index_d$1_mad: typeof mad;
+declare const index_d$1_mean: typeof mean;
+declare const index_d$1_median: typeof median;
+declare const index_d$1_norminmax: typeof norminmax;
+declare const index_d$1_percentiles: typeof percentiles;
+declare const index_d$1_quantile: typeof quantile;
+declare const index_d$1_rollcorr: typeof rollcorr;
+declare const index_d$1_rollcovar: typeof rollcovar;
+declare const index_d$1_rollkurtosis: typeof rollkurtosis;
+declare const index_d$1_rollmean: typeof rollmean;
+declare const index_d$1_rollmedian: typeof rollmedian;
+declare const index_d$1_rollquantile: typeof rollquantile;
+declare const index_d$1_rollskew: typeof rollskew;
+declare const index_d$1_rollstdev: typeof rollstdev;
+declare const index_d$1_rollvar: typeof rollvar;
+declare const index_d$1_sample: typeof sample;
+declare const index_d$1_shuffle: typeof shuffle;
+declare const index_d$1_skew: typeof skew;
+declare const index_d$1_stdev: typeof stdev;
+declare const index_d$1_winsorize: typeof winsorize;
+declare const index_d$1_zscore: typeof zscore;
+declare namespace index_d$1 {
   export {
-    index_d_bootstrap as bootstrap,
-    index_d_corr as corr,
-    index_d_covar as covar,
-    index_d_gmean as gmean,
-    index_d_hmean as hmean,
-    index_d_kurtosis as kurtosis,
-    index_d_mad as mad,
-    index_d_mean as mean,
-    index_d_median as median,
-    index_d_norminmax as norminmax,
-    index_d_percentiles as percentiles,
-    index_d_quantile as quantile,
-    index_d_rollcorr as rollcorr,
-    index_d_rollcovar as rollcovar,
-    index_d_rollkurtosis as rollkurtosis,
-    index_d_rollmean as rollmean,
-    index_d_rollmedian as rollmedian,
-    index_d_rollquantile as rollquantile,
-    index_d_rollskew as rollskew,
-    index_d_rollstdev as rollstdev,
-    index_d_rollvar as rollvar,
-    index_d_sample as sample,
-    index_d_shuffle as shuffle,
-    index_d_skew as skew,
-    index_d_stdev as stdev,
+    index_d$1_bootstrap as bootstrap,
+    index_d$1_corr as corr,
+    index_d$1_covar as covar,
+    index_d$1_gmean as gmean,
+    index_d$1_hmean as hmean,
+    index_d$1_kurtosis as kurtosis,
+    index_d$1_mad as mad,
+    index_d$1_mean as mean,
+    index_d$1_median as median,
+    index_d$1_norminmax as norminmax,
+    index_d$1_percentiles as percentiles,
+    index_d$1_quantile as quantile,
+    index_d$1_rollcorr as rollcorr,
+    index_d$1_rollcovar as rollcovar,
+    index_d$1_rollkurtosis as rollkurtosis,
+    index_d$1_rollmean as rollmean,
+    index_d$1_rollmedian as rollmedian,
+    index_d$1_rollquantile as rollquantile,
+    index_d$1_rollskew as rollskew,
+    index_d$1_rollstdev as rollstdev,
+    index_d$1_rollvar as rollvar,
+    index_d$1_sample as sample,
+    index_d$1_shuffle as shuffle,
+    index_d$1_skew as skew,
+    index_d$1_stdev as stdev,
     variance as var,
-    index_d_winsorize as winsorize,
-    index_d_zscore as zscore,
+    index_d$1_winsorize as winsorize,
+    index_d$1_zscore as zscore,
   };
 }
 
-export { arr_d as arr, index_d$2 as math, index_d as stats, index_d$1 as ta };
+/**
+ * Compute simple period returns from a level series.
+ * For each i>0: returns[i] = source[i]/source[i-1] - 1 when both values are finite and previous != 0.
+ * The first element is always NaN. Invalid or non-finite inputs produce NaN at that position.
+ * @param source Input level series (prices/equity)
+ * @returns Float32Array of simple returns (same length as `source`)
+ */
+declare function returns(source: ArrayLike<number>): Float32Array;
+/**
+ * Compute log returns from a level series.
+ * For each i>0: logreturns[i] = log(source[i]/source[i-1]) when both values are finite and previous>0.
+ * The first element is always NaN. Invalid or non-positive previous values yield NaN.
+ * @param source Input level series (prices/equity)
+ * @returns Float32Array of log returns (same length as `source`)
+ */
+declare function logreturns(source: ArrayLike<number>): Float32Array;
+/**
+ * Compute cumulative compound returns from a returns series, skipping NaNs.
+ * Cumulative return at i is prod_{j<=i, r_j finite} (1+r_j) - 1; NaN inputs leave an output NaN at that position.
+ * @param returns Simple returns series
+ * @returns Float64Array of cumulative returns
+ */
+declare function cumreturns(returns: ArrayLike<number>): Float64Array;
+/**
+ * Compute the compound annual growth rate (CAGR) from a returns series.
+ * Ignores NaNs. `freq` is the number of periods per year (default 252).
+ * @param returns Simple returns series
+ * @param freq Periods per year (default 252)
+ * @returns CAGR as a number, or NaN when insufficient data
+ */
+declare function cagr(returns: ArrayLike<number>, freq?: number): number;
+/**
+ * Aggregate irregular (event-aligned) returns into calendar-day returns.
+ *
+ * The function groups `returnsArr` by calendar day (optionally shifted by `tzOffsetMinutes`),
+ * compounds returns within each day (prod(1+r)-1) and returns a continuous range of days
+ * from the minimum to the maximum observed day. Missing days are filled with zero returns.
+ *
+ * @param tsMs Array of timestamps (ms since epoch) aligned to `returnsArr`
+ * @param returnsArr Array of simple returns aligned to `tsMs`
+ * @param tzOffsetMinutes Optional timezone offset in minutes (default 0, UTC)
+ * @returns Object { days: number[], dailyReturns: Float32Array }
+ */
+declare function dailyReturns(tsMs: ArrayLike<number>, returnsArr: ArrayLike<number>, tzOffsetMinutes?: number): {
+    days: number[];
+    dailyReturns: Float32Array<ArrayBuffer>;
+};
+
+type DrawdownDurationResult = {
+    durations: Int32Array;
+    maxDuration: number;
+};
+type MaxDrawdownInfo = {
+    maxDrawdown: number;
+    peakIndex: number;
+    troughIndex: number;
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Compute the drawdown series from an equity/price series.
+ * For valid points: out[i] = equity[i]/peak - 1 (<= 0). NaNs propagate and do not update the peak.
+ * @param equity Array-like equity or price series
+ * @returns Float64Array of drawdowns (same length)
+ */
+declare function dd(equity: ArrayLike<number>): Float64Array;
+/**
+ * Compute the maximum drawdown magnitude over the entire series.
+ * Returns a positive number (0..+inf) or NaN when no valid points.
+ * @param equity Array-like equity or price series
+ * @returns Maximum drawdown magnitude (positive) or NaN
+ */
+declare function maxdd(equity: ArrayLike<number>): number;
+/**
+ * Compute detailed information about the maximum drawdown, including peak, trough, and recovery indices.
+ * When no valid points exist returns NaN/placeholder indices (-1).
+ * @param equity Array-like equity or price series
+ * @returns MaxDrawdownInfo with `maxDrawdown`, `peakIndex`, `troughIndex`, `startIndex`, and `endIndex`
+ */
+declare function maxddDetails(equity: ArrayLike<number>): MaxDrawdownInfo;
+/**
+ * Rolling maximum drawdown over a trailing window.
+ * For each index i computes the max drawdown observed within the trailing window.
+ * @param equity Array-like equity or price series
+ * @param window Rolling window length (positive integer)
+ * @returns Float64Array of rolling max drawdowns
+ */
+declare function rollmaxdd(equity: ArrayLike<number>, window: number): Float64Array;
+/**
+ * Compute drawdown durations (consecutive periods in current drawdown) and the maximum duration.
+ * Positions where equity is NaN are marked with -1.
+ * @param equity Array-like equity or price series
+ * @returns DrawdownDurationResult { durations: Int32Array, maxDuration: number }
+ */
+declare function dduration(equity: ArrayLike<number>): DrawdownDurationResult;
+/**
+ * Recovery factor: ratio of annualized return (CAGR) to maximum drawdown magnitude.
+ * Returns NaN if insufficient data, invalid start value, or zero/NaN max drawdown.
+ * @param equity Array-like equity or price series
+ * @param freq Periods per year (default 252)
+ * @returns Recovery factor or NaN
+ */
+declare function recoveryFactor(equity: ArrayLike<number>, freq?: number): number;
+/**
+ * Calmar ratio: CAGR over a lookback period divided by the max drawdown magnitude over the same period.
+ * If `lookbackPeriodYears` is null uses the entire series. Returns NaN on invalid inputs or zero drawdown.
+ * @param equity Array-like equity or price series
+ * @param lookbackPeriodYears Lookback window in years (null = full span)
+ * @param freq Periods per year (default 252)
+ * @returns Calmar ratio or NaN
+ */
+declare function calmarRatio(equity: ArrayLike<number>, lookbackPeriodYears?: number | null, freq?: number): number;
+/**
+ * Ulcer Index: measures depth and duration of drawdowns (root-mean-square of depths).
+ * Returns NaN for empty input.
+ * @param equity Array-like equity or price series
+ * @returns Ulcer Index (>=0) or NaN
+ */
+declare function ulcerIndex(equity: ArrayLike<number>): number;
+/**
+ * Rolling Ulcer Index computed over a trailing window.
+ * Returns NaN for windows with insufficient valid samples (< minPeriod) or invalid window.
+ * @param equity Array-like equity or price series
+ * @param window Rolling window length (positive integer)
+ * @param minPeriod Minimum number of valid points required in window
+ * @returns Float64Array of rolling ulcer index values
+ */
+declare function rollUlcerIndex(equity: ArrayLike<number>, window: number, minPeriod?: number): Float64Array;
+
+/**
+ * Compute the (annualized) Sharpe ratio for a returns series.
+ * Uses NaN-aware mean and sample standard deviation (ddof=1).
+ * Returns NaN for empty input, zero or NaN volatility, or invalid mean.
+ * @param returns Array-like returns series
+ * @param riskFree Annualized risk-free rate (default 0)
+ * @param freq Periods per year (default 252)
+ * @returns Sharpe ratio (annualized) or NaN
+ */
+declare function sharpe(returns: ArrayLike<number>, riskFree?: number, freq?: number): number;
+/**
+ * Compute the (annualized) Sortino ratio for a returns series.
+ * Uses downside deviation (sample corrected) computed over negative excess returns.
+ * Requires at least two downside observations; returns NaN otherwise.
+ * @param returns Array-like returns series
+ * @param requiredReturn Target return to define downside (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum valid periods (unused for scalar Sortino)
+ * @returns Sortino ratio (annualized) or NaN
+ */
+declare function sortino(returns: ArrayLike<number>, requiredReturn?: number, freq?: number, minPeriod?: number): number;
+/**
+ * Rolling Sharpe ratio computed over a trailing window.
+ * Output is a Float64Array aligned with `returns`; positions before enough data are NaN.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param riskFree Annualized risk-free rate (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling Sharpe ratios
+ */
+declare function rollsharpe(returns: ArrayLike<number>, window: number, riskFree?: number, freq?: number, minPeriod?: number): Float64Array;
+/**
+ * Rolling Sortino ratio computed over a trailing window using downside deviations.
+ * Outputs NaN where insufficient downside or invalid data exists.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param requiredReturn Target return to define downside (default 0)
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling Sortino ratios
+ */
+declare function rollsortino(returns: ArrayLike<number>, window: number, requiredReturn?: number, freq?: number, minPeriod?: number): Float64Array;
+/**
+ * Annualized volatility (sample standard deviation) of returns.
+ * Uses NaN-aware `stats.stdev` with ddof=1. Returns NaN for empty input or zero/NaN sigma.
+ * @param returns Array-like returns series
+ * @param freq Periods per year (default 252)
+ * @returns Annualized volatility or NaN
+ */
+declare function vol(returns: ArrayLike<number>, freq?: number): number;
+/**
+ * Rolling annualized volatility (sample stddev) over a trailing window.
+ * Outputs NaN for windows with insufficient valid samples or zero/NaN sigma.
+ * @param returns Array-like returns series
+ * @param window Rolling window length
+ * @param freq Periods per year (default 252)
+ * @param minPeriod Minimum number of valid samples required per window (default 1)
+ * @returns Float64Array of rolling volatilities
+ */
+declare function rollvol(returns: ArrayLike<number>, window: number, freq?: number, minPeriod?: number): Float64Array;
+
+/**
+ * Value-at-Risk (VaR) estimator.
+ * Supports `historical` (empirical quantile) and `parametric` (normal) methods.
+ * Returns NaN for empty inputs or invalid alpha or when parametric stats are invalid.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @param method 'historical' | 'parametric' (default 'historical')
+ * @returns VaR as a number (left-tail) or NaN
+ */
+declare function valueAtRisk(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+/**
+ * Expected shortfall (conditional tail expectation) estimator.
+ * Supports `historical` (empirical mean of losses <= VaR) and `parametric` (normal) methods.
+ * Returns NaN for empty inputs, invalid alpha, or invalid parametric stats.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @param method 'historical' | 'parametric' (default 'historical')
+ * @returns Expected shortfall (left-tail) or NaN
+ */
+declare function expectedShortfall(returns: ArrayLike<number>, alpha?: number, method?: 'historical' | 'parametric'): number;
+/**
+ * Tail ratio: mean of upper tail divided by absolute mean of lower tail.
+ * Returns NaN for empty inputs, invalid alpha, or when either tail has no observations or lower mean is zero.
+ * @param returns Array-like returns series
+ * @param alpha Tail probability (default 0.05)
+ * @returns Tail ratio or NaN
+ */
+declare function tailRatio(returns: ArrayLike<number>, alpha?: number): number;
+/**
+ * Omega ratio: sum of gains above `requiredReturn` divided by sum of losses below it.
+ * Returns NaN for empty inputs or when there is no variation (all gains or all losses zero).
+ * @param returns Array-like returns series
+ * @param requiredReturn Threshold for gains/losses (default 0)
+ * @returns Omega ratio number, Infinity if no losses, or NaN when no variation
+ */
+declare function omegaRatio(returns: ArrayLike<number>, requiredReturn?: number): number;
+
+type index_d_DrawdownDurationResult = DrawdownDurationResult;
+type index_d_MaxDrawdownInfo = MaxDrawdownInfo;
+declare const index_d_cagr: typeof cagr;
+declare const index_d_calmarRatio: typeof calmarRatio;
+declare const index_d_cumreturns: typeof cumreturns;
+declare const index_d_dailyReturns: typeof dailyReturns;
+declare const index_d_dd: typeof dd;
+declare const index_d_dduration: typeof dduration;
+declare const index_d_expectedShortfall: typeof expectedShortfall;
+declare const index_d_logreturns: typeof logreturns;
+declare const index_d_maxdd: typeof maxdd;
+declare const index_d_maxddDetails: typeof maxddDetails;
+declare const index_d_omegaRatio: typeof omegaRatio;
+declare const index_d_recoveryFactor: typeof recoveryFactor;
+declare const index_d_returns: typeof returns;
+declare const index_d_rollUlcerIndex: typeof rollUlcerIndex;
+declare const index_d_rollmaxdd: typeof rollmaxdd;
+declare const index_d_rollsharpe: typeof rollsharpe;
+declare const index_d_rollsortino: typeof rollsortino;
+declare const index_d_rollvol: typeof rollvol;
+declare const index_d_sharpe: typeof sharpe;
+declare const index_d_sortino: typeof sortino;
+declare const index_d_tailRatio: typeof tailRatio;
+declare const index_d_ulcerIndex: typeof ulcerIndex;
+declare const index_d_valueAtRisk: typeof valueAtRisk;
+declare const index_d_vol: typeof vol;
+declare namespace index_d {
+  export { index_d_cagr as cagr, index_d_calmarRatio as calmarRatio, index_d_cumreturns as cumreturns, index_d_dailyReturns as dailyReturns, index_d_dd as dd, index_d_dduration as dduration, index_d_expectedShortfall as expectedShortfall, index_d_logreturns as logreturns, index_d_maxdd as maxdd, index_d_maxddDetails as maxddDetails, index_d_omegaRatio as omegaRatio, index_d_recoveryFactor as recoveryFactor, index_d_returns as returns, index_d_rollUlcerIndex as rollUlcerIndex, index_d_rollmaxdd as rollmaxdd, index_d_rollsharpe as rollsharpe, index_d_rollsortino as rollsortino, index_d_rollvol as rollvol, index_d_sharpe as sharpe, index_d_sortino as sortino, index_d_tailRatio as tailRatio, index_d_ulcerIndex as ulcerIndex, index_d_valueAtRisk as valueAtRisk, index_d_vol as vol };
+  export type { index_d_DrawdownDurationResult as DrawdownDurationResult, index_d_MaxDrawdownInfo as MaxDrawdownInfo };
+}
+
+export { arr_d as arr, index_d$3 as math, index_d as perf, index_d$1 as stats, index_d$2 as ta };
+export type { DrawdownDurationResult, IchimokuOptions, KstOptions, MaxDrawdownInfo, UltoscOptions };