oakscriptjs 0.10.1 → 0.11.1

package/src/security/other.ts

@@ -0,0 +1,269 @@
+/**
+ * PineScript `request.security(symbol, timeframe, expression, gaps, lookahead)` of another symbol: which bar of the
+ * other symbol each chart bar shows (#179). The bars of the other symbol are given by the caller, already on the
+ * requested timeframe; the expression is computed on them and its values are mapped to the chart bars with the index
+ * given here. The script API does this with the `bars` accessor of its chart context.
+ *
+ * PineScript rules (measured on stocks, crypto and an exchange whose trading day starts on the previous UTC day; the
+ * chart timeframe, D, W and M on intraday and daily charts; the four gaps / lookahead combinations):
+ * - lookahead off: the last bar of the other symbol whose close time is at or before the close time of the chart bar
+ *   (a daily stock bar closes at the session end, a crypto daily bar at 00:00 UTC: a stock chart shows the crypto
+ *   bar of the day before, a crypto chart the stock bar of the same day)
+ * - lookahead on, intraday chart or intraday request: the last bar of the other symbol that opened at or before the
+ *   open of the chart bar
+ * - lookahead on, D / W / M chart and request: the last bar of the other symbol whose period starts at or before the trading day
+ *   of the chart bar: the trading day of a D bar, the Monday of a W bar, the first day of the month of an M bar, each
+ *   in the exchange time zone of its symbol (a week that opens on a Tuesday after a holiday still starts on Monday)
+ * - before the first bar of the other symbol: na; on chart bars where the other symbol has no bar (weekends,
+ *   holidays, closed hours), gaps off repeats the last value
+ * - gaps on: a value only on the chart bar where the shown bar changes (and on the first chart bar), na on the others
+ * - the last bar while it is open (`lastBarConfirmed` false) with gaps off: the realtime update shows the bar given by
+ *   lookahead on (the open bar of a higher timeframe), with lookahead off as well
+ *
+ * Close times, trading days and time zones come from the exchange calendars of the chart and of the other symbol
+ * (time zone and session, read by the session functions). Without them:
+ * - a symbol that trades every day (bars on Saturdays or Sundays; W bars at Monday 00:00 UTC; M bars on the first day
+ *   at 00:00 UTC) is on the "24x7" UTC calendar
+ * - another symbol whose bars open where the chart calendar starts its periods is on the calendar of the chart
+ * - else the UTC rule: an intraday bar closes one bar interval after its open (or at the next bar), a D / W / M bar at
+ *   the end of the last weekday (UTC) of its day / week / month; the trading day is the UTC date of the bar
+ * The fallback is exact between symbols of the same calendar and with 24x7 symbols; between a stock and a 24x7 symbol,
+ * or an exchange whose trading day starts on the previous UTC day, it needs the session of the stock.
+ *
+ * @module security/other
+ */
+
+import * as timeframe from '../timeframe/index.js';
+import { chartSessions, periodClose, periodTime, tradingDayTime, type SessionContext } from '../session/context.js';
+import type { SessionSpec } from '../session/calendar.js';
+
+const DAY = 86_400_000;
+
+/** Exchange calendar of a symbol: time zone and session (hours, corrections, holidays). */
+export interface SymbolCalendar {
+  timezone?: string;
+  session?: SessionSpec | string;
+}
+
+/** Options of {@link securityOther}. */
+export interface OtherSymbolOptions {
+  /** PineScript `barmerge.lookahead_on`; default false */
+  lookahead?: boolean;
+  /** PineScript `barmerge.gaps_on`; default false */
+  gaps?: boolean;
+  /** Calendar of the other symbol; see the module notes for the fallback */
+  other?: SymbolCalendar;
+}
+
+/** The chart: its timeframe, calendar, time unit and whether its last bar is closed. */
+export interface OtherSymbolChart extends SymbolCalendar {
+  /** Chart timeframe ("60", "1D"...) */
+  timeframe: string;
+  /** Unit of the bar times: 's' (default) or 'ms' */
+  timeUnit?: 's' | 'ms';
+  /** false: the last chart bar is still open (realtime rule) */
+  lastBarConfirmed?: boolean;
+}
+
+interface Zone {
+  timezone: string;
+  session: SessionSpec | string;
+}
+
+const calendars = new Map<string, SessionContext | null>();
+
+/** The session context of a zone and a timeframe (bar times in ms); null when the session cannot be read. */
+function calendarOf(zone: Zone | null, tf: string): SessionContext | null {
+  if (!zone) return null;
+  const key = `${zone.timezone}|${typeof zone.session === 'string' ? zone.session : JSON.stringify(zone.session)}|${tf}`;
+  let context = calendars.get(key);
+  if (context === undefined) {
+    context = { timeframe: tf, timezone: zone.timezone, session: zone.session, timeUnit: 'ms' };
+    try {
+      chartSessions(context);
+    } catch {
+      context = null;
+    }
+    if (calendars.size > 64) calendars.clear();
+    calendars.set(key, context);
+  }
+  return context;
+}
+
+const UTC_24X7: Zone = { timezone: 'Etc/UTC', session: '24x7' };
+
+/** True when bars of timeframe `tf` opening at `times` (ms) are those of a symbol that trades every day in UTC. */
+function tradesEveryDay(times: number[], tf: string): boolean {
+  if (times.length === 0) return false;
+  const info = timeframe.info(tf);
+  if (info.isweekly) return times.every((t) => t % DAY === 0 && new Date(t).getUTCDay() === 1);
+  if (info.ismonthly) return times.every((t) => t % DAY === 0 && new Date(t).getUTCDate() === 1);
+  return times.some((t) => {
+    const wd = new Date(t).getUTCDay();
+    return wd === 0 || wd === 6;
+  });
+}
+
+/** True when most of the last bars open at the start of a period of `tf` on the calendar `zone`. */
+function onCalendar(times: number[], tf: string, zone: Zone | null): boolean {
+  const calendar = calendarOf(zone, tf);
+  if (!calendar || times.length === 0) return false;
+  const last = times.slice(-50);
+  return last.filter((t) => periodTime(t, tf, calendar) === t).length >= 0.9 * last.length;
+}
+
+const utcDay = (t: number): number => Math.floor(t / DAY) * DAY;
+/** Monday 00:00 UTC of the week of the day `day` (00:00 UTC, ms). */
+const weekStart = (day: number): number => day - ((new Date(day).getUTCDay() + 6) % 7) * DAY;
+const monthStart = (day: number): number => {
+  const d = new Date(day);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
+};
+
+/** 00:00 UTC after the last weekday before `end` (00:00 UTC, ms): the end of a period of a Monday-to-Friday symbol. */
+function afterLastWeekday(end: number): number {
+  let day = end - DAY;
+  while (new Date(day).getUTCDay() % 6 === 0) day -= DAY;
+  return day + DAY;
+}
+
+/** Close time (ms) of each bar of timeframe `tf` opening at `times` (ms). */
+function closeTimes(times: number[], tf: string, zone: Zone | null): number[] {
+  const calendar = calendarOf(zone, tf);
+  const info = timeframe.info(tf);
+  const len = timeframe.in_seconds(tf) * 1000;
+  return times.map((t, i) => {
+    if (calendar) {
+      const c = periodClose(t, tf, calendar);
+      if (!Number.isNaN(c)) return c;
+    }
+    if (info.isintraday) return i + 1 < times.length ? Math.min(t + len, times[i + 1]!) : t + len;
+    const day = utcDay(t);
+    if (info.isweekly) return afterLastWeekday(weekStart(day) + 7 * DAY * info.multiplier);
+    if (info.ismonthly) {
+      const d = new Date(day);
+      return afterLastWeekday(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + info.multiplier, 1));
+    }
+    return day + DAY * info.multiplier;
+  });
+}
+
+/** Trading day (00:00 UTC, ms) of each bar opening at `times` (ms): its date in the exchange time zone. */
+function tradingDays(times: number[], zone: Zone | null): number[] {
+  const calendar = calendarOf(zone, '1D');
+  return times.map((t) => {
+    const d = calendar ? tradingDayTime(t, calendar) : NaN;
+    return Number.isNaN(d) ? utcDay(t) : d;
+  });
+}
+
+/** For each element of `at` (non-decreasing), the index of the last element of `keys` (non-decreasing) <= it; -1: none. */
+function latestAtOrBefore(keys: number[], at: number[]): number[] {
+  let j = -1;
+  return at.map((x) => {
+    while (j + 1 < keys.length && keys[j + 1]! <= x) j++;
+    return j;
+  });
+}
+
+const zoneOf = (c: SymbolCalendar | undefined): Zone | null =>
+  c?.timezone && c.session ? { timezone: c.timezone, session: c.session } : null;
+
+/** Timeframes and exchange calendars of a merge: given, 24x7, the chart's, else the UTC rule. */
+function setup(
+  ct: number[],
+  ot: number[],
+  tf: string,
+  chart: OtherSymbolChart,
+  options: OtherSymbolOptions
+): { chartTf: string; otherTf: string; chartZone: Zone | null; otherZone: Zone | null } {
+  const chartTf = timeframe.info(chart.timeframe).period;
+  const otherTf = tf.trim() === '' ? chartTf : timeframe.info(tf).period;
+  if (timeframe.info(otherTf).isticks) throw new RangeError(`request.security: tick timeframe "${tf}" is not supported.`);
+  const chartZone = zoneOf(chart) ?? (tradesEveryDay(ct, chartTf) ? UTC_24X7 : null);
+  const otherZone =
+    zoneOf(options.other) ??
+    (tradesEveryDay(ot, otherTf) ? UTC_24X7 : chartZone && onCalendar(ot, otherTf, chartZone) ? chartZone : null);
+  return { chartTf, otherTf, chartZone, otherZone };
+}
+
+/**
+ * PineScript `request.security` of another symbol: the index in `otherBars` of the bar shown on each chart bar, -1
+ * for na (#179). `otherBars` are the bars of the other symbol on `tf` ("" for the chart timeframe, or a higher
+ * or a lower one), with times in the unit of the chart bars. Rules in the module notes; the same rules hold for a
+ * lower timeframe (#181): lookahead off shows the last lower bar that closes by the close of the chart bar, lookahead
+ * on the last one that opened by its open. It also serves the chart symbol on a lower timeframe.
+ * @throws RangeError for a tick timeframe
+ */
+export function securityOther(
+  chartBars: ReadonlyArray<{ time: number }>,
+  otherBars: ReadonlyArray<{ time: number }>,
+  tf: string,
+  chart: OtherSymbolChart,
+  options: OtherSymbolOptions = {}
+): number[] {
+  const n = chartBars.length;
+  if (n === 0) return [];
+  const unit = chart.timeUnit === 'ms' ? 1 : 1000;
+  const ct = chartBars.map((b) => b.time * unit);
+  const ot = otherBars.map((b) => b.time * unit);
+  const { chartTf, otherTf, chartZone, otherZone } = setup(ct, ot, tf, chart, options);
+  if (ot.length === 0) return new Array<number>(n).fill(-1);
+
+  // by trading day when both timeframes are D / W / M; by open time with an intraday side (#181)
+  const daily = timeframe.info(chartTf).isdwm && timeframe.info(otherTf).isdwm;
+  const realtime = chart.lastBarConfirmed === false && !options.gaps;
+  let on: number[] = [];
+  if (options.lookahead || realtime) {
+    if (daily) {
+      const info = timeframe.info(otherTf);
+      const starts = tradingDays(ot, otherZone).map((d) => (info.isweekly ? weekStart(d) : info.ismonthly ? monthStart(d) : d));
+      on = latestAtOrBefore(starts, tradingDays(ct, chartZone));
+    } else {
+      on = latestAtOrBefore(ot, ct);
+    }
+  }
+  const index = options.lookahead ? on : latestAtOrBefore(closeTimes(ot, otherTf, otherZone), closeTimes(ct, chartTf, chartZone));
+  // realtime updates of the open last bar: lookahead off shows the bar of lookahead on
+  if (realtime) index[n - 1] = on[n - 1]!;
+  if (!options.gaps) return index;
+  return index.map((j, i) => (i === 0 || j !== index[i - 1] ? j : -1));
+}
+
+/**
+ * PineScript `request.security_lower_tf` (#181): for each chart bar, the range `[from, to)` of the bars of
+ * `otherBars` (a lower timeframe, the chart symbol or another one) that it contains: the bars whose close time is
+ * after the open of the chart bar and at or before its close (a 13:00 hourly bar of a 24x7 symbol is in a 13:30 stock
+ * day, which closes at 20:00). An empty range for a chart bar without such bars.
+ */
+export function securityLowerTf(
+  chartBars: ReadonlyArray<{ time: number }>,
+  otherBars: ReadonlyArray<{ time: number }>,
+  tf: string,
+  chart: OtherSymbolChart,
+  options: Pick<OtherSymbolOptions, 'other'> = {}
+): Array<[number, number]> {
+  const unit = chart.timeUnit === 'ms' ? 1 : 1000;
+  const ct = chartBars.map((b) => b.time * unit);
+  const ot = otherBars.map((b) => b.time * unit);
+  const { chartTf, otherTf, chartZone, otherZone } = setup(ct, ot, tf, chart, options);
+  const oc = closeTimes(ot, otherTf, otherZone);
+  const from = latestAtOrBefore(oc, ct);
+  const to = latestAtOrBefore(oc, closeTimes(ct, chartTf, chartZone));
+  return ct.map((_, i) => [from[i]! + 1, Math.max(from[i]! + 1, to[i]! + 1)]);
+}
+
+/**
+ * {@link securityOther} with the values of an expression: `values` has one value per bar of the other symbol; the
+ * result has one value per chart bar, NaN for na.
+ */
+export function securityOtherValues(
+  chartBars: ReadonlyArray<{ time: number }>,
+  otherBars: ReadonlyArray<{ time: number }>,
+  tf: string,
+  values: ArrayLike<number>,
+  chart: OtherSymbolChart,
+  options: OtherSymbolOptions = {}
+): number[] {
+  return securityOther(chartBars, otherBars, tf, chart, options).map((j) => (j < 0 ? NaN : (values[j] ?? NaN)));
+}

package/src/session/bars.ts

@@ -111,18 +111,25 @@ 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 and no intraday period: `time("D")`, `time("240")` and `time("60")` are
+   * 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);
     if (!at) return NaN;
     if (tf.isintraday) {
       if (this.chart.isdwm) return time;
+      // a bar after an early close has no intraday period either (#173)
+      if (this.stray(time)) return NaN;
       const [start] = this.calendar.periods(at.date)[at.index]!;
       const ms = in_seconds(tf.period) * 1000;
       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);
@@ -137,9 +144,11 @@ export class SessionBars {
       const [, end] = this.calendar.periods(at.date)[at.index]!;
       // on D / W / M charts: the end of the session period that contains the bar open
       if (this.chart.isdwm) return end;
+      if (this.stray(time)) return NaN;
       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 +163,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 +197,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;
@@ -200,6 +238,25 @@ export class SessionBars {
   }
 }
 
+/**
+ * Periods of the chart bars that open after an early close, for `request.security` (#173): such a bar has no period
+ * (`time("D")` and `time("240")` are na on it), but PineScript resamples it into the D / W / M bar of the bar before
+ * it, and into an intraday bar of its own (opening at the bar's time). The bar before it still completes its period
+ * (its day period is cut there). `intradayMs` is the duration of an intraday timeframe, null for D / W / M.
+ * Changes `starts` and `dayPeriods` in place.
+ */
+export function strayPeriods(starts: number[], dayPeriods: number[], times: number[], bars: SessionBars, intradayMs: number | null): void {
+  for (let i = 1; i < starts.length; i++) {
+    if (!bars.stray(times[i]!)) continue;
+    if (Number.isNaN(starts[i]!)) {
+      // intraday: periods of `intradayMs` from the first such bar ("240": 18:30 and 20:30 are one bar)
+      const run = Number.isNaN(dayPeriods[i - 1]!) && times[i]! < starts[i - 1]! + (intradayMs ?? 0);
+      starts[i] = intradayMs === null || run ? starts[i - 1]! : times[i]!;
+    }
+    dayPeriods[i] = NaN;
+  }
+}
+
 /** PineScript `session.*` flags of each bar. */
 export interface SessionFlags {
   isfirstbar: boolean[];
@@ -217,6 +274,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 +302,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[] {
@@ -90,11 +94,16 @@ function pineVersion(text: string, from: DateNum): Version {
   const ranges = parsePineSession(text);
   if (ranges === null) throw new SyntaxError(`Session "${text}" is the symbol session`);
   const byDay: Period[][] = Array.from({ length: 8 }, () => []);
-  for (const { start, end, days } of ranges) {
+  for (const { start, end, days, startDays } of ranges) {
+    // a run that ends at 0000 ends at 24:00 of the day it starts and belongs to that day (#173)
     const period: Period =
       start === 0 && end === 0
         ? { start: 0, end: 1440, startOffset: 0, endOffset: 0 }
-        : { start, end, startOffset: end <= start ? 1 : 0, endOffset: 0 };
+        : startDays !== undefined
+          ? { start, end, startOffset: startDays, endOffset: 0 }
+          : end === 0
+            ? { start, end: 1440, startOffset: 0, endOffset: 0 }
+            : { start, end, startOffset: end <= start ? 1 : 0, endOffset: 0 };
     for (const d of days) byDay[d]!.push(period);
   }
   return { from, periods: [], days: byDay.map((p) => p.length > 0), byDay };
@@ -102,6 +111,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';
@@ -118,17 +138,22 @@ export class TradingCalendar {
   private readonly corrections = new Map<DateNum, Period[] | null>();
   private readonly holidays: Set<DateNum>;
   private readonly cache = new Map<DateNum, Array<[number, number]>>();
+  private readonly pine: boolean;
 
   /**
    * @param timezone - Time zone of the session hours (the exchange time zone)
    * @param spec - Session information (hours, corrections, holidays)
    * @param rule - Days without ":days": 'symbol' (Monday to Friday) or 'pine' (PineScript session strings)
+   * @param dayPlacement - PineScript session strings read for `time("D", session)`: the wall times of a clock-change
+   *   day are placed as the JVM does (see `periods`); without it, as `time.inSession` places them
    */
   constructor(
     readonly timezone: string,
     spec: SessionSpec,
-    rule: 'symbol' | 'pine' = 'symbol'
+    rule: 'symbol' | 'pine' = 'symbol',
+    dayPlacement = false
   ) {
+    this.pine = rule === 'pine' && dayPlacement;
     const [first = '', ...changes] = spec.session.split('#');
     this.versions = [parseVersion(first, 0, spec.session, rule)];
     for (const change of changes) {
@@ -162,10 +187,16 @@ export class TradingCalendar {
     const y = Math.floor(date / 10000);
     const m = Math.floor(date / 100) % 100;
     const d = date % 100;
-    out = periods.map((p) => [
-      zonedToUnix(this.timezone, y, m, d - p.startOffset, Math.floor(p.start / 60), p.start % 60),
-      zonedToUnix(this.timezone, y, m, d - p.endOffset, Math.floor(p.end / 60), p.end % 60),
-    ]);
+    const at = (dd: number, minutes: number, earlier = false): number =>
+      zonedToUnix(this.timezone, y, m, dd, Math.floor(minutes / 60), minutes % 60, 0, earlier);
+    // for "D", PineScript session strings place the wall times of a clock-change day as the JVM does: a skipped time moves
+    // past the gap, a repeated time is its first pass, and the end is the minute before it plus one minute ("0000-0300"
+    // on a 02:00 -> 03:00 night ends at 03:00 of the old offset, "0000-0400" at 04:00 of the new one) (#173)
+    out = periods.map((p) =>
+      this.pine
+        ? [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)]
+    );
     this.cache.set(date, out);
     return out;
   }
@@ -174,6 +205,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.