@promptctl/rich-js 0.24.0 → 0.25.0

package/dist/core/cells.d.ts

@@ -1,6 +1,5 @@
 /**
- * Terminal cell width calculation.
- * Handles ASCII, CJK (double-width), and emoji characters.
+ * Terminal cell width calculation: Rich's `cell_len`, ported.
  */
 /**
  * Returns the terminal cell width of a string.
@@ -72,13 +71,20 @@ export declare function setCellSize(text: string, totalWidth: CellCol): string;
  */
 export declare function splitText(text: string, position: CellCol): [string, string];
 /**
- * Cuts `text` into exactly `position` cells and the rest, as the reference's
- * `Segment.split_cells` does: a wide glyph the cut goes through fits neither
- * side, so it leaves a space in each of its cells, where `splitText` keeps it
- * whole on the right. Every other character lands on exactly one side.
- * `position` must fall inside `text`, between 0 and its width.
+ * Cuts `text` at each of `positions`, as the reference's `Segment.split_cells`
+ * cuts at one: a wide glyph a cut goes through fits neither side, so it leaves
+ * a space in each of its cells, where `splitText` keeps it whole on the right.
+ * Every other character lands in exactly one piece, so each piece is exactly
+ * as wide as the distance between its cuts. `positions` are non-decreasing and
+ * fall inside `text`: from 0 to one short of its width.
+ *
+ * One walk over `text` however many positions there are, ending at the last
+ * of them: cutting what is left again at every position re-measures and copies
+ * the rest each time, which is quadratic in a long enough string, and walking
+ * past the last position makes one cut near the start of a long string pay for
+ * all of it.
  */
-export declare function cutCells(text: string, position: CellCol): [string, string];
+export declare function cutCells(text: string, positions: readonly CellCol[]): string[];
 /**
  * Wraps text into lines of at most `maxWidth` cells, preserving every code
  * point: `chopCells(t, w).join("") === t`. Unlike `splitText` this never pads,
@@ -90,6 +96,22 @@ export declare function cutCells(text: string, position: CellCol): [string, stri
  * or less is no budget at all, so the text comes back as one line.
  */
 export declare function chopCells(text: string, maxWidth: CellCol): string[];
+/**
+ * `text` cut into rows in one walk over its clusters, row `i` holding as many
+ * whole glyphs as fit in `capOf(i)` cells. A row's first glyph is taken even
+ * when it is wider than the budget, overflowing it by its own width, so every
+ * row is past the last and a loop over the rows ends by construction.
+ *
+ * [LAW:single-enforcer] `cellFit` leaves its caller to choose between
+ * force-taking and skipping; this is that choice, made once. Made twice, the
+ * copies drifted — the textarea's soft wrap force-took, `chopCells` did
+ * neither and hung. And the rows are cut in one walk because a row at a time,
+ * each segmenting the text again, is quadratic in a long word.
+ */
+export declare function cellRows(text: string, capOf: (row: number) => CellCol): Generator<{
+    start: CodePoint;
+    end: CodePoint;
+}>;
 /**
  * `line` split at each of `cuts`, in one walk over it. Converting each cut to a
  * code-unit offset on its own rescans the line from the start every time, which
@@ -97,13 +119,20 @@ export declare function chopCells(text: string, maxWidth: CellCol): string[];
  */
 export declare function splitAtCells(line: string, cuts: readonly CellCol[]): string[];
 /**
- * The grapheme clusters of `text`, in order: the unit `string-width` measures,
- * and so the unit `cellLen` of a whole string is the sum of. Summing `cellLen`
- * over code points instead disagrees with it on every glyph built from several:
+ * The grapheme clusters of `text`, in order: the unit `cellLen` of a whole
+ * string is the sum of. Summing `cellLen` over code points instead disagrees
+ * with it on every glyph built from several:
  * `❤️` is 1 + 0 by code point and 2 as a cluster, `👨‍👩‍👧` is 6 and 2, and a cut
  * between two of its code points leaves half a glyph.
  */
 export declare function graphemes(text: string): string[];
+/**
+ * The clusters of `text` from code unit `start` on, lazily, so a walk that
+ * stops early pays only for the clusters it reads.
+ */
+export declare function clustersFrom(text: string, start: CodePoint): Generator<string>;
+/** `clustersFrom` backwards: the clusters of `text` before code unit `end`, nearest first. */
+export declare function clustersBefore(text: string, end: CodePoint): Generator<string>;
 /**
  * Returns the largest prefix of `text` whose cell width fits within `cap` cells,
  * cut between grapheme clusters. No padding — the returned string may be
@@ -126,19 +155,6 @@ export declare function cellFitEnd(text: string, cap: CellCol): string;
  * grapheme clusters, and every cluster boundary is a code-point boundary.
  */
 export declare function cellFitFrom(text: string, startCU: CodePoint, cap: CellCol): CodePoint;
-/**
- * Like `cellFitFrom`, but for any `startCU` inside `text` the result is
- * strictly past it: a glyph too wide for `cap` is force-taken whole and
- * overflows `cap` by its own width. So a `while (i < text.length)` loop driven
- * by this terminates by construction, and the re-brand is honest — both
- * operands land on code-point boundaries, so their max does too.
- *
- * [LAW:single-enforcer] `cellFit` documents that its caller must choose between
- * force-taking and skipping; this is that choice, made once. It was made twice
- * before and the copies drifted — the textarea's soft wrap force-took,
- * `chopCells` did neither and hung.
- */
-export declare function cellStepFrom(text: string, startCU: CodePoint, cap: CellCol): CodePoint;
 /**
  * The code-unit offset a visual column falls at: the end of the largest
  * prefix of `content` within `cellCol` cells, so a column inside a wide glyph

package/dist/core/cells.js

@@ -1,11 +1,62 @@
 /**
- * Terminal cell width calculation.
- * Handles ASCII, CJK (double-width), and emoji characters.
+ * Terminal cell width calculation: Rich's `cell_len`, ported.
  */
-import stringWidth from "string-width";
+import { codePointWidth, widensToEmoji } from "./cell-widths.js";
 import { Memo } from "./memo.js";
-// [LAW:one-source-of-truth] string-width is the single authority for cell width
+import { pattern } from "./pattern.js";
 const cellLenMemo = new Memo();
+const ZWJ = 0x200d;
+const VS16 = 0xfe0f;
+const JOINERS = pattern(/[\u200d\ufe0f]/);
+const PRINTABLE_ASCII = pattern(/^[ -~]*$/);
+// Segmented afresh on every call: a cursor's step costs a few microseconds
+// even in 10k code units, and a cache of segmentations would hold native
+// memory for every string it kept.
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+// Rich's `cell_len` over a run of text: each code point the cells Rich's table
+// gives it, but that a ZWJ takes the code point after it into the glyph before
+// so neither adds a cell, and VS16 widens the last code point measured to two
+// cells when the table lists it as one that emoji presentation widens.
+function richCells(text) {
+    let cells = 0;
+    let widenable = false;
+    let joined = false;
+    for (const ch of text) {
+        const codePoint = ch.codePointAt(0);
+        if (joined) {
+            joined = false;
+        }
+        else if (codePoint === ZWJ) {
+            joined = true;
+        }
+        else if (codePoint === VS16) {
+            cells += widenable ? 1 : 0;
+            widenable = false;
+        }
+        else {
+            const width = codePointWidth(codePoint);
+            cells += width;
+            widenable = width > 0 ? widensToEmoji(codePoint) : widenable;
+        }
+    }
+    return cells;
+}
+// [LAW:one-source-of-truth] the single authority for cell width. A string is
+// the sum of its grapheme clusters, each measured as Rich measures it, so a cut
+// between clusters splits the width exactly; the two part only where a ZWJ or
+// VS16 reaches across a cluster boundary, as in `a` ZWJ `b`, which Rich counts
+// as one cell and two clusters count as two. Without either, every code point
+// counts alone and no segmentation is needed.
+function measure(text) {
+    if (PRINTABLE_ASCII.test(text))
+        return text.length;
+    if (!JOINERS.test(text))
+        return richCells(text);
+    let cells = 0;
+    for (const { segment } of SEGMENTER.segment(text))
+        cells += richCells(segment);
+    return cells;
+}
 /**
  * Returns the terminal cell width of a string.
  */
@@ -13,7 +64,7 @@ export function cellLen(text) {
     if (text.length === 0)
         return 0;
     // Short strings recur (words, cells, labels); a long one is rarely measured twice.
-    return text.length <= 64 ? cellLenMemo.get(text, stringWidth) : stringWidth(text);
+    return text.length <= 64 ? cellLenMemo.get(text, measure) : measure(text);
 }
 /** Brand a raw number as a CellCol. Use only at trust boundaries. */
 export function asCellCol(n) { return n; }
@@ -82,22 +133,49 @@ export function splitText(text, position) {
     return [left + " ".repeat(position - cellLen(left)), text.slice(left.length)];
 }
 /**
- * Cuts `text` into exactly `position` cells and the rest, as the reference's
- * `Segment.split_cells` does: a wide glyph the cut goes through fits neither
- * side, so it leaves a space in each of its cells, where `splitText` keeps it
- * whole on the right. Every other character lands on exactly one side.
- * `position` must fall inside `text`, between 0 and its width.
+ * Cuts `text` at each of `positions`, as the reference's `Segment.split_cells`
+ * cuts at one: a wide glyph a cut goes through fits neither side, so it leaves
+ * a space in each of its cells, where `splitText` keeps it whole on the right.
+ * Every other character lands in exactly one piece, so each piece is exactly
+ * as wide as the distance between its cuts. `positions` are non-decreasing and
+ * fall inside `text`: from 0 to one short of its width.
+ *
+ * One walk over `text` however many positions there are, ending at the last
+ * of them: cutting what is left again at every position re-measures and copies
+ * the rest each time, which is quadratic in a long enough string, and walking
+ * past the last position makes one cut near the start of a long string pay for
+ * all of it.
  */
-export function cutCells(text, position) {
-    const head = cellFit(text, position);
-    // Cells of the glyph the cut goes through that lie left of it; 0 when the
-    // cut falls between glyphs, and then there is no such glyph.
-    const straddle = position - cellLen(head);
-    const [glyph = ""] = straddle > 0 ? clustersFrom(text, asCodePoint(head.length)) : [];
-    return [
-        head + " ".repeat(straddle),
-        " ".repeat(cellLen(glyph) - straddle) + text.slice(head.length + glyph.length),
-    ];
+export function cutCells(text, positions) {
+    const pieces = [];
+    // The current piece is `lead` blank cells, then `text` from `start` to `at`.
+    let start = 0;
+    let lead = 0;
+    let at = 0;
+    let col = 0;
+    let next = 0;
+    for (const glyph of clustersFrom(text, asCodePoint(0))) {
+        if (next === positions.length)
+            break;
+        const end = col + cellLen(glyph);
+        // The first cell of this glyph no piece has taken yet.
+        let from = col;
+        for (; next < positions.length && positions[next] < end; next++) {
+            const cut = positions[next];
+            pieces.push(" ".repeat(lead) + text.slice(start, at) + " ".repeat(cut - from));
+            lead = 0;
+            // A cut between glyphs leaves this one to the next piece; a cut through
+            // it blanks it, and the pieces after the cut start past it.
+            start = cut === col ? at : at + glyph.length;
+            from = cut;
+        }
+        if (from > col)
+            lead = end - from;
+        at += glyph.length;
+        col = end;
+    }
+    pieces.push(" ".repeat(lead) + text.slice(start));
+    return pieces;
 }
 /**
  * Wraps text into lines of at most `maxWidth` cells, preserving every code
@@ -112,14 +190,38 @@ export function cutCells(text, position) {
 export function chopCells(text, maxWidth) {
     if (maxWidth <= 0 || text.length === 0)
         return [text];
-    const lines = [];
-    let start = asCodePoint(0);
-    while (start < text.length) {
-        const end = cellStepFrom(text, start, maxWidth);
-        lines.push(text.slice(start, end));
-        start = end;
+    return Array.from(cellRows(text, () => maxWidth), ({ start, end }) => text.slice(start, end));
+}
+/**
+ * `text` cut into rows in one walk over its clusters, row `i` holding as many
+ * whole glyphs as fit in `capOf(i)` cells. A row's first glyph is taken even
+ * when it is wider than the budget, overflowing it by its own width, so every
+ * row is past the last and a loop over the rows ends by construction.
+ *
+ * [LAW:single-enforcer] `cellFit` leaves its caller to choose between
+ * force-taking and skipping; this is that choice, made once. Made twice, the
+ * copies drifted — the textarea's soft wrap force-took, `chopCells` did
+ * neither and hung. And the rows are cut in one walk because a row at a time,
+ * each segmenting the text again, is quadratic in a long word.
+ */
+export function* cellRows(text, capOf) {
+    let row = 0;
+    let start = 0;
+    let at = 0;
+    let cells = 0;
+    for (const glyph of clustersFrom(text, asCodePoint(0))) {
+        const width = cellLen(glyph);
+        if (at > start && cells + width > capOf(row)) {
+            yield { start: asCodePoint(start), end: asCodePoint(at) };
+            row += 1;
+            start = at;
+            cells = 0;
+        }
+        cells += width;
+        at += glyph.length;
     }
-    return lines;
+    if (at > start)
+        yield { start: asCodePoint(start), end: asCodePoint(at) };
 }
 /**
  * `line` split at each of `cuts`, in one walk over it. Converting each cut to a
@@ -141,41 +243,41 @@ export function splitAtCells(line, cuts) {
     }
     return [...pieces, line.slice(start)];
 }
-// [LAW:no-shared-mutable-globals] Private memos, written only by `segmentsOf`:
-// the segmenter, and the segmentation of the last string walked, so a caller
-// stepping along one string does not re-segment the whole of it every step.
-let segmenter;
-let lastSegmented;
-/** The grapheme segmentation of `text`, reusing the last one when it is the same string. */
-function segmentsOf(text) {
-    if (lastSegmented?.text !== text) {
-        segmenter ??= new Intl.Segmenter(undefined, { granularity: "grapheme" });
-        lastSegmented = { text, segments: segmenter.segment(text) };
-    }
-    return lastSegmented.segments;
-}
 /**
- * The grapheme clusters of `text`, in order: the unit `string-width` measures,
- * and so the unit `cellLen` of a whole string is the sum of. Summing `cellLen`
- * over code points instead disagrees with it on every glyph built from several:
+ * The grapheme clusters of `text`, in order: the unit `cellLen` of a whole
+ * string is the sum of. Summing `cellLen` over code points instead disagrees
+ * with it on every glyph built from several:
  * `❤️` is 1 + 0 by code point and 2 as a cluster, `👨‍👩‍👧` is 6 and 2, and a cut
  * between two of its code points leaves half a glyph.
  */
 export function graphemes(text) {
+    // Printable ASCII joins nothing, so each character is a cluster of its own
+    // and no segmentation is needed — the same reach `measure` makes.
+    if (PRINTABLE_ASCII.test(text))
+        return text.split("");
     return Array.from(clustersFrom(text, asCodePoint(0)));
 }
 /**
  * The clusters of `text` from code unit `start` on, lazily, so a walk that
  * stops early pays only for the clusters it reads.
  */
-function* clustersFrom(text, start) {
-    const segments = segmentsOf(text);
+export function* clustersFrom(text, start) {
+    const segments = SEGMENTER.segment(text);
     for (let at = start, s = segments.containing(at); s; s = segments.containing(at)) {
         const end = s.index + s.segment.length;
         yield text.slice(at, end);
         at = asCodePoint(end);
     }
 }
+/** `clustersFrom` backwards: the clusters of `text` before code unit `end`, nearest first. */
+export function* clustersBefore(text, end) {
+    const segments = SEGMENTER.segment(text);
+    for (let at = end; at > 0;) {
+        const { index } = segments.containing(at - 1);
+        yield text.slice(index, at);
+        at = asCodePoint(index);
+    }
+}
 /**
  * Returns the largest prefix of `text` whose cell width fits within `cap` cells,
  * cut between grapheme clusters. No padding — the returned string may be
@@ -190,7 +292,7 @@ export function cellFit(text, cap) {
 }
 /** `cellFit` from the other end: the largest suffix of `text` within `cap` cells. */
 export function cellFitEnd(text, cap) {
-    return text.slice(text.length - fitLength(graphemes(text).reverse(), cap));
+    return text.slice(text.length - fitLength(clustersBefore(text, asCodePoint(text.length)), cap));
 }
 /** The code units of the leading `clusters` that fit within `cap` cells. */
 function fitLength(clusters, cap) {
@@ -217,22 +319,6 @@ function fitLength(clusters, cap) {
 export function cellFitFrom(text, startCU, cap) {
     return asCodePoint(startCU + fitLength(clustersFrom(text, startCU), cap));
 }
-/**
- * Like `cellFitFrom`, but for any `startCU` inside `text` the result is
- * strictly past it: a glyph too wide for `cap` is force-taken whole and
- * overflows `cap` by its own width. So a `while (i < text.length)` loop driven
- * by this terminates by construction, and the re-brand is honest — both
- * operands land on code-point boundaries, so their max does too.
- *
- * [LAW:single-enforcer] `cellFit` documents that its caller must choose between
- * force-taking and skipping; this is that choice, made once. It was made twice
- * before and the copies drifted — the textarea's soft wrap force-took,
- * `chopCells` did neither and hung.
- */
-export function cellStepFrom(text, startCU, cap) {
-    const [first = ""] = clustersFrom(text, startCU);
-    return asCodePoint(Math.max(cellFitFrom(text, startCU, cap), startCU + first.length));
-}
 /**
  * The code-unit offset a visual column falls at: the end of the largest
  * prefix of `content` within `cellCol` cells, so a column inside a wide glyph
@@ -253,9 +339,8 @@ export function nextGrapheme(s, cu) {
 }
 /** `nextGrapheme` backwards: the start of the cluster ending at `cu`; 0 at the start. */
 export function prevGrapheme(s, cu) {
-    if (cu <= 0)
-        return asCodePoint(0);
-    return asCodePoint(segmentsOf(s).containing(cu - 1).index);
+    const [cluster = ""] = clustersBefore(s, cu);
+    return asCodePoint(cu - cluster.length);
 }
 /**
  * Where an offset into `s` comes to rest as a cursor: itself when it is a
@@ -265,7 +350,7 @@ export function prevGrapheme(s, cu) {
  */
 export function graphemeBoundary(s, cu) {
     const at = Math.min(cu, s.length);
-    const cluster = segmentsOf(s).containing(at);
+    const cluster = SEGMENTER.segment(s).containing(at);
     return asCodePoint(cluster === undefined || cluster.index === at ? at : cluster.index + cluster.segment.length);
 }
 /**

package/dist/core/clock.d.ts

@@ -46,8 +46,8 @@ export interface Clock {
      * Call `tick` once, when this clock reads `time` — as soon as it can for a
      * time already past — unless the returned function is called first. What
      * a host that knows when its frame next changes (`Segment.nextChange`)
-     * waits on. A `time` further off than a timer can wait, about 24.8 days,
-     * throws, as `frameRate` refuses the rate.
+     * waits on. A `time` that is not a finite number of seconds throws; one
+     * further off than a platform timer can wait is waited for in turns.
      */
     at(time: number, tick: () => void): Unsubscribe;
 }

package/dist/core/clock.js

@@ -40,9 +40,8 @@ export function systemClock() {
             return () => clearInterval(timer);
         },
         at: (time, tick) => {
-            if (!(time - now() <= LONGEST_INTERVAL)) {
-                throw new RangeError(`a clock waits at most ${LONGEST_INTERVAL} s, not until ${time} s from ${now()} s`);
-            }
+            if (!Number.isFinite(time))
+                throw new RangeError(`a clock waits until a finite number of seconds, not ${time}`);
             // [LAW:single-enforcer] A platform timer is due by a whole millisecond
             // of the event loop's own time, truncated, so it can run while this
             // clock still reads under `time` — by most of a millisecond. The
@@ -51,9 +50,12 @@ export function systemClock() {
             // again for what remains, so `tick` runs when `now()` has reached
             // `time` and not before. A host re-drawing at a frame's end would
             // otherwise draw the old frame again and wait again, every boundary.
+            // A wait longer than a timer holds is the same re-arming, one longest
+            // timer at a time, so a hold a slowed timeline stretches to months is
+            // waited out rather than refused.
             let timer;
             const arm = () => {
-                timer = setTimeout(() => (now() < time ? arm() : tick()), Math.ceil(Math.max(0, time - now()) * 1000));
+                timer = setTimeout(() => (now() < time ? arm() : tick()), Math.min(LONGEST_INTERVAL * 1000, Math.ceil(Math.max(0, time - now()) * 1000)));
             };
             arm();
             return () => clearTimeout(timer);

package/dist/core/color.d.ts

@@ -67,14 +67,13 @@ export declare function rgbDistance(a: ColorRgba, b: ColorRgba): number;
  */
 export declare class ColorTable {
     private readonly colors;
+    /** Each entry's relative luminance. */
+    private readonly luminances;
     readonly firstIndex: number;
     private readonly matchMemo;
     private readonly readableMemo;
-    constructor(colors: ColorRgba[], firstIndex?: number);
+    constructor(colors: readonly ColorRgba[], firstIndex?: number);
     get(index: number): ColorRgba;
-    private luminanceCache;
-    /** Each entry's relative luminance, computed once per table. */
-    private luminances;
     /** How many entries the table holds (terminal indices `firstIndex`…). */
     get size(): number;
     /**
@@ -150,13 +149,31 @@ export declare function detectColorSystem(options?: DetectColorOptions): ColorDe
 export declare function isDumbTerminal(env: Env): boolean;
 /**
  * Where segments are written, as everything the serializer (`segmentsToString`)
- * needs to know about it: the colour depth SGR is drawn at, and whether OSC 8
- * hyperlinks are emitted. The serializer takes this value whole, so a fact the
- * encoding comes to need joins it here rather than the serializer's signature.
+ * needs to know about it: the colour depth SGR is drawn at, whether OSC 8
+ * hyperlinks are emitted, and whether the reader there asked for reduced
+ * motion — under which the terminal's own blink is not asked for
+ * (`shownOn`, `./render.ts`). The serializer takes this value whole, so a
+ * fact the encoding comes to need joins it here rather than the serializer's
+ * signature.
  */
 export interface Destination {
     readonly colorSystem: ColorDepth | null;
     readonly hyperlinks: boolean;
+    /**
+     * The reader asked for reduced motion. A host draws for it with the same
+     * value as `RenderOptions.reducedMotion`, read off this field, so what is
+     * drawn and how it is encoded take one preference.
+     */
+    readonly reducedMotion: boolean;
+}
+/**
+ * What `resolveDestination` is told about where it writes beyond the colour
+ * spec: what detection probes, and the reader's preference for motion, which
+ * no spec or terminal reports, so the program hands it in. Absent, everything
+ * moves.
+ */
+export interface DestinationOptions extends DetectColorOptions {
+    reducedMotion?: boolean;
 }
 /**
  * Resolve a colour spec into a `Destination`.
@@ -168,7 +185,7 @@ export interface Destination {
  * colour preferences, leave them alone. A FORCE_COLOR that forces colour on
  * declares the destination takes escapes, so it keeps links on a pipe too.
  */
-export declare function resolveDestination(spec: ColorSystemName | ColorDepth | null, options?: DetectColorOptions): Destination;
+export declare function resolveDestination(spec: ColorSystemName | ColorDepth | null, options?: DestinationOptions): Destination;
 /**
  * Resolve a colour system name into a `ColorDepth` (or `null` for no color).
  *
@@ -187,7 +204,7 @@ export declare class ColorSpec {
     readonly type: ColorDepth;
     readonly number: number | undefined;
     readonly value: ColorRgba | undefined;
-    private downgradeCache;
+    private readonly downgrades;
     constructor(name: string, type: ColorDepth, number?: number, value?: ColorRgba);
     get isDefault(): boolean;
     /**
@@ -336,7 +353,7 @@ export declare function resolveTerminal(theme: TerminalTheme | undefined, depth:
  * writer rounds to those same indices.
  */
 export declare function downgradeTable(depth: ColorDepth.EIGHT_BIT | ColorDepth.STANDARD | ColorDepth.WINDOWS): ColorTable;
-export declare const ANSI_COLOR_NAMES: Record<string, number>;
+export declare const ANSI_COLOR_NAMES: Readonly<Record<string, number>>;
 /**
  * Every word `ColorSpec.parse` accepts as a name rather than a `#hex`,
  * `rgb()` or `color(N)` form: `default` and the named palette entries, which

package/dist/core/color.js

@@ -1,7 +1,7 @@
 /**
  * Terminal color representation, parsing, downgrading, and ANSI code generation.
  */
-import { Memo } from "./memo.js";
+import { Memo, WeakMemo } from "./memo.js";
 // --- ColorRgba ---
 function hex2(byte) {
     return byte.toString(16).padStart(2, "0");
@@ -129,23 +129,20 @@ export function rgbDistance(a, b) {
  */
 export class ColorTable {
     colors;
+    /** Each entry's relative luminance. */
+    luminances;
     firstIndex;
     // Keyed by colours a host computes without end (ramp stops, mixes), so bounded.
     matchMemo = new Memo();
     readableMemo = new Memo();
     constructor(colors, firstIndex = 0) {
         this.colors = colors;
+        this.luminances = colors.map(relativeLuminance);
         this.firstIndex = firstIndex;
     }
     get(index) {
         return this.colors[index - this.firstIndex];
     }
-    luminanceCache;
-    /** Each entry's relative luminance, computed once per table. */
-    luminances() {
-        this.luminanceCache ??= this.colors.map(relativeLuminance);
-        return this.luminanceCache;
-    }
     /** How many entries the table holds (terminal indices `firstIndex`…). */
     get size() {
         return this.colors.length;
@@ -192,7 +189,7 @@ export class ColorTable {
         let bestScore = -Infinity;
         for (let i = 0; i < this.colors.length; i++) {
             const c = this.colors[i];
-            const lc = this.luminances()[i];
+            const lc = this.luminances[i];
             const ratio = luminanceRatio(lc, lOn);
             const passes = ratio >= minRatio;
             // A passing entry scores by closeness; a failing one only by contrast,
@@ -376,17 +373,20 @@ function terminalColorSystem(options) {
  * colour preferences, leave them alone. A FORCE_COLOR that forces colour on
  * declares the destination takes escapes, so it keeps links on a pipe too.
  */
-export function resolveDestination(spec, options) {
+export function resolveDestination(spec, options = {}) {
+    const reducedMotion = options.reducedMotion ?? false;
     if (spec !== "auto") {
         return {
             colorSystem: typeof spec === "string" ? resolveColorSystem(spec) : spec,
             hyperlinks: true,
+            reducedMotion,
         };
     }
     return {
         colorSystem: detectColorSystem(options),
-        hyperlinks: (forcedColorSystem(envOf(options ?? {})) ?? null) !== null ||
-            terminalColorSystem(options ?? {}) !== null,
+        hyperlinks: (forcedColorSystem(envOf(options)) ?? null) !== null ||
+            terminalColorSystem(options) !== null,
+        reducedMotion,
     };
 }
 /**
@@ -419,7 +419,7 @@ export class ColorSpec {
     type;
     number;
     value;
-    downgradeCache = new Map();
+    downgrades = new Memo();
     constructor(name, type, number, value) {
         this.name = name;
         this.type = type;
@@ -518,12 +518,7 @@ export class ColorSpec {
             return this;
         if (this.type === targetSystem || fidelity(this.type) < fidelity(targetSystem))
             return this;
-        const cached = this.downgradeCache.get(targetSystem);
-        if (cached)
-            return cached;
-        const result = this.performDowngrade(targetSystem);
-        this.downgradeCache.set(targetSystem, result);
-        return result;
+        return this.downgrades.get(`${targetSystem}`, () => this.performDowngrade(targetSystem));
     }
     /**
      * Resolves to an actual RGB(A) value for any color type.
@@ -636,11 +631,7 @@ export class ColorSpec {
      * `matchOn` rounds to, but for the default, read off the same two tables.
      */
     static indexed(depth, theme) {
-        const byDepth = indexedMemo.get(theme) ?? new Map();
-        indexedMemo.set(theme, byDepth);
-        const listed = byDepth.get(depth) ?? listIndexed(depth, theme);
-        byDepth.set(depth, listed);
-        return listed;
+        return indexedMemo.get(theme, () => new Memo()).get(`${depth}`, () => listIndexed(depth, theme));
     }
     /**
      * The spec a slot is written in once its colour moves from `was`, what its
@@ -689,7 +680,7 @@ function cubeCandidate(value) {
     return [ColorSpec.fromAnsi(index), EIGHT_BIT_DOWNGRADE_TABLE.get(index)];
 }
 /** `ColorSpec.indexed`'s list, made once for each theme and depth. */
-const indexedMemo = new WeakMap();
+const indexedMemo = new WeakMemo();
 function listIndexed(depth, theme) {
     const slots = () => Array.from({ length: 16 }, (_, slot) => [new ColorSpec(`color(${slot})`, depth === ColorDepth.WINDOWS ? depth : ColorDepth.STANDARD, slot), theme.ansiColors.get(slot)]);
     switch (depth) {
@@ -736,11 +727,11 @@ class ColorBlend extends ColorSpec {
     }
 }
 // --- Parsing internals ---
-const RGB_RE = /^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/;
-const COLOR_NUMBER_RE = /^color\((\d+)\)$/;
-const BLEND_RE = /^blend\((.*)\)$/;
+const RGB_RE = pattern(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+const COLOR_NUMBER_RE = pattern(/^color\((\d+)\)$/);
+const BLEND_RE = pattern(/^blend\((.*)\)$/);
 // A decimal as `String(number)` spells one, exponent included; `blend` owns its range.
-const FRACTION_RE = /^\s*(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?\s*$/;
+const FRACTION_RE = pattern(/^\s*(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?\s*$/);
 function parseSingle(key) {
     if (key === "default" || key === "") {
         return ColorSpec.default();
@@ -817,7 +808,7 @@ function parseByte(key, digits, field) {
 // reference, a template argument — becomes one through the three parsers below,
 // and each is this check at the lengths it admits. Each digit pair is a byte, so
 // the grammar holding is what keeps `ColorRgba`'s channels in range.
-const HEX_DIGITS_RE = /^[0-9a-fA-F]+$/;
+const HEX_DIGITS_RE = pattern(/^[0-9a-fA-F]+$/);
 // Each admitted digit count, by the grammar it spells: the message a failure
 // carries is read off the lengths a parser admits, so the two cannot disagree.
 const HEX_GRAMMARS = { 6: "RRGGBB", 8: "RRGGBBAA" };
@@ -963,6 +954,7 @@ export const WINDOWS_TABLE = new ColorTable(buildWindowsTable());
 // Runtime-importing `Palette` from `themes/palette.ts` is safe: that module
 // only `import type`s from `core/color.ts`, so there is no runtime cycle.
 import { Palette } from "../themes/palette.js";
+import { pattern } from "./pattern.js";
 const INTERNAL_DEFAULT_THEME = new TerminalTheme(new ColorRgba(0, 0, 0), new ColorRgba(255, 255, 255), STANDARD_TABLE, new Palette("default", true, new Map()));
 /** The Windows console in its default Campbell scheme: a WINDOWS colour's terminal. */
 const WINDOWS_CONSOLE_THEME = new TerminalTheme(WINDOWS_TABLE.get(0), WINDOWS_TABLE.get(7), WINDOWS_TABLE, new Palette("windows", true, new Map()));