@promptctl/rich-js 0.24.0 → 0.25.0

package/dist/renderables/embed.js

@@ -23,6 +23,8 @@
  */
 import { cellCount, cellLen, setCellSize } from "../core/cells.js";
 import { activeHighlighter, readStr } from "../core/markup.js";
+import { Memo } from "../core/memo.js";
+import { measure, render } from "../core/protocol.js";
 import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
 /**
@@ -38,8 +40,10 @@ export class EmbeddedText {
     // A string's reading under each markup setting, made the first time one is
     // asked for. Parsing is the costly half of drawing a string, and a table
     // measures every cell more than once per print; read on every call, a
-    // 500-row table of markup printed 75% slower.
-    _readings = new Map();
+    // 500-row table of markup printed 75% slower. Kept as characters and spans,
+    // not as the `RichText`, whose state a memo may not hold: a memo is "same
+    // key, same value", and each call builds a text of its own from it.
+    _readings = new Memo();
     constructor(content) {
         if (typeof content === "string") {
             this._source = content;
@@ -60,10 +64,15 @@ export class EmbeddedText {
     text(options, base) {
         if (typeof this._source !== "string")
             return this._source.copy();
+        const source = this._source;
         const markup = options.markup !== false;
-        const reading = this._readings.get(markup) ?? readStr(this._source, markup);
-        this._readings.set(markup, reading);
-        const text = reading.copy();
+        const reading = this._readings.get(markup ? "markup" : "plain", () => {
+            const read = readStr(source, markup);
+            return { plain: read.plain, spans: [...read.spans] };
+        });
+        const text = new RichText(reading.plain);
+        for (const span of reading.spans)
+            text.stylize(span.style, span.start, span.end);
         const highlighter = activeHighlighter(options);
         if (base !== undefined && highlighter === undefined)
             text.style = base;
@@ -71,7 +80,7 @@ export class EmbeddedText {
         return text;
     }
     render(options) {
-        return this.text(options).render(options);
+        return render(this.text(options), options);
     }
     /**
      * Measured unhighlighted, as Rich's `Measurement.get` reads a string with
@@ -80,7 +89,7 @@ export class EmbeddedText {
      * measures, and no highlighter runs just to be thrown away.
      */
     measure(options) {
-        return this.text({ ...options, highlight: false }).measure(options);
+        return measure(this.text({ ...options, highlight: false }), options);
     }
 }
 /**
@@ -124,7 +133,7 @@ export class InlineLabel {
  * measures it, so a cut to a border and the width a label asks for count
  * the cells it will draw. [LAW:single-enforcer] The one reading of "set into
  * a line", for a label read through the crossing above and for text a
- * caller hands over already read (`Frames`).
+ * caller hands over already read (`FrameSequence`).
  */
 export function setIntoLine(text) {
     text.end = "";
@@ -163,7 +172,7 @@ export function present(content) {
  */
 export function drawLabel(text, options, base) {
     text.overflow = "ignore";
-    return [...Segment.applyStyle(text.render(options), base)];
+    return [...Segment.applyStyle(render(text, options), base)];
 }
 /**
  * Caller content as a label, or no label at all: content that is not

package/dist/renderables/flexStrip.js

@@ -16,9 +16,10 @@
  * FlexStrip reuses it verbatim. There is no second concept of "join."
  */
 import { Segment } from "../core/segment.js";
+import { render } from "../core/protocol.js";
 import { drawItem, drawJoin } from "../core/strip.js";
 function renderToBlock(r, options) {
-    const segments = [...r.render(options)];
+    const segments = [...render(r, options)];
     let width = 0;
     for (const s of segments)
         width += s.cellLength;

package/dist/renderables/frames.d.ts

@@ -7,32 +7,33 @@
  * (`./effect.ts`: "It changes how cells look, never which cells exist or who
  * drew them"). A frame is the other kind of motion — what the element shows
  * changes — so it is its own primitive and not a wider `Effect`, and the two
- * compose by nesting: `new Effected(new Frames(…), …)` lights whichever frame
- * is up.
+ * compose by nesting: `new Effected(sequence, …)` lights whichever frame is
+ * up.
  *
- * [LAW:no-ambient-temporal-coupling] `t` is an argument, as
- * `Effected`'s is, never a clock read: whoever draws frames hands each one
- * its time (`core/clock.ts`), so the same `t` draws the same bytes at one
+ * [LAW:no-ambient-temporal-coupling] `t` is the frame's time, never a
+ * clock read: whoever draws frames hands each one its time
+ * (`RenderOptions.frame`), so the same `t` draws the same bytes at one
  * redraw a second or sixty. The host's rate is the host's. At sixty a frame
  * shows for exactly its hold; at one a second a hold shorter than a second is
  * skipped and a period of whole seconds freezes on one frame, and nothing
  * here adapts to that — the beat is `core/easing.ts`'s, the one timing
  * vocabulary, and a draw costs the same at `t = 0` and `t = 10⁶`.
  *
- * The sequence and the moment are two values, because only one of them
- * changes from frame to frame. A `FrameSequence` is the frames prepared once
- * — the beat, the one width, each frame set into a line and padded — and a
- * `Frames` is that sequence at a `t`, whose work is one frame's — finding
- * which, and copying it: a host holds the sequence and asks it for a frame,
- * as `Spinner` holds its two, so a draw costs the same over ninety frames as
- * over one. The sequence is a value the host keeps, not a memo here: nothing
- * is looked up by key.
+ * A `FrameSequence` is the frames prepared once — the beat, the one width,
+ * each frame set into a line and padded — and an `Animation` of the frame
+ * shown (`core/animation.ts`), placed like any other: drawn, its work is one
+ * frame's — finding which, and copying it — so a draw costs the same over
+ * ninety frames as over one. The sequence is a value its holder keeps, as
+ * `Spinner` holds its two, not a memo here: nothing is looked up by key.
  *
- * The frame drawn is drawn until the next begins, and its cells say so: they
- * are stamped with that moment (`Style.nextChange`), which rides up through
- * every container to whoever holds the composed frame (`Segment.nextChange`),
- * so a host drawing at `t` knows when to draw again, and one drawing slower
- * than the frames turn can see that it is skipping them.
+ * The frame drawn is drawn until the next begins, and its cells say so: a
+ * placed sequence stamps them with its hold (`Style.hold`,
+ * `placedRender` in `core/animation.ts`), which rides up
+ * through every container to whoever holds the composed frame
+ * (`Segment.nextChange`), so a host drawing at `t` knows when to draw again,
+ * and one drawing slower than the frames turn can see that it is skipping
+ * them. Nothing an animation's `at` returns carries a stamp of its own: the
+ * stamp is put on where the frame's time is known.
  *
  * Every frame is drawn at one width, the widest frame's, each padded on the
  * right to it, so whatever sits beside the frames never moves as they turn;
@@ -43,17 +44,18 @@
  * binding has no console for, so the frame arrives read, as a `Group`'s
  * children do.
  */
+import { Animation } from "../core/animation.js";
 import { type Beat } from "../core/easing.js";
-import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
+import type { Motion, RenderOptions } from "../core/protocol.js";
 import type { Segment } from "../core/segment.js";
-import type { RichText } from "../core/text.js";
+import { RichText } from "../core/text.js";
 /** One frame: what it shows, and how long it is held, in seconds. */
 export interface Frame {
     readonly text: RichText;
     readonly seconds: number;
 }
 /** A sequence of frames prepared to be drawn: built once, asked for the frame at a time. */
-export declare class FrameSequence {
+export declare class FrameSequence implements Animation<RichText> {
     /** Which frame is in progress when: the holds are the frames' seconds, in order. */
     readonly beat: Beat;
     /** The width every frame draws at: the widest frame's, in cells. */
@@ -62,34 +64,34 @@ export declare class FrameSequence {
     constructor(frames: readonly Frame[]);
     /**
      * The frame in progress at `t`, at `width` cells, ending no line: a copy,
-     * the caller's to change, its every cell — padding included — stamped with
-     * when it gives way to the next, `beat.end(t)`, so a blank frame among
-     * drawn ones still turns. [LAW:one-source-of-truth] The stamp is the one
-     * answer to when the frame changes, read off the cells
-     * (`Segment.nextChange`): a sequence of nothing has no cell to carry one,
-     * and a field saying a time would disagree with cells saying never.
-     * `beat.at` refuses a `t` that is not finite.
+     * the caller's to change, carrying no word on when it changes — that is
+     * stamped where it is placed, at the frame's time. `beat.at`
+     * refuses a `t` that is not finite.
      */
-    text(t: number): RichText;
-}
-export interface FramesOptions {
-    /** The moment to draw, in seconds. */
-    readonly t: number;
-}
-/** A sequence's frame in progress at one moment, as a renderable. */
-export declare class Frames implements Renderable, Measurable {
-    readonly sequence: FrameSequence;
-    readonly t: number;
-    private readonly _shown;
-    constructor(sequence: FrameSequence, options: FramesOptions);
+    at(t: number): RichText;
+    /** When the frame in progress at `t` gives way to the next: the beat's answer, its holds being the frames'. */
+    nextChange(t: number): number;
+    /** When the frame in progress at `t` began: the beat's answer. */
+    lastChange(t: number): number;
+    /** The frames with their motion taken out: the beat's first frame, held, a copy as `at`'s is. */
+    reduced(): Animation<RichText>;
     render(options: RenderOptions): Iterable<Segment>;
     /**
-     * One width both ways: a frame is one picture, never wrapped apart at a
-     * space or narrowed as the frames turn. Fitting it to the room is
-     * `Measurement.get`'s, as for every measurable.
+     * One width both ways, the same for every frame and reduced or not: a frame
+     * is one picture, never wrapped apart at a space or narrowed as the frames
+     * turn. Fitting it to the room is `Measurement.get`'s, as for every measurable.
      */
     measure(): {
         minimum: number;
         maximum: number;
     };
 }
+/**
+ * The text frame `animation` shows at host time `t` under `motion`
+ * (`shownAt`), copied and stamped with the hold it is in there: what the
+ * template `frames` and `glyphs` functions, which know the reader's
+ * preference before any render, splice into a line. The stamp is on the
+ * base style, which an empty text still draws as its one piece of no width,
+ * and on a copy, since an animation may hand back the one `RichText` it holds.
+ */
+export declare function textFrameAt(animation: Animation<RichText>, t: number, motion: Motion): RichText;

package/dist/renderables/frames.js

@@ -7,32 +7,33 @@
  * (`./effect.ts`: "It changes how cells look, never which cells exist or who
  * drew them"). A frame is the other kind of motion — what the element shows
  * changes — so it is its own primitive and not a wider `Effect`, and the two
- * compose by nesting: `new Effected(new Frames(…), …)` lights whichever frame
- * is up.
+ * compose by nesting: `new Effected(sequence, …)` lights whichever frame is
+ * up.
  *
- * [LAW:no-ambient-temporal-coupling] `t` is an argument, as
- * `Effected`'s is, never a clock read: whoever draws frames hands each one
- * its time (`core/clock.ts`), so the same `t` draws the same bytes at one
+ * [LAW:no-ambient-temporal-coupling] `t` is the frame's time, never a
+ * clock read: whoever draws frames hands each one its time
+ * (`RenderOptions.frame`), so the same `t` draws the same bytes at one
  * redraw a second or sixty. The host's rate is the host's. At sixty a frame
  * shows for exactly its hold; at one a second a hold shorter than a second is
  * skipped and a period of whole seconds freezes on one frame, and nothing
  * here adapts to that — the beat is `core/easing.ts`'s, the one timing
  * vocabulary, and a draw costs the same at `t = 0` and `t = 10⁶`.
  *
- * The sequence and the moment are two values, because only one of them
- * changes from frame to frame. A `FrameSequence` is the frames prepared once
- * — the beat, the one width, each frame set into a line and padded — and a
- * `Frames` is that sequence at a `t`, whose work is one frame's — finding
- * which, and copying it: a host holds the sequence and asks it for a frame,
- * as `Spinner` holds its two, so a draw costs the same over ninety frames as
- * over one. The sequence is a value the host keeps, not a memo here: nothing
- * is looked up by key.
+ * A `FrameSequence` is the frames prepared once — the beat, the one width,
+ * each frame set into a line and padded — and an `Animation` of the frame
+ * shown (`core/animation.ts`), placed like any other: drawn, its work is one
+ * frame's — finding which, and copying it — so a draw costs the same over
+ * ninety frames as over one. The sequence is a value its holder keeps, as
+ * `Spinner` holds its two, not a memo here: nothing is looked up by key.
  *
- * The frame drawn is drawn until the next begins, and its cells say so: they
- * are stamped with that moment (`Style.nextChange`), which rides up through
- * every container to whoever holds the composed frame (`Segment.nextChange`),
- * so a host drawing at `t` knows when to draw again, and one drawing slower
- * than the frames turn can see that it is skipping them.
+ * The frame drawn is drawn until the next begins, and its cells say so: a
+ * placed sequence stamps them with its hold (`Style.hold`,
+ * `placedRender` in `core/animation.ts`), which rides up
+ * through every container to whoever holds the composed frame
+ * (`Segment.nextChange`), so a host drawing at `t` knows when to draw again,
+ * and one drawing slower than the frames turn can see that it is skipping
+ * them. Nothing an animation's `at` returns carries a stamp of its own: the
+ * stamp is put on where the frame's time is known.
  *
  * Every frame is drawn at one width, the widest frame's, each padded on the
  * right to it, so whatever sits beside the frames never moves as they turn;
@@ -43,8 +44,9 @@
  * binding has no console for, so the frame arrives read, as a `Group`'s
  * children do.
  */
+import { Animation, holdOf, placedRender, shownAt, stamp } from "../core/animation.js";
 import { beat } from "../core/easing.js";
-import { Style } from "../core/style.js";
+import { layerStyle } from "../core/style.js";
 import { setIntoLine } from "./embed.js";
 /** A sequence of frames prepared to be drawn: built once, asked for the frame at a time. */
 export class FrameSequence {
@@ -61,7 +63,7 @@ export class FrameSequence {
         this.width = Math.max(...widths);
         this._shown = texts.map((text, i) => {
             // One picture: a slot narrower than the frame crops it, never folds
-            // or wraps it onto a second line, which `Frames.measure` says it cannot take.
+            // or wraps it onto a second line, which `measure` says it cannot take.
             text.noWrap = true;
             text.overflow = "crop";
             return text.padRight(this.width - widths[i]);
@@ -69,38 +71,48 @@ export class FrameSequence {
     }
     /**
      * The frame in progress at `t`, at `width` cells, ending no line: a copy,
-     * the caller's to change, its every cell — padding included — stamped with
-     * when it gives way to the next, `beat.end(t)`, so a blank frame among
-     * drawn ones still turns. [LAW:one-source-of-truth] The stamp is the one
-     * answer to when the frame changes, read off the cells
-     * (`Segment.nextChange`): a sequence of nothing has no cell to carry one,
-     * and a field saying a time would disagree with cells saying never.
-     * `beat.at` refuses a `t` that is not finite.
+     * the caller's to change, carrying no word on when it changes — that is
+     * stamped where it is placed, at the frame's time. `beat.at`
+     * refuses a `t` that is not finite.
      */
-    text(t) {
-        return this._shown[this.beat.at(t)].copy().stylize(new Style({ nextChange: this.beat.end(t) }));
+    at(t) {
+        return this._shown[this.beat.at(t)].copy();
     }
-}
-/** A sequence's frame in progress at one moment, as a renderable. */
-export class Frames {
-    sequence;
-    t;
-    // The frame `t` lands on, found once, here, so a bad time fails at construction.
-    _shown;
-    constructor(sequence, options) {
-        this.sequence = sequence;
-        this.t = options.t;
-        this._shown = sequence.text(options.t);
+    /** When the frame in progress at `t` gives way to the next: the beat's answer, its holds being the frames'. */
+    nextChange(t) {
+        return this.beat.nextChange(t);
+    }
+    /** When the frame in progress at `t` began: the beat's answer. */
+    lastChange(t) {
+        return this.beat.lastChange(t);
+    }
+    /** The frames with their motion taken out: the beat's first frame, held, a copy as `at`'s is. */
+    reduced() {
+        return Animation.map(this.beat.reduced(), (i) => this._shown[i].copy());
     }
     render(options) {
-        return this._shown.render(options);
+        return placedRender(this, options);
     }
     /**
-     * One width both ways: a frame is one picture, never wrapped apart at a
-     * space or narrowed as the frames turn. Fitting it to the room is
-     * `Measurement.get`'s, as for every measurable.
+     * One width both ways, the same for every frame and reduced or not: a frame
+     * is one picture, never wrapped apart at a space or narrowed as the frames
+     * turn. Fitting it to the room is `Measurement.get`'s, as for every measurable.
      */
     measure() {
-        return { minimum: this.sequence.width, maximum: this.sequence.width };
+        return { minimum: this.width, maximum: this.width };
     }
 }
+/**
+ * The text frame `animation` shows at host time `t` under `motion`
+ * (`shownAt`), copied and stamped with the hold it is in there: what the
+ * template `frames` and `glyphs` functions, which know the reader's
+ * preference before any render, splice into a line. The stamp is on the
+ * base style, which an empty text still draws as its one piece of no width,
+ * and on a copy, since an animation may hand back the one `RichText` it holds.
+ */
+export function textFrameAt(animation, t, motion) {
+    const shown = shownAt(animation, t, motion);
+    const stamped = shown.value.copy();
+    stamped.style = layerStyle(stamped.style, stamp(holdOf(shown, t)));
+    return stamped;
+}

package/dist/renderables/glyph-effect.d.ts

@@ -0,0 +1,158 @@
+/**
+ * GlyphEffected — a renderable whose finished cells' glyphs pass through a
+ * glyph effect at a moment `t`: the glyph half of `Effected` (`./effect.ts`),
+ * built to its contract.
+ *
+ * A glyph effect is the colour effect's two-stage shape with a glyph where
+ * the colours were: for the cells an element draws in a frame, an
+ * `Animation` (`../core/animation.ts`) of what is done to them. The first
+ * stage is handed every cell once a frame (`GlyphCell`), blanks included —
+ * rain and stars live there — and whether the output draws ASCII alone
+ * (`DrawnGlyphs`), and works out what holds for the whole frame:
+ * how many cells are typed, where a band is. The second, the function
+ * `at(t)` returns, maps each cell to the text it shows. A typewriter, a
+ * scramble, a wave of case changes and particles on blank cells are all this
+ * one shape (`./glyph-effects.ts`) [LAW:one-type-per-behavior].
+ *
+ * Colour and glyph are not two kinds of animation: each is an `Animation` of
+ * a per-cell map, and they differ only in what a cell is mapped to. The
+ * wrappers are two because the stages are handed different facts. A colour
+ * effect is settled against the depth, the terminal and the colours of the
+ * words (`Drawn`), and with no colour output there is nothing for it to
+ * change. A glyph effect needs none of that, and is written at every depth,
+ * with no colour too. Over one element the two compose by nesting:
+ * `new Effected(new GlyphEffected(child, glyphs, …), colours, …)` moves the
+ * colours of the glyphs the glyph effect left, since each wrapper measures
+ * what its child drew.
+ *
+ * A `GlyphEffected` is the element under its glyph effect over time, an
+ * `Animation<Renderable>` placed as an `Effected` is, its value at `t` the
+ * element through the effect at `t` (`Reglyphed`).
+ * [LAW:no-ambient-temporal-coupling] The time is the frame's, never a clock
+ * read, so the same time draws the same bytes at any frame rate.
+ *
+ * What a glyph effect may not do is the contract this module holds:
+ *
+ * - It changes what a cell shows, never which cells exist, where they are or
+ *   who drew them. The text it returns for a cell is exactly as many cells
+ *   wide (`cellLen`), carries no line break or control character, and does
+ *   not join the cell beside it into one grapheme cluster, or the render
+ *   throws naming the cell [LAW:single-enforcer]. So what sits beside the
+ *   element never moves, and a wide glyph is changed whole — blanked as two
+ *   spaces, scrambled as two one-cell glyphs — never cut.
+ * - A segment whose every glyph comes back as it was is yielded as it was,
+ *   so the identity effect is byte-identical. A changed segment keeps its
+ *   style whole, link, meta and anchor included; no cell has moved, so the
+ *   anchor's offsets are still true and hit testing still finds the owner.
+ * - Placed as a `GlyphEffected`, every cell carries the hold the frame is in
+ *   (`Style.hold`), under whatever the child said,
+ *   as under `Effected`; drawn as a `Reglyphed`, a value, none.
+ *
+ * Positions are the child's own: row and column count from the top-left of
+ * what the child drew.
+ */
+import { Animation } from "../core/animation.js";
+import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
+import { Segment } from "../core/segment.js";
+import { type RichText } from "../core/text.js";
+import { type Moved, type Placed } from "./effect.js";
+/**
+ * A cell of the element a glyph effect wraps: the glyph it shows, where it
+ * sits and who drew it, its place in reading order among the cells handed
+ * (`DrawnGlyphs.cells[index]` is this cell), and its seed, a number in [0, 1) that is the
+ * same for that cell on every frame, as an `EffectCell`'s is.
+ */
+export interface GlyphCell extends Placed {
+    readonly glyph: string;
+    readonly index: number;
+    readonly seed: number;
+}
+/** What a glyph effect does to the cells of one frame: a cell in, the text it shows out, as many cells wide. Return `cell.glyph` to leave it be. */
+export type GlyphFrame = (cell: GlyphCell) => string;
+/**
+ * What the element a glyph effect wraps draws in one frame, and on what: the
+ * glyph half of `Drawn`.
+ */
+export interface DrawnGlyphs {
+    /** Every cell, in reading order; a line break is no cell. */
+    readonly cells: readonly GlyphCell[];
+    /**
+     * Whether the output draws ASCII alone (`RenderOptions.asciiOnly`). A glyph
+     * the effect chooses itself, rather than one the element drew, goes through
+     * `drawable` against it, as every glyph the library chooses does.
+     */
+    readonly asciiOnly: boolean;
+}
+/**
+ * For an element drawing `drawn`, the animation of what is done to its
+ * glyphs. Its `nextChange` is when the frame next changes, as an `Effect`'s is.
+ */
+export type GlyphEffect = (drawn: DrawnGlyphs) => Animation<GlyphFrame>;
+export interface GlyphEffectedOptions {
+    /** Names the element for its seeds, as `EffectedOptions.key` does; under both wrappers, one key gives one seed a cell. */
+    readonly key: string;
+}
+/**
+ * A `GlyphEffected` at `t`, or an element through a glyph effect at a time an
+ * animation's `at` was handed: `renderable` with its cells' glyphs passed
+ * through `effect` at `t`, saying nothing of when that changes, as a
+ * `Recolored` is (`./effect.ts`). [LAW:one-type-per-behavior]
+ */
+export declare class Reglyphed implements Renderable, Measurable {
+    readonly renderable: Renderable;
+    readonly effect: GlyphEffect;
+    readonly t: number;
+    readonly key: string;
+    constructor(renderable: Renderable, effect: GlyphEffect, options: GlyphEffectedOptions & {
+        readonly t: number;
+    });
+    render(options: RenderOptions): Iterable<Segment>;
+    /** The frame the effect draws at `t`, and the hold it says that is in. */
+    moved(options: RenderOptions): Moved;
+    measure(options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}
+/**
+ * `renderable` under a glyph effect over time, an `Animation<Renderable>`
+ * as an `Effected` is (`./effect.ts`): its own answer is `t`, and placed,
+ * its cells carry the glyph effect's exact hold at the frame's time and the
+ * output's `asciiOnly`, under whatever the element already said.
+ */
+export declare class GlyphEffected implements Animation<Renderable> {
+    readonly renderable: Renderable;
+    readonly effect: GlyphEffect;
+    readonly key: string;
+    constructor(renderable: Renderable, effect: GlyphEffect, options: GlyphEffectedOptions);
+    /** The element through the glyph effect at `t`, unstamped. */
+    at(t: number): Reglyphed;
+    nextChange(t: number): number;
+    lastChange(t: number): number;
+    /** The element under the glyph effect with its motion taken out. */
+    reduced(): GlyphEffected;
+    /** Drawn at the frame's time, its cells stamped with the glyph effect's exact hold there. */
+    render(options: RenderOptions): Iterable<Segment>;
+    measure(options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}
+/**
+ * `text` with its glyphs passed through `effect`, before any render: the
+ * glyph half of a template fragment (`../template-bindings/animation-funcs.ts`),
+ * which is spliced into a line and drawn under a theme it does not know yet,
+ * so it cannot be rendered to cells first as `Reglyphed` renders its child.
+ * The cells are the text's own lines, at its own columns; the contract is
+ * the one `Reglyphed` is held to, through the same checks, over the text's
+ * own glyphs: a neighbour spliced beside it later, a combining mark leading
+ * the next fragment say, is outside what either check can see. The text keeps
+ * its every style and span, each moved to where its glyphs now sit, and a
+ * frame that changes nothing hands the text back as it was. What it says of
+ * when it changes is the effect's, unstamped: whoever draws it at a time
+ * stamps it (`textFrameAt`).
+ */
+export declare function reglyphText(text: RichText, effect: GlyphEffect, options: {
+    readonly key: string;
+    readonly asciiOnly: boolean;
+}): Animation<RichText>;