oakscriptjs 0.10.0 → 0.11.0

package/src/script/index.ts

@@ -69,6 +69,7 @@ import type {
   FillConfig,
   HLineConfig,
   InputConfig,
+  InputCondition,
   PlotConfig,
   ShapeConfig,
 } from '../runtime/types.js';
@@ -86,12 +87,14 @@ import * as tableCore from '../table/index.js';
 import * as chartPointCore from '../chartpoint/index.js';
 import * as textCore from '../text/index.js';
 import * as mathCore from '../math/index.js';
-import { resetDrawings, setDrawingLimits } from '../drawing/registry.js';
+import { resetDrawings, setDrawingBar, setDrawingLimits } from '../drawing/registry.js';
+export { holdDrawing, releaseDrawing, varDrawing, type DrawingVariable } from '../drawing/registry.js';
 import { drawingOutputs } from '../drawing/output.js';
 import * as timeframeCore from '../timeframe/index.js';
 import * as timeCore from '../time/index.js';
 import * as strCore from '../str/index.js';
 import { formatMessage } from '../str/messageformat.js';
+import { tickScale } from '../str/numberformat.js';
 import { TradingCalendar, type SessionSpec } from '../session/calendar.js';
 import { SessionBars, sessionFlags, type SessionFlags } from '../session/bars.js';
 import { afterCompletion, heikinAshi, mapToChart, periodsOf, resample } from '../security/resample.js';
@@ -294,6 +297,7 @@ export function executeScript(
 ): ScriptRunResult {
   ctxBars.setAll(barsInput);
   chartCtx = { ...chart };
+  runNow = chart.now ?? Date.now();
   scriptOptions = options;
   ctx = freshCollector(inputs);
   resetDrawings();
@@ -380,13 +384,19 @@ function declare(c: Collector, kind: 'indicator' | 'strategy'): void {
   c.declaration = kind;
 }
 
-/** Options of every `input.*` kind (PineScript `group`, `inline`, `tooltip`, `confirm`, `display`). */
+/** Options of every `input.*` kind (PineScript `group`, `inline`, `tooltip`, `confirm`, `display`, `active`). */
 export interface InputOptions {
   group?: string;
   inline?: string;
   tooltip?: string;
   confirm?: boolean;
   display?: InputConfig['display'];
+  /**
+   * PineScript `active`: false greys the input out in the settings (it keeps its value). A boolean as in
+   * PineScript (`active: showMa`), or a condition on input ids that a host can apply without running the script
+   * (`active: 'ma_1'`, `active: { input: 'type', ne: 'None' }`)
+   */
+  active?: boolean | InputCondition;
 }
 
 export interface NumericInputOptions extends InputOptions {
@@ -407,6 +417,7 @@ function common(opts: InputOptions): Partial<InputConfig> {
   if (opts.tooltip !== undefined) out.tooltip = opts.tooltip;
   if (opts.confirm !== undefined) out.confirm = opts.confirm;
   if (opts.display !== undefined) out.display = opts.display;
+  if (opts.active !== undefined) out.active = opts.active;
   return out;
 }
 
@@ -538,25 +549,27 @@ export const ta = {
   ): [Series, Series, Series, Series, Series] =>
     taSeries.ichimoku(bars(), conversionPeriods, basePeriods, laggingSpan2Periods, displacement),
   /** `ta.highest(source, length)` or `ta.highest(length)` (source = high). */
-  highest: (sourceOrLength: Series | number, length?: number): Series =>
+  highest: (sourceOrLength: Series | number, length?: number | Series): Series =>
     typeof sourceOrLength === 'number' ? taSeries.highest(high, sourceOrLength) : taSeries.highest(sourceOrLength, length!),
   /** `ta.lowest(source, length)` or `ta.lowest(length)` (source = low). */
-  lowest: (sourceOrLength: Series | number, length?: number): Series =>
+  lowest: (sourceOrLength: Series | number, length?: number | Series): Series =>
     typeof sourceOrLength === 'number' ? taSeries.lowest(low, sourceOrLength) : taSeries.lowest(sourceOrLength, length!),
   /** `ta.highestbars(source, length)` or `ta.highestbars(length)` (source = high); offsets are 0 or negative. */
-  highestbars: (sourceOrLength: Series | number, length?: number): Series =>
+  highestbars: (sourceOrLength: Series | number, length?: number | Series): Series =>
     typeof sourceOrLength === 'number'
       ? taSeries.highestbars(high, sourceOrLength)
       : taSeries.highestbars(sourceOrLength, length!),
   /** `ta.lowestbars(source, length)` or `ta.lowestbars(length)` (source = low); offsets are 0 or negative. */
-  lowestbars: (sourceOrLength: Series | number, length?: number): Series =>
+  lowestbars: (sourceOrLength: Series | number, length?: number | Series): Series =>
     typeof sourceOrLength === 'number'
       ? taSeries.lowestbars(low, sourceOrLength)
       : taSeries.lowestbars(sourceOrLength, length!),
   /** `ta.vwap(source, anchor?, stdev_mult?)` with the chart volume; the default anchor is a new trading
-   *  day (`timeframe.change("1D")`), which needs the chart context (timeframe, time zone, session). */
+   *  day (`timeframe.change("1D")`), which needs the chart context (timeframe, time zone, session), and the
+   *  first bar: as in PineScript, the first loaded bars (a day in progress) have a value. */
   vwap: ((source: Series, anchor?: Series, stdev_mult?: number): Series | [Series, Series, Series] => {
-    const a = anchor ?? changeOf('1D'); // PineScript default: timeframe.change("1D")
+    // PineScript default: timeframe.change("1D"); the sums also start on the first bar (a day in progress)
+    const a = anchor ?? changeOf('1D', true);
     return stdev_mult === undefined ? taSeries.vwap(source, volume, a) : taSeries.vwapBands(source, volume, a, stdev_mult);
   }) as {
     (source: Series, anchor?: Series): Series;
@@ -566,12 +579,12 @@ export const ta = {
   mfi: (source: Series, length: number): Series => taSeries.mfi(source, length, volume),
   /** `ta.pivothigh(source, leftbars, rightbars)` or `ta.pivothigh(leftbars, rightbars)` (source = high).
    *  The value appears `rightbars` bars after the pivot bar, as in PineScript. */
-  pivothigh: (sourceOrLeft: Series | number, leftOrRight: number, rightbars?: number): Series =>
+  pivothigh: (sourceOrLeft: Series | number, leftOrRight: number | Series, rightbars?: number | Series): Series =>
     typeof sourceOrLeft === 'number'
       ? taSeries.pivothigh(high, sourceOrLeft, leftOrRight)
       : taSeries.pivothigh(sourceOrLeft, leftOrRight, rightbars!),
   /** `ta.pivotlow(source, leftbars, rightbars)` or `ta.pivotlow(leftbars, rightbars)` (source = low). */
-  pivotlow: (sourceOrLeft: Series | number, leftOrRight: number, rightbars?: number): Series =>
+  pivotlow: (sourceOrLeft: Series | number, leftOrRight: number | Series, rightbars?: number | Series): Series =>
     typeof sourceOrLeft === 'number'
       ? taSeries.pivotlow(low, sourceOrLeft, leftOrRight)
       : taSeries.pivotlow(sourceOrLeft, leftOrRight, rightbars!),
@@ -1253,6 +1266,7 @@ export function eachBar(fn: (c: BarContext) => number | boolean | void): Series
     for (idx = 0; idx < b.length; idx++) {
       if (pendingError && pendingError.bar === idx) throw new Error(historyError(idx, pendingError.barsBack));
       currentBar = idx;
+      setDrawingBar(idx, idx === b.length - 1);
       const r = fn(ctx);
       out[idx] = typeof r === 'number' ? r : typeof r === 'boolean' ? (r ? 1 : 0) : NaN;
       // grow the history buffers from the largest reference of this bar
@@ -1269,6 +1283,7 @@ export function eachBar(fn: (c: BarContext) => number | boolean | void): Series
     }
   } finally {
     currentBar = -1;
+    setDrawingBar(null);
   }
   return Series.fromArray(ctxBars, out);
 }
@@ -1522,12 +1537,32 @@ export interface ChartContext {
   tickerid?: string;
   /** Unit of `Bar.time`: 's' (default, as lightweight-charts) or 'ms'. PineScript times are in ms. */
   timeUnit?: 's' | 'ms';
-  /** Minimum price move of the symbol (PineScript `syminfo.mintick`), e.g. 0.01; used by `math.round_to_mintick` */
+  /**
+   * Minimum price move of the symbol (PineScript `syminfo.mintick`), e.g. 0.01; used by `math.round_to_mintick` and
+   * `format.mintick`. Default: `minmove / pricescale` when both are given
+   */
   mintick?: number;
+  /**
+   * PineScript `syminfo.minmove` and `syminfo.pricescale` (mintick = minmove / pricescale). Default: from `mintick`,
+   * with pricescale 10^(its decimals) (0.25 is 25 / 100). Pass them for a symbol priced in fractions (1 / 32):
+   * `format.mintick` shows floor(log10(pricescale)) decimals
+   */
+  minmove?: number;
+  pricescale?: number;
   /** Currency value of one point of price move for one contract (PineScript `syminfo.pointvalue`); 1 for stocks */
   pointvalue?: number;
   /** Smallest tradable quantity (PineScript `syminfo.mincontract`); 1 for whole shares */
   mincontract?: number;
+  /** Symbol type (PineScript `syminfo.type`): "stock", "crypto", "forex", "futures", "index", "fund"... */
+  symbolType?: string;
+  /** Currency of the symbol (PineScript `syminfo.currency`), e.g. "USD" */
+  currency?: string;
+  /** Chart foreground colour (PineScript `chart.fg_color`), e.g. "#DBDBDB" on a dark chart */
+  foregroundColor?: string;
+  /** Chart background colour (PineScript `chart.bg_color`), e.g. "#0F0F0F" on a dark chart */
+  backgroundColor?: string;
+  /** Current time in ms (PineScript `timenow`); default: the clock of the computer at the start of the run */
+  now?: number;
   /**
    * The last bar is closed (`barstate.isconfirmed` on the last bar). Default false: PineScript treats the last bar
    * of the data as not confirmed until the data feed closes it.
@@ -1611,19 +1646,48 @@ function symbolProperty(key: 'mintick' | 'pointvalue' | 'mincontract'): number {
   collector();
   const value = chartCtx[key];
   if (value === undefined) {
+    if (key === 'mintick' && chartCtx.minmove !== undefined && chartCtx.pricescale !== undefined) {
+      return chartCtx.minmove / chartCtx.pricescale;
+    }
     throw new Error(`syminfo.${key} is not known: pass it as executeScript(body, bars, inputs, { ${key} }).`);
   }
   return value;
 }
 
+/** A text value of the chart or the symbol that the host passes in the chart context. */
+function chartText(key: 'symbolType' | 'currency' | 'foregroundColor' | 'backgroundColor', name: string): string {
+  collector();
+  const value = chartCtx[key];
+  if (value === undefined) {
+    throw new Error(`${name} is not known: pass it as executeScript(body, bars, inputs, { ${key} }).`);
+  }
+  return value;
+}
+
+/** `[minmove, pricescale]` of the chart symbol: from the chart context, else from its mintick. */
+function symbolScale(): [number, number] {
+  collector();
+  const { minmove, pricescale } = chartCtx;
+  if (minmove !== undefined && pricescale !== undefined) return [minmove, pricescale];
+  const [move, scale] = tickScale(symbolProperty('mintick'), pricescale);
+  return [minmove ?? move, scale];
+}
+
 /**
  * PineScript `syminfo.timezone`, `syminfo.tickerid`, `syminfo.session` (session type), `syminfo.mintick`,
- * `syminfo.pointvalue` and `syminfo.mincontract`, from the chart context.
+ * `syminfo.minmove`, `syminfo.pricescale`, `syminfo.pointvalue`, `syminfo.mincontract`, `syminfo.type` and
+ * `syminfo.currency`, from the chart context.
  */
 export const syminfo = {
   get mintick(): number {
     return symbolProperty('mintick');
   },
+  get minmove(): number {
+    return symbolScale()[0];
+  },
+  get pricescale(): number {
+    return symbolScale()[1];
+  },
   get pointvalue(): number {
     return symbolProperty('pointvalue');
   },
@@ -1644,6 +1708,12 @@ export const syminfo = {
     collector();
     return chartCtx.sessionType ?? 'regular';
   },
+  get type(): string {
+    return chartText('symbolType', 'syminfo.type');
+  },
+  get currency(): string {
+    return chartText('currency', 'syminfo.currency');
+  },
 };
 
 /** A calendar function: `(time, timezone?)` on a UNIX time or on a Series of times. */
@@ -1709,9 +1779,11 @@ export function inSession(time: number, session: string, timezone?: string): boo
 /** PineScript `str.*`; `format_time` and the dates of `format` use the exchange time zone by default. */
 export const str = {
   ...strCore,
-  // format.mintick rounds to the chart symbol's tick (syminfo.mintick)
-  tostring: ((value: unknown, format?: string, mintick?: number) =>
-    strCore.tostring(value as never, format, format === 'mintick' ? (mintick ?? syminfo.mintick) : mintick)) as typeof strCore.tostring,
+  // format.mintick uses the chart symbol's tick and price scale (syminfo.mintick, syminfo.pricescale)
+  tostring: ((value: unknown, format?: string, mintick?: number, pricescale?: number) =>
+    format === 'mintick' && mintick === undefined
+      ? strCore.tostring(value as never, format, syminfo.mintick, pricescale ?? syminfo.pricescale)
+      : strCore.tostring(value as never, format, mintick, pricescale)) as typeof strCore.tostring,
   format_time(time: number, format: string = "yyyy-MM-dd'T'HH:mm:ssZ", timezone?: string): string {
     return strCore.format_time(time, format, timezone ?? exchangeTimezone());
   },
@@ -1755,7 +1827,10 @@ function sessionBars(): { bars: SessionBars; regular: SessionBars } {
  * 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): { bars: SessionBars; test: boolean } {
+function calendarFor(
+  session?: string,
+  timezone?: string
+): { bars: SessionBars; test: boolean; inside?: (time: number) => boolean } {
   const { bars } = sessionBars();
   if (!session && !timezone) return { bars, test: false };
   const tz = timezone ?? exchangeTimezone();
@@ -1767,7 +1842,14 @@ function calendarFor(session?: string, timezone?: string): { bars: SessionBars;
     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'), bars.chart.period), test: true };
+  return {
+    bars: new SessionBars(new TradingCalendar(tz, spec, session ? 'pine' : 'symbol'), 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 {
@@ -1784,22 +1866,28 @@ function callableSeries<F extends (...args: never[]) => Series>(series: Series,
 
 function timeFunction(tf?: string, session?: string, timezone?: string): Series {
   collector();
-  const { bars, test } = calendarFor(session, timezone);
+  const { bars, test, inside } = calendarFor(session, timezone);
   const timeframeString = tf || chartTimeframe().period;
-  return perBar((t) => (test && !bars.inside(t) ? NaN : bars.timeOf(t, timeframeString)));
+  return perBar((t) => (test && !(inside ? inside(t) : bars.inside(t)) ? NaN : bars.timeOf(t, timeframeString)));
 }
 
 function timeCloseFunction(tf?: string, session?: string, timezone?: string): Series {
   collector();
-  const { bars, test } = calendarFor(session, timezone);
+  const { bars, test, inside } = calendarFor(session, timezone);
   const timeframeString = tf || chartTimeframe().period;
-  return perBar((t) => (test && !bars.inside(t) ? NaN : bars.closeOf(t, timeframeString)));
+  return perBar((t) => (test && !(inside ? inside(t) : bars.inside(t)) ? NaN : bars.closeOf(t, timeframeString)));
 }
 
 /**
  * PineScript `time`: the bar open time in ms (a Series), and `time(timeframe?, session?, timezone?)`:
  * the open time of the `timeframe` period that contains the bar, `na` outside `session`.
  */
+/** Current time of the run in ms, see `ChartContext.now`. */
+let runNow = NaN;
+
+/** PineScript `timenow`: the current time in ms, the same on every bar of a run (`ChartContext.now`). */
+export const timenow = new Series(ctxBars, () => runNow);
+
 export const time = callableSeries(new Series(ctxBars, (b) => barTime(b)), timeFunction);
 
 /**
@@ -1814,9 +1902,11 @@ export const time_close = callableSeries(
 /** PineScript `time_tradingday`: 00:00 UTC of the trading day of each bar, in ms. */
 export const time_tradingday = new Series(ctxBars, (b) => sessionBars().bars.tradingDayTime(barTime(b)));
 
-function changeOf(tf: string): Series {
+function changeOf(tf: string, firstBar = false): Series {
   const { bars } = sessionBars();
-  return perBar((t, i, times) => (i > 0 && bars.timeOf(t, tf) !== bars.timeOf(times[i - 1]!, tf) ? 1 : 0));
+  // a bar without a period (after an early close) is no change, and neither is the bar after it
+  const changed = (a: number, b: number): boolean => !Number.isNaN(a) && !Number.isNaN(b) && a !== b;
+  return perBar((t, i, times) => ((i > 0 ? changed(bars.timeOf(t, tf), bars.timeOf(times[i - 1]!, tf)) : firstBar) ? 1 : 0));
 }
 
 function flag(key: keyof SessionFlags): Series {
@@ -2052,6 +2142,14 @@ export const text = { ...textCore };
  * (index, time, and `price`, default the close), so it runs inside eachBar().
  */
 export const chart = {
+  /** Chart foreground colour (PineScript `chart.fg_color`), from the chart context. */
+  get fg_color(): string {
+    return chartText('foregroundColor', 'chart.fg_color');
+  },
+  /** Chart background colour (PineScript `chart.bg_color`), from the chart context. */
+  get bg_color(): string {
+    return chartText('backgroundColor', 'chart.bg_color');
+  },
   point: {
     ...chartPointCore,
     now(price?: number): ChartPoint {
@@ -2115,11 +2213,13 @@ export const math = {
   }) as typeof mathCore.round_to_mintick,
 };
 export * as compare from '../compare/index.js';
+export { isInputActive } from '../runtime/input-active.js';
 export type {
   Bar,
   IndicatorResult,
   TimeValue,
   InputConfig,
+  InputCondition,
   PlotConfig,
   HLineConfig,
   FillConfig,

package/src/session/bars.ts

@@ -111,7 +111,10 @@ export class SessionBars {
     return p[p.length - 1]![1];
   }
 
-  /** PineScript `time(tf)` for a bar that opens at `time`; NaN when no trading day is found. */
+  /**
+   * PineScript `time(tf)` for a bar that opens at `time`; NaN when no trading day is found. An intraday bar that
+   * opens after an early close has no day: `time("D")` is NaN on it (measured; `time("W")` keeps its value).
+   */
   timeOf(time: number, timeframe: string): number {
     const tf = info(timeframe);
     const at = this.calendar.locate(time);
@@ -123,6 +126,7 @@ export class SessionBars {
       return start + Math.floor((time - start) / ms) * ms;
     }
     const { unit, n } = unitOf(tf);
+    if (unit === 'D' && n === 1 && this.stray(time)) return NaN;
     const [from, to] = this.periodRange(at.date, unit, n);
     const first = this.calendar.firstTradingDay(from, to);
     return first === null ? NaN : this.dayStart(first);
@@ -140,6 +144,7 @@ export class SessionBars {
       return Math.min(this.timeOf(time, timeframe) + in_seconds(tf.period) * 1000, end);
     }
     const { unit, n } = unitOf(tf);
+    if (unit === 'D' && n === 1 && this.stray(time)) return NaN;
     const [from, to] = this.periodRange(at.date, unit, n);
     // intraday charts: the start of the next period, except "1D" (the session end)
     if (this.chart.isintraday && (unit !== 'D' || n > 1)) {
@@ -154,7 +159,7 @@ export class SessionBars {
   /** Trading day of a bar: on D / W / M charts the last trading day of the chart period. */
   tradingDay(time: number): DateNum | null {
     const at = this.calendar.locate(time);
-    if (!at) return null;
+    if (!at || this.stray(time)) return null;
     if (this.chart.isdwm) {
       const { unit, n } = unitOf(this.chart);
       const [from, to] = this.periodRange(at.date, unit, n);
@@ -188,6 +193,35 @@ export class SessionBars {
     return day === null ? NaN : dateUtcMs(day);
   }
 
+  /**
+   * Open time of the bar after the bar that opens at `time`, on the trading calendar: the next bar of the session
+   * period, else the start of the next period or trading day; on D / W / M charts the session start of the first
+   * trading day of the next chart period. NaN when none is found within 400 days.
+   */
+  nextBarTime(time: number): number {
+    const at = this.calendar.locate(time);
+    if (!at) return NaN;
+    if (!this.chart.isdwm) {
+      const periods = this.calendar.periods(at.date);
+      const [start, end] = periods[at.index]!;
+      const ms = in_seconds(this.chart.period) * 1000;
+      const next = start + (Math.floor((time - start) / ms) + 1) * ms;
+      if (at.inside && next < end) return next;
+      if (at.index + 1 < periods.length) return periods[at.index + 1]![0];
+      const day = this.calendar.firstTradingDay(addDays(at.date, 1), addDays(at.date, 400));
+      return day === null ? NaN : this.dayStart(day);
+    }
+    const { unit, n } = unitOf(this.chart);
+    const [, to] = this.periodRange(at.date, unit, n);
+    const day = this.calendar.firstTradingDay(addDays(to, 1), addDays(to, 400));
+    return day === null ? NaN : this.dayStart(day);
+  }
+
+  /** An intraday bar that opens after an early close of its day (see TradingCalendar.afterEarlyClose). */
+  stray(time: number): boolean {
+    return !this.chart.isdwm && this.calendar.afterEarlyClose(time);
+  }
+
   /** True when the bar at `time` is inside the session. */
   inside(time: number): boolean {
     return this.calendar.locate(time)?.inside ?? false;
@@ -217,6 +251,9 @@ export interface SessionFlags {
  * time; first and last bars are per session period (a trading day can have two periods, e.g. after a
  * futures holiday); pre / post market compare with the regular hours of the same trading day; on
  * D / W / M charts every bar is its own session (first, last, market, first and last regular).
+ * The first loaded bar is a first bar only when no earlier bar of its period can exist (it opens less than one chart
+ * period after the period start). A bar that opens after an early close is in the market hours (the usual hours of
+ * its day) but is no last bar.
  */
 export function sessionFlags(times: number[], bars: SessionBars, regular: SessionBars): SessionFlags {
   const n = times.length;
@@ -242,18 +279,22 @@ export function sessionFlags(times: number[], bars: SessionBars, regular: Sessio
     const close = bars.closeOf(t, chart.period);
     const [, end] = bars.calendar.periods(at.date)[at.index]!;
     const period = `${at.date}/${at.index}`;
-    out.isfirstbar[i] = period !== previousPeriod;
-    out.islastbar[i] = close >= end;
+    const [start] = bars.calendar.periods(at.date)[at.index]!;
+    const barMs = in_seconds(chart.period) * 1000;
+    // the first loaded bar: a first bar only when no earlier bar of the period can exist
+    out.isfirstbar[i] = i === 0 ? t - start < barMs : period !== previousPeriod;
+    const stray = bars.stray(t);
+    out.islastbar[i] = !stray && close >= end;
     const regularPeriods = regular.calendar.periods(at.date);
     const r = regularPeriods.findIndex(([s, e]) => s <= t && t < e);
     const market = r !== -1;
-    out.ismarket[i] = market;
+    out.ismarket[i] = market || regular.stray(t);
     if (!market && regularPeriods.length) {
       out.ispremarket[i] = t < regularPeriods[0]![0];
       out.ispostmarket[i] = t >= regularPeriods[regularPeriods.length - 1]![1];
     }
     const regularPeriod = market ? `${at.date}/${r}` : '';
-    out.isfirstbar_regular[i] = market && regularPeriod !== previousRegular;
+    out.isfirstbar_regular[i] = market && (i === 0 ? t - regularPeriods[r]![0] < barMs : regularPeriod !== previousRegular);
     out.islastbar_regular[i] = market && close >= regularPeriods[r]![1];
     previousPeriod = period;
     previousRegular = regularPeriod;

package/src/session/calendar.ts

@@ -6,7 +6,10 @@
  * - periods "HHMM-HHMM", several separated by commas; "24x7" is the whole day, every day
  * - a period whose end is not after its start ("1700-1600", "1700-1700") starts the day before the
  *   trading day: the session that opens Sunday 17:00 is Monday's
- * - "HHMMF<n>" moves a time <n> days before the trading day ("1700F2-1200F1")
+ * - "HHMMF<n>" moves a time <n> days before the trading day ("1700F2-1200F1"); "F" alone is one day ("1700F-1900":
+ *   17:00 of the day before to 19:00)
+ * - several sections joined by "|", each with its own days ("1900-1900:3456|1700F-1900:2": Monday opens on Sunday
+ *   17:00, the other days at 19:00 of the day before)
  * - optional days after ":" (1 = Sunday ... 7 = Saturday); without days a symbol session trades Monday to
  *   Friday ("24x7": every day), and a PineScript session string follows PineScript's rules (one period:
  *   every day; several periods: Monday to Friday)
@@ -62,9 +65,10 @@ export const weekdayOf = (date: DateNum): number => new Date(utcOf(date)).getUTC
 export const dateUtcMs = utcOf;
 
 function parseTime(token: string, spec: string): { minutes: number; offset?: number } {
-  const m = /^(\d{2})(\d{2})(?:F(\d+))?$/.exec(token.trim());
+  const m = /^(\d{2})(\d{2})(?:F(\d*))?$/.exec(token.trim());
   if (!m) throw new SyntaxError(`Invalid session "${spec}"`);
-  return { minutes: Number(m[1]) * 60 + Number(m[2]), offset: m[3] === undefined ? undefined : Number(m[3]) };
+  // "F" without a number is one day before the trading day
+  return { minutes: Number(m[1]) * 60 + Number(m[2]), offset: m[3] === undefined ? undefined : Number(m[3] || 1) };
 }
 
 function parsePeriods(text: string, spec: string): Period[] {
@@ -102,6 +106,17 @@ function pineVersion(text: string, from: DateNum): Version {
 
 function parseVersion(text: string, from: DateNum, spec: string, rule: 'symbol' | 'pine'): Version {
   if (rule === 'pine') return pineVersion(text, from);
+  if (text.includes('|')) {
+    // sections with their own days
+    const byDay: Period[][] = Array.from({ length: 8 }, () => []);
+    for (const section of text.split('|').filter((part) => part.trim())) {
+      const one = parseVersion(section, from, spec, rule);
+      one.days.forEach((on, d) => {
+        if (on) byDay[d] = one.periods;
+      });
+    }
+    return { from, periods: [], days: byDay.map((p) => p.length > 0), byDay };
+  }
   const [periodText = '', dayText] = text.trim().split(':');
   const periods = parsePeriods(periodText, spec);
   const allDays = periodText.trim() === '24x7';
@@ -174,6 +189,25 @@ export class TradingCalendar {
     return this.periods(date).length > 0;
   }
 
+  /**
+   * True for a bar that opens after the session of its day was cut by a correction (an early close) but inside the
+   * usual hours of that day: PineScript has no period for such a bar (`time("D")` is na on it).
+   */
+  afterEarlyClose(time: number): boolean {
+    const at = this.locate(time);
+    if (!at || at.inside || !this.corrections.get(at.date)) return false;
+    const version = [...this.versions].reverse().find((v) => v.from <= at.date)!;
+    const usual = version.byDay ? version.byDay[weekdayOf(at.date)]! : version.days[weekdayOf(at.date)] ? version.periods : [];
+    const y = Math.floor(at.date / 10000);
+    const m = Math.floor(at.date / 100) % 100;
+    const d = at.date % 100;
+    return usual.some(
+      (p) =>
+        zonedToUnix(this.timezone, y, m, d - p.startOffset, Math.floor(p.start / 60), p.start % 60) <= time &&
+        time < zonedToUnix(this.timezone, y, m, d - p.endOffset, Math.floor(p.end / 60), p.end % 60)
+    );
+  }
+
   /**
    * Trading day and period of a time: the period that contains it, else the last period that started
    * before it. Null when no trading day is found near the time.