@promptctl/rich-js 0.24.1 → 0.25.0

package/dist/core/ansi.js

@@ -51,10 +51,10 @@ import { RichText } from "./text.js";
  * and one final byte (`\x1b(B`, `\x1b)0`, `\x1b#8`, `\x1bc`). Only the first
  * three become tokens.
  */
-const ESCAPE = /\r|\x1b\[([0-9;:]*)m|\x1b\[([012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[\]P_^X][\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[ -/]*[0-~]/g;
+const escapes = () => /\r|\x1b\[([0-9;:]*)m|\x1b\[([012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[\]P_^X][\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[ -/]*[0-~]/g;
 function* escapeTokens(bytes) {
     let at = 0;
-    for (const match of bytes.matchAll(ESCAPE)) {
+    for (const match of bytes.matchAll(escapes())) {
         if (match.index > at)
             yield { kind: "text", text: bytes.slice(at, match.index) };
         if (match[0] === "\r")

package/dist/core/box.d.ts

@@ -28,19 +28,19 @@ import { Segment } from "./segment.js";
 import type { Style } from "./style.js";
 /** A rule spanning the table: the top and bottom borders, and every separator. */
 export interface EdgeChars {
-    left: string;
-    horizontal: string;
-    cross: string;
-    right: string;
+    readonly left: string;
+    readonly horizontal: string;
+    readonly cross: string;
+    readonly right: string;
 }
 /**
  * The verticals framing a row of cells. A content line of the grid has no
  * horizontal of its own — its fill column is a placeholder the cells occupy.
  */
 export interface ContentChars {
-    left: string;
-    vertical: string;
-    right: string;
+    readonly left: string;
+    readonly vertical: string;
+    readonly right: string;
 }
 export type RowLevel = "head" | "row" | "foot" | "mid";
 export interface SubstituteOptions {

package/dist/core/cells.d.ts

@@ -96,6 +96,22 @@ export declare function cutCells(text: string, positions: readonly CellCol[]): s
  * 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
@@ -110,6 +126,13 @@ export declare function splitAtCells(line: string, cuts: readonly CellCol[]): st
  * 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
@@ -132,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

@@ -3,11 +3,16 @@
  */
 import { codePointWidth, widensToEmoji } from "./cell-widths.js";
 import { Memo } from "./memo.js";
+import { pattern } from "./pattern.js";
 const cellLenMemo = new Memo();
 const ZWJ = 0x200d;
 const VS16 = 0xfe0f;
-const JOINERS = /[\u200d\ufe0f]/;
-const PRINTABLE_ASCII = /^[ -~]*$/;
+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
@@ -48,7 +53,7 @@ function measure(text) {
     if (!JOINERS.test(text))
         return richCells(text);
     let cells = 0;
-    for (const { segment } of graphemeSegmenter().segment(text))
+    for (const { segment } of SEGMENTER.segment(text))
         cells += richCells(segment);
     return cells;
 }
@@ -185,14 +190,38 @@ export function cutCells(text, positions) {
 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
@@ -214,21 +243,6 @@ 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;
-function graphemeSegmenter() {
-    return (segmenter ??= new Intl.Segmenter(undefined, { granularity: "grapheme" }));
-}
-/** The grapheme segmentation of `text`, reusing the last one when it is the same string. */
-function segmentsOf(text) {
-    if (lastSegmented?.text !== text) {
-        lastSegmented = { text, segments: graphemeSegmenter().segment(text) };
-    }
-    return lastSegmented.segments;
-}
 /**
  * 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
@@ -237,20 +251,33 @@ function segmentsOf(text) {
  * 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
@@ -265,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) {
@@ -292,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
@@ -328,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
@@ -340,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()));

package/dist/core/console.d.ts

@@ -59,6 +59,15 @@ export interface ConsoleOptions {
      * renderable this console draws. Default false.
      */
     asciiOnly?: boolean;
+    /**
+     * The reader asked for reduced motion: every animation this console draws
+     * — through `print`, a `Live` or an `App` — is drawn with its motion taken
+     * out, waking its host only where content changes
+     * (`RenderOptions.reducedMotion`). A preference of the
+     * person at the terminal, which no terminal reports, so the program hands
+     * it in; nothing here reads the environment for it. Default false.
+     */
+    reducedMotion?: boolean;
     /**
      * Static width (cells). Ignored when `getSize` is provided. Falls back to
      * the `COLUMNS` env var / the bound stream's `columns` / 80.
@@ -127,24 +136,25 @@ export interface PrintOptions {
 }
 export declare class Console {
     private readonly _destination;
-    private _getSize;
+    private readonly _getSize;
     private readonly _getDatetime;
-    private _lastLogTime;
-    private _style;
-    private _isTerminal;
+    private readonly _lastLogTime;
+    private readonly _style;
+    private readonly _isTerminal;
     private readonly _interactive;
-    private _file;
-    private _stream;
-    private _record;
-    private _markup;
-    private _highlight;
-    private _theme;
-    private _onStyleError;
+    private readonly _file;
+    private readonly _stream;
+    private readonly _record;
+    private readonly _markup;
+    private readonly _highlight;
+    private readonly _theme;
+    private readonly _onStyleError;
     private readonly _asciiOnly;
-    private _highlighter;
-    private _recorded;
-    private _capture;
-    private _liveRegion;
+    private readonly _highlighter;
+    private readonly _recorded;
+    private readonly _capture;
+    private readonly _liveRegion;
+    private readonly _madeIn;
     constructor(options?: ConsoleOptions);
     get size(): {
         width: number;
@@ -156,8 +166,9 @@ export declare class Console {
     get isInteractive(): boolean;
     get colorSystem(): ColorDepth | null;
     /**
-     * Where this console writes: the colour depth it draws at and whether it
-     * emits OSC 8 hyperlinks, overrides applied — the value its output is
+     * Where this console writes: the colour depth it draws at, whether it
+     * emits OSC 8 hyperlinks, and whether its reader asked for reduced motion,
+     * overrides applied — the value its output is
      * encoded for, for anything that encodes on its behalf (`Live`).
      */
     get destination(): Destination;