oakscriptjs 0.9.5 → 0.10.0

package/src/ta/running-sum.ts

@@ -6,8 +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. The test rounds on the grid of the
- *   new value toward +infinity: for a negative power of two, the finer grid of the binade below (#136).
+ *   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.
@@ -15,115 +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;
-}
-
-/**
- * Distance from a finite non-zero `x` to the next number toward +infinity: the spacing of the binade of `x`, or half
- * of it when `x` is a negative power of two (the next number up is in the binade below).
- */
-function spacingUp(x: number): number {
-  const e = exponentOf(x);
-  const powerOfTwo = (view.getUint16(0) & 0xf) === 0 && view.getUint16(2) === 0 && view.getUint32(4) === 0;
-  return 2 ** (e - (x < 0 && powerOfTwo && e > -1022 ? 53 : 52));
-}
-
 /**
- * Whether the compensation `c` is (partly) lost when it is applied to `x`: `x - c` rounded on the grid of `x`
- * (spacing {@link spacingUp}, 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 = spacingUp(x);
-  const q = c / ulp;
-  const mantissa = x / ulp;
-  const f = Math.floor(q);
-  const d = q - f;
-  // parity of mantissa - f from each part: the mantissa can be 2^53 (half spacing), where mantissa - f is not exact
-  const applied = d > 0.5 ? f + 1 : d < 0.5 ? f : Math.abs(mantissa % 2) === Math.abs(f % 2) ? 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/table/index.ts

@@ -0,0 +1,221 @@
+/**
+ * Table namespace
+ * Functions for creating and filling table drawing objects.
+ *
+ * @remarks
+ * A table is drawn at a fixed position of the pane (`position.*`), not at a bar. Tables have no getters in
+ * PineScript; the script API returns the live tables in `result.tables`.
+ *
+ * PineScript rules:
+ * - `table.cell` defines a cell: the arguments it does not give get their default, a previous definition of the
+ *   cell is replaced
+ * - `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
+ *
+ * @version 6
+ */
+
+import { all as allDrawings, isDeleted, register, remove } from '../drawing/registry.js';
+import type { Table, TableCell, color } from '../types/index.js';
+
+type TablePosition = Table['position'];
+type HAlign = 'left' | 'center' | 'right';
+type VAlign = 'top' | 'center' | 'bottom';
+type FontFamily = 'default' | 'monospace';
+
+/**
+ * Creates a new table (PineScript `table.new`).
+ *
+ * @example
+ * ```typescript
+ * const t = table.new(position.top_right, 2, 3, '#131722', '#787B86', 1);
+ * table.cell(t, 0, 0, 'RSI', 0, 0, '#FFFFFF');
+ * ```
+ */
+export function new_table(
+  position: TablePosition,
+  columns: number,
+  rows: number,
+  bgcolor?: color,
+  frame_color?: color,
+  frame_width?: number,
+  border_color?: color,
+  border_width?: number,
+  force_overlay?: boolean
+): Table {
+  return register('table', {
+    position,
+    columns,
+    rows,
+    bgcolor,
+    frame_color,
+    frame_width,
+    border_color,
+    border_width,
+    force_overlay: force_overlay ?? false,
+    cells: new Map(),
+    merges: [],
+  });
+}
+
+function checkCell(caller: string, id: Table, column: number, row: number): void {
+  if (!(column >= 0 && column < id.columns && row >= 0 && row < id.rows)) {
+    throw new RangeError(
+      `${caller}: column ${column}, row ${row} is outside the table (${id.columns} columns, ${id.rows} rows).`
+    );
+  }
+}
+
+const key = (column: number, row: number): string => `${column},${row}`;
+
+/** The cell at column / row, created when it was not defined. */
+function cellOf(caller: string, id: Table, column: number, row: number): TableCell {
+  checkCell(caller, id, column, row);
+  const cells = (id.cells ??= new Map());
+  let cell = cells.get(key(column, row));
+  if (!cell) cells.set(key(column, row), (cell = { text: '' }));
+  return cell;
+}
+
+/**
+ * Defines a cell (PineScript `table.cell`): its text and properties. Omitted properties get their default.
+ */
+export function cell(
+  table_id: Table,
+  column: number,
+  row: number,
+  text?: string,
+  width?: number,
+  height?: number,
+  text_color?: color,
+  text_halign?: HAlign,
+  text_valign?: VAlign,
+  text_size?: string | number,
+  bgcolor?: color,
+  tooltip?: string,
+  text_font_family?: FontFamily,
+  text_formatting?: number
+): void {
+  if (isDeleted(table_id)) return;
+  checkCell('table.cell()', table_id, column, row);
+  (table_id.cells ??= new Map()).set(key(column, row), {
+    text: text ?? '',
+    width,
+    height,
+    text_color,
+    text_halign,
+    text_valign,
+    text_size,
+    bgcolor,
+    tooltip,
+    text_font_family,
+    text_formatting,
+  });
+}
+
+function setCell<K extends keyof TableCell>(name: string, field: K) {
+  return (table_id: Table, column: number, row: number, value: TableCell[K]): void => {
+    if (isDeleted(table_id)) return;
+    cellOf(`table.${name}()`, table_id, column, row)[field] = value;
+  };
+}
+
+/** Sets the text of a cell. */
+export const cell_set_text = setCell('cell_set_text', 'text');
+/** Sets the width of a cell (% of the chart width; 0 fits the text). */
+export const cell_set_width = setCell('cell_set_width', 'width');
+/** Sets the height of a cell (% of the chart height; 0 fits the text). */
+export const cell_set_height = setCell('cell_set_height', 'height');
+/** Sets the text colour of a cell. */
+export const cell_set_text_color = setCell('cell_set_text_color', 'text_color');
+/** Sets the horizontal text alignment of a cell. */
+export const cell_set_text_halign = setCell('cell_set_text_halign', 'text_halign');
+/** Sets the vertical text alignment of a cell. */
+export const cell_set_text_valign = setCell('cell_set_text_valign', 'text_valign');
+/** Sets the text size of a cell. */
+export const cell_set_text_size = setCell('cell_set_text_size', 'text_size');
+/** Sets the background colour of a cell. */
+export const cell_set_bgcolor = setCell('cell_set_bgcolor', 'bgcolor');
+/** Sets the tooltip of a cell. */
+export const cell_set_tooltip = setCell('cell_set_tooltip', 'tooltip');
+/** Sets the font family of a cell. */
+export const cell_set_text_font_family = setCell('cell_set_text_font_family', 'text_font_family');
+/** Sets the text formatting of a cell (`text.format_*` flags). */
+export const cell_set_text_formatting = setCell('cell_set_text_formatting', 'text_formatting');
+
+/**
+ * Merges the cells from start_column / start_row to end_column / end_row (PineScript `table.merge_cells`). The
+ * merged cell shows the content of the start cell.
+ */
+export function merge_cells(
+  table_id: Table,
+  start_column: number,
+  start_row: number,
+  end_column: number,
+  end_row: number
+): void {
+  if (isDeleted(table_id)) return;
+  checkCell('table.merge_cells()', table_id, start_column, start_row);
+  checkCell('table.merge_cells()', table_id, end_column, end_row);
+  if (end_column < start_column || end_row < start_row) {
+    throw new RangeError('table.merge_cells(): the end cell is before the start cell.');
+  }
+  (table_id.merges ??= []).push({ start_column, start_row, end_column, end_row });
+}
+
+/**
+ * Removes the cells from start_column / start_row to end_column / end_row (PineScript `table.clear`; default end:
+ * the start cell), and the merges that start in that range.
+ */
+export function clear(
+  table_id: Table,
+  start_column: number,
+  start_row: number,
+  end_column: number = start_column,
+  end_row: number = start_row
+): void {
+  if (isDeleted(table_id)) return;
+  checkCell('table.clear()', table_id, start_column, start_row);
+  checkCell('table.clear()', table_id, end_column, end_row);
+  const inside = (column: number, row: number): boolean =>
+    column >= start_column && column <= end_column && row >= start_row && row <= end_row;
+  for (let column = start_column; column <= end_column; column++) {
+    for (let row = start_row; row <= end_row; row++) table_id.cells?.delete(key(column, row));
+  }
+  if (table_id.merges) table_id.merges = table_id.merges.filter((m) => !inside(m.start_column, m.start_row));
+}
+
+function setTable<K extends keyof Table>(field: K) {
+  return (table_id: Table, value: Table[K]): void => {
+    if (isDeleted(table_id)) return;
+    table_id[field] = value;
+  };
+}
+
+/** Moves the table to another position (`position.*`). */
+export const set_position = setTable('position');
+/** Sets the background colour of the table. */
+export const set_bgcolor = setTable('bgcolor');
+/** Sets the colour of the outer frame. */
+export const set_frame_color = setTable('frame_color');
+/** Sets the width of the outer frame. */
+export const set_frame_width = setTable('frame_width');
+/** Sets the colour of the cell borders. */
+export const set_border_color = setTable('border_color');
+/** Sets the width of the cell borders. */
+export const set_border_width = setTable('border_width');
+
+/** Deletes the table (PineScript `table.delete`). */
+export function delete_table(table_id: Table): void {
+  remove('table', table_id);
+}
+
+/** All live tables, in creation order (PineScript `table.all`). A new array. */
+export function all(): Table[] {
+  return allDrawings('table');
+}
+
+// Alias to match PineScript API
+export { new_table as new };
+export { delete_table as delete };

package/src/text/index.ts

@@ -1,8 +1,9 @@
 /**
  * Text namespace
- * PineScript `text.format_*` constants for `label.set_text_formatting` and `box.set_text_formatting`.
+ * PineScript `text.format_*` constants for `label.set_text_formatting` and `box.set_text_formatting`, and the
+ * `text.align_*` / `text.wrap_*` constants.
  *
- * The values are flags that add up, as in PineScript (`text.format_bold + text.format_italic`).
+ * The format values are flags that add up, as in PineScript (`text.format_bold + text.format_italic`).
  * They are the values PineScript uses for drawn labels and boxes.
  */
 
@@ -12,3 +13,18 @@ export const format_none = 0;
 export const format_bold = 1;
 /** Italic text. */
 export const format_italic = 2;
+
+/** Text aligned to the left (`table.cell`, `box.new`, `label.new` textalign). */
+export const align_left = 'left' as const;
+/** Text centred horizontally or vertically. */
+export const align_center = 'center' as const;
+/** Text aligned to the right. */
+export const align_right = 'right' as const;
+/** Text aligned to the top (`table.cell`, `box.new` text_valign). */
+export const align_top = 'top' as const;
+/** Text aligned to the bottom. */
+export const align_bottom = 'bottom' as const;
+/** Text wrapped to the box width (`box.new` text_wrap). */
+export const wrap_auto = 'auto' as const;
+/** Text not wrapped. */
+export const wrap_none = 'none' as const;

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();