@promptctl/rich-js 0.24.0 → 0.25.0

package/dist/core/animation.js

@@ -0,0 +1,375 @@
+/**
+ * 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,
+ * 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
+ * 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
+ * when to look again.
+ *
+ * `lastChange(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
+ * 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.
+ *
+ * `reduced()` is the same animation with its motion taken out: what it shows,
+ * and when it starts and stops showing it, kept; every moment between two
+ * values skipped. A loop holds its first value, a one-shot cuts to its end
+ * when it starts, a transition to its new state, a stagger has everyone arrived, and an element is
+ * there from when it entered until it is told to leave. Terminals have no
+ * `prefers-reduced-motion`, so a host is told (`reducedMotion`,
+ * `./protocol.ts`), and under it draws every animation's reduced form, which
+ * wakes it only where content changes. It is the one place the preference is
+ * honoured for every kind at once, because every kind is this type, and each
+ * combinator says its reduced form so a built animation answers it too.
+ * [LAW:types-are-the-program] It is an animation and not a value because
+ * 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
+ * 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
+ * move (`../renderables/effect.ts`). Every kind of motion is one more.
+ *
+ * An animation of renderables is a renderable — its face, `placedRender`:
+ * placed as the child of any container — a `Panel`, a `Table` cell, a
+ * `Group`, a container a user wrote — it draws at the time of the frame it
+ * is drawn in (`RenderOptions.frame`; 0, its own start, when printed) and
+ * stamps its cells with its hold there, under whatever its value's cells
+ * already say, so a frame's hold is the intersection of its cells' holds.
+ * [LAW:composability] No time is threaded through the code that places it,
+ * and no container knows animations exist. An animation placed inside
+ * another's value draws at the frame's time too: a combinator remaps the
+ * time it hands its parts, never a value's contents, so content that should
+ * follow a part's clock is composed into the part (`map`, `all`) and the
+ * result placed. [LAW:one-source-of-truth]
+ *
+ * [LAW:no-ambient-temporal-coupling] Pure: `t` is an argument and never a
+ * clock read (`./clock.ts`), the same `t` gives the same value, nothing is
+ * kept between calls, and a call costs the same at `t = 0` and `t = 10⁶`, so
+ * a host sampling once a second and one sampling sixty times see the same
+ * value at every `t` they share.
+ *
+ * [LAW:one-type-per-behavior] The combinators here are the ones every kind
+ * 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
+ * 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 { Measurement } from "./measure.js";
+import { isRenderable, render } from "./protocol.js";
+import { Segment } from "./segment.js";
+import { 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
+ * (`reduced`). [LAW:single-enforcer] The one place the preference is read:
+ * every placed animation (`placedRender`), every effect, a spinner and
+ * the template functions choose here, so a host told once
+ * reduces every one.
+ */
+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 };
+}
+/** 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 style saying a cell is in `hold`. */
+export function stamp(hold) {
+    return new Style({ hold });
+}
+/**
+ * `segments`, every one carrying `hold` under whatever it already said: the
+ * later `lastChange` and the sooner `nextChange` 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));
+}
+/**
+ * The moment a frame drawn under `options` is drawn for: the frame's time,
+ * which the host writes once a frame (`RenderOptions.frame`), or with no
+ * frame — a `print` — 0, the start of an animation's own clock, the one
+ * moment it can name without reading one. [LAW:one-source-of-truth] Nothing
+ * else hands a placed animation its time, so an animation inside another's
+ * value draws at the frame's time too, never at a time a combinator mapped.
+ */
+export function frameTimeOf(options) {
+    return options.frame?.time ?? 0;
+}
+/** `value` as what an animation's face draws. [LAW:no-silent-failure] An animation of numbers made through `Animation.of` has a face at runtime and nothing to draw. */
+function drawable(value) {
+    if (!isRenderable(value))
+        throw new TypeError("an Animation is drawn only when its values are renderables; place what it maps to (Animation.map)");
+    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]
+ */
+export function* placedRender(animation, options) {
+    const t = frameTimeOf(options);
+    const shown = shownAt(animation, t, options);
+    const value = drawable(shown.value);
+    const hold = holdOf(shown, t);
+    options.onHold?.(hold);
+    yield* stampFrame(render(value, options), hold);
+}
+/**
+ * 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
+ * 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));
+    return Measurement.get(options, drawable(shown.value));
+}
+/**
+ * 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
+ * as it is. So a class instance keeps its methods, and a spread of the copy
+ * is whole.
+ */
+function membersOf(source) {
+    const copy = {};
+    for (let layer = source; layer !== null && layer !== Object.prototype; layer = Object.getPrototypeOf(layer)) {
+        for (const key of Reflect.ownKeys(layer)) {
+            if (key === "constructor" || Object.hasOwn(copy, key))
+                continue;
+            const member = Object.getOwnPropertyDescriptor(layer, key);
+            Object.defineProperty(copy, key, member.get !== undefined
+                ? { enumerable: true, configurable: true, get: () => Reflect.get(source, key) }
+                : { enumerable: true, configurable: true, writable: true, value: typeof member.value === "function" ? member.value.bind(source) : member.value });
+        }
+    }
+    return copy;
+}
+export const Animation = {
+    /**
+     * `timed` as an animation: every member it carries kept (`membersOf`),
+     * with the face its values call for — `render` and `measure`,
+     * drawing it at the frame's time. Every animation made from a literal is
+     * made here, the library's and a user's alike. [LAW:single-enforcer] The
+     * one cast in the type: a literal's `T` is not known at runtime, so every
+     * animation made here has the face, and one whose values are not
+     * renderables throws when it is drawn.
+     */
+    of(timed) {
+        const faced = Object.assign(membersOf(timed), {
+            render: (options) => placedRender(faced, options),
+            measure: (options) => placedMeasure(faced, options),
+        });
+        return faced;
+    },
+    /** `value` at every time, never changing. */
+    constant(value) {
+        const still = Animation.of({ at: () => value, nextChange: () => Number.POSITIVE_INFINITY, lastChange: () => Number.NEGATIVE_INFINITY, reduced: () => still });
+        return still;
+    },
+    /**
+     * `before` until 0, then `after`: an instant change at 0 — a cut, what a
+     * one-shot is with its motion taken out, its start kept and its end at once.
+     */
+    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),
+            reduced: () => cut,
+        });
+        return cut;
+    },
+    /**
+     * The value `at` gives, taken to move at every moment: what an animation
+     * that cannot say when it holds still is, so a host draws it every frame.
+     * Reduced, it holds its first value, as a loop does; a one-shot built on
+     * 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)) });
+    },
+    /**
+     * The time itself, in seconds, moving at every moment: what a clock, a
+     * counter or anything else that reports the time is mapped from. It is
+     * information and not motion, so reduced it is itself, and a clock shown
+     * to a reader who wants no motion still keeps the time; motion computed
+     * from the time is `continuous`, which reduced holds still.
+     * [LAW:types-are-the-program]
+     */
+    time() {
+        const time = Animation.of({ at: (t) => t, nextChange: (t) => t, lastChange: (t) => t, reduced: () => time });
+        return time;
+    },
+    /**
+     * `animation`'s value through `f`, changing when it does. Two values `f`
+     * maps alike make an early answer, which the contract allows.
+     */
+    map(animation, f) {
+        return Animation.of({
+            at: (t) => f(animation.at(t)),
+            nextChange: (t) => animation.nextChange(t),
+            lastChange: (t) => animation.lastChange(t),
+            reduced: () => Animation.map(animation.reduced(), f),
+        });
+    },
+    /**
+     * Every one of `animations` at once, their values in order, changing when
+     * the soonest of them does — so a stack of effects drawn together holds
+     * still exactly while each of them does, and reduced each reduced — a
+     * stagger with every child arrived. None never changes.
+     */
+    all(animations) {
+        return Animation.of({
+            // [LAW:types-are-the-program] Each value at its own place in the tuple,
+            // which `map` cannot say of its array.
+            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),
+            reduced: () => Animation.all(animations.map((animation) => animation.reduced())),
+        });
+    },
+    /**
+     * `animation` sampled once a hold of `beat`: within a hold, its value at
+     * the hold's start, and at each hold's start it moves on. It changes at the
+     * first hold's start the sampled animation has moved by: the end of this
+     * hold for one that moves every moment, the hold its next change falls in
+     * for one that holds longer, and never for one that never changes again.
+     * The answer is read off what the animation says, never a comparison of
+     * values, so one that is back on the same value by the next hold still
+     * turns the beat there, an early answer the contract allows.
+     * [LAW:one-source-of-truth] The one stepping rule, for an effect's frames
+     * and a transition's schedule alike.
+     */
+    onBeat(animation, beat) {
+        return Animation.of({
+            at: (t) => animation.at(beat.lastChange(t)),
+            nextChange(t) {
+                const moved = animation.nextChange(beat.lastChange(t));
+                if (moved === Number.POSITIVE_INFINITY)
+                    return moved;
+                const end = beat.nextChange(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);
+            },
+            // 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),
+            // Reduced, nothing moves between beats, so there is nothing to sample on them.
+            reduced: () => animation.reduced(),
+        });
+    },
+    /**
+     * `first` until `seconds`, then `then`, handed the time since it began —
+     * each part on its own clock from 0, as every effect is. Before the switch
+     * the value next changes when `first`'s does or at the switch, whichever is
+     * sooner; after it, when `then`'s does, carried back onto this timeline.
+     * Reduced, each part is reduced and the switch kept, so what either shows
+     * shows on time; a one-shot that is the motion into what follows says its
+     * own end (`transition`, `../renderables/effects.ts`).
+     */
+    sequence(first, seconds, then) {
+        positiveSeconds("Animation.sequence seconds", seconds);
+        // `then`'s moment `local`, on its own clock, carried back onto this
+        // timeline: the first moment whose time since the switch reaches
+        // `local`, which the sum `local + seconds` can round to either side of —
+        // under it, where `at` still shows the old value, or over it, a float
+        // after the change showed.
+        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) {
+                const into = t - seconds;
+                if (into < 0)
+                    return Math.min(first.nextChange(t), seconds);
+                return Math.max(t, carried(then.nextChange(into)));
+            },
+            // 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) {
+                const into = t - seconds;
+                if (into < 0)
+                    return first.lastChange(t);
+                return Math.min(t, Math.max(seconds, carried(then.lastChange(into))));
+            },
+            reduced: () => Animation.sequence(first.reduced(), seconds, then.reduced()),
+        });
+    },
+    /**
+     * `nth(n)` for every time in the `n`th turn, `[n·period, (n+1)·period)`,
+     * handed the time since that turn began — a one-shot played again every
+     * `period` seconds, a different one each turn if `nth` says so. `n` is any
+     * integer, so a timeline run back past 0 is in turn −1. Within a turn the
+     * value next changes when the turn's does or at the next turn, whichever is
+     * sooner, and became what it is when the turn's did or at this turn's start,
+     * whichever is later: run backwards, a host wakes where the turn began.
+     * Reduced, each turn is reduced and the turns kept, so a turn showing
+     * something new still shows it on time and a one-shot inside cuts to its
+     * end there. Nothing is walked through: a call reads only its turn.
+     */
+    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
+        // 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]);
+        // 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.
+        const carried = (n, began, local) => Number.isFinite(local)
+            ? firstReaching(began + local, (x) => {
+                const { pass, into } = passAt("Animation.repeat", x, period);
+                return pass > n || (pass === n && into >= local);
+            })
+            : local;
+        return Animation.of({
+            at: (t) => {
+                const { pass, into } = passAt("Animation.repeat", t, period);
+                return nth(pass).at(into);
+            },
+            nextChange(t) {
+                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))));
+            },
+            lastChange(t) {
+                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))));
+            },
+            reduced: () => Animation.repeat(period, (n) => nth(n).reduced()),
+        });
+    },
+};

package/dist/core/ansi.js

@@ -51,10 +51,10 @@ import { RichText } from "./text.js";
  * and one final byte (`\x1b(B`, `\x1b)0`, `\x1b#8`, `\x1bc`). Only the first
  * three become tokens.
  */
-const ESCAPE = /\r|\x1b\[([0-9;:]*)m|\x1b\[([012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[\]P_^X][\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[ -/]*[0-~]/g;
+const escapes = () => /\r|\x1b\[([0-9;:]*)m|\x1b\[([012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|\x1b[\]P_^X][\s\S]*?(?:\x07|\x1b\\|\x9c|$)|\x1b[ -/]*[0-~]/g;
 function* escapeTokens(bytes) {
     let at = 0;
-    for (const match of bytes.matchAll(ESCAPE)) {
+    for (const match of bytes.matchAll(escapes())) {
         if (match.index > at)
             yield { kind: "text", text: bytes.slice(at, match.index) };
         if (match[0] === "\r")

package/dist/core/box.d.ts

@@ -28,19 +28,19 @@ import { Segment } from "./segment.js";
 import type { Style } from "./style.js";
 /** A rule spanning the table: the top and bottom borders, and every separator. */
 export interface EdgeChars {
-    left: string;
-    horizontal: string;
-    cross: string;
-    right: string;
+    readonly left: string;
+    readonly horizontal: string;
+    readonly cross: string;
+    readonly right: string;
 }
 /**
  * The verticals framing a row of cells. A content line of the grid has no
  * horizontal of its own — its fill column is a placeholder the cells occupy.
  */
 export interface ContentChars {
-    left: string;
-    vertical: string;
-    right: string;
+    readonly left: string;
+    readonly vertical: string;
+    readonly right: string;
 }
 export type RowLevel = "head" | "row" | "foot" | "mid";
 export interface SubstituteOptions {

package/dist/core/cell-widths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The cells Rich's `cell_len` gives each code point, and the code points VS16
+ * widens. Generated by scripts/cell-widths.py from Rich 15.0.0's Unicode 17.0.0
+ * table, which Rich builds from wcwidth's data; regenerate rather than edit.
+ */
+/** The cells Rich gives `codePoint` on its own: none for a C0 or C1 control. */
+export declare function codePointWidth(codePoint: number): 0 | 1 | 2;
+/** Whether VS16 after `codePoint` widens it from one cell to two. */
+export declare function widensToEmoji(codePoint: number): boolean;

package/dist/core/cell-widths.js

@@ -0,0 +1,140 @@
+/**
+ * The cells Rich's `cell_len` gives each code point, and the code points VS16
+ * widens. Generated by scripts/cell-widths.py from Rich 15.0.0's Unicode 17.0.0
+ * table, which Rich builds from wcwidth's data; regenerate rather than edit.
+ */
+// Every range of code points that does not take one cell, as [first, last,
+// cells]: ascending, disjoint, adjacent ranges of one width merged.
+const RANGES = [
+    [0x0, 0x0, 0], [0x300, 0x36f, 0], [0x483, 0x489, 0], [0x591, 0x5bd, 0], [0x5bf, 0x5bf, 0], [0x5c1, 0x5c2, 0],
+    [0x5c4, 0x5c5, 0], [0x5c7, 0x5c7, 0], [0x610, 0x61a, 0], [0x61c, 0x61c, 0], [0x64b, 0x65f, 0], [0x670, 0x670, 0],
+    [0x6d6, 0x6dc, 0], [0x6df, 0x6e4, 0], [0x6e7, 0x6e8, 0], [0x6ea, 0x6ed, 0], [0x711, 0x711, 0], [0x730, 0x74a, 0],
+    [0x7a6, 0x7b0, 0], [0x7eb, 0x7f3, 0], [0x7fd, 0x7fd, 0], [0x816, 0x819, 0], [0x81b, 0x823, 0], [0x825, 0x827, 0],
+    [0x829, 0x82d, 0], [0x859, 0x85b, 0], [0x897, 0x89f, 0], [0x8ca, 0x8e1, 0], [0x8e3, 0x903, 0], [0x93a, 0x93c, 0],
+    [0x93e, 0x94f, 0], [0x951, 0x957, 0], [0x962, 0x963, 0], [0x981, 0x983, 0], [0x9bc, 0x9bc, 0], [0x9be, 0x9c4, 0],
+    [0x9c7, 0x9c8, 0], [0x9cb, 0x9cd, 0], [0x9d7, 0x9d7, 0], [0x9e2, 0x9e3, 0], [0x9fe, 0x9fe, 0], [0xa01, 0xa03, 0],
+    [0xa3c, 0xa3c, 0], [0xa3e, 0xa42, 0], [0xa47, 0xa48, 0], [0xa4b, 0xa4d, 0], [0xa51, 0xa51, 0], [0xa70, 0xa71, 0],
+    [0xa75, 0xa75, 0], [0xa81, 0xa83, 0], [0xabc, 0xabc, 0], [0xabe, 0xac5, 0], [0xac7, 0xac9, 0], [0xacb, 0xacd, 0],
+    [0xae2, 0xae3, 0], [0xafa, 0xaff, 0], [0xb01, 0xb03, 0], [0xb3c, 0xb3c, 0], [0xb3e, 0xb44, 0], [0xb47, 0xb48, 0],
+    [0xb4b, 0xb4d, 0], [0xb55, 0xb57, 0], [0xb62, 0xb63, 0], [0xb82, 0xb82, 0], [0xbbe, 0xbc2, 0], [0xbc6, 0xbc8, 0],
+    [0xbca, 0xbcd, 0], [0xbd7, 0xbd7, 0], [0xc00, 0xc04, 0], [0xc3c, 0xc3c, 0], [0xc3e, 0xc44, 0], [0xc46, 0xc48, 0],
+    [0xc4a, 0xc4d, 0], [0xc55, 0xc56, 0], [0xc62, 0xc63, 0], [0xc81, 0xc83, 0], [0xcbc, 0xcbc, 0], [0xcbe, 0xcc4, 0],
+    [0xcc6, 0xcc8, 0], [0xcca, 0xccd, 0], [0xcd5, 0xcd6, 0], [0xce2, 0xce3, 0], [0xcf3, 0xcf3, 0], [0xd00, 0xd03, 0],
+    [0xd3b, 0xd3c, 0], [0xd3e, 0xd44, 0], [0xd46, 0xd48, 0], [0xd4a, 0xd4d, 0], [0xd57, 0xd57, 0], [0xd62, 0xd63, 0],
+    [0xd81, 0xd83, 0], [0xdca, 0xdca, 0], [0xdcf, 0xdd4, 0], [0xdd6, 0xdd6, 0], [0xdd8, 0xddf, 0], [0xdf2, 0xdf3, 0],
+    [0xe31, 0xe31, 0], [0xe34, 0xe3a, 0], [0xe47, 0xe4e, 0], [0xeb1, 0xeb1, 0], [0xeb4, 0xebc, 0], [0xec8, 0xece, 0],
+    [0xf18, 0xf19, 0], [0xf35, 0xf35, 0], [0xf37, 0xf37, 0], [0xf39, 0xf39, 0], [0xf3e, 0xf3f, 0], [0xf71, 0xf84, 0],
+    [0xf86, 0xf87, 0], [0xf8d, 0xf97, 0], [0xf99, 0xfbc, 0], [0xfc6, 0xfc6, 0], [0x102b, 0x103e, 0], [0x1056, 0x1059, 0],
+    [0x105e, 0x1060, 0], [0x1062, 0x1064, 0], [0x1067, 0x106d, 0], [0x1071, 0x1074, 0], [0x1082, 0x108d, 0],
+    [0x108f, 0x108f, 0], [0x109a, 0x109d, 0], [0x1100, 0x115f, 2], [0x1160, 0x11ff, 0], [0x135d, 0x135f, 0],
+    [0x1712, 0x1715, 0], [0x1732, 0x1734, 0], [0x1752, 0x1753, 0], [0x1772, 0x1773, 0], [0x17b4, 0x17d3, 0],
+    [0x17dd, 0x17dd, 0], [0x180b, 0x180f, 0], [0x1885, 0x1886, 0], [0x18a9, 0x18a9, 0], [0x1920, 0x192b, 0],
+    [0x1930, 0x193b, 0], [0x1a17, 0x1a1b, 0], [0x1a55, 0x1a5e, 0], [0x1a60, 0x1a7c, 0], [0x1a7f, 0x1a7f, 0],
+    [0x1ab0, 0x1add, 0], [0x1ae0, 0x1aeb, 0], [0x1b00, 0x1b04, 0], [0x1b34, 0x1b44, 0], [0x1b6b, 0x1b73, 0],
+    [0x1b80, 0x1b82, 0], [0x1ba1, 0x1bad, 0], [0x1be6, 0x1bf3, 0], [0x1c24, 0x1c37, 0], [0x1cd0, 0x1cd2, 0],
+    [0x1cd4, 0x1ce8, 0], [0x1ced, 0x1ced, 0], [0x1cf4, 0x1cf4, 0], [0x1cf7, 0x1cf9, 0], [0x1dc0, 0x1dff, 0],
+    [0x200b, 0x200f, 0], [0x2028, 0x202e, 0], [0x2060, 0x206f, 0], [0x20d0, 0x20f0, 0], [0x231a, 0x231b, 2],
+    [0x2329, 0x232a, 2], [0x23e9, 0x23ec, 2], [0x23f0, 0x23f0, 2], [0x23f3, 0x23f3, 2], [0x25fd, 0x25fe, 2],
+    [0x2614, 0x2615, 2], [0x2630, 0x2637, 2], [0x2648, 0x2653, 2], [0x267f, 0x267f, 2], [0x268a, 0x268f, 2],
+    [0x2693, 0x2693, 2], [0x26a1, 0x26a1, 2], [0x26aa, 0x26ab, 2], [0x26bd, 0x26be, 2], [0x26c4, 0x26c5, 2],
+    [0x26ce, 0x26ce, 2], [0x26d4, 0x26d4, 2], [0x26ea, 0x26ea, 2], [0x26f2, 0x26f3, 2], [0x26f5, 0x26f5, 2],
+    [0x26fa, 0x26fa, 2], [0x26fd, 0x26fd, 2], [0x2705, 0x2705, 2], [0x270a, 0x270b, 2], [0x2728, 0x2728, 2],
+    [0x274c, 0x274c, 2], [0x274e, 0x274e, 2], [0x2753, 0x2755, 2], [0x2757, 0x2757, 2], [0x2795, 0x2797, 2],
+    [0x27b0, 0x27b0, 2], [0x27bf, 0x27bf, 2], [0x2b1b, 0x2b1c, 2], [0x2b50, 0x2b50, 2], [0x2b55, 0x2b55, 2],
+    [0x2cef, 0x2cf1, 0], [0x2d7f, 0x2d7f, 0], [0x2de0, 0x2dff, 0], [0x2e80, 0x2e99, 2], [0x2e9b, 0x2ef3, 2],
+    [0x2f00, 0x2fd5, 2], [0x2ff0, 0x3029, 2], [0x302a, 0x302f, 0], [0x3030, 0x303e, 2], [0x3041, 0x3096, 2],
+    [0x3099, 0x309a, 0], [0x309b, 0x30ff, 2], [0x3105, 0x312f, 2], [0x3131, 0x3163, 2], [0x3164, 0x3164, 0],
+    [0x3165, 0x318e, 2], [0x3190, 0x31e5, 2], [0x31ef, 0x321e, 2], [0x3220, 0x3247, 2], [0x3250, 0xa48c, 2],
+    [0xa490, 0xa4c6, 2], [0xa66f, 0xa672, 0], [0xa674, 0xa67d, 0], [0xa69e, 0xa69f, 0], [0xa6f0, 0xa6f1, 0],
+    [0xa802, 0xa802, 0], [0xa806, 0xa806, 0], [0xa80b, 0xa80b, 0], [0xa823, 0xa827, 0], [0xa82c, 0xa82c, 0],
+    [0xa880, 0xa881, 0], [0xa8b4, 0xa8c5, 0], [0xa8e0, 0xa8f1, 0], [0xa8ff, 0xa8ff, 0], [0xa926, 0xa92d, 0],
+    [0xa947, 0xa953, 0], [0xa960, 0xa97c, 2], [0xa980, 0xa983, 0], [0xa9b3, 0xa9c0, 0], [0xa9e5, 0xa9e5, 0],
+    [0xaa29, 0xaa36, 0], [0xaa43, 0xaa43, 0], [0xaa4c, 0xaa4d, 0], [0xaa7b, 0xaa7d, 0], [0xaab0, 0xaab0, 0],
+    [0xaab2, 0xaab4, 0], [0xaab7, 0xaab8, 0], [0xaabe, 0xaabf, 0], [0xaac1, 0xaac1, 0], [0xaaeb, 0xaaef, 0],
+    [0xaaf5, 0xaaf6, 0], [0xabe3, 0xabea, 0], [0xabec, 0xabed, 0], [0xac00, 0xd7a3, 2], [0xd7b0, 0xd7ff, 0],
+    [0xf900, 0xfaff, 2], [0xfb1e, 0xfb1e, 0], [0xfe00, 0xfe0f, 0], [0xfe10, 0xfe19, 2], [0xfe20, 0xfe2f, 0],
+    [0xfe30, 0xfe52, 2], [0xfe54, 0xfe66, 2], [0xfe68, 0xfe6b, 2], [0xfeff, 0xfeff, 0], [0xff01, 0xff60, 2],
+    [0xffa0, 0xffa0, 0], [0xffe0, 0xffe6, 2], [0xfff0, 0xfffb, 0], [0x101fd, 0x101fd, 0], [0x102e0, 0x102e0, 0],
+    [0x10376, 0x1037a, 0], [0x10a01, 0x10a03, 0], [0x10a05, 0x10a06, 0], [0x10a0c, 0x10a0f, 0], [0x10a38, 0x10a3a, 0],
+    [0x10a3f, 0x10a3f, 0], [0x10ae5, 0x10ae6, 0], [0x10d24, 0x10d27, 0], [0x10d69, 0x10d6d, 0], [0x10eab, 0x10eac, 0],
+    [0x10efa, 0x10eff, 0], [0x10f46, 0x10f50, 0], [0x10f82, 0x10f85, 0], [0x11000, 0x11002, 0], [0x11038, 0x11046, 0],
+    [0x11070, 0x11070, 0], [0x11073, 0x11074, 0], [0x1107f, 0x11082, 0], [0x110b0, 0x110ba, 0], [0x110c2, 0x110c2, 0],
+    [0x11100, 0x11102, 0], [0x11127, 0x11134, 0], [0x11145, 0x11146, 0], [0x11173, 0x11173, 0], [0x11180, 0x11182, 0],
+    [0x111b3, 0x111c0, 0], [0x111c9, 0x111cc, 0], [0x111ce, 0x111cf, 0], [0x1122c, 0x11237, 0], [0x1123e, 0x1123e, 0],
+    [0x11241, 0x11241, 0], [0x112df, 0x112ea, 0], [0x11300, 0x11303, 0], [0x1133b, 0x1133c, 0], [0x1133e, 0x11344, 0],
+    [0x11347, 0x11348, 0], [0x1134b, 0x1134d, 0], [0x11357, 0x11357, 0], [0x11362, 0x11363, 0], [0x11366, 0x1136c, 0],
+    [0x11370, 0x11374, 0], [0x113b8, 0x113c0, 0], [0x113c2, 0x113c2, 0], [0x113c5, 0x113c5, 0], [0x113c7, 0x113ca, 0],
+    [0x113cc, 0x113d0, 0], [0x113d2, 0x113d2, 0], [0x113e1, 0x113e2, 0], [0x11435, 0x11446, 0], [0x1145e, 0x1145e, 0],
+    [0x114b0, 0x114c3, 0], [0x115af, 0x115b5, 0], [0x115b8, 0x115c0, 0], [0x115dc, 0x115dd, 0], [0x11630, 0x11640, 0],
+    [0x116ab, 0x116b7, 0], [0x1171d, 0x1172b, 0], [0x1182c, 0x1183a, 0], [0x11930, 0x11935, 0], [0x11937, 0x11938, 0],
+    [0x1193b, 0x1193e, 0], [0x11940, 0x11940, 0], [0x11942, 0x11943, 0], [0x119d1, 0x119d7, 0], [0x119da, 0x119e0, 0],
+    [0x119e4, 0x119e4, 0], [0x11a01, 0x11a0a, 0], [0x11a33, 0x11a39, 0], [0x11a3b, 0x11a3e, 0], [0x11a47, 0x11a47, 0],
+    [0x11a51, 0x11a5b, 0], [0x11a8a, 0x11a99, 0], [0x11b60, 0x11b67, 0], [0x11c2f, 0x11c36, 0], [0x11c38, 0x11c3f, 0],
+    [0x11c92, 0x11ca7, 0], [0x11ca9, 0x11cb6, 0], [0x11d31, 0x11d36, 0], [0x11d3a, 0x11d3a, 0], [0x11d3c, 0x11d3d, 0],
+    [0x11d3f, 0x11d45, 0], [0x11d47, 0x11d47, 0], [0x11d8a, 0x11d8e, 0], [0x11d90, 0x11d91, 0], [0x11d93, 0x11d97, 0],
+    [0x11ef3, 0x11ef6, 0], [0x11f00, 0x11f01, 0], [0x11f03, 0x11f03, 0], [0x11f34, 0x11f3a, 0], [0x11f3e, 0x11f42, 0],
+    [0x11f5a, 0x11f5a, 0], [0x13430, 0x13440, 0], [0x13447, 0x13455, 0], [0x1611e, 0x1612f, 0], [0x16af0, 0x16af4, 0],
+    [0x16b30, 0x16b36, 0], [0x16f4f, 0x16f4f, 0], [0x16f51, 0x16f87, 0], [0x16f8f, 0x16f92, 0], [0x16fe0, 0x16fe3, 2],
+    [0x16fe4, 0x16fe4, 0], [0x16ff0, 0x16ff1, 0], [0x16ff2, 0x16ff6, 2], [0x17000, 0x18cd5, 2], [0x18cff, 0x18d1e, 2],
+    [0x18d80, 0x18df2, 2], [0x1aff0, 0x1aff3, 2], [0x1aff5, 0x1affb, 2], [0x1affd, 0x1affe, 2], [0x1b000, 0x1b122, 2],
+    [0x1b132, 0x1b132, 2], [0x1b150, 0x1b152, 2], [0x1b155, 0x1b155, 2], [0x1b164, 0x1b167, 2], [0x1b170, 0x1b2fb, 2],
+    [0x1bc9d, 0x1bc9e, 0], [0x1bca0, 0x1bca3, 0], [0x1cf00, 0x1cf2d, 0], [0x1cf30, 0x1cf46, 0], [0x1d165, 0x1d169, 0],
+    [0x1d16d, 0x1d182, 0], [0x1d185, 0x1d18b, 0], [0x1d1aa, 0x1d1ad, 0], [0x1d242, 0x1d244, 0], [0x1d300, 0x1d356, 2],
+    [0x1d360, 0x1d376, 2], [0x1da00, 0x1da36, 0], [0x1da3b, 0x1da6c, 0], [0x1da75, 0x1da75, 0], [0x1da84, 0x1da84, 0],
+    [0x1da9b, 0x1da9f, 0], [0x1daa1, 0x1daaf, 0], [0x1e000, 0x1e006, 0], [0x1e008, 0x1e018, 0], [0x1e01b, 0x1e021, 0],
+    [0x1e023, 0x1e024, 0], [0x1e026, 0x1e02a, 0], [0x1e08f, 0x1e08f, 0], [0x1e130, 0x1e136, 0], [0x1e2ae, 0x1e2ae, 0],
+    [0x1e2ec, 0x1e2ef, 0], [0x1e4ec, 0x1e4ef, 0], [0x1e5ee, 0x1e5ef, 0], [0x1e6e3, 0x1e6e3, 0], [0x1e6e6, 0x1e6e6, 0],
+    [0x1e6ee, 0x1e6ef, 0], [0x1e6f5, 0x1e6f5, 0], [0x1e8d0, 0x1e8d6, 0], [0x1e944, 0x1e94a, 0], [0x1f004, 0x1f004, 2],
+    [0x1f0cf, 0x1f0cf, 2], [0x1f18e, 0x1f18e, 2], [0x1f191, 0x1f19a, 2], [0x1f200, 0x1f202, 2], [0x1f210, 0x1f23b, 2],
+    [0x1f240, 0x1f248, 2], [0x1f250, 0x1f251, 2], [0x1f260, 0x1f265, 2], [0x1f300, 0x1f320, 2], [0x1f32d, 0x1f335, 2],
+    [0x1f337, 0x1f37c, 2], [0x1f37e, 0x1f393, 2], [0x1f3a0, 0x1f3ca, 2], [0x1f3cf, 0x1f3d3, 2], [0x1f3e0, 0x1f3f0, 2],
+    [0x1f3f4, 0x1f3f4, 2], [0x1f3f8, 0x1f3fa, 2], [0x1f3fb, 0x1f3ff, 0], [0x1f400, 0x1f43e, 2], [0x1f440, 0x1f440, 2],
+    [0x1f442, 0x1f4fc, 2], [0x1f4ff, 0x1f53d, 2], [0x1f54b, 0x1f54e, 2], [0x1f550, 0x1f567, 2], [0x1f57a, 0x1f57a, 2],
+    [0x1f595, 0x1f596, 2], [0x1f5a4, 0x1f5a4, 2], [0x1f5fb, 0x1f64f, 2], [0x1f680, 0x1f6c5, 2], [0x1f6cc, 0x1f6cc, 2],
+    [0x1f6d0, 0x1f6d2, 2], [0x1f6d5, 0x1f6d8, 2], [0x1f6dc, 0x1f6df, 2], [0x1f6eb, 0x1f6ec, 2], [0x1f6f4, 0x1f6fc, 2],
+    [0x1f7e0, 0x1f7eb, 2], [0x1f7f0, 0x1f7f0, 2], [0x1f90c, 0x1f93a, 2], [0x1f93c, 0x1f945, 2], [0x1f947, 0x1f9ff, 2],
+    [0x1fa70, 0x1fa7c, 2], [0x1fa80, 0x1fa8a, 2], [0x1fa8e, 0x1fac6, 2], [0x1fac8, 0x1fac8, 2], [0x1facd, 0x1fadc, 2],
+    [0x1fadf, 0x1faea, 2], [0x1faef, 0x1faf8, 2], [0x20000, 0x2fffd, 2], [0x30000, 0x3fffd, 2], [0xe0000, 0xe0fff, 0],
+];
+// The code points one cell wide on their own and two when VARIATION SELECTOR-16
+// asks for emoji presentation.
+const NARROW_TO_WIDE = new Set([
+    0x23, 0x2a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xa9, 0xae, 0x203c, 0x2049, 0x2122, 0x2139,
+    0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, 0x21a9, 0x21aa, 0x2328, 0x23cf, 0x23ed, 0x23ee, 0x23ef, 0x23f1,
+    0x23f2, 0x23f8, 0x23f9, 0x23fa, 0x24c2, 0x25aa, 0x25ab, 0x25b6, 0x25c0, 0x25fb, 0x25fc, 0x2600, 0x2601, 0x2602,
+    0x2603, 0x2604, 0x260e, 0x2611, 0x2618, 0x261d, 0x2620, 0x2622, 0x2623, 0x2626, 0x262a, 0x262e, 0x262f, 0x2638,
+    0x2639, 0x263a, 0x2640, 0x2642, 0x265f, 0x2660, 0x2663, 0x2665, 0x2666, 0x2668, 0x267b, 0x267e, 0x2692, 0x2694,
+    0x2695, 0x2696, 0x2697, 0x2699, 0x269b, 0x269c, 0x26a0, 0x26a7, 0x26b0, 0x26b1, 0x26c8, 0x26cf, 0x26d1, 0x26d3,
+    0x26e9, 0x26f0, 0x26f1, 0x26f4, 0x26f7, 0x26f8, 0x26f9, 0x2702, 0x2708, 0x2709, 0x270c, 0x270d, 0x270f, 0x2712,
+    0x2714, 0x2716, 0x271d, 0x2721, 0x2733, 0x2734, 0x2744, 0x2747, 0x2763, 0x2764, 0x27a1, 0x2934, 0x2935, 0x2b05,
+    0x2b06, 0x2b07, 0x1f170, 0x1f171, 0x1f17e, 0x1f17f, 0x1f321, 0x1f324, 0x1f325, 0x1f326, 0x1f327, 0x1f328, 0x1f329,
+    0x1f32a, 0x1f32b, 0x1f32c, 0x1f336, 0x1f37d, 0x1f396, 0x1f397, 0x1f399, 0x1f39a, 0x1f39b, 0x1f39e, 0x1f39f, 0x1f3cb,
+    0x1f3cc, 0x1f3cd, 0x1f3ce, 0x1f3d4, 0x1f3d5, 0x1f3d6, 0x1f3d7, 0x1f3d8, 0x1f3d9, 0x1f3da, 0x1f3db, 0x1f3dc, 0x1f3dd,
+    0x1f3de, 0x1f3df, 0x1f3f3, 0x1f3f5, 0x1f3f7, 0x1f43f, 0x1f441, 0x1f4fd, 0x1f549, 0x1f54a, 0x1f56f, 0x1f570, 0x1f573,
+    0x1f574, 0x1f575, 0x1f576, 0x1f577, 0x1f578, 0x1f579, 0x1f587, 0x1f58a, 0x1f58b, 0x1f58c, 0x1f58d, 0x1f590, 0x1f5a5,
+    0x1f5a8, 0x1f5b1, 0x1f5b2, 0x1f5bc, 0x1f5c2, 0x1f5c3, 0x1f5c4, 0x1f5d1, 0x1f5d2, 0x1f5d3, 0x1f5dc, 0x1f5dd, 0x1f5de,
+    0x1f5e1, 0x1f5e3, 0x1f5e8, 0x1f5ef, 0x1f5f3, 0x1f5fa, 0x1f6cb, 0x1f6cd, 0x1f6ce, 0x1f6cf, 0x1f6e0, 0x1f6e1, 0x1f6e2,
+    0x1f6e3, 0x1f6e4, 0x1f6e5, 0x1f6e9, 0x1f6f0, 0x1f6f3,
+]);
+/** The cells Rich gives `codePoint` on its own: none for a C0 or C1 control. */
+export function codePointWidth(codePoint) {
+    if (codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0))
+        return 0;
+    let low = 0;
+    let high = RANGES.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const [first, last, cells] = RANGES[mid];
+        if (codePoint < first)
+            high = mid - 1;
+        else if (codePoint > last)
+            low = mid + 1;
+        else
+            return cells;
+    }
+    return 1;
+}
+/** Whether VS16 after `codePoint` widens it from one cell to two. */
+export function widensToEmoji(codePoint) {
+    return NARROW_TO_WIDE.has(codePoint);
+}