@promptctl/rich-js 0.24.1 → 0.25.1

package/dist/renderables/live.js

@@ -29,32 +29,40 @@ import { Console } from "../core/console.js";
 import { Segment } from "../core/segment.js";
 import { FinalFramePainter, SurfacePainter } from "../core/paint.js";
 import { fitHeight, render } from "../core/protocol.js";
-// [LAW:parse-dont-validate] The one shape Live holds: a renderable becomes
-// the view that answers it at every t, where it is given, so no frame asks
-// which it was.
-const viewOf = (view) => view === undefined || typeof view === "function" ? view : () => view;
+import { Timeline } from "../core/timeline.js";
+import { drawView, frameTime, hostView, undrawn } from "../core/view.js";
+import { State } from "../core/state.js";
+// Nothing: what a Live made with no view draws until `update` gives it one.
+const NOTHING = { render: () => [] };
 export class Live {
     _view;
     _console;
     _rate;
     _clock;
+    // The clock moment this host began: what its default timeline plays from,
+    // and what a renderable view is drawn for the time since (`HostTime`).
+    _epoch;
+    _timeline;
     _autoRefresh;
     _transient;
     _verticalOverflow;
     _painter;
-    // The one wait for the next auto-refresh frame, armed after each frame.
-    _waking;
+    // The one wait for the next auto-refresh frame, armed after each frame, and
+    // the clock moment it is due at.
+    _waking = new State(undefined);
     // [LAW:one-source-of-truth] The console's live region, held from `start()`
     // to the hand-back — which is what "started" means, so there is no separate
     // flag to disagree with it.
-    _held;
+    _held = new State(null);
     constructor(view, options) {
-        this._view = viewOf(view);
+        this._view = new State(hostView(view ?? NOTHING));
         this._console = options?.console ?? new Console();
         // [LAW:parse-dont-validate] Parsed whether or not it auto-refreshes, so a
         // rate that could never tick is refused where it is given.
         this._rate = frameRate(options?.refreshPerSecond ?? 4);
         this._clock = options?.clock ?? systemClock();
+        this._epoch = this._clock.now();
+        this._timeline = new State(options?.timeline ?? Timeline.play(this._epoch));
         this._autoRefresh = options?.autoRefresh !== false;
         this._transient = options?.transient ?? false;
         this._verticalOverflow = options?.verticalOverflow ?? "ellipsis";
@@ -65,7 +73,6 @@ export class Live {
         this._painter = this._console.isInteractive
             ? new SurfacePainter(options?.altScreen ? "alternate" : "inline", (bytes) => void this._console.file.write(bytes))
             : new FinalFramePainter((frame) => this._console.print(linesOf(frame)));
-        this._held = null;
     }
     /**
      * The console to print through while this Live runs: what it prints lands
@@ -74,20 +81,45 @@ export class Live {
     get console() {
         return this._console;
     }
+    /** The clock the auto-refresh waits on: where the host time a `Timeline` operation takes is read. */
+    get clock() {
+        return this._clock;
+    }
+    /** The map from the clock to the time the view is drawn for. */
+    get timeline() {
+        return this._timeline.get();
+    }
+    /** The time a frame drawn now is drawn for: the clock's now, through the timeline. */
+    get frameTime() {
+        return frameTime(this._time());
+    }
+    _time() {
+        return { now: this._clock.now(), epoch: this._epoch, timeline: this._timeline.get() };
+    }
+    /**
+     * Replace the timeline and draw the frame for the time it now maps the
+     * clock's now to, so a seek shows where it sought, once. Paused, the frame
+     * then holds — the auto-refresh waits on nothing until the timeline plays
+     * again — while `refresh()` and `update(…, { refresh: true })` still draw.
+     */
+    set timeline(timeline) {
+        this._timeline.set(timeline);
+        this.refresh();
+    }
     start() {
-        if (this._held !== null)
+        if (this._held.get() !== null)
             return;
         // Claimed before a byte is written, so a console another Live is running
         // on refuses this one with the terminal untouched.
         const held = this._console.claimLiveRegion({ around: (text) => this._stepAround(text) });
-        this._held = held;
+        this._held.set(held);
         this._painter.take();
         // Nothing is drawn yet, so nothing has said when it changes: the first
         // auto-refresh frame comes at the rate, from now.
-        this._wake(held, { t: this._clock.now(), nextChange: Number.POSITIVE_INFINITY });
+        this._wake(held, undrawn(this._clock.now()));
     }
     stop() {
-        const held = this._held;
+        const held = this._held.get();
         if (held === null)
             return;
         // [LAW:no-silent-failure] A final frame that throws still propagates, and
@@ -106,17 +138,29 @@ export class Live {
     }
     update(view, options) {
         if (view !== undefined) {
-            this._view = viewOf(view);
+            this._view.set(hostView(view));
         }
         if (options?.refresh) {
             this.refresh();
+            return;
+        }
+        const held = this._held.get();
+        if (view !== undefined && held !== null) {
+            // The last wake was armed for what the old view said; a new view has
+            // said nothing yet, so the auto-refresh draws it by the rate's next
+            // frame from now — sooner if the wake already armed is, and never
+            // later, so updates faster than the rate do not put the frame off.
+            const now = this._clock.now();
+            const waking = this._waking.get();
+            if (waking === undefined || waking.at > now + this._rate.interval)
+                this._wake(held, undrawn(now));
         }
     }
     refresh() {
         // A frame is drawn only while this Live holds the terminal, as in Rich:
         // before `start()` or after the hand-back it would land on a screen that
         // belongs to someone else — the main buffer, under the user's own output.
-        const held = this._held;
+        const held = this._held.get();
         if (held === null)
             return;
         // [LAW:no-ambient-temporal-coupling] The frame says when what it shows
@@ -126,30 +170,33 @@ export class Live {
         // frame not drawn has said nothing.
         let said;
         this._paint(() => {
-            const { t, lines } = this._frame();
-            said = { t, nextChange: lines.reduce((soonest, row) => Math.min(soonest, Segment.nextChange(row)), Number.POSITIVE_INFINITY) };
-            return lines;
+            const drawn = this._frame();
+            said = drawn;
+            return drawn.lines;
         });
-        this._wake(held, said ?? { t: this._clock.now(), nextChange: Number.POSITIVE_INFINITY });
-    }
-    // Arm the one wait for the next auto-refresh frame while `held`: at the
-    // frame's `nextChange` when that is before the rate's next frame, else at
-    // the rate — both measured from the frame's own `t`, never from a second
-    // reading of the clock, so the rate does not stretch by what a frame cost
-    // to draw, and a change that fell due while it was drawn is drawn at once
-    // (`Clock.at` fires now for a time already past). Content that changes
-    // every frame answers `t` itself, and is drawn at the rate.
+        this._wake(held, said ?? undrawn(this._clock.now()));
+    }
+    // Arm the one wait for the next auto-refresh frame while `held`, from what
+    // the frame says: at its `nextChange` when it holds until a moment sooner
+    // than the rate, and at the rate otherwise — every view is drawn from state
+    // that may change without saying so, which the auto-refresh polls, as
+    // Rich's does, a paused timeline's included. Every moment is measured from the
+    // frame's own `t`, never from a second reading of the clock, so the rate
+    // does not stretch by what a frame cost to draw, and a change that fell
+    // due while it was drawn is drawn at once (`Clock.at` fires now for a time
+    // already past).
     _wake(held, { t, nextChange }) {
-        this._waking?.();
-        this._waking = undefined;
+        this._waking.get()?.stop();
+        this._waking.set(undefined);
+        const rate = t + this._rate.interval;
+        const at = nextChange <= t ? rate : Math.min(nextChange, rate);
         if (!this._autoRefresh)
             return;
-        const at = Math.min(t + this._rate.interval, nextChange > t ? nextChange : Number.POSITIVE_INFINITY);
         // No caller is on the stack to run `stop()` for a frame that throws
         // here, and in Node the throw ends the process — so the terminal is
         // handed back first, and the error then goes on to wherever an uncaught
         // one goes.
-        this._waking = this._clock.at(at, () => {
+        const stop = this._clock.at(at, () => {
             try {
                 this.refresh();
             }
@@ -158,15 +205,13 @@ export class Live {
                 throw error;
             }
         });
+        this._waking.set({ at, stop });
     }
-    // The frame at the clock's now, with that time: the one the view was handed, and the one the next wake is measured from.
+    // The frame at the clock's now, drawn for the time the timeline maps it to,
+    // with when it next changes on the clock: what the next wake is measured from.
     _frame() {
         // [LAW:effects-at-boundaries] One read of the clock a frame, handed to
         // the view as the frame's time.
-        const t = this._clock.now();
-        if (!this._view)
-            return { t, lines: [] };
-        const renderable = this._view(t);
         // [LAW:dataflow-not-control-flow] Both modes render under the terminal's
         // rows and differ only in what those rows are: the alternate screen is a
         // region the frame stands in, and an inline frame keeps its natural height
@@ -174,8 +219,10 @@ export class Live {
         // back — its overflow policy, then `fitHeight`, which pads only a region.
         const options = this._console.options;
         const height = this._painter.height(options.height.rows);
-        const lines = Segment.splitLines(render(renderable, { ...options, height }));
-        return { t, lines: fitHeight(this._overflow(lines, height.rows), height) };
+        return drawView(this._view.get(), this._time(), this, { ...options, height }, (renderable, drawn) => {
+            const lines = Segment.splitLines(render(renderable, drawn));
+            return fitHeight(this._overflow(lines, height.rows), height);
+        });
     }
     // What the console writes goes where the frame was, and the frame is painted
     // again under it, as Rich's render hook does — in the bytes the console
@@ -210,9 +257,9 @@ export class Live {
     // ran or a frame threw with no caller to run it.
     _release(held) {
         held();
-        this._held = null;
-        this._waking?.();
-        this._waking = undefined;
+        this._held.set(null);
+        this._waking.get()?.stop();
+        this._waking.set(undefined);
         this._painter.handBack();
     }
 }

package/dist/renderables/markdown-parse.d.ts

@@ -25,7 +25,7 @@ export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
  * `parseMarkdown` hands back. `Mark` is what the block pass keeps besides:
  * none, once the inline pass has dropped its marks.
  */
-export type MdToken<Text = readonly Inline[], Mark = never> = {
+export type MdToken<Text = readonly Inline[], Mark = never> = Readonly<{
     type: "heading";
     level: HeadingLevel;
     text: Text;
@@ -56,7 +56,7 @@ export type MdToken<Text = readonly Inline[], Mark = never> = {
 /** Kept, though nothing draws it, as Rich exits it like any other block. */
  | {
     type: "html_block";
-} | Mark;
+} | Mark>;
 /** The element markdown-it makes of a pair of delimiters. */
 type EmphasisTag = "em" | "strong" | "s";
 /**
@@ -66,7 +66,7 @@ type EmphasisTag = "em" | "strong" | "s";
  * characters they stand for. Emphasis is named by the element markdown-it
  * makes of it, GFM's strikethrough `s` among them.
  */
-export type Inline = {
+export type Inline = Readonly<{
     kind: "text";
     text: string;
 } | {
@@ -103,7 +103,7 @@ export type Inline = {
     kind: "softbreak";
 } | {
     kind: "hardbreak";
-};
+}>;
 /** `source` read as Markdown: its blocks, and the text in each read into inlines. A line ends at `\r\n`, `\r` or `\n`, as markdown-it normalizes them. */
 export declare function parseMarkdown(source: string): MdToken[];
 export {};

package/dist/renderables/markdown-parse.js

@@ -14,6 +14,7 @@
 import { linkHref, normalizeLinkText } from "./markdown-url.js";
 import { PY_WHITESPACE, pyStrip } from "./python-space.js";
 import { namedReference } from "./html-entities.js";
+import { pattern } from "../core/pattern.js";
 /** A line of the source as the top level holds it. */
 function sourceLine(text) {
     return { text, marked: 0, quoteStart: 0, margin: 0, lead: advance(0, LEAD.exec(text)[0]), lazy: false };
@@ -54,35 +55,35 @@ class Lines {
     }
 }
 /** An ATX heading's opening: one to six `#`, then a space, a tab or the end of the line. */
-const HEADING = /^#{1,6}(?=[ \t]|$)/;
+const HEADING = pattern(/^#{1,6}(?=[ \t]|$)/);
 /**
  * An ATX heading's closing sequence, as markdown-it cuts one: a run of `#` at
  * the end of the line, spaces and tabs after it allowed, with a space or tab
  * before it — so `# x#` keeps its `#` and `# #` is an empty heading.
  */
-const HEADING_CLOSE = /(?<=[ \t])#+[ \t]*$/;
+const HEADING_CLOSE = pattern(/(?<=[ \t])#+[ \t]*$/);
 /** A thematic break: three or more of one of `*`, `-` or `_`, spaces and tabs between them allowed. */
-const RULE = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
-const SETEXT = /^(=+|-+)[ \t]*$/;
+const RULE = pattern(/^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/);
+const SETEXT = pattern(/^(=+|-+)[ \t]*$/);
 /**
  * A code fence's opening, as markdown-it's fence rule reads one: three or more
  * backticks, the info string after them holding no backtick, or three or more
  * tildes, the info string free to hold anything. The run is captured whole, so
  * its closing can be read off it.
  */
-const FENCE = /^(`{3,}(?=[^`]*$)|~{3,})/;
-const QUOTE = /^>/;
-const ITEM_MARKER = /^(?:[*+-]|(\d{1,9})[.)])/;
+const FENCE = pattern(/^(`{3,}(?=[^`]*$)|~{3,})/);
+const QUOTE = pattern(/^>/);
+const ITEM_MARKER = pattern(/^(?:[*+-]|(\d{1,9})[.)])/);
 /**
  * A line's leading space and tab: CommonMark's whitespace, and the only
  * whitespace markdown-it's block pass reads — what indents a line, what makes
  * one blank. A no-break space or any other Unicode space is text to it.
  */
-const LEAD = /^[ \t]*/;
+const LEAD = pattern(/^[ \t]*/);
 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 = /^:?-+:?$/;
+const DELIMITER_ROW = pattern(/^(?!-[ \t])[-:|][-:| \t]+$/);
+const DELIMITER_CELL = pattern(/^:?-+:?$/);
 /**
  * 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
@@ -110,15 +111,15 @@ const HTML_ATTRIBUTE = String.raw `(?:${PY_WHITESPACE}+[a-zA-Z_:][a-zA-Z0-9:._-]
 const HTML_OPEN_TAG = String.raw `<[A-Za-z][A-Za-z0-9-]*${HTML_ATTRIBUTE}*${PY_WHITESPACE}*\/?>`;
 const HTML_CLOSE_TAG = String.raw `<\/[A-Za-z][A-Za-z0-9-]*${PY_WHITESPACE}*>`;
 const HTML_BLOCKS = [
-    { start: new RegExp(String.raw `^<(?:script|pre|style|textarea)(?=${PY_WHITESPACE}|>|$)`, "i"), end: /<\/(?:script|pre|style|textarea)>/i, interrupts: true },
-    { start: /^<!--/, end: /-->/, interrupts: true },
-    { start: /^<\?/, end: /\?>/, interrupts: true },
+    { start: pattern(new RegExp(String.raw `^<(?:script|pre|style|textarea)(?=${PY_WHITESPACE}|>|$)`, "i")), end: pattern(/<\/(?:script|pre|style|textarea)>/i), interrupts: true },
+    { start: pattern(/^<!--/), end: pattern(/-->/), interrupts: true },
+    { start: pattern(/^<\?/), end: pattern(/\?>/), 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})(?=${PY_WHITESPACE}|\/?>|$)`, "i"), end: "blank", interrupts: true },
+    { start: pattern(/^<![A-Z]/), end: pattern(/>/), interrupts: true },
+    { start: pattern(/^<!\[CDATA\[/), end: pattern(/\]\]>/), interrupts: true },
+    { start: pattern(new RegExp(String.raw `^<\/?(?:${HTML_BLOCK_NAMES})(?=${PY_WHITESPACE}|\/?>|$)`, "i")), end: "blank", interrupts: true },
     {
-        start: new RegExp(String.raw `^(?:${HTML_OPEN_TAG}|${HTML_CLOSE_TAG})${PY_WHITESPACE}*$`),
+        start: pattern(new RegExp(String.raw `^(?:${HTML_OPEN_TAG}|${HTML_CLOSE_TAG})${PY_WHITESPACE}*$`)),
         end: "blank",
         interrupts: false,
     },
@@ -337,9 +338,8 @@ function continuation(lines, start) {
  * `lower().upper()` folds it.
  */
 function normalizeReference(label) {
-    return pyStrip(label).replace(WHITESPACE_RUN, " ").toLowerCase().toUpperCase();
+    return pyStrip(label).replace(new RegExp(`${PY_WHITESPACE}+`, "g"), " ").toLowerCase().toUpperCase();
 }
-const WHITESPACE_RUN = new RegExp(`${PY_WHITESPACE}+`, "g");
 /**
  * The link reference definition opening at `start`, if one does, as
  * markdown-it's reference rule reads it: `[label]:`, space, a destination, and
@@ -546,7 +546,7 @@ function listItem(item, level, lines, start) {
  * marker at least as long, then nothing but spaces and tabs.
  */
 function closingFence(open) {
-    return new RegExp(`^${open}${open[0]}*[ \\t]*$`);
+    return pattern(new RegExp(`^${open}${open[0]}*[ \\t]*$`));
 }
 /**
  * Whether a list item holding `children` swallows the rest of the lines its
@@ -717,54 +717,60 @@ function tokenize(lines, level) {
     return { tokens, end: i };
 }
 /** markdown-it's `isWhiteSpace`: Unicode's space separators, and tab, line feed, vertical tab, form feed and carriage return. */
-const WHITESPACE = /^[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]$/;
+const WHITESPACE = pattern(/^[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]$/);
 /** markdown-it's `isPunctChar`, which takes in all of ASCII's punctuation: Unicode's punctuation and symbols. */
-const PUNCTUATION = /^[\p{P}\p{S}]$/u;
-const TICKS = /`+/y;
-const TICK_RUNS = /`+/g;
-const LINE_INDENT = /[ \t]*/y;
+const PUNCTUATION = pattern(/^[\p{P}\p{S}]$/u);
+function anchored(p) {
+    // [LAW:no-silent-failure] Under `m`, `^` also matches after a line break, and the match would no longer be at the index.
+    if (p.flags.includes("m"))
+        throw new TypeError(`/${p.source}/${p.flags}: a multiline pattern is not anchored to where it is read`);
+    return pattern(new RegExp(`^(?:${p.source})`, p.flags));
+}
+const TICKS = pattern(/`+/);
+const TICKS_AT = anchored(TICKS);
+const LINE_INDENT = anchored(pattern(/[ \t]*/));
 /** markdown-it's autolink: `<`, then text holding no `<` up to the first `>`. */
-const AUTOLINK = /<([^<>]*)>/y;
+const AUTOLINK = anchored(pattern(/<([^<>]*)>/));
 /** What an autolink's text must be: a URI, scheme first, or an email address. */
-const AUTOLINK_URI = /^[a-zA-Z][a-zA-Z0-9+.\-]{1,31}:[^<>\x00-\x20]*$/;
-const AUTOLINK_EMAIL = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+const AUTOLINK_URI = pattern(/^[a-zA-Z][a-zA-Z0-9+.\-]{1,31}:[^<>\x00-\x20]*$/);
+const AUTOLINK_EMAIL = pattern(/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/);
 /** Space as markdown-it's link rule skips it around a destination and title: a space, tab or line ending, not Unicode's. */
-const LINK_SPACE = /[ \t\n]*/y;
+const LINK_SPACE = anchored(pattern(/[ \t\n]*/));
 /**
  * A link title, as markdown-it's `parseLinkTitle` reads one: in `"`, `'` or
  * `(…)`, a backslash taking the character after it, and a `(` refusing a
  * `(…)` title.
  */
-const LINK_TITLE = /"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|\((?:\\[\s\S]|[^()\\])*\)/y;
+const LINK_TITLE = anchored(pattern(/"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|\((?:\\[\s\S]|[^()\\])*\)/));
 /** How many parentheses markdown-it's `parseLinkDestination` lets a bare destination hold open: one more and it reads none. */
 const MAX_DESTINATION_NESTING = 32;
 /** A backslash escape, as markdown-it reads one: the ASCII punctuation character after it, standing for itself. */
-const ESCAPE = /\\([!-\/:-@[-`{-~])/y;
+const ESCAPE = pattern(/\\([!-\/:-@[-`{-~])/);
+const ESCAPE_AT = anchored(ESCAPE);
 /** A numeric character reference, as markdown-it reads one in text: up to seven decimal digits, or up to six hex. */
-const NUMERIC_REFERENCE = /&#([xX][0-9a-fA-F]{1,6}|[0-9]{1,7});/y;
+const NUMERIC_REFERENCE = anchored(pattern(/&#([xX][0-9a-fA-F]{1,6}|[0-9]{1,7});/));
 /** A named character reference, as markdown-it reads one in text: a letter, then one to 31 letters or digits. */
-const NAMED_REFERENCE = /&([A-Za-z][A-Za-z0-9]{1,31});/y;
+const NAMED_REFERENCE = anchored(pattern(/&([A-Za-z][A-Za-z0-9]{1,31});/));
 /**
  * A backslash escape or a character reference, as markdown-it's `unescapeAll`
  * reads them in a link's destination: the reference read more widely than in
  * text, a name or a `#` then one to 31 letters or digits.
  */
-const UNESCAPE_ALL = new RegExp(`${ESCAPE.source}|&[A-Za-z#][A-Za-z0-9]{1,31};`, "g");
+const unescapes = () => new RegExp(`${ESCAPE.source}|&[A-Za-z#][A-Za-z0-9]{1,31};`, "g");
 /** A numeric reference as `unescapeAll` reads one: up to eight digits of either base. */
-const DESTINATION_NUMERIC = /^&#([xX][0-9a-fA-F]{1,8}|[0-9]{1,8});$/;
+const DESTINATION_NUMERIC = pattern(/^&#([xX][0-9a-fA-F]{1,8}|[0-9]{1,8});$/);
 /** 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([
+const HTML_TAG = anchored(pattern(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;
-    return re.exec(text);
+].join("|"))));
+/** `p` matched exactly at `i` in `text`: read from `i` on, so no regex keeps a cursor, and none is built per call. */
+function matchAt(p, text, i) {
+    return p.exec(text.slice(i));
 }
 /**
  * The character a numeric reference to `code` names, unless markdown-it's
@@ -807,11 +813,11 @@ function referenceAt(text, i) {
 /**
  * markdown-it's `unescapeAll`, which a link's destination is read through:
  * each backslash escape as the character it escapes, and each reference
- * `UNESCAPE_ALL` finds as the characters it names — a reference naming
+ * `unescapes` finds as the characters it names — a reference naming
  * nothing, or no character `isValidEntityCode` accepts, left as written.
  */
 function unescapeAll(text) {
-    return text.replace(UNESCAPE_ALL, (whole, escaped) => {
+    return text.replace(unescapes(), (whole, escaped) => {
         if (escaped !== undefined)
             return escaped;
         const numeric = DESTINATION_NUMERIC.exec(whole);
@@ -893,7 +899,7 @@ class BacktickRuns {
     // Where each run starts, by its length, in order.
     starts = new Map();
     constructor(text) {
-        for (const run of text.matchAll(TICK_RUNS)) {
+        for (const run of text.matchAll(new RegExp(TICKS.source, "g"))) {
             const starts = this.starts.get(run[0].length);
             if (starts)
                 starts.push(run.index);
@@ -1227,7 +1233,7 @@ function nextLine(text, from) {
 function inlineAt(text, i, state, level) {
     switch (text[i]) {
         case "`": {
-            const ticks = matchAt(TICKS, text, i)[0];
+            const ticks = matchAt(TICKS_AT, text, i)[0];
             const close = state.codeClose(text, i + ticks.length, ticks.length);
             if (close === undefined)
                 return { kind: "text", text: ticks, end: i + ticks.length };
@@ -1251,7 +1257,7 @@ function inlineAt(text, i, state, level) {
             // counts toward no hard break.
             if (text[i + 1] === "\n")
                 return { kind: "hardbreak", end: nextLine(text, i + 2) };
-            const escape = matchAt(ESCAPE, text, i);
+            const escape = matchAt(ESCAPE_AT, text, i);
             if (escape)
                 return { kind: "text", text: escape[1], end: i + escape[0].length };
             if (i + 1 === text.length)

package/dist/renderables/markdown-url.js

@@ -9,13 +9,14 @@
  * markdown-it keeps the capital, and refuses outright what markdown-it reads.
  */
 import { pyStrip } from "./python-space.js";
+import { pattern } from "../core/pattern.js";
 /** mdurl's protocol, `[a-z0-9.+-]+:` under Python's IGNORECASE, which also folds İ, ı, ſ and K (Kelvin) into `[a-z]`. */
-const PROTOCOL = /^[a-z0-9.+\-\u0130\u0131\u017f\u212a]+:/i;
-const PORT = /:[0-9]*$/;
+const PROTOCOL = pattern(/^[a-z0-9.+\-\u0130\u0131\u017f\u212a]+:/i);
+const PORT = pattern(/:[0-9]*$/);
 const HOST_ENDING_CHARS = "/?#";
 const NON_HOST_CHARS = "%/?;#'{}|\\^`<>\" \r\n\t";
-const HOSTNAME_PART = /^[+a-z0-9A-Z_-]{0,63}$/;
-const HOSTNAME_PART_START = /^([+a-z0-9A-Z_-]{0,63})(.*)$/s;
+const HOSTNAME_PART = pattern(/^[+a-z0-9A-Z_-]{0,63}$/);
+const HOSTNAME_PART_START = pattern(/^([+a-z0-9A-Z_-]{0,63})(.*)$/s);
 const HOSTNAME_MAX_LEN = 255;
 /** Protocols whose hostname markdown-it recodes; anything else may not be a host at all, as `skype:name` is not. */
 const RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
@@ -106,8 +107,8 @@ function format(url) {
 }
 /** What mdurl's `encode` leaves as it is, besides ASCII letters and digits. */
 const ENCODE_KEEP = ";/?:@&=+$,-_.!~*'()#";
-const ALPHANUMERIC = /[A-Za-z0-9]/;
-const HEX_PAIR = /^[0-9a-fA-F]{2}$/;
+const ALPHANUMERIC = pattern(/[A-Za-z0-9]/);
+const HEX_PAIR = pattern(/^[0-9a-fA-F]{2}$/);
 /** mdurl's `encode`: every character it does not keep percent-encoded as UTF-8, a `%` already starting an escape kept. */
 function encode(text) {
     let result = "";
@@ -140,7 +141,6 @@ function encode(text) {
 }
 /** What `normalizeLinkText` leaves escaped: mdurl's default reserved set, and `%` (markdown-it issue 720). */
 const DECODE_KEEP = ";/?:@&=+$,#%";
-const ESCAPE_RUN = /(?:%[a-f0-9]{2})+/gi;
 /**
  * The code point of the UTF-8 sequence `bytes`, or undefined where Python's
  * strict decoder refuses it: an overlong form, a surrogate, past U+10FFFF.
@@ -157,7 +157,7 @@ function utf8(bytes) {
  * and an escape of a kept character left as an escape, its hex uppercased.
  */
 function decode(text) {
-    return text.replace(ESCAPE_RUN, (run) => {
+    return text.replace(/(?:%[a-f0-9]{2})+/gi, (run) => {
         const bytes = run.split("%").slice(1).map((hex) => parseInt(hex, 16));
         let result = "";
         for (let i = 0; i < bytes.length;) {
@@ -274,7 +274,7 @@ function punycodeDecode(label) {
     return output.join("");
 }
 /** A host's labels, split at any of the four full stops IDNA reads as one, and joined back with the ASCII one. */
-const LABEL_SEPARATOR = /[.。．｡]/;
+const LABEL_SEPARATOR = pattern(/[.。．｡]/);
 /** markdown-it's `to_ascii`: each label carrying a non-ASCII character punycoded. A hostname carries no `@`, so the email half of its `map_domain` never applies. */
 function toAscii(hostname) {
     return hostname
@@ -295,8 +295,8 @@ function recodeHostname(url, recode) {
     }
     return format(parsed);
 }
-const BAD_PROTOCOL = /^(?:vbscript|javascript|file|data):/;
-const GOOD_DATA = /^data:image\/(?:gif|png|jpeg|webp);/;
+const BAD_PROTOCOL = pattern(/^(?:vbscript|javascript|file|data):/);
+const GOOD_DATA = pattern(/^data:image\/(?:gif|png|jpeg|webp);/);
 /**
  * The href markdown-it gives a link to `destination`: its host punycoded and
  * the rest percent-encoded, as `normalizeLink` does — or undefined where

package/dist/renderables/padding.d.ts

@@ -4,8 +4,8 @@
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import type { RichText } from "../core/text.js";
-import type { Composite, Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-export type PaddingDimensions = number | [number, number] | [number, number, number, number];
+import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+export type PaddingDimensions = number | readonly [number, number] | readonly [number, number, number, number];
 /**
  * Parses the shapes a caller may write padding in — one number, a vertical/
  * horizontal pair, or all four sides — into the four-sided form every
@@ -18,7 +18,7 @@ export type PaddingDimensions = number | [number, number] | [number, number, num
  * to reach the renderers, where `Panel` drew content rows wider than its own
  * border and `Table` threw outright.
  */
-export declare function normalizePadding(padding: PaddingDimensions): [number, number, number, number];
+export declare function normalizePadding(padding: PaddingDimensions): readonly [number, number, number, number];
 /**
  * The width a padding leaves its content: what the request holds once both
  * sides are paid for, as Rich's `Padding` divides it. The sides are paid in
@@ -26,7 +26,7 @@ export declare function normalizePadding(padding: PaddingDimensions): [number, n
  * is drawn as nothing — Rich's `Console.render` under one column.
  */
 export declare function paddedContentWidth(outerWidth: number, left: number, right: number): number;
-export declare class Padding implements Renderable, Measurable, Composite {
+export declare class Padding implements Renderable, Measurable {
     readonly renderable: Renderable;
     readonly top: number;
     readonly right: number;
@@ -38,7 +38,6 @@ export declare class Padding implements Renderable, Measurable, Composite {
         style?: string | Style;
         expand?: boolean;
     });
-    contents(): Iterable<Renderable>;
     render(rawOptions: RenderOptions): Iterable<Segment>;
     measure(rawOptions: RenderOptions): {
         minimum: number;

package/dist/renderables/padding.js

@@ -67,9 +67,6 @@ export class Padding {
         this.style = options?.style ?? NULL_STYLE;
         this.expand = options?.expand !== false;
     }
-    *contents() {
-        yield this.renderable;
-    }
     *render(rawOptions) {
         const options = withBoundedWidth(rawOptions, this);
         // `expand` decides how wide the block is, never whether its rows reach