oakscriptjs 0.10.0 → 0.11.0

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 { 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);
 }
 
@@ -234,6 +236,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 +288,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 +319,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 +339,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;
   });
 }
 
@@ -763,6 +833,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 +842,10 @@ 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;
   // 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 +859,9 @@ 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 (isNa || !(len >= 1) || count < len) {
       result.push(NaN);
       continue;
     }
@@ -812,11 +886,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 +906,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);
 }
 
@@ -1127,6 +1206,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);
@@ -1738,35 +1818,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 +1860,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 +1873,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 +1900,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 +1911,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) {
@@ -2420,10 +2500,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 +2513,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);
 }
 

package/src/ta/limits.ts

@@ -0,0 +1,47 @@
+/**
+ * History limits of the window functions.
+ *
+ * PineScript stops a script when `ta.highest` / `ta.lowest` / `ta.highestbars` / `ta.lowestbars` ask for more than
+ * 15,000 bars (runtime error RE10004): with a constant length on the first bar, with a length that changes on the
+ * bar where it passes the limit. `math.sum`, `ta.sma`, `ta.variance`, `ta.stdev` and `ta.bb` have the same error
+ * above 5,000 bars; the message names the function that keeps the window ('stdev'->'variance', 'bb'->'sma').
+ */
+
+/** Largest length of `ta.highest` / `ta.lowest` / `ta.highestbars` / `ta.lowestbars`. */
+export const MAX_WINDOW_LENGTH = 15000;
+
+/** Largest length of `math.sum` / `ta.sma` / `ta.variance` / `ta.stdev` / `ta.bb`. */
+export const MAX_SUM_LENGTH = 5000;
+
+/** Names of the PineScript message for the functions with the 5,000 limit ("a->b": a calls b). */
+export const SUM_FUNCTIONS: Record<string, string> = {
+  'math.sum': 'sum',
+  'ta.sma': 'sma',
+  'ta.variance': 'variance',
+  'ta.stdev': 'stdev->variance',
+  'ta.bb': 'bb->sma',
+};
+
+/**
+ * PineScript's runtime error RE10004 text; `bar` is the bar index of the call when it is known. `name` is the
+ * function, or a call path "stdev->variance" (printed 'stdev'->'variance').
+ */
+export function windowError(name: string, length: number, bar?: number, max = MAX_WINDOW_LENGTH): string {
+  const fn = name.split('->').map((part) => `'${part}'`).join('->');
+  return (
+    (bar === undefined ? '' : `Error on bar ${bar}: `) +
+    `The ${fn} function references too many historical candles (${length}), the limit is ${max}.`
+  );
+}
+
+/** Throws RE10004 when the (truncated) length of a window function is above the limit. */
+export function checkWindowLength(name: string, length: number, bar?: number, max = MAX_WINDOW_LENGTH): void {
+  const len = Math.trunc(length);
+  if (len > max) throw new Error(windowError(name, len, bar, max));
+}
+
+/** Throws RE10004 for a function of {@link SUM_FUNCTIONS} ("ta.sma", ...) with a length above 5,000. */
+export function checkSumLength(name: string, length: number, bar?: number): void {
+  const fn = SUM_FUNCTIONS[name];
+  if (fn !== undefined) checkWindowLength(fn, length, bar, MAX_SUM_LENGTH);
+}

package/src/ta/running-sum.ts

@@ -14,6 +14,7 @@
  *
  * @internal
  */
+import { checkSumLength } from './limits.js';
 
 /**
  * Whether the compensation `c` is (partly) lost when it is applied to `x`: `x + |c|` in floating point moves `x` by
@@ -177,6 +178,7 @@ function seriesLengths(lengths: ArrayLike<number>, count: number, name: string):
   return Array.from({ length: count }, (_, i) => {
     const len = Math.floor(lengths[i]!);
     if (!(len >= 1)) throw new Error(`${name}: length must be at least 1 (bar ${i}: ${lengths[i]})`);
+    checkSumLength(name, len, i);
     return len;
   });
 }

package/src/ta-series.ts

@@ -40,10 +40,10 @@ export function ema(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with WMA values
  */
-export function wma(source: Series, length: number): Series {
+export function wma(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.wma(sourceValues, length);
+  const result = taCore.wma(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -333,10 +333,10 @@ export function roc(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with highest values
  */
-export function highest(source: Series, length: number): Series {
+export function highest(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.highest(sourceValues, length);
+  const result = taCore.highest(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -346,10 +346,10 @@ export function highest(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with lowest values
  */
-export function lowest(source: Series, length: number): Series {
+export function lowest(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.lowest(sourceValues, length);
+  const result = taCore.lowest(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -688,9 +688,10 @@ export function hma(source: Series, length: number): Series {
  * @returns Series with the pivot high value on the bar where the pivot is confirmed,
  *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
  */
-export function pivothigh(source: Series, leftbars: number, rightbars: number): Series {
+export function pivothigh(source: Series, leftbars: number | Series, rightbars: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.pivothigh(source.toArray(), leftbars, rightbars);
+  const arr = (v: number | Series) => (v instanceof Series ? v.toArray() : v);
+  const result = taCore.pivothigh(source.toArray(), arr(leftbars), arr(rightbars));
   return Series.fromArray(bars, result);
 }
 
@@ -702,9 +703,10 @@ export function pivothigh(source: Series, leftbars: number, rightbars: number):
  * @returns Series with the pivot low value on the bar where the pivot is confirmed,
  *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
  */
-export function pivotlow(source: Series, leftbars: number, rightbars: number): Series {
+export function pivotlow(source: Series, leftbars: number | Series, rightbars: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.pivotlow(source.toArray(), leftbars, rightbars);
+  const arr = (v: number | Series) => (v instanceof Series ? v.toArray() : v);
+  const result = taCore.pivotlow(source.toArray(), arr(leftbars), arr(rightbars));
   return Series.fromArray(bars, result);
 }
 
@@ -861,9 +863,9 @@ export function kcw(bars: Bar[], source: Series, length: number = 20, mult: numb
  * @param length - Period length
  * @returns Series with bar offsets to highest value
  */
-export function highestbars(source: Series, length: number): Series {
+export function highestbars(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.highestbars(source.toArray(), length);
+  const result = taCore.highestbars(source.toArray(), length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -873,9 +875,9 @@ export function highestbars(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with bar offsets to lowest value
  */
-export function lowestbars(source: Series, length: number): Series {
+export function lowestbars(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.lowestbars(source.toArray(), length);
+  const result = taCore.lowestbars(source.toArray(), length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 

package/src/time/index.ts

@@ -156,8 +156,11 @@ export function second(time: int, timezone: string): int {
  * ":" (1 = Sunday ... 7 = Saturday), e.g. "0930-1600:23456" or "1000-1100,1400-1500".
  * Without days, one period covers every day and several periods cover Monday to Friday.
  * A period includes its start and excludes its end. An overnight period ("1800-0930")
- * belongs to the day it ends. "0000-0000" and "24x7" cover the whole day.
+ * belongs to the day it ends. "0000-0000" and "24x7" cover the whole day. A period that ends at 0000 ends at 24:00 of
+ * the day it starts. On the days around a clock change the periods are placed as PineScript places them (see
+ * time/session.ts); `barMs`, the duration of the bars in ms, is needed for one of these rules (the day before the
+ * clocks go back).
  */
-export function inSession(time: int, session: string, timezone: string): boolean {
-  return sessionContains(time, session, timezone);
+export function inSession(time: int, session: string, timezone: string, barMs?: number): boolean {
+  return sessionContains(time, session, timezone, barMs);
 }