oakscriptjs 0.11.0 → 0.11.1

package/src/ta/index.ts

@@ -11,7 +11,7 @@
 import type { series_float, series_bool, series_int, int, Source, simple_int, simple_float, simple_bool } from '../types/index.js';
 import { eq, ge, gt, le, lt } from '../compare/index.js';
 import { runningSum, runningSumSeries, runningVariance, runningVarianceSeries } from './running-sum.js';
-import { checkSumLength, checkWindowLength } from './limits.js';
+import { checkPositiveLength, checkSumLength, checkWindowLength } from './limits.js';
 
 /**
  * Simple Moving Average - returns the moving average (sum of last y values divided by y).
@@ -68,6 +68,7 @@ export function sma(source: Source, length: simple_int | ArrayLike<number>): ser
  * ```
  */
 export function ema(source: Source, length: simple_int): series_float {
+  checkPositiveLength('ema', length, 0);
   const result: series_float = [];
   const len = Math.floor(length);
   const multiplier = 2 / (len + 1);
@@ -133,7 +134,25 @@ export function ema(source: Source, length: simple_int): series_float {
  * const oversold = rsi14.map(v => v < 30);
  * ```
  */
-export function rsi(source: Source, length: simple_int): series_float {
+export function rsi(source: Source, length: simple_int): series_float;
+/**
+ * PineScript v4 `rsi(x, y)` with two series (#180): `x` and `y` are the averages of the upward and downward changes,
+ * already computed. As in PineScript: 100 when `y` is within 1e-10 of zero (also with an na `x`), else 0 when `x` is,
+ * else `100 - 100 / (1 + x / y)`, na when that divides by zero (`x == -y`). Versions 5 and 6 have the length form only.
+ */
+export function rsi(x: Source, y: Source): series_float;
+export function rsi(source: Source, length: simple_int | Source): series_float {
+  if (typeof length !== 'number') {
+    return Array.from(source, (xv, i) => {
+      const x = xv ?? NaN;
+      const y = length[i] ?? NaN;
+      if (eq(y, 0)) return 100;
+      if (eq(x, 0)) return 0;
+      const r = 100 - 100 / (1 + x / y);
+      return Number.isFinite(r) ? r : NaN;
+    });
+  }
+  checkPositiveLength('rsi', length, 0, 'y');
   const result: series_float = [];
 
   // Calculate price changes
@@ -506,6 +525,7 @@ export function crossunder(series1: Source, series2: Source): series_bool {
  * ```
  */
 export function change(source: Source, length: simple_int = 1): series_float {
+  checkPositiveLength('change', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -618,6 +638,7 @@ export function tr(
  * ```
  */
 export function atr(length: simple_int, high?: Source, low?: Source, close?: Source): series_float {
+  checkPositiveLength('atr->rma', length, 0);
   if (!high || !low || !close) {
     throw new Error(
       'ta.atr() requires high, low, and close series. ' +
@@ -763,6 +784,7 @@ export function supertrend(
  * ```
  */
 export function rma(source: Source, length: simple_int): series_float {
+  checkPositiveLength('rma', length, 0);
   const result: series_float = [];
   // Floor the length to match PineScript's auto-truncation of float to int
   const len = Math.floor(length);
@@ -846,6 +868,7 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
   const result: series_float = [];
   // Floor the length to match PineScript's auto-truncation of float to int
   const fixed = typeof length === 'number' ? Math.floor(length) : NaN;
+  if (typeof length === 'number') checkPositiveLength('wma', fixed, 0);
   // PineScript: na on a bar with an na source (also +/-Infinity) and until `len` non-na values were received;
   // otherwise the last `len` bars, each na replaced by the previous non-na value
   const filled: number[] = [];
@@ -861,6 +884,7 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
     filled.push(last);
     // a series length: the window of this bar's length (the result of ta.wma with that fixed length)
     const len = typeof length === 'number' ? fixed : Math.floor(length[i]!);
+    if (typeof length !== 'number') checkPositiveLength('wma', len, i);
     if (isNa || !(len >= 1) || count < len) {
       result.push(NaN);
       continue;
@@ -1022,6 +1046,7 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
  * ```
  */
 export function rising(source: Source, length: simple_int): series_bool {
+  checkPositiveLength('rising', length, 0);
   return monotonic(source, length, gt);
 }
 
@@ -1047,6 +1072,7 @@ export function rising(source: Source, length: simple_int): series_bool {
  * ```
  */
 export function falling(source: Source, length: simple_int): series_bool {
+  checkPositiveLength('falling', length, 0);
   return monotonic(source, length, lt);
 }
 
@@ -1072,6 +1098,7 @@ export function falling(source: Source, length: simple_int): series_bool {
  * ```
  */
 export function roc(source: Source, length: simple_int): series_float {
+  checkPositiveLength('roc', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -1112,6 +1139,7 @@ export function roc(source: Source, length: simple_int): series_float {
  * ```
  */
 export function mom(source: Source, length: simple_int): series_float {
+  checkPositiveLength('mom', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
@@ -1151,6 +1179,7 @@ export function mom(source: Source, length: simple_int): series_float {
  * ```
  */
 export function dev(source: Source, length: simple_int): series_float {
+  checkPositiveLength('dev', length, 0);
   const len = Math.floor(length);
   return sma(source, len).map((mean, i) => {
     if (i < len - 1 || Number.isNaN(mean)) return NaN;
@@ -1234,6 +1263,7 @@ function varianceOf(
  * ```
  */
 export function median(source: Source, length: simple_int): series_float {
+  checkPositiveLength('median', length, 0);
   const len = Math.floor(length);
   const n = source.length;
   const out: series_float = new Array<number>(n).fill(NaN);
@@ -1321,6 +1351,7 @@ export function swma(source: Source): series_float {
  * ```
  */
 export function vwma(source: Source, length: simple_int, volume?: Source): series_float {
+  checkPositiveLength('vwma->sma', length, 0);
   if (!volume) {
     throw new Error(
       'ta.vwma() requires volume series. ' +
@@ -1374,6 +1405,7 @@ export function vwma(source: Source, length: simple_int, volume?: Source): serie
  * ```
  */
 export function linreg(source: Source, length: simple_int, offset: simple_int = 0): series_float {
+  checkPositiveLength('linreg', length, 0);
   const result: series_float = [];
     // Floor the length to match PineScript's auto-truncation of float to int
     const len = Math.floor(length);
@@ -1443,6 +1475,7 @@ export function linreg(source: Source, length: simple_int, offset: simple_int =
  * ```
  */
 export function correlation(source1: Source, source2: Source, length: simple_int): series_float {
+  checkPositiveLength('correlation', length, 0);
   // PineScript: from compensated running sums, cov = sma(x * y) - sma(x) * sma(y), r = cov / sqrt(var(x) * var(y))
   // (biased variances); each running sum skips its own na values
   const product = Array.from({ length: source1.length }, (_, i) => {
@@ -1481,8 +1514,8 @@ export function correlation(source1: Source, source2: Source, length: simple_int
  *
  * PineScript rules:
  * - percentrank = count(source[k] <= source, k = 1..length) * 100 / length (in this order: the PineScript bits)
- * - a value from bar `length` on, when the current source is not `na`; an `na` value in the window counts as not
- *   `<=` the current value
+ * - a value from bar `length` on; an `na` value in the window counts as not `<=` the current value, and an `na`
+ *   current value gives 0 (#177)
  * - the comparison uses the 1e-10 tolerance
  *
  * @example
@@ -1493,15 +1526,16 @@ export function correlation(source1: Source, source2: Source, length: simple_int
  * ```
  */
 export function percentrank(source: Source, length: simple_int): series_float {
+  checkPositiveLength('percentrank', length, 0);
   const result: series_float = [];
 
   for (let i = 0; i < source.length; i++) {
     const currentValue = source[i]!;
-    if (i < length || Number.isNaN(currentValue)) {
+    if (i < length) {
       result.push(NaN);
       continue;
     }
-    // le() is false for an na value in the window
+    // le() is false for an na value in the window, and for all of them when the current value is na (0)
     let countLessOrEqual = 0;
     for (let j = 1; j <= length; j++) {
       if (le(source[i - j]!, currentValue)) countLessOrEqual++;
@@ -1541,6 +1575,7 @@ export function percentrank(source: Source, length: simple_int): series_float {
  * \`\`\`
  */
 export function cci(source: Source, length: simple_int): series_float {
+  checkPositiveLength('cci', length, 0);
   const smaValues = sma(source, length);
   const devValues = dev(source, length);
   let last = 0;
@@ -1577,6 +1612,7 @@ export function cci(source: Source, length: simple_int): series_float {
  * \`\`\`
  */
 export function stoch(source: Source, high: Source, low: Source, length: simple_int): series_float {
+  checkPositiveLength('stoch->highest', length, 0);
   const result: series_float = [];
   const lowestValues = lowest(low, length);
   const highestValues = highest(high, length);
@@ -1629,6 +1665,7 @@ export function stoch(source: Source, high: Source, low: Source, length: simple_
  * ```
  */
 export function mfi(source: Source, length: simple_int, volume?: Source): series_float {
+  checkPositiveLength('mfi', length, 0);
   if (!volume) {
     throw new Error(
       'ta.mfi() requires volume series. ' +
@@ -1687,6 +1724,7 @@ export function mfi(source: Source, length: simple_int, volume?: Source): series
  * ```
  */
 export function hma(source: Source, length: simple_int): series_float {
+  checkPositiveLength('hma', length, 0);
   const halfLength = Math.floor(length / 2);
   const sqrtLength = Math.floor(Math.sqrt(length));
 
@@ -2093,6 +2131,7 @@ export function dmi(
  * ```
  */
 export function tsi(source: Source, shortLength: simple_int, longLength: simple_int): series_float {
+  checkPositiveLength('tsi->ema', shortLength, 0);
   const momentum: series_float = [];
 
   // Calculate momentum (price change)
@@ -2142,6 +2181,7 @@ export function tsi(source: Source, shortLength: simple_int, longLength: simple_
  * ```
  */
 export function cmo(source: Source, length: simple_int): series_float {
+  checkPositiveLength('cmo', length, 0);
   // PineScript definition: mom = ta.change(src), sm1 = math.sum(mom >= 0 ? mom : 0, length),
   // sm2 = math.sum(mom >= 0 ? 0 : -mom, length), cmo = 100 * (sm1 - sm2) / (sm1 + sm2), with the running sums of
   // math.sum (bit for bit). A comparison with na is false: an na change adds 0 to sm1 and na (skipped) to sm2.
@@ -2191,6 +2231,7 @@ export function kc(
   low?: Source,
   close?: Source
 ): [series_float, series_float, series_float] {
+  checkPositiveLength('kc', length, 0);
   // Calculate middle band (EMA of source)
   const middle = ema(source, length);
 
@@ -2250,6 +2291,7 @@ export function kc(
  * ```
  */
 export function bbw(source: Source, length: simple_int, mult: simple_float): series_float {
+  checkPositiveLength('bbw', length, 0);
   const [basis, upper, lower] = bb(source, length, mult);
   const result: series_float = [];
 
@@ -2293,6 +2335,7 @@ export function bbw(source: Source, length: simple_int, mult: simple_float): ser
  * ```
  */
 export function wpr(high: Source, low: Source, close: Source, length: simple_int = 14): series_float {
+  checkPositiveLength('wpr', length, 0);
   const highs = highest(high, length);
   const lows = lowest(low, length);
   return Array.from({ length: close.length }, (_, i) => {
@@ -2393,6 +2436,7 @@ export function alma(
   sigma: simple_float = 6,
   floor: boolean = false
 ): series_float {
+  checkPositiveLength('alma', length, 0);
   const result: series_float = [];
     const m = floor ? Math.floor(offset * (length - 1)) : offset * (length - 1);
   const s = length / sigma;
@@ -2489,6 +2533,7 @@ export function kcw(
  * values), and a bar whose own value is `na` still gets a result.
  */
 export function range(source: Source, length: simple_int): series_float {
+  checkPositiveLength('range', length, 0);
   return source.map((_, i) => {
     const values = lastValues(source, i, length);
     return values ? Math.max(...values) - Math.min(...values) : NaN;
@@ -2574,6 +2619,7 @@ export function min(source: Source): series_float {
  * ```
  */
 export function cog(source: Source, length: simple_int = 10): series_float {
+  checkPositiveLength('cog', length, 0);
   const len = Math.floor(length);
   return runningSum(source, len).map((sum, i) => {
     if (i < len - 1 || Number.isNaN(sum) || sum === 0) return NaN;
@@ -2607,6 +2653,7 @@ export function cog(source: Source, length: simple_int = 10): series_float {
  * - If no mode exists, returns the smallest value
  */
 export function mode(source: Source, length: simple_int): series_float {
+  checkPositiveLength('mode', length, 0);
   const result: series_float = [];
   const len = Math.floor(length);
   const seen: number[] = []; // non-na values so far
@@ -2684,6 +2731,7 @@ export function percentile_linear_interpolation(
   length: simple_int,
   percentage: number
 ): series_float {
+  checkPositiveLength('percentile_linear_interpolation', length, 0);
   return sortedWindow(source, length, (s) => {
     const pos = (percentage / 100) * length - 0.5;
     if (pos <= 0) return s[0]!;
@@ -2753,6 +2801,7 @@ export function percentile_nearest_rank(
   length: simple_int,
   percentage: number
 ): series_float {
+  checkPositiveLength('percentile_nearest_rank', length, 0);
   const rank = Math.min(length, Math.max(1, Math.ceil((percentage / 100) * length)));
   return sortedWindow(source, length, (s) => s[rank - 1]!);
 }
@@ -2789,6 +2838,7 @@ export function percentile_nearest_rank(
  *   where the `na` was
  */
 export function rci(source: Source, length: simple_int): series_float {
+  checkPositiveLength('rci', length, 0);
   const len = Math.floor(length);
   const result: series_float = [];
   // PineScript keeps the values in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start
@@ -2852,31 +2902,42 @@ export function rci(source: Source, length: simple_int): series_float {
 }
 
 /**
- * Pivot Point Levels
+ * Pivot Point Levels (PineScript `ta.pivot_point_levels`).
  *
- * Calculates pivot point levels using various calculation methods.
- * Returns an array containing: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ * Returns 11 series: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5] (one value per bar in each).
  *
  * @param type - Calculation type: "Traditional", "Fibonacci", "Woodie", "Classic", "DM", "Camarilla"
- * @param anchor - Condition that triggers reset of calculations
- * @param developing - If true, pivots recalculate continuously; if false, use last anchor values
- * @param high - High price series (optional, uses context if not provided)
- * @param low - Low price series (optional, uses context if not provided)
- * @param close - Close price series (optional, uses context if not provided)
- * @param open - Open price series (optional, uses context if not provided)
- * @returns Array of 11 pivot levels
+ * @param anchor - Condition that starts a new period (`timeframe.change("W")`...)
+ * @param developing - false: the levels of the previous period, constant until the next anchor; true: the levels of
+ *   the current period so far, recalculated on each bar
+ * @param high - High price series
+ * @param low - Low price series
+ * @param close - Close price series
+ * @param open - Open price series (Woodie and DM)
+ * @returns 11 series of levels
  *
  * @example
  * ```typescript
  * const weekChange = [false, false, false, false, true, false, ...]; // Weekly anchor
- * const pivots = ta.pivot_point_levels("Traditional", weekChange, false, high, low, close);
- * // pivots[i]! = [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+ * const levels = ta.pivot_point_levels("Traditional", weekChange, false, high, low, close, open);
+ * // levels[0]![i] is P on bar i, levels[5]![i] is R3
  * ```
  *
  * @remarks
- * - Woodie type cannot use developing=true (will error in PineScript)
- * - DM type only calculates P, R1, S1 (other levels are NaN)
- * - All calculations follow PineScript v6 specifications
+ * As in PineScript (#177):
+ * - a period runs from an anchor bar to the bar before the next anchor; the bars before the first anchor are a
+ *   period too (from bar 0). The fixed levels use the high and low of the previous period and the close of the bar
+ *   before the anchor (na with an anchor on bar 0), and are na until the first anchor; the developing levels use
+ *   the current period's high and low and the bar's close, from bar 0
+ * - Traditional: R3 = P * 2 + (H - 2 * L), S3 = P * 2 - (2 * H - L), R4 = P * 3 + (H - 3 * L), S4 = P * 3 - (3 * H - L),
+ *   R5 = P * 4 + (H - 4 * L), S5 = P * 4 - (4 * H - L)
+ * - Fibonacci: P +- 0.382 / 0.618 / 1 * (H - L); R4 to S5 na
+ * - Classic: R3 / S3 = P +- 2 * (H - L), R4 / S4 = P +- 3 * (H - L); R5 / S5 na
+ * - Woodie: P = (H + L + 2 * open of the current period) / 4, R3 = H + 2 * (P - L), S3 = L - 2 * (H - P), R4 / S4 =
+ *   R3 + (H - L) / S3 - (H - L); R5 / S5 na. `developing` true throws (RE10128)
+ * - DM: x = H + 2 * L + C (C < open of the period), 2 * H + L + C (C > O) or H + L + 2 * C; P = x / 4,
+ *   R1 = x / 2 - L, S1 = x / 2 - H; the other levels na
+ * - Camarilla: C +- (H - L) * 1.1 / 12, / 6, / 4, / 2 for R1 to S4, R5 = (H / L) * C, S5 = 2 * C - R5
  */
 export function pivot_point_levels(
   type: series_float | string,
@@ -2887,183 +2948,96 @@ export function pivot_point_levels(
   close?: Source,
   open?: Source
 ): series_float[] {
-  // For simplicity, we need to handle the case where type is a string array
-  // But according to the docs, type is "series string", meaning it can change per bar
-  // For this implementation, we'll support constant type strings
-
   const typeStr = typeof type === 'string' ? type : String(type[0]);
-  const isDeveloping = typeof developing === 'boolean' ? developing : developing[0];
-
-  // Woodie cannot be developing
+  const isDeveloping = typeof developing === 'boolean' ? developing : Boolean(developing[0]);
   if (typeStr === 'Woodie' && isDeveloping) {
-    throw new Error('ta.pivot_point_levels: Woodie type cannot use developing=true');
+    throw new Error(
+      'Error on bar 0: The `developing` parameter of the `ta.pivot_point_levels()` cannot be `true` when `type` is "Woodie".'
+    );
   }
-
-  // Ensure all series have the same length
-  const length = anchor.length;
-  if (high && high.length !== length) throw new Error('High series length mismatch');
-  if (low && low.length !== length) throw new Error('Low series length mismatch');
-  if (close && close.length !== length) throw new Error('Close series length mismatch');
-  if (open && open.length !== length) throw new Error('Open series length mismatch');
-
-  // Initialize result arrays for all 11 levels
-  const results: series_float[] = Array.from({ length: 11 }, () => []);
-
-  // Track the last anchor point data
-  let lastH = NaN, lastL = NaN, lastC = NaN, lastO = NaN;
-  let lastAnchorIndex = -1;
-
-  for (let i = 0; i < length; i++) {
-    // Check if anchor triggered
-    if (anchor[i]!) {
-      lastAnchorIndex = i;
-      // Store OHLC at anchor point (these will be used for calculations)
-      lastH = high ? high[i]! : NaN;
-      lastL = low ? low[i]! : NaN;
-      lastC = close ? close[i]! : NaN;
-      lastO = open ? open[i]! : NaN;
-    }
-
-    // Calculate data to use
-    let h: number, l: number, c: number, o: number;
-
-    if (isDeveloping && lastAnchorIndex >= 0) {
-      // Developing: use max/min/last since anchor
-      h = high ? Math.max(...high.slice(lastAnchorIndex, i + 1).filter(v => !isNaN(v))) : NaN;
-      l = low ? Math.min(...low.slice(lastAnchorIndex, i + 1).filter(v => !isNaN(v))) : NaN;
-      c = close ? close[i]! : NaN;
-      o = open && lastAnchorIndex >= 0 ? open[lastAnchorIndex]! : NaN;
-    } else {
-      // Not developing: use last anchor values
-      h = lastH;
-      l = lastL;
-      c = lastC;
-      o = lastO;
-    }
-
-    // Calculate pivot levels based on type
-    const levels = calculatePivotLevels(typeStr, h, l, c, o);
-
-    // Push to results
-    for (let j = 0; j < 11; j++) {
-      results[j]!.push(levels[j]!);
-    }
+  const n = anchor.length;
+  for (const [s, name] of [[high, 'High'], [low, 'Low'], [close, 'Close'], [open, 'Open']] as const) {
+    if (s && s.length !== n) throw new Error(`${name} series length mismatch`);
+  }
+  const at = (s: Source | undefined, i: number): number => (s ? (s[i] ?? NaN) : NaN);
+  const results: series_float[] = Array.from({ length: 11 }, () => new Array<number>(n));
+  // the current period (from bar 0 until the first anchor) and the previous one
+  let curH = NaN, curL = NaN, curO = NaN;
+  let prevH = NaN, prevL = NaN, prevC = NaN, prevO = NaN;
+  let anchored = false;
+  for (let i = 0; i < n; i++) {
+    const h = at(high, i), l = at(low, i);
+    if (i === 0) {
+      // the first period starts on bar 0: an anchor there makes bar 0 its own previous period
+      curH = h;
+      curL = l;
+      curO = at(open, i);
+    }
+    if (anchor[i]) {
+      prevH = curH;
+      prevL = curL;
+      prevC = i > 0 ? at(close, i - 1) : NaN;
+      prevO = curO;
+      curH = h;
+      curL = l;
+      curO = at(open, i);
+      anchored = true;
+    } else if (i > 0) {
+      if (h > curH || Number.isNaN(curH)) curH = h;
+      if (l < curL || Number.isNaN(curL)) curL = l;
+    }
+    const levels = isDeveloping
+      ? pivotLevels(typeStr, curH, curL, at(close, i), curO, at(close, i))
+      : anchored
+        ? pivotLevels(typeStr, prevH, prevL, prevC, prevO, curO)
+        : NA_LEVELS;
+    for (let k = 0; k < 11; k++) results[k]![i] = levels[k]!;
   }
-
   return results;
 }
 
+const NA_LEVELS: readonly number[] = new Array<number>(11).fill(NaN);
+
 /**
- * Helper function to calculate pivot levels
+ * The 11 levels of one bar, in PineScript's operation order (bit for bit). `o` is the open of the period (DM),
+ * `wo` the close term of Woodie (the open of the current period, or the bar's close while developing).
  */
-function calculatePivotLevels(
-  type: string,
-  h: number,
-  l: number,
-  c: number,
-  o: number
-): number[] {
-  // Return NaN array if data is insufficient
-  if (isNaN(h) || isNaN(l) || isNaN(c)) {
-    return Array(11).fill(NaN);
-  }
-
-  const levels: number[] = Array(11).fill(NaN);
-
-  // Calculate pivot point (P)
-  let P: number;
-
-  switch (type) {
-    case 'Traditional':
-    case 'Fibonacci':
-    case 'Classic':
-      P = (h + l + c) / 3;
-      break;
-    case 'Woodie':
-      P = (h + l + 2 * c) / 4;
-      break;
-    case 'DM':
-      P = (h + l + c) / 3;
-      break;
-    case 'Camarilla':
-      P = (h + l + c) / 3;
-      break;
-    default:
-      P = (h + l + c) / 3;
-  }
-
-  levels[0] = P; // P is at index 0
-
-  // Calculate resistance and support levels based on type
+function pivotLevels(type: string, h: number, l: number, c: number, o: number, wo: number): readonly number[] {
+  const N = NaN;
+  const r = h - l;
   switch (type) {
-    case 'Traditional':
-    case 'Classic':
-      levels[1] = 2 * P - l;  // R1
-      levels[2] = 2 * P - h;  // S1
-      levels[3] = P + (h - l);  // R2
-      levels[4] = P - (h - l);  // S2
-      levels[5] = h + 2 * (P - l);  // R3
-      levels[6] = l - 2 * (h - P);  // S3
-      levels[7] = levels[5] + (h - l);  // R4
-      levels[8] = levels[6] - (h - l);  // S4
-      levels[9] = levels[7] + (h - l);  // R5
-      levels[10] = levels[8] - (h - l);  // S5
-      break;
-
-    case 'Fibonacci':
-      levels[1] = P + 0.382 * (h - l);  // R1
-      levels[2] = P - 0.382 * (h - l);  // S1
-      levels[3] = P + 0.618 * (h - l);  // R2
-      levels[4] = P - 0.618 * (h - l);  // S2
-      levels[5] = P + (h - l);  // R3
-      levels[6] = P - (h - l);  // S3
-      levels[7] = levels[5] + 0.618 * (h - l);  // R4
-      levels[8] = levels[6] - 0.618 * (h - l);  // S4
-      levels[9] = levels[7] + 0.382 * (h - l);  // R5
-      levels[10] = levels[8] - 0.382 * (h - l);  // S5
-      break;
-
-    case 'Woodie':
-      levels[1] = 2 * P - l;  // R1
-      levels[2] = 2 * P - h;  // S1
-      levels[3] = P + (h - l);  // R2
-      levels[4] = P - (h - l);  // S2
-      levels[5] = h + 2 * (P - l);  // R3
-      levels[6] = l - 2 * (h - P);  // S3
-      levels[7] = levels[5] + (h - l);  // R4
-      levels[8] = levels[6] - (h - l);  // S4
-      levels[9] = levels[7] + (h - l);  // R5
-      levels[10] = levels[8] - (h - l);  // S5
-      break;
-
+    case 'Traditional': {
+      const p = (h + l + c) / 3;
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, p * 2 + (h - 2 * l), p * 2 - (2 * h - l), p * 3 + (h - 3 * l),
+        p * 3 - (3 * h - l), p * 4 + (h - 4 * l), p * 4 - (4 * h - l)];
+    }
+    case 'Fibonacci': {
+      const p = (h + l + c) / 3;
+      return [p, p + 0.382 * r, p - 0.382 * r, p + 0.618 * r, p - 0.618 * r, p + 1 * r, p - 1 * r, N, N, N, N];
+    }
+    case 'Classic': {
+      const p = (h + l + c) / 3;
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, p + 2 * r, p - 2 * r, p + 3 * r, p - 3 * r, N, N];
+    }
+    case 'Woodie': {
+      const p = (h + l + 2 * wo) / 4;
+      const r3 = h + 2 * (p - l);
+      const s3 = l - 2 * (h - p);
+      return [p, 2 * p - l, 2 * p - h, p + r, p - r, r3, s3, r3 + r, s3 - r, N, N];
+    }
     case 'DM': {
-      // DM (Demark) only calculates P, R1, S1
-      const x = h + l + (c * 2) + (isNaN(o) ? c : o);
-      const newP = x / (isNaN(o) ? 4 : 5);
-      levels[0] = newP;
-      levels[1] = x / 2 - l;  // R1
-      levels[2] = x / 2 - h;  // S1
-      // R2-S5 remain NaN
-      break;
+      const x = c < o ? h + 2 * l + c : c > o ? 2 * h + l + c : h + l + 2 * c;
+      return [x / 4, x / 2 - l, x / 2 - h, N, N, N, N, N, N, N, N];
     }
-
     case 'Camarilla': {
-      const range = h - l;
-      levels[1] = c + range * 1.1 / 12;  // R1
-      levels[2] = c - range * 1.1 / 12;  // S1
-      levels[3] = c + range * 1.1 / 6;   // R2
-      levels[4] = c - range * 1.1 / 6;   // S2
-      levels[5] = c + range * 1.1 / 4;   // R3
-      levels[6] = c - range * 1.1 / 4;   // S3
-      levels[7] = c + range * 1.1 / 2;   // R4
-      levels[8] = c - range * 1.1 / 2;   // S4
-      levels[9] = h;  // R5 (high)
-      levels[10] = l; // S5 (low)
-      break;
+      const p = (h + l + c) / 3;
+      const r5 = (h / l) * c;
+      return [p, c + (r * 1.1) / 12, c - (r * 1.1) / 12, c + (r * 1.1) / 6, c - (r * 1.1) / 6, c + (r * 1.1) / 4,
+        c - (r * 1.1) / 4, c + (r * 1.1) / 2, c - (r * 1.1) / 2, r5, 2 * c - r5];
     }
+    default:
+      return NA_LEVELS;
   }
-
-  return levels;
 }
 
 /**

package/src/ta/limits.ts

@@ -37,11 +37,38 @@ export function windowError(name: string, length: number, bar?: number, max = MA
 /** Throws RE10004 when the (truncated) length of a window function is above the limit. */
 export function checkWindowLength(name: string, length: number, bar?: number, max = MAX_WINDOW_LENGTH): void {
   const len = Math.trunc(length);
+  if (len <= 0) throw new Error(lengthError(name, len, bar));
   if (len > max) throw new Error(windowError(name, len, bar, max));
 }
 
 /** Throws RE10004 for a function of {@link SUM_FUNCTIONS} ("ta.sma", ...) with a length above 5,000. */
 export function checkSumLength(name: string, length: number, bar?: number): void {
   const fn = SUM_FUNCTIONS[name];
-  if (fn !== undefined) checkWindowLength(fn, length, bar, MAX_SUM_LENGTH);
+  if (fn === undefined) return;
+  // RE10001 names 'bb' itself, RE10004 its inner 'sma'
+  checkPositiveLength(name === 'ta.bb' ? 'bb' : fn, length, bar);
+  checkWindowLength(fn, length, bar, MAX_SUM_LENGTH);
+}
+
+/**
+ * PineScript's runtime error RE10001 text for a length that is 0 or negative. `name` is the function, or a call path
+ * "atr->rma" (printed 'atr'->'rma'); the value prints as a float ("0.0", "-1.0").
+ */
+export function lengthError(name: string, value: number, bar?: number, arg = 'length'): string {
+  const fn = name.split('->').map((part) => `'${part}'`).join('->');
+  const text = Number.isInteger(value) ? value.toFixed(1) : String(value);
+  return (
+    (bar === undefined ? '' : `Error on bar ${bar}: `) +
+    `Invalid value of the '${arg}' argument (${text}) in the ${fn} function. It must be > 0.`
+  );
+}
+
+/**
+ * Throws RE10001 when the (truncated) length is 0 or negative, as PineScript does for every window function on the
+ * bar of the call (#175): `ta.sma(close, 0)` stops on bar 0, a series length that becomes 0 on the bar where it
+ * does. `ta.hma(src, 1)` stops in its inner `wma(src, 0)`. An na length is not checked here.
+ */
+export function checkPositiveLength(name: string, length: number, bar?: number, arg = 'length'): void {
+  const len = Math.trunc(length);
+  if (len <= 0) throw new Error(lengthError(name, len, bar, arg));
 }