@promptctl/rich-js 0.22.0 → 0.24.0

package/dist/renderables/markdown.js

@@ -5,14 +5,19 @@
  * Block structure is read as CommonMark reads it: a blockquote and a list
  * item are both containers, their lines tokenized as Markdown of their own
  * once the container's marker or indentation is cut off, and drawn beside a
- * gutter — the quote's bar, the item's marker then its hang. Where CommonMark
- * leaves the drawing open, Rich's is followed.
+ * gutter — the quote's bar, the item's marker then its hang. A table, which
+ * CommonMark has none of, and an HTML block are read as markdown-it — Rich's
+ * parser — reads them. Where CommonMark leaves the drawing open, Rich's is
+ * followed: HTML, a block of it or a tag inline, is drawn as Rich draws it,
+ * not at all.
  */
 import { cellLen, expandTabs, parseTabSize } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { RichText, resolveStyle } from "../core/text.js";
 import { Rule } from "./rule.js";
+import { Table } from "./table.js";
+import { SIMPLE } from "../core/box.js";
 import { drawable, getStyle, groundedStyle, stackedHeight } from "../core/protocol.js";
 const HEADING = /^(#{1,6})\s+(.+)$/;
 /** A thematic break: three or more of one of `*`, `-` or `_`, spaces and tabs between them allowed. */
@@ -24,11 +29,43 @@ const ITEM_MARKER = /^(?:[*+-]|(\d{1,9})\.)/;
 const LEAD = /^[ \t]*/;
 const HARD_BREAK = /(?: {2,}|\\)$/;
 const BLOCK_STARTS = [HEADING, FENCE, QUOTE, RULE];
+/** A line that may be a table's delimiter row, screened as markdown-it screens one: pipes, dashes, colons and space only, and not a dash then a space, which opens a list item. */
+const DELIMITER_ROW = /^(?!-[ \t])[-:|][-:| \t]+$/;
+const DELIMITER_CELL = /^:?-+:?$/;
+/**
+ * How many empty cells a table's short rows may be filled out with before the
+ * table ends, as markdown-it caps them: a header of many columns over many
+ * one-cell rows would otherwise grow a few kilobytes of source into millions of cells.
+ */
+const MAX_AUTOCOMPLETED_CELLS = 0x10000;
 /** Indentation that makes a line indented code when it opens a block, as CommonMark counts it. */
 const CODE_INDENT = 4;
 /** The tab stop code is drawn with, as Rich's `Syntax` draws it. */
 const CODE_TAB_SIZE = parseTabSize(8);
 const BLANK_LINE = { text: "", margin: 0, lazy: false };
+/** The block-level element names an HTML block of the sixth kind opens with, as markdown-it-py lists them. */
+const HTML_BLOCK_NAMES = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|" +
+    "fieldset|figcaption|figure|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|header|hr|html|iframe|legend|li|link|" +
+    "main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|" +
+    "title|tr|track|ul";
+// The tag grammar of markdown-it-py's common/html_re, shared by the HTML block a lone tag opens and the inline HTML it reads in text.
+const HTML_ATTRIBUTE = String.raw `(?:\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\s*=\s*(?:[^"'=<>\`\x00-\x20]+|'[^']*'|"[^"]*"))?)`;
+const HTML_OPEN_TAG = String.raw `<[A-Za-z][A-Za-z0-9-]*${HTML_ATTRIBUTE}*\s*\/?>`;
+const HTML_CLOSE_TAG = String.raw `<\/[A-Za-z][A-Za-z0-9-]*\s*>`;
+const HTML_BLOCKS = [
+    { start: /^<(?:script|pre|style|textarea)(?=\s|>|$)/i, end: /<\/(?:script|pre|style|textarea)>/i, interrupts: true },
+    { start: /^<!--/, end: /-->/, interrupts: true },
+    { start: /^<\?/, end: /\?>/, interrupts: true },
+    // Uppercase only, as markdown-it-py has it, where markdown-it in JS and CommonMark 0.31 take `<!doctype` too.
+    { start: /^<![A-Z]/, end: />/, interrupts: true },
+    { start: /^<!\[CDATA\[/, end: /\]\]>/, interrupts: true },
+    { start: new RegExp(String.raw `^<\/?(?:${HTML_BLOCK_NAMES})(?=\s|\/?>|$)`, "i"), end: "blank", interrupts: true },
+    {
+        start: new RegExp(String.raw `^(?:${HTML_OPEN_TAG}|${HTML_CLOSE_TAG})\s*$`),
+        end: "blank",
+        interrupts: false,
+    },
+];
 /** The column `ws` ends at when it starts at column `from`, a tab reaching the next stop of 4 as CommonMark counts it. */
 function advance(from, ws) {
     return [...ws].reduce((col, ch) => (ch === "\t" ? col + 4 - (col % 4) : col + 1), from);
@@ -90,6 +127,57 @@ function itemStart(line) {
         first: rest === "" ? undefined : { text: lead + " ".repeat(m[0].length) + after, margin: content, lazy: false },
     };
 }
+/** Whether `line` may be a table's row: a line of its container's own, neither lazy paragraph text nor indented code. */
+function tableLine(line) {
+    return !line.lazy && indentOf(line) < CODE_INDENT;
+}
+/**
+ * A table row's cells, as markdown-it splits one: at every `|` no backslash escapes,
+ * a pipe at either end of the row closing it rather than opening an empty
+ * cell, and each cell trimmed. An escaped `\|` is a `|` in its cell, inside a
+ * code span too.
+ */
+function rowCells(row) {
+    const cells = [""];
+    for (const ch of row.trim()) {
+        const last = cells.length - 1;
+        if (ch !== "|")
+            cells[last] += ch;
+        else if (cells[last].endsWith("\\"))
+            cells[last] = `${cells[last].slice(0, -1)}|`;
+        else
+            cells.push("");
+    }
+    const from = cells[0] === "" ? 1 : 0;
+    const to = cells.length > from && cells[cells.length - 1] === "" ? -1 : undefined;
+    return cells.slice(from, to).map((cell) => cell.trim());
+}
+/** The alignment of each column `line` declares, if it is a table's delimiter row: a run of dashes per column, a colon on the side its cells sit. */
+function alignments(line) {
+    const text = body(line);
+    if (!tableLine(line) || !DELIMITER_ROW.test(text))
+        return undefined;
+    const cells = rowCells(text);
+    if (!cells.every((cell) => DELIMITER_CELL.test(cell)))
+        return undefined;
+    return cells.map((cell) => (cell.endsWith(":") ? (cell.startsWith(":") ? "center" : "right") : cell.startsWith(":") ? "left" : undefined));
+}
+/**
+ * The columns of the table opening at `start`, if one does, as markdown-it
+ * reads one: a header row with a pipe in it, then a delimiter row naming as
+ * many columns.
+ */
+function tableAt(lines, start) {
+    const head = lines[start];
+    const delimiter = lines[start + 1];
+    if (delimiter === undefined || !tableLine(head) || !body(head).includes("|"))
+        return undefined;
+    const aligns = alignments(delimiter);
+    if (!aligns)
+        return undefined;
+    const headers = rowCells(body(head));
+    return headers.length === aligns.length ? headers.map((header, n) => ({ header, align: aligns[n] })) : undefined;
+}
 /** Whether two item starts belong to one list: the same bullet character, or both numbered. */
 function sameList(a, b) {
     return a.bullet === b.bullet;
@@ -104,13 +192,18 @@ function quoted(line) {
     const spaced = /[ \t]/.test(line.text[at + 1] ?? "");
     return { text: `${line.text.slice(0, at)} ${line.text.slice(at + 1)}`, margin: leadEnd(line) + 1 + (spaced ? 1 : 0), lazy: false };
 }
+/** The kind of HTML block `line` opens, if it opens one: the first kind whose opening it matches, as markdown-it tries them in order. */
+function htmlBlockAt(line) {
+    return HTML_BLOCKS.find((kind) => startsWith(line, kind.start));
+}
 /**
- * Whether `line` opens a block of its own — a heading, a fence, a quote, a
- * rule or a list item. A line that does not is text, and under an open
+ * Whether `line` opens a block of its own that may cut short the block before
+ * it — a heading, a fence, a quote, a rule, a list item or an HTML block of
+ * any kind but a lone tag. A line that does not is text, and under an open
  * paragraph it continues that paragraph.
  */
 function opensBlock(line) {
-    return BLOCK_STARTS.some((re) => startsWith(line, re)) || itemStart(line) !== undefined;
+    return BLOCK_STARTS.some((re) => startsWith(line, re)) || itemStart(line) !== undefined || htmlBlockAt(line)?.interrupts === true;
 }
 /**
  * Whether `line` ends a paragraph: `opensBlock`, read as CommonMark reads it
@@ -160,7 +253,7 @@ function continuesLazily(inner, line, afterLazy) {
 }
 /**
  * The text of the paragraph begun at `start`, every line after it up to a
- * blank or a line that ends a paragraph, and the index of the line that ended
+ * blank, a line that ends a paragraph or a table's header row, and the index of the line that ended
  * it. Soft-broken lines are joined by one space, as a Markdown renderer
  * reflows them, with their own indentation dropped; a line ending in two
  * spaces or a backslash breaks hard, and its break is kept.
@@ -168,7 +261,7 @@ function continuesLazily(inner, line, afterLazy) {
 function continuation(lines, start) {
     const parts = [lines[start].text];
     let i = start + 1;
-    for (; i < lines.length && !isBlank(lines[i]) && !endsParagraph(lines[i]); i++)
+    for (; i < lines.length && !isBlank(lines[i]) && !endsParagraph(lines[i]) && !tableAt(lines, i); i++)
         parts.push(lines[i].text);
     const text = parts
         .map((part, n) => {
@@ -247,6 +340,23 @@ function tokenize(lines) {
             i++;
             continue;
         }
+        // Table: before every other block, as markdown-it tries it, so a header
+        // row that reads as a heading or a list item is still a header. Its body
+        // rows run to a blank line or a line that opens a block.
+        const columns = tableAt(lines, i);
+        if (columns) {
+            const rows = [];
+            let autocompleted = 0;
+            for (i += 2; i < lines.length && !isBlank(lines[i]) && tableLine(lines[i]) && !opensBlock(lines[i]); i++) {
+                const cells = rowCells(body(lines[i]));
+                autocompleted += columns.length - cells.length;
+                if (autocompleted > MAX_AUTOCOMPLETED_CELLS)
+                    break;
+                rows.push(columns.map((_, n) => cells[n] ?? ""));
+            }
+            tokens.push({ type: "table", columns, rows });
+            continue;
+        }
         // Indented code: its lines, and the blank lines between them, with the indent cut off
         if (indentOf(line) >= CODE_INDENT) {
             const code = [];
@@ -305,6 +415,19 @@ function tokenize(lines) {
             i = next;
             continue;
         }
+        // HTML block: to the line that closes its kind, or to the end of its
+        // container when none does; a closing blank line is left to what follows
+        const html = htmlBlockAt(line);
+        if (html) {
+            const { end } = html;
+            const closes = end === "blank" ? isBlank : (closing) => end.test(body(closing));
+            while (i < lines.length && !closes(lines[i]))
+                i++;
+            if (i < lines.length && end !== "blank")
+                i++;
+            tokens.push({ type: "html_block" });
+            continue;
+        }
         // Paragraph, or a setext heading when a line of `=` or `-` underlines it
         const { text, next } = continuation(lines, i);
         const setext = underline(lines[next]);
@@ -316,10 +439,20 @@ function tokenize(lines) {
     return tokens;
 }
 const TICKS = /`+/y;
-const STRONG = /\*\*(.+?)\*\*/y;
-const EMPHASIS = /\*(.+?)\*/y;
 const ANGLED_DESTINATION = /\(\s*<([^<>\n]*)>/y;
 const LINK_TAIL = /\s*(?:"[^"]*"|'[^']*'|\([^()]*\))?\s*\)/y;
+/** A backslash escape, as markdown-it reads one: the ASCII punctuation character after it, standing for itself. */
+const ESCAPE = /\\([!-\/:-@[-`{-~])/y;
+const ESCAPES = new RegExp(ESCAPE.source, "g");
+/** Inline HTML, as markdown-it-py's HTML_TAG_RE reads it: a tag, a comment, a processing instruction, a declaration or a CDATA section. */
+const HTML_TAG = new RegExp([
+    HTML_OPEN_TAG,
+    HTML_CLOSE_TAG,
+    String.raw `<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->`,
+    String.raw `<[?][\s\S]*?[?]>`,
+    String.raw `<![A-Za-z][^>]*>`,
+    String.raw `<!\[CDATA\[[\s\S]*?\]\]>`,
+].join("|"), "y");
 /** `re`, a sticky pattern, matched exactly at `i` in `text`. */
 function matchAt(re, text, i) {
     re.lastIndex = i;
@@ -327,8 +460,10 @@ function matchAt(re, text, i) {
 }
 /**
  * Each `[` in `text` that a `]` closes, to the index of that `]`: brackets
- * nest, and a backslash escapes the character after it. One pass, so a run of
- * text full of brackets that close nothing costs no more than one without.
+ * nest, a backslash escapes the character after it, and a bracket inside a
+ * code span or inline HTML, which bind tighter than a link, is not one. One
+ * pass, so a run of text full of brackets that close nothing costs no more
+ * than one without.
  */
 function bracketPairs(text) {
     const pairs = new Map();
@@ -340,6 +475,9 @@ function bracketPairs(text) {
             open.push(i);
         else if (text[i] === "]" && open.length > 0)
             pairs.set(open.pop(), i);
+        // Neither construct reads the brackets, so the pairs found so far serve.
+        else if (text[i] === "`" || text[i] === "<")
+            i = (inlineAt(text, i, pairs)?.end ?? i + 1) - 1;
     }
     return pairs;
 }
@@ -347,7 +485,8 @@ function bracketPairs(text) {
  * The `(destination "title")` of a link opening at `open`, as CommonMark reads
  * it: a destination in angle brackets, or a run of non-space characters whose
  * parentheses balance — so a URL may itself hold `(…)` — then an optional
- * quoted title, then the `)`. The destination and the index past the `)`.
+ * quoted title, then the `)`. The destination, its backslash escapes read, and
+ * the index past the `)`.
  */
 function linkDestination(text, open) {
     if (text[open] !== "(")
@@ -375,7 +514,22 @@ function linkDestination(text, open) {
         url = text.slice(from, i);
     }
     const tail = matchAt(LINK_TAIL, text, i);
-    return tail ? { url, end: i + tail[0].length } : undefined;
+    return tail ? { url: url.replace(ESCAPES, "$1"), end: i + tail[0].length } : undefined;
+}
+/**
+ * The index of the `delimiter` that closes emphasis whose text starts at
+ * `from`, after at least one character of it. Every other inline construct
+ * binds tighter than emphasis, as CommonMark has it, so a delimiter inside an
+ * escape, a code span, inline HTML or a link closes nothing.
+ */
+function emphasisClose(text, from, delimiter, brackets) {
+    for (let i = from; i < text.length;) {
+        if (i > from && text.startsWith(delimiter, i))
+            return i;
+        const tighter = text[i] === "*" ? undefined : inlineAt(text, i, brackets);
+        i = tighter ? tighter.end : i + 1;
+    }
+    return undefined;
 }
 /** The inline construct opening at `i` in `text`, if one does; `brackets` is `text`'s `bracketPairs`. */
 function inlineAt(text, i, brackets) {
@@ -390,11 +544,25 @@ function inlineAt(text, i, brackets) {
                 : { kind: "literal", text: ticks, end: i + ticks.length };
         }
         case "*": {
-            const strong = matchAt(STRONG, text, i);
-            const emphasis = strong ?? matchAt(EMPHASIS, text, i);
-            return emphasis
-                ? { kind: "emphasis", style: strong ? "bold" : "italic", inner: emphasis[1], end: i + emphasis[0].length }
-                : undefined;
+            const strong = text.startsWith("**", i) ? emphasisClose(text, i + 2, "**", brackets) : undefined;
+            const delimiter = strong === undefined ? "*" : "**";
+            const close = strong ?? emphasisClose(text, i + 1, "*", brackets);
+            return close === undefined
+                ? undefined
+                : {
+                    kind: "emphasis",
+                    style: strong === undefined ? "italic" : "bold",
+                    inner: text.slice(i + delimiter.length, close),
+                    end: close + delimiter.length,
+                };
+        }
+        case "\\": {
+            const escape = matchAt(ESCAPE, text, i);
+            return escape ? { kind: "literal", text: escape[1], end: i + escape[0].length } : undefined;
+        }
+        case "<": {
+            const tag = matchAt(HTML_TAG, text, i);
+            return tag ? { kind: "html", end: i + tag[0].length } : undefined;
         }
         case "!":
         case "[": {
@@ -426,7 +594,8 @@ function styled(text, style, settings, options) {
 /**
  * `text` as inline Markdown appended to `result`: code spans, emphasis, links
  * and images, the text inside emphasis, links and images parsed the same way,
- * and everything else as it is.
+ * a backslash escape as the character it escapes, inline HTML as nothing, and
+ * everything else as it is.
  */
 function appendInline(result, text, settings, options) {
     const brackets = bracketPairs(text);
@@ -445,6 +614,9 @@ function appendInline(result, text, settings, options) {
             case "literal":
                 result.append(found.text);
                 break;
+            case "html":
+                // Rich draws nothing for inline HTML.
+                break;
             case "emphasis":
                 result.append(styled(found.inner, found.style, settings, options));
                 break;
@@ -558,6 +730,25 @@ function* renderTokens(tokens, options, settings) {
                 yield* guttered(body, options, bar, bar, Style.parse("dim italic"));
                 break;
             }
+            case "table": {
+                // Rich's TableElement: each cell inline Markdown placed by its
+                // column's alignment, the header's in `markdown.table.header` on top.
+                const cell = (text, justify) => {
+                    const content = new RichText("", { justify });
+                    appendInline(content, text, settings, options);
+                    return content;
+                };
+                const table = new Table({ box: SIMPLE, padEdge: false, style: "markdown.table.border", showEdge: true, collapsePadding: true });
+                for (const { header, align } of token.columns)
+                    table.addColumn(cell(header, align).stylize("markdown.table.header"));
+                for (const row of token.rows)
+                    table.addRow(...row.map((text, n) => cell(text, token.columns[n].align)));
+                yield* table.render(options);
+                break;
+            }
+            case "html_block":
+                // Rich draws nothing for one.
+                break;
             case "blank":
                 yield Segment.line();
                 break;

package/dist/renderables/progress.d.ts

@@ -124,7 +124,7 @@ export interface SpinnerColumnOptions {
 }
 export declare class SpinnerColumn implements ProgressColumn {
     readonly tableColumn: ColumnOptions;
-    private _spinner;
+    private readonly _spinner;
     private _finishedText;
     constructor(spinnerName?: string, options?: SpinnerColumnOptions);
     render(task: Task): Renderable;

package/dist/renderables/progress.js

@@ -173,8 +173,10 @@ export class SpinnerColumn {
         const finishedText = options?.finishedText ?? " ";
         this._finishedText = typeof finishedText === "string" ? readStr(finishedText, true) : finishedText.copy();
     }
+    // Rich's `self.spinner.render(task.get_time())`: the frame for the time the
+    // task is drawn at, which `Progress` read off its clock once for the frame.
     render(task) {
-        return finished(task) ? this._finishedText : this._spinner;
+        return finished(task) ? this._finishedText : this._spinner.at(task.time);
     }
 }
 /**

package/dist/renderables/progressBar.js

@@ -59,17 +59,17 @@ export class ProgressBar {
         // [LAW:no-ambient-temporal-coupling] The moment is the caller's; the bar
         // only says what it looks like then. An empty track, lit by the shimmer.
         const track = { render: (o) => this.track(o, width, 0, back) };
-        yield* new Effected(track, this.pulseEffect(options, back, width, depth, theme), { t: this.pulse.t, key: "progress-bar", theme }).render(options);
+        yield* new Effected(track, this.pulseEffect(options, back, depth, theme), { t: this.pulse.t, key: "progress-bar", theme }).render(options);
     }
     /**
      * The shimmer over this bar's back colour as `Effected` sees it drawn at
      * `depth`, toward `bar.pulse`. A bar has no words to keep legible, so its
      * back takes the whole of the light.
      */
-    pulseEffect(options, back, width, depth, theme) {
+    pulseEffect(options, back, depth, theme) {
         const ink = back.drawnColors(depth).color ?? ColorSpec.default();
         const glow = getStyle(options, "bar.pulse").drawnColors(depth).color ?? ColorSpec.default();
-        const loop = shimmer(PULSE_CURVE, width, PULSE_REACH, glow.getTruecolor(theme, true), 0);
+        const loop = shimmer(PULSE_CURVE, PULSE_REACH, glow.getTruecolor(theme, true), 0);
         const whole = new Map([[ink.getTruecolor(theme, true).hex, 1]]);
         return atShares(loop, () => whole);
     }

package/dist/renderables/spinner.d.ts

@@ -1,15 +1,59 @@
 /**
- * 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` scales the holds, not the time: at speed 2 each frame is held half
+ * the interval, and a negative speed is the frames in reverse order, each held
+ * the interval over the speed's size. [LAW:one-source-of-truth] Rich scales
+ * the time instead, `t × speed` into the beat. At a positive speed the frame
+ * drawn is the same; but when the frame next changes (`Style.nextChange`) is
+ * a time on the host's timeline, and a beat over scaled time answers on the
+ * scaled one — so the sequence is scaled where it is built, and the
+ * `FrameSequence` stamps host time with nothing to map back. Backwards, this is the plain
+ * reversed sequence from `t = 0`, where Rich's `int()` truncation holds
+ * frame 0 for a first interval and then counts down: a departure, made so a
+ * negative speed is one more sequence on the beat and not a second rule
+ * about time. A speed of zero would hold a frame forever, which is not a
+ * beat, and is refused where it is given.
  */
-import { Segment } from "../core/segment.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 {
     readonly name: string;
     readonly speed: number;
     readonly style: string | Style;
@@ -22,36 +66,26 @@ 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;
+    private _render;
     /**
-     * `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.
      */
     private _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: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
 }