oakscriptjs 0.9.4 → 0.9.6

package/src/ta/running-sum.ts

@@ -6,7 +6,8 @@
  * - each bar first removes, with a Kahan step, the compensated value that was added for the value that leaves the
  *   window, then adds the new value with a Kahan step and keeps its compensated value;
  * - when the compensation of the previous step would be lost when applied to the new value, the sum is computed
- *   again from the window values (newest first) and the compensation is reset.
+ *   again from the window values (newest first) and the compensation is reset. The test moves the new value toward
+ *   +infinity by the size of the compensation, in floating point (#136, #142).
  *
  * So the result can differ from the exact window sum in the last bits (e.g. a small residue on a window of zeros),
  * as in PineScript.
@@ -14,104 +15,228 @@
  * @internal
  */
 
-const view = new DataView(new ArrayBuffer(8));
-
-/** Binary exponent of a finite non-zero number (from its bits). */
-function exponentOf(x: number): number {
-  view.setFloat64(0, x);
-  const e = (view.getUint16(0) >> 4) & 0x7ff;
-  return e === 0 ? -1074 : e - 1023;
-}
-
 /**
- * Whether the compensation `c` is (partly) lost when it is applied to `x`: `x - c` rounded on the grid of `x`
- * (spacing of the binade of `x`, ties to an even mantissa) applies less than `c`.
+ * Whether the compensation `c` is (partly) lost when it is applied to `x`: `x + |c|` in floating point moves `x` by
+ * less than `|c|`. Moving toward +infinity uses the grid above `x` (the coarser binade just below a power of two, the
+ * finer binade for a negative power of two), as PineScript (measured bit for bit, #142).
  */
 function compensationLost(x: number, c: number): boolean {
   if (c === 0 || x === 0) return false;
-  const ulp = 2 ** (exponentOf(x) - 52);
-  const q = c / ulp;
-  const mantissa = x / ulp;
-  const f = Math.floor(q);
-  const d = q - f;
-  const applied = d > 0.5 ? f + 1 : d < 0.5 ? f : (mantissa - f) % 2 === 0 ? f : f + 1;
-  return Math.abs(applied) < Math.abs(q);
+  const size = Math.abs(c);
+  return Math.abs(x + size - x) < size;
 }
 
 /** A value PineScript treats as na in window functions (also +/-Infinity). */
-function isNa(v: number | null | undefined): boolean {
+export function isNa(v: number | null | undefined): boolean {
   return v === undefined || v === null || !Number.isFinite(v);
 }
 
 /**
- * The sum of the last `length` non-na values on each bar, as PineScript computes it.
+ * Running sum state, one value at a time. {@link step} computes the sum with a new value from the kept state without
+ * changing it; {@link commit} keeps the last step. So several candidate values can be tried on one bar and only the
+ * last one kept (a ta.* call in a loop).
  *
- * @param source - Values (na: NaN, null, undefined or +/-Infinity, skipped)
- * @param length - Number of non-na values in the window
- * @returns The running sum per bar: NaN until `length` non-na values exist; a bar with an na value keeps the
- *   previous result
+ * The length can change from one step to the next (a series length). PineScript then first moves the kept sum to the
+ * new length with Kahan steps of the raw values (not the stored compensated values): a smaller length removes the
+ * values that leave the window, oldest first; a larger length adds back the values from the one before the old window
+ * down to the one `length` values back, newest first (one more than the window needs). Then the usual step runs with
+ * the new length: it removes the stored value of the one `length` values back and adds the new value.
  */
-export function runningSum(source: ArrayLike<number | null | undefined>, length: number): number[] {
-  const len = Math.floor(length);
-  const out: number[] = new Array<number>(source.length).fill(NaN);
-  if (!(len >= 1)) return out;
-  const values: number[] = [];
-  const stored: number[] = [];
-  let s = 0;
-  let c = 0;
-  let previous = NaN;
-  const kahanAdd = (v: number): number => {
-    const y = v - c;
-    const t = s + y;
-    c = (t - s) - y;
-    s = t;
-    return y;
-  };
-  for (let i = 0; i < source.length; i++) {
-    const v = source[i];
-    if (isNa(v)) {
-      out[i] = previous;
-      continue;
+export class RunningSum {
+  private readonly values: number[] = [];
+  private readonly stored: number[] = [];
+  private keptLength = NaN;
+  private s = 0;
+  private c = 0;
+  private stepLength = NaN;
+  private stepX = NaN;
+  private stepY = NaN;
+  private stepS = 0;
+  private stepC = 0;
+
+  /** Kahan steps that move the kept sum from the kept length to `len`; the result goes to stepS / stepC. */
+  private resize(len: number): void {
+    const values = this.values;
+    const n = values.length;
+    const kept = this.keptLength;
+    let s = this.s;
+    let c = this.c;
+    const add = (v: number) => {
+      const y = v - c;
+      const t = s + y;
+      c = (t - s) - y;
+      s = t;
+    };
+    if (len < kept) {
+      for (let k = Math.max(0, n - kept); k <= n - len - 1; k++) add(-values[k]!);
+    } else if (len > kept) {
+      for (let k = n - kept - 1; k >= Math.max(0, n - len); k--) add(values[k]!);
     }
-    const x = v as number;
+    this.stepS = s;
+    this.stepC = c;
+  }
+
+  /**
+   * The running sum of the last `length` values with the (not na) value `x` added, from the kept state; the state is
+   * unchanged until {@link commit}.
+   *
+   * @returns The sum, or NaN while fewer than `length` values exist (with `x`)
+   */
+  step(x: number, length: number): number {
+    const len = length;
+    const values = this.values;
+    this.resize(len);
+    let s = this.stepS;
+    let c = this.stepC;
     const c0 = c;
     const n = values.length;
-    if (n >= len) kahanAdd(-stored[n - len]!);
-    values.push(x);
+    if (n >= len) {
+      const y = -this.stored[n - len]! - c;
+      const t = s + y;
+      c = (t - s) - y;
+      s = t;
+    }
     if (compensationLost(x, c0)) {
-      let fresh = 0;
-      for (let k = values.length - 1; k >= Math.max(0, values.length - len); k--) fresh += values[k]!;
+      let fresh = x;
+      for (let k = n - 1; k >= Math.max(0, n + 1 - len); k--) fresh += values[k]!;
       s = fresh;
       c = 0;
-      stored.push(x);
+      this.stepY = x;
     } else {
-      stored.push(kahanAdd(x));
+      const y = x - c;
+      const t = s + y;
+      c = (t - s) - y;
+      s = t;
+      this.stepY = y;
     }
-    previous = values.length >= len ? s : NaN;
-    out[i] = previous;
+    this.stepLength = len;
+    this.stepX = x;
+    this.stepS = s;
+    this.stepC = c;
+    return n + 1 >= len ? s : NaN;
+  }
+
+  /**
+   * The running sum of the last `length` values on a bar with an na value (no value added), from the kept state; the
+   * state is unchanged until {@link commit}. With an unchanged length, it is the previous result.
+   *
+   * @returns The sum, or NaN while fewer than `length` values exist
+   */
+  stepNa(length: number): number {
+    this.resize(length);
+    this.stepLength = length;
+    this.stepX = NaN;
+    const n = this.values.length;
+    return n > 0 && n >= length ? this.stepS : NaN;
+  }
+
+  /** Keeps the state of the last {@link step} or {@link stepNa}. */
+  commit(): void {
+    if (!Number.isNaN(this.stepX)) {
+      this.values.push(this.stepX);
+      this.stored.push(this.stepY);
+    }
+    this.keptLength = this.stepLength;
+    this.s = this.stepS;
+    this.c = this.stepC;
+  }
+}
+
+/** The running sums of `source` with the length `lengthAt(i)` on bar `i`. */
+function sumWindows(source: ArrayLike<number | null | undefined>, lengthAt: (i: number) => number): number[] {
+  const out: number[] = new Array<number>(source.length);
+  const sum = new RunningSum();
+  for (let i = 0; i < source.length; i++) {
+    const v = source[i];
+    const len = lengthAt(i);
+    out[i] = isNa(v) ? sum.stepNa(len) : sum.step(v as number, len);
+    sum.commit();
   }
   return out;
 }
 
 /**
- * Window variance from the running sums of the values and of their squares, as PineScript computes it:
- * biased `sumSq / n - mean * mean`, unbiased `sumSq / (n - 1) - mean * sum / (n - 1)`, with `mean = sum / n`.
+ * The sum of the last `length` non-na values on each bar, as PineScript computes it.
+ *
+ * @param source - Values (na: NaN, null, undefined or +/-Infinity, skipped)
+ * @param length - Number of non-na values in the window
+ * @returns The running sum per bar: NaN until `length` non-na values exist; a bar with an na value keeps the
+ *   previous result
  */
-export function runningVariance(
+export function runningSum(source: ArrayLike<number | null | undefined>, length: number): number[] {
+  const len = Math.floor(length);
+  if (!(len >= 1)) return new Array<number>(source.length).fill(NaN);
+  return sumWindows(source, () => len);
+}
+
+/** The values of a series length, floored, checked to be at least 1 on every bar. */
+function seriesLengths(lengths: ArrayLike<number>, count: number, name: string): number[] {
+  if (lengths.length < count) {
+    throw new Error(`${name}: the length series has ${lengths.length} values for ${count} bars`);
+  }
+  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]})`);
+    return len;
+  });
+}
+
+/**
+ * The sum of the last `lengths[i]` non-na values on each bar `i` (a series length), as PineScript computes it (see
+ * {@link RunningSum}). A bar with an na value gives the sum of the last `lengths[i]` earlier values.
+ *
+ * @param name - Function name for the error messages
+ */
+export function runningSumSeries(
   source: ArrayLike<number | null | undefined>,
-  length: number,
+  lengths: ArrayLike<number>,
+  name = 'math.sum'
+): number[] {
+  const lens = seriesLengths(lengths, source.length, name);
+  return sumWindows(source, (i) => lens[i]!);
+}
+
+/** Variance from the running sums of the values and of their squares; rules in {@link runningVariance}. */
+function varianceFromSums(
+  source: ArrayLike<number | null | undefined>,
+  sumOf: (src: ArrayLike<number | null | undefined>) => number[],
+  lengthAt: (i: number) => number,
   biased: boolean
 ): number[] {
-  const len = Math.floor(length);
   const squares = Array.from({ length: source.length }, (_, i) => {
     const v = source[i];
     return isNa(v) ? NaN : (v as number) * (v as number);
   });
-  const sums = runningSum(source, len);
-  const sumSquares = runningSum(squares, len);
+  const sums = sumOf(source);
+  const sumSquares = sumOf(squares);
   return sums.map((sum, i) => {
+    const len = lengthAt(i);
     const mean = sum / len;
     const sq = sumSquares[i]!;
     return biased ? sq / len - mean * mean : sq / (len - 1) - (mean * sum) / (len - 1);
   });
 }
+
+/**
+ * Window variance from the running sums of the values and of their squares, as PineScript computes it:
+ * biased `sumSq / n - mean * mean`, unbiased `sumSq / (n - 1) - mean * sum / (n - 1)`, with `mean = sum / n`.
+ */
+export function runningVariance(
+  source: ArrayLike<number | null | undefined>,
+  length: number,
+  biased: boolean
+): number[] {
+  const len = Math.floor(length);
+  return varianceFromSums(source, (src) => runningSum(src, len), () => len, biased);
+}
+
+/** {@link runningVariance} with a series length (the length of bar `i` is `lengths[i]`). */
+export function runningVarianceSeries(
+  source: ArrayLike<number | null | undefined>,
+  lengths: ArrayLike<number>,
+  biased: boolean,
+  name = 'ta.variance'
+): number[] {
+  const lens = seriesLengths(lengths, source.length, name);
+  return varianceFromSums(source, (src) => sumWindows(src, (i) => lens[i]!), (i) => lens[i]!, biased);
+}

package/src/ta-series.ts

@@ -14,10 +14,10 @@ import type { Bar } from './types/index.js';
  * @param length - Period length
  * @returns Series with SMA values
  */
-export function sma(source: Series, length: number): Series {
+export function sma(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.sma(sourceValues, length);
+  const result = taCore.sma(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -124,9 +124,10 @@ export function bb(source: Series, length: number, mult: number): [Series, Serie
      * @param biased - true (default): divide by length; false: by length - 1
      * @returns Series with standard deviation values
      */
-    export function stdev(source: Series, length: number, biased: boolean = true): Series {
+    export function stdev(source: Series, length: number | Series, biased: boolean = true): Series {
       const bars = source.bars as Bar[];
-      return Series.fromArray(bars, taCore.stdev(source.toArray(), length, biased));
+      const len = length instanceof Series ? length.toArray() : length;
+      return Series.fromArray(bars, taCore.stdev(source.toArray(), len, biased));
     }
     
 
@@ -600,9 +601,9 @@ export function dev(source: Series, length: number): Series {
  * @param biased - Use biased estimation (default: true)
  * @returns Series with variance values
  */
-export function variance(source: Series, length: number, biased: boolean = true): Series {
+export function variance(source: Series, length: number | Series, biased: boolean = true): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.variance(source.toArray(), length, biased);
+  const result = taCore.variance(source.toArray(), length instanceof Series ? length.toArray() : length, biased);
   return Series.fromArray(bars, result);
 }
 
@@ -757,7 +758,7 @@ export function dmi(bars: Bar[], diLength: number, adxSmoothing: number): [Serie
  * @param source - Source series
  * @param shortLength - Short smoothing period
  * @param longLength - Long smoothing period
- * @returns Series with TSI values
+ * @returns Series with TSI values, in [-1, 1] as PineScript
  */
 export function tsi(source: Series, shortLength: number, longLength: number): Series {
   const bars = source.bars as Bar[];

package/src/time/datestring.ts

@@ -10,6 +10,7 @@
  * Time zones: "UT", "UTC", "GMT", "+0530", "-05:00", "GMT+5", "UTC-0300", and the RFC 2822
  * names EST, EDT, CST, CDT, MST, MDT, PST, PDT. After a "T" time, only numeric offsets.
  * Without a time the time is 00:00. Without a time zone the time zone is GMT+0.
+ * "2025" and "2025-06" are the first day of the year / month. "01 Jan 2022 GMT+3" (a zone without a time) gives na.
  * "24:00" is midnight at the end of the day.
  *
  * "Z", "2024-01-01T09:30:00 GMT", "24:30" and "09:30:60" are compile errors in PineScript, and
@@ -34,6 +35,7 @@ const NUMERIC_ZONE = String.raw`([+-]\d{2}(?::?\d{2})?)`;
 const DATE = String.raw`(\d{4})([-/])(\d{1,2})\2(\d{1,2})`;
 const WEEKDAY = String.raw`(?:[a-z]{3,9},?\s+)?`;
 
+const YEAR_MONTH = /^(\d{4})(?:-(\d{1,2}))?$/;
 const ISO_T = new RegExp(String.raw`^${DATE}t${TIME}\s*${NUMERIC_ZONE}?$`, 'i');
 const ISO = new RegExp(String.raw`^${DATE}(?:\s+${TIME})?\s*${ZONE}?$`, 'i');
 const DAY_FIRST = new RegExp(String.raw`^${WEEKDAY}(\d{1,2})(?:\s+|-)([a-z]+)\.?,?(?:\s+|-)(\d{4})(?:,?\s+${TIME})?\s*${ZONE}?$`, 'i');
@@ -68,12 +70,20 @@ export function parseDateString(dateString: string): number {
   let rest: Array<string | undefined>;
 
   let m: RegExpExecArray | null;
+  // "2025" and "2025-06": the first day of the year / month, 00:00 UTC (PineScript)
+  if ((m = YEAR_MONTH.exec(text))) {
+    const mo = m[2] ? Number(m[2]) : 1;
+    if (mo < 1 || mo > 12) throw new SyntaxError(`Invalid date string "${dateString}": a field is out of range`);
+    return Date.UTC(Number(m[1]), mo - 1, 1);
+  }
   if ((m = ISO_T.exec(text) ?? ISO.exec(text))) {
     [year, month, day] = [m[1]!, Number(m[3]), m[4]!];
     rest = m.slice(5);
   } else if ((m = DAY_FIRST.exec(text))) {
     [day, month, year] = [m[1]!, monthNumber(m[2]!), m[3]!];
     rest = m.slice(4);
+    // a time zone without a time ("01 Jan 2022 GMT+3") gives na in PineScript
+    if (rest[0] === undefined && rest[4] !== undefined) return NaN;
   } else if ((m = MONTH_FIRST.exec(text))) {
     [month, day, year] = [monthNumber(m[1]!), m[2]!, m[3]!];
     rest = m.slice(4);

package/src/time/index.ts

@@ -61,8 +61,10 @@ export function timestamp(
 export function timestamp(first: string | simple_int, ...rest: Array<simple_int | undefined>): int {
   if (typeof first === 'string') {
     if (rest.length === 0) return parseDateString(first);
+    // PineScript: an na field counts as 0 (day na of January 2020 is 2019-12-31)
+    const f = (v: number | undefined) => (v === undefined || v === null || Number.isNaN(v) ? 0 : v);
     const [year, month, day, hour, minute, second] = rest as [number, number, number, number?, number?, number?];
-    return zonedToUnix(first, year, month, day, hour ?? 0, minute ?? 0, second ?? 0);
+    return zonedToUnix(first, f(year), f(month), f(day), f(hour), f(minute), f(second));
   }
   const [month, day, hour, minute, second] = rest as [number, number, number?, number?, number?];
   return new Date(first, month - 1, day, hour || 0, minute || 0, second || 0).getTime();

package/src/time/session.ts

@@ -1,78 +1,128 @@
 /**
- * Session strings ("0930-1600", "0930-1600:23456", "1000-1100,1400-1500:23456", "24x7").
+ * PineScript session strings ("0930-1600", "0930-1600:23456", "1000-1100,1400-1500:23456", "0930-1600|1000-1300:7",
+ * "24x7").
  *
- * Format `<periods>[:<days>]`:
- * - a period is "HHmm-HHmm"; several periods are separated by commas
- * - days are digits 1 (Sunday) to 7 (Saturday). Without days, a single period covers every
- *   day, and several periods cover Monday to Friday ("23456"), as in PineScript
- * - an end before the start is an overnight period that ends on the next day, and it
- *   belongs to the day it ends: "1700-1700:23456" starts Sunday 17:00 and covers Monday
- * - "0000-0000" and "24x7" are the 24-hour session of every day
+ * Grammar (measured on PineScript): `range[,range...][:days]`, several sections joined by "|".
+ * - a range is exactly "HHMM-HHMM"; hours and minutes are minute counts taken modulo one day ("0930-2500" runs
+ *   09:30 to 01:00, "0960-1600" 10:00 to 16:00); a start of 24:00 or later must open a run of at most a day
+ * - days are digits 1 (Sunday) to 7 (Saturday), the day each run ends on
+ * - a lone range without days runs every day; otherwise a section without days is the default section, which runs
+ *   on the weekdays (2-6) no other section names, and a later section naming a day replaces the earlier ones on that
+ *   day ("1100-1400|1200-1300:7": 11:00-14:00 Monday to Friday, 12:00-13:00 Saturday)
+ * - a trailing ",", ":" or "|" ends its list ("1100-1400," is "1100-1400" Monday to Friday)
+ * - an end before the start is an overnight run that belongs to the day it ends; equal ends are 24 hours;
+ *   "0000-0000" and "24x7" are the whole day, every day
+ * - a string that is empty or does not start with a digit ("regular", "extended") is the symbol's own session
+ * - a malformed string ("1100 -1400", "0930-16", ":8") is an error, as the PineScript runtime error
  */
 
 import { zonedFields } from './timezone.js';
 
-interface Period {
-  /** Minutes after midnight, 0-1439 */
+const MINUTES_PER_DAY = 1440;
+const WEEKDAYS = [2, 3, 4, 5, 6];
+const ALL_DAYS = [1, 2, 3, 4, 5, 6, 7];
+
+/** A run of a session: minutes after midnight (0-1439) and the days it ends on (1 = Sunday ... 7 = Saturday). */
+export interface SessionRange {
   start: number;
   end: number;
+  days: Set<number>;
 }
 
-interface ParsedSession {
-  periods: Period[];
-  /** Included days, indexed 1 (Sunday) to 7 (Saturday) */
-  days: boolean[];
+function invalid(session: string): SyntaxError {
+  return new SyntaxError(`Invalid session "${session}": expected "HHMM-HHMM[,HHMM-HHMM...][:days][|...]"`);
 }
 
-const PERIOD = /^(\d{2})(\d{2})-(\d{2})(\d{2})$/;
-
-const sessions = new Map<string, ParsedSession>();
-
-function parseSession(session: string): ParsedSession {
-  let parsed = sessions.get(session);
-  if (parsed) return parsed;
-
-  const invalid = () => new SyntaxError(`Invalid session "${session}": expected "HHmm-HHmm[,HHmm-HHmm...][:days]"`);
-  const text = session.trim() === '24x7' ? '0000-0000' : session.replace(/\s+/g, '');
-  const [periodText = '', dayText, extra] = text.split(':');
-  if (extra !== undefined || periodText === '') throw invalid();
-
-  const periods = periodText.split(',').map((p) => {
-    const m = PERIOD.exec(p);
-    if (!m) throw invalid();
-    const [h1, m1, h2, m2] = [m[1], m[2], m[3], m[4]].map(Number) as [number, number, number, number];
-    if (h1 > 23 || h2 > 23 || m1 > 59 || m2 > 59) throw invalid();
-    return { start: h1 * 60 + m1, end: h2 * 60 + m2 };
+function parseRanges(text: string, session: string): Array<[number, number]> {
+  if (!text) return [];
+  const entries = text.split(',');
+  if (entries.length > 1 && entries[entries.length - 1] === '') entries.pop();
+  return entries.map((entry) => {
+    if (!/^\d{4}-\d{4}$/.test(entry)) throw invalid(session);
+    let start = Number(entry.slice(0, 2)) * 60 + Number(entry.slice(2, 4));
+    let end = Number(entry.slice(5, 7)) * 60 + Number(entry.slice(7, 9));
+    if (start >= MINUTES_PER_DAY) {
+      const endOfRun = end || MINUTES_PER_DAY;
+      if (!(start - MINUTES_PER_DAY < endOfRun && endOfRun <= start && start < 2 * MINUTES_PER_DAY)) throw invalid(session);
+    }
+    start %= MINUTES_PER_DAY;
+    end %= MINUTES_PER_DAY;
+    return [start, end];
   });
+}
 
-  const dayDigits = dayText ?? (periods.length > 1 ? '23456' : '1234567');
-  if (!/^[1-7]+$/.test(dayDigits)) throw invalid();
-  const days = new Array<boolean>(8).fill(false);
-  for (const d of dayDigits) days[Number(d)] = true;
+function parseDays(text: string, session: string): Set<number> {
+  if (!/^[1-7]+$/.test(text)) throw invalid(session);
+  return new Set([...text].map(Number));
+}
+
+const parsed = new Map<string, SessionRange[] | null>();
 
-  parsed = { periods, days };
-  sessions.set(session, parsed);
-  return parsed;
+/**
+ * Runs of a PineScript session string, or null for the symbol's own session (empty or not starting with a digit).
+ * @throws SyntaxError when the string is malformed (a PineScript runtime error)
+ */
+export function parsePineSession(session: string): SessionRange[] | null {
+  const cached = parsed.get(session);
+  if (cached !== undefined) return cached;
+  const spec = session.trim();
+  let out: SessionRange[] | null;
+  if (!spec || !/^\d/.test(spec)) {
+    out = null;
+  } else if (spec === '24x7') {
+    out = [{ start: 0, end: 0, days: new Set(ALL_DAYS) }];
+  } else if (!/[:,|]/.test(spec)) {
+    out = parseRanges(spec, session).map(([start, end]) => ({ start, end, days: new Set(ALL_DAYS) }));
+  } else {
+    const sections = spec.split('|');
+    if (sections.length > 1 && sections[sections.length - 1] === '') sections.pop();
+    const items = sections.map((section) => {
+      const parts = section.split(':');
+      if (parts.length > 2) throw invalid(session);
+      const ranges = parseRanges(parts[0]!, session);
+      const days = parts.length === 1 || parts[1] === '' ? null : parseDays(parts[1]!, session);
+      return { ranges, days };
+    });
+    if (items.filter((it) => it.days === null).length > 1) throw invalid(session);
+    // a later section naming a day replaces the earlier ones on that day; the default section takes the weekdays
+    // no other section names
+    const own: Set<number>[] = items.map(() => new Set<number>());
+    const claimed = new Set<number>();
+    for (let i = items.length - 1; i >= 0; i--) {
+      const days = items[i]!.days;
+      if (days === null) continue;
+      for (const d of days) if (!claimed.has(d)) own[i]!.add(d);
+      for (const d of days) claimed.add(d);
+    }
+    items.forEach((it, i) => {
+      if (it.days === null) for (const d of WEEKDAYS) if (!claimed.has(d)) own[i]!.add(d);
+    });
+    out = items.flatMap((it, i) => (own[i]!.size ? it.ranges.map(([start, end]) => ({ start, end, days: own[i]! })) : []));
+  }
+  parsed.set(session, out);
+  return out;
 }
 
 /**
  * True when `time` falls inside `session`, with the session hours read in `timezone`.
- * A period includes its start minute and excludes its end minute.
+ * A run includes its start minute and excludes its end minute.
+ * @throws Error for the symbol's own session ("regular", "extended", ""), which this function does not know: use
+ * `time(timeframe, session)` in a script with the chart session
  */
 export function inSession(time: number, session: string, timezone: string): boolean {
   if (Number.isNaN(time)) return false;
-  const { periods, days } = parseSession(session);
+  const ranges = parsePineSession(session);
+  if (ranges === null) throw new Error(`Session "${session}" is the symbol session: it needs the chart session (time(timeframe, session) in a script)`);
   const f = zonedFields(time, timezone);
   const minute = f.hour * 60 + f.minute;
   const nextDay = (f.dayOfWeek % 7) + 1;
-
-  for (const { start, end } of periods) {
+  for (const { start, end, days } of ranges) {
     if (start < end || (start === 0 && end === 0)) {
-      if (minute >= start && (minute < end || end === 0) && days[f.dayOfWeek]) return true;
+      if (minute >= start && (minute < end || end === 0) && days.has(f.dayOfWeek)) return true;
     } else {
       // Overnight (24 hours when start === end): the part from `start` belongs to the next day.
-      if (minute >= start && days[nextDay]) return true;
-      if (minute < end && days[f.dayOfWeek]) return true;
+      if (minute >= start && days.has(nextDay)) return true;
+      if (minute < end && days.has(f.dayOfWeek)) return true;
     }
   }
   return false;

package/src/time/timezone.ts

@@ -157,6 +157,26 @@ export function zonedFields(time: number, timezone: string): ZonedFields {
  * resolve to the later instant, and wall-clock times that do not exist (start of
  * daylight saving time) are shifted forward by the length of the gap.
  */
+/**
+ * UNIX time (ms) of a UTC wall-clock date: Gregorian calendar from 1582-10-15, Julian calendar before it (as
+ * PineScript: 1582-10-05 is 1582-10-15). Out-of-range fields roll over like `Date.UTC`.
+ */
+export function civilToUnix(year: number, month: number, day: number, hour = 0, minute = 0, second = 0): number {
+  const gregorian = Date.UTC(year, month - 1, day, hour, minute, second);
+  // normalized year / month / day of the Gregorian reading decides the calendar
+  const d = new Date(Date.UTC(year, month - 1, 1));
+  const y = d.getUTCFullYear();
+  const m = d.getUTCMonth() + 1;
+  if (y > 1582 || (y === 1582 && (m > 10 || (m === 10 && day >= 15)))) return gregorian;
+  // Julian day number of y-m-1, then the day offset and the time of day
+  const a = Math.floor((14 - m) / 12);
+  const yy = y + 4800 - a;
+  const mm = m + 12 * a - 3;
+  const jdn = 1 + Math.floor((153 * mm + 2) / 5) + 365 * yy + Math.floor(yy / 4) - 32083;
+  const days = jdn - 2440588 + (day - 1);
+  return days * MS_PER_DAY + Date.UTC(1970, 0, 1, hour, minute, second);
+}
+
 export function zonedToUnix(
   timezone: string,
   year: number,
@@ -167,7 +187,7 @@ export function zonedToUnix(
   second: number = 0
 ): number {
   const zone = resolveZone(timezone);
-  const local = Date.UTC(year, month - 1, day, hour, minute, second);
+  const local = civilToUnix(year, month, day, hour, minute, second);
   if (zone.kind === 'fixed') return local - zone.offsetMs;
 
   // At most one offset transition happens within a day of `local`: the offsets