oakscriptjs 0.11.1 → 0.11.2

package/src/script/index.ts

@@ -122,7 +122,7 @@ import {
   type StrategyTrade,
   type StrategyVariable,
 } from '../strategy/index.js';
-import { parsePineSession, sessionRun } from '../time/session.js';
+import { sessionPeriods, type SessionPeriods } from '../session/context.js';
 
 /** Everything one run of a script produced. */
 export interface ScriptRunResult {
@@ -1894,37 +1894,6 @@ function sessionBars(): { bars: SessionBars; regular: SessionBars } {
   return sessionCache;
 }
 
-/**
- * Calendar for `time(tf, session, timezone)` arguments. Without session and time zone: the loaded
- * session. As in PineScript, an explicit time zone reads the symbol session hours in that zone without
- * corrections and holidays, and an explicit session follows PineScript's session string rules.
- */
-function calendarFor(
-  session?: string,
-  timezone?: string,
-  dayPlacement = false
-): { bars: SessionBars; test: boolean; inside?: (time: number) => boolean } {
-  const { bars } = sessionBars();
-  if (!session && !timezone) return { bars, test: false };
-  const tz = timezone ?? exchangeTimezone();
-  // a session string that is empty or does not start with a digit is the symbol session: "regular" the regular
-  // hours, "extended" and any other name the loaded hours (PineScript)
-  if (session !== undefined && parsePineSession(session) === null) {
-    const name = session.trim();
-    const symbol = name === 'regular' && chartCtx.regularSession ? chartCtx.regularSession : chartCtx.session!;
-    return { bars: new SessionBars(new TradingCalendar(tz, { session: toSpec(symbol).session }, 'symbol'), bars.chart.period), test: true };
-  }
-  const spec = session ? { session } : { session: toSpec(chartCtx.session!).session };
-  return {
-    bars: new SessionBars(new TradingCalendar(tz, spec, session ? 'pine' : 'symbol', dayPlacement), bars.chart.period),
-    test: true,
-    // a PineScript session string: the rules of time.inSession (runs ending at 0000, days around a clock change)
-    inside: session
-      ? (time) => timeCore.inSession(time, session, tz, timeframeCore.in_seconds(bars.chart.period) * 1000)
-      : undefined,
-  };
-}
-
 function perBar(fn: (t: number, i: number, times: number[]) => number): Series {
   const times = ctxBars.bars.map(barTime);
   return Series.fromArray(ctxBars, times.map((t, i) => fn(t, i, times)));
@@ -1937,48 +1906,21 @@ function callableSeries<F extends (...args: never[]) => Series>(series: Series,
   return fn as Series & F;
 }
 
-/**
- * `time(tf, session)` / `time_close(tf, session)` of a bar, as PineScript computes them (#173): an intraday timeframe
- * tests the bar with the session rules of time.inSession and aligns its periods on the start of the run that
- * contains the bar; "D" tests the bar against the day's session period (the calendar); a timeframe of more than one
- * day ("2D", "W", "M") has no test and keeps the period's time.
- */
-function sessionPeriods(timeframeString: string, session?: string, timezone?: string): { open: (t: number) => number; close: (t: number) => number } {
-  const tf = timeframeCore.info(timeframeString);
-  const { bars, test, inside } = calendarFor(session, timezone, !tf.isintraday);
-  const open = (t: number): number => bars.timeOf(t, timeframeString);
-  const close = (t: number): number => bars.closeOf(t, timeframeString);
-  if (!test) return { open, close };
-  if (tf.isintraday) {
-    if (session !== undefined && parsePineSession(session) !== null && !bars.chart.isdwm) {
-      const tz = timezone ?? exchangeTimezone();
-      const barMs = timeframeCore.in_seconds(bars.chart.period) * 1000;
-      const ms = timeframeCore.in_seconds(tf.period) * 1000;
-      const run = (t: number) => sessionRun(t, session, tz, barMs);
-      const start = (t: number, r: [number, number]) => r[0] + Math.floor((t - r[0]) / ms) * ms;
-      return {
-        open: (t) => { const r = run(t); return r ? start(t, r) : NaN; },
-        close: (t) => { const r = run(t); return r ? Math.min(start(t, r) + ms, r[1]) : NaN; },
-      };
-    }
-    const isIn = (t: number) => (inside ? inside(t) : bars.inside(t));
-    return { open: (t) => (isIn(t) ? open(t) : NaN), close: (t) => (isIn(t) ? close(t) : NaN) };
-  }
-  if (tf.isdaily && tf.multiplier === 1) {
-    return { open: (t) => (bars.inside(t) ? open(t) : NaN), close: (t) => (bars.inside(t) ? close(t) : NaN) };
-  }
-  return { open, close };
+/** `time(tf, session, timezone)` / `time_close(...)` periods of the run's chart (see session/context `sessionPeriods`). */
+function chartSessionPeriods(timeframeString: string, session?: string, timezone?: string): SessionPeriods {
+  const { bars } = sessionBars();
+  return sessionPeriods(bars, { ...chartCtx, timezone: exchangeTimezone() }, timeframeString, session, timezone);
 }
 
 function timeFunction(tf?: string, session?: string, timezone?: string): Series {
   collector();
-  const { open } = sessionPeriods(tf || chartTimeframe().period, session, timezone);
+  const { open } = chartSessionPeriods(tf || chartTimeframe().period, session, timezone);
   return perBar((t) => open(t));
 }
 
 function timeCloseFunction(tf?: string, session?: string, timezone?: string): Series {
   collector();
-  const { close } = sessionPeriods(tf || chartTimeframe().period, session, timezone);
+  const { close } = chartSessionPeriods(tf || chartTimeframe().period, session, timezone);
   return perBar((t) => close(t));
 }
 

package/src/session/calendar.ts

@@ -197,6 +197,9 @@ export class TradingCalendar {
         ? [at(d - p.startOffset, p.start, true), at(d - p.endOffset, p.end - 1, true) + 60_000]
         : [at(d - p.startOffset, p.start), at(d - p.endOffset, p.end)]
     );
+    // for "D", the runs of a PineScript session string on one day are one period, from the earliest start to the
+    // latest end: the time between two runs is inside the day (#182)
+    if (this.pine && out.length > 1) out = [[Math.min(...out.map((p) => p[0])), Math.max(...out.map((p) => p[1]))]];
     this.cache.set(date, out);
     return out;
   }

package/src/session/context.ts

@@ -11,6 +11,7 @@
 import type { Bar } from '../types/index.js';
 import { info, in_seconds } from '../timeframe/index.js';
 import { afterCompletion, periodsOf, resample } from '../security/resample.js';
+import { parsePineSession, sessionRun } from '../time/session.js';
 import { SessionBars, sessionFlags, strayPeriods, type SessionFlags } from './bars.js';
 import { TradingCalendar, type SessionSpec } from './calendar.js';
 
@@ -61,16 +62,107 @@ export function chartSessions(chart: SessionContext): ChartSessions {
   return out;
 }
 
-/** PineScript `time(timeframe)` (ms) of a bar that opens at `time`: the start of its period; NaN without one. */
-export function periodTime(time: number, timeframe: string, chart: SessionContext): number {
-  const s = chartSessions(chart);
-  return s.bars.timeOf(time * s.unit, timeframe);
+/** Open and close (ms) of the period that contains a bar opening at a time in ms; NaN outside the session. */
+export interface SessionPeriods {
+  open: (time: number) => number;
+  close: (time: number) => number;
+}
+
+/**
+ * Calendar for the `session` / `timezone` arguments of `time(tf, session, timezone)`. Without both: the loaded
+ * session. As in PineScript, an explicit time zone reads the symbol session hours in that zone without corrections
+ * and holidays, and an explicit session follows PineScript's session string rules.
+ */
+function calendarFor(
+  bars: SessionBars,
+  chart: SessionContext,
+  session: string | undefined,
+  timezone: string | undefined,
+  dayPlacement: boolean
+): { bars: SessionBars; test: boolean; inside?: (time: number) => boolean } {
+  if (!session && !timezone) return { bars, test: false };
+  const tz = timezone ?? chart.timezone!;
+  // a session string that is empty or does not start with a digit is the symbol session: "regular" the regular
+  // hours, "extended" and any other name the loaded hours (PineScript)
+  if (session !== undefined && parsePineSession(session) === null) {
+    const name = session.trim();
+    const symbol = name === 'regular' && chart.regularSession ? chart.regularSession : chart.session!;
+    return { bars: new SessionBars(new TradingCalendar(tz, { session: toSpec(symbol).session }, 'symbol'), bars.chart.period), test: true };
+  }
+  const spec = session ? { session } : { session: toSpec(chart.session!).session };
+  return {
+    bars: new SessionBars(new TradingCalendar(tz, spec, session ? 'pine' : 'symbol', dayPlacement), bars.chart.period),
+    test: true,
+    // a PineScript session string: the rules of time.inSession (runs ending at 0000, days around a clock change)
+    inside: session ? (time) => sessionRun(time, session, tz, in_seconds(bars.chart.period) * 1000) !== null : undefined,
+  };
+}
+
+/**
+ * `time(tf, session, timezone)` / `time_close(tf, session, timezone)` of a bar, as PineScript computes them (#173):
+ * an intraday timeframe tests the bar with the session rules of time.inSession and aligns its periods on the start
+ * of the run that contains the bar; "D" tests the bar against the day's session period (the calendar; the time
+ * between two runs of a day is inside it, #182); a timeframe of more than one day ("2D", "W", "M") has no test and
+ * keeps the period's time. `bars` is the calendar of the loaded session (`chartSessions(chart).bars`).
+ */
+export function sessionPeriods(
+  bars: SessionBars,
+  chart: SessionContext,
+  timeframe: string,
+  session?: string,
+  timezone?: string
+): SessionPeriods {
+  const tf = info(timeframe);
+  const { bars: calendar, test, inside } = calendarFor(bars, chart, session, timezone, !tf.isintraday);
+  const open = (t: number): number => calendar.timeOf(t, timeframe);
+  const close = (t: number): number => calendar.closeOf(t, timeframe);
+  if (!test) return { open, close };
+  if (tf.isintraday) {
+    if (session !== undefined && parsePineSession(session) !== null && !calendar.chart.isdwm) {
+      const tz = timezone ?? chart.timezone!;
+      const barMs = in_seconds(calendar.chart.period) * 1000;
+      const ms = in_seconds(tf.period) * 1000;
+      const run = (t: number) => sessionRun(t, session, tz, barMs);
+      const start = (t: number, r: [number, number]) => r[0] + Math.floor((t - r[0]) / ms) * ms;
+      return {
+        open: (t) => { const r = run(t); return r ? start(t, r) : NaN; },
+        close: (t) => { const r = run(t); return r ? Math.min(start(t, r) + ms, r[1]) : NaN; },
+      };
+    }
+    const isIn = (t: number) => (inside ? inside(t) : calendar.inside(t));
+    return { open: (t) => (isIn(t) ? open(t) : NaN), close: (t) => (isIn(t) ? close(t) : NaN) };
+  }
+  if (tf.isdaily && tf.multiplier === 1) {
+    return { open: (t) => (calendar.inside(t) ? open(t) : NaN), close: (t) => (calendar.inside(t) ? close(t) : NaN) };
+  }
+  return { open, close };
 }
 
-/** PineScript `time_close(timeframe)` (ms) of a bar that opens at `time`. */
-export function periodClose(time: number, timeframe: string, chart: SessionContext): number {
+const periodCache = new WeakMap<object, Map<string, SessionPeriods>>();
+
+function periodsOfChart(chart: SessionContext, timeframe: string, session?: string, timezone?: string): { s: ChartSessions; p: SessionPeriods } {
   const s = chartSessions(chart);
-  return s.bars.closeOf(time * s.unit, timeframe);
+  let byKey = periodCache.get(chart);
+  if (!byKey) periodCache.set(chart, (byKey = new Map()));
+  const key = `${timeframe}|${session ?? ''}|${timezone ?? ''}`;
+  let p = byKey.get(key);
+  if (!p) byKey.set(key, (p = sessionPeriods(s.bars, chart, timeframe, session, timezone)));
+  return { s, p };
+}
+
+/**
+ * PineScript `time(timeframe, session, timezone)` (ms) of a bar that opens at `time`: the start of its period; NaN
+ * without one or outside `session` (#182). Without `session` and `timezone`, the periods of the loaded session.
+ */
+export function periodTime(time: number, timeframe: string, chart: SessionContext, session?: string, timezone?: string): number {
+  const { s, p } = periodsOfChart(chart, timeframe, session, timezone);
+  return p.open(time * s.unit);
+}
+
+/** PineScript `time_close(timeframe, session, timezone)` (ms) of a bar that opens at `time` (#182). */
+export function periodClose(time: number, timeframe: string, chart: SessionContext, session?: string, timezone?: string): number {
+  const { s, p } = periodsOfChart(chart, timeframe, session, timezone);
+  return p.close(time * s.unit);
 }
 
 /** PineScript `time_tradingday` (ms, 00:00 UTC of the trading day) of a bar that opens at `time`. */

package/src/ta/index.ts

@@ -138,7 +138,8 @@ export function rsi(source: Source, length: simple_int): series_float;
 /**
  * PineScript v4 `rsi(x, y)` with two series (#180): `x` and `y` are the averages of the upward and downward changes,
  * already computed. As in PineScript: 100 when `y` is within 1e-10 of zero (also with an na `x`), else 0 when `x` is,
- * else `100 - 100 / (1 + x / y)`, na when that divides by zero (`x == -y`). Versions 5 and 6 have the length form only.
+ * else `100 - 100 / (1 + x / y)`: -Infinity when `x == -y` (#182), which `na()` and `nz()` treat as na while comparisons
+ * see it (`r < 30` is true). Versions 5 and 6 have the length form only.
  */
 export function rsi(x: Source, y: Source): series_float;
 export function rsi(source: Source, length: simple_int | Source): series_float {
@@ -148,8 +149,7 @@ export function rsi(source: Source, length: simple_int | Source): series_float {
       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;
+      return 100 - 100 / (1 + x / y);
     });
   }
   checkPositiveLength('rsi', length, 0, 'y');
@@ -293,14 +293,14 @@ export function stdev(
 }
 
 /**
- * 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: Source, i: number, length: number): number[] | null {
   const values: number[] = [];
   for (let j = i; j >= 0 && values.length < length; j--) {
     const x = source[j]!;
-    if (!Number.isNaN(x)) values.push(x);
+    if (Number.isFinite(x)) values.push(x);
   }
   return values.length === length ? values : null;
 }
@@ -361,7 +361,7 @@ function windowExtremes(
 /**
  * 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: Source): { values: number[]; bars: number[]; last: Int32Array } {
   const values: number[] = [];
@@ -369,7 +369,7 @@ function keptValues(source: Source): { values: number[]; bars: number[]; last: I
   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);
     }
@@ -910,9 +910,9 @@ export function wma(source: Source, length: simple_int | ArrayLike<number>): ser
  * @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`).
@@ -930,9 +930,9 @@ export function highest(source: Source, length: simple_int | ArrayLike<number>):
  * @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: Source, length: simple_int | ArrayLike<number>): series_float {
   return extremeValue(source, length, true);
@@ -1018,7 +1018,7 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
   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)) count = step(v, prev) ? count + 1 : 0;
+    if (Number.isFinite(v) && Number.isFinite(prev)) count = step(v, prev) ? count + 1 : 0;
     result.push(count >= length);
   }
   return result;
@@ -1035,8 +1035,8 @@ function monotonic(source: Source, length: simple_int, step: (newer: number, old
  * 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
@@ -1061,8 +1061,8 @@ export function rising(source: Source, length: simple_int): series_bool {
  * 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
@@ -1251,7 +1251,7 @@ function varianceOf(
  * @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)
@@ -1287,7 +1287,7 @@ export function median(source: Source, length: simple_int): series_float {
   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
@@ -1601,8 +1601,9 @@ export function cci(source: Source, length: simple_int): series_float {
  * - 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
@@ -1617,13 +1618,13 @@ export function stoch(source: Source, high: Source, low: Source, length: simple_
   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);
   }
 
@@ -1898,8 +1899,8 @@ function pivot(source: Source, leftbars: PivotLength, rightbars: PivotLength, is
  * - 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
  *
@@ -1938,8 +1939,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
- * - `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
@@ -2529,7 +2530,7 @@ export function kcw(
  * (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: Source, length: simple_int): series_float {
@@ -2545,9 +2546,9 @@ 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: 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: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, false);
@@ -2558,9 +2559,9 @@ export function highestbars(source: Source, length: simple_int | ArrayLike<numbe
  * -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: Source, length: simple_int | ArrayLike<number>): series_int {
   return extremeOffset(source, length, true);
@@ -2570,13 +2571,13 @@ export function lowestbars(source: Source, length: simple_int | ArrayLike<number
  * 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: Source): series_float {
   let best = NaN;
   return source.map((x) => {
-    if (!Number.isNaN(x) && !(x <= best)) best = x;
+    if (Number.isFinite(x) && !(x <= best)) best = x;
     return best;
   });
 }
@@ -2585,13 +2586,13 @@ export function max(source: Source): series_float {
  * 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: Source): series_float {
   let best = NaN;
   return source.map((x) => {
-    if (!Number.isNaN(x) && !(x >= best)) best = x;
+    if (Number.isFinite(x) && !(x >= best)) best = x;
     return best;
   });
 }
@@ -2647,8 +2648,8 @@ export function cog(source: Source, length: simple_int = 10): series_float {
  *
  * @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
  */
@@ -2660,7 +2661,7 @@ export function mode(source: Source, length: simple_int): series_float {
 
   for (let i = 0; i < source.length; i++) {
     const v = source[i]!;
-    if (!Number.isNaN(v)) seen.push(v);
+    if (Number.isFinite(v)) seen.push(v);
     if (seen.length < len) {
       result.push(NaN);
       continue;

package/src/table/index.ts

@@ -12,7 +12,9 @@
  * - `table.cell_set_*` changes one property of a cell (a cell that was not defined is created)
  * - a column or row outside the table is a runtime error
  * - a deleted table is `na`: its functions do nothing
- * - one live table per position: `table.new` at the position of a live table deletes that table (#176)
+ * - one live table per position and pane: `table.new` or `table.set_position` at the position of a live table with
+ *   the same `force_overlay` deletes that table (#176, #182); a table with `force_overlay = true` and one without
+ *   keep each their own position, also in an overlay script
  *
  * @version 6
  */
@@ -25,9 +27,16 @@ type HAlign = 'left' | 'center' | 'right';
 type VAlign = 'top' | 'center' | 'bottom';
 type FontFamily = 'default' | 'monospace';
 
+/** Deletes the live tables other than `keep` at `position` with the same `force_overlay` (#176, #182). */
+function freePosition(position: TablePosition, force_overlay: boolean, keep?: Table): void {
+  for (const old of allDrawings('table')) {
+    if (old !== keep && old.position === position && (old.force_overlay ?? false) === force_overlay) remove('table', old);
+  }
+}
+
 /**
- * Creates a new table (PineScript `table.new`). A live table at the same position is deleted, as PineScript keeps
- * one table per position (#176).
+ * Creates a new table (PineScript `table.new`). A live table at the same position with the same `force_overlay` is
+ * deleted, as PineScript keeps one table per position and pane (#176, #182).
  *
  * @example
  * ```typescript
@@ -46,7 +55,7 @@ export function new_table(
   border_width?: number,
   force_overlay?: boolean
 ): Table {
-  for (const old of allDrawings('table')) if (old.position === position) remove('table', old);
+  freePosition(position, force_overlay ?? false);
   return register('table', {
     position,
     columns,
@@ -196,8 +205,15 @@ function setTable<K extends keyof Table>(field: K) {
   };
 }
 
-/** Moves the table to another position (`position.*`). */
-export const set_position = setTable('position');
+/**
+ * Moves the table to another position (`position.*`). A live table at that position with the same `force_overlay` is
+ * deleted (#182).
+ */
+export function set_position(table_id: Table, position: TablePosition): void {
+  if (isDeleted(table_id)) return;
+  freePosition(position, table_id.force_overlay ?? false, table_id);
+  table_id.position = position;
+}
 /** Sets the background colour of the table. */
 export const set_bgcolor = setTable('bgcolor');
 /** Sets the colour of the outer frame. */