@promptctl/rich-js 0.18.0 → 0.19.0

package/dist/core/style.js

@@ -0,0 +1,758 @@
+/**
+ * Immutable style descriptors — colors, text attributes, links, metadata.
+ */
+import { COLOR_NAMES, ColorSpec, SURFACE_BLACK, } from "./color.js";
+import { shiftAnchor } from "./anchor.js";
+import { Memo } from "./memo.js";
+// [LAW:one-way-deps] `core/style` depends only on `core/color`. The substrate
+// a translucent colour is flattened over is `SURFACE_BLACK`, defined beside
+// `compositeOver`.
+// --- Attribute definitions ---
+/**
+ * Canonical text-attribute inventory. Single source of truth consumed by
+ * `Style.parse` / `Style.toString` and the template bindings — adding an
+ * attribute here propagates to every styling surface without a second
+ * list to keep in sync. [LAW:one-source-of-truth]
+ */
+export const ATTRIBUTE_NAMES = [
+    "bold",
+    "dim",
+    "italic",
+    "underline",
+    "blink",
+    "blink2",
+    "reverse",
+    "conceal",
+    "strike",
+    "underline2",
+    "frame",
+    "encircle",
+    "overline",
+];
+// The SGR parameter that turns each attribute on. `ansi.ts` reads it back.
+export const ATTRIBUTE_SGR = {
+    bold: 1,
+    dim: 2,
+    italic: 3,
+    underline: 4,
+    blink: 5,
+    blink2: 6,
+    reverse: 7,
+    conceal: 8,
+    strike: 9,
+    underline2: 21,
+    frame: 51,
+    encircle: 52,
+    overline: 53,
+};
+/**
+ * Canonical short-attribute aliases (`b` → `bold`, `i` → `italic`, …).
+ * Single source of truth consumed by `Style.parse` and the template
+ * bindings — adding an alias here makes it available everywhere.
+ * [LAW:one-source-of-truth]
+ */
+export const ATTRIBUTE_SHORT_ALIASES = {
+    b: "bold",
+    d: "dim",
+    i: "italic",
+    u: "underline",
+    s: "strike",
+    r: "reverse",
+    o: "overline",
+    uu: "underline2",
+};
+export class StyleSyntaxError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "StyleSyntaxError";
+    }
+}
+// [LAW:one-source-of-truth] The single source for parsed Style instances.
+const styleParseMemo = new Memo();
+// --- Style ---
+export class Style {
+    color;
+    bgcolor;
+    bold;
+    dim;
+    italic;
+    underline;
+    blink;
+    blink2;
+    reverse;
+    conceal;
+    strike;
+    underline2;
+    frame;
+    encircle;
+    overline;
+    link;
+    meta;
+    /**
+     * Where this style's cells sat in the output of whatever drew them; see
+     * `./anchor.ts`. It draws nothing, and it makes two styles that draw alike
+     * unequal, because they came from different places.
+     */
+    anchor;
+    constructor(options = {}) {
+        this.color = resolveColor(options.color);
+        this.bgcolor = resolveBackground(options.bgcolor);
+        this.bold = options.bold;
+        this.dim = options.dim;
+        this.italic = options.italic;
+        this.underline = options.underline;
+        this.blink = options.blink;
+        this.blink2 = options.blink2;
+        this.reverse = options.reverse;
+        this.conceal = options.conceal;
+        this.strike = options.strike;
+        this.underline2 = options.underline2;
+        this.frame = options.frame;
+        this.encircle = options.encircle;
+        this.overline = options.overline;
+        this.link = options.link;
+        this.meta = options.meta;
+        this.anchor = options.anchor;
+    }
+    get isNull() {
+        return (this.color === undefined &&
+            this.bgcolor === undefined &&
+            this.bold === undefined &&
+            this.dim === undefined &&
+            this.italic === undefined &&
+            this.underline === undefined &&
+            this.blink === undefined &&
+            this.blink2 === undefined &&
+            this.reverse === undefined &&
+            this.conceal === undefined &&
+            this.strike === undefined &&
+            this.underline2 === undefined &&
+            this.frame === undefined &&
+            this.encircle === undefined &&
+            this.overline === undefined &&
+            this.link === undefined &&
+            this.meta === undefined &&
+            this.anchor === undefined);
+    }
+    get transparentBackground() {
+        return this.bgcolor === undefined || this.bgcolor.isDefault;
+    }
+    get backgroundStyle() {
+        return new Style({ bgcolor: this.bgcolor });
+    }
+    /**
+     * This style with `overrides` in place of its own fields.
+     *
+     * [LAW:one-source-of-truth] The field list is the class's own fields, so a
+     * field added to `Style` is carried by every copy without being named here.
+     */
+    with(overrides) {
+        return new Style({ ...this, ...overrides });
+    }
+    get withoutColor() {
+        return this.with({ color: undefined, bgcolor: undefined });
+    }
+    // [LAW:types-are-the-program] Structural clone helper — pure rearrangement
+    // of fields, no policy. Sanitization of the URL is the trust boundary's
+    // job (see RichText in text.ts); Style stays a faithful container so
+    // callers that have already sanitized are not silently re-mutated.
+    withLink(link) {
+        return this.with({ link });
+    }
+    clearMetaAndLinks() {
+        return this.with({ link: undefined, meta: undefined });
+    }
+    /**
+     * The same look, drawn from the place `anchor` names, or from nowhere.
+     */
+    withAnchor(anchor) {
+        return this.with({ anchor });
+    }
+    /**
+     * This style on the cell `cells` to the right: its anchor shifted along its
+     * row, or the style itself when it has no anchor.
+     */
+    shiftedBy(cells) {
+        return this.anchor ? this.withAnchor(shiftAnchor(this.anchor, cells)) : this;
+    }
+    /**
+     * Merges two styles. `other`'s values take priority.
+     */
+    add(other) {
+        if (!other || other.isNull)
+            return this;
+        if (this.isNull)
+            return other;
+        return new Style({
+            color: other.color ?? this.color,
+            bgcolor: other.bgcolor ?? this.bgcolor,
+            bold: other.bold ?? this.bold,
+            dim: other.dim ?? this.dim,
+            italic: other.italic ?? this.italic,
+            underline: other.underline ?? this.underline,
+            blink: other.blink ?? this.blink,
+            blink2: other.blink2 ?? this.blink2,
+            reverse: other.reverse ?? this.reverse,
+            conceal: other.conceal ?? this.conceal,
+            strike: other.strike ?? this.strike,
+            underline2: other.underline2 ?? this.underline2,
+            frame: other.frame ?? this.frame,
+            encircle: other.encircle ?? this.encircle,
+            overline: other.overline ?? this.overline,
+            link: other.link ?? this.link,
+            meta: other.meta && this.meta
+                ? { ...this.meta, ...other.meta }
+                : other.meta ?? this.meta,
+            anchor: other.anchor ?? this.anchor,
+        });
+    }
+    equals(other) {
+        if (this === other)
+            return true;
+        return (this.color?.name === other.color?.name &&
+            this.bgcolor?.name === other.bgcolor?.name &&
+            this.bold === other.bold &&
+            this.dim === other.dim &&
+            this.italic === other.italic &&
+            this.underline === other.underline &&
+            this.blink === other.blink &&
+            this.blink2 === other.blink2 &&
+            this.reverse === other.reverse &&
+            this.conceal === other.conceal &&
+            this.strike === other.strike &&
+            this.underline2 === other.underline2 &&
+            this.frame === other.frame &&
+            this.encircle === other.encircle &&
+            this.overline === other.overline &&
+            this.link === other.link &&
+            anchorsEqual(this.anchor, other.anchor));
+    }
+    /**
+     * The colours this style puts on screen at `colorSystem`: each flattened
+     * onto what lies beneath it — the background onto the terminal's black, the
+     * foreground onto that background — then downgraded to the depth. The one
+     * account of what a style draws: `toSgrCodes` encodes exactly these, and a
+     * renderable choosing between two ways of drawing measures them.
+     */
+    drawnColors(colorSystem) {
+        // [LAW:dataflow-not-control-flow] Always resolve a substrate and flatten
+        // alpha before downgrade. Opaque colors short-circuit inside compositeOver,
+        // so the same code path runs every render — the alpha value is the data,
+        // not a branch.
+        const surface = SURFACE_BLACK;
+        const bgFlat = this.bgcolor?.flattenAlpha(surface);
+        const fgSubstrate = bgFlat?.getTruecolor(undefined, false) ?? surface;
+        const fgFlat = this.color?.flattenAlpha(fgSubstrate);
+        const at = (c) => colorSystem !== undefined ? c.downgrade(colorSystem) : c;
+        return {
+            color: fgFlat === undefined ? undefined : at(fgFlat),
+            bgcolor: bgFlat === undefined ? undefined : at(bgFlat),
+        };
+    }
+    /**
+     * Returns the SGR parameter list this style emits (e.g. `"1;31;48;2;0;0;255"`),
+     * or `""` when the style has no SGR contribution. Excludes OSC 8 link bytes —
+     * links are not SGR. The segment encoder (`segmentToString`) wraps it in
+     * `\x1b[...m`; styled text reaches the wire only through that encoder.
+     *
+     * [LAW:one-source-of-truth] One computation of SGR codes.
+     */
+    toSgrCodes(colorSystem) {
+        if (this.isNull)
+            return "";
+        // Attributes, then foreground, then background: Python Rich 9d8f9a3's
+        // `_make_ansi_codes` order, so a byte pinned against the reference holds.
+        // An attribute set false writes nothing, as there. It overrides an
+        // inherited attribute when styles combine, and every styled run is written
+        // after a reset, so no off code is ever needed.
+        const drawn = this.drawnColors(colorSystem);
+        return [
+            ...ATTRIBUTE_NAMES.filter((name) => this[name] === true).map((name) => `${ATTRIBUTE_SGR[name]}`),
+            ...(drawn.color?.getAnsiCodes(true) ?? []),
+            ...(drawn.bgcolor?.getAnsiCodes(false) ?? []),
+        ].join(";");
+    }
+    /**
+     * Serializes to a canonical string that round-trips through `Style.parse()`.
+     */
+    toString() {
+        if (this.isNull)
+            return "none";
+        const parts = [];
+        // Negated attributes first
+        for (const name of ATTRIBUTE_NAMES) {
+            if (this[name] === false)
+                parts.push(`not ${name}`);
+        }
+        // Positive attributes
+        for (const name of ATTRIBUTE_NAMES) {
+            if (this[name] === true)
+                parts.push(name);
+        }
+        if (this.color)
+            parts.push(this.color.name);
+        if (this.bgcolor)
+            parts.push(`on ${this.bgcolor.name}`);
+        if (this.link)
+            parts.push(`link ${this.link}`);
+        return parts.join(" ") || "none";
+    }
+    // --- Static methods ---
+    static null() {
+        return NULL_STYLE;
+    }
+    static fromColor(color, bgcolor) {
+        return new Style({ color, bgcolor });
+    }
+    static fromMeta(meta) {
+        return new Style({ meta });
+    }
+    static pickFirst(...args) {
+        for (const a of args) {
+            if (a !== undefined)
+                return a;
+        }
+        throw new Error("All arguments are undefined");
+    }
+    static combine(styles) {
+        let result = NULL_STYLE;
+        for (const s of styles) {
+            if (s)
+                result = result.add(s);
+        }
+        return result;
+    }
+    static chain(...styles) {
+        return Style.combine(styles);
+    }
+    static normalize(definition) {
+        return definition.trim().replace(/\s+/g, " ");
+    }
+    /**
+     * Parse a space-separated style definition. Memoized (`Memo`).
+     *
+     * A definition only: `"bold red"` parses, `"repr.number"` does not. Names
+     * belong to a `Theme`, and `Theme.resolve` is where one is looked up.
+     */
+    static parse(definition) {
+        const normalized = Style.normalize(definition);
+        if (normalized === "" || normalized === "none")
+            return NULL_STYLE;
+        return styleParseMemo.get(normalized, parseStyleDefinition);
+    }
+}
+export const NULL_STYLE = new Style();
+// --- StyleStack ---
+export class StyleStack {
+    stack;
+    constructor(base = NULL_STYLE) {
+        this.stack = [base];
+    }
+    get current() {
+        return this.stack[this.stack.length - 1];
+    }
+    push(style) {
+        this.stack.push(this.current.add(style));
+    }
+    pop() {
+        if (this.stack.length <= 1) {
+            throw new Error("Cannot pop the base style from StyleStack");
+        }
+        return this.stack.pop();
+    }
+}
+// --- Theme ---
+const STYLE_NAME_RE = /^[a-z][a-z0-9._-]*$/;
+/**
+ * `over` added to `base`, the outer style winning as `Style.add` has it. A
+ * `Style` base takes the addition now, and so does `""`, the definition that
+ * adds nothing; any other string keeps it as a `LayeredStyle` for the render
+ * that resolves the string.
+ */
+export function layerStyle(base, over) {
+    if (base instanceof Style)
+        return base.add(over);
+    if (base === "")
+        return over;
+    if (typeof base === "string")
+        return { under: base, over };
+    return { under: base.under, over: base.over.add(over) };
+}
+export class Theme {
+    styles;
+    constructor(definitions = {}, options) {
+        this.styles = new Map();
+        const inherit = options?.inherit !== false;
+        if (inherit) {
+            for (const [name, style] of Object.entries(DEFAULT_STYLES)) {
+                this.styles.set(name, style);
+            }
+        }
+        for (const [name, def] of Object.entries(definitions)) {
+            if (!STYLE_NAME_RE.test(name)) {
+                throw new Error(`Invalid style name: "${name}" (must be lowercase, start with letter, contain only letters, digits, ".", "-", "_")`);
+            }
+            this.styles.set(name, Style.parse(def));
+        }
+    }
+    get(name) {
+        return this.styles.get(name);
+    }
+    /**
+     * The style a `TextStyle` stands for under this theme: a name this theme
+     * defines, otherwise a definition for `Style.parse`, which throws
+     * `StyleSyntaxError` when the string is neither. A `LayeredStyle` is its
+     * `under` resolved here with its `over` added on top.
+     *
+     * [LAW:one-source-of-truth] The theme is the one map from names to styles.
+     * The lookup stays outside `Style.parse`'s process-wide cache on purpose:
+     * cached there, the first console to resolve `repr.number` would decide it
+     * for every console after it, whatever theme each was given.
+     */
+    resolve(style) {
+        if (style instanceof Style)
+            return style;
+        if (typeof style !== "string")
+            return this.resolve(style.under).add(style.over);
+        return this.styles.get(style) ?? Style.parse(style);
+    }
+    has(name) {
+        return this.styles.has(name);
+    }
+}
+// --- Parse helpers ---
+const ATTRIBUTE_SET = new Set(ATTRIBUTE_NAMES);
+// The words each position of a definition can hold: a bare token is a keyword,
+// an attribute or a colour name; `on` takes a colour name; `not` an attribute.
+// The short aliases are left out, since `b` is no help to someone who typed
+// `bolt` and a one-letter name sits one edit from every other short word.
+// [LAW:one-source-of-truth] Derived from the lists the parser accepts from; the
+// keywords are the three `parseStyleDefinition` reads before anything else.
+const FOREGROUND_WORDS = ["not", "on", "link", ...ATTRIBUTE_NAMES, ...COLOR_NAMES];
+/**
+ * Optimal string alignment distance: insertions, deletions, substitutions, and
+ * swaps of two neighbouring letters each cost one edit, so `cyna` is as near
+ * `cyan` as `rd` is to `red`. Kept to three rows, since only the two before the
+ * current one are ever read.
+ */
+function editDistance(a, b) {
+    let before = [];
+    let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const swap = i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1];
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + Number(a[i - 1] !== b[j - 1]), swap ? before[j - 2] + 1 : Infinity);
+        }
+        [before, previous] = [previous, current];
+    }
+    return previous[b.length];
+}
+/**
+ * The ` (did you mean …?)` clause for a word no position accepted, or `""`
+ * when nothing in `words` is a plausible typo of it.
+ *
+ * Plausible means within one edit per three letters, at least one, which lets
+ * `rd` reach `red` and keeps `hello` from reaching `yellow`. Every name tied
+ * for nearest is offered: `gold` is one edit from `bold` and from three
+ * `goldN` colours, and choosing among them would be a guess the reader cannot
+ * tell from a finding. Case is not an edit, because the colour parser ignores
+ * it: `Cyna` is as near `cyan` as `cyna` is.
+ *
+ * This runs on every render that meets the bad style, since only successful
+ * parses are cached. Two words differ by at least their difference in length,
+ * so a name outside the budget on length alone is never measured — which is
+ * also what keeps a long garbage token from costing length × length per name.
+ */
+function nearMiss(word, words) {
+    const typed = word.toLowerCase();
+    const budget = Math.max(1, Math.floor(typed.length / 3));
+    const scored = words
+        .filter((name) => Math.abs(name.length - typed.length) <= budget)
+        .map((name) => ({ name, distance: editDistance(typed, name) }));
+    const nearest = Math.min(budget, ...scored.map((s) => s.distance));
+    const names = scored
+        .filter((s) => s.distance === nearest)
+        .map((s) => `"${s.name}"`)
+        .sort();
+    return names.length === 0 ? "" : ` (did you mean ${names.join(" or ")}?)`;
+}
+/**
+ * A style token read as a colour. The colour parser's own error is the reason
+ * the token failed, so it rides along twice: in the message, for a reader with
+ * only the text, and as `cause`, for code that wants the original error.
+ *
+ * [LAW:single-enforcer] Both colour positions in a definition rewrap here, and
+ * the near miss is named here rather than by the colour parser: only a
+ * definition knows whether the token could also have been an attribute.
+ */
+function parseStyleColor(token, failure, words) {
+    try {
+        return ColorSpec.parse(token);
+    }
+    catch (cause) {
+        throw new StyleSyntaxError(`${failure} "${token}"${nearMiss(token, words)}: ${String(cause)}`, {
+            cause,
+        });
+    }
+}
+function parseStyleDefinition(definition) {
+    const tokens = definition.split(/\s+/);
+    const opts = {};
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        // "not <attr>"
+        if (token === "not") {
+            i++;
+            const next = tokens[i];
+            if (!next) {
+                throw new StyleSyntaxError(`Expected attribute after "not" in style definition`);
+            }
+            const attrName = ATTRIBUTE_SHORT_ALIASES[next] ?? next;
+            if (!ATTRIBUTE_SET.has(attrName)) {
+                throw new StyleSyntaxError(`Invalid attribute: "${next}"${nearMiss(next, ATTRIBUTE_NAMES)}`);
+            }
+            opts[attrName] = false;
+            i++;
+            continue;
+        }
+        // "on <color>"
+        if (token === "on") {
+            i++;
+            const next = tokens[i];
+            if (!next) {
+                throw new StyleSyntaxError(`Expected color after "on" in style definition`);
+            }
+            opts.bgcolor = parseStyleColor(next, "Invalid background color", COLOR_NAMES);
+            i++;
+            continue;
+        }
+        // "link <url>"
+        if (token === "link") {
+            i++;
+            const url = tokens[i];
+            if (url) {
+                opts.link = url;
+            }
+            i++;
+            continue;
+        }
+        // Attribute (full name)
+        const resolvedAttr = ATTRIBUTE_SHORT_ALIASES[token] ?? token;
+        if (ATTRIBUTE_SET.has(resolvedAttr)) {
+            opts[resolvedAttr] = true;
+            i++;
+            continue;
+        }
+        // Must be a color
+        opts.color = parseStyleColor(token, "Invalid style definition", FOREGROUND_WORDS);
+        i++;
+    }
+    return new Style(opts);
+}
+function resolveColor(c) {
+    if (c === undefined)
+        return undefined;
+    if (c instanceof ColorSpec)
+        return c;
+    return ColorSpec.parse(c);
+}
+// A fully transparent background draws nothing over whatever lies beneath it,
+// so it is no background: a style added on top of another keeps that one's,
+// which is what Textual's `#00000000` means. A transparent foreground is not
+// the same, it draws its glyph in whatever lies beneath it — the background,
+// or `SURFACE_BLACK` when there is none — so it stays a colour.
+function resolveBackground(c) {
+    const spec = resolveColor(c);
+    return spec?.value?.alpha === 0 ? undefined : spec;
+}
+// --- DEFAULT_STYLES ---
+// [LAW:one-source-of-truth] Single canonical mapping of semantic names to styles
+export const DEFAULT_STYLES = {
+    none: NULL_STYLE,
+    reset: new Style({
+        color: ColorSpec.default(),
+        bgcolor: ColorSpec.default(),
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false,
+        blink: false,
+        blink2: false,
+        reverse: false,
+        conceal: false,
+        strike: false,
+        underline2: false,
+        frame: false,
+        encircle: false,
+        overline: false,
+    }),
+    bold: new Style({ bold: true }),
+    dim: new Style({ dim: true }),
+    italic: new Style({ italic: true }),
+    underline: new Style({ underline: true }),
+    blink: new Style({ blink: true }),
+    blink2: new Style({ blink2: true }),
+    reverse: new Style({ reverse: true }),
+    conceal: new Style({ conceal: true }),
+    strike: new Style({ strike: true }),
+    underline2: new Style({ underline2: true }),
+    frame: new Style({ frame: true }),
+    encircle: new Style({ encircle: true }),
+    overline: new Style({ overline: true }),
+    // Table
+    "table.header": new Style({ bold: true }),
+    "table.footer": new Style({ bold: true }),
+    "table.cell": NULL_STYLE,
+    "table.title": new Style({ italic: true }),
+    "table.caption": new Style({ italic: true, dim: true }),
+    // Repr/highlighting — Rich 15.0.0's `rich.default_styles`, in its order
+    "repr.ellipsis": Style.parse("yellow"),
+    "repr.indent": Style.parse("dim green"),
+    "repr.error": Style.parse("bold red"),
+    "repr.str": Style.parse("not bold not italic green"),
+    "repr.brace": Style.parse("bold"),
+    "repr.comma": Style.parse("bold"),
+    "repr.ipv4": Style.parse("bold bright_green"),
+    "repr.ipv6": Style.parse("bold bright_green"),
+    "repr.eui48": Style.parse("bold bright_green"),
+    "repr.eui64": Style.parse("bold bright_green"),
+    "repr.tag_start": Style.parse("bold"),
+    "repr.tag_name": Style.parse("bold bright_magenta"),
+    "repr.tag_contents": Style.parse("default"),
+    "repr.tag_end": Style.parse("bold"),
+    "repr.attrib_name": Style.parse("not italic yellow"),
+    "repr.attrib_equal": Style.parse("bold"),
+    "repr.attrib_value": Style.parse("not italic magenta"),
+    "repr.number": Style.parse("bold not italic cyan"),
+    "repr.number_complex": Style.parse("bold not italic cyan"),
+    "repr.bool_true": Style.parse("italic bright_green"),
+    "repr.bool_false": Style.parse("italic bright_red"),
+    "repr.none": Style.parse("italic magenta"),
+    "repr.url": Style.parse("not bold not italic underline bright_blue"),
+    "repr.uuid": Style.parse("not bold bright_yellow"),
+    "repr.call": Style.parse("bold magenta"),
+    "repr.path": Style.parse("magenta"),
+    "repr.filename": Style.parse("bright_magenta"),
+    // Log
+    "log.time": Style.parse("cyan dim"),
+    "log.message": NULL_STYLE,
+    "log.path": Style.parse("dim"),
+    "log.line_no": Style.parse("cyan"),
+    "log.level": NULL_STYLE,
+    // Rule
+    "rule.line": Style.parse("green"),
+    "rule.text": Style.parse("bold"),
+    // JSON
+    "json.brace": Style.parse("bold"),
+    "json.bool_true": Style.parse("italic bright_green"),
+    "json.bool_false": Style.parse("italic bright_red"),
+    "json.key": Style.parse("bold blue"),
+    "json.null": Style.parse("italic magenta"),
+    "json.number": Style.parse("bold not italic cyan"),
+    "json.str": Style.parse("not bold not italic green"),
+    // Syntax
+    "syntax.keyword": Style.parse("bold magenta"),
+    "syntax.constant": Style.parse("italic bright_magenta"),
+    "syntax.string": Style.parse("green"),
+    "syntax.number": Style.parse("cyan"),
+    "syntax.comment": Style.parse("dim italic"),
+    "syntax.line_number": Style.parse("dim"),
+    // Ink and ground both from the fixed 256-colour greys: the terminal theme's
+    // own foreground is dark on a light theme and would vanish on grey27. At 16
+    // colours `Syntax` draws it without the pair (`groundedStyle`).
+    "syntax.line_number.highlight": Style.parse("bold grey93 on grey27"),
+    // Markdown
+    "markdown.h1": Style.parse("bold underline"),
+    "markdown.h2": Style.parse("bold"),
+    "markdown.h3": Style.parse("bold dim"),
+    "markdown.h4": Style.parse("bold dim italic"),
+    // A fixed cyan, not the theme's: `cyan` is dark enough on some themes to
+    // sink into grey11. Bold, as Rich's is: at 16 colours a renderable draws it
+    // without its pair (`groundedStyle`), and bold is what still marks code.
+    "markdown.code": Style.parse("bold dark_turquoise on grey11"),
+    "markdown.hr": Style.parse("yellow"),
+    "markdown.link": Style.parse("bright_blue"),
+    "markdown.link_url": Style.parse("blue"),
+    // Progress
+    "progress.description": NULL_STYLE,
+    "progress.percentage": Style.parse("cyan"),
+    "progress.remaining": Style.parse("cyan"),
+    "progress.elapsed": Style.parse("cyan"),
+    "progress.spinner": Style.parse("green"),
+    "progress.download": Style.parse("green"),
+    "progress.filesize": Style.parse("green"),
+    "progress.filesize.total": Style.parse("green"),
+    "progress.data.speed": Style.parse("red"),
+    // Bar
+    "bar.back": Style.parse("grey23"),
+    "bar.complete": Style.parse("magenta"),
+    "bar.finished": Style.parse("green"),
+    "bar.pulse": Style.parse("magenta"),
+    // Scrollbar
+    "scrollbar.thumb": NULL_STYLE,
+    "scrollbar.track": Style.parse("grey37"),
+    // Tree
+    "tree": NULL_STYLE,
+    "tree.guide": NULL_STYLE,
+    // Status
+    "status.spinner": Style.parse("green"),
+    "status.message": NULL_STYLE,
+    // Prompt
+    "prompt": NULL_STYLE,
+    "prompt.choices": Style.parse("bold magenta"),
+    "prompt.default": Style.parse("bold cyan"),
+    "prompt.invalid": Style.parse("red"),
+    "prompt.invalid.choice": Style.parse("red"),
+    // Inspect
+    "inspect.attr": Style.parse("yellow italic"),
+    "inspect.attr.dunder": Style.parse("yellow italic dim"),
+    "inspect.callable": Style.parse("bold magenta"),
+    "inspect.error": Style.parse("bold red"),
+    "inspect.help": Style.parse("cyan"),
+    "inspect.doc": Style.parse("dim"),
+    "inspect.value.border": Style.parse("green"),
+    // Traceback
+    "traceback.border": Style.parse("red"),
+    "traceback.text": Style.parse("red"),
+    "traceback.title": Style.parse("bold red"),
+    "traceback.exc_type": Style.parse("bold bright_red"),
+    "traceback.exc_value": NULL_STYLE,
+    "traceback.offset": Style.parse("bold bright_red"),
+    // Scope
+    "scope.border": Style.parse("blue"),
+    "scope.key": Style.parse("italic"),
+    "scope.key.special": Style.parse("dim italic"),
+    // Pretty
+    "pretty": NULL_STYLE,
+    // ISO8601
+    "iso8601.date": Style.parse("blue"),
+    "iso8601.time": Style.parse("magenta"),
+    "iso8601.timezone": Style.parse("yellow"),
+    // The parts ISO8601Highlighter lays inside a date or time. Rich's theme names
+    // none of them, so they draw nothing; they are here so a theme can set them
+    // and so none reaches `onStyleError` as an unknown name.
+    "iso8601.year": NULL_STYLE,
+    "iso8601.month": NULL_STYLE,
+    "iso8601.day": NULL_STYLE,
+    "iso8601.week": NULL_STYLE,
+    "iso8601.hour": NULL_STYLE,
+    "iso8601.minute": NULL_STYLE,
+    "iso8601.second": NULL_STYLE,
+    "iso8601.frac": NULL_STYLE,
+    "iso8601.ms": NULL_STYLE,
+    "iso8601.hyphen": NULL_STYLE,
+};
+/**
+ * The theme a render resolves names against when nothing supplied one — what
+ * a renderable sees outside a `Console`, as in `renderToString`.
+ */
+export const DEFAULT_THEME = new Theme();
+function anchorsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.owner === b.owner && a.row === b.row && a.col === b.col && anchorsEqual(a.inner, b.inner);
+}