@promptctl/rich-js 0.27.0 → 0.29.0

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
@@ -121,13 +121,14 @@ function onGrid(text, draw) {
  * blinks with the glyph. A wide glyph's box sits between the two: it inherits
  * the double underline, and the inner span inside it draws the other lines.
  */
-function runHtml({ text, look }) {
+function runHtml({ text, look, inVisualOrder }) {
     const drawn = look.underline === "double"
         ? span([...paintCss(look), "text-decoration-line:underline", "text-decoration-style:double", ...BLINK[look.blink]], onGrid(text, (glyph) => span([`color:${look.foreground.hex}`, ...glyphCss(look)], glyph)))
         : span([...paintCss(look), ...glyphCss(look)], onGrid(text, (glyph) => glyph));
+    const ordered = inVisualOrder ? span(["unicode-bidi:bidi-override"], drawn) : drawn;
     return look.href === null
-        ? drawn
-        : `<a href="${escapeAttribute(look.href)}" style="${ANCHOR_CSS}">${drawn}</a>`;
+        ? ordered
+        : `<a href="${escapeAttribute(look.href)}" style="${ANCHOR_CSS}">${ordered}</a>`;
 }
 /**
  * The CSS a page includes once, wherever fragments appear: what an inline

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.
  */
@@ -65,6 +65,8 @@ export interface ExportLook {
 export interface ExportRun {
     readonly text: string;
     readonly look: ExportLook;
+    /** Its cells are in display order already, so a browser must not reorder them. */
+    readonly inVisualOrder: boolean;
 }
 /** One terminal row, left to right. An empty array is a blank row. */
 export type ExportLine = readonly ExportRun[];
@@ -94,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`
@@ -31,6 +31,7 @@
  */
 import { blendRgb, ColorSpec } from "./color.js";
 import { NULL_STYLE } from "./style.js";
+import { sealed } from "./seal.js";
 /**
  * The URL schemes an export will link.
  *
@@ -81,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 {
@@ -93,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
@@ -129,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),
     };
@@ -146,13 +147,16 @@ export function resolveLook(style, theme) {
  */
 export function exportLines(segments, theme) {
     const rows = [[]];
-    for (const segment of segments) {
-        const look = resolveLook(segment.style ?? NULL_STYLE, theme);
+    // A browser is a display that reorders and holds the controls at zero width.
+    for (const segment of sealed(segments, "logical")) {
+        const style = segment.style ?? NULL_STYLE;
+        const look = resolveLook(style, theme);
+        const inVisualOrder = style.bidi?.order === "visual";
         segment.text.split("\n").forEach((piece, index) => {
             if (index > 0)
                 rows.push([]);
             if (piece.length > 0)
-                rows[rows.length - 1].push({ text: piece, look });
+                rows[rows.length - 1].push({ text: piece, look, inVisualOrder });
         });
     }
     return rows[rows.length - 1].length === 0 ? rows.slice(0, -1) : rows;

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
@@ -87,10 +87,10 @@ function chunk(text, column) {
 function place(rows) {
     return rows.flatMap((runs, row) => {
         let column = 0;
-        return runs.map(({ text, look }) => {
+        return runs.map(({ text, look, inVisualOrder }) => {
             const chunks = chunk(text, column);
             const cells = chunks.reduce((sum, c) => sum + c.cells, 0);
-            const placed = { row, column, cells, look, chunks };
+            const placed = { row, column, cells, look, inVisualOrder, chunks };
             column += cells;
             return placed;
         });
@@ -132,15 +132,16 @@ function backgroundSvg(run) {
         ? []
         : [`<rect fill="${run.look.background.hex}" ${cellBox(run)} shape-rendering="crispEdges"/>`];
 }
-function textSvg({ text, column, cells }, baseline) {
+function textSvg({ text, column, cells }, baseline, inVisualOrder) {
     // A chunk of no cells has no length to stretch to; it takes the font's.
     const length = cells === 0 ? "" : ` textLength="${n(cells * CELL_WIDTH)}" lengthAdjust="spacingAndGlyphs"`;
-    return `<text x="${n(column * CELL_WIDTH)}" y="${n(baseline)}"${length} xml:space="preserve">${escapeText(text)}</text>`;
+    const order = inVisualOrder ? ` unicode-bidi="bidi-override"` : "";
+    return `<text x="${n(column * CELL_WIDTH)}" y="${n(baseline)}"${length}${order} xml:space="preserve">${escapeText(text)}</text>`;
 }
 /**
  * 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;
@@ -155,7 +156,7 @@ function runSvg(run, className) {
     ];
     const radius = OUTLINE_RADIUS[look.outline];
     const drawn = [
-        ...run.chunks.map((c) => textSvg(c, baseline)),
+        ...run.chunks.map((c) => textSvg(c, baseline, run.inVisualOrder)),
         ...lineYs.map((y) => `<rect x="${x}" y="${n(y)}" width="${width}" height="${LINE_THICKNESS}"/>`),
         ...(radius === null
             ? []

package/dist/core/json.js

@@ -6,10 +6,13 @@
  * imports core primitives only. `Console.printJson` delegates here, so this is
  * where the console can reach it without an upward edge. [LAW:one-way-deps]
  */
+import { escaped } from "./bidi.js";
 import { RichText } from "./text.js";
 import { JSONHighlighter } from "./highlighter.js";
 import { measure, render } from "./protocol.js";
 const highlighter = new JSONHighlighter();
+/** `character` as JSON escapes, a surrogate pair for one past the BMP. */
+const jsonEscape = (character) => Array.from({ length: character.length }, (_, at) => `\\u${character.charCodeAt(at).toString(16).padStart(4, "0")}`).join("");
 export class JSONRenderable {
     text;
     constructor(text) {
@@ -38,8 +41,12 @@ export class JSONRenderable {
                 return value;
             }
             : undefined;
-        const jsonStr = JSON.stringify(data, replacer, indent);
-        const text = new RichText(jsonStr);
+        // `undefined` for what JSON has no form of, a function or a symbol, whatever its type says.
+        const jsonStr = JSON.stringify(data, replacer, indent) ?? "";
+        // Data on show: one string holds every key and value, so a control left in
+        // one would act on the rest of its line, and what content deletes or the wire
+        // withholds would leave a document that no longer parses back to this data.
+        const text = new RichText(escaped(jsonStr, jsonEscape));
         if (doHighlight) {
             highlighter.highlight(text);
         }

package/dist/core/markup.js

@@ -17,9 +17,10 @@
  * and is rejected with a `MarkupSyntaxError`. For the same reason a style tag
  * may not open on one side of a plugin tag and close on the other.
  */
+import { closed } from "./bidi.js";
 import { cellLen } from "./cells.js";
 import { Style, StyleSyntaxError } from "./style.js";
-import { RichText, stripControlChars } from "./text.js";
+import { RichText, sanitized } from "./text.js";
 import { emojiReplace } from "./emoji.js";
 import { pattern } from "./pattern.js";
 import { State } from "./state.js";
@@ -545,7 +546,7 @@ function walk(tokens, source, registry, emoji) {
             // counted along the way — a span, a splice point — indexes the text it
             // lands on. Stripped only by the constructor, a control character
             // shifted every style after it one cell right.
-            write(out, stripControlChars(emoji ? emojiReplace(text) : text));
+            write(out, sanitized(emoji ? emojiReplace(text) : text));
             continue;
         }
         const plugin = pluginOf(token, registry);
@@ -580,7 +581,7 @@ function walk(tokens, source, registry, emoji) {
         const children = compose(takeFrom(out, target.mark));
         const text = handler({ attrs, children, raw: source.slice(target.tag.end, token.start) });
         out.spliced.push({ at: out.length, text });
-        write(out, text.plain);
+        write(out, closed(text.plain));
     }
     // Close what is still open, innermost first. The reference pops its stack
     // here (`while style_stack: start, tag = style_stack.pop()`), and popping is
@@ -615,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.
  */

package/dist/core/oklch.d.ts

@@ -14,7 +14,7 @@
  * sRGB is the wire format terminals consume (what ANSI escape codes
  * carry); OKLCH is the perceptual manipulation space (where equal
  * numerical deltas mean equal perceptual deltas, which is the property
- * "transposition" requires). Two types, mutual conversion, no hybrid.
+ * "adjustment" requires). Two types, mutual conversion, no hybrid.
  *
  * [LAW:one-way-deps] This module imports `ColorRgba` from core/color and
  * nothing else from inside the project. Nothing in core/ depends back on
@@ -25,13 +25,13 @@ import { ColorRgba } from "./color.js";
  * A perceptually-uniform color transform.
  *
  * [LAW:dataflow-not-control-flow] Identity is *data* (`IDENTITY`), not a
- * special case. Every transposition runs the same code path — the values
+ * special case. Every adjustment runs the same code path — the values
  * decide whether the operation is a no-op or a 180° rotation.
  *
  * Lightness is parameterized as `L' = clamp01(L * scale + shift)` to make
  * "invert" expressible as `{scale: -1, shift: 1}` without a boolean knob.
  */
-export interface ThemeKey {
+export interface ColorAdjustment {
     /** Hue offset in degrees; positive rotates toward warmer→cooler→back. */
     readonly hueShift: number;
     /** Multiplier on chroma. 0 = grayscale, 1 = identity, >1 = more saturated. */
@@ -48,22 +48,22 @@ export interface OklchWeights {
     readonly h: number;
     readonly alpha: number;
 }
-export declare const IDENTITY: ThemeKey;
+export declare const IDENTITY: ColorAdjustment;
 /**
  * Flip lightness around the midpoint (`L' = 1 - L`) with hue and chroma
- * untouched. Combined with the anchor logic in `transposePalette`, this
+ * untouched. Combined with the anchor logic in `adjustPalette`, this
  * converts a dark theme to its light "octave": semantic anchors
  * (error/success/warning) still lightness-invert — only their *hue* is
  * preserved — so errors stay red and dark-on-light becomes light-on-dark.
  */
-export declare const INVERT_LIGHTNESS: ThemeKey;
+export declare const INVERT_LIGHTNESS: ColorAdjustment;
 /**
  * Whether a key is the no-op transform. Exported so that callers
- * (`transposePalette`) can fast-path byte-exact identity without going
+ * (`adjustPalette`) can fast-path byte-exact identity without going
  * through the lossy sRGB↔OKLCH round-trip. [LAW:one-source-of-truth] —
  * the predicate lives once, here.
  */
-export declare function isIdentityKey(k: ThemeKey): boolean;
+export declare function isIdentityKey(k: ColorAdjustment): boolean;
 export declare function srgbToLinear(v: number): number;
 export declare function linearToSrgb(v: number): number;
 /**
@@ -96,13 +96,13 @@ export declare class Oklch {
      */
     toRgba(): ColorRgba;
     /**
-     * Apply a `ThemeKey`. Returns a new `Oklch`; pure.
+     * Apply a `ColorAdjustment`. Returns a new `Oklch`; pure.
      *
      * [LAW:dataflow-not-control-flow] Identity short-circuits to `this` —
      * same shape as `ColorRgba.compositeOver(bg)` returning `this` when
      * `alpha === 1`. Callers invoke unconditionally; the data decides.
      */
-    applyKey(k: ThemeKey): Oklch;
+    applyKey(k: ColorAdjustment): Oklch;
     /**
      * The color `t` of the way from this one toward `toward`, in OKLCH.
      * `t = 0` is this color, `t = 1` is `toward`; pure.
@@ -115,7 +115,7 @@ export declare class Oklch {
      * that gains chroma, instead of rotating through the wheel from 0°.
      *
      * `t` must lie in [0, 1]: this is interpolation, not extrapolation, and a
-     * `t` outside it (NaN included) is a RangeError, never a colour off the
+     * `t` outside it (NaN included) is a RangeError, never a color off the
      * far end of the segment. [LAW:no-silent-failure]
      *
      * [LAW:one-source-of-truth] Achromatic means the same `ACHROMATIC_EPS`
@@ -133,19 +133,19 @@ export declare class Oklch {
      * whichever is called.
      *
      * It exists because perceptual axes are independent: a tint can take most of
-     * a hue's colourfulness while keeping close to the lightness it started at,
+     * a hue's colorfulness while keeping close to the lightness it started at,
      * which a single `t` cannot say — raising `t` for chroma drags lightness with
      * it. Every weight is required: an axis left out would need a default, and
      * "unchanged" (0) and "same as the others" are both plausible readings.
      *
-     * A weak `h` beside a strong `c` shows the starting colour's hue at high
+     * A weak `h` beside a strong `c` shows the starting color's hue at high
      * chroma. The powerless rule covers only a truly achromatic start, so a
      * near-grey whose hue is noise (a theme surface at c ≈ 0.004) keeps that
      * noise in proportion. To land on the target's hue, pass `h: 1`.
      */
     mixAxes(toward: Oklch, weights: OklchWeights): Oklch;
     /**
-     * ΔE_OK — the Euclidean distance between this colour and `other` in OKLab
+     * ΔE_OK — the Euclidean distance between this color and `other` in OKLab
      * (CSS Color 4's `deltaEOK`), where ~0.02 is the smallest difference the eye
      * resolves. Alpha is not a coordinate of the space and does not count.
      * Symmetric and pure.

package/dist/core/oklch.js

@@ -14,7 +14,7 @@
  * sRGB is the wire format terminals consume (what ANSI escape codes
  * carry); OKLCH is the perceptual manipulation space (where equal
  * numerical deltas mean equal perceptual deltas, which is the property
- * "transposition" requires). Two types, mutual conversion, no hybrid.
+ * "adjustment" requires). Two types, mutual conversion, no hybrid.
  *
  * [LAW:one-way-deps] This module imports `ColorRgba` from core/color and
  * nothing else from inside the project. Nothing in core/ depends back on
@@ -33,7 +33,7 @@ export const IDENTITY = Object.freeze({
 });
 /**
  * Flip lightness around the midpoint (`L' = 1 - L`) with hue and chroma
- * untouched. Combined with the anchor logic in `transposePalette`, this
+ * untouched. Combined with the anchor logic in `adjustPalette`, this
  * converts a dark theme to its light "octave": semantic anchors
  * (error/success/warning) still lightness-invert — only their *hue* is
  * preserved — so errors stay red and dark-on-light becomes light-on-dark.
@@ -46,7 +46,7 @@ export const INVERT_LIGHTNESS = Object.freeze({
 });
 /**
  * Whether a key is the no-op transform. Exported so that callers
- * (`transposePalette`) can fast-path byte-exact identity without going
+ * (`adjustPalette`) can fast-path byte-exact identity without going
  * through the lossy sRGB↔OKLCH round-trip. [LAW:one-source-of-truth] —
  * the predicate lives once, here.
  */
@@ -179,7 +179,7 @@ export class Oklch {
         return new ColorRgba(sR, sG, sB, this.alpha);
     }
     /**
-     * Apply a `ThemeKey`. Returns a new `Oklch`; pure.
+     * Apply a `ColorAdjustment`. Returns a new `Oklch`; pure.
      *
      * [LAW:dataflow-not-control-flow] Identity short-circuits to `this` —
      * same shape as `ColorRgba.compositeOver(bg)` returning `this` when
@@ -205,7 +205,7 @@ export class Oklch {
      * that gains chroma, instead of rotating through the wheel from 0°.
      *
      * `t` must lie in [0, 1]: this is interpolation, not extrapolation, and a
-     * `t` outside it (NaN included) is a RangeError, never a colour off the
+     * `t` outside it (NaN included) is a RangeError, never a color off the
      * far end of the segment. [LAW:no-silent-failure]
      *
      * [LAW:one-source-of-truth] Achromatic means the same `ACHROMATIC_EPS`
@@ -228,12 +228,12 @@ export class Oklch {
      * whichever is called.
      *
      * It exists because perceptual axes are independent: a tint can take most of
-     * a hue's colourfulness while keeping close to the lightness it started at,
+     * a hue's colorfulness while keeping close to the lightness it started at,
      * which a single `t` cannot say — raising `t` for chroma drags lightness with
      * it. Every weight is required: an axis left out would need a default, and
      * "unchanged" (0) and "same as the others" are both plausible readings.
      *
-     * A weak `h` beside a strong `c` shows the starting colour's hue at high
+     * A weak `h` beside a strong `c` shows the starting color's hue at high
      * chroma. The powerless rule covers only a truly achromatic start, so a
      * near-grey whose hue is noise (a theme surface at c ≈ 0.004) keeps that
      * noise in proportion. To land on the target's hue, pass `h: 1`.
@@ -265,7 +265,7 @@ export class Oklch {
         return new _a(lerp(this.l, toward.l, wl), c, hueOf(c, wrapHue(lerp(fromU, toU, wh))), lerp(this.alpha, toward.alpha, walpha));
     }
     /**
-     * ΔE_OK — the Euclidean distance between this colour and `other` in OKLab
+     * ΔE_OK — the Euclidean distance between this color and `other` in OKLab
      * (CSS Color 4's `deltaEOK`), where ~0.02 is the smallest difference the eye
      * resolves. Alpha is not a coordinate of the space and does not count.
      * Symmetric and pure.
@@ -276,9 +276,9 @@ export class Oklch {
         return Math.hypot(this.l - other.l, a - otherA, b - otherB);
     }
     /**
-     * This colour's OKLab a and b, kept with it: a colour matched against a
+     * This color's OKLab a and b, kept with it: a color matched against a
      * palette is measured against every entry, and each entry against every
-     * colour it is matched with, so the trigonometry is paid once a colour
+     * color it is matched with, so the trigonometry is paid once a color
      * rather than once a comparison.
      */
     #lab;

package/dist/core/orient.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Orienting a drawn line for its destination's `TextOrder`.
+ *
+ * Levels are resolved over the whole logical line and a row is ordered alone,
+ * because UAX #9 runs L1 and L2 after line breaking. So `directed` runs ahead of
+ * wrapping and each row's `orient` after it, and cuts fall on logical offsets in
+ * every order: what survives a cut is a logical prefix of the sentence, which is
+ * what a reader of either direction expects.
+ *
+ * [LAW:dataflow-not-control-flow] The order chooses values and never steps: a
+ * `plain` line passes through both.
+ */
+import { Segment } from "./segment.js";
+import { type Style } from "./style.js";
+import type { TextOrder } from "./text-order.js";
+/**
+ * The cells that end `text` and are no content: its whitespace, once what draws no
+ * cell among it is gone. A mark drawn on a space is not in it, because that space
+ * is a cell with something on it.
+ */
+export declare function drawnTail(text: string): string;
+/**
+ * The cells of trailing whitespace on a wrapped line.
+ *
+ * A wrap cuts before a word, so the line it closes ends with the whitespace
+ * that followed *its* last word — padding the break created, not content the
+ * author wrote. Measuring it is what lets the overflow method tell "this line
+ * was cut" from "this line ends in spaces" and stamp an ellipsis only on the
+ * first, and what keeps a centred line from drifting half a space off true.
+ *
+ * Asked of the line's text rather than walked back through its segments,
+ * because where a line ends is a fact about the characters and not about how
+ * they were split. Walking the segments made it a fact about both: it read a
+ * segment with no trailing whitespace as content and stopped there, which an
+ * empty segment also looks like — and a crop leaves one behind. A styled line
+ * whose last cells were cropped therefore reported no hanging whitespace at
+ * all and was centred as though it were content to the edge, so a span landing
+ * anywhere in a wrap's whitespace un-centred the line it closed. What draws no
+ * cell after the whitespace is no content either: `closed` writes a bidi control
+ * exactly there, and a cut leaves a zero-width code point that opened the next
+ * word on the row before it.
+ */
+export declare function hangingWhitespace(line: Segment[]): number;
+/** What a row of a directed line is, given the text it started as and its offset in the line. */
+export interface ReorderedLine {
+    /** The line to cut: X9's removals gone where the terminal will not need them. */
+    readonly line: readonly Segment[];
+    /** Whether a row's cells may not be merged with the padding beside them. */
+    readonly oriented: boolean;
+    /** A row of `source` at `start`: the segments it became, ready for padding. */
+    orient(shown: readonly Segment[], start: number, source: string): Segment[];
+}
+/** What `order` does with `line`, one logical line of drawn segments. */
+export declare function reorder(line: readonly Segment[], order: TextOrder): ReorderedLine;
+/** `text` as `order` measures it: what `directed` removes ahead of wrapping is no word. */
+export declare function measured(text: string, order: TextOrder): string;
+/** The offsets in `text`, one row, of the characters `order` shows at its left and right edges. */
+export declare function edges(text: string, order: TextOrder): {
+    readonly left: number;
+    readonly right: number;
+};
+/**
+ * A label set between `before` and `after`, which are frame and stay where they
+ * are, for a row drawn with no `RichText`: only the label is oriented, or a
+ * button's brackets would be mirrored around it. A label `directed` leaves alone
+ * is one segment with its frame, as it always was.
+ */
+export declare function labeled(before: string, label: string, after: string, style: Style | undefined, order: TextOrder | undefined): Segment[];