@stvy/fund-indicators 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,1615 @@
+'use strict';
+
+var technicalindicators = require('technicalindicators');
+var ss = require('simple-statistics');
+var jstat = require('jstat');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ss__namespace = /*#__PURE__*/_interopNamespaceDefault(ss);
+
+function navToHLC(nav) {
+  return nav.map((v) => ({ high: v, low: v, close: v }));
+}
+function padLeft(arr, totalLen) {
+  const padLen = totalLen - arr.length;
+  const result = new Array(padLen).fill(null);
+  for (const v of arr) {
+    result.push(v ?? null);
+  }
+  return result;
+}
+function lastNonNull(arr) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] != null) return arr[i];
+  }
+  return null;
+}
+function sma(nav, period) {
+  const raw = technicalindicators.SMA.calculate({ values: nav, period });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function ema(nav, period) {
+  const raw = technicalindicators.EMA.calculate({ values: nav, period });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "EMA" };
+}
+function wma(nav, period) {
+  const raw = technicalindicators.WMA.calculate({ values: nav, period });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "WMA" };
+}
+function dema(nav, period) {
+  const ema1 = technicalindicators.EMA.calculate({ values: nav, period });
+  const ema1Padded = padLeft(ema1, nav.length);
+  const ema1Values = ema1.filter((v) => v !== void 0);
+  const ema2 = technicalindicators.EMA.calculate({ values: ema1Values, period });
+  const values = new Array(nav.length).fill(null);
+  const offset = nav.length - ema1Values.length;
+  for (let i = 0; i < ema2.length; i++) {
+    const idx = offset + i;
+    if (idx < nav.length && ema2[i] != null && ema1Padded[idx] != null) {
+      values[idx] = 2 * ema1Padded[idx] - ema2[i];
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "DEMA" };
+}
+function tema(nav, period) {
+  const ema1Raw = technicalindicators.EMA.calculate({ values: nav, period });
+  const ema1Vals = ema1Raw.filter((v) => v !== void 0);
+  const ema2Raw = technicalindicators.EMA.calculate({ values: ema1Vals, period });
+  const ema2Vals = ema2Raw.filter((v) => v !== void 0);
+  const ema3Raw = technicalindicators.EMA.calculate({ values: ema2Vals, period });
+  const ema1Padded = padLeft(ema1Raw, nav.length);
+  const offset2 = nav.length - ema1Vals.length;
+  const ema2Full = new Array(nav.length).fill(null);
+  for (let i = 0; i < ema2Raw.length; i++) {
+    const idx = offset2 + i;
+    if (idx < nav.length) ema2Full[idx] = ema2Raw[i] ?? null;
+  }
+  const offset3 = offset2 + (ema1Vals.length - ema2Vals.length);
+  const ema3Full = new Array(nav.length).fill(null);
+  for (let i = 0; i < ema3Raw.length; i++) {
+    const idx = offset3 + i;
+    if (idx < nav.length) ema3Full[idx] = ema3Raw[i] ?? null;
+  }
+  const values = new Array(nav.length).fill(null);
+  for (let i = 0; i < nav.length; i++) {
+    const v1 = ema1Padded[i];
+    const v2 = ema2Full[i];
+    const v3 = ema3Full[i];
+    if (v1 != null && v2 != null && v3 != null) {
+      values[i] = 3 * v1 - 3 * v2 + v3;
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "TEMA" };
+}
+function kama(nav, period = 10, fast = 2, slow = 30) {
+  const fastSC = 2 / (fast + 1);
+  const slowSC = 2 / (slow + 1);
+  const values = new Array(nav.length).fill(null);
+  if (nav.length <= period) return { values, current: null, period, type: "KAMA" };
+  values[period] = nav[period];
+  for (let i = period + 1; i < nav.length; i++) {
+    const direction = Math.abs(nav[i] - nav[i - period]);
+    let volatility = 0;
+    for (let j = i - period + 1; j <= i; j++) {
+      volatility += Math.abs(nav[j] - nav[j - 1]);
+    }
+    const er = volatility === 0 ? 0 : direction / volatility;
+    const sc = Math.pow(er * (fastSC - slowSC) + slowSC, 2);
+    const prevKama = values[i - 1];
+    values[i] = prevKama + sc * (nav[i] - prevKama);
+  }
+  return { values, current: lastNonNull(values), period, type: "KAMA" };
+}
+function macd(nav, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9) {
+  const raw = technicalindicators.MACD.calculate({
+    values: nav,
+    fastPeriod,
+    slowPeriod,
+    signalPeriod,
+    SimpleMAOscillator: false,
+    SimpleMASignal: false
+  });
+  const dif = padLeft(raw.map((r) => r.MACD), nav.length);
+  const dea = padLeft(raw.map((r) => r.signal), nav.length);
+  const histogram = padLeft(raw.map((r) => r.histogram), nav.length);
+  return {
+    dif,
+    dea,
+    histogram,
+    currentDIF: lastNonNull(dif),
+    currentDEA: lastNonNull(dea),
+    currentHistogram: lastNonNull(histogram)
+  };
+}
+function rsi(nav, period = 14) {
+  const raw = technicalindicators.RSI.calculate({ values: nav, period });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period };
+}
+function kdj(nav, kPeriod = 9, kSmooth = 3, dPeriod = 3) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.Stochastic.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    close: hlc.map((h) => h.close),
+    period: kPeriod,
+    signalPeriod: dPeriod
+  });
+  const kArr = padLeft(raw.map((r) => r.k), nav.length);
+  const dArr = padLeft(raw.map((r) => r.d), nav.length);
+  const jArr = kArr.map((kVal, i) => {
+    const dVal = dArr[i];
+    if (kVal != null && dVal != null) return 3 * kVal - 2 * dVal;
+    return null;
+  });
+  return {
+    k: kArr,
+    d: dArr,
+    j: jArr,
+    currentK: lastNonNull(kArr),
+    currentD: lastNonNull(dArr),
+    currentJ: lastNonNull(jArr)
+  };
+}
+function bollingerBands(nav, period = 20, stdDev = 2) {
+  const raw = technicalindicators.BollingerBands.calculate({ values: nav, period, stdDev });
+  const middle = padLeft(raw.map((r) => r.middle), nav.length);
+  const upper = padLeft(raw.map((r) => r.upper), nav.length);
+  const lower = padLeft(raw.map((r) => r.lower), nav.length);
+  const bandwidth = [];
+  const percentB = [];
+  for (let i = 0; i < nav.length; i++) {
+    const m = middle[i];
+    const u = upper[i];
+    const l = lower[i];
+    if (m != null && u != null && l != null) {
+      bandwidth.push((u - l) / m);
+      percentB.push(u === l ? 0.5 : (nav[i] - l) / (u - l));
+    } else {
+      bandwidth.push(null);
+      percentB.push(null);
+    }
+  }
+  return { middle, upper, lower, bandwidth, percentB };
+}
+function donchianChannel(nav, period = 20) {
+  const upper = [];
+  const lower = [];
+  const middle = [];
+  for (let i = 0; i < nav.length; i++) {
+    if (i < period - 1) {
+      upper.push(null);
+      lower.push(null);
+      middle.push(null);
+      continue;
+    }
+    const slice = nav.slice(i - period + 1, i + 1);
+    const high = Math.max(...slice);
+    const low = Math.min(...slice);
+    upper.push(high);
+    lower.push(low);
+    middle.push((high + low) / 2);
+  }
+  return { upper, lower, middle };
+}
+function keltnerChannel(nav, emaPeriod = 20, atrPeriod = 10, multiplier = 2) {
+  const emaResult = ema(nav, emaPeriod);
+  const atrResult = atr(nav, atrPeriod);
+  const upper = [];
+  const lower = [];
+  for (let i = 0; i < nav.length; i++) {
+    const e = emaResult.values[i];
+    const a = atrResult.values[i];
+    if (e != null && a != null) {
+      upper.push(e + multiplier * a);
+      lower.push(e - multiplier * a);
+    } else {
+      upper.push(null);
+      lower.push(null);
+    }
+  }
+  return { upper, lower, middle: emaResult.values };
+}
+function adx(nav, period = 14) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.ADX.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    close: hlc.map((h) => h.close),
+    period
+  });
+  const adxArr = padLeft(raw.map((r) => r.adx), nav.length);
+  const plusDI = padLeft(raw.map((r) => r.pdi), nav.length);
+  const minusDI = padLeft(raw.map((r) => r.mdi), nav.length);
+  return {
+    adx: adxArr,
+    plusDI,
+    minusDI,
+    currentADX: lastNonNull(adxArr)
+  };
+}
+function atr(nav, period = 14) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.ATR.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    close: hlc.map((h) => h.close),
+    period
+  });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function cci(nav, period = 20) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.CCI.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    close: hlc.map((h) => h.close),
+    period
+  });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function roc(nav, period = 12) {
+  const raw = technicalindicators.ROC.calculate({ values: nav, period });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function momentum(nav, period = 10) {
+  const values = [];
+  for (let i = 0; i < nav.length; i++) {
+    if (i < period) {
+      values.push(null);
+    } else {
+      values.push(nav[i] - nav[i - period]);
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function williamsR(nav, period = 14) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.WilliamsR.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    close: hlc.map((h) => h.close),
+    period
+  });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function stochasticRSI(nav, rsiPeriod = 14, stochPeriod = 14, kPeriod = 3, dPeriod = 3) {
+  const raw = technicalindicators.StochasticRSI.calculate({
+    values: nav,
+    rsiPeriod,
+    stochasticPeriod: stochPeriod,
+    kPeriod,
+    dPeriod
+  });
+  const k = padLeft(raw.map((r) => r.k), nav.length);
+  const d = padLeft(raw.map((r) => r.d), nav.length);
+  const j = k.map((kVal, i) => {
+    const dVal = d[i];
+    return kVal != null && dVal != null ? 3 * kVal - 2 * dVal : null;
+  });
+  return { k, d, j, currentK: lastNonNull(k), currentD: lastNonNull(d), currentJ: lastNonNull(j) };
+}
+function sar(nav, step = 0.02, max = 0.2) {
+  const hlc = navToHLC(nav);
+  const raw = technicalindicators.PSAR.calculate({
+    high: hlc.map((h) => h.high),
+    low: hlc.map((h) => h.low),
+    step,
+    max
+  });
+  const values = padLeft(raw, nav.length);
+  return { values, current: lastNonNull(values) };
+}
+function trix(nav, period = 12) {
+  const ema1 = technicalindicators.EMA.calculate({ values: nav, period });
+  const ema1Vals = ema1.filter((v) => v !== void 0);
+  const ema2 = technicalindicators.EMA.calculate({ values: ema1Vals, period });
+  const ema2Vals = ema2.filter((v) => v !== void 0);
+  const ema3 = technicalindicators.EMA.calculate({ values: ema2Vals, period });
+  const values = new Array(nav.length).fill(null);
+  const offset = nav.length - ema3.length;
+  for (let i = 1; i < ema3.length; i++) {
+    const prev = ema3[i - 1];
+    const curr = ema3[i];
+    if (prev != null && curr != null && prev !== 0) {
+      values[offset + i] = (curr - prev) / prev * 100;
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function dpo(nav, period = 20) {
+  const smaResult = sma(nav, period);
+  const shift = Math.floor(period / 2) + 1;
+  const values = [];
+  for (let i = 0; i < nav.length; i++) {
+    const smaIdx = i + shift;
+    if (smaIdx < nav.length && smaResult.values[smaIdx] != null) {
+      values.push(nav[i] - smaResult.values[smaIdx]);
+    } else {
+      values.push(null);
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function bias(nav, period = 20) {
+  const maResult = sma(nav, period);
+  const values = [];
+  for (let i = 0; i < nav.length; i++) {
+    const m = maResult.values[i];
+    if (m != null && m !== 0) {
+      values.push((nav[i] - m) / m * 100);
+    } else {
+      values.push(null);
+    }
+  }
+  return { values, current: lastNonNull(values), period, type: "SMA" };
+}
+function navPercentile(nav, lookback) {
+  const window = lookback ? nav.slice(-lookback) : nav;
+  const current = nav[nav.length - 1];
+  const sorted = [...window].sort((a, b) => a - b);
+  let rank = 0;
+  for (const v of sorted) {
+    if (v < current) rank++;
+    else if (v === current) rank += 0.5;
+  }
+  return rank / sorted.length * 100;
+}
+function detectCrossSignal(fastMA, slowMA, lookback = 5) {
+  const fVals = fastMA.values;
+  const sVals = slowMA.values;
+  const len = Math.min(fVals.length, sVals.length);
+  for (let i = len - 1; i >= Math.max(1, len - lookback); i--) {
+    const fCurr = fVals[i];
+    const fPrev = fVals[i - 1];
+    const sCurr = sVals[i];
+    const sPrev = sVals[i - 1];
+    if (fCurr == null || fPrev == null || sCurr == null || sPrev == null) continue;
+    if (fPrev <= sPrev && fCurr > sCurr) {
+      return { type: "golden_cross", index: i, fastValue: fCurr, slowValue: sCurr };
+    }
+    if (fPrev >= sPrev && fCurr < sCurr) {
+      return { type: "death_cross", index: i, fastValue: fCurr, slowValue: sCurr };
+    }
+  }
+  return { type: "none", index: -1, fastValue: 0, slowValue: 0 };
+}
+function detectMAAlignment(maList) {
+  const maValues = maList.map((m) => m.current ?? 0);
+  const allValid = maList.every((m) => m.current != null);
+  if (!allValid) {
+    return { alignment: "neutral", maValues, divergence: 0 };
+  }
+  let isBullish = true;
+  let isBearish = true;
+  for (let i = 1; i < maValues.length; i++) {
+    if (maValues[i] >= maValues[i - 1]) isBullish = false;
+    if (maValues[i] <= maValues[i - 1]) isBearish = false;
+  }
+  const mean = maValues.reduce((a, b) => a + b, 0) / maValues.length;
+  const variance = maValues.reduce((sum, v) => sum + (v - mean) ** 2, 0) / maValues.length;
+  const divergence = Math.sqrt(variance);
+  const alignment = isBullish ? "bullish" : isBearish ? "bearish" : "neutral";
+  return { alignment, maValues, divergence };
+}
+function massIndex(nav, emaPeriod = 9, sumPeriod = 25) {
+  const ema1 = technicalindicators.EMA.calculate({ values: nav, period: emaPeriod });
+  const ema1Vals = ema1.filter((v) => v !== void 0);
+  const ema2 = technicalindicators.EMA.calculate({ values: ema1Vals, period: emaPeriod });
+  const ratios = [];
+  for (let i = 0; i < ema2.length; i++) {
+    const e1 = ema1Vals[i + (ema1Vals.length - ema2.length)];
+    const e2 = ema2[i];
+    if (e1 != null && e2 != null && e2 !== 0) {
+      ratios.push(e1 / e2);
+    } else {
+      ratios.push(1);
+    }
+  }
+  const values = new Array(nav.length).fill(null);
+  const offset = nav.length - ratios.length;
+  for (let i = sumPeriod - 1; i < ratios.length; i++) {
+    let sum = 0;
+    for (let j = i - sumPeriod + 1; j <= i; j++) {
+      sum += ratios[j];
+    }
+    values[offset + i] = sum;
+  }
+  return { values, current: lastNonNull(values), period: sumPeriod, type: "SMA" };
+}
+
+const TRADING_DAYS_PER_YEAR = 242;
+function navToReturns(nav) {
+  const returns = [];
+  for (let i = 1; i < nav.length; i++) {
+    returns.push((nav[i] - nav[i - 1]) / nav[i - 1]);
+  }
+  return returns;
+}
+function annualizeReturn(dailyReturns) {
+  if (dailyReturns.length === 0) return 0;
+  const cumulative = dailyReturns.reduce((acc, r) => acc * (1 + r), 1);
+  const years = dailyReturns.length / TRADING_DAYS_PER_YEAR;
+  if (years <= 0 || cumulative <= 0) return 0;
+  return Math.pow(cumulative, 1 / years) - 1;
+}
+function totalReturn(nav) {
+  if (nav.length < 2) return 0;
+  return (nav[nav.length - 1] - nav[0]) / nav[0];
+}
+function annualizedVolatility(returns) {
+  if (returns.length < 2) return 0;
+  return ss__namespace.standardDeviation(returns) * Math.sqrt(TRADING_DAYS_PER_YEAR);
+}
+function downsideVolatility(returns, riskFreeRate = 0) {
+  const downsideReturns = returns.filter((r) => r < riskFreeRate / TRADING_DAYS_PER_YEAR);
+  if (downsideReturns.length < 2) return 0;
+  const deviations = downsideReturns.map((r) => Math.pow(r - riskFreeRate / TRADING_DAYS_PER_YEAR, 2));
+  const meanSqDev = deviations.reduce((a, b) => a + b, 0) / returns.length;
+  return Math.sqrt(meanSqDev) * Math.sqrt(TRADING_DAYS_PER_YEAR);
+}
+function rollingVolatility(returns, window = 20) {
+  const result = [];
+  for (let i = 0; i < returns.length; i++) {
+    if (i < window - 1) {
+      result.push(null);
+    } else {
+      const slice = returns.slice(i - window + 1, i + 1);
+      result.push(ss__namespace.standardDeviation(slice) * Math.sqrt(TRADING_DAYS_PER_YEAR));
+    }
+  }
+  return result;
+}
+function volatilityCone(returns, windows = [5, 10, 20, 60, 120], quantiles = [0.1, 0.25, 0.5, 0.75, 0.9]) {
+  const cone = /* @__PURE__ */ new Map();
+  for (const w of windows) {
+    const vols = [];
+    for (let i = w - 1; i < returns.length; i++) {
+      const slice = returns.slice(i - w + 1, i + 1);
+      vols.push(ss__namespace.standardDeviation(slice) * Math.sqrt(TRADING_DAYS_PER_YEAR));
+    }
+    const sorted = [...vols].sort((a, b) => a - b);
+    const qMap = /* @__PURE__ */ new Map();
+    for (const q of quantiles) {
+      qMap.set(q, ss__namespace.quantileSorted(sorted, q));
+    }
+    cone.set(w, qMap);
+  }
+  return cone;
+}
+function maxDrawdown(nav, dates) {
+  if (nav.length < 2) {
+    return {
+      maxDrawdown: 0,
+      peakIndex: 0,
+      troughIndex: 0,
+      peakDate: null,
+      troughDate: null,
+      recoveryDate: null,
+      durationDays: 0,
+      recoveryDays: null,
+      drawdownSeries: []
+    };
+  }
+  const drawdownSeries = [];
+  let peak = nav[0];
+  let peakIdx = 0;
+  let maxDD = 0;
+  let maxPeakIdx = 0;
+  let maxTroughIdx = 0;
+  for (let i = 0; i < nav.length; i++) {
+    if (nav[i] > peak) {
+      peak = nav[i];
+      peakIdx = i;
+    }
+    const dd = (nav[i] - peak) / peak;
+    drawdownSeries.push(dd);
+    if (dd < maxDD) {
+      maxDD = dd;
+      maxPeakIdx = peakIdx;
+      maxTroughIdx = i;
+    }
+  }
+  let recoveryIdx = null;
+  const peakValue = nav[maxPeakIdx];
+  for (let i = maxTroughIdx + 1; i < nav.length; i++) {
+    if (nav[i] >= peakValue) {
+      recoveryIdx = i;
+      break;
+    }
+  }
+  return {
+    maxDrawdown: maxDD,
+    peakIndex: maxPeakIdx,
+    troughIndex: maxTroughIdx,
+    peakDate: dates ? dates[maxPeakIdx] ?? null : null,
+    troughDate: dates ? dates[maxTroughIdx] ?? null : null,
+    recoveryDate: recoveryIdx != null && dates ? dates[recoveryIdx] ?? null : null,
+    durationDays: maxTroughIdx - maxPeakIdx,
+    recoveryDays: recoveryIdx != null ? recoveryIdx - maxTroughIdx : null,
+    drawdownSeries
+  };
+}
+function maxDrawdownDuration(nav) {
+  let maxDuration = 0;
+  let currentDuration = 0;
+  let peak = nav[0];
+  for (let i = 0; i < nav.length; i++) {
+    if (nav[i] >= peak) {
+      peak = nav[i];
+      currentDuration = 0;
+    } else {
+      currentDuration++;
+      maxDuration = Math.max(maxDuration, currentDuration);
+    }
+  }
+  return maxDuration;
+}
+function calculateVaR(returns, confidence = 0.95, method = "historical") {
+  if (returns.length < 2) return 0;
+  if (method === "historical") {
+    const sorted = [...returns].sort((a, b) => a - b);
+    return ss__namespace.quantileSorted(sorted, 1 - confidence);
+  } else {
+    const mean = ss__namespace.mean(returns);
+    const std = ss__namespace.standardDeviation(returns);
+    const z = jstat.jStat.normal.inv(1 - confidence, 0, 1);
+    return mean + z * std;
+  }
+}
+function calculateCVaR(returns, confidence = 0.95) {
+  if (returns.length < 2) return 0;
+  const varValue = calculateVaR(returns, confidence, "historical");
+  const tailReturns = returns.filter((r) => r <= varValue);
+  if (tailReturns.length === 0) return varValue;
+  return ss__namespace.mean(tailReturns);
+}
+function riskMetrics(nav, riskFreeRate = 0.025) {
+  const returns = navToReturns(nav);
+  const dd = maxDrawdown(nav);
+  return {
+    annualizedVolatility: annualizedVolatility(returns),
+    downsideVolatility: downsideVolatility(returns, riskFreeRate),
+    maxDrawdown: dd.maxDrawdown,
+    maxDrawdownDuration: maxDrawdownDuration(nav),
+    var95: calculateVaR(returns, 0.95),
+    var99: calculateVaR(returns, 0.99),
+    cvar95: calculateCVaR(returns, 0.95),
+    cvar99: calculateCVaR(returns, 0.99)
+  };
+}
+function sharpeRatio(nav, riskFreeRate = 0.025) {
+  const returns = navToReturns(nav);
+  const annReturn = annualizeReturn(returns);
+  const annVol = annualizedVolatility(returns);
+  if (annVol === 0) return 0;
+  return (annReturn - riskFreeRate) / annVol;
+}
+function sortinoRatio(nav, riskFreeRate = 0.025) {
+  const returns = navToReturns(nav);
+  const annReturn = annualizeReturn(returns);
+  const dv = downsideVolatility(returns, riskFreeRate);
+  if (dv === 0) return 0;
+  return (annReturn - riskFreeRate) / dv;
+}
+function calmarRatio(nav) {
+  const returns = navToReturns(nav);
+  const annReturn = annualizeReturn(returns);
+  const dd = maxDrawdown(nav);
+  if (dd.maxDrawdown === 0) return 0;
+  return annReturn / Math.abs(dd.maxDrawdown);
+}
+function treynorRatio(nav, benchmarkNav, riskFreeRate = 0.025) {
+  const fundReturns = navToReturns(nav);
+  const benchReturns = navToReturns(benchmarkNav);
+  const minLen = Math.min(fundReturns.length, benchReturns.length);
+  const fRet = fundReturns.slice(-minLen);
+  const bRet = benchReturns.slice(-minLen);
+  const beta = calculateBeta(fRet, bRet);
+  if (beta === 0) return null;
+  const annReturn = annualizeReturn(fRet);
+  return (annReturn - riskFreeRate) / beta;
+}
+function omegaRatio(nav, threshold = 0) {
+  const returns = navToReturns(nav);
+  const dailyThreshold = threshold / TRADING_DAYS_PER_YEAR;
+  let gains = 0;
+  let losses = 0;
+  for (const r of returns) {
+    if (r > dailyThreshold) gains += r - dailyThreshold;
+    else losses += dailyThreshold - r;
+  }
+  if (losses === 0) return gains > 0 ? Infinity : 0;
+  return gains / losses;
+}
+function winRate(returns) {
+  if (returns.length === 0) return 0;
+  const wins = returns.filter((r) => r > 0).length;
+  return wins / returns.length;
+}
+function profitLossRatio(returns) {
+  const wins = returns.filter((r) => r > 0);
+  const losses = returns.filter((r) => r < 0);
+  if (losses.length === 0) return wins.length > 0 ? Infinity : 0;
+  const avgWin = wins.length > 0 ? ss__namespace.mean(wins) : 0;
+  const avgLoss = Math.abs(ss__namespace.mean(losses));
+  if (avgLoss === 0) return 0;
+  return avgWin / avgLoss;
+}
+function profitFactor(returns) {
+  const totalWins = returns.filter((r) => r > 0).reduce((a, b) => a + b, 0);
+  const totalLosses = Math.abs(returns.filter((r) => r < 0).reduce((a, b) => a + b, 0));
+  if (totalLosses === 0) return totalWins > 0 ? Infinity : 0;
+  return totalWins / totalLosses;
+}
+function consecutiveWinLoss(returns) {
+  let maxWins = 0, maxLosses = 0;
+  let curWins = 0, curLosses = 0;
+  for (const r of returns) {
+    if (r > 0) {
+      curWins++;
+      curLosses = 0;
+      maxWins = Math.max(maxWins, curWins);
+    } else if (r < 0) {
+      curLosses++;
+      curWins = 0;
+      maxLosses = Math.max(maxLosses, curLosses);
+    } else {
+      curWins = 0;
+      curLosses = 0;
+    }
+  }
+  return { maxWins, maxLosses };
+}
+function performanceMetrics(nav, riskFreeRate = 0.025) {
+  const returns = navToReturns(nav);
+  const consec = consecutiveWinLoss(returns);
+  const dd = maxDrawdown(nav);
+  const annReturn = annualizeReturn(returns);
+  const annVol = annualizedVolatility(returns);
+  const dv = downsideVolatility(returns, riskFreeRate);
+  return {
+    totalReturn: totalReturn(nav),
+    annualizedReturn: annReturn,
+    sharpeRatio: annVol > 0 ? (annReturn - riskFreeRate) / annVol : 0,
+    sortinoRatio: dv > 0 ? (annReturn - riskFreeRate) / dv : 0,
+    calmarRatio: dd.maxDrawdown !== 0 ? annReturn / Math.abs(dd.maxDrawdown) : 0,
+    treynorRatio: null,
+    // 需要基准数据，单独计算
+    omegaRatio: omegaRatio(nav),
+    winRate: winRate(returns),
+    profitLossRatio: profitLossRatio(returns),
+    profitFactor: profitFactor(returns),
+    maxConsecutiveWins: consec.maxWins,
+    maxConsecutiveLosses: consec.maxLosses
+  };
+}
+function calculateBeta(fundReturns, benchmarkReturns) {
+  const minLen = Math.min(fundReturns.length, benchmarkReturns.length);
+  const f = fundReturns.slice(-minLen);
+  const b = benchmarkReturns.slice(-minLen);
+  const cov = ss__namespace.sampleCovariance(f, b);
+  const bVar = ss__namespace.variance(b);
+  return bVar > 0 ? cov / bVar : 0;
+}
+function calculateAlpha(fundReturns, benchmarkReturns, riskFreeRate = 0.025) {
+  const minLen = Math.min(fundReturns.length, benchmarkReturns.length);
+  const f = fundReturns.slice(-minLen);
+  const b = benchmarkReturns.slice(-minLen);
+  const fAnnReturn = annualizeReturn(f);
+  const bAnnReturn = annualizeReturn(b);
+  const beta = calculateBeta(f, b);
+  return fAnnReturn - (riskFreeRate + beta * (bAnnReturn - riskFreeRate));
+}
+function trackingError(fundReturns, benchmarkReturns) {
+  const minLen = Math.min(fundReturns.length, benchmarkReturns.length);
+  const f = fundReturns.slice(-minLen);
+  const b = benchmarkReturns.slice(-minLen);
+  const excessReturns = f.map((r, i) => r - b[i]);
+  return ss__namespace.standardDeviation(excessReturns) * Math.sqrt(TRADING_DAYS_PER_YEAR);
+}
+function informationRatio(fundReturns, benchmarkReturns) {
+  const minLen = Math.min(fundReturns.length, benchmarkReturns.length);
+  const f = fundReturns.slice(-minLen);
+  const b = benchmarkReturns.slice(-minLen);
+  const excessReturns = f.map((r, i) => r - b[i]);
+  const meanExcess = ss__namespace.mean(excessReturns) * TRADING_DAYS_PER_YEAR;
+  const te = ss__namespace.standardDeviation(excessReturns) * Math.sqrt(TRADING_DAYS_PER_YEAR);
+  return te > 0 ? meanExcess / te : 0;
+}
+function benchmarkMetrics(fundNav, benchmarkNav, riskFreeRate = 0.025) {
+  const fundReturns = navToReturns(fundNav);
+  const benchReturns = navToReturns(benchmarkNav);
+  const minLen = Math.min(fundReturns.length, benchReturns.length);
+  const f = fundReturns.slice(-minLen);
+  const b = benchReturns.slice(-minLen);
+  const beta = calculateBeta(f, b);
+  const alpha = calculateAlpha(f, b, riskFreeRate);
+  const te = trackingError(f, b);
+  const ir = te > 0 ? informationRatio(f, b) : 0;
+  const corr = ss__namespace.sampleCorrelation(f, b);
+  const rSquared = corr * corr;
+  return {
+    alpha,
+    beta,
+    trackingError: te,
+    informationRatio: ir,
+    correlation: corr,
+    rSquared
+  };
+}
+
+function statisticalFeatures(nav) {
+  const returns = navToReturns(nav);
+  if (returns.length < 4) {
+    return {
+      mean: 0,
+      median: 0,
+      stdDev: 0,
+      skewness: 0,
+      kurtosis: 0,
+      min: 0,
+      max: 0,
+      range: 0,
+      coefficientOfVariation: 0,
+      jarqueBera: 0
+    };
+  }
+  const mean = ss__namespace.mean(returns);
+  const median = ss__namespace.median(returns);
+  const stdDev = ss__namespace.standardDeviation(returns);
+  const skewness = ss__namespace.sampleSkewness(returns);
+  const kurtosis = ss__namespace.sampleKurtosis(returns);
+  const min = ss__namespace.min(returns);
+  const max = ss__namespace.max(returns);
+  const range = max - min;
+  const coefficientOfVariation = mean !== 0 ? stdDev / Math.abs(mean) : 0;
+  const n = returns.length;
+  const jarqueBera = n / 6 * (skewness * skewness + kurtosis * kurtosis / 4);
+  return {
+    mean,
+    median,
+    stdDev,
+    skewness,
+    kurtosis,
+    min,
+    max,
+    range,
+    coefficientOfVariation,
+    jarqueBera
+  };
+}
+function navStatisticalFeatures(nav) {
+  if (nav.length < 4) {
+    return {
+      mean: 0,
+      median: 0,
+      stdDev: 0,
+      skewness: 0,
+      kurtosis: 0,
+      min: 0,
+      max: 0,
+      range: 0,
+      coefficientOfVariation: 0,
+      jarqueBera: 0
+    };
+  }
+  const mean = ss__namespace.mean(nav);
+  const median = ss__namespace.median(nav);
+  const stdDev = ss__namespace.standardDeviation(nav);
+  const skewness = ss__namespace.sampleSkewness(nav);
+  const kurtosis = ss__namespace.sampleKurtosis(nav);
+  const min = ss__namespace.min(nav);
+  const max = ss__namespace.max(nav);
+  const range = max - min;
+  const coefficientOfVariation = mean !== 0 ? stdDev / Math.abs(mean) : 0;
+  const n = nav.length;
+  const jarqueBera = n / 6 * (skewness * skewness + kurtosis * kurtosis / 4);
+  return {
+    mean,
+    median,
+    stdDev,
+    skewness,
+    kurtosis,
+    min,
+    max,
+    range,
+    coefficientOfVariation,
+    jarqueBera
+  };
+}
+function hurstExponent(nav, minWindowSize = 16, maxWindowSize, numPoints = 10) {
+  const returns = navToReturns(nav);
+  const n = returns.length;
+  if (n < minWindowSize * 2) {
+    return {
+      hurstExponent: 0.5,
+      interpretation: "random_walk",
+      dataPoints: [],
+      rSquared: 0
+    };
+  }
+  const maxWin = maxWindowSize ?? Math.floor(n / 2);
+  const dataPoints = [];
+  const logMin = Math.log(minWindowSize);
+  const logMax = Math.log(maxWin);
+  for (let p = 0; p < numPoints; p++) {
+    const logWindowSize = logMin + p / (numPoints - 1) * (logMax - logMin);
+    const windowSize = Math.floor(Math.exp(logWindowSize));
+    if (windowSize < 2 || windowSize > n) continue;
+    const numSubPeriods = Math.floor(n / windowSize);
+    if (numSubPeriods < 1) continue;
+    let totalRS = 0;
+    let validCount = 0;
+    for (let s = 0; s < numSubPeriods; s++) {
+      const start = s * windowSize;
+      const subPeriod = returns.slice(start, start + windowSize);
+      const mean = ss__namespace.mean(subPeriod);
+      const std = ss__namespace.standardDeviation(subPeriod);
+      if (std === 0) continue;
+      const cumDeviations = [];
+      let cumDev = 0;
+      for (const r of subPeriod) {
+        cumDev += r - mean;
+        cumDeviations.push(cumDev);
+      }
+      const range = Math.max(...cumDeviations) - Math.min(...cumDeviations);
+      const rs = range / std;
+      totalRS += rs;
+      validCount++;
+    }
+    if (validCount > 0) {
+      const avgRS = totalRS / validCount;
+      dataPoints.push({ logN: Math.log(windowSize), logRS: Math.log(avgRS) });
+    }
+  }
+  if (dataPoints.length < 3) {
+    return {
+      hurstExponent: 0.5,
+      interpretation: "random_walk",
+      dataPoints,
+      rSquared: 0
+    };
+  }
+  const regressionData = dataPoints.map((d) => [d.logN, d.logRS]);
+  const regression = ss__namespace.linearRegression(regressionData);
+  const H = regression.m;
+  const predicted = dataPoints.map((d) => regression.m * d.logN + regression.b);
+  const actual = dataPoints.map((d) => d.logRS);
+  const meanActual = ss__namespace.mean(actual);
+  const ssTotal = actual.reduce((sum, v) => sum + (v - meanActual) ** 2, 0);
+  const ssResidual = actual.reduce((sum, v, i) => sum + (v - predicted[i]) ** 2, 0);
+  const rSquared = ssTotal > 0 ? 1 - ssResidual / ssTotal : 0;
+  let interpretation;
+  if (H > 0.55) interpretation = "trending";
+  else if (H < 0.45) interpretation = "mean_reverting";
+  else interpretation = "random_walk";
+  return {
+    hurstExponent: Math.max(0, Math.min(1, H)),
+    // 限制在 [0, 1]
+    interpretation,
+    dataPoints,
+    rSquared
+  };
+}
+function autocorrelation(nav, maxLag = 20) {
+  const returns = navToReturns(nav);
+  const n = returns.length;
+  if (n < maxLag + 2) {
+    maxLag = Math.max(1, n - 2);
+  }
+  const mean = ss__namespace.mean(returns);
+  const variance = returns.reduce((sum, r) => sum + (r - mean) ** 2, 0) / n;
+  const coefficients = [];
+  for (let lag = 0; lag <= maxLag; lag++) {
+    if (variance === 0) {
+      coefficients.push(lag === 0 ? 1 : 0);
+      continue;
+    }
+    let cov = 0;
+    for (let i = 0; i < n - lag; i++) {
+      cov += (returns[i] - mean) * (returns[i + lag] - mean);
+    }
+    cov /= n;
+    coefficients.push(cov / variance);
+  }
+  let interpretation;
+  const lag1 = coefficients.length > 1 ? coefficients[1] : 0;
+  if (lag1 > 0.05) interpretation = "persistent";
+  else if (lag1 < -0.05) interpretation = "anti_persistent";
+  else interpretation = "no_correlation";
+  return { coefficients, maxLag, interpretation };
+}
+function ljungBoxTest(returns, maxLag = 10) {
+  const n = returns.length;
+  const mean = ss__namespace.mean(returns);
+  const variance = returns.reduce((sum, r) => sum + (r - mean) ** 2, 0) / n;
+  if (variance === 0) return { qStatistic: 0, approximatePValue: 1 };
+  const acf = [];
+  for (let k = 1; k <= maxLag; k++) {
+    let cov = 0;
+    for (let i = 0; i < n - k; i++) {
+      cov += (returns[i] - mean) * (returns[i + k] - mean);
+    }
+    cov /= n;
+    acf.push(cov / variance);
+  }
+  let q = 0;
+  for (let k = 0; k < maxLag; k++) {
+    q += acf[k] * acf[k] / (n - k - 1);
+  }
+  q *= n * (n + 2);
+  const df = maxLag;
+  const z = Math.pow(q / df, 1 / 3) - (1 - 2 / (9 * df));
+  const se = Math.sqrt(2 / (9 * df));
+  const zScore = z / se;
+  const pValue = 1 - normalCDF(zScore);
+  return { qStatistic: q, approximatePValue: Math.max(0, Math.min(1, pValue)) };
+}
+function normalCDF(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  x = Math.abs(x) / Math.sqrt(2);
+  const t = 1 / (1 + p * x);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+  return 0.5 * (1 + sign * y);
+}
+function returnQuantiles(nav, quantiles = [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99]) {
+  const returns = navToReturns(nav);
+  const sorted = [...returns].sort((a, b) => a - b);
+  const result = /* @__PURE__ */ new Map();
+  for (const q of quantiles) {
+    result.set(q, ss__namespace.quantileSorted(sorted, q));
+  }
+  return result;
+}
+function rollingSkewness(returns, window = 60) {
+  const result = [];
+  for (let i = 0; i < returns.length; i++) {
+    if (i < window - 1) {
+      result.push(null);
+    } else {
+      const slice = returns.slice(i - window + 1, i + 1);
+      result.push(ss__namespace.sampleSkewness(slice));
+    }
+  }
+  return result;
+}
+function rollingKurtosis(returns, window = 60) {
+  const result = [];
+  for (let i = 0; i < returns.length; i++) {
+    if (i < window - 1) {
+      result.push(null);
+    } else {
+      const slice = returns.slice(i - window + 1, i + 1);
+      result.push(ss__namespace.sampleKurtosis(slice));
+    }
+  }
+  return result;
+}
+function garch11(returns) {
+  const n = returns.length;
+  if (n < 30) {
+    const v = ss__namespace.variance(returns);
+    return {
+      conditionalVariance: new Array(n).fill(v),
+      nextPeriodForecast: v,
+      omega: v * 0.1,
+      alpha: 0.1,
+      beta: 0.8
+    };
+  }
+  const unconditionalVar = ss__namespace.variance(returns);
+  const squaredReturns = returns.map((r) => r * r);
+  const meanSquared = ss__namespace.mean(squaredReturns);
+  let autocov = 0;
+  for (let i = 0; i < n - 1; i++) {
+    autocov += (squaredReturns[i] - meanSquared) * (squaredReturns[i + 1] - meanSquared);
+  }
+  autocov /= n;
+  const autoCorr = meanSquared > 0 ? autocov / ss__namespace.variance(squaredReturns) : 0;
+  const alphaBeta = Math.max(0.5, Math.min(0.99, autoCorr + 0.8));
+  const alpha = Math.max(0.01, Math.min(0.3, (1 - alphaBeta) * 2));
+  const beta = alphaBeta - alpha;
+  const omega = unconditionalVar * (1 - alpha - beta);
+  const conditionalVariance = [unconditionalVar];
+  for (let i = 1; i < n; i++) {
+    const prevVar = conditionalVariance[i - 1];
+    const newVar = omega + alpha * returns[i - 1] * returns[i - 1] + beta * prevVar;
+    conditionalVariance.push(Math.max(newVar, 1e-10));
+  }
+  const lastVar = conditionalVariance[n - 1];
+  const lastReturn = returns[n - 1];
+  const nextPeriodForecast = omega + alpha * lastReturn * lastReturn + beta * lastVar;
+  return { conditionalVariance, nextPeriodForecast, omega, alpha, beta };
+}
+
+function simulateDCA(nav, config, dates) {
+  const { amount, interval = 1, startIndex = 0 } = config;
+  let totalInvested = 0;
+  let totalShares = 0;
+  const investmentDates = [];
+  const valueHistory = [];
+  for (let i = startIndex; i < nav.length; i += interval) {
+    const navPrice = nav[i];
+    if (navPrice <= 0) continue;
+    const shares = amount / navPrice;
+    totalShares += shares;
+    totalInvested += amount;
+    investmentDates.push(i);
+    const currentValue2 = totalShares * navPrice;
+    valueHistory.push(currentValue2);
+  }
+  if (totalInvested === 0 || totalShares === 0) {
+    return {
+      totalInvestments: 0,
+      totalInvested: 0,
+      currentValue: 0,
+      totalShares: 0,
+      averageCost: 0,
+      currentNav: 0,
+      returnRate: 0,
+      profitLoss: 0,
+      irr: null,
+      investmentDates,
+      valueHistory
+    };
+  }
+  const currentNav = nav[nav.length - 1];
+  const currentValue = totalShares * currentNav;
+  const averageCost = totalInvested / totalShares;
+  const returnRate = (currentValue - totalInvested) / totalInvested;
+  const profitLoss = currentValue - totalInvested;
+  const irr = calculateIRR(nav, investmentDates, amount, totalShares, currentNav);
+  return {
+    totalInvestments: investmentDates.length,
+    totalInvested,
+    currentValue,
+    totalShares,
+    averageCost,
+    currentNav,
+    returnRate,
+    profitLoss,
+    irr,
+    investmentDates,
+    valueHistory
+  };
+}
+function calculateIRR(nav, investmentDates, amount, totalShares, currentNav) {
+  if (investmentDates.length < 2) return null;
+  const baseDay = investmentDates[0];
+  const cashFlows = [];
+  for (const d of investmentDates) {
+    cashFlows.push({ day: d - baseDay, amount: -amount });
+  }
+  const lastDay = nav.length - 1 - baseDay;
+  cashFlows.push({ day: lastDay, amount: totalShares * currentNav });
+  const T = 242;
+  function npv(r2) {
+    let sum = 0;
+    for (const cf of cashFlows) {
+      const t = cf.day / T;
+      if (t === 0) sum += cf.amount;
+      else sum += cf.amount / Math.pow(1 + r2, t);
+    }
+    return sum;
+  }
+  function npvDerivative(r2) {
+    let sum = 0;
+    for (const cf of cashFlows) {
+      const t = cf.day / T;
+      if (t <= 0) continue;
+      sum -= t * cf.amount / Math.pow(1 + r2, t + 1);
+    }
+    return sum;
+  }
+  let r = 0.1;
+  const maxIterations = 100;
+  const tolerance = 1e-8;
+  for (let i = 0; i < maxIterations; i++) {
+    const f = npv(r);
+    const fPrime = npvDerivative(r);
+    if (Math.abs(fPrime) < 1e-12) break;
+    const newR = r - f / fPrime;
+    if (Math.abs(newR - r) < tolerance) {
+      return newR;
+    }
+    r = newR;
+    if (r < -0.99) r = -0.99;
+    if (r > 10) r = 10;
+  }
+  return bisectionIRR(npv);
+}
+function bisectionIRR(npv) {
+  let low = -0.99;
+  let high = 10;
+  const tolerance = 1e-6;
+  const maxIterations = 200;
+  let fLow = npv(low);
+  let fHigh = npv(high);
+  if (fLow * fHigh > 0) return null;
+  for (let i = 0; i < maxIterations; i++) {
+    const mid = (low + high) / 2;
+    const fMid = npv(mid);
+    if (Math.abs(fMid) < tolerance || (high - low) / 2 < tolerance) {
+      return mid;
+    }
+    if (fLow * fMid < 0) {
+      high = mid;
+      fHigh = fMid;
+    } else {
+      low = mid;
+      fLow = fMid;
+    }
+  }
+  return (low + high) / 2;
+}
+function takeProfitStopLoss(nav, costPrice, takeProfitThreshold = 0.3, stopLossThreshold = -0.15) {
+  const currentNav = nav[nav.length - 1];
+  const currentPnL = (currentNav - costPrice) / costPrice;
+  return {
+    takeProfitTriggered: currentPnL >= takeProfitThreshold,
+    stopLossTriggered: currentPnL <= stopLossThreshold,
+    currentPnL,
+    distanceToTakeProfit: takeProfitThreshold - currentPnL,
+    distanceToStopLoss: currentPnL - stopLossThreshold
+  };
+}
+function trailingStop(nav, trailPercent = 0.1, costPrice) {
+  let peakNav = nav[0];
+  for (const v of nav) {
+    if (v > peakNav) peakNav = v;
+  }
+  const currentNav = nav[nav.length - 1];
+  const drawdownFromPeak = (peakNav - currentNav) / peakNav;
+  const profitFromCost = costPrice ? (currentNav - costPrice) / costPrice : 0;
+  return {
+    triggered: drawdownFromPeak >= trailPercent && currentNav > (costPrice ?? 0),
+    peakNav,
+    currentNav,
+    drawdownFromPeak,
+    profitFromCost
+  };
+}
+function safetyMargin(nav) {
+  const peak = Math.max(...nav);
+  const current = nav[nav.length - 1];
+  return (peak - current) / peak;
+}
+function pricePosition(nav) {
+  const peak = Math.max(...nav);
+  const trough = Math.min(...nav);
+  const current = nav[nav.length - 1];
+  if (peak === trough) return 0.5;
+  return (current - trough) / (peak - trough);
+}
+function smartDCAMultiplier(nav, maPeriod = 250, maxMultiplier = 2, minMultiplier = 0.5) {
+  if (nav.length < maPeriod) return 1;
+  const recent = nav.slice(-maPeriod);
+  const ma = recent.reduce((a, b) => a + b, 0) / maPeriod;
+  const current = nav[nav.length - 1];
+  const deviation = (current - ma) / ma;
+  const multiplier = 1 - deviation * 4;
+  return Math.max(minMultiplier, Math.min(maxMultiplier, multiplier));
+}
+function tieredBuySignal(nav, levels = [0.3, 0.2, 0.1]) {
+  const sorted = [...nav].sort((a, b) => a - b);
+  const current = nav[nav.length - 1];
+  let rank = 0;
+  for (const v of sorted) {
+    if (v < current) rank++;
+    else if (v === current) rank += 0.5;
+  }
+  const percentile = rank / sorted.length;
+  for (let i = 0; i < levels.length; i++) {
+    if (percentile <= levels[i]) return levels.length - i;
+  }
+  return 0;
+}
+function tieredSellSignal(nav, levels = [0.7, 0.8, 0.9]) {
+  const sorted = [...nav].sort((a, b) => a - b);
+  const current = nav[nav.length - 1];
+  let rank = 0;
+  for (const v of sorted) {
+    if (v < current) rank++;
+    else if (v === current) rank += 0.5;
+  }
+  const percentile = rank / sorted.length;
+  for (let i = levels.length - 1; i >= 0; i--) {
+    if (percentile >= levels[i]) return i + 1;
+  }
+  return 0;
+}
+function positionPnL(nav, buyIndex, sellIndex, amount = 1e4) {
+  const sell = sellIndex ?? nav.length - 1;
+  const buyNav = nav[buyIndex];
+  const sellNav = nav[sell];
+  const shares = amount / buyNav;
+  const value = shares * sellNav;
+  const pnl = value - amount;
+  const returnRate = pnl / amount;
+  const holdDays = sell - buyIndex;
+  const annualizedReturn = holdDays > 0 ? Math.pow(1 + returnRate, 242 / holdDays) - 1 : 0;
+  return {
+    buyNav,
+    sellNav,
+    shares,
+    cost: amount,
+    value,
+    pnl,
+    returnRate,
+    holdDays,
+    annualizedReturn
+  };
+}
+
+function supportResistance(nav, tolerance = 0.02, minTouches = 3) {
+  if (nav.length < 10) {
+    return { supports: [], resistances: [] };
+  }
+  const current = nav[nav.length - 1];
+  const levelMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nav.length; i++) {
+    const isLocalHigh = i > 0 && i < nav.length - 1 && nav[i] >= nav[i - 1] && nav[i] >= nav[i + 1];
+    const isLocalLow = i > 0 && i < nav.length - 1 && nav[i] <= nav[i - 1] && nav[i] <= nav[i + 1];
+    if (isLocalHigh || isLocalLow) {
+      let merged = false;
+      for (const [level, count] of levelMap.entries()) {
+        if (Math.abs(nav[i] - level) / level < tolerance) {
+          levelMap.set(level, count + 1);
+          merged = true;
+          break;
+        }
+      }
+      if (!merged) {
+        levelMap.set(nav[i], 1);
+      }
+    }
+  }
+  for (const price of nav) {
+    let merged = false;
+    for (const [level, count] of levelMap.entries()) {
+      if (Math.abs(price - level) / level < tolerance) {
+        levelMap.set(level, count + 1);
+        merged = true;
+        break;
+      }
+    }
+    if (!merged) {
+      levelMap.set(price, 1);
+    }
+  }
+  const validLevels = Array.from(levelMap.entries()).filter(([, touches]) => touches >= minTouches).map(([level, touches]) => ({
+    level,
+    touches,
+    strength: touches / nav.length
+  })).sort((a, b) => b.strength - a.strength);
+  const supports = validLevels.filter((l) => l.level < current).sort((a, b) => b.level - a.level);
+  const resistances = validLevels.filter((l) => l.level > current).sort((a, b) => a.level - b.level);
+  return { supports, resistances };
+}
+function doubleBottomTop(nav, lookback = 60, tolerance = 0.03, minDistance = 10) {
+  const noResult = {
+    type: "none",
+    firstPointIndex: null,
+    secondPointIndex: null,
+    necklineIndex: null,
+    necklinePrice: null,
+    breakout: false,
+    confidence: 0
+  };
+  if (nav.length < lookback || lookback < minDistance * 2) return noResult;
+  const window = nav.slice(-lookback);
+  const offset = nav.length - lookback;
+  const localMins = [];
+  const localMaxs = [];
+  for (let i = 2; i < window.length - 2; i++) {
+    if (window[i] <= window[i - 1] && window[i] <= window[i + 1] && window[i] <= window[i - 2] && window[i] <= window[i + 2]) {
+      localMins.push({ index: i, value: window[i] });
+    }
+    if (window[i] >= window[i - 1] && window[i] >= window[i + 1] && window[i] >= window[i - 2] && window[i] >= window[i + 2]) {
+      localMaxs.push({ index: i, value: window[i] });
+    }
+  }
+  for (let i = 0; i < localMins.length; i++) {
+    for (let j = i + 1; j < localMins.length; j++) {
+      const first = localMins[i];
+      const second = localMins[j];
+      const distance = second.index - first.index;
+      if (distance < minDistance) continue;
+      const priceDiff = Math.abs(first.value - second.value) / first.value;
+      if (priceDiff > tolerance) continue;
+      const between = window.slice(first.index, second.index + 1);
+      const neckValue = Math.max(...between);
+      const neckIdx = first.index + between.indexOf(neckValue);
+      const currentPrice = window[window.length - 1];
+      const breakout = currentPrice > neckValue;
+      const similarity = 1 - priceDiff / tolerance;
+      const distanceFactor = Math.min(1, distance / lookback * 2);
+      const confidence = (similarity * 0.6 + distanceFactor * 0.4) * (breakout ? 1 : 0.7);
+      return {
+        type: "double_bottom",
+        firstPointIndex: offset + first.index,
+        secondPointIndex: offset + second.index,
+        necklineIndex: offset + neckIdx,
+        necklinePrice: neckValue,
+        breakout,
+        confidence
+      };
+    }
+  }
+  for (let i = 0; i < localMaxs.length; i++) {
+    for (let j = i + 1; j < localMaxs.length; j++) {
+      const first = localMaxs[i];
+      const second = localMaxs[j];
+      const distance = second.index - first.index;
+      if (distance < minDistance) continue;
+      const priceDiff = Math.abs(first.value - second.value) / first.value;
+      if (priceDiff > tolerance) continue;
+      const between = window.slice(first.index, second.index + 1);
+      const neckValue = Math.min(...between);
+      const neckIdx = first.index + between.indexOf(neckValue);
+      const currentPrice = window[window.length - 1];
+      const breakout = currentPrice < neckValue;
+      const similarity = 1 - priceDiff / tolerance;
+      const distanceFactor = Math.min(1, distance / lookback * 2);
+      const confidence = (similarity * 0.6 + distanceFactor * 0.4) * (breakout ? 1 : 0.7);
+      return {
+        type: "double_top",
+        firstPointIndex: offset + first.index,
+        secondPointIndex: offset + second.index,
+        necklineIndex: offset + neckIdx,
+        necklinePrice: neckValue,
+        breakout,
+        confidence
+      };
+    }
+  }
+  return noResult;
+}
+function detectGaps(nav, threshold = 0.02) {
+  const gaps = [];
+  for (let i = 1; i < nav.length; i++) {
+    const change = (nav[i] - nav[i - 1]) / nav[i - 1];
+    const absChange = Math.abs(change);
+    if (absChange >= threshold) {
+      const isGapUp = change > 0;
+      const gapTop = isGapUp ? nav[i] : nav[i - 1];
+      const gapBottom = isGapUp ? nav[i - 1] : nav[i];
+      let filled = false;
+      let filledIndex = null;
+      if (isGapUp) {
+        for (let j = i + 1; j < nav.length; j++) {
+          if (nav[j] <= gapBottom) {
+            filled = true;
+            filledIndex = j;
+            break;
+          }
+        }
+      } else {
+        for (let j = i + 1; j < nav.length; j++) {
+          if (nav[j] >= gapTop) {
+            filled = true;
+            filledIndex = j;
+            break;
+          }
+        }
+      }
+      gaps.push({
+        type: isGapUp ? "gap_up" : "gap_down",
+        startIndex: i - 1,
+        endIndex: i,
+        gapTop,
+        gapBottom,
+        gapSize: absChange,
+        filled,
+        filledIndex
+      });
+    }
+  }
+  return gaps;
+}
+function trendStrength(nav, period = 20) {
+  if (nav.length < period + 10) return 50;
+  const recent = nav.slice(-period);
+  const returns = [];
+  for (let i = 1; i < recent.length; i++) {
+    returns.push((recent[i] - recent[i - 1]) / recent[i - 1]);
+  }
+  const positiveDays = returns.filter((r) => r > 0).length;
+  const directionScore = positiveDays / returns.length * 100;
+  const indices = returns.map((_, i) => i);
+  const meanY = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const meanX = indices.reduce((a, b) => a + b, 0) / indices.length;
+  let ssXY = 0, ssXX = 0, ssYY = 0;
+  for (let i = 0; i < returns.length; i++) {
+    ssXY += (indices[i] - meanX) * (returns[i] - meanY);
+    ssXX += (indices[i] - meanX) ** 2;
+    ssYY += (returns[i] - meanY) ** 2;
+  }
+  const rSquared = ssXX > 0 && ssYY > 0 ? ssXY * ssXY / (ssXX * ssYY) : 0;
+  const fitScore = rSquared * 100;
+  let maxStreak = 0;
+  let currentStreak = 0;
+  for (const r of returns) {
+    if (r > 0) {
+      currentStreak++;
+      maxStreak = Math.max(maxStreak, currentStreak);
+    } else currentStreak = 0;
+  }
+  const streakScore = Math.min(100, maxStreak / returns.length * 200);
+  return directionScore * 0.4 + fitScore * 0.35 + streakScore * 0.25;
+}
+function headAndShoulders(nav, lookback = 90) {
+  const noResult = {
+    type: "none",
+    leftShoulder: null,
+    head: null,
+    rightShoulder: null,
+    neckline: null,
+    confidence: 0
+  };
+  if (nav.length < lookback) return noResult;
+  const window = nav.slice(-lookback);
+  const peaks = [];
+  const troughs = [];
+  for (let i = 3; i < window.length - 3; i++) {
+    const isPeak = window[i] > window[i - 1] && window[i] > window[i + 1] && window[i] > window[i - 2] && window[i] > window[i + 2] && window[i] > window[i - 3] && window[i] > window[i + 3];
+    const isTrough = window[i] < window[i - 1] && window[i] < window[i + 1] && window[i] < window[i - 2] && window[i] < window[i + 2] && window[i] < window[i - 3] && window[i] < window[i + 3];
+    if (isPeak) peaks.push({ index: i, value: window[i] });
+    if (isTrough) troughs.push({ index: i, value: window[i] });
+  }
+  if (peaks.length >= 3) {
+    for (let i = 0; i < peaks.length - 2; i++) {
+      const left = peaks[i];
+      const head = peaks[i + 1];
+      const right = peaks[i + 2];
+      if (head.value <= left.value || head.value <= right.value) continue;
+      const shoulderDiff = Math.abs(left.value - right.value) / left.value;
+      if (shoulderDiff > 0.05) continue;
+      const headPremium = (head.value - (left.value + right.value) / 2) / ((left.value + right.value) / 2);
+      if (headPremium < 0.03) continue;
+      const between = window.slice(left.index, right.index + 1);
+      const neckline = Math.min(...between);
+      const confidence = Math.min(1, (1 - shoulderDiff / 0.05) * 0.5 + Math.min(headPremium / 0.1, 1) * 0.5);
+      return {
+        type: "head_and_shoulders_top",
+        leftShoulder: { index: nav.length - lookback + left.index, value: left.value },
+        head: { index: nav.length - lookback + head.index, value: head.value },
+        rightShoulder: { index: nav.length - lookback + right.index, value: right.value },
+        neckline,
+        confidence
+      };
+    }
+  }
+  if (troughs.length >= 3) {
+    for (let i = 0; i < troughs.length - 2; i++) {
+      const left = troughs[i];
+      const head = troughs[i + 1];
+      const right = troughs[i + 2];
+      if (head.value >= left.value || head.value >= right.value) continue;
+      const shoulderDiff = Math.abs(left.value - right.value) / left.value;
+      if (shoulderDiff > 0.05) continue;
+      const headDiscount = ((left.value + right.value) / 2 - head.value) / ((left.value + right.value) / 2);
+      if (headDiscount < 0.03) continue;
+      const between = window.slice(left.index, right.index + 1);
+      const neckline = Math.max(...between);
+      const confidence = Math.min(1, (1 - shoulderDiff / 0.05) * 0.5 + Math.min(headDiscount / 0.1, 1) * 0.5);
+      return {
+        type: "head_and_shoulders_bottom",
+        leftShoulder: { index: nav.length - lookback + left.index, value: left.value },
+        head: { index: nav.length - lookback + head.index, value: head.value },
+        rightShoulder: { index: nav.length - lookback + right.index, value: right.value },
+        neckline,
+        confidence
+      };
+    }
+  }
+  return noResult;
+}
+
+exports.adx = adx;
+exports.annualizeReturn = annualizeReturn;
+exports.annualizedVolatility = annualizedVolatility;
+exports.atr = atr;
+exports.autocorrelation = autocorrelation;
+exports.benchmarkMetrics = benchmarkMetrics;
+exports.bias = bias;
+exports.bollingerBands = bollingerBands;
+exports.calculateAlpha = calculateAlpha;
+exports.calculateBeta = calculateBeta;
+exports.calculateCVaR = calculateCVaR;
+exports.calculateVaR = calculateVaR;
+exports.calmarRatio = calmarRatio;
+exports.cci = cci;
+exports.consecutiveWinLoss = consecutiveWinLoss;
+exports.dema = dema;
+exports.detectCrossSignal = detectCrossSignal;
+exports.detectGaps = detectGaps;
+exports.detectMAAlignment = detectMAAlignment;
+exports.donchianChannel = donchianChannel;
+exports.doubleBottomTop = doubleBottomTop;
+exports.downsideVolatility = downsideVolatility;
+exports.dpo = dpo;
+exports.ema = ema;
+exports.garch11 = garch11;
+exports.headAndShoulders = headAndShoulders;
+exports.hurstExponent = hurstExponent;
+exports.informationRatio = informationRatio;
+exports.kama = kama;
+exports.kdj = kdj;
+exports.keltnerChannel = keltnerChannel;
+exports.ljungBoxTest = ljungBoxTest;
+exports.macd = macd;
+exports.massIndex = massIndex;
+exports.maxDrawdown = maxDrawdown;
+exports.maxDrawdownDuration = maxDrawdownDuration;
+exports.momentum = momentum;
+exports.navPercentile = navPercentile;
+exports.navStatisticalFeatures = navStatisticalFeatures;
+exports.navToReturns = navToReturns;
+exports.omegaRatio = omegaRatio;
+exports.performanceMetrics = performanceMetrics;
+exports.positionPnL = positionPnL;
+exports.pricePosition = pricePosition;
+exports.profitFactor = profitFactor;
+exports.profitLossRatio = profitLossRatio;
+exports.returnQuantiles = returnQuantiles;
+exports.riskMetrics = riskMetrics;
+exports.roc = roc;
+exports.rollingKurtosis = rollingKurtosis;
+exports.rollingSkewness = rollingSkewness;
+exports.rollingVolatility = rollingVolatility;
+exports.rsi = rsi;
+exports.safetyMargin = safetyMargin;
+exports.sar = sar;
+exports.sharpeRatio = sharpeRatio;
+exports.simulateDCA = simulateDCA;
+exports.sma = sma;
+exports.smartDCAMultiplier = smartDCAMultiplier;
+exports.sortinoRatio = sortinoRatio;
+exports.statisticalFeatures = statisticalFeatures;
+exports.stochasticRSI = stochasticRSI;
+exports.supportResistance = supportResistance;
+exports.takeProfitStopLoss = takeProfitStopLoss;
+exports.tema = tema;
+exports.tieredBuySignal = tieredBuySignal;
+exports.tieredSellSignal = tieredSellSignal;
+exports.totalReturn = totalReturn;
+exports.trackingError = trackingError;
+exports.trailingStop = trailingStop;
+exports.trendStrength = trendStrength;
+exports.treynorRatio = treynorRatio;
+exports.trix = trix;
+exports.volatilityCone = volatilityCone;
+exports.williamsR = williamsR;
+exports.winRate = winRate;
+exports.wma = wma;