oakscriptjs 0.9.5 → 0.10.0

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

package/src/types/index.ts

@@ -217,8 +217,22 @@ export interface Table {
   border_width?: number;
   /** Table background color */
   bgcolor?: color;
-  /** Cell data (internal storage) */
+  /** Display on the main chart pane (PineScript force_overlay) */
+  force_overlay?: boolean;
+  /** Cells by "column,row" */
   cells?: Map<string, TableCell>;
+  /** Merged cell ranges (PineScript table.merge_cells) */
+  merges?: TableMerge[];
+}
+
+/**
+ * Merged cell range of a table
+ */
+export interface TableMerge {
+  start_column: number;
+  start_row: number;
+  end_column: number;
+  end_row: number;
 }
 
 /**
@@ -245,6 +259,8 @@ export interface TableCell {
   tooltip?: string;
   /** Text font family */
   text_font_family?: 'default' | 'monospace';
+  /** Text formatting flags: 0 none, 1 bold, 2 italic, 3 bold + italic (PineScript text.format_*) */
+  text_formatting?: number;
 }
 
 // Series types for drawing objects
@@ -349,6 +365,21 @@ export const xloc = {
   bar_time: 'bar_time' as const,
 };
 
+/**
+ * Table position constants (PineScript `position.*`), for `table.new` and `table.set_position`
+ */
+export const position = {
+  top_left: 'top_left' as const,
+  top_center: 'top_center' as const,
+  top_right: 'top_right' as const,
+  middle_left: 'middle_left' as const,
+  middle_center: 'middle_center' as const,
+  middle_right: 'middle_right' as const,
+  bottom_left: 'bottom_left' as const,
+  bottom_center: 'bottom_center' as const,
+  bottom_right: 'bottom_right' as const,
+};
+
 /**
  * ChartPoint interface - Represents a point on the chart
  * @remarks

package/src/types/metadata.ts

@@ -223,14 +223,19 @@ export interface FillGradient {
 }
 
 /**
- * Marker location on the chart (PineScript plotshape/plotchar locations)
+ * Marker location on the chart (PineScript plotshape/plotchar `location.*`)
  */
 export type MarkerLocation = 'abovebar' | 'belowbar' | 'top' | 'bottom' | 'absolute';
 
+/**
+ * PineScript size constant (`size.auto`, `size.tiny`, ...)
+ */
+export type PineSize = 'auto' | 'tiny' | 'small' | 'normal' | 'large' | 'huge';
+
 /**
  * Marker size (PineScript size.* constants)
  */
-export type MarkerSize = 'auto' | 'tiny' | 'small' | 'normal' | 'large' | 'huge';
+export type MarkerSize = PineSize;
 
 /**
  * Shape style (PineScript shape.* constants)
@@ -250,31 +255,76 @@ export type ShapeStyle =
   | 'diamond';
 
 /**
- * One marker emitted by plotshape()/plotchar() on a bar where the condition held
+ * Position of a marker:
+ * - aboveBar / belowBar / inBar: next to the bar (PineScript location.abovebar / location.belowbar)
+ * - atPriceTop / atPriceBottom / atPriceMiddle: at `price` (PineScript location.absolute), with the meaning of the
+ *   lightweight-charts price positions: atPriceTop has the shape above the price, its bottom (the tip of a label) on
+ *   the price (shape.labeldown); atPriceBottom has the shape below the price, its top on the price (shape.labelup);
+ *   atPriceMiddle centres the shape on the price (other shapes)
+ * - top / bottom: at the top / bottom edge of the pane of the indicator (PineScript location.top / location.bottom),
+ *   the price pane for an overlay indicator or with forceOverlay
+ */
+export type MarkerPosition =
+  | 'aboveBar'
+  | 'belowBar'
+  | 'inBar'
+  | 'atPriceTop'
+  | 'atPriceBottom'
+  | 'atPriceMiddle'
+  | 'top'
+  | 'bottom';
+
+/**
+ * Marker shape (PineScript shape.* in the lightweight-charts spelling)
+ */
+export type MarkerShape =
+  | 'arrowUp'
+  | 'arrowDown'
+  | 'circle'
+  | 'square'
+  | 'labelUp'
+  | 'labelDown'
+  | 'triangleUp'
+  | 'triangleDown'
+  | 'cross'
+  | 'xcross'
+  | 'diamond'
+  | 'flag';
+
+/**
+ * One marker: a plotshape()/plotchar() marker on a bar where the condition held, or a marker of a built-in indicator
  */
 export interface MarkerData {
   /** Time of the bar the marker is displayed on (offset already applied) */
-  time: any;
-  /** Id of the plotshape/plotchar declaration that produced it */
-  id: string;
-  /** Marker location relative to the bar */
-  location: MarkerLocation;
-  /** Shape style, or 'char' for plotchar markers */
-  style: ShapeStyle | 'char';
-  /** Character (plotchar only) */
-  char?: string;
-  /** Marker color */
-  color?: string;
-  /** Text shown near the marker */
+  time: number;
+  /** Where the marker is drawn */
+  position: MarkerPosition;
+  /** Price of the atPrice* positions (required with them) */
+  price?: number;
+  /** Shape. A plotchar marker also has `char`: the character is drawn in place of the shape */
+  shape: MarkerShape;
+  /**
+   * Shape colour (the character colour of a plotchar marker). A fully transparent colour ('transparent',
+   * '#rrggbb00', 'rgba(r, g, b, 0)') draws no shape, as PineScript `color = na`; the text is still drawn
+   */
+  color: string;
+  /** Text; a line feed starts a new line */
   text?: string;
-  /** Text color */
-  textcolor?: string;
-  /** Marker size */
-  size?: MarkerSize;
-  /** Hover tooltip (extension over PineScript plotshape, used by label.new ports) */
+  /**
+   * Text colour (PineScript textcolor). When omitted: white inside label shapes (labelUp / labelDown), the shape
+   * colour for the other shapes
+   */
+  textColor?: string;
+  /** Size multiplier (1 = default size) or a PineScript size */
+  size?: number | PineSize;
+  /** PineScript force_overlay = true: the marker of a non-overlay indicator is drawn on the price pane */
+  forceOverlay?: boolean;
+  /** Id of the plotshape/plotchar declaration that produced it (script markers) */
+  id?: string;
+  /** plotchar character, drawn in place of the shape */
+  char?: string;
+  /** Hover tooltip */
   tooltip?: string;
-  /** Price for location 'absolute' (the series value on that bar) */
-  price?: number;
 }
 
 /**
@@ -292,15 +342,248 @@ export interface ArrowData {
 }
 
 /**
- * Per-bar color for bgcolor()/barcolor() output
+ * Per-bar candle color (barcolor() output)
  */
 export interface BarColorData {
   /** Time of the colored bar (offset already applied) */
-  time: any;
+  time: number;
   /** Color */
   color: string;
 }
 
+/**
+ * Per-bar background color (bgcolor() output)
+ */
+export interface BgColorData {
+  /** Time of the colored bar (offset already applied) */
+  time: number;
+  /** Color (with its transparency) */
+  color: string;
+  /** PineScript bgcolor(..., force_overlay = true): drawn on the price pane even for a non-overlay indicator */
+  forceOverlay?: boolean;
+}
+
+/**
+ * One candle of plotcandle() (or of a built-in indicator that draws candles)
+ */
+export interface PlotCandleData {
+  time: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  /** Body colour */
+  color?: string;
+  borderColor?: string;
+  wickColor?: string;
+  /** PineScript force_overlay = true: the candles of a non-overlay indicator are drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
+/**
+ * One bar of plotbar(): an OHLC bar (a vertical line from low to high, the open tick on the left, the close tick on
+ * the right)
+ */
+export interface PlotBarData {
+  time: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  color?: string;
+  /** PineScript force_overlay = true: the bars of a non-overlay indicator are drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
+/** PineScript label style (`label.style_*` without the prefix) */
+export type LabelStyle =
+  | 'none'
+  | 'xcross'
+  | 'cross'
+  | 'triangleup'
+  | 'triangledown'
+  | 'flag'
+  | 'circle'
+  | 'arrowup'
+  | 'arrowdown'
+  | 'label_up'
+  | 'label_down'
+  | 'label_left'
+  | 'label_right'
+  | 'label_lower_left'
+  | 'label_lower_right'
+  | 'label_upper_left'
+  | 'label_upper_right'
+  | 'label_center'
+  | 'square'
+  | 'diamond'
+  | 'text_outline';
+
+// Drawing outputs (labels, lines, boxes, linefills, polylines, tables). A field the script did not set is omitted and
+// the renderer uses the PineScript default; a colour set to na is 'transparent'. A point on a bar after the last bar
+// (PineScript bar_index + k) has the time of that future bar (see barTime). The same applies to markers and plots.
+
+/**
+ * A label (PineScript label.new)
+ */
+export interface LabelData {
+  time: number;
+  /** Price; not used with yloc 'abovebar' / 'belowbar' */
+  price: number;
+  text: string;
+  /** Background, border and arrow colour */
+  color?: string;
+  textColor?: string;
+  /** 'none': text only, no background (PineScript label.style_none) */
+  style?: LabelStyle;
+  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';
+  textAlign?: 'left' | 'center' | 'right';
+  tooltip?: string;
+  fontFamily?: 'default' | 'monospace';
+  /** PineScript text.format_* flags: 0 none, 1 bold, 2 italic, 3 bold + italic */
+  textFormatting?: number;
+  /** PineScript force_overlay = true: the label of a non-overlay indicator is drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
+/**
+ * A line (PineScript line.new)
+ */
+export interface LineDrawingData {
+  time1: number;
+  price1: number;
+  time2: number;
+  price2: number;
+  color?: string;
+  width?: number;
+  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 */
+  forceOverlay?: boolean;
+}
+
+/**
+ * A rectangle (PineScript box.new): time1 / price1 are the left / top, time2 / price2 the right / bottom
+ */
+export interface BoxData {
+  time1: number;
+  price1: number;
+  time2: number;
+  price2: number;
+  bgColor?: string;
+  borderColor?: string;
+  borderWidth?: number;
+  borderStyle?: 'solid' | 'dashed' | 'dotted';
+  text?: string;
+  textColor?: string;
+  textSize?: PineSize | number;
+  textHAlign?: 'left' | 'center' | 'right';
+  textVAlign?: 'top' | 'center' | 'bottom';
+  textWrap?: 'none' | 'auto';
+  fontFamily?: 'default' | 'monospace';
+  /** PineScript text.format_* flags: 0 none, 1 bold, 2 italic, 3 bold + italic */
+  textFormatting?: number;
+  /** PineScript box extend: the box continues to the left / right edge of the chart */
+  extend?: 'none' | 'left' | 'right' | 'both';
+  /** PineScript force_overlay = true: the box of a non-overlay indicator is drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
+/**
+ * The area between two lines (PineScript linefill.new), with the two lines as drawn (their extend included)
+ */
+export interface LinefillData {
+  line1: LineDrawingData;
+  line2: LineDrawingData;
+  color?: string;
+}
+
+/**
+ * A polyline (PineScript polyline.new)
+ */
+export interface PolylineData {
+  points: Array<{ time: number; price: number }>;
+  /** Curved segments between the points */
+  curved?: boolean;
+  /** The last point is connected to the first */
+  closed?: boolean;
+  lineColor?: string;
+  /** Fill of the area inside the polyline */
+  fillColor?: string;
+  lineStyle?: 'solid' | 'dotted' | 'dashed' | 'arrow_left' | 'arrow_right' | 'arrow_both';
+  lineWidth?: number;
+  /** PineScript force_overlay = true: the polyline of a non-overlay indicator is drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
+/** Table position (PineScript position.*) */
+export type TablePosition =
+  | 'top_left'
+  | 'top_center'
+  | 'top_right'
+  | 'middle_left'
+  | 'middle_center'
+  | 'middle_right'
+  | 'bottom_left'
+  | 'bottom_center'
+  | 'bottom_right';
+
+/**
+ * A table cell (PineScript table.cell)
+ */
+export interface TableCellData {
+  row: number;
+  column: number;
+  text: string;
+  bgColor?: string;
+  textColor?: string;
+  textSize?: PineSize | number;
+  /** Width in % of the chart width; 0 fits the text */
+  width?: number;
+  /** Height in % of the chart height; 0 fits the text */
+  height?: number;
+  textHAlign?: 'left' | 'center' | 'right';
+  textVAlign?: 'top' | 'center' | 'bottom';
+  tooltip?: string;
+  fontFamily?: 'default' | 'monospace';
+  /** PineScript text.format_* flags: 0 none, 1 bold, 2 italic, 3 bold + italic */
+  textFormatting?: number;
+}
+
+/**
+ * Merged cells of a table (PineScript table.merge_cells): the cell at the start column / row covers the range and
+ * gives its content
+ */
+export interface TableMergeData {
+  startColumn: number;
+  startRow: number;
+  endColumn: number;
+  endRow: number;
+}
+
+/**
+ * A table (PineScript table.new)
+ */
+export interface TableData {
+  position: TablePosition;
+  columns: number;
+  rows: number;
+  cells: TableCellData[];
+  merges?: TableMergeData[];
+  bgColor?: string;
+  frameColor?: string;
+  frameWidth?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  /** PineScript force_overlay = true: the table of a non-overlay indicator is drawn on the price pane */
+  forceOverlay?: boolean;
+}
+
 /**
  * Complete indicator calculation result
  */
@@ -318,9 +601,25 @@ export interface IndicatorResult {
   /** Arrows from plotarrow() */
   arrows?: ArrowData[];
   /** Background colors from bgcolor() */
-  bgcolors?: BarColorData[];
+  bgColors?: BgColorData[];
   /** Bar colors from barcolor() */
-  barcolors?: BarColorData[];
+  barColors?: BarColorData[];
+  /** Candles from plotcandle(), keyed by plotcandle id */
+  plotCandles?: Record<string, PlotCandleData[]>;
+  /** OHLC bars from plotbar(), keyed by plotbar id */
+  plotBars?: Record<string, PlotBarData[]>;
+  /** Labels alive after the last bar */
+  labels?: LabelData[];
+  /** Lines alive after the last bar */
+  lines?: LineDrawingData[];
+  /** Boxes alive after the last bar */
+  boxes?: BoxData[];
+  /** Linefills alive after the last bar */
+  linefills?: LinefillData[];
+  /** Polylines alive after the last bar */
+  polylines?: PolylineData[];
+  /** Tables alive after the last bar */
+  tables?: TableData[];
 }
 
 /**