@promptctl/rich-js 0.26.0 → 0.28.0

package/README.md

@@ -397,6 +397,7 @@ npm run demo
 | `npm run animation-playground` | animation-playground | Every kind of motion — tweens, moving ramps, a marching border, glyph and attribute effects, transitions, a list that comes and goes, a marquee, staggers and a blinking caret — on one timeline, with buttons to pause, reverse, scrub, change speed, reduce motion, drop to sixteen colours or none, and paint at one frame a second or sixty. |
 | `npm run markup-plugins` | rich-markup-plugins | Custom markup tags registered through `MarkupRegistry`. Prints once and exits. |
 | `npm run viewport` | rich-viewport | A selection you move through a list taller than its window with the arrow keys, `j`/`k`, PgUp/PgDn and Home/End, kept in view by `Viewport.ensureVisible`; the mouse wheel scrolls the window, and `q` quits. |
+| `npm run terminal-colors` | terminal-colors | Your terminal asked for its own foreground and background with OSC 10 and OSC 11, shown as swatches, and whether it answered or the colours are assumed. |
 | `npm run terminal-host` | terminal-host | Each key you press printed as the bytes the terminal sends for it, and each resize as the new size — a program written against `TerminalHost` alone. `examples/terminal-host/embed.ts` runs the same program on an xterm.js terminal in your own page. |
 
 `Ctrl-C` quits any demo that stays running.

package/THIRD-PARTY-NOTICES

@@ -107,3 +107,45 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+src/core/bidi-data.ts holds data derived from the Unicode Character Database.
+
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1991-2026 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING,
+INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR SOFTWARE, YOU
+UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS
+OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY,
+DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+data files and any associated documentation (the "Data Files") or software and
+any associated documentation (the "Software") to deal in the Data Files or
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of the Data Files
+or Software, and to permit persons to whom the Data Files or Software are
+furnished to do so, provided that either (a) this copyright and permission
+notice appear with all copies of the Data Files or Software, or (b) this
+copyright and permission notice appear in associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD
+PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE
+LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall not be
+used in advertising or otherwise to promote the sale, use or other dealings in
+these Data Files or Software without prior written authorization of the
+copyright holder.

package/dist/core/animation.d.ts

@@ -9,7 +9,8 @@
  * changes every frame, however close together they are drawn. An early
  * answer costs a host a frame that draws what the last one did; a late one
  * skips a change. So an animation that cannot say answers `t`, as
- * `continuous` does. A value drawn as cells carries this answer on every
+ * `continuous` does. An answer that depends on what the frame drew, an
+ * effect's, is told by that drawing (`Moves`). A value drawn as cells carries this answer on every
  * cell (`Style.hold`, both ends of the hold below), so a host holding
  * the composed frame reads it there (`Segment.nextChange`); a value that is
  * not drawn — a number, a colour — has `nextChange` as its only way to say
@@ -76,14 +77,31 @@ import { type Beat } from "./easing.js";
 import { type Measurable, type Motion, type Renderable, type RenderOptions } from "./protocol.js";
 import { Segment } from "./segment.js";
 import { Style, type Hold } from "./style.js";
+/**
+ * What a frame's drawing said of the hold the element named `key`, drawn at
+ * `t`, is in, or nothing if the frame heard of no such drawing: handed to an
+ * animation asked about a frame already drawn, so an answer only a drawing
+ * knows goes up through the combinators that remapped the time. It reads by
+ * `key` and not by the effect, which `reduced()` and a `repeat`'s `nth` build
+ * anew at each asking, and by `t`, since one element may be drawn at two
+ * moments. Parts sharing both share the intersection of what was drawn:
+ * narrower and never wider. A drawing a container hid, by not handing on its
+ * options, reads as none and stays early, unless a part sharing its key and
+ * `t` told. A measurement, which draws nothing, answers held for good for
+ * every part (`UNLAID`). An animation that does not read it ignores it, and
+ * one that forwards it to no part stays early. [LAW:one-source-of-truth] The
+ * frame's one drawing says it, so the answer cannot disagree with what the
+ * frame shows.
+ */
+export type Moves = (t: number, key: string) => Hold | undefined;
 /** A value of `T` at a time in seconds, and the hold it is in: what every animation answers, whatever its values. */
 export interface Timed<T> {
     /** The value at `t` seconds. */
     at(t: number): T;
     /** The first moment, never before `t`, at which the value may stop being `at(t)`: `t` while it moves, `Infinity` once it never will. */
-    nextChange(t: number): number;
+    nextChange(t: number, moves?: Moves): number;
     /** The last moment, never after `t`, at which the value may have become `at(t)`: `t` while it moves, `-Infinity` if it always was. */
-    lastChange(t: number): number;
+    lastChange(t: number, moves?: Moves): number;
     /** This animation with its motion taken out — a loop at its first value, a one-shot cut to its end — drawn in its place under reduced motion. */
     reduced(): Animation<T>;
 }
@@ -99,8 +117,6 @@ export type Animation<T> = Timed<T> & ([T] extends [Renderable] ? Renderable & M
 /** What a frame drawn at a time shows of an animation, and what that says. */
 export interface Shown<T> {
     readonly value: T;
-    /** The first moment, never before the time drawn at, the value may stop being this. */
-    readonly nextChange: number;
     /** The animation the value is drawn from: the one handed in, or under reduced motion its reduced form. */
     readonly drawn: Timed<T>;
     /** Whether it is the animation reduced: drawn under reduced motion, changing only where content does. */
@@ -115,8 +131,8 @@ export interface Shown<T> {
  * reduces every one.
  */
 export declare function shownAt<T>(animation: Timed<T>, t: number, motion: Motion): Shown<T>;
-/** The hold `shown`, drawn at `t`, is in: its animation's two answers there. */
-export declare function holdOf(shown: Shown<unknown>, t: number): Hold;
+/** The hold `shown`, drawn at `t`, is in: its animation's two answers there, given what its drawing said. */
+export declare function holdOf(shown: Shown<unknown>, t: number, moves?: Moves): Hold;
 /** The style saying a cell is in `hold`. */
 export declare function stamp(hold: Hold): Style;
 /**
@@ -137,14 +153,26 @@ export declare function stampFrame(segments: Iterable<Segment>, hold: Hold): Ite
  */
 export declare function frameTimeOf(options: RenderOptions): number;
 /**
- * An animation's face, `render`: drawn at the time of the frame it is drawn
- * in (`frameTimeOf`), the value `shownAt` picks, every segment stamped with
- * its hold there under whatever its own cells say, and the hold told to the
- * frame (`RenderOptions.onHold`), because a frame of no cells — an element
- * not yet entered — may have cells later, and must say when without taking a
- * row to say it in. A container — the library's or a user's — that draws its
- * children through `render` draws an animation among them with no word about
- * time: the hold goes back the way the time came in. [LAW:composability]
+ * An animation placed in the frame `options` draws: its value at the frame's
+ * time (`frameTimeOf`, `shownAt`), drawn whole by `draw` under the options it
+ * is handed, every segment then stamped with its hold there under whatever
+ * its own cells say, and the hold told to the frame (`RenderOptions.onHold`),
+ * because a frame of no cells — an element not yet entered — may have cells
+ * later, and must say when without taking a row to say it in. Drawn first,
+ * because the hold is asked with what the drawing said (`Moves`); each report
+ * goes on outward too, since a value drawn inside a placement in this value
+ * may be a part of an animation placed further out. [LAW:single-enforcer]
+ * The one placement: an animation of renderables (`placedRender`), an effect
+ * and a widget drawing one cell from an animation of its own (a caret's
+ * blink) place through it, so how a time reaches an animation and how its
+ * hold reaches the frame is written once.
+ */
+export declare function placed<T>(animation: Timed<T>, options: RenderOptions, draw: (value: T, options: RenderOptions) => Iterable<Segment>): Iterable<Segment>;
+/**
+ * An animation's face, `render`: `placed`, its value drawn as the renderable
+ * it is. A container — the library's or a user's — that draws its children
+ * through `render` draws an animation among them with no word about time:
+ * the hold goes back the way the time came in. [LAW:composability]
  */
 export declare function placedRender(animation: Timed<unknown>, options: RenderOptions): Iterable<Segment>;
 /**
@@ -169,6 +197,15 @@ export declare const Animation: {
      * renderables throws when it is drawn.
      */
     of<X extends Timed<unknown>>(timed: X): Faced<NoInfer<X>>;
+    /**
+     * Whether `animation` never changes again from `t`: a one-shot that has
+     * run, a loop at a depth that shows no motion. [LAW:single-enforcer] The
+     * one reading of "never": a `Transition`'s `done` and a lifecycle's
+     * arrived and gone moments are this, so what ends a one-shot is written
+     * once. An early answer the contract allows is a finite one, so `Infinity`
+     * is only ever a true never.
+     */
+    done(animation: Timed<unknown>, t: number): boolean;
     /** `value` at every time, never changing. */
     constant<T>(value: T): Animation<T>;
     /**

package/dist/core/animation.js

@@ -9,7 +9,8 @@
  * changes every frame, however close together they are drawn. An early
  * answer costs a host a frame that draws what the last one did; a late one
  * skips a change. So an animation that cannot say answers `t`, as
- * `continuous` does. A value drawn as cells carries this answer on every
+ * `continuous` does. An answer that depends on what the frame drew, an
+ * effect's, is told by that drawing (`Moves`). A value drawn as cells carries this answer on every
  * cell (`Style.hold`, both ends of the hold below), so a host holding
  * the composed frame reads it there (`Segment.nextChange`); a value that is
  * not drawn — a number, a colour — has `nextChange` as its only way to say
@@ -76,7 +77,7 @@ import { beat, firstReaching, passAt, positiveSeconds } from "./easing.js";
 import { Measurement } from "./measure.js";
 import { isRenderable, render } from "./protocol.js";
 import { Segment } from "./segment.js";
-import { Style } from "./style.js";
+import { intersection, NEVER_CHANGES, Style } from "./style.js";
 /**
  * What a frame drawn at `t` shows of `animation` under `motion`, and when
  * that changes: the animation's, or under reduced motion its reduced form's
@@ -88,11 +89,11 @@ import { Style } from "./style.js";
 export function shownAt(animation, t, motion) {
     const reduced = motion.reducedMotion === true;
     const drawn = reduced ? animation.reduced() : animation;
-    return { value: drawn.at(t), nextChange: drawn.nextChange(t), drawn, reduced };
+    return { value: drawn.at(t), drawn, reduced };
 }
-/** The hold `shown`, drawn at `t`, is in: its animation's two answers there. */
-export function holdOf(shown, t) {
-    return { lastChange: shown.drawn.lastChange(t), nextChange: shown.nextChange };
+/** The hold `shown`, drawn at `t`, is in: its animation's two answers there, given what its drawing said. */
+export function holdOf(shown, t, moves) {
+    return { lastChange: shown.drawn.lastChange(t, moves), nextChange: shown.drawn.nextChange(t, moves) };
 }
 /** The style saying a cell is in `hold`. */
 export function stamp(hold) {
@@ -126,22 +127,43 @@ function drawable(value) {
     return value;
 }
 /**
- * An animation's face, `render`: drawn at the time of the frame it is drawn
- * in (`frameTimeOf`), the value `shownAt` picks, every segment stamped with
- * its hold there under whatever its own cells say, and the hold told to the
- * frame (`RenderOptions.onHold`), because a frame of no cells — an element
- * not yet entered — may have cells later, and must say when without taking a
- * row to say it in. A container — the library's or a user's — that draws its
- * children through `render` draws an animation among them with no word about
- * time: the hold goes back the way the time came in. [LAW:composability]
+ * An animation placed in the frame `options` draws: its value at the frame's
+ * time (`frameTimeOf`, `shownAt`), drawn whole by `draw` under the options it
+ * is handed, every segment then stamped with its hold there under whatever
+ * its own cells say, and the hold told to the frame (`RenderOptions.onHold`),
+ * because a frame of no cells — an element not yet entered — may have cells
+ * later, and must say when without taking a row to say it in. Drawn first,
+ * because the hold is asked with what the drawing said (`Moves`); each report
+ * goes on outward too, since a value drawn inside a placement in this value
+ * may be a part of an animation placed further out. [LAW:single-enforcer]
+ * The one placement: an animation of renderables (`placedRender`), an effect
+ * and a widget drawing one cell from an animation of its own (a caret's
+ * blink) place through it, so how a time reaches an animation and how its
+ * hold reaches the frame is written once.
  */
-export function* placedRender(animation, options) {
+export function* placed(animation, options, draw) {
     const t = frameTimeOf(options);
     const shown = shownAt(animation, t, options);
-    const value = drawable(shown.value);
-    const hold = holdOf(shown, t);
+    const said = new Map();
+    const part = (at, key) => `${at} ${key}`;
+    const onMoved = (at, key, hold) => {
+        const known = said.get(part(at, key));
+        said.set(part(at, key), known === undefined ? hold : intersection(known, hold));
+        options.onMoved?.(at, key, hold);
+    };
+    const segments = [...draw(shown.value, { ...options, onMoved })];
+    const hold = holdOf(shown, t, (at, key) => said.get(part(at, key)));
     options.onHold?.(hold);
-    yield* stampFrame(render(value, options), hold);
+    yield* stampFrame(segments, hold);
+}
+/**
+ * An animation's face, `render`: `placed`, its value drawn as the renderable
+ * it is. A container — the library's or a user's — that draws its children
+ * through `render` draws an animation among them with no word about time:
+ * the hold goes back the way the time came in. [LAW:composability]
+ */
+export function placedRender(animation, options) {
+    return placed(animation, options, (value, drawing) => render(drawable(value), drawing));
 }
 /**
  * An animation's face, `measure`: what it shows at the frame's time, measured,
@@ -151,9 +173,16 @@ export function* placedRender(animation, options) {
 export function placedMeasure(animation, options) {
     const t = frameTimeOf(options);
     const shown = shownAt(animation, t, options);
-    options.onHold?.(holdOf(shown, t));
+    options.onHold?.(holdOf(shown, t, UNLAID));
     return Measurement.get(options, drawable(shown.value));
 }
+/**
+ * What a measurement's drawing would say: held for good. An effect changes
+ * how cells look and never which exist, so nothing it does can change a
+ * layout; a combinator's own switches and a child's holds still reach the
+ * measurement. [LAW:types-are-the-program]
+ */
+const UNLAID = () => NEVER_CHANGES;
 /**
  * Every member of `source`, its own and its class's, as own properties of a
  * new object: a method bound to `source`, a getter read off it live, a field
@@ -191,6 +220,17 @@ export const Animation = {
         });
         return faced;
     },
+    /**
+     * Whether `animation` never changes again from `t`: a one-shot that has
+     * run, a loop at a depth that shows no motion. [LAW:single-enforcer] The
+     * one reading of "never": a `Transition`'s `done` and a lifecycle's
+     * arrived and gone moments are this, so what ends a one-shot is written
+     * once. An early answer the contract allows is a finite one, so `Infinity`
+     * is only ever a true never.
+     */
+    done(animation, t) {
+        return animation.nextChange(t) === Number.POSITIVE_INFINITY;
+    },
     /** `value` at every time, never changing. */
     constant(value) {
         const still = Animation.of({ at: () => value, nextChange: () => Number.POSITIVE_INFINITY, lastChange: () => Number.NEGATIVE_INFINITY, reduced: () => still });
@@ -237,8 +277,8 @@ export const Animation = {
     map(animation, f) {
         return Animation.of({
             at: (t) => f(animation.at(t)),
-            nextChange: (t) => animation.nextChange(t),
-            lastChange: (t) => animation.lastChange(t),
+            nextChange: (t, moves) => animation.nextChange(t, moves),
+            lastChange: (t, moves) => animation.lastChange(t, moves),
             reduced: () => Animation.map(animation.reduced(), f),
         });
     },
@@ -255,8 +295,8 @@ export const Animation = {
             at: (t) => animations.map((animation) => animation.at(t)),
             // A fold, not a spread: a stagger over a table's rows is a list as long
             // as the table, past what an engine takes as arguments.
-            nextChange: (t) => animations.reduce((soonest, animation) => Math.min(soonest, animation.nextChange(t)), Number.POSITIVE_INFINITY),
-            lastChange: (t) => animations.reduce((latest, animation) => Math.max(latest, animation.lastChange(t)), Number.NEGATIVE_INFINITY),
+            nextChange: (t, moves) => animations.reduce((soonest, animation) => Math.min(soonest, animation.nextChange(t, moves)), Number.POSITIVE_INFINITY),
+            lastChange: (t, moves) => animations.reduce((latest, animation) => Math.max(latest, animation.lastChange(t, moves)), Number.NEGATIVE_INFINITY),
             reduced: () => Animation.all(animations.map((animation) => animation.reduced())),
         });
     },
@@ -275,8 +315,8 @@ export const Animation = {
     onBeat(animation, beat) {
         return Animation.of({
             at: (t) => animation.at(beat.lastChange(t)),
-            nextChange(t) {
-                const moved = animation.nextChange(beat.lastChange(t));
+            nextChange(t, moves) {
+                const moved = animation.nextChange(beat.lastChange(t), moves);
                 if (moved === Number.POSITIVE_INFINITY)
                     return moved;
                 const end = beat.nextChange(t);
@@ -285,8 +325,13 @@ export const Animation = {
                 return moved <= end ? end : beat.lastChange(moved) === moved ? moved : beat.nextChange(moved);
             },
             // The value held now began at this hold's start at the latest: an early
-            // answer where the animation had not moved by it, which the contract allows.
-            lastChange: (t) => beat.lastChange(t),
+            // answer where the animation had not moved by it, which the contract
+            // allows. One that always was never turned on any beat.
+            lastChange(t, moves) {
+                const began = beat.lastChange(t);
+                const moved = animation.lastChange(began, moves);
+                return moved === Number.NEGATIVE_INFINITY ? moved : began;
+            },
             // Reduced, nothing moves between beats, so there is nothing to sample on them.
             reduced: () => animation.reduced(),
         });
@@ -310,19 +355,19 @@ export const Animation = {
         const carried = (local) => (Number.isFinite(local) ? firstReaching(local + seconds, (x) => x - seconds >= local) : local);
         return Animation.of({
             at: (t) => (t - seconds >= 0 ? then.at(t - seconds) : first.at(t)),
-            nextChange(t) {
+            nextChange(t, moves) {
                 const into = t - seconds;
                 if (into < 0)
-                    return Math.min(first.nextChange(t), seconds);
-                return Math.max(t, carried(then.nextChange(into)));
+                    return Math.min(first.nextChange(t, moves), seconds);
+                return Math.max(t, carried(then.nextChange(into, moves)));
             },
             // After the switch the value became what it is at the switch or when
             // `then`'s did since, whichever is later; before it, when `first`'s did.
-            lastChange(t) {
+            lastChange(t, moves) {
                 const into = t - seconds;
                 if (into < 0)
-                    return first.lastChange(t);
-                return Math.min(t, Math.max(seconds, carried(then.lastChange(into))));
+                    return first.lastChange(t, moves);
+                return Math.min(t, Math.max(seconds, carried(then.lastChange(into, moves))));
             },
             reduced: () => Animation.sequence(first.reduced(), seconds, then.reduced()),
         });
@@ -360,14 +405,14 @@ export const Animation = {
                 const { pass, into } = passAt("Animation.repeat", t, period);
                 return nth(pass).at(into);
             },
-            nextChange(t) {
+            nextChange(t, moves) {
                 const { pass, into } = passAt("Animation.repeat", t, period);
-                return Math.max(t, Math.min(turns.nextChange(t), carried(pass, turns.lastChange(t), nth(pass).nextChange(into))));
+                return Math.max(t, Math.min(turns.nextChange(t), carried(pass, turns.lastChange(t), nth(pass).nextChange(into, moves))));
             },
-            lastChange(t) {
+            lastChange(t, moves) {
                 const { pass, into } = passAt("Animation.repeat", t, period);
                 const began = turns.lastChange(t);
-                return Math.min(t, Math.max(began, carried(pass, began, nth(pass).lastChange(into))));
+                return Math.min(t, Math.max(began, carried(pass, began, nth(pass).lastChange(into, moves))));
             },
             reduced: () => Animation.repeat(period, (n) => nth(n).reduced()),
         });

package/dist/core/ansi.d.ts

@@ -21,18 +21,25 @@
  *
  * Carriage returns are the other departure, and the same argument. Rich splits
  * lines with Python's `splitlines`, which also breaks at `\r`, so its `a\rb`
- * is two lines. Here a line ends only at `\n`, and `\r` returns to the first
- * column, so later text overwrites earlier text character by character:
- * `50%\r100%` is `100%`, `Downloading\rDone` is `Doneloading`, and `done\r`
- * is still `done`. Columns are counted in characters, not cells, so a wide
- * character overwritten by a narrow one is where this and a terminal differ.
- * Erase in line (`\x1b[K`) is honoured for the same reason, because a redraw
+ * is two lines. Here a line ends at `\n` and the census's other line breaks, and
+ * `\r` returns to the first column, so later text overwrites earlier text cell by
+ * cell: `50%\r100%` is `100%`, `Downloading\rDone` is `Doneloading`, and `done\r`
+ * is still `done`. Columns are a terminal's cells: a wide character takes two, a
+ * combining mark none, a tab moves to the next stop over what is there, and a wide
+ * character or a tab half overwritten leaves blanks. Erase in line (`\x1b[K`) is honoured for the same reason, because a redraw
  * is usually `\r\x1b[K` and the old text must not show through a shorter new
  * one.
  *
+ * Backspace is the third. Rich drops it; here it is nroff's overstrike, the
+ * adjacent `x BS x` bold and `_ BS x` underline that `man` writes, and a bare one
+ * moves back a column, so `12%\b\b\b13%` is the redraw it looks like. The bytes
+ * alone cannot tell `1\b1` the redraw from `1\b1` the bold, and `less` reads them
+ * as overstrike with no other evidence, so this does.
+ *
  * Everything else follows Rich: malformed SGR parameters are skipped rather
- * than refused, and every other escape is dropped. It is not a terminal
- * emulator — any other cursor movement is dropped, not performed.
+ * than refused, and every other escape is dropped, with every control a terminal
+ * draws nothing for. It is not a terminal emulator — any other cursor movement is
+ * dropped, not performed.
  *
  * Tier 5 of `src/core/`: it builds `RichText`, so it sits above `text`, and
  * `RichText` cannot offer a `fromAnsi` static without importing upward.

package/dist/core/ansi.js

@@ -21,48 +21,78 @@
  *
  * Carriage returns are the other departure, and the same argument. Rich splits
  * lines with Python's `splitlines`, which also breaks at `\r`, so its `a\rb`
- * is two lines. Here a line ends only at `\n`, and `\r` returns to the first
- * column, so later text overwrites earlier text character by character:
- * `50%\r100%` is `100%`, `Downloading\rDone` is `Doneloading`, and `done\r`
- * is still `done`. Columns are counted in characters, not cells, so a wide
- * character overwritten by a narrow one is where this and a terminal differ.
- * Erase in line (`\x1b[K`) is honoured for the same reason, because a redraw
+ * is two lines. Here a line ends at `\n` and the census's other line breaks, and
+ * `\r` returns to the first column, so later text overwrites earlier text cell by
+ * cell: `50%\r100%` is `100%`, `Downloading\rDone` is `Doneloading`, and `done\r`
+ * is still `done`. Columns are a terminal's cells: a wide character takes two, a
+ * combining mark none, a tab moves to the next stop over what is there, and a wide
+ * character or a tab half overwritten leaves blanks. Erase in line (`\x1b[K`) is honoured for the same reason, because a redraw
  * is usually `\r\x1b[K` and the old text must not show through a shorter new
  * one.
  *
+ * Backspace is the third. Rich drops it; here it is nroff's overstrike, the
+ * adjacent `x BS x` bold and `_ BS x` underline that `man` writes, and a bare one
+ * moves back a column, so `12%\b\b\b13%` is the redraw it looks like. The bytes
+ * alone cannot tell `1\b1` the redraw from `1\b1` the bold, and `less` reads them
+ * as overstrike with no other evidence, so this does.
+ *
  * Everything else follows Rich: malformed SGR parameters are skipped rather
- * than refused, and every other escape is dropped. It is not a terminal
- * emulator — any other cursor movement is dropped, not performed.
+ * than refused, and every other escape is dropped, with every control a terminal
+ * draws nothing for. It is not a terminal emulator — any other cursor movement is
+ * dropped, not performed.
  *
  * Tier 5 of `src/core/`: it builds `RichText`, so it sits above `text`, and
  * `RichText` cannot offer a `fromAnsi` static without importing upward.
  */
+import { cellLen, graphemes } from "./cells.js";
 import { ColorSpec } from "./color.js";
+import { controlClass } from "./control-codes.js";
 import { osc8Sequences } from "./osc8.js";
 import { ATTRIBUTE_NAMES, ATTRIBUTE_SGR, NULL_STYLE, Style } from "./style.js";
 import { RichText } from "./text.js";
+const BOLD = new Style({ bold: true });
+const UNDERLINED = new Style({ underline: true });
+const BOLD_UNDERLINED = BOLD.add(UNDERLINED);
+const STRING_ESCAPE = String.raw `\x1b[\]P_^X][^\n]*?(?:\x07|\x1b\\|\x9c|\n|$)`;
 /**
  * Every escape but OSC 8, which `osc8Sequences` reads before this runs. In
- * order: a carriage return; an SGR sequence (group 1, its parameters — a
- * private marker such as the `>` of `\x1b[>4;2m` makes it some other CSI);
- * erase in line (group 2, its mode); any other CSI sequence; any other string
- * escape — OSC, DCS, APC, PM, SOS — run to the terminators OSC 8 accepts or
- * cut off by the end of the line; any other escape, ECMA-48's intermediates
- * and one final byte (`\x1b(B`, `\x1b)0`, `\x1b#8`, `\x1bc`). Only the first
- * three become tokens.
+ * order: a carriage return; an SGR sequence (`sgr`, its parameters — a private
+ * marker such as the `>` of `\x1b[>4;2m` makes it some other CSI); erase in line
+ * (`mode`); any other CSI sequence; any other string escape — OSC, DCS, APC, PM,
+ * SOS — run to the terminators OSC 8 accepts or cut off by the end of the line;
+ * any other escape, ECMA-48's intermediates and one final byte (`\x1b(B`,
+ * `\x1b)0`, `\x1b#8`, `\x1bc`); a character struck over itself (`struck`), over an
+ * underscore first or not (`underscore`); a character struck over an underscore
+ * alone (`underlined`); a backspace; and every control a line may not hold or a
+ * terminal draws nothing for. The silent ones are the two "any other" escapes and
+ * that last class.
  */
-const escapes = () => /\r|\x1b\[([0-9;:]*)m|\x1b\[([012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[\]P_^X][\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[ -/]*[0-~]/g;
+const ESCAPES = [
+    String.raw `\r|\x1b\[(?<sgr>[0-9;:]*)m|\x1b\[(?<mode>[012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|${STRING_ESCAPE}|\x1b[ -/]*[0-~]`,
+    String.raw `(?<underscore>_\x08)?(?<struck>\P{Cc})(?:\x08\k<struck>)+|_\x08(?<underlined>\P{Cc})|\x08`,
+    controlClass((disposition) => disposition !== "keep" && disposition !== "withheld"),
+].join("|");
+const escapes = () => new RegExp(ESCAPES, "gu");
+// A string escape goes first so a line break in its payload stays in the payload.
+const lineBreaks = () => new RegExp(`${STRING_ESCAPE}|${controlClass((disposition) => disposition === "line-break")}`, "gu");
 function* escapeTokens(bytes) {
     let at = 0;
     for (const match of bytes.matchAll(escapes())) {
+        const { sgr, mode, underscore, struck, underlined } = match.groups;
         if (match.index > at)
             yield { kind: "text", text: bytes.slice(at, match.index) };
         if (match[0] === "\r")
             yield { kind: "return" };
-        if (match[1] !== undefined)
-            yield { kind: "sgr", params: match[1] };
-        if (match[2] !== undefined)
-            yield { kind: "erase", mode: (match[2] || "0") };
+        if (sgr !== undefined)
+            yield { kind: "sgr", params: sgr };
+        if (mode !== undefined)
+            yield { kind: "erase", mode: (mode || "0") };
+        if (struck !== undefined)
+            yield { kind: "overstrike", character: struck, emphasis: underscore === undefined ? BOLD : BOLD_UNDERLINED };
+        if (underlined !== undefined)
+            yield { kind: "overstrike", character: underlined, emphasis: UNDERLINED };
+        if (match[0] === "\b")
+            yield { kind: "backspace" };
         at = match.index + match[0].length;
     }
     if (at < bytes.length)
@@ -153,11 +183,52 @@ function applySgr(style, params) {
         result = (SGR_OPS.get(code) ?? identity)(result, codes);
     return result;
 }
+const ORIGIN = ["", NULL_STYLE];
 const BLANK = [" ", NULL_STYLE];
+const TAB_STOP = 8;
+/** The column holding the cluster drawn across `column`. */
+function leadOf(cells, column) {
+    let at = column;
+    while (at > 0 && cells[at][0] === "")
+        at -= 1;
+    return at;
+}
+/** A cluster across the edge before `column` goes blank, as on a terminal. */
+function splitWide(cells, column) {
+    if (cells[column]?.[0] !== "")
+        return;
+    const lead = leadOf(cells, column);
+    for (let at = lead; at === lead || cells[at]?.[0] === ""; at += 1)
+        cells[at] = BLANK;
+}
+/** `cluster` drawn at `column`, and the columns the cursor moves. */
+function draw(cells, column, cluster, style) {
+    const width = cluster === "\t" ? TAB_STOP - ((column - 1) % TAB_STOP) : cellLen(cluster);
+    if (width === 0) {
+        const lead = leadOf(cells, column - 1);
+        cells[lead] = [cells[lead][0] + cluster, cells[lead][1]];
+        return 0;
+    }
+    if (cluster === "\t" && column < cells.length) {
+        while (cells.length < column + width)
+            cells.push(BLANK);
+        return width;
+    }
+    splitWide(cells, column);
+    splitWide(cells, column + width);
+    cells[column] = [cells[0][0] + cluster, style];
+    cells[0] = ORIGIN;
+    for (let at = 1; at < width; at += 1)
+        cells[column + at] = ["", style];
+    return width;
+}
 /** Erase in line: the cells before the cursor go blank, the ones from it on go. */
 function erase(cells, column, mode) {
+    splitWide(cells, column);
+    splitWide(cells, column + 1);
+    cells[0] = ORIGIN;
     if (mode !== "0")
-        cells.fill(BLANK, 0, Math.min(column + 1, cells.length));
+        cells.fill(BLANK, 1, Math.min(column + 1, cells.length));
     if (mode !== "1")
         cells.length = Math.min(column, cells.length);
 }
@@ -173,25 +244,32 @@ export class AnsiDecoder {
     link = undefined;
     /** One `RichText` per line of `ansi`; a final newline ends a line rather than starting one. */
     decode(ansi) {
-        return (ansi.match(/[^\n]*\n|[^\n]+/g) ?? []).map((line) => this.decodeLine(line.replace(/\r?\n$/, "")));
+        const lined = ansi.replace(lineBreaks(), (found) => (found.startsWith("\x1b") ? found : "\n"));
+        return (lined.match(/[^\n]*\n|[^\n]+/g) ?? []).map((line) => this.decodeLine(line.replace(/\r?\n$/, "")));
     }
     /**
      * One line of output, holding no `\n`, written the way a terminal writes
      * it: `\r` returns to the first column, and text overwrites from there.
      */
     decodeLine(line) {
-        const cells = [];
-        let column = 0;
+        const cells = [ORIGIN];
+        let column = 1;
         for (const token of tokens(line)) {
             switch (token.kind) {
                 case "text": {
                     const style = this.sgr.withLink(this.link);
-                    for (const char of token.text)
-                        cells[column++] = [char, style];
+                    for (const cluster of graphemes(token.text))
+                        column += draw(cells, column, cluster, style);
                     break;
                 }
+                case "overstrike":
+                    column += draw(cells, column, token.character, this.sgr.add(token.emphasis).withLink(this.link));
+                    break;
                 case "return":
-                    column = 0;
+                    column = 1;
+                    break;
+                case "backspace":
+                    column = Math.max(1, column - 1);
                     break;
                 case "erase":
                     erase(cells, column, token.mode);
@@ -205,7 +283,7 @@ export class AnsiDecoder {
             }
         }
         const runs = [];
-        for (const [char, style] of cells) {
+        for (const [char, style] of cells.filter(([char]) => char !== "")) {
             const last = runs.at(-1);
             if (last?.[1].equals(style))
                 last[0] += char;