oakscriptjs 0.3.0 → 0.5.0

package/dist/script/index.cjs

@@ -0,0 +1,3630 @@
+"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);
+
+// src/script/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BarData: () => BarData,
+  Series: () => Series,
+  alertcondition: () => alertcondition,
+  barcolor: () => barcolor,
+  bgcolor: () => bgcolor,
+  close: () => close,
+  color: () => color,
+  eachBar: () => eachBar,
+  executeScript: () => executeScript,
+  fill: () => fill,
+  high: () => high,
+  hl2: () => hl2,
+  hlc3: () => hlc3,
+  hlcc4: () => hlcc4,
+  hline: () => hline,
+  indicator: () => indicator,
+  input: () => input,
+  low: () => low,
+  math: () => math_exports,
+  na: () => isNA,
+  nz: () => nz,
+  ohlc4: () => ohlc4,
+  open: () => open,
+  plot: () => plot,
+  plotchar: () => plotchar,
+  plotshape: () => plotshape,
+  seriesOf: () => seriesOf,
+  ta: () => ta2,
+  volume: () => volume
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runtime/series.ts
+var BarData = class _BarData {
+  _bars;
+  _version = 0;
+  /**
+   * Create a new BarData wrapper
+   * @param bars - Initial bar data (defaults to empty array)
+   */
+  constructor(bars2 = []) {
+    this._bars = bars2;
+  }
+  /**
+   * Get the current version number
+   * Version increments whenever data is mutated
+   */
+  get version() {
+    return this._version;
+  }
+  /**
+   * Get the underlying bar array
+   * Note: Direct mutations to this array will NOT increment version
+   * Use the provided mutation methods instead
+   */
+  get bars() {
+    return this._bars;
+  }
+  /**
+   * Get the number of bars
+   */
+  get length() {
+    return this._bars.length;
+  }
+  /**
+   * Add a new bar to the end
+   * @param bar - Bar to add
+   */
+  push(bar) {
+    this._bars.push(bar);
+    this._version++;
+  }
+  /**
+   * Remove and return the last bar
+   * @returns The removed bar, or undefined if empty
+   */
+  pop() {
+    const bar = this._bars.pop();
+    if (bar !== void 0) {
+      this._version++;
+    }
+    return bar;
+  }
+  /**
+   * Replace a bar at a specific index
+   * @param index - Index to update
+   * @param bar - New bar data
+   */
+  set(index, bar) {
+    if (index >= 0 && index < this._bars.length) {
+      this._bars[index] = bar;
+      this._version++;
+    }
+  }
+  /**
+   * Update the last bar (useful for real-time/streaming updates)
+   * @param bar - New bar data
+   */
+  updateLast(bar) {
+    if (this._bars.length > 0) {
+      this._bars[this._bars.length - 1] = bar;
+      this._version++;
+    }
+  }
+  /**
+   * Replace all bars with new data
+   * @param bars - New bar array
+   */
+  setAll(bars2) {
+    this._bars = bars2;
+    this._version++;
+  }
+  /**
+   * Manually increment version (for advanced use cases)
+   * Call this after direct mutations to the bars array
+   */
+  invalidate() {
+    this._version++;
+  }
+  /**
+   * Get a bar at a specific index
+   * @param index - Bar index
+   * @returns Bar at that index, or undefined
+   */
+  at(index) {
+    return this._bars[index];
+  }
+  /**
+   * Create a BarData from an existing Bar array
+   * @param bars - Bar array
+   * @returns New BarData instance
+   */
+  static from(bars2) {
+    return new _BarData(bars2);
+  }
+};
+var Series = class _Series {
+  extractor;
+  dataSource;
+  cached = null;
+  cachedVersion = -1;
+  /**
+   * Create a new Series
+   *
+   * @param data - Bar data (Bar[] or BarData)
+   * @param extractor - Function to extract/compute value for each bar
+   */
+  constructor(data, extractor) {
+    this.dataSource = data instanceof BarData ? data : new BarData(data);
+    this.extractor = extractor;
+  }
+  /**
+   * Get the underlying bar data
+   * @returns Bar array
+   */
+  get bars() {
+    return this.dataSource.bars;
+  }
+  /**
+   * Get the underlying BarData source
+   * @returns BarData instance
+   */
+  get barData() {
+    return this.dataSource;
+  }
+  // ============================================
+  // Static Factory Methods
+  // ============================================
+  /**
+   * Create Series from bar data by extracting a specific field
+   * @param bars - Bar data (Bar[] or BarData)
+   * @param field - Field to extract ('open', 'high', 'low', 'close', 'volume')
+   * @returns Series with extracted field values
+   */
+  static fromBars(bars2, field) {
+    return new _Series(bars2, (bar) => bar[field] ?? NaN);
+  }
+  /**
+   * Create a constant series (same value for all bars)
+   * @param bars - Bar data (Bar[] or BarData)
+   * @param value - Constant value
+   * @returns Series with constant value
+   */
+  static constant(bars2, value) {
+    return new _Series(bars2, () => value);
+  }
+  /**
+   * Create series from array of values
+   * @param bars - Bar data (Bar[] or BarData) for time alignment
+   * @param values - Array of values
+   * @returns Series
+   */
+  static fromArray(bars2, values) {
+    return new _Series(bars2, (_bar, i) => values[i] ?? NaN);
+  }
+  // ============================================
+  // Arithmetic Operations
+  // ============================================
+  /**
+   * Add two series or a series and a number
+   * @param other - Series or number to add
+   * @returns New Series representing the sum
+   */
+  add(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a + b2;
+    });
+  }
+  /**
+   * Subtract two series or subtract a number from a series
+   * @param other - Series or number to subtract
+   * @returns New Series representing the difference
+   */
+  sub(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a - b2;
+    });
+  }
+  /**
+   * Multiply two series or a series by a number
+   * @param other - Series or number to multiply
+   * @returns New Series representing the product
+   */
+  mul(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a * b2;
+    });
+  }
+  /**
+   * Raise the series to a power (PineScript math.pow on a series)
+   * @param exponent - Series or number exponent
+   * @returns New Series representing base ** exponent
+   */
+  pow(exponent) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof exponent === "number" ? exponent : exponent.extractor(bar, i, data);
+      return Math.pow(a, b2);
+    });
+  }
+  /**
+   * Divide two series or a series by a number
+   * @param other - Series or number to divide by
+   * @returns New Series representing the quotient
+   */
+  div(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return b2 !== 0 ? a / b2 : NaN;
+    });
+  }
+  /**
+   * Modulo operation
+   * @param other - Series or number for modulo
+   * @returns New Series representing the remainder
+   */
+  mod(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return b2 !== 0 ? a % b2 : NaN;
+    });
+  }
+  /**
+   * Negation
+   * @returns New Series with negated values
+   */
+  neg() {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      return -this.extractor(bar, i, data);
+    });
+  }
+  // ============================================
+  // Comparison Operations
+  // ============================================
+  /**
+   * Greater than comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  gt(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a > b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Greater than or equal comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  gte(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a >= b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Less than comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  lt(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a < b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Less than or equal comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  lte(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a <= b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Equality comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  eq(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a === b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Not equal comparison
+   * @param other - Series or number to compare
+   * @returns New Series with 1 where true, 0 where false
+   */
+  neq(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a !== b2 ? 1 : 0;
+    });
+  }
+  // ============================================
+  // Logical Operations (for boolean series)
+  // ============================================
+  /**
+   * Logical AND
+   * @param other - Series or number (truthy/falsy)
+   * @returns New Series with 1 where both true, 0 otherwise
+   */
+  and(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a && b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Logical OR
+   * @param other - Series or number (truthy/falsy)
+   * @returns New Series with 1 where either true, 0 otherwise
+   */
+  or(other) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      const b2 = typeof other === "number" ? other : other.extractor(bar, i, data);
+      return a || b2 ? 1 : 0;
+    });
+  }
+  /**
+   * Logical NOT
+   * @returns New Series with inverted boolean values
+   */
+  not() {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const a = this.extractor(bar, i, data);
+      return !a ? 1 : 0;
+    });
+  }
+  // ============================================
+  // Conditional Selection
+  // ============================================
+  /**
+   * Bar-by-bar conditional selection (ternary operator for Series)
+   * Uses this Series as the condition (truthy = nonzero, falsy = zero/NaN)
+   *
+   * @param trueValue - Value or Series to use when condition is truthy
+   * @param falseValue - Value or Series to use when condition is falsy
+   * @returns New Series with bar-by-bar selected values
+   *
+   * @example
+   * ```typescript
+   * // PineScript: result = condition ? trueVal : falseVal
+   * const result = condition.iff(trueVal, falseVal);
+   *
+   * // Example: RSI formula uses ternary for edge cases
+   * // rsi = down == 0 ? 100 : up == 0 ? 0 : formula
+   * const rsi = down.eq(0).iff(100, up.eq(0).iff(0, formula));
+   * ```
+   */
+  iff(trueValue, falseValue) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const condition = this.extractor(bar, i, data);
+      const isTruthy = condition !== 0 && !Number.isNaN(condition);
+      if (isTruthy) {
+        return typeof trueValue === "number" ? trueValue : trueValue.extractor(bar, i, data);
+      } else {
+        return typeof falseValue === "number" ? falseValue : falseValue.extractor(bar, i, data);
+      }
+    });
+  }
+  // ============================================
+  // Offset/History
+  // ============================================
+  /**
+   * Access previous bars (like close[1] in PineScript)
+   * @param offset - Number of bars back (positive = past)
+   * @returns New Series with offset values
+   */
+  offset(offset) {
+    return new _Series(this.dataSource, (_bar, i, data) => {
+      const targetIndex = i - offset;
+      if (targetIndex < 0 || targetIndex >= data.length) {
+        return NaN;
+      }
+      return this.extractor(data[targetIndex], targetIndex, data);
+    });
+  }
+  // ============================================
+  // Computation & Access
+  // ============================================
+  /**
+   * Compute all values for the series
+   * 
+   * Now includes automatic cache invalidation:
+   * - Checks if dataSource version has changed since cache was computed
+   * - Recomputes if version mismatch detected
+   * - Stores version when cache is created
+   * 
+   * @returns Array of computed values
+   */
+  toArray() {
+    if (this.cached !== null && this.cachedVersion === this.dataSource.version) {
+      return this.cached;
+    }
+    const bars2 = this.dataSource.bars;
+    this.cached = bars2.map((bar, i) => this.extractor(bar, i, bars2));
+    this.cachedVersion = this.dataSource.version;
+    return this.cached;
+  }
+  /**
+   * Materialize this Series by eagerly computing values and breaking closure chain
+   * 
+   * This method addresses the closure chain memory leak issue:
+   * - Computes all values immediately
+   * - Creates a new Series that stores values directly
+   * - Breaks references to parent Series objects
+   * - Useful for complex expressions to free intermediate Series memory
+   * 
+   * @example
+   * ```typescript
+   * // Without materialize: keeps a, b, c, d in memory via closures
+   * const result = a.add(b).mul(c).div(d).sub(e);
+   * 
+   * // With materialize: breaks chain, frees a, b, c memory
+   * const result = a.add(b).mul(c).materialize().div(d).sub(e);
+   * ```
+   * 
+   * @returns New Series with computed values and no closure dependencies
+   */
+  materialize() {
+    const values = this.toArray();
+    const valuesCopy = [...values];
+    return _Series.fromArray(this.dataSource, valuesCopy);
+  }
+  /**
+   * Invalidate cache (when data changes)
+   * 
+   * Note: With BarData versioning, manual invalidation is rarely needed.
+   * The cache is automatically invalidated when the underlying BarData changes.
+   * This method is kept for backward compatibility and advanced use cases.
+   * 
+   * @internal
+   */
+  _invalidate() {
+    this.cached = null;
+    this.cachedVersion = -1;
+  }
+  /**
+   * Compute all values (alias for toArray)
+   * @returns Array of computed values
+   * @internal
+   */
+  _compute() {
+    return this.toArray();
+  }
+  /**
+   * Get value at specific index
+   * @param index - Bar index
+   * @returns Value at that index
+   */
+  get(index) {
+    const values = this.toArray();
+    return values[index] ?? NaN;
+  }
+  /**
+   * Get the last value (most recent bar)
+   * @returns Most recent value
+   */
+  last() {
+    const values = this.toArray();
+    return values[values.length - 1] ?? NaN;
+  }
+  /**
+   * Get number of values
+   * @returns Length of series
+   */
+  length() {
+    return this.dataSource.length;
+  }
+  /**
+   * Convert series to time-value pairs for charting
+   * @returns Array of { time, value } objects
+   */
+  toTimeValuePairs() {
+    const values = this.toArray();
+    const bars2 = this.dataSource.bars;
+    return bars2.map((bar, i) => ({
+      time: bar.time,
+      value: values[i]
+    })).filter((point) => !Number.isNaN(point.value));
+  }
+};
+
+// src/ta-series.ts
+var ta_series_exports = {};
+__export(ta_series_exports, {
+  alma: () => alma2,
+  atr: () => atr2,
+  barssince: () => barssince2,
+  bb: () => bb2,
+  bbw: () => bbw2,
+  cci: () => cci2,
+  change: () => change2,
+  cmo: () => cmo2,
+  cog: () => cog2,
+  correlation: () => correlation2,
+  cross: () => cross2,
+  crossover: () => crossover2,
+  crossunder: () => crossunder2,
+  cum: () => cum2,
+  dev: () => dev2,
+  dmi: () => dmi2,
+  ema: () => ema2,
+  falling: () => falling2,
+  highest: () => highest2,
+  highestbars: () => highestbars2,
+  hma: () => hma2,
+  ichimoku: () => ichimoku2,
+  kc: () => kc2,
+  kcw: () => kcw2,
+  linreg: () => linreg2,
+  lowest: () => lowest2,
+  lowestbars: () => lowestbars2,
+  macd: () => macd2,
+  max: () => max2,
+  median: () => median2,
+  mfi: () => mfi2,
+  min: () => min2,
+  mode: () => mode2,
+  mom: () => mom2,
+  percentile_linear_interpolation: () => percentile_linear_interpolation2,
+  percentile_nearest_rank: () => percentile_nearest_rank2,
+  percentrank: () => percentrank2,
+  pivothigh: () => pivothigh2,
+  pivotlow: () => pivotlow2,
+  range: () => range2,
+  rci: () => rci2,
+  rising: () => rising2,
+  rma: () => rma2,
+  roc: () => roc2,
+  rsi: () => rsi2,
+  sar: () => sar2,
+  sma: () => sma2,
+  stdev: () => stdev2,
+  stoch: () => stoch2,
+  supertrend: () => supertrend2,
+  swma: () => swma2,
+  ta: () => ta,
+  tr: () => tr2,
+  tsi: () => tsi2,
+  valuewhen: () => valuewhen2,
+  variance: () => variance2,
+  vwap: () => vwap2,
+  vwma: () => vwma2,
+  wma: () => wma2,
+  wpr: () => wpr2,
+  zigzag: () => zigzag2
+});
+
+// src/ta/index.ts
+function sma(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < len - 1) {
+      result.push(NaN);
+    } else {
+      let sum2 = 0;
+      for (let j = 0; j < len; j++) {
+        sum2 += source[i - j];
+      }
+      result.push(sum2 / len);
+    }
+  }
+  return result;
+}
+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 && !isNaN(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 && !isNaN(val)) {
+        emaValue = (val - emaValue) * multiplier + emaValue;
+      }
+      result.push(emaValue);
+    }
+  }
+  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) => c > 0 ? c : 0);
+  const losses = changes.map((c) => 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 dev3 = stdev(series, length);
+  const upper = [];
+  const lower = [];
+  for (let i = 0; i < series.length; i++) {
+    upper.push(basis[i] + mult * dev3[i]);
+    lower.push(basis[i] - mult * dev3[i]);
+  }
+  return [basis, upper, lower];
+}
+function stdev(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  const avg2 = sma(source, len);
+  for (let i = 0; i < source.length; i++) {
+    if (i < len - 1) {
+      result.push(NaN);
+    } else {
+      let sumSquares = 0;
+      for (let j = 0; j < len; j++) {
+        const diff = source[i - j] - avg2[i];
+        sumSquares += diff * diff;
+      }
+      result.push(Math.sqrt(sumSquares / len));
+    }
+  }
+  return result;
+}
+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, high2, low2, close2) {
+  if (!high2 || !low2 || !close2) {
+    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 < high2.length; i++) {
+    if (i === 0) {
+      result.push(high2[i] - low2[i]);
+    } else {
+      const prevClose = close2[i - 1];
+      if (isNaN(prevClose)) {
+        if (handle_na) {
+          result.push(high2[i] - low2[i]);
+        } else {
+          result.push(NaN);
+        }
+      } else {
+        const tr3 = Math.max(
+          high2[i] - low2[i],
+          Math.abs(high2[i] - prevClose),
+          Math.abs(low2[i] - prevClose)
+        );
+        result.push(tr3);
+      }
+    }
+  }
+  return result;
+}
+function atr(length, high2, low2, close2) {
+  if (!high2 || !low2 || !close2) {
+    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(false, high2, low2, close2);
+  return rma(trueRange, length);
+}
+function supertrend(factor, atrPeriod, high2, low2, close2, wicks = false) {
+  if (!high2 || !low2 || !close2) {
+    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 < high2.length; i++) {
+    source.push((high2[i] + low2[i]) / 2);
+  }
+  const atrValues = atr(atrPeriod, high2, low2, close2);
+  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 ? high2[i] : close2[i];
+    const lowPrice = wicks ? low2[i] : close2[i];
+    const prevLowPrice = i > 0 ? wicks ? low2[i - 1] : close2[i - 1] : 0;
+    const prevHighPrice = i > 0 ? wicks ? high2[i - 1] : close2[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);
+  const alpha = 1 / len;
+  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 && !isNaN(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 && !isNaN(val)) {
+        rmaValue = alpha * val + (1 - alpha) * rmaValue;
+      }
+      result.push(rmaValue);
+    }
+  }
+  return result;
+}
+function wma(source, length) {
+  const result = [];
+  const len = Math.floor(length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < len - 1) {
+      result.push(NaN);
+    } else {
+      let sum2 = 0;
+      let weightSum = 0;
+      for (let j = 0; j < len; j++) {
+        const weight = len - j;
+        sum2 += source[i - j] * weight;
+        weightSum += weight;
+      }
+      result.push(sum2 / weightSum);
+    }
+  }
+  return result;
+}
+function highest(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+    } else {
+      let max4 = -Infinity;
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          max4 = Math.max(max4, source[i - j]);
+        }
+      }
+      result.push(max4 === -Infinity ? NaN : max4);
+    }
+  }
+  return result;
+}
+function lowest(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+    } else {
+      let min4 = Infinity;
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          min4 = Math.min(min4, source[i - j]);
+        }
+      }
+      result.push(min4 === Infinity ? NaN : min4);
+    }
+  }
+  return result;
+}
+function cum(source) {
+  const result = [];
+  let sum2 = 0;
+  for (let i = 0; i < source.length; i++) {
+    sum2 += source[i];
+    result.push(sum2);
+  }
+  return result;
+}
+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 rising(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(false);
+    } else {
+      let isRising = true;
+      for (let j = 1; j <= length; j++) {
+        if (source[i - j + 1] <= source[i - j]) {
+          isRising = false;
+          break;
+        }
+      }
+      result.push(isRising);
+    }
+  }
+  return result;
+}
+function falling(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(false);
+    } else {
+      let isFalling = true;
+      for (let j = 1; j <= length; j++) {
+        if (source[i - j + 1] >= source[i - j]) {
+          isFalling = false;
+          break;
+        }
+      }
+      result.push(isFalling);
+    }
+  }
+  return result;
+}
+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 = sma(source, length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1 || isNaN(meanValues[i])) {
+      result.push(NaN);
+    } else {
+      let sum2 = 0;
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          sum2 += Math.abs(source[i - j] - meanValues[i]);
+        }
+      }
+      result.push(sum2 / length);
+    }
+  }
+  return result;
+}
+function variance(source, length, biased = true) {
+  const result = [];
+  const meanValues = sma(source, length);
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1 || isNaN(meanValues[i])) {
+      result.push(NaN);
+    } else {
+      let sumSquares = 0;
+      let count = 0;
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          const diff = source[i - j] - meanValues[i];
+          sumSquares += diff * diff;
+          count++;
+        }
+      }
+      const divisor = biased ? count : count - 1;
+      result.push(divisor > 0 ? sumSquares / divisor : NaN);
+    }
+  }
+  return result;
+}
+function median(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+    } else {
+      const values = [];
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source[i - j])) {
+          values.push(source[i - j]);
+        }
+      }
+      if (values.length === 0) {
+        result.push(NaN);
+      } else {
+        values.sort((a, b2) => a - b2);
+        const mid = Math.floor(values.length / 2);
+        if (values.length % 2 === 0) {
+          result.push((values[mid - 1] + values[mid]) / 2);
+        } else {
+          result.push(values[mid]);
+        }
+      }
+    }
+  }
+  return result;
+}
+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, volume2) {
+  if (!volume2) {
+    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] * volume2[i]);
+  }
+  const numerator = sma(sourceTimesVolume, length);
+  const denominator = sma(volume2, 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 = [];
+  for (let i = 0; i < source1.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+    } else {
+      const pairs = [];
+      for (let j = 0; j < length; j++) {
+        if (!isNaN(source1[i - j]) && !isNaN(source2[i - j])) {
+          pairs.push([source1[i - j], source2[i - j]]);
+        }
+      }
+      if (pairs.length === 0) {
+        result.push(NaN);
+      } else {
+        let sum1 = 0;
+        let sum2 = 0;
+        for (const [v1, v2] of pairs) {
+          sum1 += v1;
+          sum2 += v2;
+        }
+        const mean1 = sum1 / pairs.length;
+        const mean2 = sum2 / pairs.length;
+        let numerator = 0;
+        let sum1Sq = 0;
+        let sum2Sq = 0;
+        for (const [v1, v2] of pairs) {
+          const dev1 = v1 - mean1;
+          const dev22 = v2 - mean2;
+          numerator += dev1 * dev22;
+          sum1Sq += dev1 * dev1;
+          sum2Sq += dev22 * dev22;
+        }
+        const denominator = Math.sqrt(sum1Sq * sum2Sq);
+        if (denominator === 0) {
+          result.push(NaN);
+        } else {
+          result.push(numerator / denominator);
+        }
+      }
+    }
+  }
+  return result;
+}
+function percentrank(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+    } else {
+      if (isNaN(source[i])) {
+        result.push(NaN);
+        continue;
+      }
+      let hasNaN = false;
+      for (let j = 1; j <= length; j++) {
+        if (isNaN(source[i - j])) {
+          hasNaN = true;
+          break;
+        }
+      }
+      if (hasNaN) {
+        result.push(NaN);
+      } else {
+        const currentValue = source[i];
+        let countLessOrEqual = 0;
+        for (let j = 1; j <= length; j++) {
+          if (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 cci3 = (source[i] - smaValues[i]) / (0.015 * devValues[i]);
+      result.push(cci3);
+    }
+  }
+  return result;
+}
+function stoch(source, high2, low2, length) {
+  const result = [];
+  const lowestValues = lowest(low2, length);
+  const highestValues = highest(high2, length);
+  for (let i = 0; i < source.length; i++) {
+    if (isNaN(lowestValues[i]) || isNaN(highestValues[i])) {
+      result.push(NaN);
+    } else {
+      const range3 = highestValues[i] - lowestValues[i];
+      if (range3 === 0) {
+        result.push(NaN);
+      } else {
+        const stochValue = 100 * (source[i] - lowestValues[i]) / range3;
+        result.push(stochValue);
+      }
+    }
+  }
+  return result;
+}
+function mfi(source, length, volume2) {
+  if (!volume2) {
+    throw new Error(
+      "ta.mfi() requires volume series. Either pass it explicitly or use createContext({ chart: { ..., volume } }) for implicit data."
+    );
+  }
+  const result = [];
+  const changes = [NaN];
+  for (let i = 1; i < source.length; i++) {
+    changes.push(source[i] - source[i - 1]);
+  }
+  const positiveFlow = [];
+  const negativeFlow = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i === 0 || isNaN(changes[i])) {
+      positiveFlow.push(0);
+      negativeFlow.push(0);
+    } else if (changes[i] > 0) {
+      positiveFlow.push(volume2[i] * source[i]);
+      negativeFlow.push(0);
+    } else if (changes[i] < 0) {
+      positiveFlow.push(0);
+      negativeFlow.push(volume2[i] * source[i]);
+    } else {
+      positiveFlow.push(0);
+      negativeFlow.push(0);
+    }
+  }
+  for (let i = 0; i < source.length; i++) {
+    if (i < length) {
+      result.push(NaN);
+    } else {
+      let posSum = 0;
+      let negSum = 0;
+      for (let j = 0; j < length; j++) {
+        posSum += positiveFlow[i - j];
+        negSum += negativeFlow[i - j];
+      }
+      if (negSum === 0) {
+        result.push(100);
+      } else {
+        const moneyRatio = posSum / negSum;
+        const mfiValue = 100 - 100 / (1 + moneyRatio);
+        result.push(mfiValue);
+      }
+    }
+  }
+  return result;
+}
+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, max4, high2, low2, close2) {
+  if (!high2 || !low2 || !close2) {
+    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 < close2.length; i++) {
+    if (i === 0) {
+      result.push(NaN);
+      continue;
+    }
+    if (i === 1) {
+      if (close2[i] > close2[i - 1]) {
+        isUpTrend = true;
+        extremePoint = high2[i];
+        sarValue = low2[i - 1];
+      } else {
+        isUpTrend = false;
+        extremePoint = low2[i];
+        sarValue = high2[i - 1];
+      }
+      isFirstTrendBar = true;
+      acceleration = start;
+    }
+    sarValue = sarValue + acceleration * (extremePoint - sarValue);
+    if (isUpTrend) {
+      if (sarValue > low2[i]) {
+        isFirstTrendBar = true;
+        isUpTrend = false;
+        sarValue = Math.max(high2[i], extremePoint);
+        extremePoint = low2[i];
+        acceleration = start;
+      }
+    } else {
+      if (sarValue < high2[i]) {
+        isFirstTrendBar = true;
+        isUpTrend = true;
+        sarValue = Math.min(low2[i], extremePoint);
+        extremePoint = high2[i];
+        acceleration = start;
+      }
+    }
+    if (!isFirstTrendBar) {
+      if (isUpTrend) {
+        if (high2[i] > extremePoint) {
+          extremePoint = high2[i];
+          acceleration = Math.min(acceleration + inc, max4);
+        }
+      } else {
+        if (low2[i] < extremePoint) {
+          extremePoint = low2[i];
+          acceleration = Math.min(acceleration + inc, max4);
+        }
+      }
+    }
+    if (isUpTrend) {
+      sarValue = Math.min(sarValue, low2[i - 1]);
+      if (i > 1) {
+        sarValue = Math.min(sarValue, low2[i - 2]);
+      }
+    } else {
+      sarValue = Math.max(sarValue, high2[i - 1]);
+      if (i > 1) {
+        sarValue = Math.max(sarValue, high2[i - 2]);
+      }
+    }
+    result.push(sarValue);
+    isFirstTrendBar = false;
+  }
+  return result;
+}
+function pivothigh(sourceOrLeftbars, leftbarsOrRightbars, rightbars, high2) {
+  let source;
+  let leftbars;
+  let right;
+  if (rightbars === void 0) {
+    if (!high2) {
+      throw new Error("ta.pivothigh() requires high series when using two-parameter version.");
+    }
+    source = high2;
+    leftbars = sourceOrLeftbars;
+    right = leftbarsOrRightbars;
+  } else {
+    source = sourceOrLeftbars;
+    leftbars = leftbarsOrRightbars;
+    right = rightbars;
+  }
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < leftbars || i + right >= source.length) {
+      result.push(NaN);
+      continue;
+    }
+    const centerValue = source[i];
+    let isPivot = true;
+    for (let j = 1; j <= leftbars; j++) {
+      if (source[i - j] >= centerValue) {
+        isPivot = false;
+        break;
+      }
+    }
+    if (isPivot) {
+      for (let j = 1; j <= right; j++) {
+        if (source[i + j] >= centerValue) {
+          isPivot = false;
+          break;
+        }
+      }
+    }
+    result.push(isPivot ? centerValue : NaN);
+  }
+  return result;
+}
+function pivotlow(sourceOrLeftbars, leftbarsOrRightbars, rightbars, low2) {
+  let source;
+  let leftbars;
+  let right;
+  if (rightbars === void 0) {
+    if (!low2) {
+      throw new Error("ta.pivotlow() requires low series when using two-parameter version.");
+    }
+    source = low2;
+    leftbars = sourceOrLeftbars;
+    right = leftbarsOrRightbars;
+  } else {
+    source = sourceOrLeftbars;
+    leftbars = leftbarsOrRightbars;
+    right = rightbars;
+  }
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < leftbars || i + right >= source.length) {
+      result.push(NaN);
+      continue;
+    }
+    const centerValue = source[i];
+    let isPivot = true;
+    for (let j = 1; j <= leftbars; j++) {
+      if (source[i - j] <= centerValue) {
+        isPivot = false;
+        break;
+      }
+    }
+    if (isPivot) {
+      for (let j = 1; j <= right; j++) {
+        if (source[i + j] <= centerValue) {
+          isPivot = false;
+          break;
+        }
+      }
+    }
+    result.push(isPivot ? centerValue : NaN);
+  }
+  return result;
+}
+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, high2, low2, close2) {
+  const len = Math.max(high2.length, low2.length, close2.length);
+  const plusDM = [];
+  const minusDM = [];
+  const trueRangeValues = tr(false, high2, low2, close2);
+  for (let i = 0; i < len; i++) {
+    if (i === 0) {
+      plusDM.push(0);
+      minusDM.push(0);
+    } else {
+      const upMove = high2[i] - high2[i - 1];
+      const downMove = low2[i - 1] - low2[i];
+      let plusDMVal = 0;
+      let minusDMVal = 0;
+      if (upMove > downMove && upMove > 0) {
+        plusDMVal = upMove;
+      }
+      if (downMove > upMove && downMove > 0) {
+        minusDMVal = downMove;
+      }
+      plusDM.push(plusDMVal);
+      minusDM.push(minusDMVal);
+    }
+  }
+  const smoothedPlusDM = rma(plusDM, diLength);
+  const smoothedMinusDM = rma(minusDM, diLength);
+  const smoothedTR = rma(trueRangeValues, diLength);
+  const plusDI = [];
+  const minusDI = [];
+  for (let i = 0; i < len; i++) {
+    if (smoothedTR[i] === 0) {
+      plusDI.push(0);
+      minusDI.push(0);
+    } else {
+      plusDI.push(smoothedPlusDM[i] / smoothedTR[i] * 100);
+      minusDI.push(smoothedMinusDM[i] / smoothedTR[i] * 100);
+    }
+  }
+  const dx = [];
+  for (let i = 0; i < len; i++) {
+    const sum2 = plusDI[i] + minusDI[i];
+    if (sum2 === 0) {
+      dx.push(0);
+    } else {
+      dx.push(Math.abs(plusDI[i] - minusDI[i]) / sum2 * 100);
+    }
+  }
+  const adx = rma(dx, adxSmoothing);
+  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 change3 = source[i - j] - source[i - j - 1];
+      if (change3 > 0) {
+        sumGains += change3;
+      } else {
+        sumLosses += Math.abs(change3);
+      }
+    }
+    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, high2, low2, close2) {
+  const middle = ema(source, length);
+  let range3;
+  if (useTrueRange) {
+    if (!high2 || !low2 || !close2) {
+      throw new Error("ta.kc() with useTrueRange=true requires high, low, and close data");
+    }
+    range3 = tr(false, high2, low2, close2);
+  } else {
+    if (!high2 || !low2) {
+      throw new Error("ta.kc() requires high and low data");
+    }
+    range3 = [];
+    for (let i = 0; i < high2.length; i++) {
+      range3.push(high2[i] - low2[i]);
+    }
+  }
+  const rangeEma = ema(range3, 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(high2, low2, close2, length = 14) {
+  const result = [];
+  for (let i = 0; i < close2.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let highestHigh = high2[i - length + 1];
+    let lowestLow = low2[i - length + 1];
+    for (let j = i - length + 2; j <= i; j++) {
+      if (high2[j] > highestHigh) highestHigh = high2[j];
+      if (low2[j] < lowestLow) lowestLow = low2[j];
+    }
+    const range3 = highestHigh - lowestLow;
+    if (range3 === 0) {
+      result.push(NaN);
+    } else {
+      const wprValue = (highestHigh - close2[i]) / range3 * -100;
+      result.push(wprValue);
+    }
+  }
+  return result;
+}
+function vwap(source, volume2) {
+  if (source.length !== volume2.length) {
+    throw new Error("ta.vwap: source and volume must have the same length");
+  }
+  const result = [];
+  let cumulativePV = 0;
+  let cumulativeVolume = 0;
+  for (let i = 0; i < source.length; i++) {
+    if (isNaN(source[i]) || isNaN(volume2[i])) {
+      result.push(NaN);
+      continue;
+    }
+    cumulativePV += source[i] * volume2[i];
+    cumulativeVolume += volume2[i];
+    if (cumulativeVolume === 0) {
+      result.push(NaN);
+    } else {
+      result.push(cumulativePV / cumulativeVolume);
+    }
+  }
+  return result;
+}
+function alma(source, length = 9, offset = 0.85, sigma = 6, floor2 = false) {
+  const result = [];
+  const m = floor2 ? 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, high2, low2, close2) {
+  const [basis, upper, lower] = kc(source, length, mult, useTrueRange, high2, low2, close2);
+  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(high2, low2) {
+  if (high2.length !== low2.length) {
+    throw new Error("ta.range: high and low must have the same length");
+  }
+  const result = [];
+  for (let i = 0; i < high2.length; i++) {
+    if (isNaN(high2[i]) || isNaN(low2[i])) {
+      result.push(NaN);
+    } else {
+      result.push(high2[i] - low2[i]);
+    }
+  }
+  return result;
+}
+function highestbars(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let highestValue = source[i - length + 1];
+    let highestOffset = length - 1;
+    for (let j = i - length + 2; j <= i; j++) {
+      if (source[j] > highestValue) {
+        highestValue = source[j];
+        highestOffset = i - j;
+      }
+    }
+    result.push(highestOffset);
+  }
+  return result;
+}
+function lowestbars(source, length) {
+  const result = [];
+  for (let i = 0; i < source.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let lowestValue = source[i - length + 1];
+    let lowestOffset = length - 1;
+    for (let j = i - length + 2; j <= i; j++) {
+      if (source[j] < lowestValue) {
+        lowestValue = source[j];
+        lowestOffset = i - j;
+      }
+    }
+    result.push(lowestOffset);
+  }
+  return result;
+}
+function max(source1, source2) {
+  if (source1.length !== source2.length) {
+    throw new Error("ta.max: source1 and source2 must have the same length");
+  }
+  const result = [];
+  for (let i = 0; i < source1.length; i++) {
+    if (isNaN(source1[i]) || isNaN(source2[i])) {
+      result.push(NaN);
+    } else {
+      result.push(Math.max(source1[i], source2[i]));
+    }
+  }
+  return result;
+}
+function min(source1, source2) {
+  if (source1.length !== source2.length) {
+    throw new Error("ta.min: source1 and source2 must have the same length");
+  }
+  const result = [];
+  for (let i = 0; i < source1.length; i++) {
+    if (isNaN(source1[i]) || isNaN(source2[i])) {
+      result.push(NaN);
+    } else {
+      result.push(Math.min(source1[i], source2[i]));
+    }
+  }
+  return result;
+}
+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 cog3 = -1 * (numerator / denominator) + (length + 1) / 2;
+      result.push(cog3);
+    }
+  }
+  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) {
+  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];
+      values.push(value);
+    }
+    if (values.some((v) => isNaN(v))) {
+      result.push(NaN);
+      continue;
+    }
+    const sorted = [...values].sort((a, b2) => a - b2);
+    const position = percentage / 100 * (sorted.length - 1);
+    const lowerIndex = Math.floor(position);
+    const upperIndex = Math.ceil(position);
+    if (lowerIndex === upperIndex) {
+      result.push(sorted[lowerIndex]);
+    } else {
+      const fraction = position - lowerIndex;
+      const interpolated = sorted[lowerIndex] + fraction * (sorted[upperIndex] - sorted[lowerIndex]);
+      result.push(interpolated);
+    }
+  }
+  return result;
+}
+function percentile_nearest_rank(source, length, percentage) {
+  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 sorted = [...values].sort((a, b2) => a - b2);
+    if (percentage >= 100) {
+      result.push(sorted[sorted.length - 1]);
+      continue;
+    }
+    const rank = Math.ceil(percentage / 100 * sorted.length);
+    const index = Math.max(0, rank - 1);
+    result.push(sorted[index]);
+  }
+  return result;
+}
+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, b2) => a.value - b2.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 ichimoku(conversionPeriods, basePeriods, laggingSpan2Periods, displacement, high2, low2, close2) {
+  const length = high2.length;
+  const highestConversion = highest(high2, conversionPeriods);
+  const lowestConversion = lowest(low2, 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(high2, basePeriods);
+  const lowestBase = lowest(low2, 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(high2, laggingSpan2Periods);
+  const lowestLagging = lowest(low2, 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(close2[sourceIndex])) {
+      chikouSpan.push(NaN);
+    } else {
+      chikouSpan.push(close2[sourceIndex]);
+    }
+  }
+  return [tenkanSen, kijunSen, senkouSpanA, senkouSpanB, chikouSpan];
+}
+function zigzag(deviation = 5, depth = 10, backstep = 3, source, high2, low2) {
+  let highSource;
+  let lowSource;
+  if (high2 && low2) {
+    highSource = high2;
+    lowSource = low2;
+  } 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 pivot of confirmedPivots) {
+    zigzagValues[pivot.index] = pivot.price;
+    isPivot[pivot.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 pivot = confirmedPivots[pivotIdx];
+      currentDir = pivot.type === "low" ? 1 : -1;
+      pivotIdx++;
+    }
+    directions[i] = currentDir;
+  }
+  return [zigzagValues, directions, isPivot];
+}
+
+// src/ta-series.ts
+function sma2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = sma(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function ema2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = ema(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function wma2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = wma(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function rma2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = rma(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function rsi2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = rsi(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function macd2(source, fastLength, slowLength, signalLength) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const [macdVals, signalVals, histVals] = macd(sourceValues, fastLength, slowLength, signalLength);
+  const macdSeries = Series.fromArray(bars2, macdVals);
+  const signalSeries = Series.fromArray(bars2, signalVals);
+  const histSeries = Series.fromArray(bars2, histVals);
+  return [macdSeries, signalSeries, histSeries];
+}
+function bb2(source, length, mult) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const [upperVals, basisVals, lowerVals] = bb(sourceValues, length, mult);
+  const upperSeries = Series.fromArray(bars2, upperVals);
+  const basisSeries = Series.fromArray(bars2, basisVals);
+  const lowerSeries = Series.fromArray(bars2, lowerVals);
+  return [upperSeries, basisSeries, lowerSeries];
+}
+function stdev2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = stdev(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function atr2(bars2, length) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const result = atr(length, high2, low2, close2);
+  return Series.fromArray(bars2, result);
+}
+function tr2(bars2, handle_na = false) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const result = tr(handle_na, high2, low2, close2);
+  return Series.fromArray(bars2, result);
+}
+function stoch2(source, high2, low2, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const highValues = high2.toArray();
+  const lowValues = low2.toArray();
+  const result = stoch(sourceValues, highValues, lowValues, length);
+  return Series.fromArray(bars2, result);
+}
+function crossover2(source1, source2) {
+  const bars2 = source1.bars;
+  const vals1 = source1.toArray();
+  const vals2 = typeof source2 === "number" ? Array(bars2.length).fill(source2) : source2.toArray();
+  const result = crossover(vals1, vals2);
+  const numResult = result.map((b2) => b2 ? 1 : 0);
+  return Series.fromArray(bars2, numResult);
+}
+function crossunder2(source1, source2) {
+  const bars2 = source1.bars;
+  const vals1 = source1.toArray();
+  const vals2 = typeof source2 === "number" ? Array(bars2.length).fill(source2) : source2.toArray();
+  const result = crossunder(vals1, vals2);
+  const numResult = result.map((b2) => b2 ? 1 : 0);
+  return Series.fromArray(bars2, numResult);
+}
+function cross2(source1, source2) {
+  const bars2 = source1.bars;
+  const vals1 = source1.toArray();
+  const vals2 = typeof source2 === "number" ? Array(bars2.length).fill(source2) : source2.toArray();
+  const result = cross(vals1, vals2);
+  const numResult = result.map((b2) => b2 ? 1 : 0);
+  return Series.fromArray(bars2, numResult);
+}
+function change2(source, length = 1) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = change(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function mom2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = mom(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function roc2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = roc(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function highest2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = highest(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function lowest2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = lowest(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function rising2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = rising(sourceValues, length);
+  const numResult = result.map((b2) => b2 ? 1 : 0);
+  return Series.fromArray(bars2, numResult);
+}
+function falling2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = falling(sourceValues, length);
+  const numResult = result.map((b2) => b2 ? 1 : 0);
+  return Series.fromArray(bars2, numResult);
+}
+function cum2(source) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = cum(sourceValues);
+  return Series.fromArray(bars2, result);
+}
+function supertrend2(bars2, factor, atrLength) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const [trendVals, dirVals] = supertrend(factor, atrLength, high2, low2, close2);
+  const trendSeries = Series.fromArray(bars2, trendVals);
+  const dirSeries = Series.fromArray(bars2, dirVals);
+  return [trendSeries, dirSeries];
+}
+function vwap2(source, volume2) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const volumeValues = volume2.toArray();
+  const result = vwap(sourceValues, volumeValues);
+  return Series.fromArray(bars2, result);
+}
+function ichimoku2(bars2, conversionPeriods, basePeriods, laggingSpan2Periods, displacement) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const [tenkan, kijun, senkouA, senkouB, chikou] = ichimoku(
+    conversionPeriods,
+    basePeriods,
+    laggingSpan2Periods,
+    displacement,
+    high2,
+    low2,
+    close2
+  );
+  return [
+    Series.fromArray(bars2, tenkan),
+    Series.fromArray(bars2, kijun),
+    Series.fromArray(bars2, senkouA),
+    Series.fromArray(bars2, senkouB),
+    Series.fromArray(bars2, chikou)
+  ];
+}
+function vwma2(source, length, volume2) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const volumeValues = volume2.toArray();
+  const result = vwma(sourceValues, length, volumeValues);
+  return Series.fromArray(bars2, result);
+}
+function linreg2(source, length, offset = 0) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = linreg(sourceValues, length, offset);
+  return Series.fromArray(bars2, result);
+}
+function alma2(source, length = 9, offset = 0.85, sigma = 6, floor2 = false) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = alma(sourceValues, length, offset, sigma, floor2);
+  return Series.fromArray(bars2, result);
+}
+function zigzag2(bars2, deviation = 5, depth = 10, backstep = 3) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const [zigzagVals, dirVals, pivotVals] = zigzag(
+    deviation,
+    depth,
+    backstep,
+    void 0,
+    high2,
+    low2
+  );
+  return [
+    Series.fromArray(bars2, zigzagVals),
+    Series.fromArray(bars2, dirVals),
+    Series.fromArray(bars2, pivotVals.map((b2) => b2 ? 1 : 0))
+  ];
+}
+function cci2(source, length) {
+  const bars2 = source.bars;
+  const sourceValues = source.toArray();
+  const result = cci(sourceValues, length);
+  return Series.fromArray(bars2, result);
+}
+function sar2(bars2, start = 0.02, inc = 0.02, max4 = 0.2) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const result = sar(start, inc, max4, high2, low2, close2);
+  return Series.fromArray(bars2, result);
+}
+function dev2(source, length) {
+  const bars2 = source.bars;
+  const result = dev(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function variance2(source, length, biased = true) {
+  const bars2 = source.bars;
+  const result = variance(source.toArray(), length, biased);
+  return Series.fromArray(bars2, result);
+}
+function median2(source, length) {
+  const bars2 = source.bars;
+  const result = median(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function swma2(source) {
+  const bars2 = source.bars;
+  const result = swma(source.toArray());
+  return Series.fromArray(bars2, result);
+}
+function correlation2(source1, source2, length) {
+  const bars2 = source1.bars;
+  const result = correlation(source1.toArray(), source2.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function percentrank2(source, length) {
+  const bars2 = source.bars;
+  const result = percentrank(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function mfi2(source, length, volume2) {
+  const bars2 = source.bars;
+  const result = mfi(source.toArray(), length, volume2.toArray());
+  return Series.fromArray(bars2, result);
+}
+function hma2(source, length) {
+  const bars2 = source.bars;
+  const result = hma(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function pivothigh2(source, leftbars, rightbars) {
+  const bars2 = source.bars;
+  const result = pivothigh(source.toArray(), leftbars, rightbars);
+  return Series.fromArray(bars2, result);
+}
+function pivotlow2(source, leftbars, rightbars) {
+  const bars2 = source.bars;
+  const result = pivotlow(source.toArray(), leftbars, rightbars);
+  return Series.fromArray(bars2, result);
+}
+function barssince2(condition) {
+  const bars2 = condition.bars;
+  const boolValues = condition.toArray().map((v) => v === 1);
+  const result = barssince(boolValues);
+  return Series.fromArray(bars2, result);
+}
+function valuewhen2(condition, source, occurrence) {
+  const bars2 = condition.bars;
+  const boolValues = condition.toArray().map((v) => v === 1);
+  const result = valuewhen(boolValues, source.toArray(), occurrence);
+  return Series.fromArray(bars2, result);
+}
+function dmi2(bars2, diLength, adxSmoothing) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const [plusDI, minusDI, adx] = dmi(diLength, adxSmoothing, high2, low2, close2);
+  return [
+    Series.fromArray(bars2, plusDI),
+    Series.fromArray(bars2, minusDI),
+    Series.fromArray(bars2, adx)
+  ];
+}
+function tsi2(source, shortLength, longLength) {
+  const bars2 = source.bars;
+  const result = tsi(source.toArray(), shortLength, longLength);
+  return Series.fromArray(bars2, result);
+}
+function cmo2(source, length) {
+  const bars2 = source.bars;
+  const result = cmo(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function kc2(bars2, source, length, mult, useTrueRange = true) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const [middle, upper, lower] = kc(source.toArray(), length, mult, useTrueRange, high2, low2, close2);
+  return [
+    Series.fromArray(bars2, middle),
+    Series.fromArray(bars2, upper),
+    Series.fromArray(bars2, lower)
+  ];
+}
+function bbw2(source, length, mult) {
+  const bars2 = source.bars;
+  const result = bbw(source.toArray(), length, mult);
+  return Series.fromArray(bars2, result);
+}
+function wpr2(bars2, length = 14) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const result = wpr(high2, low2, close2, length);
+  return Series.fromArray(bars2, result);
+}
+function kcw2(bars2, source, length = 20, mult = 2, useTrueRange = true) {
+  const high2 = bars2.map((b2) => b2.high);
+  const low2 = bars2.map((b2) => b2.low);
+  const close2 = bars2.map((b2) => b2.close);
+  const result = kcw(source.toArray(), length, mult, useTrueRange, high2, low2, close2);
+  return Series.fromArray(bars2, result);
+}
+function range2(high2, low2) {
+  const bars2 = high2.bars;
+  const result = range(high2.toArray(), low2.toArray());
+  return Series.fromArray(bars2, result);
+}
+function highestbars2(source, length) {
+  const bars2 = source.bars;
+  const result = highestbars(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function lowestbars2(source, length) {
+  const bars2 = source.bars;
+  const result = lowestbars(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function max2(source1, source2) {
+  const bars2 = source1.bars;
+  const result = max(source1.toArray(), source2.toArray());
+  return Series.fromArray(bars2, result);
+}
+function min2(source1, source2) {
+  const bars2 = source1.bars;
+  const result = min(source1.toArray(), source2.toArray());
+  return Series.fromArray(bars2, result);
+}
+function cog2(source, length = 10) {
+  const bars2 = source.bars;
+  const result = cog(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function mode2(source, length) {
+  const bars2 = source.bars;
+  const result = mode(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+function percentile_linear_interpolation2(source, length, percentage) {
+  const bars2 = source.bars;
+  const result = percentile_linear_interpolation(source.toArray(), length, percentage);
+  return Series.fromArray(bars2, result);
+}
+function percentile_nearest_rank2(source, length, percentage) {
+  const bars2 = source.bars;
+  const result = percentile_nearest_rank(source.toArray(), length, percentage);
+  return Series.fromArray(bars2, result);
+}
+function rci2(source, length) {
+  const bars2 = source.bars;
+  const result = rci(source.toArray(), length);
+  return Series.fromArray(bars2, result);
+}
+var ta = {
+  sma: sma2,
+  ema: ema2,
+  wma: wma2,
+  vwma: vwma2,
+  rma: rma2,
+  rsi: rsi2,
+  macd: macd2,
+  bb: bb2,
+  stdev: stdev2,
+  atr: atr2,
+  tr: tr2,
+  stoch: stoch2,
+  crossover: crossover2,
+  crossunder: crossunder2,
+  cross: cross2,
+  change: change2,
+  mom: mom2,
+  roc: roc2,
+  highest: highest2,
+  lowest: lowest2,
+  rising: rising2,
+  falling: falling2,
+  cum: cum2,
+  supertrend: supertrend2,
+  vwap: vwap2,
+  ichimoku: ichimoku2,
+  linreg: linreg2,
+  alma: alma2,
+  zigzag: zigzag2,
+  cci: cci2,
+  sar: sar2,
+  dev: dev2,
+  variance: variance2,
+  median: median2,
+  swma: swma2,
+  correlation: correlation2,
+  percentrank: percentrank2,
+  mfi: mfi2,
+  hma: hma2,
+  pivothigh: pivothigh2,
+  pivotlow: pivotlow2,
+  barssince: barssince2,
+  valuewhen: valuewhen2,
+  dmi: dmi2,
+  tsi: tsi2,
+  cmo: cmo2,
+  kc: kc2,
+  bbw: bbw2,
+  wpr: wpr2,
+  kcw: kcw2,
+  range: range2,
+  highestbars: highestbars2,
+  lowestbars: lowestbars2,
+  max: max2,
+  min: min2,
+  cog: cog2,
+  mode: mode2,
+  percentile_linear_interpolation: percentile_linear_interpolation2,
+  percentile_nearest_rank: percentile_nearest_rank2,
+  rci: rci2
+};
+
+// src/color/index.ts
+var color_exports = {};
+__export(color_exports, {
+  aqua: () => aqua,
+  b: () => b,
+  black: () => black,
+  blue: () => blue,
+  from_gradient: () => from_gradient,
+  from_hex: () => from_hex,
+  fuchsia: () => fuchsia,
+  g: () => g,
+  gray: () => gray,
+  green: () => green,
+  lime: () => lime,
+  maroon: () => maroon,
+  navy: () => navy,
+  new: () => new_color,
+  new_color: () => new_color,
+  olive: () => olive,
+  orange: () => orange,
+  purple: () => purple,
+  r: () => r,
+  red: () => red,
+  rgb: () => rgb,
+  silver: () => silver,
+  t: () => t,
+  teal: () => teal,
+  white: () => white,
+  yellow: () => yellow
+});
+function rgb(red2, green2, blue2, transp) {
+  const r2 = Math.max(0, Math.min(255, red2));
+  const g2 = Math.max(0, Math.min(255, green2));
+  const b2 = Math.max(0, Math.min(255, blue2));
+  const a = transp !== void 0 ? 1 - transp / 100 : 1;
+  if (a === 1) {
+    return `rgb(${r2}, ${g2}, ${b2})`;
+  }
+  return `rgba(${r2}, ${g2}, ${b2}, ${a})`;
+}
+function from_hex(hex, transp) {
+  hex = hex.replace("#", "");
+  const r2 = parseInt(hex.substring(0, 2), 16);
+  const g2 = parseInt(hex.substring(2, 4), 16);
+  const b2 = parseInt(hex.substring(4, 6), 16);
+  return rgb(r2, g2, b2, transp);
+}
+function new_color(baseColor, transp) {
+  const rgba = parseColor(baseColor);
+  return rgb(rgba.r, rgba.g, rgba.b, transp);
+}
+function r(clr) {
+  return parseColor(clr).r;
+}
+function g(clr) {
+  return parseColor(clr).g;
+}
+function b(clr) {
+  return parseColor(clr).b;
+}
+function t(clr) {
+  return parseColor(clr).t;
+}
+function parseColor(clr) {
+  if (typeof clr === "string") {
+    const match = clr.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+    if (match) {
+      return {
+        r: parseInt(match[1]),
+        g: parseInt(match[2]),
+        b: parseInt(match[3]),
+        t: match[4] ? (1 - parseFloat(match[4])) * 100 : 0
+      };
+    }
+  }
+  return { r: 0, g: 0, b: 0, t: 0 };
+}
+var aqua = "#00FFFF";
+var black = "#000000";
+var blue = "#0000FF";
+var fuchsia = "#FF00FF";
+var gray = "#808080";
+var green = "#00FF00";
+var lime = "#00FF00";
+var maroon = "#800000";
+var navy = "#000080";
+var olive = "#808000";
+var orange = "#FFA500";
+var purple = "#800080";
+var red = "#FF0000";
+var silver = "#C0C0C0";
+var teal = "#008080";
+var white = "#FFFFFF";
+var yellow = "#FFFF00";
+function from_gradient(value, bottom_value, top_value, bottom_color, top_color) {
+  const parseColor2 = (col) => {
+    if (typeof col === "string") {
+      if (col.startsWith("#")) {
+        const hex = col.slice(1);
+        const r4 = parseInt(hex.slice(0, 2), 16);
+        const g4 = parseInt(hex.slice(2, 4), 16);
+        const b4 = parseInt(hex.slice(4, 6), 16);
+        return [r4, g4, b4, 1];
+      }
+      const match = col.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+      if (match) {
+        return [
+          parseInt(match[1]),
+          parseInt(match[2]),
+          parseInt(match[3]),
+          match[4] ? parseFloat(match[4]) : 1
+        ];
+      }
+    }
+    return [0, 0, 0, 1];
+  };
+  const [r1, g1, b1, a1] = parseColor2(bottom_color);
+  const [r2, g2, b2, a2] = parseColor2(top_color);
+  let t2;
+  if (value <= bottom_value) {
+    t2 = 0;
+  } else if (value >= top_value) {
+    t2 = 1;
+  } else {
+    t2 = (value - bottom_value) / (top_value - bottom_value);
+  }
+  const r3 = Math.round(r1 + (r2 - r1) * t2);
+  const g3 = Math.round(g1 + (g2 - g1) * t2);
+  const b3 = Math.round(b1 + (b2 - b1) * t2);
+  const a = a1 + (a2 - a1) * t2;
+  if (a === 1) {
+    return `rgb(${r3}, ${g3}, ${b3})`;
+  }
+  return `rgba(${r3}, ${g3}, ${b3}, ${a})`;
+}
+
+// src/utils/index.ts
+function isNA(value) {
+  return value === null || value === void 0 || Number.isNaN(value);
+}
+function nz(value, defaultValue = 0) {
+  return isNA(value) ? defaultValue : value;
+}
+
+// src/math/index.ts
+var math_exports = {};
+__export(math_exports, {
+  abs: () => abs,
+  acos: () => acos,
+  asin: () => asin,
+  atan: () => atan,
+  avg: () => avg,
+  ceil: () => ceil,
+  cos: () => cos,
+  e: () => e,
+  exp: () => exp,
+  floor: () => floor,
+  log: () => log,
+  log10: () => log10,
+  max: () => max3,
+  min: () => min3,
+  phi: () => phi,
+  pi: () => pi,
+  pow: () => pow,
+  random: () => random,
+  round: () => round,
+  round_to_mintick: () => round_to_mintick,
+  rphi: () => rphi,
+  sign: () => sign,
+  sin: () => sin,
+  sqrt: () => sqrt,
+  sum: () => sum,
+  tan: () => tan,
+  todegrees: () => todegrees,
+  toradians: () => toradians
+});
+function abs(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.abs(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.abs(value);
+}
+function ceil(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.ceil(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.ceil(value);
+}
+function floor(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.floor(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.floor(value);
+}
+function round(value, precision) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    if (precision === void 0) {
+      for (let i = 0; i < length; i++) {
+        const v = valueArray[i] ?? NaN;
+        result.push(Math.round(v));
+      }
+    } else {
+      const multiplier2 = Math.pow(10, precision);
+      for (let i = 0; i < length; i++) {
+        const v = valueArray[i] ?? NaN;
+        result.push(Math.round(v * multiplier2) / multiplier2);
+      }
+    }
+    return Series.fromArray(bars2, result);
+  }
+  if (precision === void 0) {
+    return Math.round(value);
+  }
+  const multiplier = Math.pow(10, precision);
+  return Math.round(value * multiplier) / multiplier;
+}
+function max3(...values) {
+  const hasSeries = values.some((v) => v instanceof Series);
+  if (!hasSeries) {
+    return Math.max(...values);
+  }
+  const firstSeries = values.find((v) => v instanceof Series);
+  const bars2 = firstSeries.bars;
+  const length = bars2.length;
+  const valueArrays = values.map(
+    (v) => v instanceof Series ? v.toArray() : null
+  );
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const nums = values.map(
+      (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
+    );
+    result.push(Math.max(...nums));
+  }
+  return Series.fromArray(bars2, result);
+}
+function min3(...values) {
+  const hasSeries = values.some((v) => v instanceof Series);
+  if (!hasSeries) {
+    return Math.min(...values);
+  }
+  const firstSeries = values.find((v) => v instanceof Series);
+  const bars2 = firstSeries.bars;
+  const length = bars2.length;
+  const valueArrays = values.map(
+    (v) => v instanceof Series ? v.toArray() : null
+  );
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const nums = values.map(
+      (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
+    );
+    result.push(Math.min(...nums));
+  }
+  return Series.fromArray(bars2, result);
+}
+function avg(...values) {
+  const hasSeries = values.some((v) => v instanceof Series);
+  if (!hasSeries) {
+    return values.reduce((a, b2) => a + b2, 0) / values.length;
+  }
+  const firstSeries = values.find((v) => v instanceof Series);
+  const bars2 = firstSeries.bars;
+  const length = bars2.length;
+  const valueArrays = values.map(
+    (v) => v instanceof Series ? v.toArray() : null
+  );
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const nums = values.map(
+      (v, idx) => valueArrays[idx] ? valueArrays[idx][i] ?? NaN : v
+    );
+    const sum2 = nums.reduce((a, b2) => a + b2, 0);
+    result.push(sum2 / nums.length);
+  }
+  return Series.fromArray(bars2, result);
+}
+function sum(source, length) {
+  const sourceArray = source instanceof Series ? source.toArray() : source;
+  const result = [];
+  for (let i = 0; i < sourceArray.length; i++) {
+    if (i < length - 1) {
+      result.push(NaN);
+    } else {
+      let total = 0;
+      for (let j = 0; j < length; j++) {
+        total += sourceArray[i - j];
+      }
+      result.push(total);
+    }
+  }
+  if (source instanceof Series) {
+    return Series.fromArray(source.bars, result);
+  }
+  return result;
+}
+function sqrt(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.sqrt(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.sqrt(value);
+}
+function pow(base, exponent) {
+  const baseIsSeries = base instanceof Series;
+  const expIsSeries = exponent instanceof Series;
+  if (!baseIsSeries && !expIsSeries) {
+    return Math.pow(base, exponent);
+  }
+  const bars2 = baseIsSeries ? base.bars : exponent.bars;
+  const baseArray = baseIsSeries ? base.toArray() : null;
+  const expArray = expIsSeries ? exponent.toArray() : null;
+  const length = bars2.length;
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const b2 = baseArray ? baseArray[i] ?? NaN : base;
+    const e2 = expArray ? expArray[i] ?? NaN : exponent;
+    result.push(Math.pow(b2, e2));
+  }
+  return Series.fromArray(bars2, result);
+}
+function exp(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.exp(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.exp(value);
+}
+function log(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.log(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.log(value);
+}
+function log10(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.log10(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.log10(value);
+}
+function sin(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.sin(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.sin(value);
+}
+function cos(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.cos(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.cos(value);
+}
+function tan(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.tan(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.tan(value);
+}
+function asin(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.asin(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.asin(value);
+}
+function acos(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.acos(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.acos(value);
+}
+function atan(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(Math.atan(v));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return Math.atan(value);
+}
+function toradians(degrees) {
+  if (degrees instanceof Series) {
+    const bars2 = degrees.bars;
+    const valueArray = degrees.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(v * (Math.PI / 180));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return degrees * (Math.PI / 180);
+}
+function todegrees(radians) {
+  if (radians instanceof Series) {
+    const bars2 = radians.bars;
+    const valueArray = radians.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(v * (180 / Math.PI));
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return radians * (180 / Math.PI);
+}
+function random(min4, max4, _seed) {
+  const rand = Math.random();
+  if (min4 !== void 0 && max4 !== void 0) {
+    return min4 + rand * (max4 - min4);
+  }
+  return rand;
+}
+function sign(value) {
+  if (value instanceof Series) {
+    const bars2 = value.bars;
+    const valueArray = value.toArray();
+    const length = bars2.length;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      const v = valueArray[i] ?? NaN;
+      result.push(v > 0 ? 1 : v < 0 ? -1 : 0);
+    }
+    return Series.fromArray(bars2, result);
+  }
+  return value > 0 ? 1 : value < 0 ? -1 : 0;
+}
+function round_to_mintick(number, mintick) {
+  if (number instanceof Series) {
+    const bars2 = number.bars;
+    const valueArray = number.toArray();
+    const length = bars2.length;
+    if (mintick === void 0) {
+      throw new Error(
+        "math.round_to_mintick() requires mintick value. Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data."
+      );
+    }
+    const result = [];
+    if (mintick === 0) {
+      for (let i = 0; i < length; i++) {
+        result.push(valueArray[i] ?? NaN);
+      }
+    } else {
+      for (let i = 0; i < length; i++) {
+        const v = valueArray[i];
+        if (v === void 0 || isNaN(v)) {
+          result.push(NaN);
+        } else {
+          result.push(Math.round(v / mintick) * mintick);
+        }
+      }
+    }
+    return Series.fromArray(bars2, result);
+  }
+  if (isNaN(number)) {
+    return NaN;
+  }
+  if (mintick === void 0) {
+    throw new Error(
+      "math.round_to_mintick() requires mintick value. Either pass it explicitly or use createContext({ syminfo: { mintick } }) for implicit data."
+    );
+  }
+  if (mintick === 0) {
+    return number;
+  }
+  return Math.round(number / mintick) * mintick;
+}
+var pi = Math.PI;
+var e = Math.E;
+var phi = 1.618033988749895;
+var rphi = 0.618033988749895;
+
+// src/script/index.ts
+var ctxBars = new BarData([]);
+var ctx = null;
+function collector() {
+  if (!ctx) {
+    throw new Error(
+      "oakscriptjs/script functions can only run inside executeScript() \u2014 the host (chart/worker) drives script execution."
+    );
+  }
+  return ctx;
+}
+function freshCollector(inputValues) {
+  return {
+    title: "Untitled",
+    overlay: true,
+    inputValues,
+    inputConfig: [],
+    inputIds: /* @__PURE__ */ new Set(),
+    defaultInputs: {},
+    plotConfig: [],
+    plots: {},
+    hlineConfig: [],
+    fills: [],
+    fillConfig: [],
+    shapeConfig: [],
+    markers: [],
+    barColorConfig: [],
+    bgcolors: [],
+    barcolors: [],
+    alertConfig: [],
+    alerts: []
+  };
+}
+function slugId(title, fallback, taken) {
+  const base = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || fallback;
+  let id = base;
+  for (let n = 2; taken.has(id); n++) id = `${base}_${n}`;
+  taken.add(id);
+  return id;
+}
+function executeScript(body, barsInput, inputs = {}) {
+  ctxBars.setAll(barsInput);
+  ctx = freshCollector(inputs);
+  try {
+    body();
+    const c = ctx;
+    return {
+      metadata: {
+        title: c.title,
+        shortTitle: c.shortTitle,
+        overlay: c.overlay,
+        precision: c.precision,
+        format: c.format
+      },
+      inputConfig: c.inputConfig,
+      plotConfig: c.plotConfig,
+      hlineConfig: c.hlineConfig,
+      fillConfig: c.fillConfig,
+      shapeConfig: c.shapeConfig,
+      barColorConfig: c.barColorConfig,
+      defaultInputs: c.defaultInputs,
+      alertConfig: c.alertConfig,
+      result: {
+        metadata: { title: c.title, shorttitle: c.shortTitle, overlay: c.overlay, precision: c.precision },
+        plots: c.plots,
+        fills: c.fills.length ? c.fills : void 0,
+        markers: c.markers.length ? c.markers : void 0,
+        bgcolors: c.bgcolors.length ? c.bgcolors : void 0,
+        barcolors: c.barcolors.length ? c.barcolors : void 0,
+        alerts: c.alerts.length ? c.alerts : void 0
+      }
+    };
+  } finally {
+    ctx = null;
+  }
+}
+function indicator(title, options = {}) {
+  const c = collector();
+  c.title = title;
+  c.shortTitle = options.shorttitle;
+  c.overlay = options.overlay ?? true;
+  c.precision = options.precision;
+  c.format = options.format;
+}
+function registerInput(config, fallbackId) {
+  const c = collector();
+  const id = slugId(config.title, fallbackId, c.inputIds);
+  c.inputConfig.push({ id, ...config });
+  c.defaultInputs[id] = config.defval;
+  const value = c.inputValues[id];
+  return value === void 0 ? config.defval : value;
+}
+function registerNumeric(type, defval, title, opts = {}) {
+  const v = registerInput(
+    { type, defval, title, min: opts.minval, max: opts.maxval, step: opts.step },
+    `input_${type}`
+  );
+  return typeof v === "number" ? v : defval;
+}
+var input = {
+  int(defval, title, opts = {}) {
+    return Math.round(registerNumeric("int", defval, title, opts));
+  },
+  float(defval, title, opts = {}) {
+    return registerNumeric("float", defval, title, opts);
+  },
+  bool(defval, title) {
+    return registerInput({ type: "bool", defval, title }, "input_bool");
+  },
+  string(defval, title, opts = {}) {
+    return registerInput({ type: "string", defval, title, options: opts.options }, "input_string");
+  },
+  color(defval, title) {
+    return registerInput({ type: "color", defval, title }, "input_color");
+  },
+  /** Declares a source input and returns it as a Series. */
+  source(defval = "close", title) {
+    const name = registerInput({ type: "source", defval, title }, "input_source");
+    return sourceSeries(name);
+  }
+};
+var open = Series.fromBars(ctxBars, "open");
+var high = Series.fromBars(ctxBars, "high");
+var low = Series.fromBars(ctxBars, "low");
+var close = Series.fromBars(ctxBars, "close");
+var volume = Series.fromBars(ctxBars, "volume");
+var hl2 = new Series(ctxBars, (b2) => (b2.high + b2.low) / 2);
+var hlc3 = new Series(ctxBars, (b2) => (b2.high + b2.low + b2.close) / 3);
+var ohlc4 = new Series(ctxBars, (b2) => (b2.open + b2.high + b2.low + b2.close) / 4);
+var hlcc4 = new Series(ctxBars, (b2) => (b2.high + b2.low + b2.close + b2.close) / 4);
+var SOURCES = { open, high, low, close, volume, hl2, hlc3, ohlc4, hlcc4 };
+function sourceSeries(name) {
+  return SOURCES[name] ?? close;
+}
+var bars = () => ctxBars.bars;
+var ta2 = {
+  ...ta_series_exports,
+  tr: (handleNa = false) => tr2(bars(), handleNa),
+  atr: (length) => atr2(bars(), length),
+  sar: (start, inc, max4) => sar2(bars(), start, inc, max4),
+  wpr: (length) => wpr2(bars(), length),
+  supertrend: (factor, atrLength) => supertrend2(bars(), factor, atrLength),
+  dmi: (diLength, adxSmoothing) => dmi2(bars(), diLength, adxSmoothing),
+  kc: (source, length, mult, useTrueRange) => kc2(bars(), source, length, mult, useTrueRange),
+  kcw: (source, length, mult, useTrueRange) => kcw2(bars(), source, length, mult, useTrueRange),
+  ichimoku: (conversionPeriods, basePeriods, laggingSpan2Periods, displacement) => ichimoku2(bars(), conversionPeriods, basePeriods, laggingSpan2Periods, displacement)
+};
+function colorWhen(cond, colorTrue, colorFalse) {
+  return cond.toArray().map((v) => !isNA(v) && v !== 0 ? colorTrue : colorFalse);
+}
+var color = {
+  ...color_exports,
+  new: new_color,
+  when: colorWhen
+};
+function plot(series, title, options = {}) {
+  const c = collector();
+  const id = `plot${c.plotConfig.length}`;
+  const perBar = Array.isArray(options.color) ? options.color : void 0;
+  const staticColor = typeof options.color === "string" ? options.color : perBar?.[perBar.length - 1] ?? "#2962FF";
+  c.plotConfig.push({
+    id,
+    title: title ?? id,
+    color: staticColor,
+    lineWidth: options.linewidth,
+    style: options.style,
+    display: options.display,
+    histbase: options.histbase
+  });
+  const values = series.toArray();
+  const b2 = bars();
+  const data = [];
+  for (let i = 0; i < b2.length; i++) {
+    const value = values[i];
+    if (value === void 0 || Number.isNaN(value)) continue;
+    data.push(perBar ? { time: b2[i].time, value, color: perBar[i] } : { time: b2[i].time, value });
+  }
+  c.plots[id] = data;
+  return { id, kind: "plot" };
+}
+function hline(price, title, options = {}) {
+  const c = collector();
+  const id = `hline${c.hlineConfig.length}`;
+  c.hlineConfig.push({
+    id,
+    price,
+    title,
+    color: options.color,
+    linestyle: options.linestyle,
+    linewidth: options.linewidth
+  });
+  return { id, kind: "hline" };
+}
+function fill(a, b2, options = {}) {
+  const c = collector();
+  const perBar = Array.isArray(options.color) ? options.color : void 0;
+  const staticColor = typeof options.color === "string" ? options.color : void 0;
+  if (a.kind === "hline" && b2.kind === "hline") {
+    c.fillConfig.push({
+      id: `fill${c.fillConfig.length}`,
+      plot1: a.id,
+      plot2: b2.id,
+      color: staticColor,
+      colors: perBar,
+      title: options.title
+    });
+    return;
+  }
+  c.fills.push({
+    plot1: a.id,
+    plot2: b2.id,
+    options: { color: staticColor, title: options.title },
+    colors: perBar
+  });
+}
+function emitMarkers(kind, condition, title, options) {
+  const c = collector();
+  const id = `${kind}${c.shapeConfig.filter((s) => s.kind === kind).length}`;
+  const style = kind === "shape" ? options.style ?? "xcross" : "char";
+  const char = kind === "char" ? options.char ?? "*" : void 0;
+  const location = options.location ?? "abovebar";
+  c.shapeConfig.push({
+    id,
+    kind,
+    title,
+    style: kind === "shape" ? style : void 0,
+    char,
+    location,
+    color: options.color,
+    text: options.text,
+    textcolor: options.textcolor,
+    size: options.size,
+    offset: options.offset
+  });
+  const values = condition.toArray();
+  const b2 = bars();
+  const off = options.offset ?? 0;
+  for (let i = 0; i < b2.length; i++) {
+    const v = values[i];
+    if (v === void 0 || Number.isNaN(v) || v === 0) continue;
+    const j = i + off;
+    if (j < 0 || j >= b2.length) continue;
+    c.markers.push({
+      time: b2[j].time,
+      id,
+      location,
+      style,
+      char,
+      color: options.color,
+      text: options.text,
+      textcolor: options.textcolor,
+      size: options.size,
+      tooltip: options.tooltip,
+      price: location === "absolute" ? v : void 0
+    });
+  }
+}
+function plotshape(condition, title, options = {}) {
+  emitMarkers("shape", condition, title, options);
+}
+function plotchar(condition, title, options = {}) {
+  emitMarkers("char", condition, title, options);
+}
+function emitBarColors(kind, colors, options) {
+  const c = collector();
+  const id = `${kind}${c.barColorConfig.filter((x) => x.kind === kind).length}`;
+  c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset });
+  const b2 = bars();
+  const off = options.offset ?? 0;
+  const target = kind === "bgcolor" ? c.bgcolors : c.barcolors;
+  for (let i = 0; i < b2.length; i++) {
+    const col = typeof colors === "string" ? colors : colors[i];
+    if (!col) continue;
+    const j = i + off;
+    if (j < 0 || j >= b2.length) continue;
+    target.push({ time: b2[j].time, color: col });
+  }
+}
+function bgcolor(colors, options = {}) {
+  emitBarColors("bgcolor", colors, options);
+}
+function barcolor(colors, options = {}) {
+  emitBarColors("barcolor", colors, options);
+}
+function eachBar(fn) {
+  collector();
+  const b2 = bars();
+  const out = new Array(b2.length).fill(NaN);
+  const cache = /* @__PURE__ */ new Map();
+  let idx = 0;
+  const ctx2 = {
+    get i() {
+      return idx;
+    },
+    n: b2.length,
+    get time() {
+      return b2[idx].time;
+    },
+    get open() {
+      return b2[idx].open;
+    },
+    get high() {
+      return b2[idx].high;
+    },
+    get low() {
+      return b2[idx].low;
+    },
+    get close() {
+      return b2[idx].close;
+    },
+    get volume() {
+      return b2[idx].volume ?? NaN;
+    },
+    get(src, offset = 0) {
+      let vals = cache.get(src);
+      if (!vals) {
+        vals = src.toArray();
+        cache.set(src, vals);
+      }
+      const j = idx - offset;
+      return j >= 0 && j < vals.length ? vals[j] ?? NaN : NaN;
+    },
+    prev(offset = 1) {
+      const j = idx - Math.max(1, offset);
+      return j >= 0 ? out[j] : NaN;
+    }
+  };
+  for (idx = 0; idx < b2.length; idx++) {
+    const r2 = fn(ctx2);
+    out[idx] = typeof r2 === "number" ? r2 : typeof r2 === "boolean" ? r2 ? 1 : 0 : NaN;
+  }
+  return Series.fromArray(ctxBars, out);
+}
+function seriesOf(values) {
+  collector();
+  return Series.fromArray(ctxBars, values);
+}
+function alertcondition(condition, title, message) {
+  const c = collector();
+  const id = `alert${c.alertConfig.length}`;
+  c.alertConfig.push({ id, title, message });
+  const last = condition.length() ? condition.last() : NaN;
+  c.alerts.push({ id, title, message, triggered: !isNA(last) && last !== 0 });
+}