@markii/ansi 0.15.0 → 0.17.0-next.0

package/dist/text-grid.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Hand-written width measurement, padding, wrapping, and box-drawing for the
+ * handful of STANDARD COMPONENTS that draw their own fixed-width glyphs
+ * (`card`, `callout`, `divider`, `chart`, `table`, and the plain-markdown
+ * table grid in `render.tsx`). Everything else in this engine wraps prose
+ * through Ink's own layout (`ink-string.ts`'s doc comment and AGENTS.md's
+ * batch-10 brief: "Drop wrap/pad/columns/frame/rule: Ink's layout replaces
+ * them").
+ *
+ * A self-drawing component cannot lean on Ink for this: the string it builds
+ * (a box-drawing frame, a sparkline, a table grid) is a fixed block of
+ * characters that has to be CORRECT the moment it is built, because Ink's
+ * `<Text>` renders it verbatim rather than reflowing pre-drawn glyphs. This
+ * module is therefore kept as a small, PRIVATE (not exported from
+ * `src/index.ts`) implementation detail of those few components, replacing
+ * the old public `measure.ts`/`box.ts` modules the batch-10 brief has this
+ * engine delete. The width-measurement approximation is unchanged from the
+ * old `measure.ts`: Latin/CJK/emoji/combining-mark ranges, not a full
+ * Unicode grapheme-segmentation table (see the doc comment below for the one
+ * documented limitation).
+ */
+import type { FrameEdges, GlyphSet } from './glyphs.js';
+/** Removes every SGR and OSC 8 escape sequence this engine can itself produce, so `measureWidth` counts only what a terminal actually draws. */
+export declare function stripEscapes(text: string): string;
+/**
+ * The display width of `text`, ANSI escapes stripped first. This is a
+ * deliberate approximation of UAX #11 (see `text-grid.ts`'s module comment
+ * and the former `measure.ts`'s identical documented limitation: a
+ * zero-width-joiner emoji sequence measures as the sum of its parts).
+ */
+export declare function measureWidth(text: string): number;
+/** Greedy word wrap to `width` columns, used only by a self-drawing component's own internal text (its title, its caption). Not exposed on `AnsiRenderContext`: ordinary prose wraps through Ink's own layout instead. */
+export declare function wrapText(text: string, width: number): string[];
+/** Pads `text` to `width` columns with spaces, aligned `left`/`center`/`right`. */
+export declare function padText(text: string, width: number, align: 'left' | 'center' | 'right'): string;
+/** `frameBlock`'s options: mirrors the old `box.ts`'s `FrameOptions`. */
+export interface FrameOptions {
+    style: 'solid' | 'dashed';
+    title?: string;
+    width: number;
+    /** The render's glyph set (`./glyphs.ts`), so a frame follows the box style. */
+    glyphs: GlyphSet;
+}
+/**
+ * The edge glyphs for a frame of `style`. Exposed so a caller that draws
+ * its OWN edges (`render.tsx`'s Ink-`Box`-bordered `card`) can match
+ * `frameBlock`'s glyphs exactly without duplicating them.
+ */
+export declare function frameGlyphs(style: 'solid' | 'dashed', glyphs: GlyphSet): FrameEdges;
+/**
+ * Just the top edge of a self-drawing frame, with an optional title woven
+ * in. Factored out of `frameBlock` for `render.tsx`'s `card`: an Ink `Box`
+ * border draws a plain edge perfectly well on its own (left, right, and an
+ * untitled top/bottom), but has no primitive for weaving text into a
+ * border line, so a titled card still builds this one line by hand and
+ * disables Ink's own top border for it.
+ */
+export declare function frameTopLine(options: FrameOptions): string;
+/** Draws a box around `block`, one glyph set for `'solid'`, another for `'dashed'`, with an optional title woven into the top edge. */
+export declare function frameBlock(block: string, options: FrameOptions): string;
+/** The `left`/`right`/`top`/`bottom`/`topLeft`/`topRight`/`bottomLeft`/`bottomRight` glyph set Ink's `Box` `borderStyle` prop takes, matching `frameBlock`'s own character set exactly for `style`. Corners are always the shared set, exactly like `frameBlock`'s (a dashed frame still has solid corners). */
+export declare function inkBorderStyle(style: 'solid' | 'dashed', glyphs: GlyphSet): {
+    topLeft: string;
+    top: string;
+    topRight: string;
+    right: string;
+    bottomRight: string;
+    bottom: string;
+    bottomLeft: string;
+    left: string;
+};
+/** The three-value per-line alignment every self-drawing component's `text=` attribute and every generic `align=` layout preset ultimately reduces to — the ONE spelling both `padText` (a pre-built string) and a caller pre-justifying a line before handing it to Ink share. */
+export declare const TEXT_ALIGNS: readonly ["left", "center", "right"];
+export type TextAlign = (typeof TEXT_ALIGNS)[number];
+export declare function isTextAlign(value: string): value is TextAlign;
+/** `text` cut to at most `width` terminal columns, with no ellipsis (so no glyph outside the engine's own table). Plain text only: an escape sequence would be measured and cut like prose. */
+export declare function cutToWidth(text: string, width: number): string;
+/** A full-width horizontal rule, `char` repeated to `width` columns. */
+export declare function ruleLine(width: number, char: string): string;
+/** Prefixes every line of `block` (split on `\n`) with `prefix`, e.g. a blockquote's bar. */
+export declare function indentBlock(block: string, prefix: string): string;
+/**
+ * Places `blocks` side by side, each padded (left-aligned) to its entry in
+ * `widths`, joined by `gutter` spaces, top-aligned. The string emitter of
+ * `row` (`render.tsx`'s `renderRowString`, reached when a `row` sits inside
+ * a body drawn as a string) places its cells with this. The Ink element
+ * emitter (`renderRowElement`) uses a flex `Box` with the same cell widths
+ * and gutter, both read from `components/row.ts`'s `resolveRowLayout`.
+ */
+export declare function columnsBlock(blocks: readonly string[], widths: readonly number[], gutter: number): string;

package/dist/text-grid.js

@@ -0,0 +1,300 @@
+/**
+ * Hand-written width measurement, padding, wrapping, and box-drawing for the
+ * handful of STANDARD COMPONENTS that draw their own fixed-width glyphs
+ * (`card`, `callout`, `divider`, `chart`, `table`, and the plain-markdown
+ * table grid in `render.tsx`). Everything else in this engine wraps prose
+ * through Ink's own layout (`ink-string.ts`'s doc comment and AGENTS.md's
+ * batch-10 brief: "Drop wrap/pad/columns/frame/rule: Ink's layout replaces
+ * them").
+ *
+ * A self-drawing component cannot lean on Ink for this: the string it builds
+ * (a box-drawing frame, a sparkline, a table grid) is a fixed block of
+ * characters that has to be CORRECT the moment it is built, because Ink's
+ * `<Text>` renders it verbatim rather than reflowing pre-drawn glyphs. This
+ * module is therefore kept as a small, PRIVATE (not exported from
+ * `src/index.ts`) implementation detail of those few components, replacing
+ * the old public `measure.ts`/`box.ts` modules the batch-10 brief has this
+ * engine delete. The width-measurement approximation is unchanged from the
+ * old `measure.ts`: Latin/CJK/emoji/combining-mark ranges, not a full
+ * Unicode grapheme-segmentation table (see the doc comment below for the one
+ * documented limitation).
+ */
+/** SGR: `ESC [ ... m`. */
+const SGR_PATTERN = /\x1b\[[0-9;]*m/g;
+/** OSC 8 hyperlink open/close: `ESC ] 8 ; ; ... BEL`. */
+const OSC8_PATTERN = /\x1b\]8;;[^\x07\x1b]*\x07/g;
+const ESCAPE_PATTERN = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x07\x1b]*\x07/g;
+/** Removes every SGR and OSC 8 escape sequence this engine can itself produce, so `measureWidth` counts only what a terminal actually draws. */
+export function stripEscapes(text) {
+    return text.replace(OSC8_PATTERN, '').replace(SGR_PATTERN, '');
+}
+const COMBINING_RANGES = [
+    [0x0300, 0x036f],
+    [0x1ab0, 0x1aff],
+    [0x1dc0, 0x1dff],
+    [0x20d0, 0x20f0],
+    [0xfe00, 0xfe0f],
+    [0xfe20, 0xfe2f],
+];
+const ZERO_WIDTH_RANGES = [
+    [0x200b, 0x200d],
+    [0x2060, 0x2060],
+    [0xfeff, 0xfeff],
+];
+const WIDE_RANGES = [
+    [0x1100, 0x115f],
+    [0x2e80, 0x303e],
+    [0x3041, 0x33ff],
+    [0x3400, 0x4dbf],
+    [0x4e00, 0x9fff],
+    [0xa000, 0xa4cf],
+    [0xac00, 0xd7a3],
+    [0xf900, 0xfaff],
+    [0xfe30, 0xfe6f],
+    [0xff00, 0xff60],
+    [0xffe0, 0xffe6],
+    [0x20000, 0x2fffd],
+    [0x30000, 0x3fffd],
+];
+const EMOJI_RANGES = [
+    [0x1f300, 0x1f64f],
+    [0x1f680, 0x1f6ff],
+    [0x1f900, 0x1f9ff],
+    [0x1fa70, 0x1faff],
+];
+const EMOJI_PRESENTATION_LOW = 0x2600;
+const EMOJI_PRESENTATION_HIGH = 0x27bf;
+const VARIATION_SELECTOR_16 = 0xfe0f;
+function inRanges(code, ranges) {
+    for (const [low, high] of ranges) {
+        if (code >= low && code <= high)
+            return true;
+    }
+    return false;
+}
+function codePointWidth(code, next) {
+    if (inRanges(code, COMBINING_RANGES))
+        return 0;
+    if (inRanges(code, ZERO_WIDTH_RANGES))
+        return 0;
+    if (inRanges(code, WIDE_RANGES))
+        return 2;
+    if (inRanges(code, EMOJI_RANGES))
+        return 2;
+    if (code >= EMOJI_PRESENTATION_LOW &&
+        code <= EMOJI_PRESENTATION_HIGH &&
+        next === VARIATION_SELECTOR_16) {
+        return 2;
+    }
+    return 1;
+}
+/**
+ * The display width of `text`, ANSI escapes stripped first. This is a
+ * deliberate approximation of UAX #11 (see `text-grid.ts`'s module comment
+ * and the former `measure.ts`'s identical documented limitation: a
+ * zero-width-joiner emoji sequence measures as the sum of its parts).
+ */
+export function measureWidth(text) {
+    const stripped = stripEscapes(text);
+    const codePoints = Array.from(stripped, (char) => char.codePointAt(0) ?? 0);
+    let width = 0;
+    for (let index = 0; index < codePoints.length; index += 1) {
+        width += codePointWidth(codePoints[index], codePoints[index + 1]);
+    }
+    return width;
+}
+function pushChars(atoms, plain) {
+    for (const char of plain)
+        atoms.push({ text: char, width: measureWidth(char) });
+}
+function tokenize(text) {
+    const atoms = [];
+    let lastIndex = 0;
+    let match;
+    ESCAPE_PATTERN.lastIndex = 0;
+    while ((match = ESCAPE_PATTERN.exec(text)) !== null) {
+        if (match.index > lastIndex)
+            pushChars(atoms, text.slice(lastIndex, match.index));
+        atoms.push({ text: match[0], width: 0 });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length)
+        pushChars(atoms, text.slice(lastIndex));
+    return atoms;
+}
+function breakLongWord(word, width) {
+    const atoms = tokenize(word);
+    const chunks = [];
+    let current = '';
+    let currentWidth = 0;
+    for (const atom of atoms) {
+        if (currentWidth + atom.width > width && current !== '') {
+            chunks.push(current);
+            current = '';
+            currentWidth = 0;
+        }
+        current += atom.text;
+        currentWidth += atom.width;
+    }
+    if (current !== '')
+        chunks.push(current);
+    return chunks.length > 0 ? chunks : [''];
+}
+/** Greedy word wrap to `width` columns, used only by a self-drawing component's own internal text (its title, its caption). Not exposed on `AnsiRenderContext`: ordinary prose wraps through Ink's own layout instead. */
+export function wrapText(text, width) {
+    const w = Math.max(1, width);
+    const lines = [];
+    for (const hardLine of text.split('\n')) {
+        const words = hardLine.split(/ +/).filter((word) => word !== '');
+        if (words.length === 0) {
+            lines.push('');
+            continue;
+        }
+        let current = '';
+        let currentWidth = 0;
+        for (const word of words) {
+            const wordWidth = measureWidth(word);
+            if (wordWidth > w) {
+                if (current !== '') {
+                    lines.push(current);
+                    current = '';
+                    currentWidth = 0;
+                }
+                lines.push(...breakLongWord(word, w));
+                continue;
+            }
+            if (current === '') {
+                current = word;
+                currentWidth = wordWidth;
+                continue;
+            }
+            if (currentWidth + 1 + wordWidth <= w) {
+                current += ` ${word}`;
+                currentWidth += 1 + wordWidth;
+            }
+            else {
+                lines.push(current);
+                current = word;
+                currentWidth = wordWidth;
+            }
+        }
+        if (current !== '')
+            lines.push(current);
+    }
+    return lines;
+}
+/** Pads `text` to `width` columns with spaces, aligned `left`/`center`/`right`. */
+export function padText(text, width, align) {
+    const total = Math.max(0, width - measureWidth(text));
+    if (total === 0)
+        return text;
+    if (align === 'right')
+        return ' '.repeat(total) + text;
+    if (align === 'center') {
+        const left = Math.floor(total / 2);
+        const right = total - left;
+        return ' '.repeat(left) + text + ' '.repeat(right);
+    }
+    return text + ' '.repeat(total);
+}
+/**
+ * The edge glyphs for a frame of `style`. Exposed so a caller that draws
+ * its OWN edges (`render.tsx`'s Ink-`Box`-bordered `card`) can match
+ * `frameBlock`'s glyphs exactly without duplicating them.
+ */
+export function frameGlyphs(style, glyphs) {
+    return style === 'dashed' ? glyphs.dashed : glyphs.solid;
+}
+/**
+ * Just the top edge of a self-drawing frame, with an optional title woven
+ * in. Factored out of `frameBlock` for `render.tsx`'s `card`: an Ink `Box`
+ * border draws a plain edge perfectly well on its own (left, right, and an
+ * untitled top/bottom), but has no primitive for weaving text into a
+ * border line, so a titled card still builds this one line by hand and
+ * disables Ink's own top border for it.
+ */
+export function frameTopLine(options) {
+    const { style: kind, title, width, glyphs } = options;
+    const { horizontal } = frameGlyphs(kind, glyphs);
+    const innerWidth = Math.max(1, width - 2);
+    if (title) {
+        const label = ` ${title} `;
+        const remaining = Math.max(0, innerWidth - measureWidth(label) - 1);
+        return `${glyphs.topLeft}${horizontal}${label}${horizontal.repeat(remaining)}${glyphs.topRight}`;
+    }
+    return `${glyphs.topLeft}${horizontal.repeat(innerWidth)}${glyphs.topRight}`;
+}
+/** Draws a box around `block`, one glyph set for `'solid'`, another for `'dashed'`, with an optional title woven into the top edge. */
+export function frameBlock(block, options) {
+    const { style: kind, width, glyphs } = options;
+    const { horizontal, vertical } = frameGlyphs(kind, glyphs);
+    const innerWidth = Math.max(1, width - 2);
+    const top = frameTopLine(options);
+    const bottom = `${glyphs.bottomLeft}${horizontal.repeat(innerWidth)}${glyphs.bottomRight}`;
+    const lines = block
+        .split('\n')
+        .map((line) => `${vertical}${padText(line, innerWidth, 'left')}${vertical}`);
+    return [top, ...lines, bottom].join('\n');
+}
+/** The `left`/`right`/`top`/`bottom`/`topLeft`/`topRight`/`bottomLeft`/`bottomRight` glyph set Ink's `Box` `borderStyle` prop takes, matching `frameBlock`'s own character set exactly for `style`. Corners are always the shared set, exactly like `frameBlock`'s (a dashed frame still has solid corners). */
+export function inkBorderStyle(style, glyphs) {
+    const { horizontal, vertical } = frameGlyphs(style, glyphs);
+    return {
+        topLeft: glyphs.topLeft,
+        top: horizontal,
+        topRight: glyphs.topRight,
+        right: vertical,
+        bottomRight: glyphs.bottomRight,
+        bottom: horizontal,
+        bottomLeft: glyphs.bottomLeft,
+        left: vertical,
+    };
+}
+/** The three-value per-line alignment every self-drawing component's `text=` attribute and every generic `align=` layout preset ultimately reduces to — the ONE spelling both `padText` (a pre-built string) and a caller pre-justifying a line before handing it to Ink share. */
+export const TEXT_ALIGNS = ['left', 'center', 'right'];
+export function isTextAlign(value) {
+    return TEXT_ALIGNS.includes(value);
+}
+/** `text` cut to at most `width` terminal columns, with no ellipsis (so no glyph outside the engine's own table). Plain text only: an escape sequence would be measured and cut like prose. */
+export function cutToWidth(text, width) {
+    let out = '';
+    let used = 0;
+    for (const char of text) {
+        const next = measureWidth(char);
+        if (used + next > width)
+            break;
+        out += char;
+        used += next;
+    }
+    return out;
+}
+/** A full-width horizontal rule, `char` repeated to `width` columns. */
+export function ruleLine(width, char) {
+    return char.repeat(Math.max(0, width));
+}
+/** Prefixes every line of `block` (split on `\n`) with `prefix`, e.g. a blockquote's bar. */
+export function indentBlock(block, prefix) {
+    return block
+        .split('\n')
+        .map((line) => `${prefix}${line}`)
+        .join('\n');
+}
+/**
+ * Places `blocks` side by side, each padded (left-aligned) to its entry in
+ * `widths`, joined by `gutter` spaces, top-aligned. The string emitter of
+ * `row` (`render.tsx`'s `renderRowString`, reached when a `row` sits inside
+ * a body drawn as a string) places its cells with this. The Ink element
+ * emitter (`renderRowElement`) uses a flex `Box` with the same cell widths
+ * and gutter, both read from `components/row.ts`'s `resolveRowLayout`.
+ */
+export function columnsBlock(blocks, widths, gutter) {
+    const gap = ' '.repeat(Math.max(0, gutter));
+    const lineArrays = blocks.map((block) => block.split('\n'));
+    const rowCount = Math.max(0, ...lineArrays.map((lines) => lines.length));
+    const rows = [];
+    for (let row = 0; row < rowCount; row += 1) {
+        const cells = lineArrays.map((lines, index) => padText(lines[row] ?? '', widths[index] ?? 0, 'left'));
+        rows.push(cells.join(gap).replace(/[ ]+$/, ''));
+    }
+    return rows.join('\n');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markii/ansi",
-  "version": "0.15.0",
-  "description": "A framework-free terminal renderer for Markii (.mk.md): a registry-driven hast-to-ANSI-text engine. Zero React; for a terminal, a pipe, or any host that wants a plain string with optional color.",
+  "version": "0.17.0-next.0",
+  "description": "The terminal renderer for Markii (.mk.md): a registry-driven hast-to-terminal engine built on Ink. Renders a note once as a string with optional color, for a pipe or a log, or as a live Ink tree a host can mount.",
   "keywords": [
     "markdown",
     "markii",
@@ -51,11 +51,15 @@
     "regenerate:fixtures": "npm run build:dist && node scripts/regenerate-ansi-fixtures.ts"
   },
   "dependencies": {
-    "@markii/core": "^0.15.0",
-    "@markii/stdlib": "^0.15.0"
+    "@markii/core": "^0.17.0-next.0",
+    "@markii/pack": "^0.17.0-next.0",
+    "@markii/stdlib": "^0.17.0-next.0",
+    "ink": "^7.1.1",
+    "react": "^19.2.0"
   },
   "devDependencies": {
     "@types/hast": "^3.0.4",
-    "@markii/runtime": "^0.15.0"
+    "@markii/runtime": "^0.17.0-next.0",
+    "@types/react": "^19.2.0"
   }
 }

package/dist/box.d.ts

@@ -1,47 +0,0 @@
-/**
- * Greedy word wrap to `width` columns. An existing `\n` is a hard break
- * (each hard-broken segment is wrapped independently); a word wider than
- * `width` on its own is broken at the width boundary via `breakLongWord`
- * rather than overflowing the line.
- */
-export declare function wrap(text: string, width: number): string[];
-/** Pads `text` to `width` columns with spaces, aligned `left`/`center`/`right`. A `text` already at or over `width` is returned unchanged. */
-export declare function pad(text: string, width: number, align: 'left' | 'center' | 'right'): string;
-/**
- * Re-wraps a block of text that was already wrapped to a WIDER budget than
- * `width` (the shape a component's pre-rendered `childrenText` always
- * arrives in: `render.ts` wraps a directive's body to the full directive
- * width before the component ever runs, since a container component that
- * draws its own frame or indent — `card`, `callout`, `details`, `figure` —
- * only learns it needs a NARROWER inner budget once it starts drawing).
- * Every existing `\n` is a hard break, each hard-broken line re-wrapped
- * independently if it still overflows `width`; a line already inside the
- * budget passes through unchanged. Mirrors the same pattern `render.ts`'s
- * `unknownDirective` fallback already uses for its dashed frame.
- */
-export declare function rewrapBlock(text: string, width: number): string;
-/** Prefixes every line of `block` (split on `\n`) with `prefix`, e.g. a blockquote's `│ `. */
-export declare function indentBlock(block: string, prefix: string): string;
-/**
- * Places `blocks` side by side, each padded (left-aligned) to its entry in
- * `widths`, joined by `gutter` spaces, top-aligned: a block with fewer
- * lines than its neighbors gets its missing rows filled with blank,
- * full-width padding rather than leaving a ragged gap.
- */
-export declare function columns(blocks: readonly string[], widths: readonly number[], gutter: number): string;
-/** `frame`'s options: which glyph set to draw with, an optional title woven into the top edge, and the frame's total outer width (borders included). */
-export interface FrameOptions {
-    style: 'solid' | 'dashed';
-    title?: string;
-    width: number;
-}
-/**
- * Draws a box around `block`: `┌ ─ ┐ │ └ ┘` for `'solid'`, `┌ ╌ ┐ ┆ └ ┘` for
- * `'dashed'` (the corners are shared; only the edge glyphs change). A
- * `title` is woven into the top edge as `┌─ title ────┐`. Every content
- * line is padded to the frame's inner width, so every drawn line is exactly
- * `options.width` columns wide.
- */
-export declare function frame(block: string, options: FrameOptions): string;
-/** A full-width horizontal rule, `char` (default `─`) repeated to `width` columns. */
-export declare function rule(width: number, char?: string): string;

package/dist/box.js

@@ -1,209 +0,0 @@
-import { measure } from './measure.js';
-/**
- * Hand-written, width-aware layout helpers: wrapping, padding, side-by-side
- * columns, and box drawing. Every measurement goes through `./measure.ts`,
- * so these helpers wrap and pad correctly around colored text, wide CJK
- * characters, and emoji, not just plain ASCII. None of these read the
- * theme; they take and return plain strings, leaving color entirely to
- * `./style.ts` and the caller.
- *
- * `wrap`'s word-splitting collapses runs of spaces to one, the ordinary
- * behavior of a text wrapper: exact inter-word spacing is not something a
- * terminal reflow is expected to preserve.
- */
-const ESCAPE_PATTERN = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x07\x1b]*\x07/g;
-/**
- * Splits `text` into atoms an escape sequence never gets split across: each
- * escape sequence is its own zero-width atom, and every other code point is
- * its own atom carrying `measure`'s width for that single code point. A
- * combining mark or variation selector that only reads as zero-width in
- * context with its BASE character (see `./measure.ts`'s module comment)
- * still measures correctly here, because it is itself in the zero-width/
- * combining ranges regardless of what precedes it; the one case this
- * under- or over-counts by a column is the dingbat-plus-variation-selector
- * pair (`☀️`), which needs to see both code points at once to know it
- * should measure 2 — an accepted instance of `./measure.ts`'s documented
- * approximation.
- */
-function tokenize(text) {
-    const atoms = [];
-    let lastIndex = 0;
-    let match;
-    ESCAPE_PATTERN.lastIndex = 0;
-    while ((match = ESCAPE_PATTERN.exec(text)) !== null) {
-        if (match.index > lastIndex) {
-            pushChars(atoms, text.slice(lastIndex, match.index));
-        }
-        atoms.push({ text: match[0], width: 0 });
-        lastIndex = match.index + match[0].length;
-    }
-    if (lastIndex < text.length)
-        pushChars(atoms, text.slice(lastIndex));
-    return atoms;
-}
-function pushChars(atoms, plain) {
-    for (const char of plain) {
-        atoms.push({ text: char, width: measure(char) });
-    }
-}
-/** Breaks one over-long word into chunks of at most `width` columns, never splitting an escape sequence. */
-function breakLongWord(word, width) {
-    const atoms = tokenize(word);
-    const chunks = [];
-    let current = '';
-    let currentWidth = 0;
-    for (const atom of atoms) {
-        if (currentWidth + atom.width > width && current !== '') {
-            chunks.push(current);
-            current = '';
-            currentWidth = 0;
-        }
-        current += atom.text;
-        currentWidth += atom.width;
-    }
-    if (current !== '')
-        chunks.push(current);
-    return chunks.length > 0 ? chunks : [''];
-}
-/**
- * Greedy word wrap to `width` columns. An existing `\n` is a hard break
- * (each hard-broken segment is wrapped independently); a word wider than
- * `width` on its own is broken at the width boundary via `breakLongWord`
- * rather than overflowing the line.
- */
-export function wrap(text, width) {
-    const w = Math.max(1, width);
-    const lines = [];
-    for (const hardLine of text.split('\n')) {
-        const words = hardLine.split(/ +/).filter((word) => word !== '');
-        if (words.length === 0) {
-            lines.push('');
-            continue;
-        }
-        let current = '';
-        let currentWidth = 0;
-        for (const word of words) {
-            const wordWidth = measure(word);
-            if (wordWidth > w) {
-                if (current !== '') {
-                    lines.push(current);
-                    current = '';
-                    currentWidth = 0;
-                }
-                lines.push(...breakLongWord(word, w));
-                continue;
-            }
-            if (current === '') {
-                current = word;
-                currentWidth = wordWidth;
-                continue;
-            }
-            if (currentWidth + 1 + wordWidth <= w) {
-                current += ` ${word}`;
-                currentWidth += 1 + wordWidth;
-            }
-            else {
-                lines.push(current);
-                current = word;
-                currentWidth = wordWidth;
-            }
-        }
-        if (current !== '')
-            lines.push(current);
-    }
-    return lines;
-}
-/** Pads `text` to `width` columns with spaces, aligned `left`/`center`/`right`. A `text` already at or over `width` is returned unchanged. */
-export function pad(text, width, align) {
-    const total = Math.max(0, width - measure(text));
-    if (total === 0)
-        return text;
-    if (align === 'right')
-        return ' '.repeat(total) + text;
-    if (align === 'center') {
-        const left = Math.floor(total / 2);
-        const right = total - left;
-        return ' '.repeat(left) + text + ' '.repeat(right);
-    }
-    return text + ' '.repeat(total);
-}
-/**
- * Re-wraps a block of text that was already wrapped to a WIDER budget than
- * `width` (the shape a component's pre-rendered `childrenText` always
- * arrives in: `render.ts` wraps a directive's body to the full directive
- * width before the component ever runs, since a container component that
- * draws its own frame or indent — `card`, `callout`, `details`, `figure` —
- * only learns it needs a NARROWER inner budget once it starts drawing).
- * Every existing `\n` is a hard break, each hard-broken line re-wrapped
- * independently if it still overflows `width`; a line already inside the
- * budget passes through unchanged. Mirrors the same pattern `render.ts`'s
- * `unknownDirective` fallback already uses for its dashed frame.
- */
-export function rewrapBlock(text, width) {
-    if (!text)
-        return text;
-    return text
-        .split('\n')
-        .flatMap((line) => wrap(line, width))
-        .join('\n');
-}
-/** Prefixes every line of `block` (split on `\n`) with `prefix`, e.g. a blockquote's `│ `. */
-export function indentBlock(block, prefix) {
-    return block
-        .split('\n')
-        .map((line) => `${prefix}${line}`)
-        .join('\n');
-}
-/**
- * Places `blocks` side by side, each padded (left-aligned) to its entry in
- * `widths`, joined by `gutter` spaces, top-aligned: a block with fewer
- * lines than its neighbors gets its missing rows filled with blank,
- * full-width padding rather than leaving a ragged gap.
- */
-export function columns(blocks, widths, gutter) {
-    const gap = ' '.repeat(Math.max(0, gutter));
-    const lineArrays = blocks.map((block) => block.split('\n'));
-    const rowCount = Math.max(0, ...lineArrays.map((lines) => lines.length));
-    const rows = [];
-    for (let row = 0; row < rowCount; row += 1) {
-        const cells = lineArrays.map((lines, index) => pad(lines[row] ?? '', widths[index] ?? 0, 'left'));
-        // The padding on the LAST column is dropped again. It buys nothing: no
-        // column follows it to be aligned against, and left in place it would
-        // end every row with a run of spaces, which shows up as trailing
-        // whitespace in a committed fixture and in anything that pipes this
-        // output to a file. Padding between columns is what does the work.
-        rows.push(cells.join(gap).replace(/[ ]+$/, ''));
-    }
-    return rows.join('\n');
-}
-/**
- * Draws a box around `block`: `┌ ─ ┐ │ └ ┘` for `'solid'`, `┌ ╌ ┐ ┆ └ ┘` for
- * `'dashed'` (the corners are shared; only the edge glyphs change). A
- * `title` is woven into the top edge as `┌─ title ────┐`. Every content
- * line is padded to the frame's inner width, so every drawn line is exactly
- * `options.width` columns wide.
- */
-export function frame(block, options) {
-    const { style: kind, title, width } = options;
-    const horizontal = kind === 'dashed' ? '╌' : '─';
-    const vertical = kind === 'dashed' ? '┆' : '│';
-    const innerWidth = Math.max(1, width - 2);
-    let top;
-    if (title) {
-        const label = ` ${title} `;
-        const remaining = Math.max(0, innerWidth - measure(label) - 1);
-        top = `┌${horizontal}${label}${horizontal.repeat(remaining)}┐`;
-    }
-    else {
-        top = `┌${horizontal.repeat(innerWidth)}┐`;
-    }
-    const bottom = `└${horizontal.repeat(innerWidth)}┘`;
-    const lines = block
-        .split('\n')
-        .map((line) => `${vertical}${pad(line, innerWidth, 'left')}${vertical}`);
-    return [top, ...lines, bottom].join('\n');
-}
-/** A full-width horizontal rule, `char` (default `─`) repeated to `width` columns. */
-export function rule(width, char = '─') {
-    return char.repeat(Math.max(0, width));
-}