@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/core/easing.d.ts

@@ -22,7 +22,7 @@
  *   `elastic`, Robert Penner's curves at the constants every animation
  *   library since has shipped. An ease that leaves [0, 1] — a spring or a
  *   back curve overshooting its rest — is still an ease: a `ColorRamp` holds
- *   its end colours where it does, and an effect's `Curve` saturates at its
+ *   its end colors where it does, and an effect's `Curve` saturates at its
  *   swing, so the overshoot is read by what can show it (a position, a
  *   count) and clipped by what cannot.
  *
@@ -33,15 +33,15 @@
  * [LAW:one-type-per-behavior] An ease is a plain function value. CSS's named
  * curves are four instances of `cubicBezier`, not four implementations, the
  * spring in `EASES` is one `spring()`, and `ColorRamp` and every effect take
- * the same `Ease`.
+ * the same `Easing`.
  *
  * Tier 0 of `src/core/`: imports nothing, so `themes/` and every later
  * `core/` module reach it downhill. [LAW:one-way-deps]
  */
 /** Progress in [0, 1] in, progress out: a reshaping of [0, 1] that may leave it, as a spring overshooting its rest does. */
-export type Ease = (x: number) => number;
+export type Easing = (x: number) => number;
 /** Time in seconds (plus any per-cell offset) in, progress in [0, 1] out. */
-export type Phase = (t: number) => number;
+export type WrapMode = (t: number) => number;
 /**
  * CSS `cubic-bezier(x1, y1, x2, y2)`: the curve from (0, 0) to (1, 1) with
  * those two control points, read as y at a given x. `x1` and `x2` must lie in
@@ -49,7 +49,7 @@ export type Phase = (t: number) => number;
  * every input has exactly one output. `y1` and `y2` may leave [0, 1]; the
  * curve then overshoots, as a CSS "back" curve does.
  */
-export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): Ease;
+export declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): Easing;
 /**
  * Where a `steps()` curve jumps, in CSS's terms. `jump-start` jumps at 0,
  * `jump-end` at 1, `jump-both` at both, `jump-none` at neither; `start` and
@@ -62,11 +62,11 @@ export type StepPosition = "jump-start" | "jump-end" | "jump-none" | "jump-both"
  * `position` names — CSS's step algorithm, so `steps(1, "end")` is 0 until
  * the very end.
  */
-export declare function steps(n: number, position?: StepPosition): Ease;
+export declare function steps(n: number, position?: StepPosition): Easing;
 /**
  * The curve `shape` over [0, 1) as an ease that has arrived: its argument
  * held to [0, 1], and exactly 1 at 1. Every built-in ease is one, so the two
- * halves of the `Ease` contract — an argument in [0, 1], the end landed on —
+ * halves of the `Easing` contract — an argument in [0, 1], the end landed on —
  * are enforced here and nowhere else. [LAW:single-enforcer] The end matters
  * because a curve is 1 at its end only in the limit or up to a rounding — a
  * spring settles to within `SPRING_REST`, the elastic's ringing never quite
@@ -74,7 +74,7 @@ export declare function steps(n: number, position?: StepPosition): Ease;
  * and a count or a width eased by it must land on its target, not a
  * thousandth or an ulp short.
  */
-export declare const settled: (shape: (p: number) => number) => Ease;
+export declare const withSettlingTime: (shape: (p: number) => number) => Easing;
 /**
  * A spring's physics: the mass on it, the stiffness of its coil and the
  * damping it moves against, in the units every animation library spells them
@@ -93,19 +93,19 @@ export interface SpringOptions {
  * An ease over a duration: CSS's timing function and duration as one value,
  * the whole of what a one-shot move needs to know about time — a tween's
  * (`./tween.ts`), a `spring()`'s, and the part of an effect's `Curve` that
- * is not its swing. `Phase.once(start, seconds)` through `ease` is the move
+ * is not its swing. `WrapMode.once(start, seconds)` through `ease` is the move
  * on a timeline. [LAW:one-type-per-behavior] One shape, so a spring is handed
  * to a tween as it is, and a curve written for an effect times a tween.
  */
 export interface Timing {
     /** How the move is shaped, as progress in to progress out. */
-    readonly ease: Ease;
+    readonly ease: Easing;
     /** How long the move takes, in seconds. */
     readonly seconds: number;
 }
 /**
  * How close to its rest a spring must come to count as settled: one part in a
- * thousand of the way it moves, under a colour channel's step (1/255) and
+ * thousand of the way it moves, under a color channel's step (1/255) and
  * under any cell, so what rounds the spring's value to show it draws the rest
  * from there on.
  */
@@ -137,28 +137,28 @@ export declare function spring(options?: SpringOptions): Timing;
  * `seconds` are `DEFAULT_SPRING`'s; the rest are Penner's at his constants.
  */
 export declare const EASES: {
-    readonly linear: Ease;
-    readonly ease: Ease;
-    readonly "ease-in": Ease;
-    readonly "ease-out": Ease;
-    readonly "ease-in-out": Ease;
-    readonly "step-start": Ease;
-    readonly "step-end": Ease;
-    readonly step: Ease;
-    readonly sine: Ease;
-    readonly spring: Ease;
-    readonly bounce: Ease;
-    readonly "back-in": Ease;
-    readonly "back-out": Ease;
-    readonly elastic: Ease;
+    readonly linear: Easing;
+    readonly ease: Easing;
+    readonly "ease-in": Easing;
+    readonly "ease-out": Easing;
+    readonly "ease-in-out": Easing;
+    readonly "step-start": Easing;
+    readonly "step-end": Easing;
+    readonly step: Easing;
+    readonly sine: Easing;
+    readonly spring: Easing;
+    readonly bounce: Easing;
+    readonly "back-in": Easing;
+    readonly "back-out": Easing;
+    readonly elastic: Easing;
 };
-export type EaseName = keyof typeof EASES;
+export type EasingName = keyof typeof EASES;
 /**
  * The gate a spelled ease crosses. [LAW:parse-dont-validate] — a name in, the
  * function out, so nothing downstream holds a string it must check again.
  * Unknown names throw naming every legal one. [LAW:no-silent-failure]
  */
-export declare function parseEase(name: string): Ease;
+export declare function parseEasing(name: string): Easing;
 /** Throws, naming `what`, unless `seconds` is a positive, finite number of seconds. */
 export declare function positiveSeconds(what: string, seconds: number): void;
 /**
@@ -166,11 +166,11 @@ export declare function positiveSeconds(what: string, seconds: number): void;
  * way the frames of an animation are each held and then replaced. `at(t)` is
  * the index of the hold in progress at `t`, counted from the first hold at
  * `t = 0`, and the sequence wraps every `period` seconds, before zero too,
- * as `Phase.loop` wraps. With equal holds `at` is `steps(n)` read as an
+ * as `WrapMode.loop` wraps. With equal holds `at` is `steps(n)` read as an
  * index; the holds here may differ, which `steps` cannot say, so a frame
  * held for a second and the next for a quarter are one beat.
  */
-export interface Beat {
+export interface StepSequence {
     readonly holds: readonly number[];
     /** The sum of the holds: how long one pass takes, in seconds. */
     readonly period: number;
@@ -180,10 +180,10 @@ export interface Beat {
      * When the hold in progress at `t` began, in seconds on `t`'s own
      * timeline: what a sample-and-hold on this beat reads at `t`. Every `t`
      * inside one hold of one pass answers the same number, to the bit, so an
-     * effect handed it draws the same frame throughout. With `nextChange`,
+     * effect handed it draws the same frame throughout. With `validUntil`,
      * the two ends of the hold, as every `Animation` answers them.
      */
-    lastChange(t: number): number;
+    validFrom(t: number): number;
     /**
      * When the hold in progress at `t` ends, in seconds on `t`'s own timeline:
      * the start of the next hold, the first moment `at` places in it, so it is
@@ -191,9 +191,9 @@ export interface Beat {
      * With `at`, this makes a beat an `Animation` of the hold in progress
      * (`./animation.ts`).
      */
-    nextChange(t: number): number;
+    validUntil(t: number): number;
     /** The beat with its motion taken out: its first hold, held for good, as a loop holds its first value. */
-    reduced(): Beat;
+    reduced(): StepSequence;
 }
 /**
  * `t`, unless it is not a finite number of seconds, which throws naming
@@ -234,14 +234,14 @@ export declare function walkUp(sum: number, reached: (x: number) => boolean, fin
  * exact to the float and the cost is logarithmic in that distance.
  */
 export declare function firstReaching(near: number, reached: (x: number) => boolean): number;
-/** `holds` as a `Beat`; a beat with no hold, or a hold that is not a positive number of seconds, throws. */
-export declare function beat(holds: readonly number[]): Beat;
-/** The three phase shapes. Each takes seconds and returns a `Phase`. */
-export declare const Phase: {
+/** `holds` as a `StepSequence`; a beat with no hold, or a hold that is not a positive number of seconds, throws. */
+export declare function stepSequence(holds: readonly number[]): StepSequence;
+/** The three phase shapes. Each takes seconds and returns a `WrapMode`. */
+export declare const WrapMode: {
     /** 0 before `start`, rising to 1 over `duration` seconds, then held at 1. */
-    once(start: number, duration: number): Phase;
+    once(start: number, duration: number): WrapMode;
     /** 0 → 1 every `period` seconds, wrapping back to 0; negative `t` wraps too. */
-    loop(period: number): Phase;
+    loop(period: number): WrapMode;
     /** 0 → 1 → 0 every `period` seconds: there in the first half, back in the second. */
-    pingPong(period: number): Phase;
+    pingPong(period: number): WrapMode;
 };

package/dist/core/easing.js

@@ -22,7 +22,7 @@
  *   `elastic`, Robert Penner's curves at the constants every animation
  *   library since has shipped. An ease that leaves [0, 1] — a spring or a
  *   back curve overshooting its rest — is still an ease: a `ColorRamp` holds
- *   its end colours where it does, and an effect's `Curve` saturates at its
+ *   its end colors where it does, and an effect's `Curve` saturates at its
  *   swing, so the overshoot is read by what can show it (a position, a
  *   count) and clipped by what cannot.
  *
@@ -33,7 +33,7 @@
  * [LAW:one-type-per-behavior] An ease is a plain function value. CSS's named
  * curves are four instances of `cubicBezier`, not four implementations, the
  * spring in `EASES` is one `spring()`, and `ColorRamp` and every effect take
- * the same `Ease`.
+ * the same `Easing`.
  *
  * Tier 0 of `src/core/`: imports nothing, so `themes/` and every later
  * `core/` module reach it downhill. [LAW:one-way-deps]
@@ -91,7 +91,7 @@ export function cubicBezier(x1, y1, x2, y2) {
         }
         return s;
     };
-    return settled((p) => yAt(solve(p)));
+    return withSettlingTime((p) => yAt(solve(p)));
 }
 /**
  * CSS `steps(n, position)`: progress held flat in `n` equal intervals, jumping
@@ -115,12 +115,12 @@ export function steps(n, position = "jump-end") {
         "jump-none": n - 1,
     }[position];
     const lift = jumpsAtStart ? 1 : 0;
-    return settled((p) => Math.min(jumps, Math.floor(p * n) + lift) / jumps);
+    return withSettlingTime((p) => Math.min(jumps, Math.floor(p * n) + lift) / jumps);
 }
 /**
  * The curve `shape` over [0, 1) as an ease that has arrived: its argument
  * held to [0, 1], and exactly 1 at 1. Every built-in ease is one, so the two
- * halves of the `Ease` contract — an argument in [0, 1], the end landed on —
+ * halves of the `Easing` contract — an argument in [0, 1], the end landed on —
  * are enforced here and nowhere else. [LAW:single-enforcer] The end matters
  * because a curve is 1 at its end only in the limit or up to a rounding — a
  * spring settles to within `SPRING_REST`, the elastic's ringing never quite
@@ -128,19 +128,19 @@ export function steps(n, position = "jump-end") {
  * and a count or a width eased by it must land on its target, not a
  * thousandth or an ulp short.
  */
-export const settled = (shape) => (x) => {
+export const withSettlingTime = (shape) => (x) => {
     const p = Math.min(1, Math.max(0, x));
     return p === 1 ? 1 : shape(p);
 };
 /** The identity ease: progress unchanged. */
-const linear = settled((p) => p);
+const linear = withSettlingTime((p) => p);
 /** CSS `step-end`: 0 until the very end. */
 const stepEnd = steps(1, "jump-end");
 /** A half-cosine, flat at both ends: the curve a breathing pulse wants. */
-const sine = settled((p) => (1 - Math.cos(Math.PI * p)) / 2);
+const sine = withSettlingTime((p) => (1 - Math.cos(Math.PI * p)) / 2);
 /**
  * How close to its rest a spring must come to count as settled: one part in a
- * thousand of the way it moves, under a colour channel's step (1/255) and
+ * thousand of the way it moves, under a color channel's step (1/255) and
  * under any cell, so what rounds the spring's value to show it draws the rest
  * from there on.
  */
@@ -171,7 +171,7 @@ export function spring(options = {}) {
     const zeta = damping / (2 * Math.sqrt(stiffness * mass));
     const decay = zeta * w0;
     const { displacement, seconds } = zeta < 1 ? ringing(w0, zeta, decay) : creeping(w0, zeta, decay);
-    return { seconds, ease: settled((p) => 1 - displacement(p * seconds)) };
+    return { seconds, ease: withSettlingTime((p) => 1 - displacement(p * seconds)) };
 }
 /**
  * Where `|displacement|` falls through `SPRING_REST` between `lo` and `hi`,
@@ -258,7 +258,7 @@ const BOUNCE_ARCS = [
     { until: 2.5 / 2.75, centre: 2.25 / 2.75, floor: 0.9375 },
     { until: Number.POSITIVE_INFINITY, centre: 2.625 / 2.75, floor: 0.984375 },
 ];
-const bounce = settled((p) => {
+const bounce = withSettlingTime((p) => {
     // The last arc's `until` is unbounded, so an arc is always found.
     const arc = BOUNCE_ARCS.find(({ until }) => p < until);
     return 7.5625 * (p - arc.centre) ** 2 + arc.floor;
@@ -272,8 +272,8 @@ const bounce = settled((p) => {
  * and lands on 1 to the bit.
  */
 const BACK_OVERSHOOT = 1.70158;
-const backIn = settled((p) => p ** 3 + BACK_OVERSHOOT * p ** 2 * (p - 1));
-const backOut = settled((p) => {
+const backIn = withSettlingTime((p) => p ** 3 + BACK_OVERSHOOT * p ** 2 * (p - 1));
+const backOut = withSettlingTime((p) => {
     const q = p - 1;
     return 1 + q ** 3 + BACK_OVERSHOOT * q ** 2 * (q + 1);
 });
@@ -284,7 +284,7 @@ const backOut = settled((p) => {
  * last — `2^(−10x)·sin((10x − 0.75)·2π/3) + 1`.
  */
 const ELASTIC_PERIOD = (2 * Math.PI) / 3;
-const elastic = settled((p) => 2 ** (-10 * p) * Math.sin((10 * p - 0.75) * ELASTIC_PERIOD) + 1);
+const elastic = withSettlingTime((p) => 2 ** (-10 * p) * Math.sin((10 * p - 0.75) * ELASTIC_PERIOD) + 1);
 /**
  * Every built-in ease by the name a template spells it with — CSS's keyword
  * names, plus `sine`, plus `step`: the spelling `ColorRamp` used before this
@@ -314,7 +314,7 @@ export const EASES = {
  * function out, so nothing downstream holds a string it must check again.
  * Unknown names throw naming every legal one. [LAW:no-silent-failure]
  */
-export function parseEase(name) {
+export function parseEasing(name) {
     if (!Object.hasOwn(EASES, name)) {
         throw new RangeError(`unknown ease ${JSON.stringify(name)}; expected one of ` +
             Object.keys(EASES).map((n) => JSON.stringify(n)).join(", "));
@@ -335,8 +335,8 @@ const STILL = {
     holds: [Number.POSITIVE_INFINITY],
     period: Number.POSITIVE_INFINITY,
     at: () => 0,
-    lastChange: () => Number.NEGATIVE_INFINITY,
-    nextChange: () => Number.POSITIVE_INFINITY,
+    validFrom: () => Number.NEGATIVE_INFINITY,
+    validUntil: () => Number.POSITIVE_INFINITY,
     reduced: () => STILL,
 };
 /**
@@ -352,7 +352,7 @@ export function finiteTime(what, t) {
 /**
  * The seconds into the current pass of a `period` at `t`: `t` taken modulo
  * the period, into [0, period), before zero too. [LAW:single-enforcer] The
- * one wrap `Phase.loop` and `beat` both read time through, so a `t` that is
+ * one wrap `WrapMode.loop` and `beat` both read time through, so a `t` that is
  * not a finite number of seconds fails here, loudly, and nowhere else. A
  * `t` at or past zero is `t % period` alone, which is exact; only a negative
  * `t` is carried up by a period, so a boundary a host samples exactly lands
@@ -474,21 +474,21 @@ export function firstReaching(near, reached) {
             lo = mid;
     }
 }
-/** `holds` as a `Beat`; a beat with no hold, or a hold that is not a positive number of seconds, throws. */
-export function beat(holds) {
+/** `holds` as a `StepSequence`; a beat with no hold, or a hold that is not a positive number of seconds, throws. */
+export function stepSequence(holds) {
     if (holds.length === 0)
-        throw new RangeError("a beat needs at least one hold");
-    holds.forEach((hold, i) => positiveSeconds(`beat hold ${i}`, hold));
-    const period = holds.reduce((sum, hold) => sum + hold, 0);
+        throw new RangeError("a step sequence needs at least one step");
+    holds.forEach((validity, i) => positiveSeconds(`step ${i}`, validity));
+    const period = holds.reduce((sum, validity) => sum + validity, 0);
     // Where each hold begins, in seconds into the period: the unit
     // `wrapSeconds` answers in, so the sum a boundary sits at is the number
     // the wrap of a `t` on that boundary produces, and the hold that begins
     // there is the one in progress, at any rate the host samples.
     const starts = [];
     let elapsed = 0;
-    for (const hold of holds) {
+    for (const validity of holds) {
         starts.push(elapsed);
-        elapsed += hold;
+        elapsed += validity;
     }
     // A copy, and the one `at` walks: what `at` and `period` were built from
     // stays what `holds` says whatever the caller does to its array.
@@ -520,40 +520,40 @@ export function beat(holds) {
         holds: own,
         period,
         at(t) {
-            return index(wrapSeconds("Beat.at", t, period));
+            return index(wrapSeconds("StepSequence.at", t, period));
         },
-        lastChange(t) {
-            const { pass, into } = passAt("Beat.lastChange", t, period);
-            return boundary("Beat.lastChange", pass, index(into), t);
+        validFrom(t) {
+            const { pass, into } = passAt("StepSequence.validFrom", t, period);
+            return boundary("StepSequence.validFrom", pass, index(into), t);
         },
         // The next hold's start, in the next pass when this hold is the last.
-        nextChange(t) {
-            const { pass, into } = passAt("Beat.nextChange", t, period);
+        validUntil(t) {
+            const { pass, into } = passAt("StepSequence.validUntil", t, period);
             const i = index(into);
             const last = i === own.length - 1;
-            return boundary("Beat.nextChange", pass + (last ? 1 : 0), last ? 0 : i + 1, t);
+            return boundary("StepSequence.validUntil", pass + (last ? 1 : 0), last ? 0 : i + 1, t);
         },
         reduced: () => STILL,
     };
 }
-/** The three phase shapes. Each takes seconds and returns a `Phase`. */
-export const Phase = {
+/** The three phase shapes. Each takes seconds and returns a `WrapMode`. */
+export const WrapMode = {
     /** 0 before `start`, rising to 1 over `duration` seconds, then held at 1. */
     once(start, duration) {
         if (!Number.isFinite(start))
-            throw new RangeError(`Phase.once start must be finite, got ${start}`);
-        positiveSeconds("Phase.once duration", duration);
+            throw new RangeError(`WrapMode.once start must be finite, got ${start}`);
+        positiveSeconds("WrapMode.once duration", duration);
         return (t) => Math.min(1, Math.max(0, (t - start) / duration));
     },
     /** 0 → 1 every `period` seconds, wrapping back to 0; negative `t` wraps too. */
     loop(period) {
-        positiveSeconds("Phase.loop period", period);
-        return (t) => wrapSeconds("Phase.loop", t, period) / period;
+        positiveSeconds("WrapMode.loop period", period);
+        return (t) => wrapSeconds("WrapMode.loop", t, period) / period;
     },
     /** 0 → 1 → 0 every `period` seconds: there in the first half, back in the second. */
     pingPong(period) {
-        positiveSeconds("Phase.pingPong period", period);
-        const wrap = Phase.loop(period);
+        positiveSeconds("WrapMode.pingPong period", period);
+        const wrap = WrapMode.loop(period);
         return (t) => 1 - Math.abs(2 * wrap(t) - 1);
     },
 };

package/dist/core/env.d.ts

@@ -16,7 +16,7 @@
 export type Env = Readonly<Record<string, string | undefined>>;
 /**
  * A terminal that says it cannot be drawn on: `TERM` is `dumb` or `unknown`,
- * as Emacs' shell mode sets it. It takes no colour and nothing that moves the
+ * as Emacs' shell mode sets it. It takes no color and nothing that moves the
  * cursor.
  */
 export declare function isDumbTerminal(env: Env): boolean;

package/dist/core/env.js

@@ -15,7 +15,7 @@
  */
 /**
  * A terminal that says it cannot be drawn on: `TERM` is `dumb` or `unknown`,
- * as Emacs' shell mode sets it. It takes no colour and nothing that moves the
+ * as Emacs' shell mode sets it. It takes no color and nothing that moves the
  * cursor.
  */
 export function isDumbTerminal(env) {

package/dist/core/export-html.js

@@ -37,7 +37,7 @@ const OUTLINE = {
     encircle: [FRAME, "border-radius:0.5em"],
 };
 /**
- * The glyph colour, and the background when one is painted.
+ * The glyph color, and the background when one is painted.
  *
  * Dim arrives already blended into `foreground`. `opacity` is never written:
  * it fades a painted background along with the glyph, which is the bug the

package/dist/core/export-lines.d.ts

@@ -3,15 +3,15 @@
  * lines every exporter draws.
  *
  * The HTML and SVG exporters are two encodings of one picture, and this module
- * is the picture. What a styled cell *looks like* — which colour its glyph is,
+ * is the picture. What a styled cell *looks like* — which color its glyph is,
  * whether its background is painted, which decorations it carries, where it
  * links — is decided here, once, and an exporter decides only how to write
  * that down. Before it existed the decision was made twice, by a CSS method
  * on `Style` and by a private converter on `Console`, and the two had already
- * disagreed: one honoured `underline2`, the other dropped it.
+ * disagreed: one honoured `doubleUnderline`, the other dropped it.
  *
  * [LAW:types-are-the-program] `ExportLook` has no `reverse`, `dim`, `conceal`
- * or default colour, because all four are consumed by `resolveLook` and turned
+ * or default color, because all four are consumed by `resolveLook` and turned
  * into plain RGB. An exporter holding a look cannot forget to swap a reversed
  * run or to fade a dim one: there is nothing left in its hands to forget. That
  * is the whole reason the representation is resolved rather than a `Style`
@@ -44,7 +44,7 @@ export type Href = string & {
 };
 /**
  * Where a run's background comes from. `"canvas"` is the theme background
- * showing through — nothing painted — and is distinct from a painted colour
+ * showing through — nothing painted — and is distinct from a painted color
  * that happens to equal it, because `on default` and `on #000000` are
  * different requests even over a black theme.
  */
@@ -96,25 +96,25 @@ export interface ExportCanvas {
  * The ground every export is drawn on under `theme`.
  *
  * An exporter paints its page or window with this, and a run with no
- * background of its own resolves to `"canvas"` rather than a colour, so a run
- * showing the canvas and the page around it cannot come out different colours.
+ * background of its own resolves to `"canvas"` rather than a color, so a run
+ * showing the canvas and the page around it cannot come out different colors.
  */
 export declare function exportCanvas(theme?: TerminalTheme): ExportCanvas;
 /**
  * A `Style` as it appears on screen under `theme`.
  *
- * The order is the terminal's: the colours are `Style.drawnColors`, the ones
+ * The order is the terminal's: the colors are `Style.drawnColors`, the ones
  * `toSgrCodes` writes, resolved through the theme — `reverse` swaps them,
  * `dim` fades the glyph toward whatever background it ended up on, and
  * `conceal` finally paints the glyph in that background. Every step works on
- * opaque colour, so no exporter ever draws a translucent one. Text under
+ * opaque color, so no exporter ever draws a translucent one. Text under
  * `conceal` is still present, and still selectable, in both formats.
  *
- * A translucent colour is flattened where the writer flattens it, over
+ * A translucent color is flattened where the writer flattens it, over
  * `SURFACE_BLACK`, not over this export's canvas. The writer's truecolor
  * bytes are absolute — no terminal theme retints them — so a terminal under
- * `theme` shows that colour, and an export that flattened over its own canvas
- * would picture a colour no terminal draws.
+ * `theme` shows that color, and an export that flattened over its own canvas
+ * would picture a color no terminal draws.
  *
  * `theme` omitted is `ColorSpec.getTruecolor`'s own fallback — black canvas,
  * white ink, the standard ANSI table. Choosing it there rather than naming a

package/dist/core/export-lines.js

@@ -3,15 +3,15 @@
  * lines every exporter draws.
  *
  * The HTML and SVG exporters are two encodings of one picture, and this module
- * is the picture. What a styled cell *looks like* — which colour its glyph is,
+ * is the picture. What a styled cell *looks like* — which color its glyph is,
  * whether its background is painted, which decorations it carries, where it
  * links — is decided here, once, and an exporter decides only how to write
  * that down. Before it existed the decision was made twice, by a CSS method
  * on `Style` and by a private converter on `Console`, and the two had already
- * disagreed: one honoured `underline2`, the other dropped it.
+ * disagreed: one honoured `doubleUnderline`, the other dropped it.
  *
  * [LAW:types-are-the-program] `ExportLook` has no `reverse`, `dim`, `conceal`
- * or default colour, because all four are consumed by `resolveLook` and turned
+ * or default color, because all four are consumed by `resolveLook` and turned
  * into plain RGB. An exporter holding a look cannot forget to swap a reversed
  * run or to fade a dim one: there is nothing left in its hands to forget. That
  * is the whole reason the representation is resolved rather than a `Style`
@@ -82,8 +82,8 @@ const DEFAULT_COLOR = ColorSpec.default();
  * The ground every export is drawn on under `theme`.
  *
  * An exporter paints its page or window with this, and a run with no
- * background of its own resolves to `"canvas"` rather than a colour, so a run
- * showing the canvas and the page around it cannot come out different colours.
+ * background of its own resolves to `"canvas"` rather than a color, so a run
+ * showing the canvas and the page around it cannot come out different colors.
  */
 export function exportCanvas(theme) {
     return {
@@ -94,18 +94,18 @@ export function exportCanvas(theme) {
 /**
  * A `Style` as it appears on screen under `theme`.
  *
- * The order is the terminal's: the colours are `Style.drawnColors`, the ones
+ * The order is the terminal's: the colors are `Style.drawnColors`, the ones
  * `toSgrCodes` writes, resolved through the theme — `reverse` swaps them,
  * `dim` fades the glyph toward whatever background it ended up on, and
  * `conceal` finally paints the glyph in that background. Every step works on
- * opaque colour, so no exporter ever draws a translucent one. Text under
+ * opaque color, so no exporter ever draws a translucent one. Text under
  * `conceal` is still present, and still selectable, in both formats.
  *
- * A translucent colour is flattened where the writer flattens it, over
+ * A translucent color is flattened where the writer flattens it, over
  * `SURFACE_BLACK`, not over this export's canvas. The writer's truecolor
  * bytes are absolute — no terminal theme retints them — so a terminal under
- * `theme` shows that colour, and an export that flattened over its own canvas
- * would picture a colour no terminal draws.
+ * `theme` shows that color, and an export that flattened over its own canvas
+ * would picture a color no terminal draws.
  *
  * `theme` omitted is `ColorSpec.getTruecolor`'s own fallback — black canvas,
  * white ink, the standard ANSI table. Choosing it there rather than naming a
@@ -130,10 +130,10 @@ export function resolveLook(style, theme) {
         background,
         bold: style.bold === true,
         italic: style.italic === true,
-        underline: style.underline2 ? "double" : style.underline ? "single" : "none",
+        underline: style.doubleUnderline ? "double" : style.underline ? "single" : "none",
         strike: style.strike === true,
         overline: style.overline === true,
-        blink: style.blink2 ? "fast" : style.blink ? "slow" : "none",
+        blink: style.rapidBlink ? "fast" : style.blink ? "slow" : "none",
         outline: style.encircle ? "encircle" : style.frame ? "frame" : "none",
         href: style.link === undefined ? null : parseHref(style.link),
     };

package/dist/core/export-svg.d.ts

@@ -9,11 +9,11 @@
  *
  * The geometry is Rich's — a 20px character, a cell 0.61 of that wide, a row
  * 1.22 of it tall, the same margin and padding — so a screenshot of the same
- * program matches the library this ports. The frame's colour is not Rich's:
+ * program matches the library this ports. The frame's color is not Rich's:
  * Rich strokes it white at 35% whatever the theme, which vanishes around a
  * light canvas. Here it is the theme's ink blended 35% into the canvas — over
- * a black canvas the colour Rich draws — and opaque, so the half of the stroke
- * lying outside the canvas does not take on the colour of the page around it.
+ * a black canvas the color Rich draws — and opaque, so the half of the stroke
+ * lying outside the canvas does not take on the color of the page around it.
  *
  * Nor is how a glyph lands on its cell. The exporter has no font engine and
  * does not know which font the viewer will draw with, so no advance width can

package/dist/core/export-svg.js

@@ -9,11 +9,11 @@
  *
  * The geometry is Rich's — a 20px character, a cell 0.61 of that wide, a row
  * 1.22 of it tall, the same margin and padding — so a screenshot of the same
- * program matches the library this ports. The frame's colour is not Rich's:
+ * program matches the library this ports. The frame's color is not Rich's:
  * Rich strokes it white at 35% whatever the theme, which vanishes around a
  * light canvas. Here it is the theme's ink blended 35% into the canvas — over
- * a black canvas the colour Rich draws — and opaque, so the half of the stroke
- * lying outside the canvas does not take on the colour of the page around it.
+ * a black canvas the color Rich draws — and opaque, so the half of the stroke
+ * lying outside the canvas does not take on the color of the page around it.
  *
  * Nor is how a glyph lands on its cell. The exporter has no font engine and
  * does not know which font the viewer will draw with, so no advance width can
@@ -141,7 +141,7 @@ function textSvg({ text, column, cells }, baseline, inVisualOrder) {
 /**
  * One run: its glyphs, then its lines and outline over them, in a group whose
  * class carries the look — so the lines take the glyph's `fill` and blink
- * with it. The outline is a stroke, so it names its colour itself.
+ * with it. The outline is a stroke, so it names its color itself.
  */
 function runSvg(run, className) {
     const { look } = run;

package/dist/core/markup.js

@@ -616,7 +616,7 @@ function compose(frame, baseStyle) {
     // The reversal is the whole of the tie-break, not decoration.
     // `[red][blue]x[/blue][/red]` yields two spans that both start at 0, and a
     // stable sort leaves those in the order they arrived — closing order,
-    // innermost first — which is the outer colour winning. Reversed first, the
+    // innermost first — which is the outer color winning. Reversed first, the
     // outer arrives first and the inner repaints it (rich-markup-krk).
     const spans = [...frame.spans].reverse().sort((a, b) => a.start - b.start);
     const result = new RichText(frame.plain);

package/dist/core/memo.d.ts

@@ -1,7 +1,7 @@
 /**
  * memo — a string-keyed memo with a size bound: the one cache shape for a
  * pure computation whose keys a long-running host derives without end. A
- * statusline daemon redrawing a time-varying colour parses a new hex string,
+ * statusline daemon redrawing a time-varying color parses a new hex string,
  * matches a new RGB triple, measures a new cell, on every frame; a memo that
  * never evicts grows by one entry per frame for the life of the process.
  */

package/dist/core/memo.js

@@ -1,7 +1,7 @@
 /**
  * memo — a string-keyed memo with a size bound: the one cache shape for a
  * pure computation whose keys a long-running host derives without end. A
- * statusline daemon redrawing a time-varying colour parses a new hex string,
+ * statusline daemon redrawing a time-varying color parses a new hex string,
  * matches a new RGB triple, measures a new cell, on every frame; a memo that
  * never evicts grows by one entry per frame for the life of the process.
  */