oakscriptjs 0.9.6 → 0.10.0

package/src/script/index.ts

@@ -37,18 +37,35 @@ import type { Bar } from '../types/index.js';
 import type {
   ArrowData,
   BarColorData,
+  BgColorData,
+  BoxData,
   FillData,
   FillGradient,
   IndicatorResult,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  LinefillData,
   MarkerData,
   MarkerLocation,
+  MarkerPosition,
+  MarkerShape,
   MarkerSize,
+  PineSize,
+  PlotBarData,
+  PlotCandleData,
+  PolylineData,
   ShapeStyle,
+  TableCellData,
+  TableData,
+  TableMergeData,
+  TablePosition,
   TimeValue,
 } from '../types/metadata.js';
 import type {
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   FillConfig,
   HLineConfig,
   InputConfig,
@@ -65,10 +82,12 @@ import * as labelCore from '../label/index.js';
 import * as boxCore from '../box/index.js';
 import * as linefillCore from '../linefill/index.js';
 import * as polylineCore from '../polyline/index.js';
+import * as tableCore from '../table/index.js';
 import * as chartPointCore from '../chartpoint/index.js';
 import * as textCore from '../text/index.js';
 import * as mathCore from '../math/index.js';
 import { resetDrawings, setDrawingLimits } from '../drawing/registry.js';
+import { drawingOutputs } from '../drawing/output.js';
 import * as timeframeCore from '../timeframe/index.js';
 import * as timeCore from '../time/index.js';
 import * as strCore from '../str/index.js';
@@ -76,6 +95,7 @@ import { formatMessage } from '../str/messageformat.js';
 import { TradingCalendar, type SessionSpec } from '../session/calendar.js';
 import { SessionBars, sessionFlags, type SessionFlags } from '../session/bars.js';
 import { afterCompletion, heikinAshi, mapToChart, periodsOf, resample } from '../security/resample.js';
+import { position } from '../types/index.js';
 import type { ChartPoint } from '../types/index.js';
 import {
   STRATEGY_CONSTANTS,
@@ -110,11 +130,17 @@ export interface ScriptRunResult {
   shapeConfig: ShapeConfig[];
   arrowConfig: ArrowConfig[];
   barColorConfig: BarColorConfig[];
+  /** plotcandle() / plotbar() declarations */
+  candleConfig: CandleConfig[];
   defaultInputs: Record<string, unknown>;
   alertConfig: AlertConditionConfig[];
   /** Strategy properties (declared values, else the PineScript defaults) when the script declares strategy(). */
   strategyConfig?: StrategyProperties;
-  /** The renderable output (plots keyed by plotConfig ids, plot-pair fills). */
+  /**
+   * The renderable output: plots keyed by plotConfig ids, plot-pair fills, markers, arrows, background and bar
+   * colours, candles and bars, and the drawings (labels, lines, boxes, linefills, polylines, tables) alive after the
+   * last bar.
+   */
   result: IndicatorResult & { alerts?: AlertState[] };
 }
 
@@ -159,8 +185,11 @@ interface Collector {
   arrowConfig: ArrowConfig[];
   arrows: ArrowData[];
   barColorConfig: BarColorConfig[];
-  bgcolors: BarColorData[];
-  barcolors: BarColorData[];
+  bgColors: BgColorData[];
+  barColors: BarColorData[];
+  candleConfig: CandleConfig[];
+  plotCandles: Record<string, PlotCandleData[]>;
+  plotBars: Record<string, PlotBarData[]>;
   alertConfig: AlertConditionConfig[];
   alerts: AlertState[];
   strategy?: StrategyRun;
@@ -210,8 +239,11 @@ function freshCollector(inputValues: Record<string, unknown>): Collector {
     arrowConfig: [],
     arrows: [],
     barColorConfig: [],
-    bgcolors: [],
-    barcolors: [],
+    bgColors: [],
+    barColors: [],
+    candleConfig: [],
+    plotCandles: {},
+    plotBars: {},
     alertConfig: [],
     alerts: [],
   };
@@ -284,6 +316,7 @@ export function executeScript(
       shapeConfig: c.shapeConfig,
       arrowConfig: c.arrowConfig,
       barColorConfig: c.barColorConfig,
+      candleConfig: c.candleConfig,
       defaultInputs: c.defaultInputs,
       alertConfig: c.alertConfig,
       strategyConfig: c.strategy?.properties,
@@ -293,8 +326,11 @@ export function executeScript(
         fills: c.fills.length ? c.fills : undefined,
         markers: c.markers.length ? c.markers : undefined,
         arrows: c.arrows.length ? c.arrows : undefined,
-        bgcolors: c.bgcolors.length ? c.bgcolors : undefined,
-        barcolors: c.barcolors.length ? c.barcolors : undefined,
+        bgColors: c.bgColors.length ? c.bgColors : undefined,
+        barColors: c.barColors.length ? c.barColors : undefined,
+        plotCandles: Object.keys(c.plotCandles).length ? c.plotCandles : undefined,
+        plotBars: Object.keys(c.plotBars).length ? c.plotBars : undefined,
+        ...drawingOutputs(ctxBars.bars, chartCtx.timeUnit),
         alerts: c.alerts.length ? c.alerts : undefined,
       },
     };
@@ -779,8 +815,46 @@ export interface PlotCharOptions extends Omit<PlotShapeOptions, 'style'> {
   char?: string;
 }
 
+/** PineScript shape.* style -> marker shape. */
+const MARKER_SHAPES: Record<ShapeStyle, MarkerShape> = {
+  xcross: 'xcross',
+  cross: 'cross',
+  triangleup: 'triangleUp',
+  triangledown: 'triangleDown',
+  flag: 'flag',
+  circle: 'circle',
+  arrowup: 'arrowUp',
+  arrowdown: 'arrowDown',
+  labelup: 'labelUp',
+  labeldown: 'labelDown',
+  square: 'square',
+  diamond: 'diamond',
+};
+
+/**
+ * Marker position of a PineScript location. With location.absolute the shape sits on the price: a label pointing
+ * down above it, a label pointing up below it, the other shapes (and the characters) centred on it.
+ */
+function markerPosition(location: MarkerLocation, shape: ShapeStyle | undefined): MarkerPosition {
+  switch (location) {
+    case 'abovebar':
+      return 'aboveBar';
+    case 'belowbar':
+      return 'belowBar';
+    case 'top':
+      return 'top';
+    case 'bottom':
+      return 'bottom';
+    case 'absolute':
+      return shape === 'labeldown' ? 'atPriceTop' : shape === 'labelup' ? 'atPriceBottom' : 'atPriceMiddle';
+  }
+}
+
+/** Default colour of plotshape / plotchar markers. */
+const MARKER_COLOR = '#2962FF';
+
 /** Shared emitter for plotshape()/plotchar(). Emits one marker per bar where
- *  the condition is truthy (not na, not 0). */
+ *  the condition is truthy (not na, not 0). A plotchar marker has the shape 'circle' and its character in `char`. */
 function emitMarkers(
   kind: 'shape' | 'char',
   condition: Series,
@@ -806,6 +880,19 @@ function emitMarkers(
     offset: options.offset,
     forceOverlay: options.force_overlay,
   });
+  const shapeStyle = kind === 'shape' ? (style as ShapeStyle) : undefined;
+  const template: Omit<MarkerData, 'time'> = {
+    position: markerPosition(location, shapeStyle),
+    shape: shapeStyle ? MARKER_SHAPES[shapeStyle] : 'circle',
+    color: options.color ?? MARKER_COLOR,
+    id,
+  };
+  if (char !== undefined) template.char = char;
+  if (options.text !== undefined) template.text = options.text;
+  if (options.textcolor !== undefined) template.textColor = options.textcolor;
+  if (options.size !== undefined) template.size = options.size;
+  if (options.tooltip !== undefined) template.tooltip = options.tooltip;
+  if (options.force_overlay) template.forceOverlay = true;
   const values = condition.toArray();
   const b = bars();
   const off = options.offset ?? 0;
@@ -814,19 +901,8 @@ function emitMarkers(
     if (v === undefined || Number.isNaN(v) || v === 0) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    c.markers.push({
-      time: b[j]!.time,
-      id,
-      location,
-      style,
-      char,
-      color: options.color,
-      text: options.text,
-      textcolor: options.textcolor,
-      size: options.size,
-      tooltip: options.tooltip,
-      price: location === 'absolute' ? v : undefined,
-    });
+    const time = b[j]!.time;
+    c.markers.push(location === 'absolute' ? { time, ...template, price: v } : { time, ...template });
   }
 }
 
@@ -906,13 +982,14 @@ function emitBarColors(
   c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset, forceOverlay: options.force_overlay });
   const b = bars();
   const off = options.offset ?? 0;
-  const target = kind === 'bgcolor' ? c.bgcolors : c.barcolors;
+  const target: BgColorData[] = kind === 'bgcolor' ? c.bgColors : c.barColors;
+  const forceOverlay = kind === 'bgcolor' && options.force_overlay === true;
   for (let i = 0; i < b.length; i++) {
     const col = typeof colors === 'string' ? colors : colors[i];
     if (!col) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    target.push({ time: b[j]!.time, color: col });
+    target.push(forceOverlay ? { time: b[j]!.time, color: col, forceOverlay } : { time: b[j]!.time, color: col });
   }
 }
 
@@ -935,6 +1012,129 @@ export function barcolor(
   emitBarColors('barcolor', colors, options);
 }
 
+/** A colour argument of plotcandle() / plotbar(): a colour, or per-bar colours (null / undefined entries are na). */
+export type ScriptCandleColor = string | Array<string | null | undefined>;
+
+export interface PlotCandleOptions {
+  /** Body colour: a colour or a per-bar array (color.when); an na entry gives a transparent body */
+  color?: ScriptCandleColor;
+  /** Wick colour: a colour or a per-bar array */
+  wickcolor?: ScriptCandleColor;
+  /** Border colour: a colour or a per-bar array */
+  bordercolor?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+export interface PlotBarOptions {
+  /** Bar colour: a colour or a per-bar array (color.when); an na entry gives a transparent bar */
+  color?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+/** Colour of bar i: undefined when the argument is not given, 'transparent' for an na entry. */
+function candleColor(col: ScriptCandleColor | undefined, i: number): string | undefined {
+  if (col === undefined) return undefined;
+  if (typeof col === 'string') return col;
+  return col[i] ?? 'transparent';
+}
+
+interface OhlcRow {
+  i: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+}
+
+/** The bars where open, high, low and close are all not na (PineScript draws no candle / bar otherwise). */
+function ohlcRows(o: Series, h: Series, l: Series, cl: Series): OhlcRow[] {
+  const [ov, hv, lv, cv] = [o.toArray(), h.toArray(), l.toArray(), cl.toArray()];
+  const rows: OhlcRow[] = [];
+  for (let i = 0; i < bars().length; i++) {
+    const [open, high, low, close] = [ov[i]!, hv[i]!, lv[i]!, cv[i]!];
+    if (Number.isFinite(open) && Number.isFinite(high) && Number.isFinite(low) && Number.isFinite(close)) {
+      rows.push({ i, open, high, low, close });
+    }
+  }
+  return rows;
+}
+
+const staticColor = (col: ScriptCandleColor | undefined): string | undefined => (typeof col === 'string' ? col : undefined);
+
+/**
+ * PineScript `plotcandle(open, high, low, close, title?, { color, wickcolor, bordercolor, display, force_overlay })`:
+ * candles in `result.plotCandles[id]`, the declaration in `candleConfig`. A bar with an na value has no candle.
+ */
+export function plotcandle(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotCandleOptions = {}
+): void {
+  const c = collector();
+  const id = `plotcandle${c.candleConfig.filter((x) => x.kind === 'candle').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'candle',
+    title,
+    color: staticColor(options.color),
+    wickColor: staticColor(options.wickcolor),
+    borderColor: staticColor(options.bordercolor),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotCandles[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const candle: PlotCandleData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    const wickColor = candleColor(options.wickcolor, i);
+    const borderColor = candleColor(options.bordercolor, i);
+    if (color !== undefined) candle.color = color;
+    if (wickColor !== undefined) candle.wickColor = wickColor;
+    if (borderColor !== undefined) candle.borderColor = borderColor;
+    if (options.force_overlay) candle.forceOverlay = true;
+    return candle;
+  });
+}
+
+/**
+ * PineScript `plotbar(open, high, low, close, title?, { color, display, force_overlay })`: OHLC bars in
+ * `result.plotBars[id]`, the declaration in `candleConfig`. A bar with an na value is not drawn.
+ */
+export function plotbar(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotBarOptions = {}
+): void {
+  const c = collector();
+  const id = `plotbar${c.candleConfig.filter((x) => x.kind === 'bar').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'bar',
+    title,
+    color: staticColor(options.color),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotBars[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const bar: PlotBarData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    if (color !== undefined) bar.color = color;
+    if (options.force_overlay) bar.forceOverlay = true;
+    return bar;
+  });
+}
+
 // ── Per-bar execution (eachBar) ──────────────────────────────────────────────
 
 /**
@@ -1831,7 +2031,20 @@ export const polyline = {
   },
 };
 
-/** PineScript `text.format_*` constants. */
+/**
+ * PineScript `table.*`; `table.all` lists the live tables in creation order. The live tables go to `result.tables`.
+ */
+export const table = {
+  ...tableCore,
+  get all() {
+    return tableCore.all();
+  },
+};
+
+/** PineScript `position.*` constants (table positions). */
+export { position };
+
+/** PineScript `text.format_*`, `text.align_*` and `text.wrap_*` constants. */
 export const text = { ...textCore };
 
 /**
@@ -1913,10 +2126,27 @@ export type {
   ShapeConfig,
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   MarkerData,
+  MarkerPosition,
+  MarkerShape,
   ArrowData,
   BarColorData,
+  BgColorData,
+  PlotCandleData,
+  PlotBarData,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  BoxData,
+  LinefillData,
+  PolylineData,
+  TableData,
+  TableCellData,
+  TableMergeData,
+  TablePosition,
   MarkerLocation,
   MarkerSize,
+  PineSize,
   ShapeStyle,
 };

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;