@vincemakes/kiso-tui-cells 0.46.2 → 0.47.1

package/dist/graphite.js

@@ -0,0 +1,311 @@
+/**
+ * Graphite (design.md §2, §3.4) — the colour tokens, the output tier, and
+ * the surfaces derived from the ground the terminal actually reported.
+ *
+ * PURE: no process state is read except where a caller passes it in, so
+ * every decision here is testable without a terminal. `render.ts` turns
+ * these colours into SGR bytes; this module only decides the colours.
+ */
+import { groundFrom, relativeLuminance } from "./ground.js";
+/** The Graphite table (design.md §2), on the two reference grounds. */
+export const GRAPHITE = {
+    light: {
+        ground: "#ffffff",
+        ink: "#111111",
+        ink2: "#444444",
+        dim: "#646464",
+        rail: "#8c8c8c",
+        line: "#e6e6e6",
+        washRun: "#edf2fb",
+        washDone: "#f1f1f1",
+        washFail: "#fbecea",
+        washAsk: "#f7f1e3",
+        human: "#f7efdc",
+        humanInk: "#171923",
+        gold: "#8a5a00",
+        goldMark: "#c9921f",
+        blue: "#2456b5",
+        code: "#e4ebf8",
+        ok: "#2f7a3a",
+        fail: "#b3261e",
+        add: "#dff0e2",
+        del: "#fadfdc",
+        track: "#e2e2e2",
+    },
+    // 0.47.1 — the dark table re-adapted (owner, 2026-10-07: preset D on
+    // the dark palette page): the surfaces were a few levels above the
+    // ground and read as heavy on a black terminal; they rise a step, and
+    // dim and ink2 rise with them to keep the floor. washAsk and code sit
+    // just under D's values (#524222, #30406a) so every pair of
+    // TEXT_PAIRS still clears 4.5, in the 256 tier too.
+    dark: {
+        ground: "#0b0b0b",
+        ink: "#ededed",
+        ink2: "#c2c2c2",
+        dim: "#a4a4a4",
+        rail: "#6b6b6b",
+        // the owner, 2026-10-08: the composer's rules read too grey on Apple
+        // Terminal's Pro profile (its transparency lightens the black) — the
+        // hairlines rise to #656565
+        line: "#656565",
+        washRun: "#2b3854",
+        washDone: "#333333",
+        washFail: "#4d2b28",
+        washAsk: "#483818",
+        human: "#e8dfc6",
+        humanInk: "#141620",
+        gold: "#e3b04b",
+        goldMark: "#e3b04b",
+        blue: "#82a8f5",
+        code: "#283658",
+        ok: "#8fd19e",
+        fail: "#f2877a",
+        add: "#2a5034",
+        del: "#5e302d",
+        track: "#474747",
+    },
+};
+/** The tokens that are GROUNDS near the terminal's own (§3.4): each is
+ *  derived from the reported ground. Every other token is fixed per kind. */
+export const SURFACES = ["line", "washRun", "washDone", "washFail", "washAsk", "human", "code", "add", "del", "track"];
+/** The text tokens that read on the ground and on the card surfaces (§2.1). */
+export const CARD_TEXT = ["ink", "ink2", "dim", "gold", "blue", "ok", "fail"];
+export const CARDS = ["washRun", "washDone", "washFail", "washAsk"];
+/** Every text-on-surface pair a human reads (§2.1's floor applies to each). */
+export const TEXT_PAIRS = [
+    ...["ground", ...CARDS].flatMap((surface) => CARD_TEXT.map((text) => [text, surface])),
+    ["humanInk", "human"],
+    ["blue", "code"],
+    ["ink", "add"],
+    ["ink", "del"],
+];
+export const FLOOR = 4.5;
+/** The floor for a GRAPHIC — a mark, not text (WCAG 1.4.11). The breath
+ *  never drops below it (§2.2). */
+export const GRAPHIC_FLOOR = 3;
+export function hexRgb(hex) {
+    const n = Number.parseInt(hex.slice(1), 16);
+    return { r: (n >> 16) & 255, g: (n >> 8) & 255, b: n & 255 };
+}
+export function rgbHex({ r, g, b }) {
+    return `#${[r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+/** The WCAG contrast ratio, the measure of §2's floor. */
+export function contrast(a, b) {
+    const [x, y] = [relativeLuminance(a), relativeLuminance(b)].sort((p, q) => q - p);
+    return (x + 0.05) / (y + 0.05);
+}
+/** `t` of the way from `a` to `b`, per channel. */
+export function mix(a, b, t) {
+    const c = (x, y) => Math.round(x + (y - x) * t);
+    return { r: c(a.r, b.r), g: c(a.g, b.g), b: c(a.b, b.b) };
+}
+const REF_LIGHT = hexRgb(GRAPHITE.light.ground);
+const REF_DARK = hexRgb(GRAPHITE.dark.ground);
+/**
+ * §3.4 — one surface for any ground. A DARK ground: per channel an affine
+ * map `s = a + k·g`, fitted so that the white reference ground gives the
+ * table's white value and the black one its black value — a terminal
+ * whose black is `#1e1e1e` gets a card that sits the same distance off
+ * ITS ground, and the distance narrows as a dark ground lightens, which
+ * keeps the text above the floor on the lighter dark themes. A LIGHT
+ * ground: the light table, moved by how far the ground sits from white.
+ * The two reference grounds reproduce the table exactly.
+ *
+ * 0.47.1 (the dark table's re-adaptation): DECLARED REVERSAL for the
+ * light grounds only. The one map through both tables tied them to the
+ * dark table — lifting the dark cards pulled a card on `#eeeeee` to within
+ * 1.09:1 of its ground. A light ground now answers to the light table
+ * alone; on the light grounds measured the cards move by a channel step
+ * or two at most.
+ */
+export function deriveSurface(token, ground) {
+    if (groundFrom(ground) === "light") {
+        const s = hexRgb(GRAPHITE.light[token]);
+        const shift = (sc, rc, g) => Math.max(0, Math.min(255, Math.round(sc + (g - rc))));
+        return { r: shift(s.r, REF_LIGHT.r, ground.r), g: shift(s.g, REF_LIGHT.g, ground.g), b: shift(s.b, REF_LIGHT.b, ground.b) };
+    }
+    const w = hexRgb(GRAPHITE.light[token]);
+    const d = hexRgb(GRAPHITE.dark[token]);
+    const chan = (wc, dc, lw, ld, g) => {
+        const k = (wc - dc) / (lw - ld);
+        return Math.max(0, Math.min(255, Math.round(dc + k * (g - ld))));
+    };
+    return {
+        r: chan(w.r, d.r, REF_LIGHT.r, REF_DARK.r, ground.r),
+        g: chan(w.g, d.g, REF_LIGHT.g, REF_DARK.g, ground.g),
+        b: chan(w.b, d.b, REF_LIGHT.b, REF_DARK.b, ground.b),
+    };
+}
+function table(kind) {
+    const t = GRAPHITE[kind];
+    return Object.fromEntries(Object.entries(t).map(([k, v]) => [k, hexRgb(v)]));
+}
+/** A colour as the terminal will show it: itself in the 24-bit tier, the
+ *  nearest xterm-256 entry in the 256 tier. The floor is checked on what
+ *  is SHOWN — rounding to the nearest index can cost a pair its contrast. */
+export function shown(c, tier) {
+    return tier === "24bit" ? c : xterm256(nearest256(c));
+}
+/** One pair's ratio as shown. The ground is the terminal's own colour and
+ *  is never rounded; every token kiso writes is. */
+function pairRatio(c, text, surface, tier) {
+    const s = surface === "ground" ? c.ground : shown(c[surface], tier);
+    return contrast(shown(c[text], tier), s);
+}
+/** The weakest text-on-surface pair of a colour set, as shown in `tier`. */
+export function weakestPair(c, tier = "24bit") {
+    let worst = { pair: TEXT_PAIRS[0], ratio: Number.POSITIVE_INFINITY };
+    for (const pair of TEXT_PAIRS) {
+        const ratio = pairRatio(c, pair[0], pair[1], tier);
+        if (ratio < worst.ratio)
+            worst = { pair, ratio };
+    }
+    return worst;
+}
+/** A text token moved toward the kind's extreme (white on a dark ground,
+ *  black on a light one) just far enough that it clears the floor, as
+ *  shown, on every surface it reads on. Unmoved when it already does. */
+function lifted(c, token, kind, tier) {
+    const on = TEXT_PAIRS.filter(([t]) => t === token).map(([, s]) => s);
+    const extreme = kind === "dark" ? { r: 255, g: 255, b: 255 } : { r: 0, g: 0, b: 0 };
+    for (let t = 0; t <= 1.0001; t += 0.02) {
+        const cand = { ...c, [token]: mix(c[token], extreme, t) };
+        if (on.every((s) => pairRatio(cand, token, s, tier) >= FLOOR))
+            return cand[token];
+    }
+    return extreme;
+}
+/**
+ * The colours for one screen. `ground` is the RGB the terminal reported
+ * (OSC 11), or null when the ground was resolved without a colour — an
+ * explicit theme, the terminal's scheme report, COLORFGBG — in which case
+ * the table is used as it stands.
+ *
+ * A reported ground of the OTHER kind (a human who set `theme: light` on
+ * a black terminal) derives nothing: the answer the human gave wins, and
+ * surfaces fitted to a ground the text tokens were not chosen for would
+ * be wrong in both directions.
+ *
+ * On a reported ground the surfaces are derived (§3.4), and a text token
+ * that would fall under the floor — as shown in `tier` — on the ground or
+ * on a surface is moved toward the kind's extreme just far enough to clear
+ * it: a lighter dark theme lifts `dim`, never the other way. The table's
+ * own values pass on their reference grounds in both tiers, so there
+ * nothing moves. If a pair is still under the floor, the table is used.
+ */
+/** The last derivation, kept: the opening's rules and wordmark ask for
+ *  the colours on every frame (the banner is a live cell), and the answer
+ *  only moves with its three inputs (the render-perf pass, 2026-10-07).
+ *  Callers read the table; none writes to it. */
+let lastColours = null;
+export function graphiteColours(kind, ground, tier = "24bit") {
+    const r = ground === null ? -1 : ground.r;
+    const g = ground === null ? -1 : ground.g;
+    const b = ground === null ? -1 : ground.b;
+    const k = lastColours;
+    if (k !== null && k.kind === kind && k.tier === tier && k.r === r && k.g === g && k.b === b)
+        return k.out;
+    const out = deriveColours(kind, ground, tier);
+    lastColours = { kind, r, g, b, tier, out };
+    return out;
+}
+function deriveColours(kind, ground, tier) {
+    const base = table(kind);
+    if (ground === null || groundFrom(ground) !== kind)
+        return base;
+    const derived = { ...base, ground };
+    for (const s of SURFACES)
+        derived[s] = deriveSurface(s, ground);
+    for (const t of new Set(TEXT_PAIRS.map(([text]) => text)))
+        derived[t] = lifted(derived, t, kind, tier);
+    const out = derived;
+    return weakestPair(out, tier).ratio >= FLOOR ? out : base;
+}
+/**
+ * The command breath (§5.2): seven steps from `gold` toward the running
+ * card's ground, peak → floor → peak. The floor is the deepest step that
+ * still meets the graphic floor on that ground (§2.2): the mark dims and
+ * never disappears.
+ */
+export function breathRamp(c) {
+    const card = c.washRun;
+    let deepest = 0;
+    for (let t = 0; t <= 1.0001; t += 0.01) {
+        if (contrast(mix(c.gold, card, t), card) >= GRAPHIC_FLOOR)
+            deepest = t;
+        else
+            break;
+    }
+    const at = (f) => mix(c.gold, card, deepest * f);
+    return [at(0), at(1 / 3), at(2 / 3), at(1), at(2 / 3), at(1 / 3), at(0)];
+}
+/** The xterm-256 palette's colour for an index 16–255 (the cube and the
+ *  grey ramp; the first sixteen are the terminal's own and never chosen). */
+export function xterm256(index) {
+    if (index >= 232) {
+        const v = 8 + (index - 232) * 10;
+        return { r: v, g: v, b: v };
+    }
+    const i = index - 16;
+    const step = (n) => (n === 0 ? 0 : 55 + n * 40);
+    return { r: step(Math.floor(i / 36)), g: step(Math.floor(i / 6) % 6), b: step(i % 6) };
+}
+/** The nearest xterm-256 index (16–255) to a colour, by squared distance
+ *  in RGB — the 256 tier's whole translation. */
+export function nearest256(c) {
+    let best = 16;
+    let bestD = Number.POSITIVE_INFINITY;
+    for (let i = 16; i <= 255; i += 1) {
+        const x = xterm256(i);
+        const d = (x.r - c.r) ** 2 + (x.g - c.g) ** 2 + (x.b - c.b) ** 2;
+        if (d < bestD) {
+            bestD = d;
+            best = i;
+        }
+    }
+    return best;
+}
+/** §2 — 24-bit where the terminal says it renders it. `COLORTERM` is the
+ *  standard statement; anything else gets the 256 tier, which every
+ *  terminal kiso docks in renders. */
+export function colourTier(colorterm) {
+    const v = colorterm?.trim().toLowerCase();
+    return v === "truecolor" || v === "24bit" ? "24bit" : "256";
+}
+/** 0.47.1 (owner, 2026-10-07) — 24-bit where the terminal is KNOWN to
+ *  render it, though it does not say so in COLORTERM. Windows Terminal is
+ *  the case that found it: drawn in the 256 tier, the person's cream block
+ *  became pink (index 224) and its gold edge olive (186). Each terminal is
+ *  recognised by what it sets; the list is the reference implementation's.
+ *  Inside tmux or screen only COLORTERM counts — the outer terminal's
+ *  variables are inherited, its rendering is not. Apple Terminal says it
+ *  in COLORTERM where it renders 24-bit (§2), and keeps the 256 tier
+ *  otherwise. PURE: the environment and the platform are passed in. */
+export function terminalTier(env, platform) {
+    if (colourTier(env.COLORTERM) === "24bit")
+        return "24bit";
+    const term = (env.TERM ?? "").toLowerCase();
+    if (env.TMUX !== undefined || term.startsWith("tmux") || term.startsWith("screen"))
+        return "256";
+    const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+    const known = env.WT_SESSION !== undefined ||
+        env.ITERM_SESSION_ID !== undefined ||
+        env.WEZTERM_PANE !== undefined ||
+        env.KITTY_WINDOW_ID !== undefined ||
+        env.GHOSTTY_RESOURCES_DIR !== undefined ||
+        ["iterm.app", "wezterm", "ghostty", "kitty", "vscode", "warpterminal", "alacritty"].includes(program) ||
+        term.includes("ghostty") ||
+        term === "alacritty" ||
+        (env.TERMINAL_EMULATOR ?? "").toLowerCase() === "jetbrains-jediterm" ||
+        // a Windows console renders 24-bit even where Windows Terminal hosts
+        // it without WT_SESSION (cmd.exe from Win+R)
+        platform === "win32";
+    return known ? "24bit" : "256";
+}
+export function fg(c, tier) {
+    return tier === "24bit" ? `\x1b[38;2;${c.r};${c.g};${c.b}m` : `\x1b[38;5;${nearest256(c)}m`;
+}
+export function bg(c, tier) {
+    return tier === "24bit" ? `\x1b[48;2;${c.r};${c.g};${c.b}m` : `\x1b[48;5;${nearest256(c)}m`;
+}

package/dist/index.d.ts

@@ -7,14 +7,17 @@
  * API-stability promise yet.
  */
 export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, foldTerms, elapsedLabel, settledLabel, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
-export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
+export { editFileDiff, editFileHunksDiff, hunksDiff, hunksOf, truncateDiff, writeFileDiff, type DiffLine, type DiffResult, type Hunk } from "./diff.js";
 export { pendingQueueRows } from "./components.js";
 export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, deletionRiskHint, SAFER_BACK, SAFER_DEGRADED, type SaferOption, type SaferRuntime, panelOptions, type PanelOption, type PanelOptionKind, type PanelState, type PanelVerdict, type PanelView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, } from "./approval-panel.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact, } from "./strings.js";
-export { coldResumeLine, coldResumeView, extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
+export { coldResumeLine, coldResumeView, extensionsBannerText, extensionsFact, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
 export { displayVerb } from "./strings.js";
-export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, currentGroundRgb, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, paletteFor, relativeTime, renderResumeList, MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame, renderTerminalGap, renderToolSummary, TAGLINE, MOTTO, WORDMARK_W, type BannerFact, type BannerMeta, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";
 /** DC-3 — the ground: is the terminal light or dark. Pure; see the
  *  module comment for why `unknown` is a result and not a failure. */
 export { groundFrom, parseOscColor, relativeLuminance, resolveGround, type Ground, type GroundInputs, type Rgb } from "./ground.js";
+/** Graphite (design.md §2, §3.4) — the tokens, the tier and the derived
+ *  surfaces, as colours. Pure; `render.ts` writes them as SGR. */
+export { GRAPHITE, breathRamp, colourTier, terminalTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair, type Colours, type Kind, type Tier, type Token } from "./graphite.js";

package/dist/index.js

@@ -7,7 +7,7 @@
  * API-stability promise yet.
  */
 export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, foldTerms, elapsedLabel, settledLabel, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
-export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
+export { editFileDiff, editFileHunksDiff, hunksDiff, hunksOf, truncateDiff, writeFileDiff } from "./diff.js";
 // W22 (the v8 input round): the pending-queue chips — the SAME
 // UserMessage chip with the □ gutter, pre-rendered above the input
 // row while turns wait in the queue.
@@ -24,11 +24,14 @@ export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWi
 // the cli; what the human reads is presentation.
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, } from "./strings.js";
 // KC3.5: the interrupted-ask copy and the extracted /help table.
-export { coldResumeLine, coldResumeView, extensionsBannerText, helpRows, unansweredAskView } from "./strings.js";
+export { coldResumeLine, coldResumeView, extensionsBannerText, extensionsFact, helpRows, unansweredAskView } from "./strings.js";
 // TUI2-R2pre ④: the ONE display-verb table — the screen names the act,
 // the tool table names the call.
 export { displayVerb } from "./strings.js";
-export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, currentGroundRgb, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, paletteFor, relativeTime, renderResumeList, MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame, renderTerminalGap, renderToolSummary, TAGLINE, MOTTO, WORDMARK_W, toolTarget, truncateRow, } from "./render.js";
 /** DC-3 — the ground: is the terminal light or dark. Pure; see the
  *  module comment for why `unknown` is a result and not a failure. */
 export { groundFrom, parseOscColor, relativeLuminance, resolveGround } from "./ground.js";
+/** Graphite (design.md §2, §3.4) — the tokens, the tier and the derived
+ *  surfaces, as colours. Pure; `render.ts` writes them as SGR. */
+export { GRAPHITE, breathRamp, colourTier, terminalTier, contrast, deriveSurface, graphiteColours, hexRgb, nearest256, rgbHex, weakestPair } from "./graphite.js";

package/dist/md.d.ts

@@ -39,7 +39,7 @@
 /** The block kinds. `fence-open`/`fence-line` are separate kinds on
  *  purpose: a fence's rows must be able to freeze ONE AT A TIME, and
  *  MD-1.4's `code-line` is the same shape for the same reason. */
-export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line" | "fence-close" | "code-line";
+export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line" | "fence-close" | "code-line" | "refdef";
 /** One block: its SOURCE lines, never a rendered form. The render is a
  *  pure function of (block, width), which is what makes the freeze
  *  property a property of the scanner alone. */
@@ -70,10 +70,15 @@ export declare class MdStream {
 }
 /** The whole message at once — the freeze property's oracle, and the
  *  path a non-streaming caller takes. */
-export declare function renderMarkdown(text: string, W: number): string[];
+export declare function renderMarkdown(text: string, W: number, opts?: {
+    readonly hardBreaks?: boolean;
+}): string[];
 /** One block's screen rows. Pure in (block, W) — this is the whole
  *  freeze guarantee: same source, same width, same bytes, forever. */
-export declare function renderBlock(b: MdBlock, W: number): string[];
+export declare function renderBlock(b: MdBlock, W: number, hardBreaks?: boolean): string[];
+/** Graphite §5 (R2b): a heading block's level, or null — the prose column
+ *  puts `§` in the mark column beside a `##`, which is outside the block. */
+export declare function headingLevel(b: MdBlock): number | null;
 /**
  * The inline pass — the mono style table applied to one block's text.
  *
@@ -90,12 +95,18 @@ export declare function renderBlock(b: MdBlock, W: number): string[];
  *   out, so a nested span can never strand it. Italic is the one span
  *   that closes surgically (SGR 23), because it can.
  *
+ * Graphite R2f (owner, 2026-09-30) adds `***bold italic***`, code spans
+ * of any backtick run, a link's title (read and dropped), `<autolinks>`,
+ * `![images]` (named: `image` dim, the alt as a link, the url dim),
+ * `[reference][links]` (the text as a link, the label dim) and `<br>` (a
+ * line break).
+ *
  * Documented deviations from CommonMark: `_` never emphasizes (it is a
  * character in identifiers far more often than a marker in prose);
- * emphasis does not nest across a code span; `~~` is not a construct at
- * all — the markers are content (the strict tokenizer both reference
- * implementations converged on, taken to its honest conclusion, since
- * SGR 9's terminal support is too fragmented to promise).
+ * emphasis does not nest across a code span; `~~` makes its text dim
+ * (R2b), never SGR 9, whose terminal support is too fragmented to
+ * promise — Apple Terminal draws none; a shortcut reference `[label]`
+ * stays literal.
  */
 export declare function inlineSpans(text: string, base: string): string;
 /** Split a table line into cells. The `|` walls are found on the RAW