oakscriptjs 0.10.1 → 0.11.1

package/src/ta/limits.ts

@@ -0,0 +1,74 @@
+/**
+ * History limits of the window functions.
+ *
+ * PineScript stops a script when `ta.highest` / `ta.lowest` / `ta.highestbars` / `ta.lowestbars` ask for more than
+ * 15,000 bars (runtime error RE10004): with a constant length on the first bar, with a length that changes on the
+ * bar where it passes the limit. `math.sum`, `ta.sma`, `ta.variance`, `ta.stdev` and `ta.bb` have the same error
+ * above 5,000 bars; the message names the function that keeps the window ('stdev'->'variance', 'bb'->'sma').
+ */
+
+/** Largest length of `ta.highest` / `ta.lowest` / `ta.highestbars` / `ta.lowestbars`. */
+export const MAX_WINDOW_LENGTH = 15000;
+
+/** Largest length of `math.sum` / `ta.sma` / `ta.variance` / `ta.stdev` / `ta.bb`. */
+export const MAX_SUM_LENGTH = 5000;
+
+/** Names of the PineScript message for the functions with the 5,000 limit ("a->b": a calls b). */
+export const SUM_FUNCTIONS: Record<string, string> = {
+  'math.sum': 'sum',
+  'ta.sma': 'sma',
+  'ta.variance': 'variance',
+  'ta.stdev': 'stdev->variance',
+  'ta.bb': 'bb->sma',
+};
+
+/**
+ * PineScript's runtime error RE10004 text; `bar` is the bar index of the call when it is known. `name` is the
+ * function, or a call path "stdev->variance" (printed 'stdev'->'variance').
+ */
+export function windowError(name: string, length: number, bar?: number, max = MAX_WINDOW_LENGTH): string {
+  const fn = name.split('->').map((part) => `'${part}'`).join('->');
+  return (
+    (bar === undefined ? '' : `Error on bar ${bar}: `) +
+    `The ${fn} function references too many historical candles (${length}), the limit is ${max}.`
+  );
+}
+
+/** Throws RE10004 when the (truncated) length of a window function is above the limit. */
+export function checkWindowLength(name: string, length: number, bar?: number, max = MAX_WINDOW_LENGTH): void {
+  const len = Math.trunc(length);
+  if (len <= 0) throw new Error(lengthError(name, len, bar));
+  if (len > max) throw new Error(windowError(name, len, bar, max));
+}
+
+/** Throws RE10004 for a function of {@link SUM_FUNCTIONS} ("ta.sma", ...) with a length above 5,000. */
+export function checkSumLength(name: string, length: number, bar?: number): void {
+  const fn = SUM_FUNCTIONS[name];
+  if (fn === undefined) return;
+  // RE10001 names 'bb' itself, RE10004 its inner 'sma'
+  checkPositiveLength(name === 'ta.bb' ? 'bb' : fn, length, bar);
+  checkWindowLength(fn, length, bar, MAX_SUM_LENGTH);
+}
+
+/**
+ * PineScript's runtime error RE10001 text for a length that is 0 or negative. `name` is the function, or a call path
+ * "atr->rma" (printed 'atr'->'rma'); the value prints as a float ("0.0", "-1.0").
+ */
+export function lengthError(name: string, value: number, bar?: number, arg = 'length'): string {
+  const fn = name.split('->').map((part) => `'${part}'`).join('->');
+  const text = Number.isInteger(value) ? value.toFixed(1) : String(value);
+  return (
+    (bar === undefined ? '' : `Error on bar ${bar}: `) +
+    `Invalid value of the '${arg}' argument (${text}) in the ${fn} function. It must be > 0.`
+  );
+}
+
+/**
+ * Throws RE10001 when the (truncated) length is 0 or negative, as PineScript does for every window function on the
+ * bar of the call (#175): `ta.sma(close, 0)` stops on bar 0, a series length that becomes 0 on the bar where it
+ * does. `ta.hma(src, 1)` stops in its inner `wma(src, 0)`. An na length is not checked here.
+ */
+export function checkPositiveLength(name: string, length: number, bar?: number, arg = 'length'): void {
+  const len = Math.trunc(length);
+  if (len <= 0) throw new Error(lengthError(name, len, bar, arg));
+}

package/src/ta/running-sum.ts

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

package/src/ta-series.ts

@@ -40,10 +40,10 @@ export function ema(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with WMA values
  */
-export function wma(source: Series, length: number): Series {
+export function wma(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.wma(sourceValues, length);
+  const result = taCore.wma(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -66,10 +66,11 @@ export function rma(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with RSI values
  */
-export function rsi(source: Series, length: number): Series {
+export function rsi(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.rsi(sourceValues, length);
+  // a Series as second argument: PineScript v4 rsi(x, y) of two averages (#180)
+  const result = length instanceof Series ? taCore.rsi(sourceValues, length.toArray()) : taCore.rsi(sourceValues, length);
   return Series.fromArray(bars, result);
 }
 
@@ -333,10 +334,10 @@ export function roc(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with highest values
  */
-export function highest(source: Series, length: number): Series {
+export function highest(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.highest(sourceValues, length);
+  const result = taCore.highest(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -346,10 +347,10 @@ export function highest(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with lowest values
  */
-export function lowest(source: Series, length: number): Series {
+export function lowest(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
   const sourceValues = source.toArray();
-  const result = taCore.lowest(sourceValues, length);
+  const result = taCore.lowest(sourceValues, length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -688,9 +689,10 @@ export function hma(source: Series, length: number): Series {
  * @returns Series with the pivot high value on the bar where the pivot is confirmed,
  *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
  */
-export function pivothigh(source: Series, leftbars: number, rightbars: number): Series {
+export function pivothigh(source: Series, leftbars: number | Series, rightbars: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.pivothigh(source.toArray(), leftbars, rightbars);
+  const arr = (v: number | Series) => (v instanceof Series ? v.toArray() : v);
+  const result = taCore.pivothigh(source.toArray(), arr(leftbars), arr(rightbars));
   return Series.fromArray(bars, result);
 }
 
@@ -702,9 +704,10 @@ export function pivothigh(source: Series, leftbars: number, rightbars: number):
  * @returns Series with the pivot low value on the bar where the pivot is confirmed,
  *   `rightbars` bars after the pivot bar (as in PineScript), NaN elsewhere
  */
-export function pivotlow(source: Series, leftbars: number, rightbars: number): Series {
+export function pivotlow(source: Series, leftbars: number | Series, rightbars: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.pivotlow(source.toArray(), leftbars, rightbars);
+  const arr = (v: number | Series) => (v instanceof Series ? v.toArray() : v);
+  const result = taCore.pivotlow(source.toArray(), arr(leftbars), arr(rightbars));
   return Series.fromArray(bars, result);
 }
 
@@ -861,9 +864,9 @@ export function kcw(bars: Bar[], source: Series, length: number = 20, mult: numb
  * @param length - Period length
  * @returns Series with bar offsets to highest value
  */
-export function highestbars(source: Series, length: number): Series {
+export function highestbars(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.highestbars(source.toArray(), length);
+  const result = taCore.highestbars(source.toArray(), length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 
@@ -873,9 +876,9 @@ export function highestbars(source: Series, length: number): Series {
  * @param length - Period length
  * @returns Series with bar offsets to lowest value
  */
-export function lowestbars(source: Series, length: number): Series {
+export function lowestbars(source: Series, length: number | Series): Series {
   const bars = source.bars as Bar[];
-  const result = taCore.lowestbars(source.toArray(), length);
+  const result = taCore.lowestbars(source.toArray(), length instanceof Series ? length.toArray() : length);
   return Series.fromArray(bars, result);
 }
 

package/src/table/index.ts

@@ -12,6 +12,7 @@
  * - `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)
  *
  * @version 6
  */
@@ -25,7 +26,8 @@ type VAlign = 'top' | 'center' | 'bottom';
 type FontFamily = 'default' | 'monospace';
 
 /**
- * Creates a new table (PineScript `table.new`).
+ * Creates a new table (PineScript `table.new`). A live table at the same position is deleted, as PineScript keeps
+ * one table per position (#176).
  *
  * @example
  * ```typescript
@@ -44,6 +46,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);
   return register('table', {
     position,
     columns,

package/src/time/index.ts

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

package/src/time/session.ts

@@ -12,11 +12,15 @@
  * - 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 run that ends at 0000 ("2000-0000") ends at 24:00 of the day it starts and belongs to that day
+ *   ("2000-0000:6" is Friday 20:00 to midnight)
+ * - "F" after the start moves it one day before the day the run ends on ("1700F-1900:2": Sunday 17:00 to Monday
+ *   19:00; "1900-1900:3456|1700F-1900:2" is the TVC:DXY symbol session) (#173)
  * - 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';
+import { zoneOffset, zonedFields, zonedToUnix } from './timezone.js';
 
 const MINUTES_PER_DAY = 1440;
 const WEEKDAYS = [2, 3, 4, 5, 6];
@@ -27,17 +31,27 @@ export interface SessionRange {
   start: number;
   end: number;
   days: Set<number>;
+  /** Days between the start and the day the run ends on, given by "F" after the start (absent otherwise) */
+  startDays?: number;
 }
 
 function invalid(session: string): SyntaxError {
   return new SyntaxError(`Invalid session "${session}": expected "HHMM-HHMM[,HHMM-HHMM...][:days][|...]"`);
 }
 
-function parseRanges(text: string, session: string): Array<[number, number]> {
+function parseRanges(text: string, session: string): Array<[number, number, number?]> {
   if (!text) return [];
   const entries = text.split(',');
   if (entries.length > 1 && entries[entries.length - 1] === '') entries.pop();
-  return entries.map((entry) => {
+  return entries.map((entry): [number, number, number?] => {
+    // "HHMMF-HHMM": the start is one day before the day the run ends on
+    const f = /^(\d{4})F-(\d{4})$/.exec(entry);
+    if (f) {
+      const minutes = (hhmm: string): number => Number(hhmm.slice(0, 2)) * 60 + Number(hhmm.slice(2, 4));
+      const [start, end] = [minutes(f[1]!), minutes(f[2]!)];
+      if (start >= MINUTES_PER_DAY || end >= MINUTES_PER_DAY) throw invalid(session);
+      return [start, end, 1];
+    }
     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));
@@ -58,6 +72,9 @@ function parseDays(text: string, session: string): Set<number> {
 
 const parsed = new Map<string, SessionRange[] | null>();
 
+const range = (start: number, end: number, days: Set<number>, startDays?: number): SessionRange =>
+  startDays === undefined ? { start, end, days } : { start, end, days, startDays };
+
 /**
  * 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)
@@ -72,7 +89,7 @@ export function parsePineSession(session: string): SessionRange[] | 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) }));
+    out = parseRanges(spec, session).map(([start, end, startDays]) => range(start, end, new Set(ALL_DAYS), startDays));
   } else {
     const sections = spec.split('|');
     if (sections.length > 1 && sections[sections.length - 1] === '') sections.pop();
@@ -97,33 +114,138 @@ export function parsePineSession(session: string): SessionRange[] | null {
     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]! })) : []));
+    out = items.flatMap((it, i) => (own[i]!.size ? it.ranges.map(([start, end, startDays]) => range(start, end, own[i]!, startDays)) : []));
   }
   parsed.set(session, out);
   return out;
 }
 
+const MS_PER_MINUTE = 60_000;
+const MS_PER_HOUR = 3_600_000;
+const MS_PER_DAY = 86_400_000;
+/** A clock change is looked for this far on each side of the tested time. */
+const CHANGE_WINDOW = 36 * MS_PER_HOUR;
+
+/** The clock change of `timezone` within 36 hours of `time`: its UNIX time and the offsets (ms) around it. */
+function clockChangeNear(time: number, timezone: string): { at: number; before: number; after: number } | null {
+  let lo = time - CHANGE_WINDOW;
+  let hi = time + CHANGE_WINDOW;
+  const before = zoneOffset(lo, timezone);
+  const after = zoneOffset(hi, timezone);
+  if (before === after) return null;
+  while (hi - lo > MS_PER_MINUTE) {
+    const mid = Math.floor((lo + hi) / 2 / MS_PER_MINUTE) * MS_PER_MINUTE;
+    if (zoneOffset(mid, timezone) === before) lo = mid;
+    else hi = mid;
+  }
+  return { at: hi, before, after };
+}
+
 /**
  * True when `time` falls inside `session`, with the session hours read in `timezone`.
  * A run includes its start minute and excludes its end minute.
+ *
+ * On the days around a clock change PineScript does not read the wall clock of each bar; it places each run of
+ * each local day (measured on 15- and 5-minute bars, clocks going forward and back, four time zones):
+ * - a wall time of the day is placed with the offset before the change when it is before the wall time of the
+ *   change (02:00 for 02:00 -> 03:00, 03:00 for 03:00 -> 02:00), with the offset after it otherwise. Forward
+ *   change: "0100-0300" lasts one hour and "0130-0230" is empty; back change: "0230-0330" lasts two hours
+ * - a run that ends exactly on the wall time of the change is placed with the offset after the change at both ends
+ *   (forward change: "0100-0200" is one hour earlier than the wall clock says)
+ * - clocks going back: a run that ends inside the repeated hour also covers its second pass
+ * - clocks going back, the day BEFORE the change: a run with a start or an end on the wall time of the change is
+ *   also true one hour (the amount of the change) later, from one bar after its usual end. This needs the bar
+ *   duration `barMs`; without it the rule is not applied
+ *
+ * @param barMs - Duration of the bars in ms (the chart timeframe); only used by the last rule
  * @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;
+export function inSession(time: number, session: string, timezone: string, barMs?: number): boolean {
+  return sessionRun(time, session, timezone, barMs) !== null;
+}
+
+/**
+ * The run of `session` that contains `time`, as [start, end) UNIX times (ms), or null outside the session; rules in
+ * {@link inSession}. PineScript aligns the intraday periods of `time(tf, session)` on the start of this run (#173).
+ */
+export function sessionRun(time: number, session: string, timezone: string, barMs?: number): [number, number] | null {
+  if (Number.isNaN(time)) return null;
   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 change = clockChangeNear(time, timezone);
   const f = zonedFields(time, timezone);
   const minute = f.hour * 60 + f.minute;
   const nextDay = (f.dayOfWeek % 7) + 1;
-  for (const { start, end, days } of ranges) {
-    if (start < end || (start === 0 && end === 0)) {
-      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.has(nextDay)) return true;
-      if (minute < end && days.has(f.dayOfWeek)) return true;
+  for (const { start, end: rawEnd, days, startDays } of ranges) {
+    if (startDays !== undefined) {
+      // "F": from `start` of `startDays` days before the end day to `end` of the end day, wall times read in the zone
+      for (let k = 0; k <= startDays + 1; k++) {
+        const endDay = Date.UTC(f.year, f.month - 1, f.day + k);
+        if (!days.has(new Date(endDay).getUTCDay() + 1)) continue;
+        const d = new Date(endDay);
+        const at = (dayShift: number, minutes: number): number =>
+          zonedToUnix(timezone, d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate() - dayShift, Math.floor(minutes / 60), minutes % 60);
+        const from = at(startDays, start);
+        const to = at(0, rawEnd);
+        if (time >= from && time < to) return [from, to];
+      }
+      continue;
+    }
+    if (start === rawEnd) {
+      // 24 hours: the run belongs to the day it ends ("0000-0000": the day itself)
+      if (days.has(start === 0 || minute < start ? f.dayOfWeek : nextDay)) {
+        const from = time - ((minute - start + MINUTES_PER_DAY) % MINUTES_PER_DAY) * MS_PER_MINUTE - f.second * 1000 - (time % 1000);
+        return [from, from + MS_PER_DAY];
+      }
+      continue;
+    }
+    // a run that ends at 0000 ends at 24:00 of the day it starts
+    const end = rawEnd === 0 ? MINUTES_PER_DAY : rawEnd;
+    const overnight = start > end;
+    if (!change) {
+      // the wall-clock minute of the bar: the run is `start` to `end` minutes of the same offset
+      const midnight = time - minute * MS_PER_MINUTE - f.second * 1000 - (time % 1000);
+      if (!overnight) {
+        if (minute >= start && minute < end && days.has(f.dayOfWeek)) return [midnight + start * MS_PER_MINUTE, midnight + end * MS_PER_MINUTE];
+      } else {
+        // the part from `start` belongs to the next day
+        if (minute >= start && days.has(nextDay)) return [midnight + start * MS_PER_MINUTE, midnight + (end + MINUTES_PER_DAY) * MS_PER_MINUTE];
+        if (minute < end && days.has(f.dayOfWeek)) return [midnight + (start - MINUTES_PER_DAY) * MS_PER_MINUTE, midnight + end * MS_PER_MINUTE];
+      }
+      continue;
+    }
+    // local days as naive instants (wall clock read as UTC)
+    const changeWall = change.at + change.before;
+    const place = (naive: number): number => (naive < changeWall ? naive - change.before : naive - change.after);
+    const today = Math.floor((time + change.before) / MS_PER_DAY);
+    for (let day = today - 1; day <= today + 1; day++) {
+      if (!days.has(((day + 4) % 7) + 1)) continue; // 01/01/1970 is a Thursday (5)
+      const from = day * MS_PER_DAY + (overnight ? start - MINUTES_PER_DAY : start) * MS_PER_MINUTE;
+      const to = day * MS_PER_DAY + end * MS_PER_MINUTE;
+      if (to === changeWall) {
+        if (time >= from - change.after && time < to - change.after) return [from - change.after, to - change.after];
+        continue;
+      }
+      if (time >= place(from) && time < place(to)) return [place(from), place(to)];
+      // clocks going back: the second pass of the repeated hour
+      const repeated = change.at + change.after;
+      if (change.after < change.before && to < changeWall && to > repeated) {
+        if (time >= Math.max(from, repeated) - change.after && time < to - change.after) return [place(from), to - change.after];
+      }
+    }
+    // clocks going back, the day before: a run with an end on the wall time of the change is also true one change
+    // later, from one bar after its usual end
+    if (barMs !== undefined && change.after < change.before) {
+      const day = Math.floor(changeWall / MS_PER_DAY) - 1;
+      const wallMinute = (changeWall - (day + 1) * MS_PER_DAY) / MS_PER_MINUTE;
+      if ((start === wallMinute || end === wallMinute) && days.has(((day + 4) % 7) + 1)) {
+        const from = day * MS_PER_DAY + (overnight ? start - MINUTES_PER_DAY : start) * MS_PER_MINUTE - change.before;
+        const to = day * MS_PER_DAY + end * MS_PER_MINUTE - change.before;
+        const shift = change.before - change.after;
+        if (time >= from + shift && time < to + shift && time >= to + barMs) return [from + shift, to + shift];
+      }
     }
   }
-  return false;
+  return null;
 }

package/src/time/timezone.ts

@@ -177,6 +177,11 @@ export function civilToUnix(year: number, month: number, day: number, hour = 0,
   return days * MS_PER_DAY + Date.UTC(1970, 0, 1, hour, minute, second);
 }
 
+/**
+ * UNIX time (ms) of a wall-clock date in `timezone`. A wall time skipped by a clock change is read with the offset
+ * before the change (02:30 on a 02:00 -> 03:00 night is 03:30 after it); a wall time that occurs twice gives the
+ * later instant, or the earlier one with `earlier`.
+ */
 export function zonedToUnix(
   timezone: string,
   year: number,
@@ -184,7 +189,8 @@ export function zonedToUnix(
   day: number,
   hour: number = 0,
   minute: number = 0,
-  second: number = 0
+  second: number = 0,
+  earlier: boolean = false
 ): number {
   const zone = resolveZone(timezone);
   const local = civilToUnix(year, month, day, hour, minute, second);
@@ -195,6 +201,7 @@ export function zonedToUnix(
   const before = offsetAt(zone, local - MS_PER_DAY);
   const after = offsetAt(zone, local + MS_PER_DAY);
   const candidates = [local - before, local - after].filter((t) => local - offsetAt(zone, t) === t);
-  if (candidates.length) return Math.max(...candidates);
+  // a wall time that occurs twice: the later instant, or the earlier one with `earlier`
+  if (candidates.length) return earlier ? Math.min(...candidates) : Math.max(...candidates);
   return local - before;
 }

package/src/types/metadata.ts

@@ -86,7 +86,7 @@ export interface FillOptions {
 /**
  * Input parameter type
  */
-export type InputType = 'int' | 'float' | 'bool' | 'string' | 'source' | 'color' | 'timeframe' | 'session' | 'time';
+export type InputType = 'int' | 'float' | 'bool' | 'string' | 'source' | 'color' | 'timeframe' | 'session' | 'time' | 'symbol';
 
 /**
  * Input parameter metadata
@@ -431,17 +431,20 @@ export interface LabelData {
   /** Price; not used with yloc 'abovebar' / 'belowbar' */
   price: number;
   text: string;
-  /** Background, border and arrow colour */
+  /** Background, border and arrow colour. Omitted: #2962FF (color.blue; #2196F3 in a v4 script) */
   color?: string;
+  /** Omitted: #FFFFFF in a v6 script, #363A45 in v4 and v5 (the result does not carry the version) */
   textColor?: string;
-  /** 'none': text only, no background (PineScript label.style_none) */
+  /** 'none': text only, no background (PineScript label.style_none). Omitted: 'label_down' */
   style?: LabelStyle;
+  /** Omitted: 'normal' */
   size?: PineSize | number;
   /**
    * PineScript yloc: 'price' (default) places the label at `price`; 'abovebar' / 'belowbar' place it above the bar
    * high / below the bar low and ignore `price` (the renderer reads the bar at `time`).
    */
   yloc?: 'price' | 'abovebar' | 'belowbar';
+  /** Omitted: 'center' */
   textAlign?: 'left' | 'center' | 'right';
   tooltip?: string;
   fontFamily?: 'default' | 'monospace';
@@ -459,8 +462,11 @@ export interface LineDrawingData {
   price1: number;
   time2: number;
   price2: number;
+  /** Omitted: #2962FF (color.blue; #2196F3 in a v4 script) */
   color?: string;
+  /** Omitted: 1. A width of 0 is kept (PineScript `width = 0`) */
   width?: number;
+  /** Omitted: 'solid' */
   style?: 'solid' | 'dashed' | 'dotted' | 'arrow_left' | 'arrow_right' | 'arrow_both';
   extend?: 'none' | 'left' | 'right' | 'both';
   /** PineScript force_overlay = true: the line of a non-overlay indicator is drawn on the price pane */
@@ -475,14 +481,22 @@ export interface BoxData {
   price1: number;
   time2: number;
   price2: number;
+  /** Omitted: #2962FF (color.blue; #2196F3 in a v4 script) */
   bgColor?: string;
+  /** Omitted: #2962FF (color.blue; #2196F3 in a v4 script) */
   borderColor?: string;
+  /** Omitted: 1. A width of 0 is no border (PineScript `border_width = 0`) */
   borderWidth?: number;
+  /** Omitted: 'solid' */
   borderStyle?: 'solid' | 'dashed' | 'dotted';
   text?: string;
+  /** Omitted: #FFFFFF in a v6 script, #363A45 in v5 (the result does not carry the version) */
   textColor?: string;
+  /** Omitted: 'auto' */
   textSize?: PineSize | number;
+  /** Omitted: 'center' */
   textHAlign?: 'left' | 'center' | 'right';
+  /** Omitted: 'center' */
   textVAlign?: 'top' | 'center' | 'bottom';
   textWrap?: 'none' | 'auto';
   fontFamily?: 'default' | 'monospace';
@@ -512,10 +526,12 @@ export interface PolylineData {
   curved?: boolean;
   /** The last point is connected to the first */
   closed?: boolean;
+  /** Omitted: #2962FF (color.blue) */
   lineColor?: string;
-  /** Fill of the area inside the polyline */
+  /** Fill of the area inside the polyline. Omitted: no fill */
   fillColor?: string;
   lineStyle?: 'solid' | 'dotted' | 'dashed' | 'arrow_left' | 'arrow_right' | 'arrow_both';
+  /** Omitted: 1 */
   lineWidth?: number;
   /** PineScript force_overlay = true: the polyline of a non-overlay indicator is drawn on the price pane */
   forceOverlay?: boolean;
@@ -540,8 +556,11 @@ export interface TableCellData {
   row: number;
   column: number;
   text: string;
+  /** Omitted: no background */
   bgColor?: string;
+  /** Omitted: #363A45 (in v4, v5 and v6 scripts) */
   textColor?: string;
+  /** Omitted: 'auto' */
   textSize?: PineSize | number;
   /** Width in % of the chart width; 0 fits the text */
   width?: number;
@@ -575,10 +594,15 @@ export interface TableData {
   rows: number;
   cells: TableCellData[];
   merges?: TableMergeData[];
+  /** Omitted: no background */
   bgColor?: string;
+  /** Omitted: no frame */
   frameColor?: string;
+  /** Omitted: 0 */
   frameWidth?: number;
+  /** Omitted: no cell borders */
   borderColor?: string;
+  /** Omitted: 0 */
   borderWidth?: number;
   /** PineScript force_overlay = true: the table of a non-overlay indicator is drawn on the price pane */
   forceOverlay?: boolean;