@promptctl/rich-js 0.27.0 → 0.29.0

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`).

package/dist/themes/data/index.js

@@ -3,10 +3,7 @@
 // below define the canonical name set for the registry. Adding a theme:
 //   1. drop a new `data/<name>.ts` file,
 //   2. add it here,
-//   3. (optional) add a matching `<NAME>` export in `terminalThemes.ts`
-//      if you want a pre-built `TerminalTheme` constant alongside the
-//      registry palette. Without step 3 the theme is still fully usable
-//      via `getThemePalette(name)`.
+//   3. add a matching `<NAME>` export in `terminalThemes.ts`.
 import atomOneDark from "./atom-one-dark.js";
 import atomOneLight from "./atom-one-light.js";
 import catppuccinFrappe from "./catppuccin-frappe.js";

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

@@ -5,156 +5,13 @@ const theme = {
     ansi: VGA_ANSI,
     vars: {
         "accent": "#0000FF",
-        "accent-darken-1": "#0000FF",
-        "accent-darken-2": "#0000FF",
-        "accent-darken-3": "#0000FF",
-        "accent-lighten-1": "#0000FF",
-        "accent-lighten-2": "#0000FF",
-        "accent-lighten-3": "#0000FF",
-        "accent-muted": "#0178D4",
         "background": "#121212",
-        "background-darken-1": "#121212",
-        "background-darken-2": "#121212",
-        "background-darken-3": "#121212",
-        "background-lighten-1": "#121212",
-        "background-lighten-2": "#121212",
-        "background-lighten-3": "#121212",
-        "block-cursor-background": "#000080",
-        "block-cursor-blurred-background": "#0000804C",
-        "block-cursor-blurred-foreground": "#E0E0E0",
-        "block-cursor-foreground": "#E0E0E0",
-        "block-hover-background": "#00000019",
-        "boost": "#0178D4",
-        "boost-darken-1": "#0178D4",
-        "boost-darken-2": "#0178D4",
-        "boost-darken-3": "#0178D4",
-        "boost-lighten-1": "#0178D4",
-        "boost-lighten-2": "#0178D4",
-        "boost-lighten-3": "#0178D4",
-        "border": "#0000FF",
-        "border-blurred": "#000080",
-        "button-color-foreground": "#E0E0E0",
-        "button-foreground": "#E0E0E0",
         "error": "#800000",
-        "error-darken-1": "#800000",
-        "error-darken-2": "#800000",
-        "error-darken-3": "#800000",
-        "error-lighten-1": "#800000",
-        "error-lighten-2": "#800000",
-        "error-lighten-3": "#800000",
-        "error-muted": "#0178D4",
-        "footer-background": "#121212",
-        "footer-description-background": "#00000000",
-        "footer-description-foreground": "#E0E0E0",
-        "footer-foreground": "#E0E0E0",
-        "footer-item-background": "#00000000",
-        "footer-key-background": "#00000000",
-        "footer-key-foreground": "#0000FF",
         "foreground": "#E0E0E0",
-        "foreground-darken-1": "#E0E0E0",
-        "foreground-darken-2": "#E0E0E0",
-        "foreground-darken-3": "#E0E0E0",
-        "foreground-disabled": "#00000060",
-        "foreground-lighten-1": "#E0E0E0",
-        "foreground-lighten-2": "#E0E0E0",
-        "foreground-lighten-3": "#E0E0E0",
-        "foreground-muted": "#00000099",
-        "input-cursor-background": "#121212",
-        "input-cursor-foreground": "#E0E0E0",
-        "input-selection-background": "#000080",
-        "link-background": "#00000000",
-        "link-background-hover": "#000080",
-        "link-color": "#E0E0E0",
-        "link-color-hover": "#0178D4",
-        "markdown-h1-background": "#00000000",
-        "markdown-h1-color": "#000080",
-        "markdown-h2-background": "#00000000",
-        "markdown-h2-color": "#000080",
-        "markdown-h3-background": "#00000000",
-        "markdown-h3-color": "#000080",
-        "markdown-h4-background": "#00000000",
-        "markdown-h4-color": "#E0E0E0",
-        "markdown-h5-background": "#00000000",
-        "markdown-h5-color": "#E0E0E0",
-        "markdown-h6-background": "#00000000",
-        "markdown-h6-color": "#00000099",
-        "panel": "#121212",
-        "panel-darken-1": "#121212",
-        "panel-darken-2": "#121212",
-        "panel-darken-3": "#121212",
-        "panel-lighten-1": "#121212",
-        "panel-lighten-2": "#121212",
-        "panel-lighten-3": "#121212",
         "primary": "#000080",
-        "primary-background": "#000080",
-        "primary-background-darken-1": "#000080",
-        "primary-background-darken-2": "#000080",
-        "primary-background-darken-3": "#000080",
-        "primary-background-lighten-1": "#000080",
-        "primary-background-lighten-2": "#000080",
-        "primary-background-lighten-3": "#000080",
-        "primary-darken-1": "#000080",
-        "primary-darken-2": "#000080",
-        "primary-darken-3": "#000080",
-        "primary-lighten-1": "#000080",
-        "primary-lighten-2": "#000080",
-        "primary-lighten-3": "#000080",
-        "primary-muted": "#0178D4",
-        "scrollbar": "#000080",
-        "scrollbar-active": "#000080",
-        "scrollbar-background": "#121212",
-        "scrollbar-background-active": "#121212",
-        "scrollbar-background-hover": "#121212",
-        "scrollbar-corner-color": "#E0E0E0",
-        "scrollbar-hover": "#000040",
         "secondary": "#008080",
-        "secondary-background": "#008080",
-        "secondary-background-darken-1": "#008080",
-        "secondary-background-darken-2": "#008080",
-        "secondary-background-darken-3": "#008080",
-        "secondary-background-lighten-1": "#008080",
-        "secondary-background-lighten-2": "#008080",
-        "secondary-background-lighten-3": "#008080",
-        "secondary-darken-1": "#008080",
-        "secondary-darken-2": "#008080",
-        "secondary-darken-3": "#008080",
-        "secondary-lighten-1": "#008080",
-        "secondary-lighten-2": "#008080",
-        "secondary-lighten-3": "#008080",
-        "secondary-muted": "#0178D4",
         "success": "#008000",
-        "success-darken-1": "#008000",
-        "success-darken-2": "#008000",
-        "success-darken-3": "#008000",
-        "success-lighten-1": "#008000",
-        "success-lighten-2": "#008000",
-        "success-lighten-3": "#008000",
-        "success-muted": "#0178D4",
-        "surface": "#121212",
-        "surface-active": "#131313",
-        "surface-darken-1": "#121212",
-        "surface-darken-2": "#121212",
-        "surface-darken-3": "#121212",
-        "surface-lighten-1": "#121212",
-        "surface-lighten-2": "#121212",
-        "surface-lighten-3": "#121212",
-        "text": "#E0E0E0",
-        "text-accent": "#5656FF",
-        "text-disabled": "#E0E0E0",
-        "text-error": "#AB5656",
-        "text-muted": "#E0E0E0",
-        "text-primary": "#5656AB",
-        "text-secondary": "#56ABAB",
-        "text-success": "#56AB56",
-        "text-warning": "#ABAB56",
         "warning": "#808000",
-        "warning-darken-1": "#808000",
-        "warning-darken-2": "#808000",
-        "warning-darken-3": "#808000",
-        "warning-lighten-1": "#808000",
-        "warning-lighten-2": "#808000",
-        "warning-lighten-3": "#808000",
-        "warning-muted": "#0178D4",
     },
 };
 export default theme;

package/dist/themes/data/types.d.ts

@@ -13,7 +13,7 @@ export interface ThemePaletteData {
     readonly name: string;
     readonly dark: boolean;
     /**
-     * The sixteen colours a terminal showing this theme draws `red`, `blue`,
+     * The sixteen colors a terminal showing this theme draws `red`, `blue`,
      * `bright_black` and the rest in. A theme without its own table would draw
      * them in the VGA defaults (`blue` as #000080), which belong to no theme.
      */
@@ -22,12 +22,12 @@ export interface ThemePaletteData {
     readonly vars: Readonly<Record<BaseRole, string> & Partial<Record<PaletteRole, string>>>;
 }
 /**
- * ANSI colour numbers 0–15 in order: the eight normal colours, then their
+ * ANSI color numbers 0–15 in order: the eight normal colors, then their
  * bright forms. Named rather than positional so a data file cannot shift a
- * colour into its neighbour's slot by miscounting.
+ * color into its neighbour's slot by miscounting.
  */
 export declare const ANSI_SLOTS: readonly ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "brightBlack", "brightRed", "brightGreen", "brightYellow", "brightBlue", "brightMagenta", "brightCyan", "brightWhite"];
-/** One `#RRGGBB` per ANSI colour number, keyed by `ANSI_SLOTS`. */
+/** One `#RRGGBB` per ANSI color number, keyed by `ANSI_SLOTS`. */
 export type AnsiColorsData = {
     readonly [K in (typeof ANSI_SLOTS)[number]]: string;
 };

package/dist/themes/data/types.js

@@ -1,7 +1,7 @@
 /**
- * ANSI colour numbers 0–15 in order: the eight normal colours, then their
+ * ANSI color numbers 0–15 in order: the eight normal colors, then their
  * bright forms. Named rather than positional so a data file cannot shift a
- * colour into its neighbour's slot by miscounting.
+ * color into its neighbour's slot by miscounting.
  */
 export const ANSI_SLOTS = [
     "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",

package/dist/themes/palette.d.ts

@@ -10,7 +10,7 @@ export type Shade = `-${"darken" | "lighten"}-${1 | 2 | 3}`;
  * list is read off those rules.
  */
 export type PaletteRole = ShadedRole | `${ShadedRole}${Shade}` | `${AccentRole}-muted` | `text-${AccentRole}` | `on-${AccentRole}` | "background-muted" | "foreground-muted" | "foreground-disabled" | "surface-active" | "text" | "text-muted" | "text-disabled" | "border" | "border-blurred" | "block-cursor-background" | "block-cursor-foreground" | "block-cursor-blurred-background" | "block-cursor-blurred-foreground" | "block-hover-background" | "button-foreground" | "button-color-foreground" | "footer-background" | "footer-foreground" | "footer-description-background" | "footer-description-foreground" | "footer-item-background" | "footer-key-background" | "footer-key-foreground" | "input-cursor-background" | "input-cursor-foreground" | "input-selection-background" | "link-background" | "link-background-hover" | "link-color" | "link-color-hover" | `markdown-h${1 | 2 | 3 | 4 | 5 | 6}-${"background" | "color"}` | "scrollbar" | "scrollbar-active" | "scrollbar-hover" | "scrollbar-background" | "scrollbar-background-active" | "scrollbar-background-hover" | "scrollbar-corner-color";
-/** A colour for each role: what proves a palette complete. */
+/** A color for each role: what proves a palette complete. */
 export type PaletteRoles = Readonly<Record<PaletteRole, ColorRgba>>;
 /**
  * A semantic palette: a named map from role → ColorRgba, holding every
@@ -22,20 +22,20 @@ export type PaletteRoles = Readonly<Record<PaletteRole, ColorRgba>>;
  *
  * Storage is uniformly ColorRgba; consumers that load from hex JSON
  * parse to ColorRgba at load time. `get` is a bare lookup — turning an
- * author-written *reference* (a name, or a `#RRGGBB` literal) into a colour
+ * author-written *reference* (a name, or a `#RRGGBB` literal) into a color
  * is `resolveColorRef`'s job in `colorRef.ts`, so a Palette never has to
  * know about the syntax callers write.
  *
- * Every colour a Palette hands out is opaque or fully transparent. A theme's translucent variable
+ * Every color a Palette hands out is opaque or fully transparent. A theme's translucent variable
  * (Textual's `boost`, a hover overlay) is a tint meant for that theme's own
- * background, and a colour leaving the palette no longer knows which
+ * background, and a color leaving the palette no longer knows which
  * background that was: the SGR writer would composite it over the terminal's
  * black, which is not the theme's background, and draw a tint the theme never
  * meant.
  * So it is drawn onto `background` here, once, and the writer, the exporters
- * and the contrast choosers all read the colour it has there. On any other
- * surface it keeps that colour: the tint does not follow what is under it.
- * The exception is a fully transparent colour, Textual's "no background": it
+ * and the contrast choosers all read the color it has there. On any other
+ * surface it keeps that color: the tint does not follow what is under it.
+ * The exception is a fully transparent color, Textual's "no background": it
  * draws nothing on any surface, so it needs none and is handed out as it is,
  * and a `Style` reads it as no background at all.
  *
@@ -48,14 +48,14 @@ export declare class Palette {
     constructor(name: string, dark: boolean, roles: PaletteRoles);
     get(role: PaletteRole): ColorRgba;
     get(role: string): ColorRgba | undefined;
-    /** This palette's roles, each put through `colour`: what a new palette is built from. */
-    mapRoles(colour: (colour: ColorRgba, role: PaletteRole) => ColorRgba): PaletteRoles;
+    /** This palette's roles, each put through `color`: what a new palette is built from. */
+    mapRoles(color: (color: ColorRgba, role: PaletteRole) => ColorRgba): PaletteRoles;
 }
 /**
- * A palette colour as it is drawn: composited onto the palette's own
+ * A palette color as it is drawn: composited onto the palette's own
  * `background`, which has nothing under it and so must itself be opaque.
  * [LAW:one-source-of-truth] The one statement of what a translucent palette
- * colour means; `buildPalette` draws its base colours through it before
+ * color means; `buildPalette` draws its base colors through it before
  * deriving from them.
  */
-export declare function drawnOn(name: string, background: ColorRgba): (colour: ColorRgba) => ColorRgba;
+export declare function drawnOn(name: string, background: ColorRgba): (color: ColorRgba) => ColorRgba;

package/dist/themes/palette.js

@@ -8,20 +8,20 @@
  *
  * Storage is uniformly ColorRgba; consumers that load from hex JSON
  * parse to ColorRgba at load time. `get` is a bare lookup — turning an
- * author-written *reference* (a name, or a `#RRGGBB` literal) into a colour
+ * author-written *reference* (a name, or a `#RRGGBB` literal) into a color
  * is `resolveColorRef`'s job in `colorRef.ts`, so a Palette never has to
  * know about the syntax callers write.
  *
- * Every colour a Palette hands out is opaque or fully transparent. A theme's translucent variable
+ * Every color a Palette hands out is opaque or fully transparent. A theme's translucent variable
  * (Textual's `boost`, a hover overlay) is a tint meant for that theme's own
- * background, and a colour leaving the palette no longer knows which
+ * background, and a color leaving the palette no longer knows which
  * background that was: the SGR writer would composite it over the terminal's
  * black, which is not the theme's background, and draw a tint the theme never
  * meant.
  * So it is drawn onto `background` here, once, and the writer, the exporters
- * and the contrast choosers all read the colour it has there. On any other
- * surface it keeps that colour: the tint does not follow what is under it.
- * The exception is a fully transparent colour, Textual's "no background": it
+ * and the contrast choosers all read the color it has there. On any other
+ * surface it keeps that color: the tint does not follow what is under it.
+ * The exception is a fully transparent color, Textual's "no background": it
  * draws nothing on any surface, so it needs none and is handed out as it is,
  * and a `Style` reads it as no background at all.
  *
@@ -35,29 +35,29 @@ export class Palette {
         this.name = name;
         this.dark = dark;
         // [LAW:single-enforcer] Every palette is built through here, so this is
-        // where "a palette colour is opaque or draws nothing" holds.
+        // where "a palette color is opaque or draws nothing" holds.
         const draw = drawnOn(name, roles.background);
-        this.vars = new Map(Object.entries(roles).map(([role, colour]) => [role, draw(colour)]));
+        this.vars = new Map(Object.entries(roles).map(([role, color]) => [role, draw(color)]));
     }
     get(role) {
         return this.vars.get(role);
     }
-    /** This palette's roles, each put through `colour`: what a new palette is built from. */
-    mapRoles(colour) {
-        return Object.fromEntries([...this.vars].map(([role, was]) => [role, colour(was, role)]));
+    /** This palette's roles, each put through `color`: what a new palette is built from. */
+    mapRoles(color) {
+        return Object.fromEntries([...this.vars].map(([role, was]) => [role, color(was, role)]));
     }
 }
 /**
- * A palette colour as it is drawn: composited onto the palette's own
+ * A palette color as it is drawn: composited onto the palette's own
  * `background`, which has nothing under it and so must itself be opaque.
  * [LAW:one-source-of-truth] The one statement of what a translucent palette
- * colour means; `buildPalette` draws its base colours through it before
+ * color means; `buildPalette` draws its base colors through it before
  * deriving from them.
  */
 export function drawnOn(name, background) {
     if (background.alpha !== 1) {
-        throw new RangeError(`palette ${JSON.stringify(name)}: background is the surface its translucent colours are drawn on, so it must be opaque; got ${background.hex}`);
+        throw new RangeError(`palette ${JSON.stringify(name)}: background is the surface its translucent colors are drawn on, so it must be opaque; got ${background.hex}`);
     }
-    // A fully transparent colour is not a tint: it draws nothing on any surface.
-    return (colour) => (colour.alpha === 0 ? colour : colour.compositeOver(background));
+    // A fully transparent color is not a tint: it draws nothing on any surface.
+    return (color) => (color.alpha === 0 ? color : color.compositeOver(background));
 }

package/dist/themes/ramp.d.ts

@@ -6,13 +6,13 @@
  * color, and none takes a *measurement*. Without a ramp the answer gets
  * computed outside the theme system — a script emits a hex, a template
  * branches `if ge .pct 80 … else if ge .pct 50 …` — and that color decision
- * can no longer transpose with the palette it was meant to belong to. A ramp
+ * can no longer adjust with the palette it was meant to belong to. A ramp
  * is the one function whose input is a number, so the decision stays inside.
  *
  * A threshold cascade is a ramp too: the same stops with the `step` ease hold
  * each color until the next position, which is exactly `≥ threshold → hotter`
  * written as data. [LAW:one-type-per-behavior] One primitive; the easing is a
- * value — any `Ease` from `core/easing`, the vocabulary every effect shares —
+ * value — any `Easing` from `core/easing`, the vocabulary every effect shares —
  * so a gradient and a cascade differ by one word, not by which function was
  * called. [LAW:dataflow-not-control-flow] `at` applies it unconditionally.
  *
@@ -21,7 +21,7 @@
  * midpoints of an sRGB blend.
  *
  * A ramp also carries how far it has been moved: `scroll`, in spans, how
- * far its colours have travelled along it, and `hue`, in turns, how far
+ * far its colors have travelled along it, and `hue`, in turns, how far
  * they are rotated round the OKLCH hue circle. A moved ramp is still a
  * `ColorRamp`, so anything that reads a ramp reads a moving one frame by
  * frame (`moving`) with nothing new to learn. [LAW:one-type-per-behavior]
@@ -33,7 +33,7 @@
  */
 import { Animation } from "../core/animation.js";
 import type { ColorRgba } from "../core/color.js";
-import { type Ease } from "../core/easing.js";
+import { type Easing } from "../core/easing.js";
 /** One stop: the color the ramp is exactly `color` at position `at`. */
 export interface ColorStop {
     readonly at: number;
@@ -42,8 +42,8 @@ export interface ColorStop {
 /**
  * How a ramp moves over time, each part an `Animation<number>` that is
  * `Animation.constant(0)` when not given. `scroll` is in spans: at 1 the
- * colours have travelled the whole way from the first stop to the last and
- * wrapped back, so `Animation.continuous(Phase.loop(seconds))` scrolls once
+ * colors have travelled the whole way from the first stop to the last and
+ * wrapped back, so `Animation.continuous(WrapMode.loop(seconds))` scrolls once
  * every `seconds`. `hue` is in turns, CSS's `turn`: at 1 every hue has gone
  * once round the circle. A one-shot that settles is a `tween` to where it
  * rests.
@@ -68,13 +68,13 @@ export interface RampMotion {
  * same way).
  */
 export declare class ColorRamp {
-    readonly ease: Ease;
+    readonly ease: Easing;
     readonly stops: readonly ColorStop[];
-    /** How far the colours have moved along the span, in spans, in [0, 1). */
+    /** How far the colors have moved along the span, in spans, in [0, 1). */
     readonly scroll: number;
     /** How far every hue is rotated in OKLCH, in turns, in [0, 1). */
     readonly hue: number;
-    constructor(ease: Ease, stops: readonly ColorStop[], scroll?: number, hue?: number);
+    constructor(ease: Easing, stops: readonly ColorStop[], scroll?: number, hue?: number);
     /**
      * The color at `value`. Below the first stop it is the first color; at or
      * above the last stop it is the last; between two stops the raw progress
@@ -91,26 +91,26 @@ export declare class ColorRamp {
      * CSS defines them. An ease that overshoots [0, 1] holds the end colors
      * where it does: a ramp never paints outside its stops.
      *
-     * A scrolled ramp reads, inside its span, the colour `scroll` spans behind
+     * A scrolled ramp reads, inside its span, the color `scroll` spans behind
      * `value`, wrapped back round the span as a repeating gradient does —
-     * seamless when the first and last stops are one colour; outside the span
-     * its end colours hold, however far it has scrolled. A rotated ramp turns
-     * the colour read by `hue` at its own lightness and chroma. Unmoved, every
+     * seamless when the first and last stops are one color; outside the span
+     * its end colors hold, however far it has scrolled. A rotated ramp turns
+     * the color read by `hue` at its own lightness and chroma. Unmoved, every
      * read keeps the exactness above.
      */
     at(value: number): ColorRgba;
-    /** The colour at `value` with the ramp unmoved: the stops and the ease alone. */
+    /** The color at `value` with the ramp unmoved: the stops and the ease alone. */
     private unmoved;
     /**
      * This ramp read over time: its span of positions, from the first stop's
      * to the last's, crossed at a steady rate in `seconds` and held at the last
-     * stop from then on, each colour along the way the ramp's own. A colour
+     * stop from then on, each color along the way the ramp's own. A color
      * tween is a two-stop ramp over its seconds — the ramp's ease shaping the
      * move, so `new ColorRamp(ease, [{ at: 0, color: a }, { at: 1, color: b
      * }]).over(seconds)` is `a` eased to `b` — and a ramp of more stops over
      * time is a sweep through all of them. [LAW:one-source-of-truth] The
      * blending is `at`'s; what time adds is `tween`'s (`core/tween.ts`), so a
-     * host sampling once a second or sixty times reads the stop colours byte
+     * host sampling once a second or sixty times reads the stop colors byte
      * for byte where `at` paints them.
      */
     over(seconds: number): Animation<ColorRgba>;
@@ -122,7 +122,7 @@ export declare class ColorRamp {
      * [LAW:one-source-of-truth] When it next changes is `Animation.all`'s
      * answer over the two parts; nothing here says it a second time. Whether
      * the depth it is drawn at can show the move is decided where it is drawn
-     * (`gradient`, through `stillOnSlots`).
+     * (`gradient`, through `staticWhereUnchanged`).
      */
     moving(motion: RampMotion): Animation<ColorRamp>;
 }