@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/themes/{transpose.d.ts → adjust.d.ts}

@@ -1,48 +1,48 @@
 /**
- * Transpose a Palette to a new "key" — analogous to transposing a melody.
+ * Adjust a Palette to a new "key" — analogous to adjusting a melody.
  *
  *   melody / chord progression  ::  Palette (relationships between colors)
- *                key (signature) ::  ThemeKey (hue / chroma / lightness deltas)
- *      "in C major" / "in D…"   ::  the resulting transposed Palette
+ *                key (signature) ::  ColorAdjustment (hue / chroma / lightness deltas)
+ *      "in C major" / "in D…"   ::  the resulting adjusted Palette
  *
  * Because OKLCH is perceptually uniform, "+30° hue" looks like a
  * consistent jump everywhere on the color wheel — the way a perfect-fifth
- * interval sounds the same in every musical key. Transposition is closed
- * under composition: `transpose(transpose(p, k1), k2)` produces the same
- * colors as a single transpose with the combined deltas, modulo round-trip
+ * interval sounds the same in every musical key. Adjustment is closed
+ * under composition: `adjust(adjust(p, k1), k2)` produces the same
+ * colors as a single adjust with the combined deltas, modulo round-trip
  * quantization.
  *
  * [LAW:dataflow-not-control-flow] A single uniform per-color transform
  * runs for every var in the palette. Anchor protection selects *which*
- * `ThemeKey` to apply (data), not *whether* to apply one (branch).
+ * `ColorAdjustment` to apply (data), not *whether* to apply one (branch).
  *
  * [LAW:one-source-of-truth] Anchor classification lives only in
- * `ANCHORED_ROOTS` below. Every variant of a semantic root carries the root
+ * `HUE_LOCKED_ROOTS` below. Every variant of a semantic root carries the root
  * as its first hyphen segment (`error`, `error-darken-1`, `error-muted`, ...)
  * or after a `text-` or `on-` that draws on it (`text-error`, `on-error`), so
  * one set covers the whole family.
  *
- * [LAW:one-way-deps] Imports flow `core/oklch → themes/transpose`;
+ * [LAW:one-way-deps] Imports flow `core/oklch → themes/adjust`;
  * nothing in core/ depends back on this file.
  */
-import { type ThemeKey } from "../core/oklch.js";
+import { type ColorAdjustment } from "../core/oklch.js";
 import { Palette } from "./palette.js";
 /**
- * Semantic roots whose hue is locked under transposition. `error` must
+ * Semantic roots whose hue is locked under adjustment. `error` must
  * look red-ish, `success` green-ish, `warning` amber-ish — rotating the
  * hue would make the UI lie about meaning. Lightness and chroma *still*
  * transform for these roles, so they invert correctly during dark↔light
  * flips and respond to chroma scaling alongside everything else.
  */
-export declare const ANCHORED_ROOTS: ReadonlySet<string>;
+export declare const HUE_LOCKED_ROOTS: ReadonlySet<string>;
 /**
- * Whether a palette var's hue is locked under transposition. The single
- * predicate used by `transposePalette`. Exported so callers building
+ * Whether a palette var's hue is locked under adjustment. The single
+ * predicate used by `adjustPalette`. Exported so callers building
  * higher-level theme machinery can stay consistent with the locking rule.
  */
-export declare function isAnchored(varName: string): boolean;
+export declare function isHueLocked(varName: string): boolean;
 /**
- * Return a new `Palette` whose colors are the transposition of `palette`'s
+ * Return a new `Palette` whose colors are the adjustment of `palette`'s
  * colors by `key`. Pure. Identity (`IDENTITY`) returns a Palette with byte-exact
  * colors — fast-pathed so identity does not pay the sRGB↔OKLCH round-trip
  * quantization cost.
@@ -57,12 +57,12 @@ export declare function isAnchored(varName: string): boolean;
  * The identity fast-path preserves the source `dark` flag verbatim.
  *
  * @param name Optional override for the resulting palette name. Defaults
- *   to the source palette's name. Callers building a family of transposed
+ *   to the source palette's name. Callers building a family of adjusted
  *   palettes (e.g. "gruvbox +60°") supply their own.
  */
-export declare function transposePalette(palette: Palette, key: ThemeKey, name?: string): Palette;
+export declare function adjustPalette(palette: Palette, key: ColorAdjustment, name?: string): Palette;
 /**
- * Build the `ThemeKey` that rotates `palette` so its *tonic* var lands on
+ * Build the `ColorAdjustment` that rotates `palette` so its *tonic* var lands on
  * `targetHueDeg`. The musical operation directly: a key is the set of
  * intervals from the tonic, so "play this theme in the key of <hue>" means
  * "shift every color by exactly the interval that carries the tonic's
@@ -70,13 +70,13 @@ export declare function transposePalette(palette: Palette, key: ThemeKey, name?:
  *
  * Returns a hue-only key (chroma and lightness untouched). Callers that also
  * want to scale chroma or shift lightness spread their own axes over the
- * result — those are independent transposition dimensions, not part of
+ * result — those are independent adjustment dimensions, not part of
  * choosing the key. [LAW:one-type-per-behavior] a degree-shift key and a
  * root-note key are the *same* transform; this is just a second constructor
- * for it, so `transposePalette` stays untouched.
+ * for it, so `adjustPalette` stays untouched.
  *
  * Throws if `tonicVar` is absent — the interval has no anchor to measure
  * from, so there is no honest key to return. Failing loudly beats inventing
- * a zero shift that would silently mean "no transposition."
+ * a zero shift that would silently mean "no adjustment."
  */
-export declare function themeKeyForRoot(palette: Palette, tonicVar: string, targetHueDeg: number): ThemeKey;
+export declare function adjustmentForRoot(palette: Palette, tonicVar: string, targetHueDeg: number): ColorAdjustment;

package/dist/themes/{transpose.js → adjust.js}

@@ -1,35 +1,35 @@
 /**
- * Transpose a Palette to a new "key" — analogous to transposing a melody.
+ * Adjust a Palette to a new "key" — analogous to adjusting a melody.
  *
  *   melody / chord progression  ::  Palette (relationships between colors)
- *                key (signature) ::  ThemeKey (hue / chroma / lightness deltas)
- *      "in C major" / "in D…"   ::  the resulting transposed Palette
+ *                key (signature) ::  ColorAdjustment (hue / chroma / lightness deltas)
+ *      "in C major" / "in D…"   ::  the resulting adjusted Palette
  *
  * Because OKLCH is perceptually uniform, "+30° hue" looks like a
  * consistent jump everywhere on the color wheel — the way a perfect-fifth
- * interval sounds the same in every musical key. Transposition is closed
- * under composition: `transpose(transpose(p, k1), k2)` produces the same
- * colors as a single transpose with the combined deltas, modulo round-trip
+ * interval sounds the same in every musical key. Adjustment is closed
+ * under composition: `adjust(adjust(p, k1), k2)` produces the same
+ * colors as a single adjust with the combined deltas, modulo round-trip
  * quantization.
  *
  * [LAW:dataflow-not-control-flow] A single uniform per-color transform
  * runs for every var in the palette. Anchor protection selects *which*
- * `ThemeKey` to apply (data), not *whether* to apply one (branch).
+ * `ColorAdjustment` to apply (data), not *whether* to apply one (branch).
  *
  * [LAW:one-source-of-truth] Anchor classification lives only in
- * `ANCHORED_ROOTS` below. Every variant of a semantic root carries the root
+ * `HUE_LOCKED_ROOTS` below. Every variant of a semantic root carries the root
  * as its first hyphen segment (`error`, `error-darken-1`, `error-muted`, ...)
  * or after a `text-` or `on-` that draws on it (`text-error`, `on-error`), so
  * one set covers the whole family.
  *
- * [LAW:one-way-deps] Imports flow `core/oklch → themes/transpose`;
+ * [LAW:one-way-deps] Imports flow `core/oklch → themes/adjust`;
  * nothing in core/ depends back on this file.
  */
 import { Oklch, isIdentityKey } from "../core/oklch.js";
 import { pattern } from "../core/pattern.js";
 import { Palette } from "./palette.js";
 /**
- * Semantic roots whose hue is locked under transposition. `error` must
+ * Semantic roots whose hue is locked under adjustment. `error` must
  * look red-ish, `success` green-ish, `warning` amber-ish — rotating the
  * hue would make the UI lie about meaning. Lightness and chroma *still*
  * transform for these roles, so they invert correctly during dark↔light
@@ -39,7 +39,7 @@ import { Palette } from "./palette.js";
 // enforcement — typed code cannot call `add`/`delete`. (`Object.freeze` is
 // not used here because it is a no-op on Set membership; relying on it would
 // imply a runtime guarantee it does not provide.)
-export const ANCHORED_ROOTS = new Set([
+export const HUE_LOCKED_ROOTS = new Set([
     "error",
     "success",
     "warning",
@@ -51,15 +51,15 @@ function rootOf(varName) {
     return dash === -1 ? role : role.slice(0, dash);
 }
 /**
- * Whether a palette var's hue is locked under transposition. The single
- * predicate used by `transposePalette`. Exported so callers building
+ * Whether a palette var's hue is locked under adjustment. The single
+ * predicate used by `adjustPalette`. Exported so callers building
  * higher-level theme machinery can stay consistent with the locking rule.
  */
-export function isAnchored(varName) {
-    return ANCHORED_ROOTS.has(rootOf(varName));
+export function isHueLocked(varName) {
+    return HUE_LOCKED_ROOTS.has(rootOf(varName));
 }
 /**
- * Return a new `Palette` whose colors are the transposition of `palette`'s
+ * Return a new `Palette` whose colors are the adjustment of `palette`'s
  * colors by `key`. Pure. Identity (`IDENTITY`) returns a Palette with byte-exact
  * colors — fast-pathed so identity does not pay the sRGB↔OKLCH round-trip
  * quantization cost.
@@ -74,23 +74,23 @@ export function isAnchored(varName) {
  * The identity fast-path preserves the source `dark` flag verbatim.
  *
  * @param name Optional override for the resulting palette name. Defaults
- *   to the source palette's name. Callers building a family of transposed
+ *   to the source palette's name. Callers building a family of adjusted
  *   palettes (e.g. "gruvbox +60°") supply their own.
  */
-export function transposePalette(palette, key, name) {
+export function adjustPalette(palette, key, name) {
     if (isIdentityKey(key)) {
-        return new Palette(name ?? palette.name, palette.dark, palette.mapRoles((colour) => colour));
+        return new Palette(name ?? palette.name, palette.dark, palette.mapRoles((color) => color));
     }
     // Anchors share *everything except* hue with the user's key. They still
     // lightness-invert in a dark↔light flip; they still chroma-scale in a
     // saturation sweep — only their hue is held.
     const anchorKey = { ...key, hueShift: 0 };
-    const next = palette.mapRoles((colour, role) => Oklch.fromRgba(colour).applyKey(isAnchored(role) ? anchorKey : key).toRgba());
+    const next = palette.mapRoles((color, role) => Oklch.fromRgba(color).applyKey(isHueLocked(role) ? anchorKey : key).toRgba());
     const newDark = Oklch.fromRgba(next.background).l < 0.5;
     return new Palette(name ?? palette.name, newDark, next);
 }
 /**
- * Build the `ThemeKey` that rotates `palette` so its *tonic* var lands on
+ * Build the `ColorAdjustment` that rotates `palette` so its *tonic* var lands on
  * `targetHueDeg`. The musical operation directly: a key is the set of
  * intervals from the tonic, so "play this theme in the key of <hue>" means
  * "shift every color by exactly the interval that carries the tonic's
@@ -98,26 +98,26 @@ export function transposePalette(palette, key, name) {
  *
  * Returns a hue-only key (chroma and lightness untouched). Callers that also
  * want to scale chroma or shift lightness spread their own axes over the
- * result — those are independent transposition dimensions, not part of
+ * result — those are independent adjustment dimensions, not part of
  * choosing the key. [LAW:one-type-per-behavior] a degree-shift key and a
  * root-note key are the *same* transform; this is just a second constructor
- * for it, so `transposePalette` stays untouched.
+ * for it, so `adjustPalette` stays untouched.
  *
  * Throws if `tonicVar` is absent — the interval has no anchor to measure
  * from, so there is no honest key to return. Failing loudly beats inventing
- * a zero shift that would silently mean "no transposition."
+ * a zero shift that would silently mean "no adjustment."
  */
-export function themeKeyForRoot(palette, tonicVar, targetHueDeg) {
+export function adjustmentForRoot(palette, tonicVar, targetHueDeg) {
     // Validate the numeric input at the boundary: a non-finite target would
     // propagate as NaN to Oklch's constructor several calls downstream, where
     // the error is far less actionable.
     if (!Number.isFinite(targetHueDeg)) {
-        throw new RangeError(`themeKeyForRoot: targetHueDeg must be a finite number; got ${targetHueDeg}`);
+        throw new RangeError(`adjustmentForRoot: targetHueDeg must be a finite number; got ${targetHueDeg}`);
     }
     const tonic = palette.get(tonicVar);
     if (tonic === undefined) {
-        throw new Error(`themeKeyForRoot: palette "${palette.name}" has no "${tonicVar}" var ` +
-            `to use as the tonic; cannot measure the transposition interval.`);
+        throw new Error(`adjustmentForRoot: palette "${palette.name}" has no "${tonicVar}" var ` +
+            `to use as the tonic; cannot measure the adjustment interval.`);
     }
     const tonicHue = Oklch.fromRgba(tonic).h;
     let hueShift = (targetHueDeg - tonicHue) % 360;

package/dist/themes/buildPalette.d.ts

@@ -21,13 +21,13 @@ export declare const BASE_KEYS: readonly BaseRole[];
 export declare const PALETTE_ROLES: readonly PaletteRole[];
 /**
  * Build a full semantic palette from its base colors and any other role it
- * states: a stated role keeps its colour, and everything derived from it
+ * states: a stated role keeps its color, and everything derived from it
  * follows it, but for `text-*`, which is held to read on its `*-muted`. An
  * authored theme is this with roles stated; see `RULES` for what a role
  * not stated becomes.
  *
- * A translucent colour is drawn onto `background` before anything is derived
- * from it, so `on-*` is chosen against the colour the accent is drawn as.
+ * A translucent color is drawn onto `background` before anything is derived
+ * from it, so `on-*` is chosen against the color the accent is drawn as.
  * `boost` alone stays a layer: it is what `panel` composites.
  */
 export declare function buildPalette(name: string, dark: boolean, given: StatedRoles): Palette;

package/dist/themes/buildPalette.js

@@ -24,9 +24,9 @@ const TEXT_ON_MUTED = 4.5;
 const ACCENT_KEYS = ["primary", "secondary", "accent", "success", "warning", "error"];
 const TRANSPARENT = new ColorRgba(0, 0, 0, 0);
 const WHITE = new ColorRgba(255, 255, 255);
-const withAlpha = (colour, alpha) => new ColorRgba(colour.red, colour.green, colour.blue, alpha);
+const withAlpha = (color, alpha) => new ColorRgba(color.red, color.green, color.blue, alpha);
 const textOn = (alpha) => (at) => withAlpha(contrastFor(at("background")), alpha);
-// [LAW:one-type-per-behavior] The roles naming another role's colour outright.
+// [LAW:one-type-per-behavior] The roles naming another role's color outright.
 const same = (role) => (at) => at(role);
 const none = () => TRANSPARENT;
 /** The six rungs around `root`, each `-darken-3`…`-lighten-3` one `LADDER_STEP` apart. */
@@ -58,7 +58,7 @@ function accentRules(accent) {
  * How each role not given to `buildPalette` is derived, following Textual's
  * `ColorSystem`, which generated the bundled themes:
  *
- * - `*-muted`  = the colour blended 70% toward its opposite base role — every
+ * - `*-muted`  = the color blended 70% toward its opposite base role — every
  *               accent AND the two base roles themselves, so a caller
  *               de-emphasizing body text reaches for `foreground-muted` the
  *               way it reaches for `primary-muted` to de-emphasize an accent.
@@ -67,7 +67,7 @@ function accentRules(accent) {
  *               terminal-support-dependent SGR attribute.
  * - `text-*`   = contrast text tinted 66% with the accent, the foreground for
  *               a `*-muted` ground; `buildPalette` then holds it to that ground
- * - `on-*`     = WCAG-correct contrast colour (black or white) for use as
+ * - `on-*`     = WCAG-correct contrast color (black or white) for use as
  *               foreground when the FULL accent is the background. Picked by
  *               relative luminance — single source of truth so widgets never
  *               need to invert fg/bg to get readable text. `contrastFor` is
@@ -158,13 +158,13 @@ export const PALETTE_ROLES = [...BASE_KEYS, ...Object.keys(RULES)];
 const ROLE_NAMES = new Set(PALETTE_ROLES);
 /**
  * Build a full semantic palette from its base colors and any other role it
- * states: a stated role keeps its colour, and everything derived from it
+ * states: a stated role keeps its color, and everything derived from it
  * follows it, but for `text-*`, which is held to read on its `*-muted`. An
  * authored theme is this with roles stated; see `RULES` for what a role
  * not stated becomes.
  *
- * A translucent colour is drawn onto `background` before anything is derived
- * from it, so `on-*` is chosen against the colour the accent is drawn as.
+ * A translucent color is drawn onto `background` before anything is derived
+ * from it, so `on-*` is chosen against the color the accent is drawn as.
  * `boost` alone stays a layer: it is what `panel` composites.
  */
 export function buildPalette(name, dark, given) {
@@ -172,9 +172,9 @@ export function buildPalette(name, dark, given) {
     // [LAW:no-ambient-temporal-coupling] A rule asks for the roles it reads, so
     // no order among the rules matters. The eight base roles are always known.
     const at = (role) => {
-        const colour = known.get(role) ?? RULES[role](at, dark);
-        known.set(role, colour);
-        return colour;
+        const color = known.get(role) ?? RULES[role](at, dark);
+        known.set(role, color);
+        return color;
     };
     // [LAW:single-enforcer] Stated and derived `text-*` alike: the tint is the
     // palette's, whether it reads is decided here. A stated tint stays translucent
@@ -193,23 +193,23 @@ export function buildPalette(name, dark, given) {
  */
 function statedRoles(name, given) {
     const drawn = drawnOn(name, given.background);
-    const stated = Object.entries(given).flatMap(([role, colour]) => {
+    const stated = Object.entries(given).flatMap(([role, color]) => {
         if (!ROLE_NAMES.has(role))
             throw new RangeError(`palette ${JSON.stringify(name)}: ${JSON.stringify(role)} is not a role`);
-        if (colour === undefined)
+        if (color === undefined)
             return [];
-        return [[role, role === "boost" ? colour : drawn(colour)]];
+        return [[role, role === "boost" ? color : drawn(color)]];
     });
     const known = new Map(stated);
-    // Every base colour is derived from, and a fully transparent one draws no
-    // colour of its own to derive a muted shade or a contrast from.
+    // Every base color is derived from, and a fully transparent one draws no
+    // color of its own to derive a muted shade or a contrast from.
     // [LAW:no-silent-failure]
     for (const key of BASE_KEYS) {
-        const colour = given[key];
-        if (colour.alpha === 0) {
-            throw new RangeError(`palette ${JSON.stringify(name)}: ${key} is fully transparent (${colour.hex}), so there is no colour to derive the palette from`);
+        const color = given[key];
+        if (color.alpha === 0) {
+            throw new RangeError(`palette ${JSON.stringify(name)}: ${key} is fully transparent (${color.hex}), so there is no color to derive the palette from`);
         }
-        known.set(key, drawn(colour));
+        known.set(key, drawn(color));
     }
     return known;
 }
@@ -217,7 +217,7 @@ function statedRoles(name, given) {
  * A palette's `text-*`: its tint held to WCAG AA on `*-muted`, moved toward
  * the palette's own text side so it also reads on `background`, where widgets
  * draw it too. The muted floor is the promise: where no lightness on the text
- * side clears it, the colour that does is on the other side, and the
+ * side clears it, the color that does is on the other side, and the
  * background pair is the one given up. Every bundled palette clears both
  * (test/themes/text-on-muted.test.ts).
  *

package/dist/themes/colorMath.d.ts

@@ -10,7 +10,7 @@ export declare function darken(color: ColorRgba, levels: number): ColorRgba;
  */
 export declare function lighten(color: ColorRgba, levels: number): ColorRgba;
 /**
- * Move a colour's CIE L* by `amount` (0..1 of the L* scale), keeping its alpha.
+ * Move a color's CIE L* by `amount` (0..1 of the L* scale), keeping its alpha.
  * Textual's `Color.lighten`, which drew every shade ladder in the bundled
  * themes, so a ladder derived here continues the ones authored there.
  */
@@ -45,16 +45,16 @@ export { relativeLuminance, contrastRatio };
  * in, so the ratio is measured on what the eye actually sees and the returned
  * color is opaque.
  *
- * `drawnAt` is the depth the terminal will draw the pair at. At 256 colours
+ * `drawnAt` is the depth the terminal will draw the pair at. At 256 colors
  * the terminal rounds text and background independently, and two roundings
  * can meet in the middle, so the ratio is measured on the drawn pair: a
- * colour that loses the floor there is replaced by the nearest cube/grey entry
+ * color that loses the floor there is replaced by the nearest cube/grey entry
  * that clears it (whose own rounding is itself). At ANSI the terminal draws
- * each index in its own theme's colour, so the ratio is measured on
+ * each index in its own theme's color, so the ratio is measured on
  * `terminal`'s sixteen: a theme whose black is light and white dark (Rosé Pine
- * Dawn) turns the nominal table's sides over. A replacement is the colour the
+ * Dawn) turns the nominal table's sides over. A replacement is the color the
  * writer emits as the index nearest `fg` that clears the floor as `terminal`
- * draws it. Truecolor draws the colour chosen.
+ * draws it. Truecolor draws the color chosen.
  *
  * [LAW:single-enforcer] The one place "is this text readable, and if not fix
  * it" is decided. Callers route every fg/bg pair through here and the
@@ -66,35 +66,35 @@ export declare function ensureContrast(fg: ColorRgba, bg: ColorRgba, minRatio?:
 drawnAt?: ColorDepth, substrate?: ColorRgba, terminal?: TerminalColors): ColorRgba;
 /**
  * `chosen` (composited opaque over `substrate`), or — when the depth the
- * terminal draws at rounds it to a colour `accept` refuses — the colour the
+ * terminal draws at rounds it to a color `accept` refuses — the color the
  * writer emits as the nearest entry `accept` takes. `accept` sees the
- * candidate as drawn, and `drawn`, the same rounding for any other colour it
+ * candidate as drawn, and `drawn`, the same rounding for any other color it
  * measures against, so the caller states a floor once and it holds on the
- * colours the terminal shows — at ANSI, `terminal`'s own sixteen, as
+ * colors the terminal shows — at ANSI, `terminal`'s own sixteen, as
  * `ensureContrast` measures there. Truecolor
- * draws from no table, so a colour refused there has no replacement;
+ * draws from no table, so a color refused there has no replacement;
  * `undefined` means nothing the depth draws is accepted.
  *
  * `ensureContrast` is this with a contrast ratio as the floor; this is for a
  * floor that is not text on its background (an open state standing off every
  * closed cell, two planes standing off each other).
  */
-export declare function ensureDrawn(chosen: ColorRgba, drawnAt: ColorDepth, accept: (candidate: ColorRgba, drawn: (c: ColorRgba) => ColorRgba) => boolean, substrate?: ColorRgba, terminal?: TerminalColors): ColorRgba | undefined;
+export declare function ensureMinimumDelta(chosen: ColorRgba, drawnAt: ColorDepth, accept: (candidate: ColorRgba, drawn: (c: ColorRgba) => ColorRgba) => boolean, substrate?: ColorRgba, terminal?: TerminalColors): ColorRgba | undefined;
 /**
- * The colour a ground is shown as at `drawnAt`: composited over `substrate`
+ * The color a ground is shown as at `drawnAt`: composited over `substrate`
  * (the SGR writer's black by default), rounded to the index the writer emits
  * at that depth, and shown as the terminal shows that index — at ANSI, in
- * `terminal`'s own colour. The one account `ensureDrawn` and `ensureContrast`
+ * `terminal`'s own color. The one account `ensureMinimumDelta` and `ensureContrast`
  * measure by, for a caller that measures a floor of its own.
  */
-export declare function drawnColour(colour: ColorRgba, drawnAt: ColorDepth, substrate?: ColorRgba, terminal?: TerminalColors): ColorRgba;
+export declare function compositedColor(color: ColorRgba, drawnAt: ColorDepth, substrate?: ColorRgba, terminal?: TerminalColors): ColorRgba;
 /**
  * `fg` held to `minRatio` on `bg` in truecolor, moving in lightness toward
  * `toward` (black or white). `ensureContrast` moves toward the pole `bg`
- * itself contrasts with; a colour that already has a side (a palette's
+ * itself contrasts with; a color that already has a side (a palette's
  * `text-*` is its text, tinted) passes that side, since on a ground near the
  * 0.179 cutoff both poles clear and only one also reads on everything else
- * the colour is drawn on. Where `toward` cannot clear `minRatio` on `bg`,
+ * the color is drawn on. Where `toward` cannot clear `minRatio` on `bg`,
  * the floor wins over the side: the answer is `contrastFor(bg)`.
  */
 export declare function ensureContrastToward(fg: ColorRgba, bg: ColorRgba, minRatio: number, toward: ColorRgba): ColorRgba;

package/dist/themes/colorMath.js

@@ -72,7 +72,7 @@ export function darken(color, levels) {
 export function lighten(color, levels) {
     return darken(color, -levels);
 }
-/** sRGB → CIE L*a*b* (D65, 2°): the space `shiftLightness` moves a colour in. */
+/** sRGB → CIE L*a*b* (D65, 2°): the space `shiftLightness` moves a color in. */
 function rgbToLab(c) {
     const [r, g, b] = [c.red, c.green, c.blue].map((v) => srgbToLinear(v / 255));
     const [x, y, z] = [
@@ -96,7 +96,7 @@ function labToRgb(l, a, b, alpha) {
     return new ColorRgba(red, green, blue, alpha);
 }
 /**
- * Move a colour's CIE L* by `amount` (0..1 of the L* scale), keeping its alpha.
+ * Move a color's CIE L* by `amount` (0..1 of the L* scale), keeping its alpha.
  * Textual's `Color.lighten`, which drew every shade ladder in the bundled
  * themes, so a ladder derived here continues the ones authored there.
  */
@@ -124,8 +124,8 @@ export function contrastFor(bg, substrate = SURFACE_BLACK) {
         : new ColorRgba(255, 255, 255);
 }
 // [LAW:one-way-deps] The WCAG measures live in core/color.ts, beside the
-// ColorTable whose `matchReadable` needs them to pick a drawn text colour, and
-// below the theme math here. Re-exported so this module stays the colour-math
+// ColorTable whose `matchReadable` needs them to pick a drawn text color, and
+// below the theme math here. Re-exported so this module stays the color-math
 // surface.
 export { relativeLuminance, contrastRatio };
 // Iterations for the lightness bisection below. 20 resolves L to ~1e-6 — far
@@ -148,16 +148,16 @@ const CONTRAST_ITERS = 20;
  * in, so the ratio is measured on what the eye actually sees and the returned
  * color is opaque.
  *
- * `drawnAt` is the depth the terminal will draw the pair at. At 256 colours
+ * `drawnAt` is the depth the terminal will draw the pair at. At 256 colors
  * the terminal rounds text and background independently, and two roundings
  * can meet in the middle, so the ratio is measured on the drawn pair: a
- * colour that loses the floor there is replaced by the nearest cube/grey entry
+ * color that loses the floor there is replaced by the nearest cube/grey entry
  * that clears it (whose own rounding is itself). At ANSI the terminal draws
- * each index in its own theme's colour, so the ratio is measured on
+ * each index in its own theme's color, so the ratio is measured on
  * `terminal`'s sixteen: a theme whose black is light and white dark (Rosé Pine
- * Dawn) turns the nominal table's sides over. A replacement is the colour the
+ * Dawn) turns the nominal table's sides over. A replacement is the color the
  * writer emits as the index nearest `fg` that clears the floor as `terminal`
- * draws it. Truecolor draws the colour chosen.
+ * draws it. Truecolor draws the color chosen.
  *
  * [LAW:single-enforcer] The one place "is this text readable, and if not fix
  * it" is decided. Callers route every fg/bg pair through here and the
@@ -181,23 +181,23 @@ drawnAt = ColorDepth.TRUECOLOR, substrate = SURFACE_BLACK, terminal) {
 }
 /**
  * `chosen` (composited opaque over `substrate`), or — when the depth the
- * terminal draws at rounds it to a colour `accept` refuses — the colour the
+ * terminal draws at rounds it to a color `accept` refuses — the color the
  * writer emits as the nearest entry `accept` takes. `accept` sees the
- * candidate as drawn, and `drawn`, the same rounding for any other colour it
+ * candidate as drawn, and `drawn`, the same rounding for any other color it
  * measures against, so the caller states a floor once and it holds on the
- * colours the terminal shows — at ANSI, `terminal`'s own sixteen, as
+ * colors the terminal shows — at ANSI, `terminal`'s own sixteen, as
  * `ensureContrast` measures there. Truecolor
- * draws from no table, so a colour refused there has no replacement;
+ * draws from no table, so a color refused there has no replacement;
  * `undefined` means nothing the depth draws is accepted.
  *
  * `ensureContrast` is this with a contrast ratio as the floor; this is for a
  * floor that is not text on its background (an open state standing off every
  * closed cell, two planes standing off each other).
  */
-export function ensureDrawn(chosen, drawnAt, accept, substrate = SURFACE_BLACK, terminal) {
+export function ensureMinimumDelta(chosen, drawnAt, accept, substrate = SURFACE_BLACK, terminal) {
     // The floor was measured on `chosen` composited over `substrate`, so that
-    // opaque colour is what is returned — never a translucent one a different
-    // ground would composite into a colour `accept` never saw.
+    // opaque color is what is returned — never a translucent one a different
+    // ground would composite into a color `accept` never saw.
     const opaque = drawnBackground(chosen, substrate);
     const table = drawnTable(drawnAt, terminal);
     const drawn = (c) => shownAs(table, drawnBackground(c, substrate));
@@ -209,17 +209,17 @@ export function ensureDrawn(chosen, drawnAt, accept, substrate = SURFACE_BLACK,
     return index === undefined ? undefined : table.written.get(index);
 }
 /**
- * The colour a ground is shown as at `drawnAt`: composited over `substrate`
+ * The color a ground is shown as at `drawnAt`: composited over `substrate`
  * (the SGR writer's black by default), rounded to the index the writer emits
  * at that depth, and shown as the terminal shows that index — at ANSI, in
- * `terminal`'s own colour. The one account `ensureDrawn` and `ensureContrast`
+ * `terminal`'s own color. The one account `ensureMinimumDelta` and `ensureContrast`
  * measure by, for a caller that measures a floor of its own.
  */
-export function drawnColour(colour, drawnAt, substrate = SURFACE_BLACK, terminal) {
-    return shownAs(drawnTable(drawnAt, terminal), drawnBackground(colour, substrate));
+export function compositedColor(color, drawnAt, substrate = SURFACE_BLACK, terminal) {
+    return shownAs(drawnTable(drawnAt, terminal), drawnBackground(color, substrate));
 }
 /**
- * An opaque colour as the terminal shows it: downgraded to the index the
+ * An opaque color as the terminal shows it: downgraded to the index the
  * writer emits and drawn as the terminal draws that index.
  * [LAW:one-source-of-truth] That rounding is `ColorSpec.downgrade`'s, the one
  * `Style.drawnColors` writes; the tables here only list the candidates.
@@ -232,13 +232,13 @@ function shownAs(table, opaque) {
  * surface is a fact about where the pair is drawn, so it arrives as a value:
  * the SGR writer (`Style.toSgrCodes`) and the exports that picture its output
  * composite over `SURFACE_BLACK`, the default here; a caller that composites
- * its colours onto a different surface itself names that one.
+ * its colors onto a different surface itself names that one.
  * [LAW:no-silent-failure] A surface has nothing under it, so a translucent one
- * has no drawn colour to offer; `compositeOver` would read its raw RGB as if
+ * has no drawn color to offer; `compositeOver` would read its raw RGB as if
  * it were opaque, so it is refused here rather than measured wrong.
- * [LAW:one-source-of-truth] Text is chosen against the colour the surface will
- * show — measuring the raw RGBA reads a colour that is drawn nowhere, and text
- * that "clears" it can land below the floor. Opaque colours composite to
+ * [LAW:one-source-of-truth] Text is chosen against the color the surface will
+ * show — measuring the raw RGBA reads a color that is drawn nowhere, and text
+ * that "clears" it can land below the floor. Opaque colors composite to
  * themselves.
  */
 function drawnBackground(bg, substrate) {
@@ -248,12 +248,12 @@ function drawnBackground(bg, substrate) {
     return bg.compositeOver(substrate);
 }
 /**
- * The table the terminal draws from at `drawnAt`. The 256-colour cube and
- * grey ramp are fixed by xterm, so the colour written is the colour shown.
+ * The table the terminal draws from at `drawnAt`. The 256-color cube and
+ * grey ramp are fixed by xterm, so the color written is the color shown.
  * ANSI 0–15 are the terminal theme's own: the writer still picks the index by
  * the nominal table — the Windows console's at WINDOWS — and the terminal
- * shows `terminal`'s colour there.
- * Truecolor draws the chosen colour itself, as do the depths no table stands
+ * shows `terminal`'s color there.
+ * Truecolor draws the chosen color itself, as do the depths no table stands
  * behind.
  */
 function drawnTable(drawnAt, terminal) {
@@ -272,10 +272,10 @@ function drawnTable(drawnAt, terminal) {
 /**
  * `fg` held to `minRatio` on `bg` in truecolor, moving in lightness toward
  * `toward` (black or white). `ensureContrast` moves toward the pole `bg`
- * itself contrasts with; a colour that already has a side (a palette's
+ * itself contrasts with; a color that already has a side (a palette's
  * `text-*` is its text, tinted) passes that side, since on a ground near the
  * 0.179 cutoff both poles clear and only one also reads on everything else
- * the colour is drawn on. Where `toward` cannot clear `minRatio` on `bg`,
+ * the color is drawn on. Where `toward` cannot clear `minRatio` on `bg`,
  * the floor wins over the side: the answer is `contrastFor(bg)`.
  */
 export function ensureContrastToward(fg, bg, minRatio, toward) {

package/dist/themes/data/ansi-tables.d.ts

@@ -1,11 +1,11 @@
 import { type AnsiColorsData } from "./types.js";
 /**
- * The VGA colours a terminal draws with no theme of its own: Rich's
+ * The VGA colors a terminal draws with no theme of its own: Rich's
  * `DEFAULT_TERMINAL_THEME`, and what `textual-ansi` spells its palette in.
  */
 export declare const VGA_ANSI: AnsiColorsData;
 /**
- * The ANSI tables Textual draws named colours in for a theme that has no
+ * The ANSI tables Textual draws named colors in for a theme that has no
  * terminal scheme of its own: `MONOKAI` under a dark theme and `ALABASTER`
  * under a light one (`ansi_theme_dark` / `ansi_theme_light` in Textual's
  * `app.py`, values from its `_ansi_theme.py`).

package/dist/themes/data/ansi-tables.js

@@ -1,12 +1,12 @@
 import { STANDARD_TABLE } from "../../core/color.js";
 import { ANSI_SLOTS } from "./types.js";
 /**
- * The VGA colours a terminal draws with no theme of its own: Rich's
+ * The VGA colors a terminal draws with no theme of its own: Rich's
  * `DEFAULT_TERMINAL_THEME`, and what `textual-ansi` spells its palette in.
  */
 export const VGA_ANSI = Object.fromEntries(ANSI_SLOTS.map((slot, n) => [slot, STANDARD_TABLE.get(n).hex]));
 /**
- * The ANSI tables Textual draws named colours in for a theme that has no
+ * The ANSI tables Textual draws named colors in for a theme that has no
  * terminal scheme of its own: `MONOKAI` under a dark theme and `ALABASTER`
  * under a light one (`ansi_theme_dark` / `ansi_theme_light` in Textual's
  * `app.py`, values from its `_ansi_theme.py`).