oakscriptjs 0.11.0 → 0.11.2

package/dist/esm/ta/index.js

@@ -9,7 +9,7 @@
  */
 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).
  *
@@ -64,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);
@@ -101,32 +102,19 @@ 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;
+            return 100 - 100 / (1 + x / y);
+        });
+    }
+    checkPositiveLength('rsi', length, 0, 'y');
     const result = [];
     // Calculate price changes
     const changes = [];
@@ -239,14 +227,14 @@ export function stdev(source, length, biased = true) {
     return varianceOf(source, length, biased, 'ta.stdev').map((v) => (Number.isNaN(v) ? NaN : v > 0 ? Math.sqrt(v) : 0));
 }
 /**
- * The last `length` non-na values up to bar `i` (the bar itself may be na), or null when fewer exist.
- * `isNa` tells which values are skipped (NaN by default).
+ * The last `length` non-na values up to bar `i` (the bar itself may be na), or null when fewer exist. +/-Infinity
+ * counts as na (#183).
  */
 function lastValues(source, i, length) {
     const values = [];
     for (let j = i; j >= 0 && values.length < length; j--) {
         const x = source[j];
-        if (!Number.isNaN(x))
+        if (Number.isFinite(x))
             values.push(x);
     }
     return values.length === length ? values : null;
@@ -305,7 +293,7 @@ function windowExtremes(source, length, lowest, newest = false) {
 /**
  * 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.
+ * ta.pivotlow keep the non-na values they receive and nothing else; +/-Infinity is skipped like na (#183).
  */
 function keptValues(source) {
     const values = [];
@@ -313,7 +301,7 @@ function keptValues(source) {
     const last = new Int32Array(source.length);
     for (let i = 0; i < source.length; i++) {
         const x = source[i];
-        if (!Number.isNaN(x)) {
+        if (Number.isFinite(x)) {
             values.push(x);
             bars.push(i);
         }
@@ -463,6 +451,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) {
@@ -560,6 +549,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.');
@@ -684,6 +674,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);
@@ -763,6 +754,8 @@ export function wma(source, length) {
     const result = [];
     // 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 = [];
@@ -778,6 +771,8 @@ export function wma(source, length) {
         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;
@@ -802,9 +797,9 @@ export function wma(source, length) {
  * @returns Highest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * 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).
+ * As in PineScript: `na` values (also +/-Infinity, #183) 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`).
@@ -821,9 +816,9 @@ export function highest(source, length) {
  * @returns Lowest value series (na on the first `length - 1` bars)
  *
  * @remarks
- * 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.
+ * As in PineScript: `na` values (also +/-Infinity, #183) 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);
@@ -909,7 +904,7 @@ function monotonic(source, length, step) {
     for (let i = 0; i < source.length; i++) {
         const v = source[i];
         const prev = i > 0 ? source[i - 1] : NaN;
-        if (!Number.isNaN(v) && !Number.isNaN(prev))
+        if (Number.isFinite(v) && Number.isFinite(prev))
             count = step(v, prev) ? count + 1 : 0;
         result.push(count >= length);
     }
@@ -926,8 +921,8 @@ function monotonic(source, length, step) {
  * PineScript rules:
  * - a counter of rises from the previous bar (a rise is larger than the 1e-10 tolerance); a step that is not a rise
  *   resets it to 0
- * - a step from or to an `na` bar leaves the counter unchanged (so an `na` bar, and the bar after it, keep the
- *   result of the bar before the `na`)
+ * - a step from or to an `na` (or +/-Infinity) bar leaves the counter unchanged (so an `na` bar, and the bar after
+ *   it, keep the result of the bar before the `na`)
  * - true when the counter is at least `length` (false at the start)
  *
  * @example
@@ -937,6 +932,7 @@ function monotonic(source, length, step) {
  * ```
  */
 export function rising(source, length) {
+    checkPositiveLength('rising', length, 0);
     return monotonic(source, length, gt);
 }
 /**
@@ -950,8 +946,8 @@ export function rising(source, length) {
  * PineScript rules:
  * - a counter of falls from the previous bar (a fall is larger than the 1e-10 tolerance); a step that is not a fall
  *   resets it to 0
- * - a step from or to an `na` bar leaves the counter unchanged (so an `na` bar, and the bar after it, keep the
- *   result of the bar before the `na`)
+ * - a step from or to an `na` (or +/-Infinity) bar leaves the counter unchanged (so an `na` bar, and the bar after
+ *   it, keep the result of the bar before the `na`)
  * - true when the counter is at least `length` (false at the start)
  *
  * @example
@@ -961,6 +957,7 @@ export function rising(source, length) {
  * ```
  */
 export function falling(source, length) {
+    checkPositiveLength('falling', length, 0);
     return monotonic(source, length, lt);
 }
 /**
@@ -985,6 +982,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) {
@@ -1024,6 +1022,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) {
@@ -1062,6 +1061,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))
@@ -1124,7 +1124,7 @@ function varianceOf(source, length, biased, name) {
  * @remarks
  * - Returns the middle value when values are sorted
  * - For an even length, returns the average of the two middle values
- * - As in PineScript: `na` values are skipped, the window holds the last `length` non-na values
+ * - As in PineScript: `na` values (also +/-Infinity) are skipped, the window holds the last `length` non-na values
  *   (going back as many bars as needed), and a bar whose own value is `na` still gets a result
  * - Returns NaN until `length` non-na values exist
  * - More robust to outliers than mean (SMA)
@@ -1136,6 +1136,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);
@@ -1162,7 +1163,7 @@ export function median(source, length) {
     const mid = Math.floor(len / 2);
     for (let i = 0; i < n; i++) {
         const x = source[i];
-        if (!Number.isNaN(x)) {
+        if (Number.isFinite(x)) {
             kept[count++] = x;
             sorted.splice(bound(x, false), 0, x); // before the equal values: the newest first
             // the value leaving the window is the oldest, so the last of its equal values
@@ -1224,6 +1225,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.');
@@ -1271,6 +1273,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);
@@ -1338,6 +1341,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) => {
@@ -1377,8 +1381,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
@@ -1389,14 +1393,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))
@@ -1435,6 +1440,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;
@@ -1461,8 +1467,9 @@ export function cci(source, length) {
  * - Measures where close is relative to the high-low range
  * - Values above 80 typically indicate overbought
  * - Values below 20 typically indicate oversold
- * - As PineScript: when the source, \`highest(high, length)\` or \`lowest(low, length)\` is \`na\`, or the range is 0, the
- *   result is the previous result of the call (\`na\` until a first value)
+ * - As PineScript: when the source, \`highest(high, length)\` or \`lowest(low, length)\` is \`na\`, or the range and
+ *   \`source - lowest\` are both 0, the result is the previous result of the call (\`na\` until a first value); a zero
+ *   range with another source value gives +/-Infinity (plotted as \`na\`)
  *
  * @example
  * \`\`\`typescript
@@ -1472,17 +1479,18 @@ 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);
-    // PineScript: an na input or a zero range keeps the previous result
+    // PineScript: an na (NaN) result keeps the previous one: an na input, or 0 / 0 on a zero range; a non-zero value
+    // over a zero range gives +/-Infinity (#183)
     let previous = NaN;
     for (let i = 0; i < source.length; i++) {
-        const value = source[i];
         const lo = lowestValues[i];
-        const range = highestValues[i] - lo;
-        if (!Number.isNaN(value) && !Number.isNaN(range) && range !== 0)
-            previous = (100 * (value - lo)) / range;
+        const k = (100 * (source[i] - lo)) / (highestValues[i] - lo);
+        if (!Number.isNaN(k))
+            previous = k;
         result.push(previous);
     }
     return result;
@@ -1521,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.');
@@ -1576,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);
@@ -1728,8 +1738,8 @@ 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
- * - `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
+ * - `na` values (also +/-Infinity) 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
  *
@@ -1762,8 +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
- * - `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
+ * - `na` values (also +/-Infinity) 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
@@ -1933,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++) {
@@ -1978,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.
@@ -2018,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
@@ -2072,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++) {
@@ -2113,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) => {
@@ -2177,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;
@@ -2251,10 +2267,11 @@ export function kcw(source, length = 20, mult = 2, useTrueRange = true, high, lo
  * (PineScript `ta.range(source, length)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped (the window holds the last `length` non-na
+ * As in PineScript: `na` values (also +/-Infinity) are skipped (the window holds the last `length` non-na
  * 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;
@@ -2265,9 +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: 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.
+ * As in PineScript: the best of the last `length` non-na values (+/-Infinity skipped), 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);
@@ -2277,9 +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: 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.
+ * As in PineScript: the best of the last `length` non-na values (+/-Infinity skipped), 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);
@@ -2288,13 +2305,13 @@ export function lowestbars(source, length) {
  * All-time highest value of `source` up to each bar (PineScript `ta.max(source)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * As in PineScript: `na` values (also +/-Infinity) are skipped, the value carries over `na` bars, and the
  * result is `na` until the first non-na value.
  */
 export function max(source) {
     let best = NaN;
     return source.map((x) => {
-        if (!Number.isNaN(x) && !(x <= best))
+        if (Number.isFinite(x) && !(x <= best))
             best = x;
         return best;
     });
@@ -2303,13 +2320,13 @@ export function max(source) {
  * All-time lowest value of `source` up to each bar (PineScript `ta.min(source)`).
  *
  * @remarks
- * As in PineScript: `na` values are skipped, the value carries over `na` bars, and the
+ * As in PineScript: `na` values (also +/-Infinity) are skipped, the value carries over `na` bars, and the
  * result is `na` until the first non-na value.
  */
 export function min(source) {
     let best = NaN;
     return source.map((x) => {
-        if (!Number.isNaN(x) && !(x >= best))
+        if (Number.isFinite(x) && !(x >= best))
             best = x;
         return best;
     });
@@ -2337,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)
@@ -2365,18 +2383,19 @@ export function cog(source, length = 10) {
  *
  * @remarks
  * PineScript rules:
- * - the window is the last `length` non-`na` values (an `na` bar does not enter it, and gets the mode of the
- *   window it keeps)
+ * - the window is the last `length` non-`na` values (an `na` or +/-Infinity bar does not enter it, and gets the mode
+ *   of the window it keeps)
  * - NaN until `length` non-`na` values exist
  * - 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
     for (let i = 0; i < source.length; i++) {
         const v = source[i];
-        if (!Number.isNaN(v))
+        if (Number.isFinite(v))
             seen.push(v);
         if (seen.length < len) {
             result.push(NaN);
@@ -2438,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)
@@ -2504,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]);
 }
@@ -2539,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
@@ -2604,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.