oakscriptjs 0.8.1 → 0.9.0

package/dist/esm/ta-series.js

@@ -0,0 +1,910 @@
+/**
+ * @fileoverview Technical analysis functions that work with Series
+ * Fixed wrappers around core ta.* functions with O(n) performance
+ * @module ta-series
+ */
+import * as taCore from './ta/index.js';
+import { Series } from './runtime/series.js';
+/**
+ * Simple Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with SMA values
+ */
+export function sma(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.sma(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Exponential Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with EMA values
+ */
+export function ema(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.ema(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Weighted Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with WMA values
+ */
+export function wma(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.wma(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Relative Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with RMA values
+ */
+export function rma(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.rma(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Relative Strength Index
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with RSI values
+ */
+export function rsi(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.rsi(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Moving Average Convergence Divergence
+ * @param source - Source series
+ * @param fastLength - Fast EMA period
+ * @param slowLength - Slow EMA period
+ * @param signalLength - Signal line period
+ * @returns Tuple of [macdLine, signalLine, histogram] Series
+ */
+export function macd(source, fastLength, slowLength, signalLength) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const [macdVals, signalVals, histVals] = taCore.macd(sourceValues, fastLength, slowLength, signalLength);
+    const macdSeries = Series.fromArray(bars, macdVals);
+    const signalSeries = Series.fromArray(bars, signalVals);
+    const histSeries = Series.fromArray(bars, histVals);
+    return [macdSeries, signalSeries, histSeries];
+}
+/**
+ * Bollinger Bands
+ * @param source - Source series
+ * @param length - Period length
+ * @param mult - Standard deviation multiplier
+ * @returns Tuple of [upper, basis, lower] Series
+ */
+export function bb(source, length, mult) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const [upperVals, basisVals, lowerVals] = taCore.bb(sourceValues, length, mult);
+    const upperSeries = Series.fromArray(bars, upperVals);
+    const basisSeries = Series.fromArray(bars, basisVals);
+    const lowerSeries = Series.fromArray(bars, lowerVals);
+    return [upperSeries, basisSeries, lowerSeries];
+}
+/**
+ * Standard deviation (PineScript ta.stdev; biased by default)
+ * @param source - Source series
+ * @param length - Period length
+ * @param biased - true (default): divide by length; false: by length - 1
+ * @returns Series with standard deviation values
+ */
+export function stdev(source, length, biased = true) {
+    const bars = source.bars;
+    return Series.fromArray(bars, taCore.stdev(source.toArray(), length, biased));
+}
+/**
+ * Average True Range
+ * @param bars - Bar data
+ * @param length - Period length
+ * @returns Series with ATR values
+ */
+export function atr(bars, length) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const result = taCore.atr(length, high, low, close);
+    return Series.fromArray(bars, result);
+}
+/**
+ * True Range
+ * @param bars - Bar data
+ * @param handle_na - How NaN values are handled (default: false)
+ * @returns Series with TR values
+ */
+export function tr(bars, handle_na = false) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const result = taCore.tr(handle_na, high, low, close);
+    return Series.fromArray(bars, result);
+}
+// Volume built-in variables. PineScript exposes them as variables of the chart bars
+// (`ta.obv`); here they take the bars.
+const col = (bars, f) => bars.map((b) => b[f] ?? NaN);
+/** On Balance Volume (PineScript `ta.obv`) */
+export function obv(bars) {
+    return Series.fromArray(bars, taCore.obv(col(bars, 'close'), col(bars, 'volume')));
+}
+/** Price-Volume Trend (PineScript `ta.pvt`) */
+export function pvt(bars) {
+    return Series.fromArray(bars, taCore.pvt(col(bars, 'close'), col(bars, 'volume')));
+}
+/** Accumulation/Distribution index (PineScript `ta.accdist`) */
+export function accdist(bars) {
+    return Series.fromArray(bars, taCore.accdist(col(bars, 'high'), col(bars, 'low'), col(bars, 'close'), col(bars, 'volume')));
+}
+/** Negative Volume Index (PineScript `ta.nvi`) */
+export function nvi(bars) {
+    return Series.fromArray(bars, taCore.nvi(col(bars, 'close'), col(bars, 'volume')));
+}
+/** Positive Volume Index (PineScript `ta.pvi`) */
+export function pvi(bars) {
+    return Series.fromArray(bars, taCore.pvi(col(bars, 'close'), col(bars, 'volume')));
+}
+/** Intraday Intensity Index (PineScript `ta.iii`) */
+export function iii(bars) {
+    return Series.fromArray(bars, taCore.iii(col(bars, 'high'), col(bars, 'low'), col(bars, 'close'), col(bars, 'volume')));
+}
+/** Williams Accumulation/Distribution (PineScript `ta.wad`) */
+export function wad(bars) {
+    return Series.fromArray(bars, taCore.wad(col(bars, 'high'), col(bars, 'low'), col(bars, 'close')));
+}
+/** Williams Variable Accumulation/Distribution (PineScript `ta.wvad`) */
+export function wvad(bars) {
+    return Series.fromArray(bars, taCore.wvad(col(bars, 'open'), col(bars, 'high'), col(bars, 'low'), col(bars, 'close'), col(bars, 'volume')));
+}
+/**
+ * Stochastic %K
+ * @param source - Source series (typically close)
+ * @param high - High series
+ * @param low - Low series
+ * @param length - Period length
+ * @returns Series with stochastic values
+ */
+export function stoch(source, high, low, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const highValues = high.toArray();
+    const lowValues = low.toArray();
+    const result = taCore.stoch(sourceValues, highValues, lowValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Crossover detection
+ * @param source1 - First series
+ * @param source2 - Second series or number
+ * @returns Series with 1 where crossover, 0 otherwise
+ */
+export function crossover(source1, source2) {
+    const bars = source1.bars;
+    const vals1 = source1.toArray();
+    const vals2 = typeof source2 === 'number'
+        ? Array(bars.length).fill(source2)
+        : source2.toArray();
+    const result = taCore.crossover(vals1, vals2);
+    // Convert boolean array to number array
+    const numResult = result.map(b => b ? 1 : 0);
+    return Series.fromArray(bars, numResult);
+}
+/**
+ * Crossunder detection
+ * @param source1 - First series
+ * @param source2 - Second series or number
+ * @returns Series with 1 where crossunder, 0 otherwise
+ */
+export function crossunder(source1, source2) {
+    const bars = source1.bars;
+    const vals1 = source1.toArray();
+    const vals2 = typeof source2 === 'number'
+        ? Array(bars.length).fill(source2)
+        : source2.toArray();
+    const result = taCore.crossunder(vals1, vals2);
+    // Convert boolean array to number array
+    const numResult = result.map(b => b ? 1 : 0);
+    return Series.fromArray(bars, numResult);
+}
+/**
+ * Cross detection
+ * @param source1 - First series
+ * @param source2 - Second series or number
+ * @returns Series with 1 where cross, 0 otherwise
+ */
+export function cross(source1, source2) {
+    const bars = source1.bars;
+    const vals1 = source1.toArray();
+    const vals2 = typeof source2 === 'number'
+        ? Array(bars.length).fill(source2)
+        : source2.toArray();
+    const result = taCore.cross(vals1, vals2);
+    // Convert boolean array to number array
+    const numResult = result.map(b => b ? 1 : 0);
+    return Series.fromArray(bars, numResult);
+}
+/**
+ * Change (difference from previous value)
+ * @param source - Source series
+ * @param length - Lookback period
+ * @returns Series with change values
+ */
+export function change(source, length = 1) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.change(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Momentum
+ * @param source - Source series
+ * @param length - Lookback period
+ * @returns Series with momentum values
+ */
+export function mom(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.mom(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Rate of Change
+ * @param source - Source series
+ * @param length - Lookback period
+ * @returns Series with ROC values
+ */
+export function roc(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.roc(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Highest value in period
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with highest values
+ */
+export function highest(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.highest(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Lowest value in period
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with lowest values
+ */
+export function lowest(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.lowest(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Rising detection
+ * @param source - Source series
+ * @param length - Lookback period
+ * @returns Series with 1 where rising, 0 otherwise
+ */
+export function rising(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.rising(sourceValues, length);
+    // Convert boolean array to number array
+    const numResult = result.map(b => b ? 1 : 0);
+    return Series.fromArray(bars, numResult);
+}
+/**
+ * Falling detection
+ * @param source - Source series
+ * @param length - Lookback period
+ * @returns Series with 1 where falling, 0 otherwise
+ */
+export function falling(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.falling(sourceValues, length);
+    // Convert boolean array to number array
+    const numResult = result.map(b => b ? 1 : 0);
+    return Series.fromArray(bars, numResult);
+}
+/**
+ * Cumulative sum
+ * @param source - Source series
+ * @returns Series with cumulative sum values
+ */
+export function cum(source) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.cum(sourceValues);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Supertrend indicator
+ * @param bars - Bar data
+ * @param factor - Multiplier factor
+ * @param atrLength - ATR period length
+ * @returns Tuple of [supertrend, direction] Series
+ */
+export function supertrend(bars, factor, atrLength) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const [trendVals, dirVals] = taCore.supertrend(factor, atrLength, high, low, close);
+    const trendSeries = Series.fromArray(bars, trendVals);
+    const dirSeries = Series.fromArray(bars, dirVals);
+    return [trendSeries, dirSeries];
+}
+/**
+ * Volume Weighted Average Price (PineScript ta.vwap)
+ * @param source - Source series
+ * @param volume - Volume series
+ * @param anchor - Reset condition (non-zero = reset); without it the sums never restart
+ * @returns Series with VWAP values
+ */
+export function vwap(source, volume, anchor) {
+    const bars = source.bars;
+    return Series.fromArray(bars, taCore.vwap(source.toArray(), volume.toArray(), anchor?.toArray()));
+}
+/**
+ * VWAP with standard deviation bands (PineScript `[vwap, upper, lower] = ta.vwap(source, anchor, stdev_mult)`)
+ * @returns [vwap, upper, lower] Series
+ */
+export function vwapBands(source, volume, anchor, stdev_mult) {
+    const bars = source.bars;
+    const [m, u, l] = taCore.vwap(source.toArray(), volume.toArray(), anchor?.toArray(), stdev_mult);
+    return [Series.fromArray(bars, m), Series.fromArray(bars, u), Series.fromArray(bars, l)];
+}
+/**
+ * Ichimoku Kinko Hyo (Ichimoku Cloud)
+ * @param bars - Bar data
+ * @param conversionPeriods - Period for Tenkan-sen (default: 9)
+ * @param basePeriods - Period for Kijun-sen (default: 26)
+ * @param laggingSpan2Periods - Period for Senkou Span B (default: 52)
+ * @param displacement - Displacement for Senkou Spans and Chikou Span (default: 26)
+ * @returns Tuple of [tenkanSen, kijunSen, senkouSpanA, senkouSpanB, chikouSpan] Series
+ */
+export function ichimoku(bars, conversionPeriods, basePeriods, laggingSpan2Periods, displacement) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const [tenkan, kijun, senkouA, senkouB, chikou] = taCore.ichimoku(conversionPeriods, basePeriods, laggingSpan2Periods, displacement, high, low, close);
+    return [
+        Series.fromArray(bars, tenkan),
+        Series.fromArray(bars, kijun),
+        Series.fromArray(bars, senkouA),
+        Series.fromArray(bars, senkouB),
+        Series.fromArray(bars, chikou),
+    ];
+}
+/**
+ * Volume Weighted Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @param volume - Volume series
+ * @returns Series with VWMA values
+ */
+export function vwma(source, length, volume) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const volumeValues = volume.toArray();
+    const result = taCore.vwma(sourceValues, length, volumeValues);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Linear Regression
+ * @param source - Source series
+ * @param length - Period length
+ * @param offset - Offset (default: 0)
+ * @returns Series with linear regression values
+ */
+export function linreg(source, length, offset = 0) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.linreg(sourceValues, length, offset);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Arnaud Legoux Moving Average
+ * @param source - Source series
+ * @param length - Period length (default: 9)
+ * @param offset - Controls tradeoff between smoothness and responsiveness (default: 0.85)
+ * @param sigma - Standard deviation factor for sharpness (default: 6)
+ * @param floor - Whether to floor the offset calculation (default: false)
+ * @returns Series with ALMA values
+ */
+export function alma(source, length = 9, offset = 0.85, sigma = 6, floor = false) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.alma(sourceValues, length, offset, sigma, floor);
+    return Series.fromArray(bars, result);
+}
+/**
+ * ZigZag indicator - identifies significant trend reversals
+ * @param bars - Bar data
+ * @param deviation - Minimum percentage price change to form a new pivot (default: 5.0)
+ * @param depth - Minimum bars between pivots (default: 10)
+ * @param backstep - Bars to look back for confirmation (default: 3)
+ * @returns Tuple of [zigzag values, direction, isPivot flags] Series
+ * @remarks
+ * - The isPivot Series contains numeric values (1 for pivot, 0 for non-pivot)
+ *   converted from boolean for consistency with other Series-based functions
+ * - The core ta.zigzag() function returns boolean isPivot values
+ */
+export function zigzag(bars, deviation = 5, depth = 10, backstep = 3) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const [zigzagVals, dirVals, pivotVals] = taCore.zigzag(deviation, depth, backstep, undefined, high, low);
+    // Convert boolean pivot flags to numbers (1/0) for Series compatibility
+    return [
+        Series.fromArray(bars, zigzagVals),
+        Series.fromArray(bars, dirVals),
+        Series.fromArray(bars, pivotVals.map(b => b ? 1 : 0)),
+    ];
+}
+/**
+ * Commodity Channel Index
+ * @param source - Source series (typically hlc3)
+ * @param length - Period length
+ * @returns Series with CCI values
+ */
+export function cci(source, length) {
+    const bars = source.bars;
+    const sourceValues = source.toArray();
+    const result = taCore.cci(sourceValues, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Parabolic SAR (Stop and Reverse)
+ * @param bars - Bar data
+ * @param start - Initial acceleration factor (default: 0.02)
+ * @param inc - Acceleration factor increment (default: 0.02)
+ * @param max - Maximum acceleration factor (default: 0.2)
+ * @returns Series with SAR values
+ */
+export function sar(bars, start = 0.02, inc = 0.02, max = 0.2) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const result = taCore.sar(start, inc, max, high, low, close);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Deviation
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with deviation values
+ */
+export function dev(source, length) {
+    const bars = source.bars;
+    const result = taCore.dev(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Variance
+ * @param source - Source series
+ * @param length - Period length
+ * @param biased - Use biased estimation (default: true)
+ * @returns Series with variance values
+ */
+export function variance(source, length, biased = true) {
+    const bars = source.bars;
+    const result = taCore.variance(source.toArray(), length, biased);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Median
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with median values
+ */
+export function median(source, length) {
+    const bars = source.bars;
+    const result = taCore.median(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Symmetrically Weighted Moving Average
+ * @param source - Source series
+ * @returns Series with SWMA values
+ */
+export function swma(source) {
+    const bars = source.bars;
+    const result = taCore.swma(source.toArray());
+    return Series.fromArray(bars, result);
+}
+/**
+ * Correlation
+ * @param source1 - First source series
+ * @param source2 - Second source series
+ * @param length - Period length
+ * @returns Series with correlation values
+ */
+export function correlation(source1, source2, length) {
+    const bars = source1.bars;
+    const result = taCore.correlation(source1.toArray(), source2.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Percent Rank
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with percent rank values
+ */
+export function percentrank(source, length) {
+    const bars = source.bars;
+    const result = taCore.percentrank(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Money Flow Index
+ * @param source - Source series (typically hlc3)
+ * @param length - Period length
+ * @param volume - Volume series
+ * @returns Series with MFI values
+ */
+export function mfi(source, length, volume) {
+    const bars = source.bars;
+    const result = taCore.mfi(source.toArray(), length, volume.toArray());
+    return Series.fromArray(bars, result);
+}
+/**
+ * Hull Moving Average
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with HMA values
+ */
+export function hma(source, length) {
+    const bars = source.bars;
+    const result = taCore.hma(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Pivot High
+ * @param source - Source series
+ * @param leftbars - Number of bars to the left of the pivot
+ * @param rightbars - Number of bars to the right of the pivot
+ * @returns Series with the pivot high value on the bar where the pivot is confirmed,
+ *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
+ */
+export function pivothigh(source, leftbars, rightbars) {
+    const bars = source.bars;
+    const result = taCore.pivothigh(source.toArray(), leftbars, rightbars);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Pivot Low
+ * @param source - Source series
+ * @param leftbars - Number of bars to the left of the pivot
+ * @param rightbars - Number of bars to the right of the pivot
+ * @returns Series with the pivot low value on the bar where the pivot is confirmed,
+ *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
+ */
+export function pivotlow(source, leftbars, rightbars) {
+    const bars = source.bars;
+    const result = taCore.pivotlow(source.toArray(), leftbars, rightbars);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Bars Since condition was true
+ * @param condition - Boolean series (1/0 values)
+ * @returns Series with bar count since condition was last true
+ */
+export function barssince(condition) {
+    const bars = condition.bars;
+    const boolValues = condition.toArray().map(v => v === 1);
+    const result = taCore.barssince(boolValues);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Value When condition was true
+ * @param condition - Boolean series (1/0 values)
+ * @param source - Source series to extract values from
+ * @param occurrence - Which occurrence to use (0 = most recent)
+ * @returns Series with values from source when condition was true
+ */
+export function valuewhen(condition, source, occurrence) {
+    const bars = condition.bars;
+    const boolValues = condition.toArray().map(v => v === 1);
+    const result = taCore.valuewhen(boolValues, source.toArray(), occurrence);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Directional Movement Index
+ * @param bars - Bar data
+ * @param diLength - DI period length
+ * @param adxSmoothing - ADX smoothing period
+ * @returns Tuple of [plusDI, minusDI, adx] Series
+ */
+export function dmi(bars, diLength, adxSmoothing) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const [plusDI, minusDI, adx] = taCore.dmi(diLength, adxSmoothing, high, low, close);
+    return [
+        Series.fromArray(bars, plusDI),
+        Series.fromArray(bars, minusDI),
+        Series.fromArray(bars, adx),
+    ];
+}
+/**
+ * True Strength Index
+ * @param source - Source series
+ * @param shortLength - Short smoothing period
+ * @param longLength - Long smoothing period
+ * @returns Series with TSI values
+ */
+export function tsi(source, shortLength, longLength) {
+    const bars = source.bars;
+    const result = taCore.tsi(source.toArray(), shortLength, longLength);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Chande Momentum Oscillator
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with CMO values
+ */
+export function cmo(source, length) {
+    const bars = source.bars;
+    const result = taCore.cmo(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Keltner Channel
+ * @param bars - Bar data
+ * @param source - Source series
+ * @param length - Period length
+ * @param mult - Multiplier
+ * @param useTrueRange - Use true range (default: true)
+ * @returns Tuple of [middle, upper, lower] Series
+ */
+export function kc(bars, source, length, mult, useTrueRange = true) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const [middle, upper, lower] = taCore.kc(source.toArray(), length, mult, useTrueRange, high, low, close);
+    return [
+        Series.fromArray(bars, middle),
+        Series.fromArray(bars, upper),
+        Series.fromArray(bars, lower),
+    ];
+}
+/**
+ * Bollinger Bands Width
+ * @param source - Source series
+ * @param length - Period length
+ * @param mult - Standard deviation multiplier
+ * @returns Series with BBW values
+ */
+export function bbw(source, length, mult) {
+    const bars = source.bars;
+    const result = taCore.bbw(source.toArray(), length, mult);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Williams %R
+ * @param bars - Bar data
+ * @param length - Period length (default: 14)
+ * @returns Series with Williams %R values
+ */
+export function wpr(bars, length = 14) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const result = taCore.wpr(high, low, close, length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Keltner Channel Width
+ * @param bars - Bar data
+ * @param source - Source series
+ * @param length - Period length (default: 20)
+ * @param mult - Multiplier (default: 2)
+ * @param useTrueRange - Use true range (default: true)
+ * @returns Series with KCW values
+ */
+export function kcw(bars, source, length = 20, mult = 2, useTrueRange = true) {
+    const high = bars.map(b => b.high);
+    const low = bars.map(b => b.low);
+    const close = bars.map(b => b.close);
+    const result = taCore.kcw(source.toArray(), length, mult, useTrueRange, high, low, close);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Range: highest minus lowest value over the last `length` non-na values (PineScript ta.range)
+ * @param source - Source series
+ * @param length - Number of values
+ * @returns Series with range values
+ */
+export function range(source, length) {
+    const bars = source.bars;
+    return Series.fromArray(bars, taCore.range(source.toArray(), length));
+}
+/**
+ * Highest Bars - offset to the highest value
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with bar offsets to highest value
+ */
+export function highestbars(source, length) {
+    const bars = source.bars;
+    const result = taCore.highestbars(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Lowest Bars - offset to the lowest value
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with bar offsets to lowest value
+ */
+export function lowestbars(source, length) {
+    const bars = source.bars;
+    const result = taCore.lowestbars(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * All-time highest value (PineScript ta.max)
+ * @param source - Source series
+ * @returns Series with the highest value up to each bar
+ */
+export function max(source) {
+    const bars = source.bars;
+    return Series.fromArray(bars, taCore.max(source.toArray()));
+}
+/**
+ * All-time lowest value (PineScript ta.min)
+ * @param source - Source series
+ * @returns Series with the lowest value up to each bar
+ */
+export function min(source) {
+    const bars = source.bars;
+    return Series.fromArray(bars, taCore.min(source.toArray()));
+}
+/**
+ * Center of Gravity
+ * @param source - Source series
+ * @param length - Period length (default: 10)
+ * @returns Series with COG values
+ */
+export function cog(source, length = 10) {
+    const bars = source.bars;
+    const result = taCore.cog(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Mode (most frequent value)
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with mode values
+ */
+export function mode(source, length) {
+    const bars = source.bars;
+    const result = taCore.mode(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Percentile (linear interpolation)
+ * @param source - Source series
+ * @param length - Period length
+ * @param percentage - Percentile percentage
+ * @returns Series with percentile values
+ */
+export function percentile_linear_interpolation(source, length, percentage) {
+    const bars = source.bars;
+    const result = taCore.percentile_linear_interpolation(source.toArray(), length, percentage);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Percentile (nearest rank)
+ * @param source - Source series
+ * @param length - Period length
+ * @param percentage - Percentile percentage
+ * @returns Series with percentile values
+ */
+export function percentile_nearest_rank(source, length, percentage) {
+    const bars = source.bars;
+    const result = taCore.percentile_nearest_rank(source.toArray(), length, percentage);
+    return Series.fromArray(bars, result);
+}
+/**
+ * Rank Correlation Index
+ * @param source - Source series
+ * @param length - Period length
+ * @returns Series with RCI values
+ */
+export function rci(source, length) {
+    const bars = source.bars;
+    const result = taCore.rci(source.toArray(), length);
+    return Series.fromArray(bars, result);
+}
+// Export as namespace object to match PineScript ta.* syntax
+export const ta = {
+    sma,
+    ema,
+    wma,
+    vwma,
+    rma,
+    rsi,
+    macd,
+    bb,
+    stdev,
+    atr,
+    tr,
+    stoch,
+    crossover,
+    crossunder,
+    cross,
+    change,
+    mom,
+    roc,
+    highest,
+    lowest,
+    rising,
+    falling,
+    cum,
+    supertrend,
+    vwap,
+    ichimoku,
+    linreg,
+    alma,
+    zigzag,
+    cci,
+    sar,
+    dev,
+    variance,
+    median,
+    swma,
+    correlation,
+    percentrank,
+    mfi,
+    hma,
+    pivothigh,
+    pivotlow,
+    barssince,
+    valuewhen,
+    dmi,
+    tsi,
+    cmo,
+    kc,
+    bbw,
+    wpr,
+    kcw,
+    range,
+    highestbars,
+    lowestbars,
+    max,
+    min,
+    vwapBands,
+    obv,
+    pvt,
+    accdist,
+    nvi,
+    pvi,
+    iii,
+    wad,
+    wvad,
+    cog,
+    mode,
+    percentile_linear_interpolation,
+    percentile_nearest_rank,
+    rci,
+};
+//# sourceMappingURL=ta-series.js.map