@promptctl/rich-js 0.24.1 → 0.25.0

package/dist/renderables/scroll.js

@@ -0,0 +1,106 @@
+/**
+ * Scroll — a slot of fixed size over content wider or taller than it, the
+ * content's offset in the slot moving with time: a long line panning as a
+ * marquee, a log tail scrolling, a panel sliding into its place.
+ *
+ * [LAW:one-type-per-behavior] A marquee, a scroll and a slide are one window
+ * and differ only in the motion handed in: the offset along each axis is an
+ * `Animation<number>`, so a marquee is a looping `Phase` scaled to the span
+ * it crosses and a slide-in is a `tween` to 0, and when the window next
+ * changes is `Animation.all`'s answer over the two. Nothing here knows which
+ * one it is drawing.
+ *
+ * The slot is what the window is. It measures as its width whatever the
+ * content, and draws exactly its rows of its width at every offset — cropped
+ * only to a narrower room it is given — so what sits beside it never moves.
+ * An offset before or past the content shows blank cells rather than stopping
+ * at an edge: that is what lets a marquee enter from the right and a slide-in
+ * arrive from outside the slot.
+ *
+ * The content is drawn at its own natural width and no height, its own
+ * length, because the content wider and taller than the slot is the thing
+ * being windowed. Content that should wrap to the slot instead, or that has
+ * no natural width because it fills whatever it is given, is
+ * `new Constrain(content, width)`, composed rather than asked for.
+ *
+ * [LAW:single-enforcer] A row is cut at the window's edges by
+ * `Segment.divide`, the one place a line is cut at a column: a wide glyph a
+ * cut falls in is blanked, never halved, and each cell's anchor still names
+ * its column in the content, so hit-testing finds the owner through a moving
+ * window.
+ *
+ * [LAW:no-ambient-temporal-coupling] Pure in `t`, nothing kept between
+ * frames; `at` hands over the frame alone, and placed, the scroll stamps
+ * the hold it is in at the frame's time (`placedRender`).
+ */
+import { Animation } from "../core/animation.js";
+import { Measurement } from "../core/measure.js";
+import { render, withBoundedWidth } from "../core/protocol.js";
+import { Segment } from "../core/segment.js";
+const NO_OFFSET = Animation.constant(0);
+/** `content` seen through a slot of `width` by `height` cells, moved in it by `col` and `row` at each moment. */
+export function scroll(content, options) {
+    const { width, height, col = NO_OFFSET, row = NO_OFFSET } = options;
+    for (const [name, n] of [["width", width], ["height", height]]) {
+        if (!(Number.isInteger(n) && n > 0))
+            throw new RangeError(`scroll: ${name} must be a positive whole number of cells, got ${n}`);
+    }
+    return Animation.map(Animation.all([col, row]), ([c, r]) => new ScrollFrame(content, width, height, cells("col", c), cells("row", r)));
+}
+/** `offset` rounded to the nearest cell. [LAW:no-silent-failure] One that is not finite has no cell to move to, and says so rather than drawing a blank slot. */
+function cells(name, offset) {
+    if (!Number.isFinite(offset))
+        throw new RangeError(`scroll: ${name} must be a finite number of cells, got ${offset}`);
+    return Math.round(offset);
+}
+/**
+ * The width `content` is drawn at: its own natural one. [LAW:no-silent-failure]
+ * Content that takes whatever width it is offered — a `Rule`, a renderable
+ * with no `measure` — has none, and is refused by name rather than drawn at
+ * an unbounded width it cannot fill.
+ */
+function naturalWidth(content, options) {
+    const natural = Measurement.get({ ...options, maxWidth: Number.POSITIVE_INFINITY }, content).maximum;
+    if (!Number.isFinite(natural)) {
+        throw new RangeError("scroll: the content has no natural width — it fills whatever width it is given; give it one with new Constrain(content, width)");
+    }
+    return natural;
+}
+/** One frame of a scroll: `content`'s cells from column `col` and row `row`, `width` by `height` of them, blank where it has none. */
+class ScrollFrame {
+    content;
+    width;
+    height;
+    col;
+    row;
+    constructor(content, width, height, col, row) {
+        this.content = content;
+        this.width = width;
+        this.height = height;
+        this.col = col;
+        this.row = row;
+    }
+    *render(rawOptions) {
+        const options = withBoundedWidth(rawOptions, this);
+        // The slot is cropped to the room it is given, as a `Panel` of a declared width is.
+        const width = Math.min(this.width, options.maxWidth);
+        const drawn = [...render(this.content, { ...options, maxWidth: naturalWidth(this.content, options), height: undefined })];
+        const lines = Segment.splitLines(drawn);
+        const blank = Math.min(width, Math.max(0, -this.col));
+        const start = Math.max(0, this.col);
+        // [LAW:one-source-of-truth] What the window shows is cut from the whole content, so it may change
+        // when anything in the content does — a row above the slot entering pushes every row down, and run
+        // backwards, leaving it pulls them up. The cut throws away the cells that hold rode on, so it is
+        // told to the frame (`RenderOptions.onHold`).
+        options.onHold?.({ lastChange: Segment.lastChange(drawn), nextChange: Segment.nextChange(drawn) });
+        for (let r = 0; r < this.height; r++) {
+            const line = lines[this.row + r] ?? [];
+            const shown = Segment.divide(line, [start, start + width - blank])[1] ?? [];
+            yield* Segment.adjustLineLength([new Segment(" ".repeat(blank)), ...shown], width);
+            yield Segment.line();
+        }
+    }
+    measure() {
+        return { minimum: this.width, maximum: this.width };
+    }
+}

package/dist/renderables/spinner.d.ts

@@ -8,7 +8,7 @@
  * the interval; the beat, the width every frame draws at and which frame `t`
  * lands on are the frames primitive's, so a spinner is one more sequence on
  * it and not a second way of turning frames. Custom frames are a `FrameSequence`
- * drawn through `Frames` directly. [LAW:one-source-of-truth]
+ * placed directly. [LAW:one-source-of-truth]
  *
  * It is built once and asked for each frame, as Rich's `Spinner` is built
  * once and has `render(time)` called on it: the name is parsed and the
@@ -19,13 +19,12 @@
  * the beat, the width, each frame padded to it — is made there too, so a
  * drawn frame costs only finding which one `t` lands on.
  *
- * [LAW:no-ambient-temporal-coupling] A Spinner draws nothing on its own:
- * only `at(t)` is a renderable, so a spinner cannot be drawn without being
- * handed its time, and nothing here reads a clock. Whoever draws frames
- * hands each one its time (`core/clock.ts`) — `SpinnerColumn` the task's
- * `time`, a `Live` the frame's time on its clock — as Rich's `Spinner.render`
- * is handed `console.get_time()` or `task.get_time()`. `t` is the clock's
- * time, as `App` and `Task.time` hand it, where Rich's spinner counts from
+ * [LAW:no-ambient-temporal-coupling] Placed, a spinner draws at the time of
+ * the frame it is drawn in, and nothing here reads a clock. Whoever draws
+ * frames hands each one its time (`core/clock.ts`) — a `Progress` the
+ * moment its tasks are drawn at, a `Live` the frame's time on its clock — as
+ * Rich's `Spinner.render` is handed `console.get_time()` or `task.get_time()`. `t` is the clock's
+ * time, as a host writes it on the frame, where Rich's spinner counts from
  * its first draw: here nothing is kept between frames, so the same `t` draws
  * the same bytes at one redraw a second or sixty, two spinners on one clock
  * agree at every `t`, a `Progress` on a hand-moved clock turns its spinners
@@ -35,10 +34,11 @@
  * that rate, as Rich scales the time, `t × speed` into the beat: the frames
  * are held for the interval the data gives, and the spinner is asked for the
  * frame at the time the timeline maps the host's to. [LAW:one-source-of-truth]
- * When the frame next changes (`Style.nextChange`) is a time on the host's
+ * When the frame next changes (`Style.hold`) is a time on the host's
  * timeline, and the sequence answers on its own, so the timeline carries the
- * answer back and the drawn cells are stamped with that (`frameAt`), where
- * the host's time is known. Backwards, the frames count down from the last at `t = 0`,
+ * answer back. `at` hands over the frame alone, as every animation's does;
+ * placed, a spinner draws at the frame's time and stamps its cells with that
+ * answer for the frames the output draws. Backwards, the frames count down from the last at `t = 0`,
  * a negative time landing in the last frame of the pass before, where Rich's
  * `int()` truncation holds frame 0 for a first interval and then counts
  * down: a departure, made so a negative speed is the one timeline run
@@ -46,10 +46,11 @@
  * frame forever, which a paused timeline is and a rate is not, and the
  * timeline refuses it.
  */
-import type { Animation } from "../core/animation.js";
+import { Animation } from "../core/animation.js";
+import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { RichText } from "../core/text.js";
-import type { Renderable, Measurable } from "../core/protocol.js";
+import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
 export interface SpinnerOptions {
     /** Multiplies the spinner's rate; negative runs it backwards; zero is refused. Defaults to 1. */
     speed?: number;
@@ -66,10 +67,19 @@ export declare class Spinner implements Animation<Renderable & Measurable> {
      * whatever the console says — and a `RichText` changed in place draws as
      * changed, as the `Text` Rich keeps does. [LAW:single-enforcer]
      */
-    text: string | RichText;
+    get text(): string | RichText;
+    set text(value: string | RichText);
+    private readonly _text;
     private readonly _data;
     private readonly _named;
     private readonly _ascii;
+    /**
+     * The spinner drawn at the frame's time, its cells saying the hold it is in
+     * on the host's clock (`stampFrame`) — exactly, for the frames the output
+     * draws, where `nextChange` must answer for both. Under reduced motion it
+     * is the spinner reduced, which never turns (`shownAt`).
+     */
+    private readonly _placed;
     constructor(name?: string, text?: string | RichText, options?: SpinnerOptions);
     get frames(): readonly string[];
     /** Milliseconds each frame is held, as the spinner data gives it. */
@@ -79,8 +89,19 @@ export declare class Spinner implements Animation<Renderable & Measurable> {
      * the line wrapped to the width and ended, as the reference's `Text` is —
      * printed, stacked in a `Group`, or laid out in a `Progress` cell alike.
      * The frames this output can draw are chosen where the output is known.
+     * The frame says nothing of when it turns — `t` may be a time a timeline
+     * mapped — so placed, the spinner itself stamps it.
      */
     at(t: number): Renderable & Measurable;
+    /** The spinner with its motion taken out: its first frame and the label, which never turn, so any time answers. */
+    reduced(): Animation<Renderable & Measurable>;
+    render(options: RenderOptions): Iterable<Segment>;
+    measure(options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+    /** The frame `choose` picks from the frames the output can draw, and the label, saying the hold it is in if `choose` says. */
+    private _frame;
     /**
      * When the spinner drawn at `t` next turns, on the host's clock: the
      * sooner of its two sequences' answers, since which one is drawn is the

package/dist/renderables/spinner.js

@@ -8,7 +8,7 @@
  * the interval; the beat, the width every frame draws at and which frame `t`
  * lands on are the frames primitive's, so a spinner is one more sequence on
  * it and not a second way of turning frames. Custom frames are a `FrameSequence`
- * drawn through `Frames` directly. [LAW:one-source-of-truth]
+ * placed directly. [LAW:one-source-of-truth]
  *
  * It is built once and asked for each frame, as Rich's `Spinner` is built
  * once and has `render(time)` called on it: the name is parsed and the
@@ -19,13 +19,12 @@
  * the beat, the width, each frame padded to it — is made there too, so a
  * drawn frame costs only finding which one `t` lands on.
  *
- * [LAW:no-ambient-temporal-coupling] A Spinner draws nothing on its own:
- * only `at(t)` is a renderable, so a spinner cannot be drawn without being
- * handed its time, and nothing here reads a clock. Whoever draws frames
- * hands each one its time (`core/clock.ts`) — `SpinnerColumn` the task's
- * `time`, a `Live` the frame's time on its clock — as Rich's `Spinner.render`
- * is handed `console.get_time()` or `task.get_time()`. `t` is the clock's
- * time, as `App` and `Task.time` hand it, where Rich's spinner counts from
+ * [LAW:no-ambient-temporal-coupling] Placed, a spinner draws at the time of
+ * the frame it is drawn in, and nothing here reads a clock. Whoever draws
+ * frames hands each one its time (`core/clock.ts`) — a `Progress` the
+ * moment its tasks are drawn at, a `Live` the frame's time on its clock — as
+ * Rich's `Spinner.render` is handed `console.get_time()` or `task.get_time()`. `t` is the clock's
+ * time, as a host writes it on the frame, where Rich's spinner counts from
  * its first draw: here nothing is kept between frames, so the same `t` draws
  * the same bytes at one redraw a second or sixty, two spinners on one clock
  * agree at every `t`, a `Progress` on a hand-moved clock turns its spinners
@@ -35,10 +34,11 @@
  * that rate, as Rich scales the time, `t × speed` into the beat: the frames
  * are held for the interval the data gives, and the spinner is asked for the
  * frame at the time the timeline maps the host's to. [LAW:one-source-of-truth]
- * When the frame next changes (`Style.nextChange`) is a time on the host's
+ * When the frame next changes (`Style.hold`) is a time on the host's
  * timeline, and the sequence answers on its own, so the timeline carries the
- * answer back and the drawn cells are stamped with that (`frameAt`), where
- * the host's time is known. Backwards, the frames count down from the last at `t = 0`,
+ * answer back. `at` hands over the frame alone, as every animation's does;
+ * placed, a spinner draws at the frame's time and stamps its cells with that
+ * answer for the frames the output draws. Backwards, the frames count down from the last at `t = 0`,
  * a negative time landing in the last frame of the pass before, where Rich's
  * `int()` truncation holds frame 0 for a first interval and then counts
  * down: a departure, made so a negative speed is the one timeline run
@@ -46,14 +46,17 @@
  * frame forever, which a paused timeline is and a rate is not, and the
  * timeline refuses it.
  */
+import { Animation, frameTimeOf, holdOf, shownAt, stampFrame } from "../core/animation.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
 import { RichText } from "../core/text.js";
 import { SPINNERS, DEFAULT_SPINNER, LINE_SPINNER } from "../core/spinnerData.js";
 import { Timeline } from "../core/timeline.js";
-import { drawable, render } from "../core/protocol.js";
+import { drawable, measure, render } from "../core/protocol.js";
 import { EmbeddedText } from "./embed.js";
-import { FrameSequence, frameAt } from "./frames.js";
+import { FrameSequence } from "./frames.js";
+import { finiteTime } from "../core/easing.js";
+import { State } from "../core/state.js";
 const sequence = (data, style, timeline) => {
     const frames = new FrameSequence(data.frames.map((frame) => ({ text: new RichText("", { end: "" }).append(frame, style), seconds: data.interval / 1000 })));
     return { frames, played: Timeline.run(timeline, frames), glyphs: data.frames.join("") };
@@ -70,12 +73,26 @@ export class Spinner {
      * whatever the console says — and a `RichText` changed in place draws as
      * changed, as the `Text` Rich keeps does. [LAW:single-enforcer]
      */
-    text;
+    get text() {
+        return this._text.get();
+    }
+    set text(value) {
+        this._text.set(value);
+    }
+    // Rich's `Spinner.update` sets the text after it is built.
+    _text;
     _data;
     // The named data's frames, and the `line` spinner's that stand in for them
     // on an ASCII-only output: prepared once, which is drawn chosen at `at`.
     _named;
     _ascii;
+    /**
+     * The spinner drawn at the frame's time, its cells saying the hold it is in
+     * on the host's clock (`stampFrame`) — exactly, for the frames the output
+     * draws, where `nextChange` must answer for both. Under reduced motion it
+     * is the spinner reduced, which never turns (`shownAt`).
+     */
+    _placed;
     constructor(name, text = "", options) {
         const spinnerName = name ?? DEFAULT_SPINNER;
         const data = SPINNERS[spinnerName];
@@ -87,12 +104,17 @@ export class Spinner {
         // refuses one that is not where it is built.
         const timeline = Timeline.play(0, speed);
         this.name = spinnerName;
-        this.text = text;
+        this._text = new State(text);
         this.speed = speed;
         this.style = options?.style ?? NULL_STYLE;
         this._data = data;
         this._named = sequence(data, this.style, timeline);
         this._ascii = sequence(LINE_SPINNER, this.style, timeline);
+        this._placed = this._frame((played, options) => {
+            const t = frameTimeOf(options);
+            const shown = shownAt(played, t, options);
+            return { value: shown.value, hold: holdOf(shown, t) };
+        });
     }
     get frames() {
         return this._data.frames;
@@ -106,21 +128,39 @@ export class Spinner {
      * the line wrapped to the width and ended, as the reference's `Text` is —
      * printed, stacked in a `Group`, or laid out in a `Progress` cell alike.
      * The frames this output can draw are chosen where the output is known.
+     * The frame says nothing of when it turns — `t` may be a time a timeline
+     * mapped — so placed, the spinner itself stamps it.
      */
     at(t) {
-        if (!Number.isFinite(t)) {
-            throw new RangeError(`Spinner.at needs a finite t, got ${t}`);
-        }
+        finiteTime("Spinner.at", t);
+        return this._frame((played) => ({ value: played.at(t) }));
+    }
+    /** The spinner with its motion taken out: its first frame and the label, which never turn, so any time answers. */
+    reduced() {
+        return Animation.constant(this._frame((played) => ({ value: played.reduced().at(0) })));
+    }
+    render(options) {
+        return render(this._placed, options);
+    }
+    measure(options) {
+        return measure(this._placed, options);
+    }
+    /** The frame `choose` picks from the frames the output can draw, and the label, saying the hold it is in if `choose` says. */
+    _frame(choose) {
         const drawn = (options) => drawable(options, this._named, this._ascii, sequenceGlyphs);
         return {
-            render: (options) => this._render(drawn(options), t, options),
+            render: (options) => {
+                const { value, hold } = choose(drawn(options).played, options);
+                const segments = this._render(value, options);
+                return hold === undefined ? segments : stampFrame(segments, hold);
+            },
             // Measured at the frames' one width, the widest frame's, so a column
             // holding it never narrows as it turns, and never offered less than
             // that frame: a frame is one picture, which the reference's `Text`
             // measure would let wrap apart at its spaces.
             measure: (options) => {
                 const { frames, played } = drawn(options);
-                const { minimum, maximum } = this._line(played, t, options).measure(options);
+                const { minimum, maximum } = measure(this._line(choose(played, options).value, options), options);
                 return { minimum: Math.max(minimum, Math.min(frames.width, maximum)), maximum };
             },
         };
@@ -139,8 +179,8 @@ export class Spinner {
     lastChange(t) {
         return Math.max(this._named.played.lastChange(t), this._ascii.played.lastChange(t));
     }
-    *_render({ played }, t, options) {
-        yield* render(this._line(played, t, options), options);
+    *_render(frame, options) {
+        yield* render(this._line(frame, options), options);
         yield Segment.line();
     }
     /**
@@ -150,9 +190,9 @@ export class Spinner {
      * styles nothing — is no label, not a trailing space, as an empty `Text` is
      * falsy there.
      */
-    _line(played, t, options) {
-        // The frame's cells say when it turns on the host's clock, the label's keep their own word.
-        const line = new RichText("", { end: "" }).append(frameAt(played, t));
+    _line(frame, options) {
+        // The frame alone, saying nothing of when it turns: placed, the spinner stamps it.
+        const line = new RichText("", { end: "" }).append(frame);
         // Unhighlighted: Rich's label is a `Text` from the moment it is handed over, and a `Text` is never highlighted.
         const label = new EmbeddedText(this.text).text({ ...options, highlight: false });
         if (label.plain !== "")

package/dist/renderables/status.js

@@ -20,7 +20,7 @@ export class Status {
             speed: options?.speed,
             style: options?.spinnerStyle ?? "status.spinner",
         });
-        this._live = new Live((t) => this._spinner.at(t), {
+        this._live = new Live(this._spinner, {
             console: this._console,
             clock: options?.clock,
             transient: true,

package/dist/renderables/syntax.d.ts

@@ -9,11 +9,12 @@
  */
 import { Segment } from "../core/segment.js";
 import { type Measurable, type Renderable, type RenderOptions } from "../core/protocol.js";
+import { type Pattern } from "../core/pattern.js";
 export interface SyntaxOptions {
     lineNumbers?: boolean;
     startLine?: number;
-    lineRange?: [number, number];
-    highlightLines?: Set<number>;
+    lineRange?: readonly [number, number];
+    highlightLines?: ReadonlySet<number>;
     wordWrap?: boolean;
     tabSize?: number;
 }
@@ -24,11 +25,11 @@ export interface SyntaxOptions {
  * render; `"text"` is the grammar with no rules.
  */
 declare const GRAMMARS: {
-    javascript: RegExp;
-    typescript: RegExp;
-    python: RegExp;
-    bash: RegExp;
-    text: RegExp;
+    readonly javascript: Pattern;
+    readonly typescript: Pattern;
+    readonly python: Pattern;
+    readonly bash: Pattern;
+    readonly text: Pattern;
 };
 export type SyntaxLanguage = keyof typeof GRAMMARS;
 export declare class Syntax implements Renderable, Measurable {
@@ -36,8 +37,8 @@ export declare class Syntax implements Renderable, Measurable {
     readonly language: SyntaxLanguage;
     readonly lineNumbers: boolean;
     readonly startLine: number;
-    readonly lineRange: [number, number] | undefined;
-    readonly highlightLines: Set<number>;
+    readonly lineRange: readonly [number, number] | undefined;
+    readonly highlightLines: ReadonlySet<number>;
     readonly wordWrap: boolean;
     readonly tabSize: number;
     /** The code with its tabs expanded, as lines — what both render and measure read. */

package/dist/renderables/syntax.js

@@ -12,6 +12,7 @@ import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
 import { drawable, groundedStyle, getStyle, withBoundedWidth, withCellWidth, } from "../core/protocol.js";
 import { render } from "../core/protocol.js";
+import { pattern } from "../core/pattern.js";
 /**
  * One regex per grammar, each token a named alternative. A single left-to-right
  * scan is what keeps a `//` inside a string from starting a comment, and a
@@ -20,7 +21,7 @@ import { render } from "../core/protocol.js";
  * `(?!)` never matches, so a grammar with no rules is still a regex.
  */
 function grammar(rules) {
-    return new RegExp([...rules.map(([token, source]) => `(?<${token}>${source})`), "(?!)"].join("|"), "g");
+    return pattern(new RegExp([...rules.map(([token, source]) => `(?<${token}>${source})`), "(?!)"].join("|")));
 }
 // Not after a `.`: `map.get` and `node.type` are properties, not keywords.
 const words = (list) => `(?<!\\.)\\b(?:${list.split(" ").join("|")})\\b`;
@@ -120,7 +121,7 @@ export class Syntax {
         // Tokenized whole and then sliced, so a block comment or a triple-quoted
         // string that spans lines is one token even when the range starts inside it.
         const text = new RichText(this._lines.join("\n"), { end: "" });
-        for (const match of text.plain.matchAll(GRAMMARS[this.language])) {
+        for (const match of text.plain.matchAll(new RegExp(GRAMMARS[this.language].source, "g"))) {
             const [token] = Object.entries(match.groups).find(([, value]) => value !== undefined);
             text.stylize(`syntax.${token}`, match.index, match.index + match[0].length);
         }

package/dist/renderables/table.d.ts

@@ -6,43 +6,42 @@ import { Style } from "../core/style.js";
 import { Box } from "../core/box.js";
 import { RichText } from "../core/text.js";
 import type { PaddingDimensions } from "./padding.js";
-import type { Composite, Renderable, Measurable, OverflowMethod, RenderOptions } from "../core/protocol.js";
+import type { Renderable, Measurable, OverflowMethod, RenderOptions } from "../core/protocol.js";
 export interface ColumnOptions {
     /** Anything a cell can hold, as Rich's `RenderableType` header is. */
-    header?: string | RichText | Renderable;
-    footer?: string | RichText | Renderable;
-    headerStyle?: string | Style;
-    footerStyle?: string | Style;
-    style?: string | Style;
-    justify?: "left" | "center" | "right" | "full";
-    width?: number;
-    minWidth?: number;
-    maxWidth?: number;
-    ratio?: number;
-    noWrap?: boolean;
-    overflow?: OverflowMethod;
+    readonly header?: string | RichText | Renderable;
+    readonly footer?: string | RichText | Renderable;
+    readonly headerStyle?: string | Style;
+    readonly footerStyle?: string | Style;
+    readonly style?: string | Style;
+    readonly justify?: "left" | "center" | "right" | "full";
+    readonly width?: number;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+    readonly ratio?: number;
+    readonly noWrap?: boolean;
+    readonly overflow?: OverflowMethod;
     /**
      * Whether the column's string cells — its header and footer among them — are
      * drawn with the console's highlighter, as Rich's `Column(highlight=)`.
      * `false` for a `Column` built alone; `addColumn` takes the table's.
      */
-    highlight?: boolean;
+    readonly highlight?: boolean;
 }
 export declare class Column {
-    private _header;
-    private _footer;
-    headerStyle: string | Style;
-    footerStyle: string | Style;
-    style: string | Style;
-    justify: "left" | "center" | "right" | "full";
-    width: number | undefined;
-    minWidth: number | undefined;
-    maxWidth: number | undefined;
-    ratio: number | undefined;
-    noWrap: boolean;
-    overflow: OverflowMethod;
-    highlight: boolean;
-    private _cells;
+    private readonly _header;
+    private readonly _footer;
+    readonly headerStyle: string | Style;
+    readonly footerStyle: string | Style;
+    readonly style: string | Style;
+    readonly justify: "left" | "center" | "right" | "full";
+    readonly width: number | undefined;
+    readonly minWidth: number | undefined;
+    readonly maxWidth: number | undefined;
+    readonly ratio: number | undefined;
+    readonly noWrap: boolean;
+    readonly overflow: OverflowMethod;
+    readonly highlight: boolean;
     constructor(options?: ColumnOptions);
     /**
      * The two stamped cells, stamped on assignment rather than at the constructor.
@@ -66,10 +65,6 @@ export declare class Column {
     get footer(): Renderable & Partial<Measurable>;
     set footer(content: ColumnOptions["footer"]);
     get flexible(): boolean;
-    /** @internal */
-    addCell(cell: Renderable): void;
-    /** @internal */
-    getCells(): Renderable[];
     copy(): Column;
 }
 export interface TableOptions {
@@ -94,13 +89,13 @@ export interface TableOptions {
     captionJustify?: "left" | "center" | "right" | "full";
     width?: number;
     minWidth?: number;
-    rowStyles?: string[];
+    rowStyles?: readonly string[];
     /** The `highlight` every column `addColumn` makes takes unless told otherwise (default: `false`). */
     highlight?: boolean;
 }
-export declare class Table implements Renderable, Measurable, Composite {
-    private _columns;
-    private _rows;
+export declare class Table implements Renderable, Measurable {
+    private readonly _columns;
+    private readonly _rows;
     readonly box: Box | null;
     private readonly _title;
     private readonly _caption;
@@ -109,7 +104,7 @@ export declare class Table implements Renderable, Measurable, Composite {
     readonly showFooter: boolean;
     readonly showLines: boolean;
     readonly showEdge: boolean;
-    readonly padding: [number, number, number, number];
+    readonly padding: readonly [number, number, number, number];
     readonly collapsePadding: boolean;
     readonly padEdge: boolean;
     readonly style: string | Style;
@@ -122,12 +117,12 @@ export declare class Table implements Renderable, Measurable, Composite {
     readonly captionJustify: "left" | "center" | "right" | "full";
     readonly tableWidth: number | undefined;
     readonly minWidth: number | undefined;
-    readonly rowStyles: string[];
+    readonly rowStyles: readonly string[];
     readonly highlight: boolean;
     get title(): (Renderable & Measurable) | undefined;
     get caption(): (Renderable & Measurable) | undefined;
     constructor(options?: TableOptions);
-    get columns(): Column[];
+    get columns(): readonly Column[];
     get rowCount(): number;
     addColumn(header?: ColumnOptions["header"], options?: ColumnOptions): this;
     addRow(...cells: unknown[]): this;
@@ -201,7 +196,6 @@ export declare class Table implements Renderable, Measurable, Composite {
      */
     private _columnPadding;
     private _rowPadding;
-    contents(): Iterable<Renderable>;
     private _rowCells;
     /**
      * Every cell column `index` draws, in draw order.