@promptctl/rich-js 0.23.0 → 0.24.1

package/dist/renderables/python-space.js

@@ -0,0 +1,24 @@
+/**
+ * Whitespace as Python reads it — `str.isspace`, `str.strip`, and `\s` in a
+ * `str` pattern of `re`, which are one set. markdown-it-py, the markdown-it
+ * Rich runs, reads whitespace through all three, and that set is not
+ * JavaScript's: `\s` and `trim` take U+FEFF, which Python does not, and leave
+ * U+001C–U+001F and U+0085, which Python takes.
+ */
+/** The set as a regex character class, every member of it a single UTF-16 unit, for composing into a pattern where markdown-it-py's has `\s`. */
+export const PY_WHITESPACE = String.raw `[\t-\r\x1c-\x20\x85\xa0  - 

  　]`;
+const PY_SPACE = new RegExp(`^${PY_WHITESPACE}$`);
+/** Python's `str.strip`, a scan in from each end, so a run of interior whitespace costs one pass, as it does there. */
+export function pyStrip(text) {
+    let start = 0;
+    while (start < text.length && PY_SPACE.test(text[start]))
+        start++;
+    return pyRstrip(text.slice(start));
+}
+/** Python's `str.rstrip`, a scan in from the end — not a `+$` pattern, which retries from every cell of an interior run. */
+export function pyRstrip(text) {
+    let end = text.length;
+    while (end > 0 && PY_SPACE.test(text[end - 1]))
+        end--;
+    return text.slice(0, end);
+}

package/dist/renderables/spinner.d.ts

@@ -1,15 +1,61 @@
 /**
- * Spinner — animated terminal spinner with optional text label.
+ * Spinner — a named spinner, asked for its frame at a time, with an optional
+ * label after it.
+ *
+ * A spinner is a `FrameSequence` (`./frames.ts`) over one entry of the named spinner
+ * data (`core/spinnerData.ts`): each frame held for the spinner's interval,
+ * looping, the frame in progress at `t` drawn. The data names the frames and
+ * 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]
+ *
+ * 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
+ * styled frames are prepared where the spinner is given, and `at(t)` is what
+ * draws, so a `Status` or `SpinnerColumn` holding one pays for the name and
+ * the styling once, and a bad name fails at the call that gave it.
+ * [LAW:parse-dont-validate] What a `FrameSequence` makes of the frames —
+ * 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
+ * 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
+ * on that clock, and a draw costs the same at `t = 0` and `t = 10⁶`.
+ *
+ * `speed` is a `Timeline` (`core/timeline.ts`) playing from `t = 0` at
+ * 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
+ * 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`,
+ * 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
+ * backwards and not a second rule about time. A speed of zero would hold a
+ * frame forever, which a paused timeline is and a rate is not, and the
+ * timeline refuses it.
  */
-import { Segment } from "../core/segment.js";
+import type { Animation } from "../core/animation.js";
 import { Style } from "../core/style.js";
 import { RichText } from "../core/text.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+import type { Renderable, Measurable } from "../core/protocol.js";
 export interface SpinnerOptions {
+    /** Multiplies the spinner's rate; negative runs it backwards; zero is refused. Defaults to 1. */
     speed?: number;
     style?: string | Style;
 }
-export declare class Spinner implements Renderable, Measurable {
+export declare class Spinner implements Animation<Renderable & Measurable> {
     readonly name: string;
     readonly speed: number;
     readonly style: string | Style;
@@ -22,36 +68,36 @@ export declare class Spinner implements Renderable, Measurable {
      */
     text: string | RichText;
     private readonly _data;
-    private _frameIndex;
-    private _lastUpdate;
+    private readonly _named;
+    private readonly _ascii;
     constructor(name?: string, text?: string | RichText, options?: SpinnerOptions);
     get frames(): readonly string[];
+    /** Milliseconds each frame is held, as the spinner data gives it. */
     get interval(): number;
-    /** Advance the frame count by the time elapsed, and return it. */
-    private _advance;
-    /** The frames this output can draw: the `line` spinner stands in for any other on an ASCII-only one. */
-    private _drawnFrames;
     /**
-     * The current frame and its label as one 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 frame in progress at `t` seconds and the label, as one renderable:
+     * 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.
      */
-    render(options: RenderOptions): Iterable<Segment>;
-    private _currentLine;
+    at(t: number): Renderable & Measurable;
     /**
-     * `frame` and the label as one text, as Rich's `Text.assemble(frame, " ",
-     * text)`: a long label wraps as one line with its frame. A label that draws
-     * nothing — the default `""`, or markup that styles nothing — is no label,
-     * not a trailing space, as an empty `Text` is falsy there.
+     * 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
+     * output's to choose and the line spinner that stands in on an ASCII-only
+     * output keeps its own interval. An early answer, on the output that draws
+     * the other one, which the contract allows; the drawn cells carry the exact one.
      */
-    private _line;
+    nextChange(t: number): number;
+    /** When the spinner drawn at `t` began to be drawn: the later of its two sequences' answers, by the same argument. */
+    lastChange(t: number): number;
+    private _render;
     /**
-     * Measured at its widest frame, 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.
+     * The frame in progress and the label as one text, as Rich's
+     * `Text.assemble(frame, " ", text)`: a long label wraps as one line with its
+     * frame. A label that draws nothing — the default `""`, or markup that
+     * styles nothing — is no label, not a trailing space, as an empty `Text` is
+     * falsy there.
      */
-    measure(options: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
+    private _line;
 }

package/dist/renderables/spinner.js

@@ -1,14 +1,64 @@
 /**
- * Spinner — animated terminal spinner with optional text label.
+ * Spinner — a named spinner, asked for its frame at a time, with an optional
+ * label after it.
+ *
+ * A spinner is a `FrameSequence` (`./frames.ts`) over one entry of the named spinner
+ * data (`core/spinnerData.ts`): each frame held for the spinner's interval,
+ * looping, the frame in progress at `t` drawn. The data names the frames and
+ * 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]
+ *
+ * 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
+ * styled frames are prepared where the spinner is given, and `at(t)` is what
+ * draws, so a `Status` or `SpinnerColumn` holding one pays for the name and
+ * the styling once, and a bad name fails at the call that gave it.
+ * [LAW:parse-dont-validate] What a `FrameSequence` makes of the frames —
+ * 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
+ * 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
+ * on that clock, and a draw costs the same at `t = 0` and `t = 10⁶`.
+ *
+ * `speed` is a `Timeline` (`core/timeline.ts`) playing from `t = 0` at
+ * 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
+ * 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`,
+ * 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
+ * backwards and not a second rule about time. A speed of zero would hold a
+ * frame forever, which a paused timeline is and a rate is not, and the
+ * timeline refuses it.
  */
-import { cellLen } from "../core/cells.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 { drawable } from "../core/protocol.js";
+import { Timeline } from "../core/timeline.js";
+import { drawable, render } from "../core/protocol.js";
 import { EmbeddedText } from "./embed.js";
-const spinnerGlyphs = ({ frames }) => frames.join("");
+import { FrameSequence, frameAt } from "./frames.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("") };
+};
+const sequenceGlyphs = ({ glyphs }) => glyphs;
 export class Spinner {
     name;
     speed;
@@ -22,82 +72,91 @@ export class Spinner {
      */
     text;
     _data;
-    _frameIndex;
-    _lastUpdate;
+    // 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;
     constructor(name, text = "", options) {
         const spinnerName = name ?? DEFAULT_SPINNER;
         const data = SPINNERS[spinnerName];
         if (!data) {
             throw new Error(`Unknown spinner: "${spinnerName}"`);
         }
+        const speed = options?.speed ?? 1;
+        // [LAW:single-enforcer] A rate is finite and not zero, and the timeline
+        // refuses one that is not where it is built.
+        const timeline = Timeline.play(0, speed);
         this.name = spinnerName;
         this.text = text;
-        this.speed = options?.speed ?? 1;
+        this.speed = speed;
         this.style = options?.style ?? NULL_STYLE;
         this._data = data;
-        this._frameIndex = 0;
-        this._lastUpdate = Date.now();
+        this._named = sequence(data, this.style, timeline);
+        this._ascii = sequence(LINE_SPINNER, this.style, timeline);
     }
     get frames() {
         return this._data.frames;
     }
+    /** Milliseconds each frame is held, as the spinner data gives it. */
     get interval() {
         return this._data.interval;
     }
-    /** Advance the frame count by the time elapsed, and return it. */
-    _advance() {
-        const now = Date.now();
-        // Whole frames passed at this speed; a negative speed steps backwards, as
-        // Rich's does, so the index wraps with a modulo that is never negative.
-        const steps = Math.trunc(((now - this._lastUpdate) * this.speed) / this.interval);
-        if (steps !== 0) {
-            const count = this._data.frames.length;
-            this._frameIndex = (((this._frameIndex + steps) % count) + count) % count;
-            this._lastUpdate = now;
+    /**
+     * The frame in progress at `t` seconds and the label, as one renderable:
+     * 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.
+     */
+    at(t) {
+        if (!Number.isFinite(t)) {
+            throw new RangeError(`Spinner.at needs a finite t, got ${t}`);
         }
-        return this._frameIndex;
-    }
-    /** The frames this output can draw: the `line` spinner stands in for any other on an ASCII-only one. */
-    _drawnFrames(options) {
-        return drawable(options, this._data, LINE_SPINNER, spinnerGlyphs).frames;
+        const drawn = (options) => drawable(options, this._named, this._ascii, sequenceGlyphs);
+        return {
+            render: (options) => this._render(drawn(options), t, options),
+            // 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);
+                return { minimum: Math.max(minimum, Math.min(frames.width, maximum)), maximum };
+            },
+        };
     }
     /**
-     * The current frame and its label as one 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.
+     * 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
+     * output's to choose and the line spinner that stands in on an ASCII-only
+     * output keeps its own interval. An early answer, on the output that draws
+     * the other one, which the contract allows; the drawn cells carry the exact one.
      */
-    *render(options) {
-        yield* this._currentLine(options).render(options);
-        yield Segment.line();
+    nextChange(t) {
+        return Math.min(this._named.played.nextChange(t), this._ascii.played.nextChange(t));
     }
-    _currentLine(options) {
-        const frames = this._drawnFrames(options);
-        return this._line(frames[this._advance() % frames.length], options);
+    /** When the spinner drawn at `t` began to be drawn: the later of its two sequences' answers, by the same argument. */
+    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);
+        yield Segment.line();
     }
     /**
-     * `frame` and the label as one text, as Rich's `Text.assemble(frame, " ",
-     * text)`: a long label wraps as one line with its frame. A label that draws
-     * nothing — the default `""`, or markup that styles nothing — is no label,
-     * not a trailing space, as an empty `Text` is falsy there.
+     * The frame in progress and the label as one text, as Rich's
+     * `Text.assemble(frame, " ", text)`: a long label wraps as one line with its
+     * frame. A label that draws nothing — the default `""`, or markup that
+     * styles nothing — is no label, not a trailing space, as an empty `Text` is
+     * falsy there.
      */
-    _line(frame, options) {
-        const line = new RichText("", { end: "" }).append(frame, this.style);
+    _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));
         // 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 !== "")
             line.append(" ").append(label);
         return line;
     }
-    /**
-     * Measured at its widest frame, 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 = this._drawnFrames(options);
-        const widths = frames.map((frame) => cellLen(frame));
-        const frameWidth = Math.max(...widths);
-        const { minimum, maximum } = this._line(frames[widths.indexOf(frameWidth)], options).measure(options);
-        return { minimum: Math.max(minimum, Math.min(frameWidth, maximum)), maximum };
-    }
 }

package/dist/renderables/status.d.ts

@@ -1,10 +1,13 @@
 /**
  * Status — displays a spinner animation with a status message.
  *
- * Its renderable is a `Spinner` whose label is the message, as Rich's is, so
- * the message is drawn the way the spinner draws its label: a string is markup
- * under the console that draws it.
+ * Its view is a `Spinner` whose label is the message, as Rich's is, so the
+ * message is drawn the way the spinner draws its label: a string is markup
+ * under the console that draws it. The `Live` hands each frame its time, and
+ * the spinner is asked for its frame at it, so the frame is the clock's, not
+ * the platform's. [LAW:no-ambient-temporal-coupling]
  */
+import type { Clock } from "../core/clock.js";
 import type { Style } from "../core/style.js";
 import type { RichText } from "../core/text.js";
 import { Console } from "../core/console.js";
@@ -14,6 +17,8 @@ export interface StatusOptions {
     /** The spinner's frame style; the message styles itself with its markup. */
     spinnerStyle?: string | Style;
     console?: Console;
+    /** What the frames are timed and drawn on. The platform's, unless given. */
+    clock?: Clock;
 }
 export declare class Status {
     private _live;

package/dist/renderables/status.js

@@ -1,9 +1,11 @@
 /**
  * Status — displays a spinner animation with a status message.
  *
- * Its renderable is a `Spinner` whose label is the message, as Rich's is, so
- * the message is drawn the way the spinner draws its label: a string is markup
- * under the console that draws it.
+ * Its view is a `Spinner` whose label is the message, as Rich's is, so the
+ * message is drawn the way the spinner draws its label: a string is markup
+ * under the console that draws it. The `Live` hands each frame its time, and
+ * the spinner is asked for its frame at it, so the frame is the clock's, not
+ * the platform's. [LAW:no-ambient-temporal-coupling]
  */
 import { Console } from "../core/console.js";
 import { Spinner } from "./spinner.js";
@@ -18,8 +20,9 @@ export class Status {
             speed: options?.speed,
             style: options?.spinnerStyle ?? "status.spinner",
         });
-        this._live = new Live(this._spinner, {
+        this._live = new Live((t) => this._spinner.at(t), {
             console: this._console,
+            clock: options?.clock,
             transient: true,
             refreshPerSecond: 12.5,
         });
@@ -41,6 +44,6 @@ export class Status {
     }
     update(message) {
         this._spinner.text = message;
-        this._live.update(this._spinner, { refresh: true });
+        this._live.refresh();
     }
 }

package/dist/renderables/syntax.js

@@ -11,6 +11,7 @@ import { cellLen, expandTabs, parseTabSize } from "../core/cells.js";
 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";
 /**
  * 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
@@ -140,7 +141,7 @@ export class Syntax {
             const lineNo = first + i;
             const style = this.highlightLines.has(lineNo) ? highlightStyle : numberStyle;
             // Terminated, so an empty line is one empty row rather than none.
-            const rows = Segment.splitLines([...textLines[i].render(lineOptions), Segment.line()]);
+            const rows = Segment.splitLines([...render(textLines[i], lineOptions), Segment.line()]);
             for (let row = 0; row < rows.length; row++) {
                 if (this.lineNumbers) {
                     // A wrapped line's continuation rows keep the gutter, unnumbered.

package/dist/renderables/table.d.ts

@@ -6,7 +6,7 @@ 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 { Renderable, Measurable, OverflowMethod, RenderOptions } from "../core/protocol.js";
+import type { Composite, 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;
@@ -98,7 +98,7 @@ export interface TableOptions {
     /** The `highlight` every column `addColumn` makes takes unless told otherwise (default: `false`). */
     highlight?: boolean;
 }
-export declare class Table implements Renderable, Measurable {
+export declare class Table implements Renderable, Measurable, Composite {
     private _columns;
     private _rows;
     readonly box: Box | null;
@@ -183,8 +183,11 @@ export declare class Table implements Renderable, Measurable {
      * mode gets its own path through the width division.
      *
      * Cells are measured against the width left once the frame is paid, as the
-     * reference's `_measure_column` measures them. Padding and the floor are laid
-     * over whichever sizing the column has: they are the same for all three.
+     * reference's `_measure_column` measures them. Padding is part of every
+     * width the demand names, because the reference measures a cell wrapped in
+     * its `Padding`, and each sizing adds it where the reference does — a
+     * rowless column's minimum is the one width it never reaches. The floor is
+     * laid over whichever sizing the column has.
      */
     private _columnDemands;
     private _columnSizing;
@@ -198,6 +201,8 @@ export declare class Table implements Renderable, Measurable {
      */
     private _columnPadding;
     private _rowPadding;
+    contents(): Iterable<Renderable>;
+    private _rowCells;
     /**
      * Every cell column `index` draws, in draw order.
      *
@@ -211,19 +216,22 @@ export declare class Table implements Renderable, Measurable {
      */
     private _columnCells;
     /**
-     * The widest any cell in a column draws, and the narrowest the column can be
-     * without cutting one — the reference's `_measure_column` — or `undefined`
-     * when the column has no cell to measure. Zero is a column whose cells draw
-     * nothing — a gutter asks for its padding and nothing else — and is not the
-     * same answer. [LAW:types-are-the-program]
+     * The widest any cell in a column draws, its padding included, and the
+     * narrowest the column can be without cutting one — the reference's
+     * `_measure_column` — or `undefined` when the column has no cell to measure.
+     * A column whose cells draw nothing measures its padding — a gutter asks for
+     * that and nothing else — which is not the same answer.
+     * [LAW:types-are-the-program]
      */
     private _cellRange;
     /**
-     * A natural width held to the column's own `minWidth`/`maxWidth`.
+     * A natural width held to the column's own `minWidth`/`maxWidth`, each
+     * widened by the column's `pad`, as the reference clamps a padded
+     * measurement to `min_width + padding_width`.
      *
      * A bound is a count of cells, read by the rule every width is read by: NaN
      * and a negative are zero cells, so a NaN floor bounds nothing and a NaN
-     * ceiling is a ceiling of zero, as `width: NaN` is. A bare `Math.max` returns
+     * ceiling holds the column to its padding alone, as `width: NaN` does. A bare `Math.max` returns
      * NaN instead, and the column vanishes. [LAW:one-source-of-truth]
      */
     private _bounded;