@promptctl/rich-js 0.27.0 → 0.28.0

package/dist/renderables/glyph-effect.js

@@ -51,44 +51,40 @@
  * Positions are the child's own: row and column count from the top-left of
  * what the child drew.
  */
-import { Animation, frameTimeOf, holdOf, shownAt, stampFrame } from "../core/animation.js";
+import { Animation, placedRender, shownAt } from "../core/animation.js";
 import { cellLen, graphemes } from "../core/cells.js";
 import { Measurement } from "../core/measure.js";
 import { render } from "../core/protocol.js";
 import { Segment } from "../core/segment.js";
 import { finiteTime } from "../core/easing.js";
-import { stripControlChars } from "../core/text.js";
-import { cellSeed, walkGlyphs } from "./effect.js";
+import { sanitized } from "../core/text.js";
+import { cellSeed, holdOver, walkGlyphs } from "./effect.js";
 import { pattern } from "../core/pattern.js";
 /**
  * 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]
+ * through `effect` at `t`, telling the hold it drew in as a `Recolored` does
+ * (`RenderOptions.onMoved`, `./effect.ts`). [LAW:one-type-per-behavior]
  */
 export class Reglyphed {
     renderable;
     effect;
-    t;
+    _t;
     key;
     constructor(renderable, effect, options) {
         this.renderable = renderable;
         this.effect = effect;
-        this.t = finiteTime("GlyphEffected", options.t);
+        this._t = finiteTime("GlyphEffected", options.t);
         this.key = options.key;
     }
     render(options) {
-        return this.moved(options).segments;
-    }
-    /** The frame the effect draws at `t`, and the hold it says that is in. */
-    moved(options) {
         const segments = [...render(this.renderable, options)];
         const { placed, cells } = placeGlyphs(segments, this.key);
         const animation = this.effect({ cells, asciiOnly: options.asciiOnly === true });
-        const frame = shownAt(animation, this.t, options);
+        const frame = shownAt(animation, this._t, options);
         const shown = showGlyphs(placed, frame.value);
-        const changed = segments.map((segment, i) => shown[i].every((text, j) => text === placed[i][j].glyph) ? segment : new Segment(shown[i].join(""), segment.style));
-        return { segments: changed, hold: holdOf(frame, this.t) };
+        options.onMoved?.(this._t, this.key, holdOver(cells.length > 0, frame, this._t));
+        return segments.map((segment, i) => (shown[i].every((text, j) => text === placed[i][j].glyph) ? segment : new Segment(shown[i].join(""), segment.style)));
     }
     measure(options) {
         return Measurement.get(options, this.renderable);
@@ -96,9 +92,10 @@ export class Reglyphed {
 }
 /**
  * `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.
+ * as an `Effected` is (`./effect.ts`): with nothing drawn its answer is `t`,
+ * and placed, on its own or as a part of any combinator, it says the glyph
+ * effect's exact hold at that time and the output's `asciiOnly`, which the
+ * frame's drawing told (`Moves`).
  */
 export class GlyphEffected {
     renderable;
@@ -113,11 +110,11 @@ export class GlyphEffected {
     at(t) {
         return new Reglyphed(this.renderable, this.effect, { t, key: this.key });
     }
-    nextChange(t) {
-        return t;
+    nextChange(t, moves) {
+        return moves?.(t, this.key)?.nextChange ?? t;
     }
-    lastChange(t) {
-        return t;
+    lastChange(t, moves) {
+        return moves?.(t, this.key)?.lastChange ?? t;
     }
     /** The element under the glyph effect with its motion taken out. */
     reduced() {
@@ -126,8 +123,7 @@ export class GlyphEffected {
     }
     /** Drawn at the frame's time, its cells stamped with the glyph effect's exact hold there. */
     render(options) {
-        const { segments, hold } = this.at(frameTimeOf(options)).moved(options);
-        return stampFrame(segments, hold);
+        return placedRender(this, options);
     }
     measure(options) {
         return Measurement.get(options, this.renderable);
@@ -161,7 +157,7 @@ function showGlyphs(placed, frame) {
  * 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`).
+ * stamps it (`placed`), or marks it for the engine to (the template `glyphs`).
  */
 export function reglyphText(text, effect, options) {
     const { placed, cells } = placeGlyphs([new Segment(text.plain)], options.key);
@@ -193,7 +189,7 @@ function rewritten(text, glyphs, shown) {
         result.stylize(span.style, moved(span.start), moved(span.end));
     return result;
 }
-/** Line breaks and tabs, which `stripControlChars` leaves for a text's own lines and which no cell may hold. */
+/** Line breaks and tabs, which `sanitized` leaves for a text's own lines and which no cell may hold. */
 const BREAKS = pattern(/[\n\t]/);
 /**
  * What `frame` shows in `cell`, held to the contract: as many cells wide as
@@ -205,7 +201,7 @@ function shows(frame, cell) {
     const text = frame(cell);
     if (text === cell.glyph)
         return text;
-    if (cellLen(text) !== cellLen(cell.glyph) || BREAKS.test(text) || stripControlChars(text) !== text) {
+    if (cellLen(text) !== cellLen(cell.glyph) || BREAKS.test(text) || sanitized(text) !== text) {
         throw new RangeError(`a glyph effect turned ${JSON.stringify(cell.glyph)} at row ${cell.row}, column ${cell.col} into ${JSON.stringify(text)}: ` +
             `it must be ${cellLen(cell.glyph)} cell(s) wide, with no line break or control character`);
     }
@@ -218,18 +214,24 @@ function shows(frame, cell) {
  * wide as its glyph is `shows`'s check; this is the half no one cell can
  * see — a trailing zero-width joiner that fuses with the next emoji, or a
  * leading combining mark that draws on the glyph before it, is right alone
- * and wrong beside its neighbour. Only a changed text is asked, so a child
- * that splits a cluster across its own segments is drawn as it drew it.
+ * and wrong beside its neighbour. Only a join the effect made is asked, seam
+ * by seam, so a child that splits a cluster across its own segments is drawn
+ * as it drew it, whatever becomes of the glyph its mark sits on.
  */
 function standsApart(placed, shown) {
-    // A line break is no cell, and nothing joins across it.
-    const beside = (j) => (placed[j]?.cell === undefined ? "" : shown[j]);
+    const fuse = (left, right) => graphemes(left + right).length < graphemes(left).length + graphemes(right).length;
+    // Whether the text at `i` fuses across its left seam and across its right.
+    const seams = (texts, i) => {
+        // A line break is no cell, and nothing joins across it.
+        const beside = (j) => (placed[j]?.cell === undefined ? "" : texts(j));
+        const [before, text, after] = [beside(i - 1), texts(i), beside(i + 1)];
+        return [fuse(before, text + after), fuse(before + text, after)];
+    };
     shown.forEach((text, i) => {
         const { glyph, cell } = placed[i];
         if (cell === undefined || text === glyph)
             return;
-        const [before, after] = [beside(i - 1), beside(i + 1)];
-        if (graphemes(before + text + after).length !== graphemes(before).length + graphemes(text).length + graphemes(after).length) {
+        if (seams((j) => shown[j], i).some((fused, seam) => fused && !seams((j) => placed[j].glyph, i)[seam])) {
             throw new RangeError(`a glyph effect turned ${JSON.stringify(glyph)} at row ${cell.row}, column ${cell.col} into ${JSON.stringify(text)}, ` +
                 `which joins the cell beside it into one character`);
         }

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

@@ -1,11 +1,12 @@
 /**
  * The glyph effect catalogue: a typewriter and a scramble, which run once and
  * are done, each with its way out for an element leaving (`backspace`,
- * `scrambleOut`), and a wave of case changes, rain and stars, which loop for as
- * long as they are drawn. Each is a `GlyphEffect` for `GlyphEffected`
- * (`./glyph-effect.ts`), built as the colour catalogue's are
- * (`./effects.ts`): one function each over the one shape, made by name, one
- * way, at the defaults in `GLYPH_DEFAULTS` (`GLYPH_EFFECT_CATALOGUE`).
+ * `scrambleOut`), and a wave of case changes, rain, stars and marching ants,
+ * which loop for as long as they are drawn. Each is a `GlyphEffect` for
+ * `GlyphEffected` (`./glyph-effect.ts`), built as the colour catalogue's are
+ * (`./effects.ts`): one function each over the one shape, at the defaults in
+ * `GLYPH_DEFAULTS`. `GLYPH_EFFECT_CATALOGUE` makes by name those a template's
+ * `glyphs` takes.
  *
  * Where a colour loop glides, a glyph cannot: a cell shows one glyph or
  * another, so every loop here moves in steps, on a `beat`, and says when its
@@ -90,11 +91,25 @@ export interface Particles {
  * row a step, and one that holds still draws a fresh field each life.
  */
 export declare function particles(spec: Particles, z: number): GlyphEffect;
-/** The names of the glyph effects that loop. */
+/** How ants march: a step, in seconds, for the gaps to move one cell, and the most cells a gap may be from the next. */
+export interface MarchingAnts {
+    readonly step: number;
+    readonly every: number;
+}
+/**
+ * Marching ants: gaps blanked round each box the element draws, spaced as
+ * evenly as the ring allows and never more than `every` cells apart, walking
+ * one cell clockwise a `step`. The whole pattern turns, so a ring that `every`
+ * does not divide closes with no seam at its corner. The ring is whatever the box
+ * is (`Box.frame`), at any width and beside a title. A ring may draw blanks and
+ * they keep the count, but an element with no ink on any ring never changes.
+ */
+export declare function marchingAnts({ step, every }: MarchingAnts): GlyphEffect;
+/** The names a template's `glyphs` takes for an effect that loops. */
 export type GlyphLoopName = "wave" | "rain" | "stars";
-/** The names of the glyph effects that run once. */
+/** The names a template's `glyphs` takes for an effect that runs once. */
 export type GlyphTransitionName = "typewriter" | "scramble" | "backspace" | "scrambleOut";
-/** Each catalogue glyph effect's defaults, as first drawn in `examples/glyph-effects`. */
+/** Each glyph effect's defaults, as first drawn in `examples/glyph-effects`. */
 export declare const GLYPH_DEFAULTS: {
     readonly typewriter: {
         readonly seconds: 2;
@@ -132,6 +147,10 @@ export declare const GLYPH_DEFAULTS: {
         readonly drift: 0;
         readonly life: 1;
     };
+    readonly march: {
+        readonly step: 0.15;
+        readonly every: 3;
+    };
 };
 /**
  * Every glyph effect in the catalogue by name, each made the one way: for an

package/dist/renderables/glyph-effects.js

@@ -1,11 +1,12 @@
 /**
  * The glyph effect catalogue: a typewriter and a scramble, which run once and
  * are done, each with its way out for an element leaving (`backspace`,
- * `scrambleOut`), and a wave of case changes, rain and stars, which loop for as
- * long as they are drawn. Each is a `GlyphEffect` for `GlyphEffected`
- * (`./glyph-effect.ts`), built as the colour catalogue's are
- * (`./effects.ts`): one function each over the one shape, made by name, one
- * way, at the defaults in `GLYPH_DEFAULTS` (`GLYPH_EFFECT_CATALOGUE`).
+ * `scrambleOut`), and a wave of case changes, rain, stars and marching ants,
+ * which loop for as long as they are drawn. Each is a `GlyphEffect` for
+ * `GlyphEffected` (`./glyph-effect.ts`), built as the colour catalogue's are
+ * (`./effects.ts`): one function each over the one shape, at the defaults in
+ * `GLYPH_DEFAULTS`. `GLYPH_EFFECT_CATALOGUE` makes by name those a template's
+ * `glyphs` takes.
  *
  * Where a colour loop glides, a glyph cannot: a cell shows one glyph or
  * another, so every loop here moves in steps, on a `beat`, and says when its
@@ -50,6 +51,10 @@ function text(cells) {
     }
     return { length: place.size, place };
 }
+/** `n` wrapped into [0, `size`), for a count a timeline may run backwards past 0. */
+function wrapped(n, size) {
+    return ((n % size) + size) % size;
+}
 /** Of `n` cells, how many have arrived at eased progress `p`, an ease that overshoots held to the cells there are. */
 function arrived(n, p) {
     return Math.min(n, Math.max(0, Math.floor(n * p)));
@@ -200,7 +205,7 @@ export function caseWave({ step, width }, z) {
         const start = Math.floor(hash(z, 2.3) * span);
         return steps((s) => {
             // The column just past the band's right edge; it enters at the left.
-            const lead = (((s + start) % span) + span) % span;
+            const lead = wrapped(s + start, span);
             // A wide glyph is in the band if any of its columns is.
             return (cell) => (cell.col < lead && cell.col + cellLen(cell.glyph) > lead - width ? swapCase(cell.glyph) : cell.glyph);
         }, AS_WRITTEN);
@@ -250,7 +255,69 @@ export function particles(spec, z) {
         }, AS_WRITTEN);
     };
 }
-/** Each catalogue glyph effect's defaults, as first drawn in `examples/glyph-effects`. */
+/**
+ * Where each cell stands on the ring of the box frame that drew it, by
+ * `index`. A ring is the
+ * perimeter of the rectangle a frame's cells cover, read in the element's own
+ * rows and columns, so it is true wherever the box sits among them. A rule or
+ * divider inside that rectangle, as a table draws, is frame and no part of the
+ * ring, and a title set into the frame is no frame but keeps its places.
+ */
+function ringPlaces(cells) {
+    const frames = new Map();
+    for (const cell of cells) {
+        if (cell.boxFrame === undefined)
+            continue;
+        const ring = frames.get(cell.boxFrame);
+        if (ring === undefined)
+            frames.set(cell.boxFrame, [cell]);
+        else
+            ring.push(cell);
+    }
+    const places = new Map();
+    for (const ring of frames.values()) {
+        // Cells come in reading order, so the rows are the ring's two ends.
+        const [top, down] = [ring[0].row, ring[ring.length - 1].row - ring[0].row];
+        const left = ring.reduce((most, { col }) => Math.min(most, col), Infinity);
+        const across = ring.reduce((most, { col }) => Math.max(most, col), -Infinity) - left;
+        const size = Math.max(1, 2 * (across + down));
+        for (const cell of ring) {
+            const [y, x] = [cell.row - top, cell.col - left];
+            const place = y === 0 ? x : x === across ? across + y : y === down ? 2 * across + down - x : x === 0 ? 2 * (across + down) - y : undefined;
+            if (place !== undefined)
+                places.set(cell.index, { place, cells: size });
+        }
+    }
+    return places;
+}
+/**
+ * Marching ants: gaps blanked round each box the element draws, spaced as
+ * evenly as the ring allows and never more than `every` cells apart, walking
+ * one cell clockwise a `step`. The whole pattern turns, so a ring that `every`
+ * does not divide closes with no seam at its corner. The ring is whatever the box
+ * is (`Box.frame`), at any width and beside a title. A ring may draw blanks and
+ * they keep the count, but an element with no ink on any ring never changes.
+ */
+export function marchingAnts({ step, every }) {
+    positiveSeconds("marchingAnts step", step);
+    if (!(Number.isInteger(every) && every > 1))
+        throw new RangeError(`marchingAnts every must be a whole number of cells above 1, got ${every}`);
+    const steps = stepped(step);
+    return ({ cells }) => {
+        const places = ringPlaces(cells);
+        if (!cells.some((cell) => places.has(cell.index) && inked(cell.glyph)))
+            return Animation.constant(AS_WRITTEN);
+        return steps((s) => (cell) => {
+            const at = places.get(cell.index);
+            if (at === undefined)
+                return cell.glyph;
+            // Bresenham's line over the ring: of `cells` places, the `gaps` where a running count crosses a whole number.
+            const gaps = Math.ceil(at.cells / every);
+            return (wrapped(at.place - s, at.cells) * gaps) % at.cells < gaps ? blank(cell.glyph) : cell.glyph;
+        }, AS_WRITTEN);
+    };
+}
+/** Each glyph effect's defaults, as first drawn in `examples/glyph-effects`. */
 export const GLYPH_DEFAULTS = {
     typewriter: { seconds: 2, ease: EASES.linear },
     scramble: { seconds: 2.5, ease: EASES["ease-in"] },
@@ -259,6 +326,7 @@ export const GLYPH_DEFAULTS = {
     wave: { step: 0.06, width: 3 },
     rain: { glyphs: "│╎", ascii: "|:", density: 0.06, step: 0.08, drift: 1, life: Number.POSITIVE_INFINITY },
     stars: { glyphs: "·+*", ascii: ".+*", density: 0.04, step: 1.5, drift: 0, life: 1 },
+    march: { step: 0.15, every: 3 },
 };
 /**
  * Every glyph effect in the catalogue by name, each made the one way: for an

package/dist/renderables/lifecycle.d.ts

@@ -29,9 +29,8 @@
  *
  * A half draws the element through a colour transition (`throughColors`, a
  * `fadeIn`) or a glyph one (`throughGlyphs`, a `typewriter`): each binds its
- * transition to the one wrapper that draws it, and to what that wrapper
- * needs — a theme for colours, nothing for glyphs — so nothing here asks which
- * kind a half is, and a line can type itself in and dissolve out. A half
+ * transition to the one wrapper that draws it, so nothing here asks which kind
+ * a half is, and a line can type itself in and dissolve out. A half
  * written by hand is any function of that shape — an arrival that slides the
  * element in, which no effect draws. An exit is a half that ends with nothing
  * drawn — `dissolveOut`, `backspace`, `scrambleOut` — so the element has
@@ -43,7 +42,6 @@
  * backwards — it draws nothing too, but is not gone.
  */
 import { Animation } from "../core/animation.js";
-import type { TerminalTheme } from "../core/color.js";
 import type { Renderable } from "../core/protocol.js";
 import type { Transition } from "./effects.js";
 import type { GlyphTransition } from "./glyph-effects.js";
@@ -59,13 +57,13 @@ import type { GlyphTransition } from "./glyph-effects.js";
  * `throughColors` and `throughGlyphs` lend one the transition's schedule.
  */
 export type Half = (element: Renderable, key: string) => Animation<Renderable>;
-/** `transition`'s colours drawn over an element on `theme`, whose ground it arrives from and leaves to. */
-export declare function throughColors(transition: Transition, theme: TerminalTheme): Half;
+/** `transition`'s colours drawn over an element, arriving from and leaving to the ground of the terminal the frame is drawn on. */
+export declare function throughColors(transition: Transition): Half;
 /** `transition`'s glyphs drawn over an element, at every depth, with no colour too. */
 export declare function throughGlyphs(transition: GlyphTransition): Half;
 /** How an element arrives and leaves, and what it is named for their seeds. */
 export interface LifecycleOptions {
-    /** The half it arrives through — `throughColors(fadeIn(curve, z), theme)`. */
+    /** The half it arrives through — `throughColors(fadeIn(curve, z))`. */
     readonly enter: Half;
     /** The half it leaves through — `throughGlyphs(scrambleOut(timing, z))`. */
     readonly exit: Half;

package/dist/renderables/lifecycle.js

@@ -29,9 +29,8 @@
  *
  * A half draws the element through a colour transition (`throughColors`, a
  * `fadeIn`) or a glyph one (`throughGlyphs`, a `typewriter`): each binds its
- * transition to the one wrapper that draws it, and to what that wrapper
- * needs — a theme for colours, nothing for glyphs — so nothing here asks which
- * kind a half is, and a line can type itself in and dissolve out. A half
+ * transition to the one wrapper that draws it, so nothing here asks which kind
+ * a half is, and a line can type itself in and dissolve out. A half
  * written by hand is any function of that shape — an arrival that slides the
  * element in, which no effect draws. An exit is a half that ends with nothing
  * drawn — `dissolveOut`, `backspace`, `scrambleOut` — so the element has
@@ -47,9 +46,9 @@ import { firstReaching } from "../core/easing.js";
 import { Timeline } from "../core/timeline.js";
 import { Effected } from "./effect.js";
 import { GlyphEffected } from "./glyph-effect.js";
-/** `transition`'s colours drawn over an element on `theme`, whose ground it arrives from and leaves to. */
-export function throughColors(transition, theme) {
-    return (element, key) => scheduled(new Effected(element, transition.effect, { key, theme }), transition.schedule);
+/** `transition`'s colours drawn over an element, arriving from and leaving to the ground of the terminal the frame is drawn on. */
+export function throughColors(transition) {
+    return (element, key) => scheduled(new Effected(element, transition.effect, { key }), transition.schedule);
 }
 /** `transition`'s glyphs drawn over an element, at every depth, with no colour too. */
 export function throughGlyphs(transition) {
@@ -107,7 +106,7 @@ function doneAt(half, start) {
  */
 function ending(half, role, key) {
     if (doneAt(half, 0) === Number.POSITIVE_INFINITY) {
-        throw new RangeError(`lifecycle "${key}": the ${role} half never ends: its animation never says it has stopped changing (Animation.done). An Effected or GlyphEffected on its own does not; throughColors(transition, theme) and throughGlyphs(transition) lend one the transition's schedule`);
+        throw new RangeError(`lifecycle "${key}": the ${role} half never ends: its animation never says it has stopped changing (Animation.done). An Effected or GlyphEffected on its own does not; throughColors(transition) and throughGlyphs(transition) lend one the transition's schedule`);
     }
     return half;
 }

package/dist/renderables/markdown.js

@@ -8,6 +8,7 @@
  * followed: HTML, a block of it or a tag inline, is drawn as Rich draws it,
  * not at all.
  */
+import { withoutExplicit } from "../core/bidi.js";
 import { cellCount, cellLen } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
@@ -107,7 +108,8 @@ function appendInline(result, inlines, settings, options) {
     };
     const write = (text, styles) => {
         const start = result.length;
-        result.append(text);
+        // Each inline node is its own content, so what it holds open ends with it.
+        result.append(new RichText(text));
         paint(start, styles);
     };
     const enter = (styles) => {
@@ -156,7 +158,7 @@ function appendInline(result, inlines, settings, options) {
                 write("\n");
                 break;
             case "code":
-                write(inline.code, [groundedStyle(options, resolveStyle(options, settings.inlineCodeStyle))]);
+                write(withoutExplicit(inline.code), [groundedStyle(options, resolveStyle(options, settings.inlineCodeStyle))]);
                 break;
             case "html":
                 kbd(inline.content);

package/dist/renderables/panel.js

@@ -1,6 +1,7 @@
 /**
  * Panel — a bordered box that wraps content, with optional title and subtitle.
  */
+import { labelled } from "../core/orient.js";
 import { cellLen, setCellSize, asCellCol, cellCount } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
@@ -42,10 +43,11 @@ function borderTitle(label, options) {
  * its own laid over the border's, the one rule for "what colour is the title
  * text in". Laid over rather than in place of it, as Rich's `stylize_before`
  * does, because the border's style carries the panel's own: a title that
- * replaced it cut a hole in the panel's background on the top row.
+ * replaced it cut a hole in the panel's background on the top row. The text
+ * is set into the frame and is not of it.
  */
 function borderTextStyle(border, own) {
-    return own.isNull ? border : (border ?? NULL_STYLE).add(own);
+    return border.add(own).withBoxFrame(undefined);
 }
 /**
  * A border row: the opening corner, the rule across `span` cells with `label`
@@ -129,7 +131,7 @@ export class Panel {
         // and the content is rendered on top of it. Applied to the padding alone,
         // "white on dark_blue" drew a blue ring with a hole where the text was.
         const borderStyle = getStyle(options, this.style).add(getStyle(options, this.borderStyle));
-        const border = borderStyle.isNull ? undefined : borderStyle;
+        const border = box.frame(borderStyle);
         const geometry = layoutPanel(this._getPanelWidth(options));
         const bodyLines = this._renderBody(options, geometry.spanWidth);
         yield* this._renderTopBorder(options, box, geometry, border);
@@ -241,7 +243,7 @@ export class Panel {
         const corner = box.bottom.right.repeat(geometry.right);
         const [close, afterAccessory] = accessoryText === "" ? [corner, ""] : ["", corner];
         yield* borderRow(options, box.bottom, geometry, geometry.spanWidth - cellLen(accessoryText), this._subtitleLabel, subtitleStyle, border, close);
-        yield new Segment(accessoryText, borderTextStyle(border, accessoryOwn));
+        yield* labelled("", accessoryText, "", borderTextStyle(border, accessoryOwn), options.textOrder);
         yield new Segment(afterAccessory, border);
         yield Segment.line();
     }

package/dist/renderables/progressBar.d.ts

@@ -44,9 +44,9 @@ export declare class ProgressBar implements Renderable, Measurable {
     set finished(value: boolean | undefined);
     render(options: RenderOptions): Iterable<Segment>;
     /**
-     * The shimmer over this bar's back colour as `Effected` sees it drawn at
-     * `depth`, toward `bar.pulse`. A bar has no words to keep legible, so its
-     * back takes the whole of the light.
+     * The shimmer over this bar's back colour as `Effected` sees it drawn,
+     * toward `bar.pulse`. A bar has no words to keep legible, so its back takes
+     * the whole of the light.
      */
     private pulseEffect;
     /** Rich 9d8f9a3 `__rich_console__`: the fill is counted in half cells, and a total of zero is a bar already full. */

package/dist/renderables/progressBar.js

@@ -71,30 +71,33 @@ export class ProgressBar {
         }
         const depth = options.colorSystem ?? ColorDepth.TRUECOLOR;
         // Rich's pulse resolves its colours on the terminal a depth assumes, as
-        // `get_truecolor` does with no theme; so does this.
-        const theme = resolveTerminal(undefined, depth);
+        // `get_truecolor` does with no theme; so does this with none named.
+        const terminal = resolveTerminal(options.terminal, depth);
         // Rich writes the pulse's back as a colour of its own, black where the
         // back style names none, so the light always has the bar's colour to fall
         // on: one the terminal supplies takes no light.
         const style = getStyle(options, this.style);
-        const ink = style.color?.isDefault === false ? style.color : ColorSpec.fromRgba((style.color ?? PULSE_BACK).getTruecolor(theme, true));
+        const ink = style.color?.isDefault === false ? style.color : ColorSpec.fromRgba((style.color ?? PULSE_BACK).getTruecolor(terminal, true));
         const back = style.add(Style.fromColor(ink));
         // [LAW:no-ambient-temporal-coupling] The moment is the frame's; the bar
         // only says what it looks like then. An empty track, lit by the shimmer.
         const track = { render: (o) => this.track(o, width, 0, back) };
-        yield* render(new Effected(track, this.pulseEffect(options, back, depth, theme), { key: "progress-bar", theme }), options);
+        yield* render(new Effected(track, this.pulseEffect(options, back), { key: "progress-bar" }), options);
     }
     /**
-     * The shimmer over this bar's back colour as `Effected` sees it drawn at
-     * `depth`, toward `bar.pulse`. A bar has no words to keep legible, so its
-     * back takes the whole of the light.
+     * The shimmer over this bar's back colour as `Effected` sees it drawn,
+     * toward `bar.pulse`. A bar has no words to keep legible, so its back takes
+     * the whole of the light.
      */
-    pulseEffect(options, back, depth, theme) {
-        const ink = back.drawnColors(depth).color ?? ColorSpec.default();
-        const glow = getStyle(options, "bar.pulse").drawnColors(depth).color ?? ColorSpec.default();
-        const loop = shimmer(PULSE_CURVE, PULSE_REACH, glow.getTruecolor(theme, true), 0);
-        const whole = new Map([[ink.getTruecolor(theme, true).hex, 1]]);
-        return atShares(loop, () => whole);
+    pulseEffect(options, back) {
+        return (drawn) => {
+            const { depth, terminal } = drawn;
+            const ink = back.drawnColors(depth).color ?? ColorSpec.default();
+            const glow = getStyle(options, "bar.pulse").drawnColors(depth).color ?? ColorSpec.default();
+            const loop = shimmer(PULSE_CURVE, PULSE_REACH, glow.getTruecolor(terminal, true), 0);
+            const whole = new Map([[ink.getTruecolor(terminal, true).hex, 1]]);
+            return atShares(loop, () => whole)(drawn);
+        };
     }
     /** Rich 9d8f9a3 `__rich_console__`: the fill is counted in half cells, and a total of zero is a bar already full. */
     completeHalves(width) {

package/dist/renderables/syntax.js

@@ -7,7 +7,8 @@
  * other renderable here is restyled, and a second styling vocabulary on this
  * one class would be a second answer to "what colour is a keyword".
  */
-import { cellLen, expandTabs, parseTabSize } from "../core/cells.js";
+import { escaped } from "../core/bidi.js";
+import { cellLen, expandTabs, parseTabSize, unicodeEscape } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
 import { drawable, groundedStyle, getStyle, withBoundedWidth, withCellWidth, } from "../core/protocol.js";
@@ -89,7 +90,11 @@ export class Syntax {
         this.wordWrap = options?.wordWrap ?? false;
         const tabSize = parseTabSize(options?.tabSize ?? 4);
         this.tabSize = tabSize;
-        this._lines = expandTabs(code, tabSize).text.split("\n");
+        // Code on show: what the wire would drop is escaped, and an explicit bidi
+        // control with it. That is the Trojan Source attack: the order and the lines on
+        // screen differing from what the compiler reads. A joiner stays, since a Persian
+        // comment or an emoji string needs it. Only a CRLF's CR goes, with its line ending.
+        this._lines = expandTabs(escaped(code.replace(/\r\n/g, "\n"), unicodeEscape), tabSize).text.split("\n");
     }
     /**
      * The lines shown, as a 0-based half-open slice of `_lines`, and the number

package/dist/renderables/table.js

@@ -454,11 +454,12 @@ export class Table {
         // that is all it styles: the reference reads it as `table_style` for the
         // frame and nowhere else, so a cell is untouched by it.
         const borderStyle = getStyle(options, this.style).add(getStyle(options, this.borderStyle));
-        const border = borderStyle.isNull ? undefined : borderStyle;
         // The one division of the width every row below is measured against.
         const outerWidth = this._outerWidth(options);
         const geometry = this._geometry(options, outerWidth);
         const edge = geometry.edge === 1;
+        // Only an edge closes a frame: without one, a table's rules are not a border.
+        const border = box && edge ? box.frame(borderStyle) : borderStyle.isNull ? undefined : borderStyle;
         // Title
         if (this._title) {
             yield* this._renderTitle(options, this._title, geometry.totalWidth, this.titleStyle, this.titleJustify);