oakscriptjs 0.10.1 → 0.11.1

package/src/ta/index.ts

@@ -11,6 +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 { checkPositiveLength, checkSumLength, checkWindowLength } from './limits.js';
 
 /**
  * Simple Moving Average - returns the moving average (sum of last y values divided by y).
@@ -42,6 +43,7 @@ export function sma(source: Source, length: simple_int | ArrayLike<number>): ser
   }
   // Floor the length to match PineScript's auto-truncation of float to int
   const len = Math.floor(length);
+  checkSumLength('ta.sma', len, 0);
   return runningSum(source, len).map((sum) => sum / len);
 }
 
@@ -66,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);
@@ -131,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
@@ -234,6 +255,7 @@ export function bb(
   length: simple_int,
   mult: simple_float
 ): [series_float, series_float, series_float] {
+  checkSumLength('ta.bb', length, 0);
   const basis = sma(series, length);
   const dev = stdev(series, length);
 
@@ -285,14 +307,20 @@ function lastValues(source: Source, i: number, length: number): number[] | null
 
 /**
  * The extreme of the window of `length` bars ending at each bar, in one pass (monotonic deque): the bar index of
- * the oldest highest (or lowest) value, or -1 when the window is empty. As PineScript does for ta.highest /
- * ta.lowest / ta.highestbars / ta.lowestbars, the window stops at the first `na` value going back, so a bar whose
- * own value is `na` has an empty window. `zeros[i]` tells whether the window holds a +0 (highest) or a -0
- * (lowest), the zero that `Math.max` / `Math.min` return when the extreme is 0.
+ * the oldest highest (or lowest) value (the newest one with `newest`), or -1 when the window is empty. The window
+ * stops at the first `na` value going back (the callers pass the non-na values only, see {@link keptValues}), and a
+ * fractional length is truncated (7.5 is 7 bars), as PineScript does.
+ * `zeros[i]` tells whether the window holds a +0 (highest) or a -0 (lowest), the zero that `Math.max` / `Math.min`
+ * return when the extreme is 0 (not kept with `newest`).
  */
-function windowExtremes(source: Source, length: number, lowest: boolean): { at: Int32Array; zeros: Uint8Array } {
+function windowExtremes(
+  source: Source,
+  length: number,
+  lowest: boolean,
+  newest = false
+): { at: Int32Array; zeros: Uint8Array } {
   const n = source.length;
-  const span = length > 0 ? Math.ceil(length) : 0; // the bars j = 0, 1... with j < length
+  const span = length > 0 ? Math.trunc(length) : 0; // PineScript casts the length to int
   const at = new Int32Array(n).fill(-1);
   const zeros = new Uint8Array(n);
   const queue = new Int32Array(n); // bar indices; values from best to worst, the oldest first among equal values
@@ -310,8 +338,10 @@ function windowExtremes(source: Source, length: number, lowest: boolean): { at:
       zeroCount = 0;
       continue;
     }
-    // drop the values that the new one beats; equal values stay (the oldest wins ties)
-    while (tail > head && (lowest ? source[queue[tail - 1]!]! > x : source[queue[tail - 1]!]! < x)) {
+    // drop the values that the new one beats; equal values stay (the oldest wins ties), or go with `newest`
+    while (tail > head) {
+      const last = source[queue[tail - 1]!]!;
+      if (!(lowest ? last > x : last < x) && !(newest && last === x)) break;
       if (isPreferredZero(queue[--tail]!)) zeroCount--;
     }
     queue[tail++] = i;
@@ -328,20 +358,79 @@ function windowExtremes(source: Source, length: number, lowest: boolean): { at:
   return { at, zeros };
 }
 
-/** Offset of the best value of the window; on ties the oldest bar wins. 0 when the window is empty. */
-function extremeOffset(source: Source, length: simple_int, lowest: boolean): series_int {
-  const { at } = windowExtremes(source, length, lowest);
-  // -(i - at): -0 when the extreme is the current bar, as the offset -j of the window scan
-  return source.map((_, i) => (i < length - 1 ? NaN : at[i]! < 0 ? 0 : -(i - at[i]!)));
+/**
+ * The non-na values of `source` with their bars, and for each bar the position of its last non-na value (-1 when
+ * there is none yet). PineScript's ta.highest / ta.lowest / ta.highestbars / ta.lowestbars / ta.pivothigh /
+ * ta.pivotlow keep the non-na values they receive and nothing else.
+ */
+function keptValues(source: Source): { values: number[]; bars: number[]; last: Int32Array } {
+  const values: number[] = [];
+  const bars: number[] = [];
+  const last = new Int32Array(source.length);
+  for (let i = 0; i < source.length; i++) {
+    const x = source[i]!;
+    if (!Number.isNaN(x)) {
+      values.push(x);
+      bars.push(i);
+    }
+    last[i] = values.length - 1;
+  }
+  return { values, bars, last };
+}
+
+/**
+ * ta.highest / ta.lowest / ta.highestbars / ta.lowestbars with a series length (a length per bar): on each bar the
+ * best of the last `length[i]` non-na values (the newest one on ties), na before bar `length[i] - 1`, as PineScript
+ * (measured with a length that changes on each bar, with and without na in the source).
+ */
+function extremeSeriesLength(source: Source, lengths: ArrayLike<number>, lowest: boolean, offsets: boolean): number[] {
+  const name = (lowest ? 'lowest' : 'highest') + (offsets ? 'bars' : '');
+  const { values, bars, last } = keptValues(source);
+  return Array.from(source, (_, i) => {
+    const len = Math.trunc(lengths[i]!);
+    checkWindowLength(name, len, i);
+    const k = last[i]!;
+    if (!(len >= 1) || i < len - 1 || k < 0) return NaN;
+    let best = k;
+    for (let j = k - 1; j >= 0 && j > k - len; j--) {
+      if (lowest ? values[j]! < values[best]! : values[j]! > values[best]!) best = j;
+    }
+    return offsets ? -(i - bars[best]!) : values[best]!;
+  });
+}
+
+/**
+ * Offset to the best of the last `length` non-na values (the newest one on ties): the distance in bars, so below
+ * `-(length - 1)` after an na value. na before bar `length - 1` and while there is no value.
+ */
+function extremeOffset(source: Source, length: simple_int | ArrayLike<number>, lowest: boolean): series_int {
+  if (typeof length !== 'number') return extremeSeriesLength(source, length, lowest, true);
+  checkWindowLength(lowest ? 'lowestbars' : 'highestbars', length, 0);
+  const { values, bars, last } = keptValues(source);
+  const { at } = windowExtremes(values, length, lowest, true);
+  const len = Math.trunc(length);
+  // -(i - bar): -0 when the extreme is the current bar, as the offset -j of the window scan
+  return source.map((_, i) => {
+    const k = last[i]!;
+    return i < len - 1 || k < 0 || at[k]! < 0 ? NaN : -(i - bars[at[k]!]!);
+  });
 }
 
-/** Best value of the window (`na` when the window is empty), with the zero sign of `Math.max` / `Math.min`. */
-function extremeValue(source: Source, length: simple_int, lowest: boolean): series_float {
-  const { at, zeros } = windowExtremes(source, length, lowest);
+/**
+ * Best of the last `length` non-na values (of all of them when there are fewer), with the zero sign of `Math.max` /
+ * `Math.min`. na before bar `length - 1` and while there is no value.
+ */
+function extremeValue(source: Source, length: simple_int | ArrayLike<number>, lowest: boolean): series_float {
+  if (typeof length !== 'number') return extremeSeriesLength(source, length, lowest, false);
+  checkWindowLength(lowest ? 'lowest' : 'highest', length, 0);
+  const { values, last } = keptValues(source);
+  const { at, zeros } = windowExtremes(values, length, lowest);
+  const len = Math.trunc(length);
   return source.map((_, i) => {
-    if (i < length - 1 || at[i]! < 0) return NaN;
-    const v = source[at[i]!]!;
-    return v === 0 && zeros[i] ? (lowest ? -0 : 0) : v;
+    const k = last[i]!;
+    if (i < len - 1 || k < 0 || at[k]! < 0) return NaN;
+    const v = values[at[k]!]!;
+    return v === 0 && zeros[k] ? (lowest ? -0 : 0) : v;
   });
 }
 
@@ -436,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++) {
@@ -548,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. ' +
@@ -693,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);
@@ -763,6 +855,8 @@ function wmaAdd(a: number, b: number): number {
  * - Summed from the oldest value to the newest; as PineScript, a partial sum `s + t` with
  *   `|s + t| <= 1e-10 * max(1, |s| + |t|)` is 0 (a cancellation residue, or values below 1e-10)
  * - More responsive to recent price changes than SMA
+ * - `length` can be an array (a length per bar, PineScript series length): each bar gives the result of its own
+ *   length (`na` for a length below 1)
  *
  * @example
  * ```typescript
@@ -770,10 +864,11 @@ function wmaAdd(a: number, b: number): number {
  * // WMA gives more weight to recent prices
  * ```
  */
-export function wma(source: Source, length: simple_int): series_float {
+export function wma(source: Source, length: simple_int | ArrayLike<number>): series_float {
   const result: series_float = [];
   // Floor the length to match PineScript's auto-truncation of float to int
-  const len = Math.floor(length);
+  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[] = [];
@@ -787,7 +882,10 @@ export function wma(source: Source, length: simple_int): series_float {
       count++;
     }
     filled.push(last);
-    if (isNa || count < len) {
+    // 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;
     }
@@ -812,11 +910,15 @@ export function wma(source: Source, length: simple_int): series_float {
  * @returns Highest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * As in PineScript: an `na` value ends the window, so only the values after the last `na`
- * count, and a bar whose own value is `na` gives `na`.
+ * As in PineScript: `na` values are skipped. The result is the highest of the last `length` non-na values (of all
+ * of them when there are fewer), also on a bar whose own value is `na`; `na` before bar `length - 1` and while no
+ * value was received. A fractional length is truncated (7.5 is 7 bars).
+ * `length` can be an array (a length per bar, PineScript series length), also for `ta.lowest`, `ta.highestbars`
+ * and `ta.lowestbars`: each bar uses its own length.
+ * A length above 15,000 throws the PineScript runtime error (also `ta.lowest`, `ta.highestbars`, `ta.lowestbars`).
  * PineScript `ta.highest(length)` (source = high) is `ta.highest(length)` in the script API.
  */
-export function highest(source: Source, length: simple_int): series_float {
+export function highest(source: Source, length: simple_int | ArrayLike<number>): series_float {
   return extremeValue(source, length, false);
 }
 
@@ -828,10 +930,11 @@ export function highest(source: Source, length: simple_int): series_float {
  * @returns Lowest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * As in PineScript: an `na` value ends the window, so only the values after the last `na`
- * count, and a bar whose own value is `na` gives `na`.
+ * As in PineScript: `na` values are skipped. The result is the lowest of the last `length` non-na values (of all
+ * of them when there are fewer), also on a bar whose own value is `na`; `na` before bar `length - 1` and while no
+ * value was received.
  */
-export function lowest(source: Source, length: simple_int): series_float {
+export function lowest(source: Source, length: simple_int | ArrayLike<number>): series_float {
   return extremeValue(source, length, true);
 }
 
@@ -943,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);
 }
 
@@ -968,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);
 }
 
@@ -993,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++) {
@@ -1033,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++) {
@@ -1072,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;
@@ -1127,6 +1235,7 @@ function varianceOf(
     return biased ? result : result.map((v, i) => (Math.floor(length[i]!) > 1 ? v : NaN));
   }
   const len = Math.floor(length);
+  checkSumLength(name, len, 0);
   // PineScript: the last `len` non-na values (also +/-Infinity skipped), as ta.sma
   if ((biased ? len : len - 1) <= 0) return source.map(() => NaN);
   return runningVariance(source, len, biased);
@@ -1154,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);
@@ -1241,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. ' +
@@ -1294,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);
@@ -1363,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) => {
@@ -1401,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
@@ -1413,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++;
@@ -1461,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;
@@ -1497,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);
@@ -1549,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. ' +
@@ -1607,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));
 
@@ -1738,35 +1856,31 @@ export function sar(
   return result;
 }
 
+/** A pivot length: one value, or a value per bar (PineScript series length). */
+type PivotLength = simple_int | ArrayLike<number>;
+
 /**
  * Pivot detection as PineScript computes it.
  *
- * The value of the pivot bar is returned `rightbars` bars later, on the bar where the pivot is
- * confirmed, so no future bar is used. A pivot high may equal values on its left but must be higher
- * than every value on its right (a pivot low: equal on the left, lower on the right). An `na`
- * neighbour ends the check on its side; an `na` pivot value gives no pivot.
- */
-function pivot(source: Source, leftbars: simple_int, rightbars: simple_int, isHigh: boolean): series_float {
-  // "beats" = the neighbour prevents the pivot
-  const beatsLeft = isHigh ? (x: number, v: number) => x > v : (x: number, v: number) => x < v;
-  const beatsRight = isHigh ? (x: number, v: number) => x >= v : (x: number, v: number) => x <= v;
-
-  return source.map((_, i) => {
-    const center = i - rightbars;
-    if (center - leftbars < 0) return NaN;
-    const v = source[center]!;
-    if (Number.isNaN(v)) return NaN;
-    for (let j = 1; j <= leftbars; j++) {
-      const x = source[center - j]!;
-      if (Number.isNaN(x)) break;
-      if (beatsLeft(x, v)) return NaN;
-    }
-    for (let j = 1; j <= rightbars; j++) {
-      const x = source[center + j]!;
-      if (Number.isNaN(x)) break;
-      if (beatsRight(x, v)) return NaN;
-    }
-    return v;
+ * The function keeps the non-na values it receives. On each bar it takes the last `leftbars + rightbars + 1` of them
+ * (all of them when there are fewer) and finds the highest (the newest one on equal values; the lowest for a pivot
+ * low): there is a pivot when that value is on the bar `rightbars` bars back, and its value is returned on this bar,
+ * so no future bar is used. A pivot high may so equal values on its left but must be higher than every value on its
+ * right. `na` before bar `leftbars + rightbars`.
+ */
+function pivot(source: Source, leftbars: PivotLength, rightbars: PivotLength, isHigh: boolean): series_float {
+  const { values, bars, last } = keptValues(source);
+  return Array.from(source, (_, i) => {
+    // a series length: the lengths of the current bar
+    const left = Math.trunc(typeof leftbars === 'number' ? leftbars : leftbars[i]!);
+    const right = Math.trunc(typeof rightbars === 'number' ? rightbars : rightbars[i]!);
+    const k = last[i]!;
+    if (!(i >= left + right) || k < 0) return NaN;
+    let best = k;
+    for (let j = k - 1; j >= 0 && j >= k - left - right; j--) {
+      if (isHigh ? values[j]! > values[best]! : values[j]! < values[best]!) best = j;
+    }
+    return bars[best] === i - right ? values[best]! : NaN;
   });
 }
 
@@ -1784,7 +1898,10 @@ function pivot(source: Source, leftbars: simple_int, rightbars: simple_int, isHi
  * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
  *   index is `i - rightbars`
  * - A pivot high may equal values on its left but must be higher than all values on its right
- * - An `na` neighbour ends the check on its side
+ * - `na` values are skipped: the window is the last `leftbars + rightbars + 1` non-na values, and the highest of
+ *   them must be on the bar `rightbars` bars back
+ * - `leftbars` / `rightbars` can be arrays (a length per bar, PineScript series length), also for `ta.pivotlow`:
+ *   each bar uses its own lengths
  *
  * @example
  * ```typescript
@@ -1794,8 +1911,8 @@ function pivot(source: Source, leftbars: simple_int, rightbars: simple_int, isHi
  */
 export function pivothigh(
   sourceOrLeftbars: Source | simple_int,
-  leftbarsOrRightbars: simple_int,
-  rightbars?: simple_int,
+  leftbarsOrRightbars: PivotLength,
+  rightbars?: PivotLength,
   high?: Source
 ): series_float {
   if (rightbars === undefined) {
@@ -1821,7 +1938,8 @@ export function pivothigh(
  * - As in PineScript, the value appears `rightbars` bars after the pivot bar: the pivot bar
  *   index is `i - rightbars`
  * - A pivot low may equal values on its left but must be lower than all values on its right
- * - An `na` neighbour ends the check on its side
+ * - `na` values are skipped: the window is the last `leftbars + rightbars + 1` non-na values, and the lowest of
+ *   them must be on the bar `rightbars` bars back
  *
  * @example
  * ```typescript
@@ -1831,8 +1949,8 @@ export function pivothigh(
  */
 export function pivotlow(
   sourceOrLeftbars: Source | simple_int,
-  leftbarsOrRightbars: simple_int,
-  rightbars?: simple_int,
+  leftbarsOrRightbars: PivotLength,
+  rightbars?: PivotLength,
   low?: Source
 ): series_float {
   if (rightbars === undefined) {
@@ -2013,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)
@@ -2062,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.
@@ -2111,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);
 
@@ -2170,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 = [];
 
@@ -2213,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) => {
@@ -2313,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;
@@ -2409,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;
@@ -2420,10 +2545,11 @@ export function range(source: Source, length: simple_int): series_float {
  * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
  *
  * @remarks
- * As in PineScript: on equal values the oldest bar wins; an `na` value ends the window;
- * 0 when the window has no value.
+ * As in PineScript: the best of the last `length` non-na values, the newest one on equal values; the offset is the
+ * distance in bars to its bar, so it is below `-(length - 1)` when `na` values were skipped. `na` before bar
+ * `length - 1` and while no value was received; a fractional length is truncated.
  */
-export function highestbars(source: Source, length: simple_int): series_int {
+export function highestbars(source: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, false);
 }
 
@@ -2432,10 +2558,11 @@ export function highestbars(source: Source, length: simple_int): series_int {
  * -1 for the previous bar, and so on (as in PineScript, the offset is negative).
  *
  * @remarks
- * As in PineScript: on equal values the oldest bar wins; an `na` value ends the window;
- * 0 when the window has no value.
+ * As in PineScript: the best of the last `length` non-na values, the newest one on equal values; the offset is the
+ * distance in bars to its bar, so it is below `-(length - 1)` when `na` values were skipped. `na` before bar
+ * `length - 1` and while no value was received; a fractional length is truncated.
  */
-export function lowestbars(source: Source, length: simple_int): series_int {
+export function lowestbars(source: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, true);
 }
 
@@ -2492,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;
@@ -2525,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
@@ -2602,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]!;
@@ -2671,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]!);
 }
@@ -2707,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
@@ -2770,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,
@@ -2805,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;
 }
 
 /**