oakscriptjs 0.8.1 → 0.9.0

package/dist/cjs/ta/index.js

@@ -0,0 +1,1715 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ta_exports = {};
+__export(ta_exports, {
+  accdist: () => accdist,
+  alma: () => alma,
+  atr: () => atr,
+  barssince: () => barssince,
+  bb: () => bb,
+  bbw: () => bbw,
+  cci: () => cci,
+  change: () => change,
+  cmo: () => cmo,
+  cog: () => cog,
+  correlation: () => correlation,
+  cross: () => cross,
+  crossover: () => crossover,
+  crossunder: () => crossunder,
+  cum: () => cum,
+  dev: () => dev,
+  dmi: () => dmi,
+  ema: () => ema,
+  falling: () => falling,
+  highest: () => highest,
+  highestbars: () => highestbars,
+  hma: () => hma,
+  ichimoku: () => ichimoku,
+  iii: () => iii,
+  kc: () => kc,
+  kcw: () => kcw,
+  linreg: () => linreg,
+  lowest: () => lowest,
+  lowestbars: () => lowestbars,
+  macd: () => macd,
+  max: () => max,
+  median: () => median,
+  mfi: () => mfi,
+  min: () => min,
+  mode: () => mode,
+  mom: () => mom,
+  nvi: () => nvi,
+  obv: () => obv,
+  percentile_linear_interpolation: () => percentile_linear_interpolation,
+  percentile_nearest_rank: () => percentile_nearest_rank,
+  percentrank: () => percentrank,
+  pivot_point_levels: () => pivot_point_levels,
+  pivothigh: () => pivothigh,
+  pivotlow: () => pivotlow,
+  pvi: () => pvi,
+  pvt: () => pvt,
+  range: () => range,
+  rci: () => rci,
+  rising: () => rising,
+  rma: () => rma,
+  roc: () => roc,
+  rsi: () => rsi,
+  sar: () => sar,
+  sma: () => sma,
+  stdev: () => stdev,
+  stoch: () => stoch,
+  supertrend: () => supertrend,
+  swma: () => swma,
+  tr: () => tr,
+  tsi: () => tsi,
+  valuewhen: () => valuewhen,
+  variance: () => variance,
+  vwap: () => vwap,
+  vwma: () => vwma,
+  wad: () => wad,
+  wma: () => wma,
+  wpr: () => wpr,
+  wvad: () => wvad,
+  zigzag: () => zigzag
+});
+module.exports = __toCommonJS(ta_exports);
+var import_compare = require("../compare/index.js");
+var import_running_sum = require("./running-sum.js");
+function sma(source, length) {
+  const len = Math.floor(length);
+  return (0, import_running_sum.runningSum)(source, len).map((sum) => sum / len);
+}
+function strictWindowMean(source, length) {
+  const len = Math.floor(length);
+  return Array.from({ length: source.length }, (_, i) => {
+    if (i < len - 1) return NaN;
+    let sum = 0;
+    for (let j = 0; j < len; j++) sum += source[i - j];
+    return sum / len;
+  });
+}
+function ema(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  const multiplier = 2 / (len + 1);
+  let firstValidIndex = -1;
+  let validCount = 0;
+  let initSum = 0;
+  for (let i = 0; i < source.length; i++) {
+    const val = source[i];
+    if (val !== void 0 && Number.isFinite(val)) {
+      initSum += val;
+      validCount++;
+      if (validCount === len) {
+        firstValidIndex = i;
+        break;
+      }
+    }
+  }
+  let emaValue = validCount > 0 ? initSum / validCount : NaN;
+  const emaInitialized = firstValidIndex >= 0;
+  for (let i = 0; i < source.length; i++) {
+    if (!emaInitialized || i < firstValidIndex) {
+      result.push(NaN);
+    } else if (i === firstValidIndex) {
+      result.push(emaValue);
+    } else {
+      const val = source[i];
+      if (val !== void 0 && Number.isFinite(val)) {
+        emaValue = (val - emaValue) * multiplier + emaValue;
+        result.push(emaValue);
+      } else {
+        result.push(NaN);
+      }
+    }
+  }
+  return result;
+}
+function rsi(source, length) {
+  const result = [];
+  const changes = [];
+  for (let i = 1; i < source.length; i++) {
+    changes.push(source[i] - source[i - 1]);
+  }
+  const gains = changes.map((c) => Number.isNaN(c) ? NaN : c > 0 ? c : 0);
+  const losses = changes.map((c) => Number.isNaN(c) ? NaN : c < 0 ? -c : 0);
+  const avgGains = rma(gains, length);
+  const avgLosses = rma(losses, length);
+  result.push(NaN);
+  for (let i = 0; i < avgGains.length; i++) {
+    if (avgLosses[i] === 0) {
+      result.push(100);
+    } else {
+      const rs = avgGains[i] / avgLosses[i];
+      result.push(100 - 100 / (1 + rs));
+    }
+  }
+  return result;
+}
+function macd(source, fastLength, slowLength, signalLength) {
+  const fastEma = ema(source, fastLength);
+  const slowEma = ema(source, slowLength);
+  const macdLine = [];
+  for (let i = 0; i < source.length; i++) {
+    macdLine.push(fastEma[i] - slowEma[i]);
+  }
+  const signalLine = ema(macdLine, signalLength);
+  const histogram = [];
+  for (let i = 0; i < source.length; i++) {
+    histogram.push(macdLine[i] - signalLine[i]);
+  }
+  return [macdLine, signalLine, histogram];
+}
+function bb(series, length, mult) {
+  const basis = sma(series, length);
+  const dev2 = stdev(series, length);
+  const upper = [];
+  const lower = [];
+  for (let i = 0; i < series.length; i++) {
+    upper.push(basis[i] + mult * dev2[i]);
+    lower.push(basis[i] - mult * dev2[i]);
+  }
+  return [basis, upper, lower];
+}
+function stdev(source, length, biased = true) {
+  return variance(source, length, biased).map((v) => Number.isNaN(v) ? NaN : v > 0 ? Math.sqrt(v) : 0);
+}
+function lastValues(source, i, length) {
+  const values = [];
+  for (let j = i; j >= 0 && values.length < length; j--) {
+    const x = source[j];
+    if (!Number.isNaN(x)) values.push(x);
+  }
+  return values.length === length ? values : null;
+}
+function windowExtremes(source, length, lowest2) {
+  const n = source.length;
+  const span = length > 0 ? Math.ceil(length) : 0;
+  const at = new Int32Array(n).fill(-1);
+  const zeros = new Uint8Array(n);
+  const queue = new Int32Array(n);
+  const preferredZero = lowest2 ? -0 : 0;
+  let head = 0;
+  let tail = 0;
+  let zeroCount = 0;
+  let lastNa = -1;
+  const isPreferredZero = (k) => Object.is(source[k], preferredZero);
+  for (let i = 0; i < n; i++) {
+    const x = source[i];
+    if (Number.isNaN(x)) {
+      lastNa = i;
+      head = tail = 0;
+      zeroCount = 0;
+      continue;
+    }
+    while (tail > head && (lowest2 ? source[queue[tail - 1]] > x : source[queue[tail - 1]] < x)) {
+      if (isPreferredZero(queue[--tail])) zeroCount--;
+    }
+    queue[tail++] = i;
+    if (isPreferredZero(i)) zeroCount++;
+    const start = Math.max(i - span + 1, lastNa + 1);
+    while (head < tail && queue[head] < start) {
+      if (isPreferredZero(queue[head++])) zeroCount--;
+    }
+    if (head < tail) {
+      at[i] = queue[head];
+      zeros[i] = zeroCount > 0 ? 1 : 0;
+    }
+  }
+  return { at, zeros };
+}
+function extremeOffset(source, length, lowest2) {
+  const { at } = windowExtremes(source, length, lowest2);
+  return source.map((_, i) => i < length - 1 ? NaN : at[i] < 0 ? 0 : -(i - at[i]));
+}
+function extremeValue(source, length, lowest2) {
+  const { at, zeros } = windowExtremes(source, length, lowest2);
+  return source.map((_, i) => {
+    if (i < length - 1 || at[i] < 0) return NaN;
+    const v = source[at[i]];
+    return v === 0 && zeros[i] ? lowest2 ? -0 : 0 : v;
+  });
+}
+function crossover(series1, series2) {
+  const result = [];
+  for (let i = 0; i < series1.length; i++) {
+    if (i === 0) {
+      result.push(false);
+    } else {
+      result.push(series1[i] > series2[i] && series1[i - 1] <= series2[i - 1]);
+    }
+  }
+  return result;
+}
+function crossunder(series1, series2) {
+  const result = [];
+  for (let i = 0; i < series1.length; i++) {
+    if (i === 0) {
+      result.push(false);
+    } else {
+      result.push(series1[i] < series2[i] && series1[i - 1] >= series2[i - 1]);
+    }
+  }
+  return result;
+}
+function change(source, length = 1) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+    } else {
+      result.push(source[i] - source[i - length]);
+    }
+  }
+  return result;
+}
+function tr(handle_na = false, high, low, close) {
+  if (!high || !low || !close) {
+    throw new Error(
+      "ta.tr() requires high, low, and close series. Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data."
+    );
+  }
+  const result = [];
+  for (let i = 0; i < high.length; i++) {
+    if (i === 0) {
+      result.push(handle_na ? high[i] - low[i] : NaN);
+    } else {
+      const prevClose = close[i - 1];
+      if (isNaN(prevClose)) {
+        if (handle_na) {
+          result.push(high[i] - low[i]);
+        } else {
+          result.push(NaN);
+        }
+      } else {
+        const tr2 = Math.max(
+          high[i] - low[i],
+          Math.abs(high[i] - prevClose),
+          Math.abs(low[i] - prevClose)
+        );
+        result.push(tr2);
+      }
+    }
+  }
+  return result;
+}
+function atr(length, high, low, close) {
+  if (!high || !low || !close) {
+    throw new Error(
+      "ta.atr() requires high, low, and close series. Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data."
+    );
+  }
+  const trueRange = tr(true, high, low, close);
+  return rma(trueRange, length);
+}
+function supertrend(factor, atrPeriod, high, low, close, wicks = false) {
+  if (!high || !low || !close) {
+    throw new Error(
+      "ta.supertrend() requires high, low, and close series. Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data."
+    );
+  }
+  const supertrendValues = [];
+  const directions = [];
+  const source = [];
+  for (let i = 0; i < high.length; i++) {
+    source.push((high[i] + low[i]) / 2);
+  }
+  const atrValues = atr(atrPeriod, high, low, close);
+  let prevLowerBand = NaN;
+  let prevUpperBand = NaN;
+  let prevSuperTrend = NaN;
+  for (let i = 0; i < source.length; i++) {
+    const atrValue = atrValues[i] * factor;
+    if (isNaN(atrValue)) {
+      supertrendValues.push(NaN);
+      directions.push(1);
+      continue;
+    }
+    let upperBand = source[i] + atrValue;
+    let lowerBand = source[i] - atrValue;
+    const highPrice = wicks ? high[i] : close[i];
+    const lowPrice = wicks ? low[i] : close[i];
+    const prevLowPrice = i > 0 ? wicks ? low[i - 1] : close[i - 1] : 0;
+    const prevHighPrice = i > 0 ? wicks ? high[i - 1] : close[i - 1] : 0;
+    if (i > 0 && !isNaN(prevLowerBand) && !isNaN(prevUpperBand)) {
+      lowerBand = lowerBand > prevLowerBand || prevLowPrice < prevLowerBand ? lowerBand : prevLowerBand;
+      upperBand = upperBand < prevUpperBand || prevHighPrice > prevUpperBand ? upperBand : prevUpperBand;
+    }
+    let currentDirection;
+    if (isNaN(prevSuperTrend)) {
+      currentDirection = 1;
+    } else if (prevSuperTrend === prevUpperBand) {
+      currentDirection = highPrice > upperBand ? -1 : 1;
+    } else {
+      currentDirection = lowPrice < lowerBand ? 1 : -1;
+    }
+    const superTrendValue = currentDirection === -1 ? lowerBand : upperBand;
+    supertrendValues.push(superTrendValue);
+    directions.push(currentDirection);
+    prevLowerBand = lowerBand;
+    prevUpperBand = upperBand;
+    prevSuperTrend = superTrendValue;
+  }
+  return [supertrendValues, directions];
+}
+function rma(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  let firstValidIndex = -1;
+  let validCount = 0;
+  let initSum = 0;
+  for (let i = 0; i < source.length; i++) {
+    const val = source[i];
+    if (val !== void 0 && Number.isFinite(val)) {
+      initSum += val;
+      validCount++;
+      if (validCount === len) {
+        firstValidIndex = i;
+        break;
+      }
+    }
+  }
+  let rmaValue = validCount > 0 ? initSum / validCount : NaN;
+  const rmaInitialized = firstValidIndex >= 0;
+  for (let i = 0; i < source.length; i++) {
+    if (!rmaInitialized || i < firstValidIndex) {
+      result.push(NaN);
+    } else if (i === firstValidIndex) {
+      result.push(rmaValue);
+    } else {
+      const val = source[i];
+      if (val !== void 0 && Number.isFinite(val)) {
+        rmaValue = (val + (len - 1) * rmaValue) / len;
+        result.push(rmaValue);
+      } else {
+        result.push(NaN);
+      }
+    }
+  }
+  return result;
+}
+function wma(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  const filled = [];
+  let last = NaN;
+  let count = 0;
+  for (let i = 0; i < source.length; i++) {
+    const v = source[i];
+    const isNa = v === void 0 || v === null || !Number.isFinite(v);
+    if (!isNa) {
+      last = v;
+      count++;
+    }
+    filled.push(last);
+    if (isNa || count < len) {
+      result.push(NaN);
+      continue;
+    }
+    let sum = 0;
+    let weightSum = 0;
+    for (let j = len - 1; j >= 0; j--) {
+      const weight = len - j;
+      sum += filled[i - j] * weight;
+      weightSum += weight;
+    }
+    result.push(sum / weightSum);
+  }
+  return result;
+}
+function highest(source, length) {
+  return extremeValue(source, length, false);
+}
+function lowest(source, length) {
+  return extremeValue(source, length, true);
+}
+function cum(source) {
+  let sum = 0;
+  return source.map((v) => {
+    if (!Number.isFinite(v)) return NaN;
+    sum += v;
+    return sum;
+  });
+}
+function cross(source1, source2) {
+  const result = [];
+  for (let i = 0; i < source1.length; i++) {
+    if (i === 0) {
+      result.push(false);
+    } else {
+      const crossedUp = source1[i] > source2[i] && source1[i - 1] <= source2[i - 1];
+      const crossedDown = source1[i] < source2[i] && source1[i - 1] >= source2[i - 1];
+      result.push(crossedUp || crossedDown);
+    }
+  }
+  return result;
+}
+function monotonic(source, length, step) {
+  const result = [];
+  const values = [];
+  for (let i = 0; i < source.length; i++) {
+    const v = source[i];
+    if (!Number.isNaN(v)) values.push(v);
+    const n = values.length;
+    let ok = n > length;
+    for (let j = 1; ok && j <= length; j++) ok = step(values[n - j], values[n - j - 1]);
+    result.push(ok);
+  }
+  return result;
+}
+function rising(source, length) {
+  return monotonic(source, length, import_compare.gt);
+}
+function falling(source, length) {
+  return monotonic(source, length, import_compare.lt);
+}
+function roc(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+    } else {
+      const oldValue = source[i - length];
+      if (oldValue === 0 || isNaN(oldValue) || isNaN(source[i])) {
+        result.push(NaN);
+      } else {
+        const changeValue = source[i] - oldValue;
+        result.push(100 * changeValue / oldValue);
+      }
+    }
+  }
+  return result;
+}
+function mom(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+    } else {
+      if (isNaN(source[i]) || isNaN(source[i - length])) {
+        result.push(NaN);
+      } else {
+        result.push(source[i] - source[i - length]);
+      }
+    }
+  }
+  return result;
+}
+function dev(source, length) {
+  const result = [];
+  const meanValues = strictWindowMean(source, length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1 || isNaN(meanValues[i])) {
+      result.push(NaN);
+    } else {
+      let sum = 0;
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          sum += Math.abs(source[i - j] - meanValues[i]);
+        }
+      }
+      result.push(sum / length);
+    }
+  }
+  return result;
+}
+function variance(source, length, biased = true) {
+  const len = Math.floor(length);
+  if ((biased ? len : len - 1) <= 0) return source.map(() => NaN);
+  return (0, import_running_sum.runningVariance)(source, len, biased);
+}
+function median(source, length) {
+  const len = Math.floor(length);
+  const n = source.length;
+  const out = new Array(n).fill(NaN);
+  if (!(len >= 1)) return out;
+  const sorted = [];
+  const kept = new Float64Array(n);
+  let count = 0;
+  const bound = (v, after) => {
+    let lo = 0;
+    let hi = sorted.length;
+    while (lo < hi) {
+      const m = lo + hi >> 1;
+      if (after ? sorted[m] <= v : sorted[m] < v) lo = m + 1;
+      else hi = m;
+    }
+    return lo;
+  };
+  const mid = Math.floor(len / 2);
+  for (let i = 0; i < n; i++) {
+    const x = source[i];
+    if (!Number.isNaN(x)) {
+      kept[count++] = x;
+      sorted.splice(bound(x, false), 0, x);
+      if (count > len) sorted.splice(bound(kept[count - 1 - len], true) - 1, 1);
+    }
+    if (count >= len) out[i] = len % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  }
+  return out;
+}
+function swma(source) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < 3) {
+      result.push(NaN);
+    } else {
+      if (isNaN(source[i]) || isNaN(source[i - 1]) || isNaN(source[i - 2]) || isNaN(source[i - 3])) {
+        result.push(NaN);
+      } else {
+        const value = source[i - 3] * (1 / 6) + source[i - 2] * (2 / 6) + source[i - 1] * (2 / 6) + source[i] * (1 / 6);
+        result.push(value);
+      }
+    }
+  }
+  return result;
+}
+function vwma(source, length, volume) {
+  if (!volume) {
+    throw new Error(
+      "ta.vwma() requires volume series. Either pass it explicitly or use createContext({ chart: { ..., volume } }) for implicit data."
+    );
+  }
+  const sourceTimesVolume = [];
+  for (let i = 0; i < source.length; i++) {
+    sourceTimesVolume.push(source[i] * volume[i]);
+  }
+  const numerator = sma(sourceTimesVolume, length);
+  const denominator = sma(volume, length);
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (denominator[i] === 0 || isNaN(denominator[i])) {
+      result.push(NaN);
+    } else {
+      result.push(numerator[i] / denominator[i]);
+    }
+  }
+  return result;
+}
+function linreg(source, length, offset = 0) {
+  const result = [];
+  const len = Math.floor(length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < len - 1) {
+      result.push(NaN);
+    } else {
+      let hasNaN = false;
+      for (let j = 0; j < len; j++) {
+        if (isNaN(source[i - j])) {
+          hasNaN = true;
+          break;
+        }
+      }
+      if (hasNaN) {
+        result.push(NaN);
+      } else {
+        let sumX = 0;
+        let sumY = 0;
+        let sumXY = 0;
+        let sumX2 = 0;
+        for (let j = 0; j < len; j++) {
+          const x2 = j;
+          const y = source[i - (len - 1 - j)];
+          sumX += x2;
+          sumY += y;
+          sumXY += x2 * y;
+          sumX2 += x2 * x2;
+        }
+        const slope = (len * sumXY - sumX * sumY) / (len * sumX2 - sumX * sumX);
+        const intercept = (sumY - slope * sumX) / len;
+        const x = len - 1 - offset;
+        result.push(intercept + slope * x);
+      }
+    }
+  }
+  return result;
+}
+function correlation(source1, source2, length) {
+  const result = [];
+  const span = length > 0 ? Math.ceil(length) : 0;
+  const a = new Float64Array(span);
+  const b = new Float64Array(span);
+  for (let i = 0; i < source1.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let m = 0;
+    for (let j = 0; j < length; j++) {
+      const v1 = source1[i - j];
+      const v2 = source2[i - j];
+      if (!isNaN(v1) && !isNaN(v2)) {
+        a[m] = v1;
+        b[m] = v2;
+        m++;
+      }
+    }
+    if (m === 0) {
+      result.push(NaN);
+      continue;
+    }
+    let sum1 = 0;
+    let sum2 = 0;
+    for (let k = 0; k < m; k++) {
+      sum1 += a[k];
+      sum2 += b[k];
+    }
+    const mean1 = sum1 / m;
+    const mean2 = sum2 / m;
+    let numerator = 0;
+    let sum1Sq = 0;
+    let sum2Sq = 0;
+    for (let k = 0; k < m; k++) {
+      const dev1 = a[k] - mean1;
+      const dev2 = b[k] - mean2;
+      numerator += dev1 * dev2;
+      sum1Sq += dev1 * dev1;
+      sum2Sq += dev2 * dev2;
+    }
+    const denominator = Math.sqrt(sum1Sq * sum2Sq);
+    result.push(denominator === 0 ? NaN : numerator / denominator);
+  }
+  return result;
+}
+function percentrank(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    const currentValue = source[i];
+    if (i < length || Number.isNaN(currentValue)) {
+      result.push(NaN);
+      continue;
+    }
+    let countLessOrEqual = 0;
+    for (let j = 1; j <= length; j++) {
+      if ((0, import_compare.le)(source[i - j], currentValue)) countLessOrEqual++;
+    }
+    result.push(countLessOrEqual / length * 100);
+  }
+  return result;
+}
+function cci(source, length) {
+  const result = [];
+  const smaValues = sma(source, length);
+  const devValues = dev(source, length);
+  for (let i = 0; i < source.length; i++) {
+    if (isNaN(smaValues[i]) || isNaN(devValues[i]) || devValues[i] === 0) {
+      result.push(NaN);
+    } else {
+      const cci2 = (source[i] - smaValues[i]) / (0.015 * devValues[i]);
+      result.push(cci2);
+    }
+  }
+  return result;
+}
+function stoch(source, high, low, length) {
+  const result = [];
+  const lowestValues = lowest(low, length);
+  const highestValues = highest(high, length);
+  for (let i = 0; i < source.length; i++) {
+    if (isNaN(lowestValues[i]) || isNaN(highestValues[i])) {
+      result.push(NaN);
+    } else {
+      const range2 = highestValues[i] - lowestValues[i];
+      if (range2 === 0) {
+        result.push(NaN);
+      } else {
+        const stochValue = 100 * (source[i] - lowestValues[i]) / range2;
+        result.push(stochValue);
+      }
+    }
+  }
+  return result;
+}
+function mfi(source, length, volume) {
+  if (!volume) {
+    throw new Error(
+      "ta.mfi() requires volume series. Either pass it explicitly or use createContext({ chart: { ..., volume } }) for implicit data."
+    );
+  }
+  const upperFlow = [];
+  const lowerFlow = [];
+  for (let i = 0; i < source.length; i++) {
+    const change2 = i === 0 ? NaN : source[i] - source[i - 1];
+    const flow = volume[i] * source[i];
+    upperFlow.push((0, import_compare.le)(change2, 0) ? 0 : flow);
+    lowerFlow.push((0, import_compare.ge)(change2, 0) ? 0 : flow);
+  }
+  const upper = (0, import_running_sum.runningSum)(upperFlow, length);
+  const lower = (0, import_running_sum.runningSum)(lowerFlow, length);
+  return upper.map((u, i) => {
+    const l = lower[i];
+    if (Number.isNaN(u) || Number.isNaN(l)) return NaN;
+    if (l === 0) return 100;
+    return 100 - 100 / (1 + u / l);
+  });
+}
+function hma(source, length) {
+  const halfLength = Math.floor(length / 2);
+  const sqrtLength = Math.floor(Math.sqrt(length));
+  const wmaHalf = wma(source, halfLength);
+  const wmaFull = wma(source, length);
+  const diff = [];
+  for (let i = 0; i < source.length; i++) {
+    diff.push(2 * wmaHalf[i] - wmaFull[i]);
+  }
+  return wma(diff, sqrtLength);
+}
+function sar(start, inc, max2, high, low, close) {
+  if (!high || !low || !close) {
+    throw new Error(
+      "ta.sar() requires high, low, and close series. Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data."
+    );
+  }
+  const result = [];
+  let sarValue = NaN;
+  let extremePoint = NaN;
+  let acceleration = start;
+  let isUpTrend = false;
+  let isFirstTrendBar = false;
+  for (let i = 0; i < close.length; i++) {
+    if (i === 0) {
+      result.push(NaN);
+      continue;
+    }
+    if (i === 1) {
+      if (close[i] > close[i - 1]) {
+        isUpTrend = true;
+        extremePoint = high[i];
+        sarValue = low[i - 1];
+      } else {
+        isUpTrend = false;
+        extremePoint = low[i];
+        sarValue = high[i - 1];
+      }
+      isFirstTrendBar = true;
+      acceleration = start;
+    }
+    sarValue = sarValue + acceleration * (extremePoint - sarValue);
+    if (isUpTrend) {
+      if (sarValue > low[i]) {
+        isFirstTrendBar = true;
+        isUpTrend = false;
+        sarValue = Math.max(high[i], extremePoint);
+        extremePoint = low[i];
+        acceleration = start;
+      }
+    } else {
+      if (sarValue < high[i]) {
+        isFirstTrendBar = true;
+        isUpTrend = true;
+        sarValue = Math.min(low[i], extremePoint);
+        extremePoint = high[i];
+        acceleration = start;
+      }
+    }
+    if (!isFirstTrendBar) {
+      if (isUpTrend) {
+        if (high[i] > extremePoint) {
+          extremePoint = high[i];
+          acceleration = Math.min(acceleration + inc, max2);
+        }
+      } else {
+        if (low[i] < extremePoint) {
+          extremePoint = low[i];
+          acceleration = Math.min(acceleration + inc, max2);
+        }
+      }
+    }
+    if (isUpTrend) {
+      sarValue = Math.min(sarValue, low[i - 1]);
+      if (i > 1) {
+        sarValue = Math.min(sarValue, low[i - 2]);
+      }
+    } else {
+      sarValue = Math.max(sarValue, high[i - 1]);
+      if (i > 1) {
+        sarValue = Math.max(sarValue, high[i - 2]);
+      }
+    }
+    result.push(sarValue);
+    isFirstTrendBar = false;
+  }
+  return result;
+}
+function pivot(source, leftbars, rightbars, isHigh) {
+  const beatsLeft = isHigh ? (x, v) => x > v : (x, v) => x < v;
+  const beatsRight = isHigh ? (x, v) => x >= v : (x, v) => x <= v;
+  return source.map((_, i) => {
+    const center = i - rightbars;
+    if (center - leftbars < 0) return NaN;
+    const v = source[center];
+    if (Number.isNaN(v)) return NaN;
+    for (let j = 1; j <= leftbars; j++) {
+      const x = source[center - j];
+      if (Number.isNaN(x)) break;
+      if (beatsLeft(x, v)) return NaN;
+    }
+    for (let j = 1; j <= rightbars; j++) {
+      const x = source[center + j];
+      if (Number.isNaN(x)) break;
+      if (beatsRight(x, v)) return NaN;
+    }
+    return v;
+  });
+}
+function pivothigh(sourceOrLeftbars, leftbarsOrRightbars, rightbars, high) {
+  if (rightbars === void 0) {
+    if (!high) {
+      throw new Error("ta.pivothigh() requires high series when using two-parameter version.");
+    }
+    return pivot(high, sourceOrLeftbars, leftbarsOrRightbars, true);
+  }
+  return pivot(sourceOrLeftbars, leftbarsOrRightbars, rightbars, true);
+}
+function pivotlow(sourceOrLeftbars, leftbarsOrRightbars, rightbars, low) {
+  if (rightbars === void 0) {
+    if (!low) {
+      throw new Error("ta.pivotlow() requires low series when using two-parameter version.");
+    }
+    return pivot(low, sourceOrLeftbars, leftbarsOrRightbars, false);
+  }
+  return pivot(sourceOrLeftbars, leftbarsOrRightbars, rightbars, false);
+}
+function barssince(condition) {
+  const result = [];
+  let barsSinceTrue = NaN;
+  for (let i = 0; i < condition.length; i++) {
+    if (condition[i]) {
+      barsSinceTrue = 0;
+    } else if (!isNaN(barsSinceTrue)) {
+      barsSinceTrue++;
+    }
+    result.push(barsSinceTrue);
+  }
+  return result;
+}
+function valuewhen(condition, source, occurrence) {
+  const result = [];
+  for (let i = 0; i < condition.length; i++) {
+    let occurrenceCount = 0;
+    let foundValue = NaN;
+    for (let j = i; j >= 0; j--) {
+      if (condition[j]) {
+        if (occurrenceCount === occurrence) {
+          foundValue = source[j];
+          break;
+        }
+        occurrenceCount++;
+      }
+    }
+    result.push(foundValue);
+  }
+  return result;
+}
+function dmi(diLength, adxSmoothing, high, low, close) {
+  const len = Math.max(high.length, low.length, close.length);
+  const plusDM = [];
+  const minusDM = [];
+  for (let i = 0; i < len; i++) {
+    const up = i === 0 ? NaN : high[i] - high[i - 1];
+    const down = i === 0 ? NaN : low[i - 1] - low[i];
+    plusDM.push(Number.isNaN(up) ? NaN : (0, import_compare.gt)(up, down) && (0, import_compare.gt)(up, 0) ? up : 0);
+    minusDM.push(Number.isNaN(down) ? NaN : (0, import_compare.gt)(down, up) && (0, import_compare.gt)(down, 0) ? down : 0);
+  }
+  const trur = rma(tr(false, high, low, close), diLength);
+  const smoothedPlus = rma(plusDM, diLength);
+  const smoothedMinus = rma(minusDM, diLength);
+  const directional = (smoothed) => {
+    let last = NaN;
+    return smoothed.map((v, i) => {
+      const t = trur[i];
+      const value = t === 0 ? NaN : 100 * v / t;
+      if (!Number.isNaN(value)) last = value;
+      return last;
+    });
+  };
+  const plusDI = directional(smoothedPlus);
+  const minusDI = directional(smoothedMinus);
+  const dx = plusDI.map((plus, i) => {
+    const minus = minusDI[i];
+    const sum = plus + minus;
+    return Math.abs(plus - minus) / ((0, import_compare.eq)(sum, 0) ? 1 : sum);
+  });
+  const adx = rma(dx, adxSmoothing).map((v) => 100 * v);
+  return [plusDI, minusDI, adx];
+}
+function tsi(source, shortLength, longLength) {
+  const momentum = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i === 0) {
+      momentum.push(NaN);
+    } else {
+      momentum.push(source[i] - source[i - 1]);
+    }
+  }
+  const smoothedMomentum = ema(ema(momentum, longLength), shortLength);
+  const absMomentum = momentum.map(Math.abs);
+  const smoothedAbsMomentum = ema(ema(absMomentum, longLength), shortLength);
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (smoothedAbsMomentum[i] === 0) {
+      result.push(0);
+    } else {
+      result.push(smoothedMomentum[i] / smoothedAbsMomentum[i] * 100);
+    }
+  }
+  return result;
+}
+function cmo(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+      continue;
+    }
+    let sumGains = 0;
+    let sumLosses = 0;
+    for (let j = 0; j < length; j++) {
+      const change2 = source[i - j] - source[i - j - 1];
+      if (change2 > 0) {
+        sumGains += change2;
+      } else {
+        sumLosses += Math.abs(change2);
+      }
+    }
+    const totalMovement = sumGains + sumLosses;
+    if (totalMovement === 0) {
+      result.push(0);
+    } else {
+      const cmoValue = (sumGains - sumLosses) / totalMovement * 100;
+      result.push(cmoValue);
+    }
+  }
+  return result;
+}
+function kc(source, length, mult, useTrueRange = true, high, low, close) {
+  const middle = ema(source, length);
+  let range2;
+  if (useTrueRange) {
+    if (!high || !low || !close) {
+      throw new Error("ta.kc() with useTrueRange=true requires high, low, and close data");
+    }
+    range2 = tr(false, high, low, close);
+  } else {
+    if (!high || !low) {
+      throw new Error("ta.kc() requires high and low data");
+    }
+    range2 = [];
+    for (let i = 0; i < high.length; i++) {
+      range2.push(high[i] - low[i]);
+    }
+  }
+  const rangeEma = ema(range2, length);
+  const upper = [];
+  const lower = [];
+  for (let i = 0; i < middle.length; i++) {
+    upper.push(middle[i] + rangeEma[i] * mult);
+    lower.push(middle[i] - rangeEma[i] * mult);
+  }
+  return [middle, upper, lower];
+}
+function bbw(source, length, mult) {
+  const [basis, upper, lower] = bb(source, length, mult);
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (basis[i] === 0) {
+      result.push(NaN);
+    } else {
+      const width = (upper[i] - lower[i]) / basis[i] * 100;
+      result.push(width);
+    }
+  }
+  return result;
+}
+function wpr(high, low, close, length = 14) {
+  const result = [];
+  for (let i = 0; i < close.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let highestHigh = high[i - length + 1];
+    let lowestLow = low[i - length + 1];
+    for (let j = i - length + 2; j <= i; j++) {
+      if (high[j] > highestHigh) highestHigh = high[j];
+      if (low[j] < lowestLow) lowestLow = low[j];
+    }
+    const range2 = highestHigh - lowestLow;
+    if (range2 === 0) {
+      result.push(NaN);
+    } else {
+      const wprValue = (highestHigh - close[i]) / range2 * -100;
+      result.push(wprValue);
+    }
+  }
+  return result;
+}
+function vwap(source, volume, anchor, stdev_mult) {
+  if (source.length !== volume.length) {
+    throw new Error("ta.vwap: source and volume must have the same length");
+  }
+  const mid = [];
+  const upper = [];
+  const lower = [];
+  let sumPV = 0;
+  let sumV = 0;
+  let sumPPV = 0;
+  for (let i = 0; i < source.length; i++) {
+    if (anchor && anchor[i]) {
+      sumPV = 0;
+      sumV = 0;
+      sumPPV = 0;
+    }
+    const s = source[i];
+    const v = volume[i];
+    if (!Number.isNaN(s) && !Number.isNaN(v)) {
+      sumPV += s * v;
+      sumV += v;
+      sumPPV += s * s * v;
+    }
+    const m = sumV === 0 ? NaN : sumPV / sumV;
+    mid.push(m);
+    if (stdev_mult !== void 0) {
+      const sd = Math.sqrt(Math.max(0, sumPPV / sumV - m * m));
+      upper.push(m + stdev_mult * sd);
+      lower.push(m - stdev_mult * sd);
+    }
+  }
+  return stdev_mult === void 0 ? mid : [mid, upper, lower];
+}
+function alma(source, length = 9, offset = 0.85, sigma = 6, floor = false) {
+  const result = [];
+  const m = floor ? Math.floor(offset * (length - 1)) : offset * (length - 1);
+  const s = length / sigma;
+  const weights = [];
+  let weightSum = 0;
+  for (let i = 0; i < length; i++) {
+    const weight = Math.exp(-1 * Math.pow(i - m, 2) / (2 * Math.pow(s, 2)));
+    weights.push(weight);
+    weightSum += weight;
+  }
+  for (let i = 0; i < length; i++) {
+    weights[i] /= weightSum;
+  }
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let almaValue = 0;
+    for (let j = 0; j < length; j++) {
+      almaValue += source[i - length + 1 + j] * weights[j];
+    }
+    result.push(almaValue);
+  }
+  return result;
+}
+function kcw(source, length = 20, mult = 2, useTrueRange = true, high, low, close) {
+  const [basis, upper, lower] = kc(source, length, mult, useTrueRange, high, low, close);
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (isNaN(basis[i]) || basis[i] === 0) {
+      result.push(NaN);
+    } else {
+      const width = (upper[i] - lower[i]) / basis[i] * 100;
+      result.push(width);
+    }
+  }
+  return result;
+}
+function range(source, length) {
+  return source.map((_, i) => {
+    const values = lastValues(source, i, length);
+    return values ? Math.max(...values) - Math.min(...values) : NaN;
+  });
+}
+function highestbars(source, length) {
+  return extremeOffset(source, length, false);
+}
+function lowestbars(source, length) {
+  return extremeOffset(source, length, true);
+}
+function max(source) {
+  let best = NaN;
+  return source.map((x) => {
+    if (!Number.isNaN(x) && !(x <= best)) best = x;
+    return best;
+  });
+}
+function min(source) {
+  let best = NaN;
+  return source.map((x) => {
+    if (!Number.isNaN(x) && !(x >= best)) best = x;
+    return best;
+  });
+}
+function cog(source, length = 10) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let numerator = 0;
+    let denominator = 0;
+    for (let j = 0; j < length; j++) {
+      const weight = j + 1;
+      const price = source[i - length + 1 + j];
+      numerator += weight * price;
+      denominator += price;
+    }
+    if (denominator === 0) {
+      result.push(NaN);
+    } else {
+      const cog2 = -1 * (numerator / denominator) + (length + 1) / 2;
+      result.push(cog2);
+    }
+  }
+  return result;
+}
+function mode(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    const values = [];
+    for (let j = 0; j < length; j++) {
+      const value = source[i - j];
+      if (!isNaN(value)) {
+        values.push(value);
+      }
+    }
+    if (values.length === 0) {
+      result.push(NaN);
+      continue;
+    }
+    const frequencyMap = /* @__PURE__ */ new Map();
+    for (const value of values) {
+      frequencyMap.set(value, (frequencyMap.get(value) || 0) + 1);
+    }
+    let maxFrequency = 0;
+    frequencyMap.forEach((freq) => {
+      if (freq > maxFrequency) {
+        maxFrequency = freq;
+      }
+    });
+    const modesWithMaxFreq = [];
+    frequencyMap.forEach((freq, value) => {
+      if (freq === maxFrequency) {
+        modesWithMaxFreq.push(value);
+      }
+    });
+    result.push(Math.min(...modesWithMaxFreq));
+  }
+  return result;
+}
+function percentile_linear_interpolation(source, length, percentage) {
+  return sortedWindow(source, length, (s) => {
+    const pos = percentage / 100 * length - 0.5;
+    if (pos <= 0) return s[0];
+    if (pos >= length - 1) return s[length - 1];
+    const lo = Math.floor(pos);
+    return s[lo] + (pos - lo) * (s[lo + 1] - s[lo]);
+  });
+}
+function sortedWindow(source, length, fn) {
+  const result = [];
+  const values = [];
+  const bars = [];
+  for (let i = 0; i < source.length; i++) {
+    const v = source[i];
+    let k = 0;
+    while (k < values.length && !(values[k] >= v)) k++;
+    values.splice(k, 0, v);
+    bars.splice(k, 0, i);
+    if (i >= length) {
+      const old = bars.indexOf(i - length);
+      values.splice(old, 1);
+      bars.splice(old, 1);
+    }
+    result.push(i < length - 1 ? NaN : fn(values));
+  }
+  return result;
+}
+function percentile_nearest_rank(source, length, percentage) {
+  const rank = Math.min(length, Math.max(1, Math.ceil(percentage / 100 * length)));
+  return sortedWindow(source, length, (s) => s[rank - 1]);
+}
+function rci(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    const values = [];
+    for (let j = 0; j < length; j++) {
+      values.push(source[i - length + 1 + j]);
+    }
+    if (values.some((v) => isNaN(v))) {
+      result.push(NaN);
+      continue;
+    }
+    const indexed = values.map((value, index) => ({ value, index }));
+    const sorted = [...indexed].sort((a, b) => a.value - b.value);
+    const ranks = new Array(length).fill(0);
+    let currentRank = 1;
+    for (let j = 0; j < sorted.length; j++) {
+      let tieCount = 1;
+      while (j + tieCount < sorted.length && sorted[j].value === sorted[j + tieCount].value) {
+        tieCount++;
+      }
+      const avgRank = (currentRank + (currentRank + tieCount - 1)) / 2;
+      for (let k = 0; k < tieCount; k++) {
+        ranks[sorted[j + k].index] = avgRank;
+      }
+      j += tieCount - 1;
+      currentRank += tieCount;
+    }
+    let sumSquaredDiff = 0;
+    for (let j = 0; j < length; j++) {
+      const timeRank = j + 1;
+      const diff = ranks[j] - timeRank;
+      sumSquaredDiff += diff * diff;
+    }
+    const n = length;
+    const base = (n * n * n - n) / 12;
+    let tieCorrection = 0;
+    for (let j = 0; j < sorted.length; ) {
+      let tieCount = 1;
+      while (j + tieCount < sorted.length && sorted[j].value === sorted[j + tieCount].value) {
+        tieCount++;
+      }
+      if (tieCount > 1) {
+        tieCorrection += (tieCount * tieCount * tieCount - tieCount) / 12;
+      }
+      j += tieCount;
+    }
+    const A = base - tieCorrection;
+    const B = base;
+    let rho;
+    if (A === 0 || B === 0) {
+      rho = 0;
+    } else {
+      rho = (A + B - sumSquaredDiff) / (2 * Math.sqrt(A * B));
+    }
+    result.push(rho * 100);
+  }
+  return result;
+}
+function pivot_point_levels(type, anchor, developing = false, high, low, close, open) {
+  const typeStr = typeof type === "string" ? type : String(type[0]);
+  const isDeveloping = typeof developing === "boolean" ? developing : developing[0];
+  if (typeStr === "Woodie" && isDeveloping) {
+    throw new Error("ta.pivot_point_levels: Woodie type cannot use developing=true");
+  }
+  const length = anchor.length;
+  if (high && high.length !== length) throw new Error("High series length mismatch");
+  if (low && low.length !== length) throw new Error("Low series length mismatch");
+  if (close && close.length !== length) throw new Error("Close series length mismatch");
+  if (open && open.length !== length) throw new Error("Open series length mismatch");
+  const results = Array.from({ length: 11 }, () => []);
+  let lastH = NaN, lastL = NaN, lastC = NaN, lastO = NaN;
+  let lastAnchorIndex = -1;
+  for (let i = 0; i < length; i++) {
+    if (anchor[i]) {
+      lastAnchorIndex = i;
+      lastH = high ? high[i] : NaN;
+      lastL = low ? low[i] : NaN;
+      lastC = close ? close[i] : NaN;
+      lastO = open ? open[i] : NaN;
+    }
+    let h, l, c, o;
+    if (isDeveloping && lastAnchorIndex >= 0) {
+      h = high ? Math.max(...high.slice(lastAnchorIndex, i + 1).filter((v) => !isNaN(v))) : NaN;
+      l = low ? Math.min(...low.slice(lastAnchorIndex, i + 1).filter((v) => !isNaN(v))) : NaN;
+      c = close ? close[i] : NaN;
+      o = open && lastAnchorIndex >= 0 ? open[lastAnchorIndex] : NaN;
+    } else {
+      h = lastH;
+      l = lastL;
+      c = lastC;
+      o = lastO;
+    }
+    const levels = calculatePivotLevels(typeStr, h, l, c, o);
+    for (let j = 0; j < 11; j++) {
+      results[j].push(levels[j]);
+    }
+  }
+  return results;
+}
+function calculatePivotLevels(type, h, l, c, o) {
+  if (isNaN(h) || isNaN(l) || isNaN(c)) {
+    return Array(11).fill(NaN);
+  }
+  const levels = Array(11).fill(NaN);
+  let P;
+  switch (type) {
+    case "Traditional":
+    case "Fibonacci":
+    case "Classic":
+      P = (h + l + c) / 3;
+      break;
+    case "Woodie":
+      P = (h + l + 2 * c) / 4;
+      break;
+    case "DM":
+      P = (h + l + c) / 3;
+      break;
+    case "Camarilla":
+      P = (h + l + c) / 3;
+      break;
+    default:
+      P = (h + l + c) / 3;
+  }
+  levels[0] = P;
+  switch (type) {
+    case "Traditional":
+    case "Classic":
+      levels[1] = 2 * P - l;
+      levels[2] = 2 * P - h;
+      levels[3] = P + (h - l);
+      levels[4] = P - (h - l);
+      levels[5] = h + 2 * (P - l);
+      levels[6] = l - 2 * (h - P);
+      levels[7] = levels[5] + (h - l);
+      levels[8] = levels[6] - (h - l);
+      levels[9] = levels[7] + (h - l);
+      levels[10] = levels[8] - (h - l);
+      break;
+    case "Fibonacci":
+      levels[1] = P + 0.382 * (h - l);
+      levels[2] = P - 0.382 * (h - l);
+      levels[3] = P + 0.618 * (h - l);
+      levels[4] = P - 0.618 * (h - l);
+      levels[5] = P + (h - l);
+      levels[6] = P - (h - l);
+      levels[7] = levels[5] + 0.618 * (h - l);
+      levels[8] = levels[6] - 0.618 * (h - l);
+      levels[9] = levels[7] + 0.382 * (h - l);
+      levels[10] = levels[8] - 0.382 * (h - l);
+      break;
+    case "Woodie":
+      levels[1] = 2 * P - l;
+      levels[2] = 2 * P - h;
+      levels[3] = P + (h - l);
+      levels[4] = P - (h - l);
+      levels[5] = h + 2 * (P - l);
+      levels[6] = l - 2 * (h - P);
+      levels[7] = levels[5] + (h - l);
+      levels[8] = levels[6] - (h - l);
+      levels[9] = levels[7] + (h - l);
+      levels[10] = levels[8] - (h - l);
+      break;
+    case "DM": {
+      const x = h + l + c * 2 + (isNaN(o) ? c : o);
+      const newP = x / (isNaN(o) ? 4 : 5);
+      levels[0] = newP;
+      levels[1] = x / 2 - l;
+      levels[2] = x / 2 - h;
+      break;
+    }
+    case "Camarilla": {
+      const range2 = h - l;
+      levels[1] = c + range2 * 1.1 / 12;
+      levels[2] = c - range2 * 1.1 / 12;
+      levels[3] = c + range2 * 1.1 / 6;
+      levels[4] = c - range2 * 1.1 / 6;
+      levels[5] = c + range2 * 1.1 / 4;
+      levels[6] = c - range2 * 1.1 / 4;
+      levels[7] = c + range2 * 1.1 / 2;
+      levels[8] = c - range2 * 1.1 / 2;
+      levels[9] = h;
+      levels[10] = l;
+      break;
+    }
+  }
+  return levels;
+}
+function ichimoku(conversionPeriods, basePeriods, laggingSpan2Periods, displacement, high, low, close) {
+  const length = high.length;
+  const highestConversion = highest(high, conversionPeriods);
+  const lowestConversion = lowest(low, conversionPeriods);
+  const tenkanSen = [];
+  for (let i = 0; i < length; i++) {
+    if (isNaN(highestConversion[i]) || isNaN(lowestConversion[i])) {
+      tenkanSen.push(NaN);
+    } else {
+      tenkanSen.push((highestConversion[i] + lowestConversion[i]) / 2);
+    }
+  }
+  const highestBase = highest(high, basePeriods);
+  const lowestBase = lowest(low, basePeriods);
+  const kijunSen = [];
+  for (let i = 0; i < length; i++) {
+    if (isNaN(highestBase[i]) || isNaN(lowestBase[i])) {
+      kijunSen.push(NaN);
+    } else {
+      kijunSen.push((highestBase[i] + lowestBase[i]) / 2);
+    }
+  }
+  const senkouSpanA = [];
+  for (let i = 0; i < length; i++) {
+    const sourceIndex = i - displacement;
+    if (sourceIndex < 0 || isNaN(tenkanSen[sourceIndex]) || isNaN(kijunSen[sourceIndex])) {
+      senkouSpanA.push(NaN);
+    } else {
+      senkouSpanA.push((tenkanSen[sourceIndex] + kijunSen[sourceIndex]) / 2);
+    }
+  }
+  const highestLagging = highest(high, laggingSpan2Periods);
+  const lowestLagging = lowest(low, laggingSpan2Periods);
+  const senkouSpanB = [];
+  for (let i = 0; i < length; i++) {
+    const sourceIndex = i - displacement;
+    if (sourceIndex < 0 || isNaN(highestLagging[sourceIndex]) || isNaN(lowestLagging[sourceIndex])) {
+      senkouSpanB.push(NaN);
+    } else {
+      senkouSpanB.push((highestLagging[sourceIndex] + lowestLagging[sourceIndex]) / 2);
+    }
+  }
+  const chikouSpan = [];
+  for (let i = 0; i < length; i++) {
+    const sourceIndex = i + displacement;
+    if (sourceIndex >= length || isNaN(close[sourceIndex])) {
+      chikouSpan.push(NaN);
+    } else {
+      chikouSpan.push(close[sourceIndex]);
+    }
+  }
+  return [tenkanSen, kijunSen, senkouSpanA, senkouSpanB, chikouSpan];
+}
+function zigzag(deviation = 5, depth = 10, backstep = 3, source, high, low) {
+  let highSource;
+  let lowSource;
+  if (high && low) {
+    highSource = high;
+    lowSource = low;
+  } else if (source) {
+    highSource = source;
+    lowSource = source;
+  } else {
+    throw new Error(
+      "ta.zigzag() requires either source series or high/low series. Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data."
+    );
+  }
+  const length = highSource.length;
+  if (lowSource.length !== length) {
+    throw new Error("ta.zigzag: high and low must have the same length");
+  }
+  const zigzagValues = new Array(length).fill(NaN);
+  const directions = new Array(length).fill(0);
+  const isPivot = new Array(length).fill(false);
+  const getDeviation = (price1, price2) => {
+    if (Math.abs(price1) < 1e-10 || isNaN(price1) || isNaN(price2)) return 0;
+    return Math.abs((price2 - price1) / price1) * 100;
+  };
+  let lastConfirmedPivot = null;
+  let potentialPivot = null;
+  let currentDirection = 0;
+  const confirmedPivots = [];
+  let startIndex;
+  let initialHighest = -Infinity;
+  let initialLowest = Infinity;
+  let initialHighIndex = -1;
+  let initialLowIndex = -1;
+  for (let i = 0; i < Math.min(depth, length); i++) {
+    if (!isNaN(highSource[i]) && highSource[i] > initialHighest) {
+      initialHighest = highSource[i];
+      initialHighIndex = i;
+    }
+    if (!isNaN(lowSource[i]) && lowSource[i] < initialLowest) {
+      initialLowest = lowSource[i];
+      initialLowIndex = i;
+    }
+  }
+  if (initialHighIndex >= 0 && initialLowIndex >= 0) {
+    if (initialLowIndex <= initialHighIndex) {
+      lastConfirmedPivot = { index: initialLowIndex, price: initialLowest, type: "low" };
+      currentDirection = 1;
+    } else {
+      lastConfirmedPivot = { index: initialHighIndex, price: initialHighest, type: "high" };
+      currentDirection = -1;
+    }
+    confirmedPivots.push(lastConfirmedPivot);
+    startIndex = lastConfirmedPivot.index + 1;
+  } else {
+    startIndex = depth;
+  }
+  for (let i = Math.max(startIndex, depth); i < length; i++) {
+    const currentHigh = highSource[i];
+    const currentLow = lowSource[i];
+    if (isNaN(currentHigh) || isNaN(currentLow)) {
+      directions[i] = currentDirection;
+      continue;
+    }
+    let isPotentialHigh = true;
+    for (let j = 1; j <= backstep && i - j >= 0; j++) {
+      if (!isNaN(highSource[i - j]) && highSource[i - j] >= currentHigh) {
+        isPotentialHigh = false;
+        break;
+      }
+    }
+    let isPotentialLow = true;
+    for (let j = 1; j <= backstep && i - j >= 0; j++) {
+      if (!isNaN(lowSource[i - j]) && lowSource[i - j] <= currentLow) {
+        isPotentialLow = false;
+        break;
+      }
+    }
+    if (currentDirection === 1) {
+      if (isPotentialHigh) {
+        if (potentialPivot === null || potentialPivot.type !== "high") {
+          if (lastConfirmedPivot && getDeviation(lastConfirmedPivot.price, currentHigh) >= deviation) {
+            potentialPivot = { index: i, price: currentHigh, type: "high" };
+          }
+        } else {
+          if (currentHigh > potentialPivot.price) {
+            potentialPivot = { index: i, price: currentHigh, type: "high" };
+          }
+        }
+      }
+      if (potentialPivot && potentialPivot.type === "high") {
+        const deviationFromPotential = getDeviation(potentialPivot.price, currentLow);
+        if (deviationFromPotential >= deviation && i - potentialPivot.index >= backstep) {
+          confirmedPivots.push(potentialPivot);
+          lastConfirmedPivot = potentialPivot;
+          currentDirection = -1;
+          potentialPivot = null;
+        }
+      }
+    } else if (currentDirection === -1) {
+      if (isPotentialLow) {
+        if (potentialPivot === null || potentialPivot.type !== "low") {
+          if (lastConfirmedPivot && getDeviation(lastConfirmedPivot.price, currentLow) >= deviation) {
+            potentialPivot = { index: i, price: currentLow, type: "low" };
+          }
+        } else {
+          if (currentLow < potentialPivot.price) {
+            potentialPivot = { index: i, price: currentLow, type: "low" };
+          }
+        }
+      }
+      if (potentialPivot && potentialPivot.type === "low") {
+        const deviationFromPotential = getDeviation(potentialPivot.price, currentHigh);
+        if (deviationFromPotential >= deviation && i - potentialPivot.index >= backstep) {
+          confirmedPivots.push(potentialPivot);
+          lastConfirmedPivot = potentialPivot;
+          currentDirection = 1;
+          potentialPivot = null;
+        }
+      }
+    } else {
+      if (lastConfirmedPivot) {
+        if (lastConfirmedPivot.type === "low" && getDeviation(lastConfirmedPivot.price, currentHigh) >= deviation) {
+          currentDirection = 1;
+        } else if (lastConfirmedPivot.type === "high" && getDeviation(lastConfirmedPivot.price, currentLow) >= deviation) {
+          currentDirection = -1;
+        }
+      }
+    }
+    directions[i] = currentDirection;
+  }
+  const lastPotentialWasAdded = potentialPivot !== null;
+  if (potentialPivot) {
+    confirmedPivots.push(potentialPivot);
+  }
+  for (const pivot2 of confirmedPivots) {
+    zigzagValues[pivot2.index] = pivot2.price;
+    isPivot[pivot2.index] = true;
+  }
+  let currentDir = 0;
+  let pivotIdx = 0;
+  const numConfirmed = lastPotentialWasAdded ? confirmedPivots.length - 1 : confirmedPivots.length;
+  for (let i = 0; i < length; i++) {
+    while (pivotIdx < numConfirmed && confirmedPivots[pivotIdx].index <= i) {
+      const pivot2 = confirmedPivots[pivotIdx];
+      currentDir = pivot2.type === "low" ? 1 : -1;
+      pivotIdx++;
+    }
+    directions[i] = currentDir;
+  }
+  return [zigzagValues, directions, isPivot];
+}
+function obv(close, volume) {
+  return cum(close.map((c, i) => i === 0 ? NaN : Math.sign(c - close[i - 1]) * volume[i]));
+}
+function pvt(close, volume) {
+  return cum(
+    close.map((c, i) => i === 0 ? NaN : (c - close[i - 1]) / close[i - 1] * volume[i])
+  );
+}
+function accdist(high, low, close, volume) {
+  return cum(
+    close.map((c, i) => {
+      const h = high[i];
+      const l = low[i];
+      return h === l ? 0 : (2 * c - l - h) / (h - l) * volume[i];
+    })
+  );
+}
+function iii(high, low, close, volume) {
+  return close.map((c, i) => {
+    const range2 = high[i] - low[i];
+    return range2 === 0 ? NaN : (2 * c - high[i] - low[i]) / range2 * volume[i];
+  });
+}
+function wvad(open, high, low, close, volume) {
+  return close.map((c, i) => {
+    const range2 = high[i] - low[i];
+    return range2 === 0 ? NaN : (c - open[i]) / range2 * volume[i];
+  });
+}
+function wad(high, low, close) {
+  return cum(
+    close.map((c, i) => {
+      const prev = i === 0 ? NaN : close[i - 1];
+      const mom2 = c - prev;
+      if (mom2 > 0) return c - Math.min(low[i], prev);
+      if (mom2 < 0) return c - Math.max(high[i], prev);
+      return 0;
+    })
+  );
+}
+function volumeIndex(close, volume, use) {
+  const result = [];
+  let prevIndex = NaN;
+  for (let i = 0; i < close.length; i++) {
+    const prev = !prevIndex ? 1 : prevIndex;
+    const c = close[i];
+    const prevC = i === 0 ? NaN : close[i - 1];
+    let value = prev;
+    if (c && prevC) {
+      const prevV = i === 0 || Number.isNaN(volume[i - 1]) ? 0 : volume[i - 1];
+      if (use(volume[i], prevV)) value = prev + (c - prevC) / prevC * prev;
+    }
+    result.push(value);
+    prevIndex = value;
+  }
+  return result;
+}
+function nvi(close, volume) {
+  return volumeIndex(close, volume, (v, prevV) => v < prevV);
+}
+function pvi(close, volume) {
+  return volumeIndex(close, volume, (v, prevV) => v > prevV);
+}
+//# sourceMappingURL=index.js.map