@promptctl/rich-js 0.24.0 → 0.25.0

package/dist/core/protocol.js

@@ -3,7 +3,7 @@
  * [LAW:one-source-of-truth] These interfaces are the single authority for the rendering contract.
  */
 import { cellCount } from "./cells.js";
-import { DEFAULT_THEME } from "./style.js";
+import { DEFAULT_THEME, Style } from "./style.js";
 /** Whether `text` is all ASCII — what an `asciiOnly` output can draw. */
 export const isAscii = (text) => /^[\x00-\x7F]*$/.test(text);
 export function drawable(options, chosen, ascii, glyphs = String) {
@@ -61,6 +61,8 @@ export function fitHeight(lines, height) {
 export function getStyle(options, style) {
     return (options.theme ?? DEFAULT_THEME).resolve(style);
 }
+/** The terminal's own foreground on its own background. */
+const TERMINAL_GROUND = Style.parse("default on default");
 /**
  * `style` as the depth the render is encoded at can draw it. A style that
  * paints its own ground in fixed colours chose its ink and ground as a pair;
@@ -69,7 +71,10 @@ export function getStyle(options, style) {
  * every bundled theme. So where the depth would turn a fixed colour of the
  * pair into a slot, the pair is dropped and the run is drawn on the
  * terminal's own foreground and background, which its theme does make
- * readable; its attributes still set it apart. A style whose colours are
+ * readable; its attributes still set it apart. Both are named, not left
+ * unset, so the colour of whatever the run sits in — a quote, a link — does
+ * not show through: Rich's code keeps its own colours inside a quote, and the
+ * terminal's are the ones it keeps here. A style whose colours are
  * slots already (`white on blue`), or that paints no ground (`bold magenta`),
  * was written for the terminal's own colours and is drawn as written. Rich
  * draws a highlighted line number the same way below 256 colours
@@ -79,7 +84,7 @@ export function groundedStyle(options, style) {
     const drawn = style.drawnColors(options.colorSystem ?? undefined);
     const lost = (written, shown) => written?.fixedValue !== undefined && shown?.fixedValue === undefined;
     const pairLost = style.bgcolor !== undefined && (lost(style.color, drawn.color) || lost(style.bgcolor, drawn.bgcolor));
-    return pairLost ? style.withoutColor : style;
+    return pairLost ? style.add(TERMINAL_GROUND) : style;
 }
 /**
  * The options a renderable should work from: the caller's, with `maxWidth`
@@ -104,6 +109,200 @@ export function groundedStyle(options, style) {
 export function withCellWidth(options) {
     return { ...options, maxWidth: cellCount(options.maxWidth) };
 }
+/** Under one column there is nothing to draw, or to measure. */
+export function drawsNothing(options) {
+    return cellCount(options.maxWidth) < 1;
+}
+// [LAW:no-shared-mutable-globals] The render phase, owned here and nowhere
+// else: only `render` and `measure` below open or enter a pass, and the rest of
+// the library reads it through `activePass` and `afterPass`. Set and restored
+// like a stack, so "not rendering" is `undefined` and needs no counter.
+let active;
+function runIn(phase, run) {
+    const outer = active;
+    active = phase;
+    try {
+        return run();
+    }
+    finally {
+        active = outer;
+    }
+}
+/**
+ * `handler` run as if between passes: a callback a render makes to user code to
+ * report something it met, such as `onStyleError`, is an event handler, and may
+ * write what one may — print to a console, set a `State` — as React lets an
+ * event handler set state.
+ */
+export function betweenPasses(handler) {
+    return runIn(undefined, handler);
+}
+/** The pass a render or measure in progress belongs to, or `undefined` between passes. */
+export function activePass() {
+    return active?.pass;
+}
+/**
+ * `effect` run once the render pass in progress has drawn its last segment,
+ * between passes, where it may write what an event handler may: React's commit
+ * phase. A render that learns something only drawing can tell it — the lines
+ * content shown through a `Viewport` runs to at the width it was handed —
+ * draws from what it learned and hands the commit here, rather than writing it
+ * as it draws.
+ *
+ * Effects run in the order they were handed over, which is document order. A
+ * measurement commits nothing, and neither does a pass that throws or whose
+ * caller stops iterating it early: nobody saw what it drew. Outside a pass — a
+ * renderable's `render` called directly — there is nothing to wait for, and
+ * `effect` runs now.
+ */
+export function afterPass(effect) {
+    if (active === undefined)
+        effect();
+    else
+        active.effects.push(effect);
+}
+/** The pass in progress, or a new one when this call is the outermost. */
+const phaseHere = () => active ?? { pass: {}, effects: [] };
+/**
+ * Every effect `phase`'s renders handed it, run now that it has ended — between
+ * passes even when the iteration that ended it was stepped inside another.
+ */
+function commit(phase) {
+    runIn(undefined, () => {
+        for (const effect of phase.effects.splice(0))
+            effect();
+    });
+}
+/**
+ * `drawn` with every step of its iteration run in `phase`, and its effects
+ * committed when the last step is done. A render is often a generator, whose
+ * body runs as its caller iterates — after `render` has returned — so the pass
+ * is re-entered on each `next()`, however many `yield`s a write sits behind,
+ * and ends only when the iteration does. An array has nothing left to run, so
+ * its pass has already ended.
+ *
+ * Only the call that opens the pass is wrapped. A nested render's steps run
+ * inside its parent's, which are already in the pass; a nested iterable could
+ * only be stepped outside it by being kept somewhere past the render, which
+ * takes a writable location `test/seam/render-purity.test.ts` refuses. Wrapping
+ * every level cost a third of the render time, once per segment per level.
+ */
+function withinPass(phase, drawn) {
+    if (Array.isArray(drawn)) {
+        commit(phase);
+        return drawn;
+    }
+    return {
+        [Symbol.iterator]: () => {
+            const steps = runIn(phase, () => drawn[Symbol.iterator]());
+            // On `%IteratorPrototype%`, as a generator's iterator is: iterable
+            // itself, and carrying the iterator helpers where the engine has them.
+            return Object.assign(Object.create(ITERATOR_PROTOTYPE), {
+                next: () => {
+                    const step = runIn(phase, () => steps.next());
+                    if (step.done === true)
+                        commit(phase);
+                    return step;
+                },
+                return: (value) => runIn(phase, () => steps.return?.(value) ?? { done: true, value: undefined }),
+                throw: (error) => runIn(phase, () => {
+                    if (steps.throw)
+                        return steps.throw(error);
+                    throw error;
+                }),
+            });
+        },
+    };
+}
+const ITERATOR_PROTOTYPE = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+/**
+ * `renderable` drawn under `options`: Rich's `Console.render`, which every
+ * renderable there is drawn through, so under one column nothing is.
+ *
+ * [LAW:single-enforcer] The one place that rule is kept. Every call of a
+ * `Renderable`'s `render` in `src/` goes through here — a container drawing
+ * its child, a renderable drawing the text it built, a host drawing a frame —
+ * and `test/seam/render-calls.test.ts` fails on one that does not. Before
+ * this, each container asked `drawsNothing` itself, and the ones that forgot
+ * drew a child handed no column anyway.
+ *
+ * It is where a render pass is entered (`Pass`), so it is the one place a
+ * write during render is refused at: a `State` set in a pass that did not make
+ * it throws (`./state.ts`).
+ *
+ * It is also the one reporter of what the view holds (`onPresent`). Under one
+ * column a renderable is held: in the view, with nothing of it on the frame.
+ * It is drawn all the same and what it drew dropped (`holding`), so what a held
+ * container is reported holding is what it draws, under the options it hands
+ * each child — one description of a container's traversal, not a second
+ * kept beside it.
+ */
+export function render(renderable, options) {
+    const opens = active === undefined;
+    const presence = drawsNothing(options) ? "held" : "drawn";
+    const { phase, drawing } = presence === "drawn" ? { phase: phaseHere(), drawing: options } : holding(options);
+    const drawn = runIn(phase, () => {
+        options.onPresent?.(renderable, presence);
+        return renderable.render(drawing);
+    });
+    if (presence === "held") {
+        runIn(phase, () => {
+            for (const _ of drawn)
+                ;
+        });
+        return [];
+    }
+    return opens ? withinPass(phase, drawn) : drawn;
+}
+/**
+ * Where a held renderable is drawn, and the options it is drawn under: what
+ * it draws is dropped, and everything it draws is reported held, whatever
+ * width it hands it. What it tells of its hold (`onHold`) still reaches the
+ * frame: an element not yet entered is held at no width, and must say when it
+ * enters and takes some. A motion held at no width therefore wakes its host
+ * for frames that look the same: when it next takes room is not a moment its
+ * hold can name, and an early answer costs a frame where a late one hides the
+ * element. It commits nothing, as a measurement commits nothing —
+ * its effects (`afterPass`) are learned at a width nobody sees, so a
+ * `Viewport` it shows content through keeps the scroll the last frame shown
+ * left it.
+ *
+ * [LAW:parse-dont-validate] It is drawn at no column, 0, whatever width under
+ * one its container worked out: `drawsNothing` reads a negative or NaN width
+ * as none, so none reaches a `render`, where it would be a count no string
+ * can repeat.
+ */
+function holding(options) {
+    const { onPresent } = options;
+    return {
+        phase: { pass: phaseHere().pass, effects: [] },
+        drawing: { ...options, maxWidth: 0, onPresent: onPresent && ((content) => onPresent(content, "held")) },
+    };
+}
+/**
+ * What `measurable` reports under `options`: asked in a render pass, as
+ * `render` draws in one, with `measuring`'s options.
+ *
+ * [LAW:single-enforcer] Every call of a `Measurable`'s `measure` in `src/`
+ * goes through here, as every `render` goes through `render`;
+ * `test/seam/render-calls.test.ts` holds both.
+ */
+export function measure(measurable, options) {
+    // The pass's identity, with effects nothing runs: a measurement commits nothing.
+    return runIn({ pass: phaseHere().pass, effects: [] }, () => measurable.measure(measuring(options)));
+}
+/**
+ * `options` as a measurement is asked with. A `measure` that renders to learn
+ * its shape draws nothing on the frame, so it reports nothing to `onPresent` —
+ * one that did would put a widget in the view at the moment a container
+ * measured it, and keep one the frame then cropped away. It still tells its
+ * hold (`onHold`): a layout decided by a measurement changes when it does.
+ *
+ * [LAW:single-enforcer] Every measurement starts here: `measure` asks with it.
+ */
+function measuring(options) {
+    return { ...options, onPresent: undefined };
+}
 /**
  * The options a renderable should *lay out against*: `withCellWidth`, with an
  * unbounded offer resolved to the renderable's own natural width.
@@ -139,23 +338,11 @@ export function withCellWidth(options) {
  * rather than zero, and saying so names the cause — where `String.repeat` and
  * `new Array` only ever name their own argument.
  */
-/**
- * `options` as a measurement is asked with. A `measure` that renders to learn
- * its shape draws nothing on the frame, so it reports no owner to `onDraw` —
- * one that did would put a widget in document order at the moment a
- * container measured it, and keep one the frame then cropped away.
- *
- * [LAW:single-enforcer] Every measurement starts here: `Measurement.get` and
- * `withBoundedWidth` ask through it, and each `measure` passes it on.
- */
-export function measuring(options) {
-    return { ...options, onDraw: undefined };
-}
 export function withBoundedWidth(options, self) {
     const parsed = withCellWidth(options);
     if (Number.isFinite(parsed.maxWidth))
         return parsed;
-    const natural = self.measure(measuring(parsed)).maximum;
+    const natural = measure(self, parsed).maximum;
     if (!Number.isFinite(natural)) {
         throw new RangeError("maxWidth is unbounded and this renderable has no natural width to fall " +
             "back on: its content does not implement measure(), or something inside " +

package/dist/core/render.d.ts

@@ -40,13 +40,16 @@
  * removes a link — a hyperlink is not a colour, and a NO_COLOR terminal still
  * follows OSC 8. This is where the port departs from the reference, whose
  * `Style.render` returns bare text for a null colour system.
+ *
+ * The third fact, `reducedMotion`, changes the segment rather than its
+ * encoding: `shownOn` takes the style's blink out before it is encoded.
  */
 import { ColorDepth } from "./color.js";
 import type { ColorSystemName, Destination } from "./color.js";
 import type { Env } from "./env.js";
-import type { Segment } from "./segment.js";
+import { Segment } from "./segment.js";
 import type { Renderable, RenderOptions } from "./protocol.js";
-export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" | "theme" | "onStyleError" | "highlight" | "highlighter"> {
+export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" | "reducedMotion" | "theme" | "onStyleError" | "highlight" | "highlighter"> {
     /** Cell width to render into. Default 80. */
     width?: number;
     /**
@@ -77,6 +80,16 @@ export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" |
      */
     hyperlinks?: boolean;
 }
+/**
+ * `segment` as `destination` shows it: under reduced motion its style
+ * `reduced()`, so the terminal is never asked to blink it.
+ *
+ * [LAW:single-enforcer] The one place reduced motion reaches a style's own
+ * motion. Drawing cannot do it: a console lays its print and base styles over
+ * what was drawn, after `render`. The encoder writes what this returns, and a
+ * recording console records it, so every export replays what was written.
+ */
+export declare function shownOn(segment: Segment, destination: Destination): Segment;
 /**
  * Encodes one segment as ANSI bytes for `destination`: the reference's
  * `Style.render` for that segment, and nothing for a control segment.

package/dist/core/render.js

@@ -40,10 +40,28 @@
  * removes a link — a hyperlink is not a colour, and a NO_COLOR terminal still
  * follows OSC 8. This is where the port departs from the reference, whose
  * `Style.render` returns bare text for a null colour system.
+ *
+ * The third fact, `reducedMotion`, changes the segment rather than its
+ * encoding: `shownOn` takes the style's blink out before it is encoded.
  */
 import { ColorDepth, resolveDestination } from "./color.js";
+import { Segment } from "./segment.js";
+import { render } from "./protocol.js";
 import { OSC8_CLOSE, osc8Open } from "./osc8.js";
 const DEFAULT_WIDTH = 80;
+/**
+ * `segment` as `destination` shows it: under reduced motion its style
+ * `reduced()`, so the terminal is never asked to blink it.
+ *
+ * [LAW:single-enforcer] The one place reduced motion reaches a style's own
+ * motion. Drawing cannot do it: a console lays its print and base styles over
+ * what was drawn, after `render`. The encoder writes what this returns, and a
+ * recording console records it, so every export replays what was written.
+ */
+export function shownOn(segment, destination) {
+    const style = destination.reducedMotion ? segment.style?.reduced() : segment.style;
+    return style === segment.style ? segment : new Segment(segment.text, style, segment.control);
+}
 /**
  * Encodes one segment as ANSI bytes for `destination`: the reference's
  * `Style.render` for that segment, and nothing for a control segment.
@@ -51,7 +69,7 @@ const DEFAULT_WIDTH = 80;
 export function segmentToString(segment, destination) {
     if (segment.isControl)
         return "";
-    const { text, style } = segment;
+    const { text, style } = shownOn(segment, destination);
     // As the reference's `if not text` and `if style:` — no pair around nothing.
     if (text.length === 0 || style === undefined)
         return text;
@@ -74,18 +92,19 @@ export function renderToString(renderable, options) {
     // [LAW:dataflow-not-control-flow] An absent spec is truecolor; an explicit
     // `null` stays null (`??` would collapse it).
     // [LAW:single-enforcer] Specs resolve through `resolveDestination`.
-    const detectOptions = {};
+    const destinationOptions = { reducedMotion: options?.reducedMotion };
     if (options?.env !== undefined)
-        detectOptions.env = options.env;
+        destinationOptions.env = options.env;
     if (options?.isTTY !== undefined)
-        detectOptions.isTTY = options.isTTY;
+        destinationOptions.isTTY = options.isTTY;
     const rawSpec = options?.colorSystem;
-    const resolved = resolveDestination(rawSpec === undefined ? ColorDepth.TRUECOLOR : rawSpec, detectOptions);
+    const resolved = resolveDestination(rawSpec === undefined ? ColorDepth.TRUECOLOR : rawSpec, destinationOptions);
     // [LAW:single-enforcer] This call's overrides are applied here, once, to
     // make the one destination everything below is drawn for. `noColor` is a
     // colour choice, so it overrides the depth and leaves hyperlinks to the
     // destination; an explicit `hyperlinks` overrides what the destination takes.
     const destination = {
+        ...resolved,
         colorSystem: options?.noColor ? null : resolved.colorSystem,
         hyperlinks: options?.hyperlinks ?? resolved.hyperlinks,
     };
@@ -93,6 +112,8 @@ export function renderToString(renderable, options) {
         maxWidth: width,
         isTerminal: false,
         asciiOnly: options?.asciiOnly ?? false,
+        // [LAW:one-source-of-truth] What is drawn and how it is encoded take one preference.
+        reducedMotion: destination.reducedMotion,
         theme: options?.theme,
         onStyleError: options?.onStyleError,
         highlight: options?.highlight,
@@ -101,5 +122,5 @@ export function renderToString(renderable, options) {
         // so a renderable measures what this very call will draw.
         colorSystem: destination.colorSystem,
     };
-    return segmentsToString(renderable.render(renderOptions), destination);
+    return segmentsToString(render(renderable, renderOptions), destination);
 }

package/dist/core/segment.d.ts

@@ -23,12 +23,12 @@ export declare enum ControlType {
     ERASE_IN_LINE = "erase_in_line",
     SET_WINDOW_TITLE = "set_window_title"
 }
-export type ControlCode = [ControlType, ...unknown[]];
+export type ControlCode = readonly [ControlType, ...unknown[]];
 export declare class Segment {
     readonly text: string;
     readonly style: Style | undefined;
-    readonly control: ControlCode[] | undefined;
-    constructor(text: string, style?: Style, control?: ControlCode[]);
+    readonly control: readonly ControlCode[] | undefined;
+    constructor(text: string, style?: Style, control?: readonly ControlCode[]);
     get cellLength(): number;
     get hasText(): boolean;
     get isControl(): boolean;
@@ -42,7 +42,16 @@ export declare class Segment {
      * whatever drew it, and its anchor says so; see `./anchor.ts`.
      */
     splitCells(position: CellCol): [Segment, Segment];
-    private static _line;
+    /**
+     * Cuts at each of `positions`, non-decreasing and inside this segment's
+     * cells: one piece more than there are positions, each exactly as wide as
+     * the distance between its cuts, the way `splitCells` cuts at one.
+     *
+     * [LAW:single-enforcer] Each piece but the first starts that many cells
+     * further into whatever drew it, and its anchor says so; see `./anchor.ts`.
+     */
+    private cutAt;
+    private static readonly _line;
     static line(): Segment;
     /**
      * `lines`, as drawn by `owner`: every segment stamped with the row and
@@ -53,7 +62,7 @@ export declare class Segment {
     static anchorLines(lines: Segment[][], owner: object, firstRow?: number): Segment[][];
     /**
      * When what `segments` show next changes, in seconds on the timeline of
-     * whoever drew them: the soonest `Style.nextChange` among them, read off
+     * whoever drew them: the soonest `Style.hold` among them, read off
      * the composed frame the way `anchorAt` reads an owner — `t` itself for a
      * frame something in moves every frame, `Infinity` for one that never
      * changes. What a host that drew the frame at `t` asks before drawing
@@ -61,6 +70,14 @@ export declare class Segment {
      * `t` until it is done, still content never.
      */
     static nextChange(segments: Iterable<Segment>): number;
+    /**
+     * Since when what `segments` show has been what it is, on the same
+     * timeline: the latest `Style.hold` among them, the other end of the
+     * hold `nextChange` reads — `t` for a frame something in moves every
+     * frame, `-Infinity` for one that always was. What a host running its
+     * timeline backwards asks before drawing again.
+     */
+    static lastChange(segments: Iterable<Segment>): number;
     /**
      * The anchor of the cell at column `x` of row `y` in a composed frame, or
      * `undefined` when that cell was drawn by no owner or lies outside the frame.
@@ -150,7 +167,15 @@ export declare class Segment {
      */
     static removeColor(segments: Iterable<Segment>): Iterable<Segment>;
     /**
-     * Divides segments at cell positions. Yields arrays of segments for each section.
+     * Divides segments at cell positions: a section ending at each cut, and the
+     * cells after the last cut when there are any. A segment wider than zero
+     * that starts at a cut opens the section after it; one with no cells stays
+     * in the section it ends.
+     *
+     * One walk, and each segment is cut once at every cut that falls inside it:
+     * cutting what is left of it again at each cut re-measures and copies the
+     * rest every time, so a long line wrapped into many rows took time quadratic
+     * in its length.
      */
     static divide(segments: Segment[], cuts: number[]): Segment[][];
     /**

package/dist/core/segment.js

@@ -59,16 +59,15 @@ export class Segment {
             return [this, new Segment("")];
         if (position <= 0)
             return [new Segment(""), this];
-        const [leftText, rightText] = cutCells(this.text, position);
-        return [
-            new Segment(leftText, this.style),
-            new Segment(rightText, this.style?.shiftedBy(position)),
-        ];
+        return this.cutAt([position]);
+    }
+    cutAt(positions) {
+        return cutCells(this.text, positions).map((text, piece) => new Segment(text, piece === 0 ? this.style : this.style?.shiftedBy(positions[piece - 1])));
     }
     // --- Static factories ---
-    static _line;
+    static _line = new Segment("\n");
     static line() {
-        return (Segment._line ??= new Segment("\n"));
+        return Segment._line;
     }
     // --- Static transformations ---
     /**
@@ -93,7 +92,7 @@ export class Segment {
     }
     /**
      * When what `segments` show next changes, in seconds on the timeline of
-     * whoever drew them: the soonest `Style.nextChange` among them, read off
+     * whoever drew them: the soonest `Style.hold` among them, read off
      * the composed frame the way `anchorAt` reads an owner — `t` itself for a
      * frame something in moves every frame, `Infinity` for one that never
      * changes. What a host that drew the frame at `t` asks before drawing
@@ -103,9 +102,22 @@ export class Segment {
     static nextChange(segments) {
         let soonest = Number.POSITIVE_INFINITY;
         for (const segment of segments)
-            soonest = Math.min(soonest, segment.style?.nextChange ?? Number.POSITIVE_INFINITY);
+            soonest = Math.min(soonest, segment.style?.hold.nextChange ?? Number.POSITIVE_INFINITY);
         return soonest;
     }
+    /**
+     * Since when what `segments` show has been what it is, on the same
+     * timeline: the latest `Style.hold` among them, the other end of the
+     * hold `nextChange` reads — `t` for a frame something in moves every
+     * frame, `-Infinity` for one that always was. What a host running its
+     * timeline backwards asks before drawing again.
+     */
+    static lastChange(segments) {
+        let latest = Number.NEGATIVE_INFINITY;
+        for (const segment of segments)
+            latest = Math.max(latest, segment.style?.hold.lastChange ?? Number.NEGATIVE_INFINITY);
+        return latest;
+    }
     /**
      * The anchor of the cell at column `x` of row `y` in a composed frame, or
      * `undefined` when that cell was drawn by no owner or lies outside the frame.
@@ -129,8 +141,11 @@ export class Segment {
      */
     static *applyStyle(segments, style, postStyle) {
         // Applying no style is the identity, so the segments pass through as they
-        // are instead of each being copied into an equal one.
-        if (!style && !postStyle) {
+        // are instead of each being copied into an equal one. A null style — a
+        // theme's plain entry, such as `markdown.item` — is no style.
+        const pre = style?.isNull ? undefined : style;
+        const post = postStyle?.isNull ? undefined : postStyle;
+        if (!pre && !post) {
             yield* segments;
             return;
         }
@@ -140,10 +155,10 @@ export class Segment {
                 continue;
             }
             let s = segment.style;
-            if (style)
-                s = style.add(s);
-            if (postStyle)
-                s = s ? s.add(postStyle) : postStyle;
+            if (pre)
+                s = pre.add(s);
+            if (post)
+                s = s ? s.add(post) : post;
             yield new Segment(segment.text, s, segment.control);
         }
     }
@@ -184,9 +199,8 @@ export class Segment {
                 }
             }
         }
-        if (currentLine.length > 0) {
+        if (currentLine.length > 0)
             lines.push(currentLine);
-        }
         return lines;
     }
     /**
@@ -201,7 +215,10 @@ export class Segment {
                 return line;
             return [...line, new Segment(" ".repeat(width - currentWidth), style)];
         }
-        // Crop to width
+        // Crop to width: the cells past it go, and every piece of no cells stays —
+        // a control, or an empty piece of text, writes nothing there, and may be
+        // all that says when its frame changes (`Style.hold`). Not the
+        // reference, which stops at the cut.
         const result = [];
         let remaining = width;
         for (const segment of line) {
@@ -214,11 +231,10 @@ export class Segment {
                 result.push(segment);
                 remaining -= segWidth;
             }
-            else {
+            else if (remaining > 0) {
                 const [left] = segment.splitCells(asCellCol(remaining));
                 result.push(left);
                 remaining = 0;
-                break;
             }
         }
         return result;
@@ -398,45 +414,44 @@ export class Segment {
         }
     }
     /**
-     * Divides segments at cell positions. Yields arrays of segments for each section.
+     * Divides segments at cell positions: a section ending at each cut, and the
+     * cells after the last cut when there are any. A segment wider than zero
+     * that starts at a cut opens the section after it; one with no cells stays
+     * in the section it ends.
+     *
+     * One walk, and each segment is cut once at every cut that falls inside it:
+     * cutting what is left of it again at each cut re-measures and copies the
+     * rest every time, so a long line wrapped into many rows took time quadratic
+     * in its length.
      */
     static divide(segments, cuts) {
         if (cuts.length === 0)
             return [segments];
-        const result = [];
-        let segmentIndex = 0;
-        let cellOffset = 0;
-        let currentSegment = segments[segmentIndex];
-        for (const cut of cuts) {
-            const section = [];
-            while (currentSegment && cellOffset + currentSegment.cellLength <= cut) {
-                section.push(currentSegment);
-                cellOffset += currentSegment.cellLength;
-                segmentIndex++;
-                currentSegment = segments[segmentIndex];
-            }
-            if (currentSegment && !currentSegment.isControl && cellOffset < cut) {
-                const splitAt = asCellCol(cut - cellOffset);
-                const [left, right] = currentSegment.splitCells(splitAt);
-                if (left.hasText)
-                    section.push(left);
-                cellOffset += left.cellLength;
-                currentSegment = right;
+        const sections = [[]];
+        let offset = 0;
+        let next = 0;
+        for (const segment of segments) {
+            const end = offset + segment.cellLength;
+            const inside = [];
+            for (; next < cuts.length && cuts[next] < end; next++) {
+                const cut = cuts[next];
+                if (cut <= offset)
+                    sections.push([]);
+                else
+                    inside.push(asCellCol(cut - offset));
             }
-            result.push(section);
-        }
-        // Remaining segments
-        const tail = [];
-        if (currentSegment?.hasText)
-            tail.push(currentSegment);
-        segmentIndex++;
-        while (segmentIndex < segments.length) {
-            tail.push(segments[segmentIndex]);
-            segmentIndex++;
+            const [head, ...rest] = inside.length === 0 ? [segment] : segment.cutAt(inside);
+            sections[sections.length - 1].push(head);
+            // A piece between two cuts at one cell has no text: the section it is holds nothing.
+            for (const piece of rest)
+                sections.push(piece.hasText ? [piece] : []);
+            offset = end;
         }
-        if (tail.length > 0)
-            result.push(tail);
-        return result;
+        for (; next < cuts.length; next++)
+            sections.push([]);
+        if (sections[sections.length - 1].length === 0)
+            sections.pop();
+        return sections;
     }
     // --- Layout helpers ---
     /**

package/dist/core/spinnerData.d.ts

@@ -8,5 +8,5 @@ export interface SpinnerData {
 }
 /** The spinner an ASCII-only output draws in place of any other. */
 export declare const LINE_SPINNER: SpinnerData;
-export declare const SPINNERS: Record<string, SpinnerData>;
+export declare const SPINNERS: Readonly<Record<string, SpinnerData>>;
 export declare const DEFAULT_SPINNER = "dots";