oakscriptjs 0.10.1 → 0.11.1

package/dist/esm/ta/index.js

@@ -9,6 +9,7 @@
  */
 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).
  *
@@ -39,6 +40,7 @@ export function sma(source, length) {
     }
     // 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);
 }
 /**
@@ -62,6 +64,7 @@ export function sma(source, length) {
  * ```
  */
 export function ema(source, length) {
+    checkPositiveLength('ema', length, 0);
     const result = [];
     const len = Math.floor(length);
     const multiplier = 2 / (len + 1);
@@ -99,32 +102,20 @@ export function ema(source, length) {
     }
     return result;
 }
-/**
- * Relative Strength Index - momentum oscillator measuring speed and magnitude of price changes.
- *
- * @param source - Series of values to process
- * @param length - Number of bars (length)
- * @returns RSI series (values range from 0 to 100)
- *
- * @remarks
- * - RSI values above 70 typically indicate overbought conditions
- * - RSI values below 30 typically indicate oversold conditions
- * - Uses `ta.rma()` (Relative Moving Average) for smoothing, matching PineScript v6
- * - Formula: RSI = 100 - (100 / (1 + RS)), where RS = Average Gain / Average Loss
- * - As in PineScript (`down == 0 ? 100 : up == 0 ? 0 : ...`): 100 when the average loss is 0, else 0 when the
- *   average gain is 0, both with the 1e-10 tolerance of the comparison operators
- * - Average Gain and Average Loss are calculated using RMA (alpha = 1 / length)
- * - `na` values in the source series are ignored
- *
- * @example
- * ```typescript
- * const rsi14 = ta.rsi(closePrices, 14);
- * // Identify overbought/oversold conditions
- * const overbought = rsi14.map(v => v > 70);
- * const oversold = rsi14.map(v => v < 30);
- * ```
- */
 export function rsi(source, length) {
+    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 = [];
     // Calculate price changes
     const changes = [];
@@ -208,6 +199,7 @@ export function macd(source, fastLength, slowLength, signalLength) {
  * ```
  */
 export function bb(series, length, mult) {
+    checkSumLength('ta.bb', length, 0);
     const basis = sma(series, length);
     const dev = stdev(series, length);
     const upper = [];
@@ -250,14 +242,15 @@ function lastValues(source, i, length) {
 }
 /**
  * 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, length, lowest) {
+function windowExtremes(source, length, lowest, newest = false) {
     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
@@ -275,8 +268,11 @@ function windowExtremes(source, length, lowest) {
             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--;
         }
@@ -295,20 +291,81 @@ function windowExtremes(source, length, lowest) {
     }
     return { at, zeros };
 }
-/** Offset of the best value of the window; on ties the oldest bar wins. 0 when the window is empty. */
+/**
+ * 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) {
+    const values = [];
+    const bars = [];
+    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, lengths, lowest, offsets) {
+    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, length, lowest) {
-    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])));
+    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`. */
+/**
+ * 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, length, lowest) {
-    const { at, zeros } = windowExtremes(source, length, lowest);
+    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)
+        const k = last[i];
+        if (i < len - 1 || k < 0 || at[k] < 0)
             return NaN;
-        const v = source[at[i]];
-        return v === 0 && zeros[i] ? (lowest ? -0 : 0) : v;
+        const v = values[at[k]];
+        return v === 0 && zeros[k] ? (lowest ? -0 : 0) : v;
     });
 }
 /**
@@ -395,6 +452,7 @@ export function crossunder(series1, series2) {
  * ```
  */
 export function change(source, length = 1) {
+    checkPositiveLength('change', length, 0);
     const result = [];
     for (let i = 0; i < source.length; i++) {
         if (i < length) {
@@ -492,6 +550,7 @@ export function tr(handle_na = false, high, low, close) {
  * ```
  */
 export function atr(length, high, low, close) {
+    checkPositiveLength('atr->rma', length, 0);
     if (!high || !low || !close) {
         throw new Error('ta.atr() requires high, low, and close series. ' +
             'Either pass them explicitly or use createContext({ chart: { high, low, close } }) for implicit data.');
@@ -616,6 +675,7 @@ export function supertrend(factor, atrPeriod, high, low, close, wicks = false) {
  * ```
  */
 export function rma(source, length) {
+    checkPositiveLength('rma', length, 0);
     const result = [];
     // Floor the length to match PineScript's auto-truncation of float to int
     const len = Math.floor(length);
@@ -682,6 +742,8 @@ function wmaAdd(a, b) {
  * - 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
@@ -692,7 +754,9 @@ function wmaAdd(a, b) {
 export function wma(source, length) {
     const result = [];
     // 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 = [];
@@ -706,7 +770,11 @@ export function wma(source, length) {
             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;
         }
@@ -730,8 +798,12 @@ export function wma(source, length) {
  * @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, length) {
@@ -745,8 +817,9 @@ export function highest(source, length) {
  * @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, length) {
     return extremeValue(source, length, true);
@@ -860,6 +933,7 @@ function monotonic(source, length, step) {
  * ```
  */
 export function rising(source, length) {
+    checkPositiveLength('rising', length, 0);
     return monotonic(source, length, gt);
 }
 /**
@@ -884,6 +958,7 @@ export function rising(source, length) {
  * ```
  */
 export function falling(source, length) {
+    checkPositiveLength('falling', length, 0);
     return monotonic(source, length, lt);
 }
 /**
@@ -908,6 +983,7 @@ export function falling(source, length) {
  * ```
  */
 export function roc(source, length) {
+    checkPositiveLength('roc', length, 0);
     const result = [];
     for (let i = 0; i < source.length; i++) {
         if (i < length) {
@@ -947,6 +1023,7 @@ export function roc(source, length) {
  * ```
  */
 export function mom(source, length) {
+    checkPositiveLength('mom', length, 0);
     const result = [];
     for (let i = 0; i < source.length; i++) {
         if (i < length) {
@@ -985,6 +1062,7 @@ export function mom(source, length) {
  * ```
  */
 export function dev(source, length) {
+    checkPositiveLength('dev', length, 0);
     const len = Math.floor(length);
     return sma(source, len).map((mean, i) => {
         if (i < len - 1 || Number.isNaN(mean))
@@ -1031,6 +1109,7 @@ function varianceOf(source, length, biased, name) {
         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);
@@ -1058,6 +1137,7 @@ function varianceOf(source, length, biased, name) {
  * ```
  */
 export function median(source, length) {
+    checkPositiveLength('median', length, 0);
     const len = Math.floor(length);
     const n = source.length;
     const out = new Array(n).fill(NaN);
@@ -1146,6 +1226,7 @@ export function swma(source) {
  * ```
  */
 export function vwma(source, length, volume) {
+    checkPositiveLength('vwma->sma', length, 0);
     if (!volume) {
         throw new Error('ta.vwma() requires volume series. ' +
             'Either pass it explicitly or use createContext({ chart: { ..., volume } }) for implicit data.');
@@ -1193,6 +1274,7 @@ export function vwma(source, length, volume) {
  * ```
  */
 export function linreg(source, length, offset = 0) {
+    checkPositiveLength('linreg', length, 0);
     const result = [];
     // Floor the length to match PineScript's auto-truncation of float to int
     const len = Math.floor(length);
@@ -1260,6 +1342,7 @@ export function linreg(source, length, offset = 0) {
  * ```
  */
 export function correlation(source1, source2, length) {
+    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) => {
@@ -1299,8 +1382,8 @@ export function correlation(source1, source2, length) {
  *
  * 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
@@ -1311,14 +1394,15 @@ export function correlation(source1, source2, length) {
  * ```
  */
 export function percentrank(source, length) {
+    checkPositiveLength('percentrank', length, 0);
     const result = [];
     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))
@@ -1357,6 +1441,7 @@ export function percentrank(source, length) {
  * \`\`\`
  */
 export function cci(source, length) {
+    checkPositiveLength('cci', length, 0);
     const smaValues = sma(source, length);
     const devValues = dev(source, length);
     let last = 0;
@@ -1394,6 +1479,7 @@ export function cci(source, length) {
  * \`\`\`
  */
 export function stoch(source, high, low, length) {
+    checkPositiveLength('stoch->highest', length, 0);
     const result = [];
     const lowestValues = lowest(low, length);
     const highestValues = highest(high, length);
@@ -1443,6 +1529,7 @@ export function stoch(source, high, low, length) {
  * ```
  */
 export function mfi(source, length, volume) {
+    checkPositiveLength('mfi', length, 0);
     if (!volume) {
         throw new Error('ta.mfi() requires volume series. ' +
             'Either pass it explicitly or use createContext({ chart: { ..., volume } }) for implicit data.');
@@ -1498,6 +1585,7 @@ export function mfi(source, length, volume) {
  * ```
  */
 export function hma(source, length) {
+    checkPositiveLength('hma', length, 0);
     const halfLength = Math.floor(length / 2);
     const sqrtLength = Math.floor(Math.sqrt(length));
     const wmaHalf = wma(source, halfLength);
@@ -1613,37 +1701,27 @@ export function sar(start, inc, max, high, low, close) {
 /**
  * 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.
+ * 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, leftbars, rightbars, isHigh) {
-    // "beats" = the neighbour prevents the pivot
-    const beatsLeft = isHigh ? (x, v) => x > v : (x, v) => x < v;
-    const beatsRight = isHigh ? (x, v) => x >= v : (x, v) => x <= v;
-    return source.map((_, i) => {
-        const center = i - rightbars;
-        if (center - leftbars < 0)
-            return NaN;
-        const v = source[center];
-        if (Number.isNaN(v))
+    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;
-        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;
+        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 v;
+        return bars[best] === i - right ? values[best] : NaN;
     });
 }
 /**
@@ -1660,7 +1738,10 @@ function pivot(source, leftbars, rightbars, isHigh) {
  * - 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
@@ -1691,7 +1772,8 @@ export function pivothigh(sourceOrLeftbars, leftbarsOrRightbars, rightbars, high
  * - 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
@@ -1861,6 +1943,7 @@ export function dmi(diLength, adxSmoothing, high, low, close) {
  * ```
  */
 export function tsi(source, shortLength, longLength) {
+    checkPositiveLength('tsi->ema', shortLength, 0);
     const momentum = [];
     // Calculate momentum (price change)
     for (let i = 0; i < source.length; i++) {
@@ -1906,6 +1989,7 @@ export function tsi(source, shortLength, longLength) {
  * ```
  */
 export function cmo(source, length) {
+    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.
@@ -1946,6 +2030,7 @@ export function cmo(source, length) {
  * ```
  */
 export function kc(source, length, mult, useTrueRange = true, high, low, close) {
+    checkPositiveLength('kc', length, 0);
     // Calculate middle band (EMA of source)
     const middle = ema(source, length);
     // Calculate range
@@ -2000,6 +2085,7 @@ export function kc(source, length, mult, useTrueRange = true, high, low, close)
  * ```
  */
 export function bbw(source, length, mult) {
+    checkPositiveLength('bbw', length, 0);
     const [basis, upper, lower] = bb(source, length, mult);
     const result = [];
     for (let i = 0; i < source.length; i++) {
@@ -2041,6 +2127,7 @@ export function bbw(source, length, mult) {
  * ```
  */
 export function wpr(high, low, close, length = 14) {
+    checkPositiveLength('wpr', length, 0);
     const highs = highest(high, length);
     const lows = lowest(low, length);
     return Array.from({ length: close.length }, (_, i) => {
@@ -2105,6 +2192,7 @@ export function vwap(source, volume, anchor, stdev_mult) {
  * ```
  */
 export function alma(source, length = 9, offset = 0.85, sigma = 6, floor = false) {
+    checkPositiveLength('alma', length, 0);
     const result = [];
     const m = floor ? Math.floor(offset * (length - 1)) : offset * (length - 1);
     const s = length / sigma;
@@ -2183,6 +2271,7 @@ export function kcw(source, length = 20, mult = 2, useTrueRange = true, high, lo
  * values), and a bar whose own value is `na` still gets a result.
  */
 export function range(source, length) {
+    checkPositiveLength('range', length, 0);
     return source.map((_, i) => {
         const values = lastValues(source, i, length);
         return values ? Math.max(...values) - Math.min(...values) : NaN;
@@ -2193,8 +2282,9 @@ export function range(source, length) {
  * -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, length) {
     return extremeOffset(source, length, false);
@@ -2204,8 +2294,9 @@ export function highestbars(source, length) {
  * -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, length) {
     return extremeOffset(source, length, true);
@@ -2263,6 +2354,7 @@ export function min(source) {
  * ```
  */
 export function cog(source, length = 10) {
+    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)
@@ -2297,6 +2389,7 @@ export function cog(source, length = 10) {
  * - If no mode exists, returns the smallest value
  */
 export function mode(source, length) {
+    checkPositiveLength('mode', length, 0);
     const result = [];
     const len = Math.floor(length);
     const seen = []; // non-na values so far
@@ -2364,6 +2457,7 @@ export function mode(source, length) {
  *   `na` values are before all numbers
  */
 export function percentile_linear_interpolation(source, length, percentage) {
+    checkPositiveLength('percentile_linear_interpolation', length, 0);
     return sortedWindow(source, length, (s) => {
         const pos = (percentage / 100) * length - 0.5;
         if (pos <= 0)
@@ -2430,6 +2524,7 @@ function sortedWindow(source, length, fn) {
  * - `na` values stay in the window, sorted from bar to bar as in `ta.percentile_linear_interpolation`
  */
 export function percentile_nearest_rank(source, length, percentage) {
+    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]);
 }
@@ -2465,6 +2560,7 @@ export function percentile_nearest_rank(source, length, percentage) {
  *   where the `na` was
  */
 export function rci(source, length) {
+    checkPositiveLength('rci', length, 0);
     const len = Math.floor(length);
     const result = [];
     // PineScript keeps the values in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start
@@ -2530,187 +2626,135 @@ export function rci(source, length) {
     return result;
 }
 /**
- * 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, anchor, developing = false, high, low, close, open) {
-    // 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');
-    }
-    // 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 = 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, l, c, o;
-        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]);
+        throw new Error('Error on bar 0: The `developing` parameter of the `ta.pivot_point_levels()` cannot be `true` when `type` is "Woodie".');
+    }
+    const n = anchor.length;
+    for (const [s, name] of [[high, 'High'], [low, 'Low'], [close, 'Close'], [open, 'Open']]) {
+        if (s && s.length !== n)
+            throw new Error(`${name} series length mismatch`);
+    }
+    const at = (s, i) => (s ? (s[i] ?? NaN) : NaN);
+    const results = Array.from({ length: 11 }, () => new Array(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 = new Array(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, h, l, c, o) {
-    // Return NaN array if data is insufficient
-    if (isNaN(h) || isNaN(l) || isNaN(c)) {
-        return Array(11).fill(NaN);
-    }
-    const levels = Array(11).fill(NaN);
-    // Calculate pivot point (P)
-    let P;
+function pivotLevels(type, h, l, c, o, wo) {
+    const N = NaN;
+    const r = h - l;
     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
-    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;
 }
 /**
  * Ichimoku Kinko Hyo (Ichimoku Cloud) - Japanese charting technique for trend identification.