@promptctl/rich-js 0.27.0 → 0.29.0

package/dist/template-bindings/palette-funcs.js

@@ -63,7 +63,7 @@
  * they are gone.
  */
 import { resolveColorRef } from "../themes/colorRef.js";
-import { parseEase } from "../core/easing.js";
+import { parseEasing } from "../core/easing.js";
 import { ColorRamp } from "../themes/ramp.js";
 import { computable } from "./color-funcs.js";
 /**
@@ -97,7 +97,7 @@ function colorStops(tail, palette) {
  *
  * `color` resolves a palette variable name to its hex string — `#RRGGBB`, or
  * `#00000000` for a theme's "no background", which `bg` paints as no
- * background and the colour functions refuse — and passes
+ * background and the color functions refuse — and passes
  * an already-literal color through unchanged. That second half is not a
  * convenience — it makes `color` **idempotent**, which is what lets consumers
  * apply it unconditionally to any author-written color string without first
@@ -111,7 +111,7 @@ function colorStops(tail, palette) {
  * @example
  * ```ts
  * const engine = createEngine({
- *   fromString: (s) => new RichText(s),
+ *   fromString: (s) => new RichText(s), isT: (v) => v instanceof RichText,
  *   toString: (rt) => rt.plain,
  *   funcs: {
  *     ...richTextFuncs(),
@@ -135,7 +135,7 @@ export function paletteFuncs(getPalette) {
     // value, the ease, and one stop, so the gate refuses a stopless call.
     // [LAW:types-are-the-program]
     const rampFunc = {
-        fn: ((value, ease, ...tail) => new ColorRamp(parseEase(ease), colorStops(tail, getPalette())).at(value)
+        fn: ((value, ease, ...tail) => new ColorRamp(parseEasing(ease), colorStops(tail, getPalette())).at(value)
             .hex),
         argTypes: ["float", "string"],
         arity: { kind: "alternating", minimum: 4 },

package/dist/template-bindings/style-funcs.d.ts

@@ -3,7 +3,7 @@
  *
  * [LAW:one-source-of-truth] The function inventory below mirrors the
  * string-syntax style vocabulary documented in `docs/style.md` — the two
- * colour slots (`fg`/`bg`), text attributes (positive + negated), short
+ * color slots (`fg`/`bg`), text attributes (positive + negated), short
  * aliases, and the hyperlink. Each registration is a templating-time analogue
  * of a piece of `Style.parse`, so a template fragment composed by these
  * functions round-trips through `Style` without semantic drift.
@@ -12,17 +12,17 @@
  * shape: child `RichText` in, `RichText` out. The styling difference
  * lives in a captured `Style` value (or constructor closure), not in
  * branches inside a single dispatch. That is why this file is mostly
- * factories — the data (the colour, the attribute name) is the
+ * factories — the data (the color, the attribute name) is the
  * variability; the operation is fixed.
  */
 import type { FuncMap } from "@promptctl/go-template-js";
 /**
- * Text-styling registrations: the two colour sinks (`fg`, `bg`), text
+ * Text-styling registrations: the two color sinks (`fg`, `bg`), text
  * attributes (canonical names, short aliases, and `not_*` negations), the
  * hyperlink cell-splitter (`link`), and the multi-attribute `style` spec.
  *
- * Colours themselves come from elsewhere: `colorFuncs()` for the palette-free
- * math, `paletteFuncs()` for naming a theme colour. This module only paints.
+ * Colors themselves come from elsewhere: `colorFuncs()` for the palette-free
+ * math, `paletteFuncs()` for naming a theme color. This module only paints.
  * [LAW:one-way-deps] — nothing here imports a palette.
  */
 export declare function richTextStyleFuncs(): FuncMap;

package/dist/template-bindings/style-funcs.js

@@ -3,7 +3,7 @@
  *
  * [LAW:one-source-of-truth] The function inventory below mirrors the
  * string-syntax style vocabulary documented in `docs/style.md` — the two
- * colour slots (`fg`/`bg`), text attributes (positive + negated), short
+ * color slots (`fg`/`bg`), text attributes (positive + negated), short
  * aliases, and the hyperlink. Each registration is a templating-time analogue
  * of a piece of `Style.parse`, so a template fragment composed by these
  * functions round-trips through `Style` without semantic drift.
@@ -12,7 +12,7 @@
  * shape: child `RichText` in, `RichText` out. The styling difference
  * lives in a captured `Style` value (or constructor closure), not in
  * branches inside a single dispatch. That is why this file is mostly
- * factories — the data (the colour, the attribute name) is the
+ * factories — the data (the color, the attribute name) is the
  * variability; the operation is fixed.
  */
 import { Style, ATTRIBUTE_NAMES, ATTRIBUTE_SHORT_ALIASES, } from "../core/style.js";
@@ -26,26 +26,26 @@ function attrFunc(style) {
         returnType: "T",
     };
 }
-// --- Colour sinks ---
+// --- Color sinks ---
 //
-// `fg` and `bg` are the only two colour-applying functions, and they are the
-// terminal step of the colour pipeline: `color` names a colour, the functions
+// `fg` and `bg` are the only two color-applying functions, and they are the
+// terminal step of the color pipeline: `color` names a color, the functions
 // in `color-funcs.ts` transform it, these paint it onto text.
 //
 // [LAW:composability] They replace five separate families — one function per
-// ANSI colour name (`red`, `bright_blue`, …), `hex`, `rgb`, `color` (256-index),
-// and `on` (background). Every one of those encoded *which colour* in the
+// ANSI color name (`red`, `bright_blue`, …), `hex`, `rgb`, `color` (256-index),
+// and `on` (background). Every one of those encoded *which color* in the
 // function's identity, so the vocabulary could only grow by adding names, and
-// a colour computed at render time could not be applied at all. Here the colour
-// is an argument, so the sink admits every colour that exists and every colour
+// a color computed at render time could not be applied at all. Here the color
+// is an argument, so the sink admits every color that exists and every color
 // that will ever exist. Two functions, unbounded reach.
 //
 // [LAW:types-are-the-program] The slot accepts the full `ColorSpec.parse`
-// vocabulary, which is wider than the hex the colour math produces — and that
-// width is deliberate, not laxity. `#7aa2f7` is a *concrete* colour; `"red"`
+// vocabulary, which is wider than the hex the color math produces — and that
+// width is deliberate, not laxity. `#7aa2f7` is a *concrete* color; `"red"`
 // and `"color(42)"` are *symbolic* ones the terminal resolves against its own
-// theme. Only concrete colours can be darkened or blended, which is why the
-// colour-math functions take hex alone; but both kinds can be painted, so the
+// theme. Only concrete colors can be darkened or blended, which is why the
+// color-math functions take hex alone; but both kinds can be painted, so the
 // sink takes the union. The type of each slot is exactly the set of values that
 // slot can mean something for.
 function colorSinkFunc(slot) {
@@ -138,12 +138,12 @@ const linkFunc = {
 };
 // --- Public assembly ---
 /**
- * Text-styling registrations: the two colour sinks (`fg`, `bg`), text
+ * Text-styling registrations: the two color sinks (`fg`, `bg`), text
  * attributes (canonical names, short aliases, and `not_*` negations), the
  * hyperlink cell-splitter (`link`), and the multi-attribute `style` spec.
  *
- * Colours themselves come from elsewhere: `colorFuncs()` for the palette-free
- * math, `paletteFuncs()` for naming a theme colour. This module only paints.
+ * Colors themselves come from elsewhere: `colorFuncs()` for the palette-free
+ * math, `paletteFuncs()` for naming a theme color. This module only paints.
  * [LAW:one-way-deps] — nothing here imports a palette.
  */
 export function richTextStyleFuncs() {

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

@@ -1,5 +1,5 @@
 import { ColorRgba } from "../core/color.js";
-import { Palette, type PaletteRole, type PaletteRoles } from "./palette.js";
+import { Palette, type BaseRole, type PaletteRole, type PaletteRoles } from "./palette.js";
 /**
  * Base colors required to build a full semantic palette.
  * All are ColorRgba — callers construct from whatever source (hex, HSL, etc.).
@@ -16,17 +16,18 @@ export interface BaseColors {
 }
 /** The eight roles every palette is given, and every role it may also state. */
 export type StatedRoles = BaseColors & Partial<PaletteRoles>;
+export declare const BASE_KEYS: readonly BaseRole[];
 /** Every role of every palette, read off the rules. */
 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 most roles stated; see `RULES` for what a role
+ * 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
@@ -152,19 +152,19 @@ const RULES = {
     "scrollbar-background-hover": same("scrollbar-background"),
     "scrollbar-corner-color": same("scrollbar-background"),
 };
-const BASE_KEYS = [...ACCENT_KEYS, "background", "foreground"];
+export const BASE_KEYS = [...ACCENT_KEYS, "background", "foreground"];
 /** Every role of every palette, read off the rules. */
 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 most roles stated; see `RULES` for what a role
+ * 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;