@promptctl/rich-js 0.27.0 → 0.29.0

package/dist/core/animation.js

@@ -2,23 +2,24 @@
  * Animation — a value for a time, and when it next changes: the one type
  * anything in rich-js that changes with time is an instance of.
  *
- * `at(t)` is the value at `t` seconds. `nextChange(t)` is the first moment,
+ * `at(t)` is the value at `t` seconds. `validUntil(t)` is the first moment,
  * on `t`'s own timeline, at which the value may stop being `at(t)`: never
  * before `t`. A later time says the value is held until then, `Infinity`
  * that it never changes again, and `t` itself that it is moving at `t` — it
  * 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 (`Reads`). 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
+ * the composed frame reads it there (`Segment.validUntil`); a value that is
+ * not drawn — a number, a color — has `validUntil` as its only way to say
  * when to look again.
  *
- * `lastChange(t)` is the other end of the same hold: the last moment, never
+ * `validFrom(t)` is the other end of the same hold: the last moment, never
  * after `t`, at which the value may have become `at(t)` — `-Infinity` if it
- * always was, `t` while it moves. Together they bound the hold, `[lastChange(t),
- * nextChange(t))`, and the answer may be narrower than the truth and never
+ * always was, `t` while it moves. Together they bound the hold, `[validFrom(t),
+ * validUntil(t))`, and the answer may be narrower than the truth and never
  * wider. It is what a host running the animation backwards reads
  * (`./timeline.ts`): run down the timeline, the value next changes where it
  * began. An animation that cannot say answers `t` here too.
@@ -37,10 +38,10 @@
  * which content shows is a fact about time that motion is not: a value with
  * no time could only show a scheduled exit as already gone.
  *
- * The instances already in the tree: a `Beat` is an animation of which hold
+ * The instances already in the tree: a `StepSequence` is an animation of which hold
  * is in progress (`./easing.ts`), a `FrameSequence` of the frame shown and a
  * `Spinner` of the spinner drawn (`../renderables/`), and an `Effect` is, for
- * what an element draws in a frame, an animation of how its cells' colours
+ * what an element draws in a frame, an animation of how its cells' colors
  * move (`../renderables/effect.ts`). Every kind of motion is one more.
  *
  * An animation of renderables is a renderable — its face, `placedRender`:
@@ -66,17 +67,17 @@
  * of motion is built from — a constant, a value moving every moment, a map
  * over the value, several at once, one animation after another, and one
  * played again every period — and each says how
- * `nextChange` composes, so an animation built from them answers it without
+ * `validUntil` composes, so an animation built from them answers it without
  * its author doing anything.
  *
  * Tier 5 of `src/core/`: `./easing.ts`, `./measure.ts`, `./protocol.ts`,
  * `./segment.ts` and `./style.ts`, nothing else. [LAW:one-way-deps]
  */
-import { beat, firstReaching, passAt, positiveSeconds } from "./easing.js";
+import { stepSequence, 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,25 +89,25 @@ 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 validityOf(shown, t, moves) {
+    return { validFrom: shown.drawn.validFrom(t, moves), validUntil: shown.drawn.validUntil(t, moves) };
 }
 /** The style saying a cell is in `hold`. */
-export function stamp(hold) {
-    return new Style({ hold });
+export function stampValidity(validity) {
+    return new Style({ validity });
 }
 /**
  * `segments`, every one carrying `hold` under whatever it already said: the
- * later `lastChange` and the sooner `nextChange` win (`Style.add`), so a
+ * later `validFrom` and the sooner `validUntil` win (`Style.add`), so a
  * frame's hold is the intersection of its cells', narrower than the truth
  * and never wider. [LAW:single-enforcer] The one way a time is put on drawn
  * cells, by whatever draws for a time it knows.
  */
-export function stampFrame(segments, hold) {
-    return Segment.applyStyle(segments, stamp(hold));
+export function stampValidityFrame(segments, validity) {
+    return Segment.applyStyle(segments, stampValidity(validity));
 }
 /**
  * The moment a frame drawn under `options` is drawn for: the frame's time,
@@ -127,22 +128,33 @@ function drawable(value) {
 }
 /**
  * An animation placed in the frame `options` draws: its value at the frame's
- * time (`frameTimeOf`, `shownAt`), drawn by `draw`, 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. [LAW:single-enforcer] The one placement: an
- * animation of renderables (`placedRender`) 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.
+ * 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.onValidity`),
+ * 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 (`Reads`); 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* placed(animation, options, draw) {
     const t = frameTimeOf(options);
     const shown = shownAt(animation, t, options);
-    const hold = holdOf(shown, t);
-    options.onHold?.(hold);
-    yield* stampFrame(draw(shown.value), hold);
+    const said = new Map();
+    const part = (at, key) => `${at} ${key}`;
+    const onReads = (at, key, validity) => {
+        const known = said.get(part(at, key));
+        said.set(part(at, key), known === undefined ? validity : intersection(known, validity));
+        options.onReads?.(at, key, validity);
+    };
+    const segments = [...draw(shown.value, { ...options, onReads })];
+    const validity = validityOf(shown, t, (at, key) => said.get(part(at, key)));
+    options.onValidity?.(validity);
+    yield* stampValidityFrame(segments, validity);
 }
 /**
  * An animation's face, `render`: `placed`, its value drawn as the renderable
@@ -151,19 +163,26 @@ export function* placed(animation, options, draw) {
  * the hold goes back the way the time came in. [LAW:composability]
  */
 export function placedRender(animation, options) {
-    return placed(animation, options, (value) => render(drawable(value), 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,
- * and its hold there told (`RenderOptions.onHold`), because a container lays
+ * and its hold there told (`RenderOptions.onValidity`), because a container lays
  * out from the measurement and must lay out again when it changes.
  */
 export function placedMeasure(animation, options) {
     const t = frameTimeOf(options);
     const shown = shownAt(animation, t, options);
-    options.onHold?.(holdOf(shown, t));
+    options.onValidity?.(validityOf(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
@@ -210,11 +229,11 @@ export const Animation = {
      * is only ever a true never.
      */
     done(animation, t) {
-        return animation.nextChange(t) === Number.POSITIVE_INFINITY;
+        return animation.validUntil(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 });
+        const still = Animation.of({ at: () => value, validUntil: () => Number.POSITIVE_INFINITY, validFrom: () => Number.NEGATIVE_INFINITY, reduced: () => still });
         return still;
     },
     /**
@@ -224,8 +243,8 @@ export const Animation = {
     cut(before, after) {
         const cut = Animation.of({
             at: (t) => (t < 0 ? before : after),
-            nextChange: (t) => (t < 0 ? 0 : Number.POSITIVE_INFINITY),
-            lastChange: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : 0),
+            validUntil: (t) => (t < 0 ? 0 : Number.POSITIVE_INFINITY),
+            validFrom: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : 0),
             reduced: () => cut,
         });
         return cut;
@@ -237,7 +256,7 @@ export const Animation = {
      * it says its own end (`transition`, `../renderables/effects.ts`).
      */
     continuous(at) {
-        return Animation.of({ at, nextChange: (t) => t, lastChange: (t) => t, reduced: () => Animation.constant(at(0)) });
+        return Animation.of({ at, validUntil: (t) => t, validFrom: (t) => t, reduced: () => Animation.constant(at(0)) });
     },
     /**
      * The time itself, in seconds, moving at every moment: what a clock, a
@@ -248,7 +267,7 @@ export const Animation = {
      * [LAW:types-are-the-program]
      */
     time() {
-        const time = Animation.of({ at: (t) => t, nextChange: (t) => t, lastChange: (t) => t, reduced: () => time });
+        const time = Animation.of({ at: (t) => t, validUntil: (t) => t, validFrom: (t) => t, reduced: () => time });
         return time;
     },
     /**
@@ -258,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),
+            validUntil: (t, moves) => animation.validUntil(t, moves),
+            validFrom: (t, moves) => animation.validFrom(t, moves),
             reduced: () => Animation.map(animation.reduced(), f),
         });
     },
@@ -276,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),
+            validUntil: (t, moves) => animations.reduce((soonest, animation) => Math.min(soonest, animation.validUntil(t, moves)), Number.POSITIVE_INFINITY),
+            validFrom: (t, moves) => animations.reduce((latest, animation) => Math.max(latest, animation.validFrom(t, moves)), Number.NEGATIVE_INFINITY),
             reduced: () => Animation.all(animations.map((animation) => animation.reduced())),
         });
     },
@@ -293,21 +312,26 @@ export const Animation = {
      * [LAW:one-source-of-truth] The one stepping rule, for an effect's frames
      * and a transition's schedule alike.
      */
-    onBeat(animation, beat) {
+    sampleAndHold(animation, stepSequence) {
         return Animation.of({
-            at: (t) => animation.at(beat.lastChange(t)),
-            nextChange(t) {
-                const moved = animation.nextChange(beat.lastChange(t));
+            at: (t) => animation.at(stepSequence.validFrom(t)),
+            validUntil(t, moves) {
+                const moved = animation.validUntil(stepSequence.validFrom(t), moves);
                 if (moved === Number.POSITIVE_INFINITY)
                     return moved;
-                const end = beat.nextChange(t);
+                const end = stepSequence.validUntil(t);
                 // The hold boundaries after `t` are `end`, then each hold's end in turn;
                 // the value turns at the first one the animation has moved by.
-                return moved <= end ? end : beat.lastChange(moved) === moved ? moved : beat.nextChange(moved);
+                return moved <= end ? end : stepSequence.validFrom(moved) === moved ? moved : stepSequence.validUntil(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.
+            validFrom(t, moves) {
+                const began = stepSequence.validFrom(t);
+                const moved = animation.validFrom(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(),
         });
@@ -331,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) {
+            validUntil(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.validUntil(t, moves), seconds);
+                return Math.max(t, carried(then.validUntil(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) {
+            validFrom(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.validFrom(t, moves);
+                return Math.min(t, Math.max(seconds, carried(then.validFrom(into, moves))));
             },
             reduced: () => Animation.sequence(first.reduced(), seconds, then.reduced()),
         });
@@ -363,10 +387,10 @@ export const Animation = {
     repeat(period, nth) {
         positiveSeconds("Animation.repeat period", period);
         // [LAW:single-enforcer] Which turn a time is in, and how far into it, is
-        // `passAt`, the wrap a `beat` and `Phase.loop` read time through, so a
+        // `passAt`, the wrap a `beat` and `WrapMode.loop` read time through, so a
         // repeat beside a loop of the same period turns on the same float; where
         // a turn begins and the next begins are a one-hold beat's two ends.
-        const turns = beat([period]);
+        const turns = stepSequence([period]);
         // The turn's moment `local`, on its own clock, carried onto this one: the
         // first float the wrap places at or past `local` in turn `n`, or in a
         // later turn, found as `sequence` carries its second part's.
@@ -381,14 +405,14 @@ export const Animation = {
                 const { pass, into } = passAt("Animation.repeat", t, period);
                 return nth(pass).at(into);
             },
-            nextChange(t) {
+            validUntil(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.validUntil(t), carried(pass, turns.validFrom(t), nth(pass).validUntil(into, moves))));
             },
-            lastChange(t) {
+            validFrom(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))));
+                const began = turns.validFrom(t);
+                return Math.min(t, Math.max(began, carried(pass, began, nth(pass).validFrom(into, moves))));
             },
             reduced: () => Animation.repeat(period, (n) => nth(n).reduced()),
         });

package/dist/core/ansi.d.ts

@@ -7,12 +7,12 @@
  * own `new Console()`, a CLI's output shown inside a Panel, a log replayed into
  * a Table cell.
  *
- * [LAW:types-are-the-program] Every colour decodes to the `ColorSpec` its
- * escape names — `31` the standard colour 1, `38;5;n` palette index n,
+ * [LAW:types-are-the-program] Every color decodes to the `ColorSpec` its
+ * escape names — `31` the standard color 1, `38;5;n` palette index n,
  * `38;2;r;g;b` that truecolor — and none is resolved to RGB here. A standard
- * colour is a slot in whatever theme draws it, so one captured run exports
+ * color is a slot in whatever theme draws it, so one captured run exports
  * correctly under a light theme and a dark one; resolved here, dark mode would
- * show light mode's colours. Resolution belongs to `export-lines`.
+ * show light mode's colors. Resolution belongs to `export-lines`.
  *
  * [LAW:types-are-the-program] The link is decoder state of its own, beside
  * the SGR style, not a field of it: a terminal ends a hyperlink only at an OSC
@@ -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

@@ -7,12 +7,12 @@
  * own `new Console()`, a CLI's output shown inside a Panel, a log replayed into
  * a Table cell.
  *
- * [LAW:types-are-the-program] Every colour decodes to the `ColorSpec` its
- * escape names — `31` the standard colour 1, `38;5;n` palette index n,
+ * [LAW:types-are-the-program] Every color decodes to the `ColorSpec` its
+ * escape names — `31` the standard color 1, `38;5;n` palette index n,
  * `38;2;r;g;b` that truecolor — and none is resolved to RGB here. A standard
- * colour is a slot in whatever theme draws it, so one captured run exports
+ * color is a slot in whatever theme draws it, so one captured run exports
  * correctly under a light theme and a dark one; resolved here, dark mode would
- * show light mode's colours. Resolution belongs to `export-lines`.
+ * show light mode's colors. Resolution belongs to `export-lines`.
  *
  * [LAW:types-are-the-program] The link is decoder state of its own, beside
  * the SGR style, not a field of it: a terminal ends a hyperlink only at an OSC
@@ -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 !== "zeroWidth"),
+].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)
@@ -90,7 +120,7 @@ function next(rest) {
 }
 /**
  * `5;n` or `2;r;g;b`, the arguments of `38` and `48`. A sequence cut short
- * names no colour, and the codes it did consume are spent, as in Rich.
+ * names no color, and the codes it did consume are spent, as in Rich.
  */
 function extendedColor(rest) {
     const kind = next(rest);
@@ -115,8 +145,8 @@ const SGR_OPS = new Map([
     [23, adding({ italic: false })],
     // ECMA-48: 24 is "neither singly nor doubly underlined", 25 "steady" at
     // either speed. Rich's table clears only the first of each pair.
-    [24, adding({ underline: false, underline2: false })],
-    [25, adding({ blink: false, blink2: false })],
+    [24, adding({ underline: false, doubleUnderline: false })],
+    [25, adding({ blink: false, rapidBlink: false })],
     [27, adding({ reverse: false })],
     [28, adding({ conceal: false })],
     [29, adding({ strike: false })],
@@ -124,7 +154,7 @@ const SGR_OPS = new Map([
     [39, adding({ color: ColorSpec.default() })],
     [48, (style, rest) => style.add(new Style({ bgcolor: extendedColor(rest) }))],
     [49, adding({ bgcolor: ColorSpec.default() })],
-    // Underline colour has no field on Style; its arguments are still spent, or
+    // Underline color has no field on Style; its arguments are still spent, or
     // `58;2;1;2;3` would read on as bold, dim and italic.
     [58, (style, rest) => (extendedColor(rest), style)],
     [54, adding({ frame: false, encircle: false })],
@@ -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;