@promptctl/rich-js 0.17.0 → 0.18.0

package/dist/core/markup.js

@@ -1,619 +0,0 @@
-/**
- * Markup — BBCode-inspired markup parser for inline styling.
- * Parses `[bold red]text[/bold red]` into RichText with styled spans.
- *
- * Plugin tags ([LAW:locality-or-seam]): a `MarkupRegistry` lets consumers
- * register tag handlers without forking the parser. When the parser sees
- * `[name attrs...]inner[/name]` and `name` is registered, it parses attrs,
- * recursively renders the inner markup as a child Renderable, and calls the
- * handler — splicing the handler's returned Renderable into the output. The
- * built-in style dialect and the plugin dialect are routed by the registry,
- * which is the single trust boundary between them.
- *
- * Plugin pairs must nest. The built-in dialect admits non-strict nesting
- * (`[bold]a[italic]b[/bold]c[/italic]`) because a style is an annotation and
- * annotations may overlap freely; a plugin tag is a replacement whose handler
- * takes one contiguous `inner`, so an overlapping pair has no slice to hand it
- * and is rejected with a `MarkupSyntaxError`.
- */
-import { cellLen } from "./cells.js";
-import { Style, StyleSyntaxError } from "./style.js";
-import { RichText, Span } from "./text.js";
-import { emojiReplace } from "./emoji.js";
-// --- Tag ---
-export class Tag {
-    name;
-    parameters;
-    constructor(name, parameters) {
-        this.name = name;
-        this.parameters = parameters;
-    }
-    toString() {
-        return this.parameters !== undefined
-            ? `${this.name} ${this.parameters}`
-            : this.name;
-    }
-    get markup() {
-        return this.parameters !== undefined
-            ? `[${this.name}=${this.parameters}]`
-            : `[${this.name}]`;
-    }
-}
-// --- MarkupError ---
-export class MarkupError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "MarkupError";
-    }
-}
-// --- MarkupSyntaxError ---
-/**
- * A markup string that cannot be parsed, with where it went wrong.
- *
- * [LAW:types-are-the-program] A subclass rather than optional fields on
- * `MarkupError`, because the parent is also what `MarkupRegistry.register`
- * throws, and a registration has no source text to point into. Every error this
- * class describes has a location, so none of its fields is optional and no
- * caller has to ask whether one is present — `instanceof` is the only question.
- *
- * [LAW:one-source-of-truth] The constructor takes the facts the parser holds —
- * the string, the offset of the offending tag, what was open — and derives
- * `line`, `column` and the message from them, so the numbers a caller reads
- * and the caret the message draws cannot disagree.
- */
-export class MarkupSyntaxError extends MarkupError {
-    /** The problem alone, with no location, for callers building their own message. */
-    reason;
-    /** The whole markup string that failed, as the caller passed it. */
-    markup;
-    /** Index into `markup` of the tag the parser rejected. */
-    offset;
-    /** 1-based line of `offset`; lines are separated by `\n`. */
-    line;
-    /** 1-based column of `offset` within its line, in UTF-16 code units. */
-    column;
-    /**
-     * The opening tags still open at `offset`, outermost first, as written. For
-     * overlapping plugin tags, only plugin tags are named.
-     */
-    openTags;
-    constructor(reason, markup, offset, openTags) {
-        const lineStart = markup.lastIndexOf("\n", offset - 1) + 1;
-        const lineEnd = markup.indexOf("\n", offset);
-        const text = markup.slice(lineStart, lineEnd === -1 ? markup.length : lineEnd);
-        const line = countNewlines(markup.slice(0, lineStart)) + 1;
-        const column = offset - lineStart + 1;
-        const open = openTags.length > 0 ? openTags.join(" ") : "none";
-        super(`${printable(reason)} (line ${line}, column ${column})\n` +
-            `${excerpt(text, offset - lineStart)}\n` +
-            `Open tags: ${printable(open)}`);
-        this.name = "MarkupSyntaxError";
-        this.reason = reason;
-        this.markup = markup;
-        this.offset = offset;
-        this.line = line;
-        this.column = column;
-        this.openTags = openTags;
-    }
-}
-function countNewlines(text) {
-    return text.split("\n").length - 1;
-}
-// Code points shown either side of the error before the excerpt is cut and
-// marked with an ellipsis. Enough to recognise the surrounding tags on a line
-// that is long, templated, or machine-assembled, without printing all of it.
-const EXCERPT_CONTEXT = 30;
-/**
- * `text` with each C0 control and DEL shown as one space.
- *
- * [LAW:single-enforcer] Every part of the message that quotes the caller's
- * markup passes through here: the reason and the open tags quote tag text, and
- * the tag grammar admits control characters, so an `ESC ]` inside a tag would
- * otherwise open an OSC sequence in the terminal printing the error. In the
- * excerpt it also keeps the caret aligned, since a control occupies no cell.
- * The fields keep the text as written; only the message is made printable.
- */
-function printable(text) {
-    return text.replace(/[\x00-\x1f\x7f]/g, " ");
-}
-/**
- * Two lines: the source line around `index`, and a caret under it.
- *
- * The window is cut in code points, so a surrogate pair is never split, and the
- * caret is placed by cell width, so a wide character before the error still
- * leaves it under the right cell.
- */
-function excerpt(text, index) {
-    const chars = Array.from(printable(text));
-    const at = Array.from(text.slice(0, index)).length;
-    const from = Math.max(0, at - EXCERPT_CONTEXT);
-    const to = Math.min(chars.length, at + EXCERPT_CONTEXT);
-    const head = from > 0 ? "…" : "";
-    const tail = to < chars.length ? "…" : "";
-    const before = head + chars.slice(from, at).join("");
-    const shown = before + chars.slice(at, to).join("") + tail;
-    return `  ${shown}\n  ${" ".repeat(cellLen(before))}^`;
-}
-// --- escape ---
-/**
- * Escapes markup characters so they render as literal text.
- */
-export function escape(text) {
-    return text.replace(/\[/g, "\\[");
-}
-// --- render ---
-// Fast path: if no `[` in text, skip parsing entirely
-const HAS_TAG_RE = /\[/;
-// [LAW:one-source-of-truth] The authority for this grammar is `RE_TAGS` in
-// `rich/markup.py`, and this is deliberately its expression rather than a
-// re-derivation, so the two can be read side by side; `[^[]*?` is lazy against
-// the following `]`, which is what stops the body at the first one.
-//
-// The enumeration it replaced — `[a-zA-Z#][a-zA-Z0-9_.# -]*` — was a second
-// drawing of the same territory and had drifted both ways at once: it invented
-// uppercase, so `[INFO]` was taken as an opening tag and its text vanished from
-// every `Console.print` with no error, and it omitted `@` and the punctuation
-// the reference admits, so `[a+b]` stayed literal (rich-markup-sec).
-// `markup-grammar.golden.txt` pins both directions.
-// The leading alternative handles an escaped bracket: \[
-const TAG_RE = /(?:\\\[)|(\[[a-z#/@][^[]*?\])/g;
-function parseTags(markup) {
-    const tags = [];
-    const re = new RegExp(TAG_RE.source, TAG_RE.flags);
-    let match;
-    while ((match = re.exec(markup)) !== null) {
-        // Escaped bracket
-        if (match[0] === "\\[")
-            continue;
-        const captured = match[1];
-        if (!captured)
-            continue;
-        const inner = captured.slice(1, -1); // Remove [ ]
-        const isClose = inner.startsWith("/");
-        const stylePart = isClose ? inner.slice(1) : inner;
-        // Check for parameters (name=value)
-        const eqIdx = stylePart.indexOf("=");
-        const styleName = eqIdx >= 0 ? stylePart.slice(0, eqIdx).trim() : stylePart.trim();
-        const parameters = eqIdx >= 0 ? stylePart.slice(eqIdx + 1) : undefined;
-        // [LAW:types-are-the-program] What separates `[/]` from `[/red]` is whether
-        // a name survives the slash, which is how the reference asks it too
-        // (`style_name = tag.name[1:].strip()`). Testing the raw tag text against
-        // the literal `"/"` answered a narrower question, and the widened grammar
-        // is what exposed the gap: `[/ ]` reaches here now, and under the old test
-        // it was an explicit close of the empty style rather than an implicit one.
-        const isImplicitClose = isClose && styleName === "";
-        const isClosing = isClose && !isImplicitClose;
-        tags.push({
-            fullMatch: captured,
-            isClosing,
-            isImplicitClose,
-            styleName,
-            parameters,
-            start: match.index,
-            end: match.index + match[0].length,
-        });
-    }
-    return tags;
-}
-function wholeString(markup) {
-    return { source: markup, base: 0, enclosing: [] };
-}
-/**
- * Parses the built-in style dialect — `[bold red]text[/bold red]` — into a
- * `RichText` with styled spans. Module-private on purpose: `renderMarkup` is
- * this module's one crossing, and it delegates straight here the moment a
- * string carries no paired plugin tag.
- *
- * [LAW:single-enforcer] Exporting this is what let a caller bind to the inner
- * layer, and two of them did — `console.ts` and `prompt.ts` imported it as
- * `render as renderMarkup`, so the import line read identically to the
- * plugin-aware sites and the difference was invisible at every point of use. A
- * tag registered on `globalMarkupRegistry` resolved in a table cell and was
- * silently eaten by `console.print`, the path almost every consumer takes
- * (rich-markup-pcp). Unexported, that drift is a compile error rather than a
- * rule someone has to keep remembering.
- *
- * [LAW:dataflow-not-control-flow] Rendering *without* plugins stays reachable
- * as a value rather than a second name: `renderMarkup(s, { registry: new
- * MarkupRegistry() })`. Two exported functions put that variability in the
- * function names; an empty registry puts it in the data, where the one
- * boundary admits both.
- */
-function render(markup, origin, baseStyle, options) {
-    // Fast path: no brackets at all
-    if (!HAS_TAG_RE.test(markup)) {
-        let text = markup;
-        if (options?.emoji !== false) {
-            text = emojiReplace(text);
-        }
-        const result = new RichText(text);
-        if (baseStyle)
-            result.stylize(baseStyle);
-        return result;
-    }
-    const tags = parseTags(markup);
-    const doEmoji = options?.emoji !== false;
-    // Build plain text and track spans
-    let plainText = "";
-    const spans = [];
-    const openStack = [];
-    const unparsable = (reason, tag) => new MarkupSyntaxError(reason, origin.source, origin.base + tag.start, [
-        ...origin.enclosing,
-        ...openStack.map((opened) => opened.tag),
-    ]);
-    let lastEnd = 0;
-    for (const tag of tags) {
-        // Add text before this tag
-        const textBefore = markup.slice(lastEnd, tag.start);
-        const processed = unescapeBrackets(doEmoji ? emojiReplace(textBefore) : textBefore);
-        plainText += processed;
-        if (tag.isImplicitClose) {
-            // [/] — close the most recent open tag
-            if (openStack.length === 0) {
-                // [/] never closes a plugin tag, so an enclosing plugin tag can be open
-                // here while no style tag is.
-                throw unparsable(`Closing tag ${tag.fullMatch} has no open style tag to close`, tag);
-            }
-            const opened = openStack.pop();
-            spans.push(new Span(opened.textStart, plainText.length, openTagStyle(opened)));
-        }
-        else if (tag.isClosing) {
-            // [/style] — find and close matching open tag
-            const idx = findLastOpen(openStack, tag.styleName);
-            if (idx === -1) {
-                throw unparsable(`Closing tag ${tag.fullMatch} doesn't match any open tag`, tag);
-            }
-            const opened = openStack[idx];
-            spans.push(new Span(opened.textStart, plainText.length, openTagStyle(opened)));
-            openStack.splice(idx, 1);
-        }
-        else {
-            // Opening tag
-            openStack.push({
-                tag: tag.fullMatch,
-                styleName: tag.styleName,
-                parameters: tag.parameters,
-                textStart: plainText.length,
-            });
-        }
-        lastEnd = tag.end;
-    }
-    // Add remaining text after last tag
-    const trailing = markup.slice(lastEnd);
-    const processedTrailing = unescapeBrackets(doEmoji ? emojiReplace(trailing) : trailing);
-    plainText += processedTrailing;
-    // Auto-close what is still open, innermost first. The reference pops its
-    // stack here (`while style_stack: start, tag = style_stack.pop()`), and
-    // popping is what keeps every span in this list in the order its tag closed
-    // — the one order the sort below is defined against. Walking the stack
-    // forwards instead put the outermost unclosed tag in first, and that lone
-    // disagreement was invisible while nothing sorted: it cancelled the missing
-    // sort, so `[red][blue]x` was the one nesting this port already got right.
-    while (openStack.length > 0) {
-        const opened = openStack.pop();
-        spans.push(new Span(opened.textStart, plainText.length, openTagStyle(opened)));
-    }
-    // [LAW:one-source-of-truth] The paint order is the reference's, expressed
-    // rather than re-derived: `sorted(spans[::-1], key=attrgetter("start"))` in
-    // `rich/markup.py`. `RichText` applies spans in list order and each one adds
-    // over the last, so this list's order *is* which style wins where two
-    // overlap; sorting by start lays the outer span down first and lets the
-    // inner one repaint the run it sits in.
-    //
-    // The reversal is the whole of the tie-break, not decoration.
-    // `[red][blue]x[/blue][/red]` yields two spans that both start at 0, and a
-    // stable sort leaves those in the order they arrived — closing order,
-    // innermost first — which is the outer colour winning. Reversed first, the
-    // outer arrives first and the inner repaints it (rich-markup-krk).
-    spans.reverse();
-    spans.sort((a, b) => a.start - b.start);
-    const result = new RichText(plainText);
-    if (baseStyle)
-        result.stylize(baseStyle);
-    // Apply link parameters as link styles
-    for (const span of spans) {
-        const style = typeof span.style === "string" ? span.style : span.style.toString();
-        // Check if this is a link tag (name=url pattern was parsed)
-        const linkMatch = /^link\s+(.+)$/.exec(style);
-        if (linkMatch) {
-            result.stylize(new Style({ link: linkMatch[1] }), span.start, span.end);
-        }
-        else {
-            result.stylize(style, span.start, span.end);
-        }
-    }
-    return result;
-}
-/**
- * The style string an open tag closes into — `name`, or `name parameters` when
- * the tag carried an `=`.
- *
- * [LAW:one-source-of-truth] One answer for the four sites that ask it: the three
- * ways a tag can close (`[/name]`, `[/]`, and end of input) and the search that
- * matches `[/red on blue]` back to `[red on blue]`. It was written out at each,
- * which is how the three closing paths could — and did — drift apart on
- * something none of the four copies was about.
- */
-function openTagStyle(opened) {
-    return opened.parameters !== undefined
-        ? `${opened.styleName} ${opened.parameters}`
-        : opened.styleName;
-}
-function findLastOpen(stack, name) {
-    // Handle "on" in style names for closing: [/red on blue] should match [red on blue]
-    const normalized = name.trim();
-    for (let i = stack.length - 1; i >= 0; i--) {
-        const entry = stack[i];
-        if (openTagStyle(entry) === normalized || entry.styleName === normalized)
-            return i;
-    }
-    return -1;
-}
-function unescapeBrackets(text) {
-    return text.replace(/\\\[/g, "[");
-}
-// [LAW:one-source-of-truth] The one answer to "what is a legal plugin tag
-// name?". Both sites that need it are derived from this fragment rather than
-// each carrying its own scanner: `register` anchors it to reject a name markup
-// could never address, and the match site anchors it at the head with a
-// boundary lookahead. When those two disagreed, registering `table` silently
-// destroyed every `table.*` built-in style and a name containing a dot could
-// never fire.
-//
-// It opens on `a-z` because a plugin name has to be a name `TAG_RE` can reach,
-// and that is strictly narrower than "a letter": nothing lowercases the tag
-// text on the way in, so `[Foo]` is literal and a handler registered as `Foo`
-// could never fire. This tracked `[A-Za-z]` while `TAG_RE` wrongly admitted
-// uppercase, which is the same drift, one subset down (rich-markup-sec).
-const PLUGIN_TAG_NAME_SRC = "[a-z][A-Za-z0-9_-]*";
-const LEGAL_PLUGIN_TAG_NAME = new RegExp(`^${PLUGIN_TAG_NAME_SRC}$`);
-export class MarkupRegistry {
-    _handlers = new Map();
-    register(name, handler) {
-        // [LAW:no-silent-failure] Registration used to accept any string, including
-        // names markup can never address (`a.b` stops the tag scan at the dot), and
-        // install a handler that could never fire.
-        if (!LEGAL_PLUGIN_TAG_NAME.test(name)) {
-            throw new MarkupError(`Cannot register markup tag "${name}": a tag name must be a lowercase letter followed by letters, digits, "_" or "-", so markup could never address this name.`);
-        }
-        if (isReservedTagName(name)) {
-            throw new MarkupError(`Cannot register markup tag "${name}": name is reserved by a built-in style.`);
-        }
-        this._handlers.set(name, handler);
-    }
-    unregister(name) {
-        this._handlers.delete(name);
-    }
-    has(name) {
-        return this._handlers.has(name);
-    }
-    get(name) {
-        return this._handlers.get(name);
-    }
-}
-// [LAW:one-source-of-truth] Reserved-name detection delegates to Style.parse —
-// if a name is a valid built-in style, it cannot be hijacked by a plugin.
-// There is no second list of "reserved names" to drift out of sync.
-function isReservedTagName(name) {
-    try {
-        Style.parse(name);
-        return true;
-    }
-    catch (err) {
-        if (err instanceof StyleSyntaxError)
-            return false;
-        throw err;
-    }
-}
-// [LAW:no-shared-mutable-globals] The process-wide default tag set, which
-// `renderMarkup` falls back to when a caller passes no registry. It has one
-// owner and one explicit API — `MarkupRegistry`'s own methods. There is
-// deliberately no free-function façade over it: `registerMarkupTag(name, fn)`
-// forwarding to `.register(name, fn)` would be a second way to say one thing,
-// and the two would document the same invariants in two places.
-export const globalMarkupRegistry = new MarkupRegistry();
-// --- Plugin-aware tag parsing ---
-function isAlpha(c) {
-    const cc = c.charCodeAt(0);
-    return (cc >= 65 && cc <= 90) || (cc >= 97 && cc <= 122);
-}
-function isIdentChar(c) {
-    if (isAlpha(c))
-        return true;
-    const cc = c.charCodeAt(0);
-    return (cc >= 48 && cc <= 57) || c === "_" || c === "-";
-}
-function isSpace(c) {
-    return c === " " || c === "\t";
-}
-// A registered name addresses a plugin only when the tag text ends there or
-// continues with the whitespace that introduces attributes. Anything else —
-// `[table.header]`, `[table=x]` — is the built-in dialect's, and falls through
-// exactly as an unregistered name would.
-const PLUGIN_TAG_HEAD = new RegExp(`^(${PLUGIN_TAG_NAME_SRC})(?=$|[ \\t])`);
-function parsePluginAttrs(after) {
-    // Hand-written tokenizer. Walks `key=value` pairs separated by whitespace;
-    // values may be bare, single-quoted, or double-quoted. Matches the syntax
-    // the regex it replaces accepted.
-    const attrs = {};
-    let i = 0;
-    while (i < after.length) {
-        while (i < after.length && isSpace(after[i]))
-            i++;
-        if (i >= after.length)
-            break;
-        if (!isAlpha(after[i])) {
-            // Skip a stray non-name character to avoid infinite loops on malformed
-            // input — the legacy regex would simply fail to match here.
-            i++;
-            continue;
-        }
-        const nameStart = i;
-        while (i < after.length && isIdentChar(after[i]))
-            i++;
-        const name = after.slice(nameStart, i);
-        while (i < after.length && isSpace(after[i]))
-            i++;
-        if (after[i] !== "=")
-            continue;
-        i++;
-        while (i < after.length && isSpace(after[i]))
-            i++;
-        let value = "";
-        const quote = after[i];
-        if (quote === '"' || quote === "'") {
-            i++;
-            const valStart = i;
-            while (i < after.length && after[i] !== quote)
-                i++;
-            value = after.slice(valStart, i);
-            if (i < after.length)
-                i++;
-        }
-        else {
-            const valStart = i;
-            while (i < after.length && !isSpace(after[i]) && after[i] !== "]")
-                i++;
-            value = after.slice(valStart, i);
-        }
-        attrs[name] = value;
-    }
-    return attrs;
-}
-/**
- * Plugin-aware markup render. Always returns a `RichText`. Built-in style
- * tags become spans; registered plugin tags are resolved by their handler,
- * whose returned `RichText` is appended (text + spans) into the output. The
- * recursion is over markup *slices* — between top-level plugin tag pairs and
- * inside each pair — and every recursion node returns a `RichText`, so the
- * append path is uniform.
- */
-export function renderMarkup(markup, options) {
-    return renderSlice(markup, wholeString(markup), options);
-}
-function renderSlice(markup, origin, options) {
-    const registry = options?.registry ?? globalMarkupRegistry;
-    const baseStyle = options?.baseStyle;
-    const doEmoji = options?.emoji !== false;
-    // Fast path: no `[` at all → no possible tags.
-    if (!HAS_TAG_RE.test(markup)) {
-        return render(markup, origin, baseStyle, { emoji: doEmoji });
-    }
-    const tags = parseTags(markup);
-    // Pair each opening plugin tag with its matching closer up-front, so the
-    // splice walk can just iterate top-level pairs in source order with no
-    // nested-state book-keeping.
-    const { annotated, topLevel: tagPairs } = pairPluginTags(tags, registry, origin);
-    if (tagPairs.size === 0) {
-        return render(markup, origin, baseStyle, { emoji: doEmoji });
-    }
-    // [LAW:one-type-per-behavior] Always assemble a single RichText. Fragments
-    // between plugin pairs are parsed by the built-in `render`, plugin pairs
-    // hand their inner slice (recursively) to a handler; both produce RichText,
-    // both get appended into one accumulator.
-    const out = new RichText("");
-    let cursor = 0;
-    for (const [openIdx, closeIdx] of tagPairs) {
-        const open = annotated[openIdx];
-        const close = annotated[closeIdx];
-        if (open.start > cursor) {
-            out.append(render(markup.slice(cursor, open.start), offsetBy(origin, cursor), baseStyle, { emoji: doEmoji }));
-        }
-        const innerRaw = markup.slice(open.end, close.start);
-        const innerRichText = renderSlice(innerRaw, { ...offsetBy(origin, open.end), enclosing: [...origin.enclosing, open.fullMatch] }, options);
-        const handler = registry.get(open.pluginName);
-        out.append(handler({ attrs: open.attrs, children: innerRichText, raw: innerRaw }));
-        cursor = close.end;
-    }
-    if (cursor < markup.length) {
-        out.append(render(markup.slice(cursor), offsetBy(origin, cursor), baseStyle, { emoji: doEmoji }));
-    }
-    if (baseStyle)
-        out.stylize(baseStyle);
-    return out;
-}
-/** The origin of a sub-slice starting `offset` into the slice `origin` describes. */
-function offsetBy(origin, offset) {
-    return { ...origin, base: origin.base + offset };
-}
-function pairPluginTags(tags, registry, origin) {
-    // Annotate tags with plugin info, then pair openers with closers. Only
-    // top-level pairs are returned; inner pairs will be re-discovered by the
-    // recursive `renderMarkup` call on the inner slice.
-    const annotated = tags.map((t) => annotatePluginTag(t, registry));
-    const stack = [];
-    const pairs = new Map();
-    for (let i = 0; i < annotated.length; i++) {
-        const t = annotated[i];
-        if (!t.pluginName)
-            continue;
-        if (t.isImplicitClose)
-            continue;
-        if (t.isClosing) {
-            // Find matching open in stack.
-            for (let j = stack.length - 1; j >= 0; j--) {
-                const openIdx = stack[j];
-                if (annotated[openIdx].pluginName === t.pluginName) {
-                    pairs.set(openIdx, i);
-                    stack.splice(j, 1);
-                    break;
-                }
-            }
-        }
-        else {
-            stack.push(i);
-        }
-    }
-    // Filter pairs to top-level only. A pair that opens inside the current one is
-    // either contained — re-discovered when the recursion renders the outer
-    // pair's inner slice — or overlapping, and only its *closing* position tells
-    // the two apart. Testing the open position alone conflated them and dropped
-    // the overlapping pair, which orphaned its closing tag into the trailing
-    // slice, where the built-in parser blamed the wrong tag for the wrong reason.
-    const topLevel = new Map();
-    let outerEnd = -1;
-    let outerOpenIdx = -1;
-    const sortedOpens = [...pairs.keys()].sort((a, b) => a - b);
-    for (const openIdx of sortedOpens) {
-        const closeIdx = pairs.get(openIdx);
-        if (annotated[openIdx].start < outerEnd) {
-            // [LAW:no-silent-failure] Overlap is unrepresentable here rather than
-            // unimplemented: a handler receives `children` as one contiguous slice,
-            // so a region straddling another pair's closing boundary has nothing to
-            // hand it. A style span may overlap because it annotates; a plugin pair
-            // may not because it replaces.
-            if (annotated[closeIdx].end > outerEnd) {
-                const inner = annotated[openIdx];
-                const outer = annotated[outerOpenIdx];
-                // The caret goes under the outer pair's closing tag, the point where
-                // nesting breaks. This pass sees plugin tags only; of those, a pair is
-                // open there when it opens before that tag and closes at or after it.
-                const caret = annotated[pairs.get(outerOpenIdx)].start;
-                const openAtCaret = sortedOpens
-                    .filter((o) => annotated[o].start < caret && annotated[pairs.get(o)].start >= caret)
-                    .map((o) => annotated[o].fullMatch);
-                throw new MarkupSyntaxError(`Plugin tag [${inner.pluginName}] overlaps [${outer.pluginName}]: plugin tags must nest, ` +
-                    `because a handler receives one contiguous slice. ` +
-                    `Close [/${inner.pluginName}] before [/${outer.pluginName}].`, origin.source, origin.base + caret, [...origin.enclosing, ...openAtCaret]);
-            }
-            continue;
-        }
-        topLevel.set(openIdx, closeIdx);
-        outerOpenIdx = openIdx;
-        outerEnd = annotated[closeIdx].end;
-    }
-    return { annotated, topLevel };
-}
-function annotatePluginTag(tag, registry) {
-    // The legacy parser splits at the first `=`, so tag.styleName for
-    // `[click verb=foo]` is "click verb". Re-read the tag text for a name that
-    // actually addresses a plugin.
-    const inner = tag.fullMatch.slice(1, -1).replace(/^\//, "");
-    const head = PLUGIN_TAG_HEAD.exec(inner);
-    const name = head?.[1];
-    if (name === undefined || !registry.has(name))
-        return tag;
-    const after = inner.slice(name.length);
-    const attrs = tag.isClosing ? {} : parsePluginAttrs(after);
-    return { ...tag, pluginName: name, attrs };
-}

package/dist/core/measure.d.ts

@@ -1,27 +0,0 @@
-/**
- * Measurement — min/max cell width calculation for renderables.
- */
-import type { Measurable, RenderOptions } from "./protocol.js";
-export declare class Measurement {
-    readonly minimum: number;
-    readonly maximum: number;
-    constructor(minimum: number, maximum: number);
-    get span(): number;
-    /**
-     * A range with no cell meaning becomes one with the nearest meaning there is:
-     * negative floors to zero, an inverted pair collapses to its ceiling, and NaN
-     * reads as zero cells the same way `cellCount` reads it.
-     *
-     * NaN and Infinity are not treated alike here, and the difference is the whole
-     * point. `Infinity` is a maximum a renderable means — `Table` reports it when
-     * a column asks for every cell there is, and `withBoundedWidth` throws on it
-     * so a caller learns their offer was unanswerable. Flooring it to zero would
-     * turn that loud failure into a table measured at no width at all.
-     */
-    normalize(): Measurement;
-    withMaximum(width: number): Measurement;
-    withMinimum(width: number): Measurement;
-    clamp(minWidth: number, maxWidth: number): Measurement;
-    static get(options: RenderOptions, measurable: Measurable): Measurement;
-}
-export declare function measureRenderables(options: RenderOptions, measurables: Measurable[]): Measurement;