md-verified 0.1.0

package/dist/src/framework.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The user-facing API.
+ *
+ * Glue code registers handlers against the ids used in the Markdown:
+ *
+ *     verify.table('validateOrder', async (row) => { ... });
+ *     verify.mermaid.edges('validateFlow', async (edge) => { ... });
+ *
+ * A handler either returns normally (pass) or throws (fail). That is the whole
+ * contract -- any assertion library works, including none.
+ */
+import { type Coercer } from './coerce.ts';
+import type { AnchorKind, AnchorMeta, ListItem, MermaidEdge, MermaidGraph, ParsedList, ParsedTable, TableRow } from './types.ts';
+/** Second argument to every handler: where in the document we are. */
+export interface VerifyContext {
+    /** The anchor id. */
+    id: string;
+    kind: AnchorKind;
+    /** The label as written, e.g. `Data`. */
+    label: string;
+    /** Markdown file the anchor came from. */
+    file: string;
+    /** 1-based line of the anchor blockquote. */
+    line: number;
+    /** Extra `**Key:** value` lines from the blockquote. */
+    meta: AnchorMeta;
+}
+export type RowHandler = (row: TableRow, ctx: VerifyContext) => unknown;
+export type TableHandler = (table: ParsedTable, ctx: VerifyContext) => unknown;
+export type GraphHandler = (graph: MermaidGraph, ctx: VerifyContext) => unknown;
+export type EdgeHandler = (edge: MermaidEdge, ctx: VerifyContext) => unknown;
+export type ItemHandler = (item: ListItem, ctx: VerifyContext) => unknown;
+export type ListHandler = (list: ParsedList, ctx: VerifyContext) => unknown;
+/** `each` fans the asset out into one case per row/edge/item. */
+export type HandlerMode = 'each' | 'all';
+export interface Registration {
+    id: string;
+    kind: AnchorKind;
+    mode: HandlerMode;
+    fn: (payload: any, ctx: VerifyContext) => unknown;
+}
+export declare const verify: {
+    table: {
+        (id: string, fn: RowHandler): void;
+        all(id: string, fn: TableHandler): void;
+    };
+    mermaid: {
+        (id: string, fn: GraphHandler): void;
+        edges(id: string, fn: EdgeHandler): void;
+    };
+    list: {
+        (id: string, fn: ItemHandler): void;
+        all(id: string, fn: ListHandler): void;
+    };
+    /** Teach `**Schema:**` a new value type. */
+    type(name: string, coercer: Coercer): void;
+    /** Drop every registration. Mainly for tests that re-import glue code. */
+    reset(): void;
+};
+/** Every handler bound to an anchor id: at most one `each` and one `all`. */
+export declare function getRegistrations(id: string): Registration[];
+/** Every registration, in declaration order. */
+export declare function registrations(): Registration[];
+export { assert, equals, oneOf } from './assertions.ts';

package/dist/src/framework.js

@@ -0,0 +1,73 @@
+/**
+ * The user-facing API.
+ *
+ * Glue code registers handlers against the ids used in the Markdown:
+ *
+ *     verify.table('validateOrder', async (row) => { ... });
+ *     verify.mermaid.edges('validateFlow', async (edge) => { ... });
+ *
+ * A handler either returns normally (pass) or throws (fail). That is the whole
+ * contract -- any assertion library works, including none.
+ */
+import { registerType } from "./coerce.js";
+/**
+ * Keyed by `id:mode`. One anchor may carry both an `each` and an `all`
+ * handler -- per-element checks and a whole-asset check such as `covers()`
+ * answer different questions about the same table or diagram. Registering the
+ * same mode twice is still an error, so typos are still caught.
+ */
+const registry = new Map();
+function register(id, kind, mode, fn) {
+    if (typeof id !== 'string' || !id.trim()) {
+        throw new TypeError('verify: id must be a non-empty string');
+    }
+    if (typeof fn !== 'function') {
+        throw new TypeError(`verify: handler for \`${id}\` must be a function`);
+    }
+    const clash = [...registry.values()].find((r) => r.id === id && r.kind !== kind);
+    if (clash) {
+        throw new Error(`verify: \`${id}\` is already registered as verify.${clash.kind}; one anchor cannot be two kinds`);
+    }
+    const key = `${id}:${mode}`;
+    if (registry.has(key)) {
+        throw new Error(`verify: \`${id}\` already has a ${kind}.${mode} handler.\n` +
+            `Anchor ids are unique per *document*, not per project, so two documents may both use \`${id}\`. ` +
+            `If that is what happened, load each document with loadDocument() rather than importing their glue files into one process.`);
+    }
+    registry.set(key, { id, kind, mode, fn: fn });
+}
+/** Register a table handler, called once per data row. */
+const table = (id, fn) => register(id, 'table', 'each', fn);
+/** Register a table handler, called once with the whole table. */
+table.all = (id, fn) => register(id, 'table', 'all', fn);
+/** Register a diagram handler, called once with the whole graph. */
+const mermaid = (id, fn) => register(id, 'mermaid', 'all', fn);
+/** Register a diagram handler, called once per edge. */
+mermaid.edges = (id, fn) => register(id, 'mermaid', 'each', fn);
+/** Register a list handler, called once per item (nested items included). */
+const list = (id, fn) => register(id, 'list', 'each', fn);
+/** Register a list handler, called once with the whole list. */
+list.all = (id, fn) => register(id, 'list', 'all', fn);
+export const verify = {
+    table,
+    mermaid,
+    list,
+    /** Teach `**Schema:**` a new value type. */
+    type(name, coercer) {
+        registerType(name, coercer);
+    },
+    /** Drop every registration. Mainly for tests that re-import glue code. */
+    reset() {
+        registry.clear();
+    },
+};
+/** Every handler bound to an anchor id: at most one `each` and one `all`. */
+export function getRegistrations(id) {
+    return [...registry.values()].filter((r) => r.id === id);
+}
+/** Every registration, in declaration order. */
+export function registrations() {
+    return [...registry.values()];
+}
+// Assertions live in `assertions.ts`; re-exported here for convenience.
+export { assert, equals, oneOf } from "./assertions.js";

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+/** Public entry point. */
+export { verify, getRegistrations, registrations } from './framework.ts';
+export { assert, equals, oneOf, format } from './assertions.ts';
+export type { VerifyContext, RowHandler, TableHandler, GraphHandler, EdgeHandler, ItemHandler, ListHandler, } from './framework.ts';
+export { parseMarkdown, parseSchema, parseCovers, findGlueHint, LABEL_KINDS } from './parser.ts';
+export { covers } from './covers.ts';
+export { checkReviews, digestOf } from './reviews.ts';
+export type { ReviewOptions } from './reviews.ts';
+export { exportedNames, exportedSymbol, exportedSymbols, clearSymbolCache } from './symbols.ts';
+export type { SymbolInfo } from './symbols.ts';
+export type { CoversOptions } from './covers.ts';
+export { checkReferences, collectReferences, headingSlugs, slugify, clearReferenceCache, } from './references.ts';
+export type { Reference, ReferenceOptions } from './references.ts';
+export { parseMermaid, MermaidParseError } from './mermaid.ts';
+export { coerce, registerType, knownTypes, hasType, CoercionError } from './coerce.ts';
+export { runFile, runParsed, runAnchor, planCases, loadDocument, resolveGlue, loadGlue } from './runner.ts';
+export type { RunOptions, Plan, PlannedCase, LoadedDocument, DocumentSuite } from './runner.ts';
+export { rewriteMarkdown, rewriteFromRun, formatRun, setColor, c } from './report.ts';
+export * from './types.ts';

package/dist/src/index.js

@@ -0,0 +1,13 @@
+/** Public entry point. */
+export { verify, getRegistrations, registrations } from "./framework.js";
+export { assert, equals, oneOf, format } from "./assertions.js";
+export { parseMarkdown, parseSchema, parseCovers, findGlueHint, LABEL_KINDS } from "./parser.js";
+export { covers } from "./covers.js";
+export { checkReviews, digestOf } from "./reviews.js";
+export { exportedNames, exportedSymbol, exportedSymbols, clearSymbolCache } from "./symbols.js";
+export { checkReferences, collectReferences, headingSlugs, slugify, clearReferenceCache, } from "./references.js";
+export { parseMermaid, MermaidParseError } from "./mermaid.js";
+export { coerce, registerType, knownTypes, hasType, CoercionError } from "./coerce.js";
+export { runFile, runParsed, runAnchor, planCases, loadDocument, resolveGlue, loadGlue } from "./runner.js";
+export { rewriteMarkdown, rewriteFromRun, formatRun, setColor, c } from "./report.js";
+export * from "./types.js";

package/dist/src/mdast-gfm.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal `mdast-util-from-markdown` extensions for GFM tables and task-list
+ * items.
+ *
+ * These are normally provided by `mdast-util-gfm-table` /
+ * `mdast-util-gfm-task-list-item`, but those packages also ship the
+ * *serialisation* half, which pulls in `mdast-util-to-markdown` ->
+ * `unist-util-visit-parents`. Bun 1.3.x cannot resolve that package's
+ * self-referencing `./do-not-use-color` subpath export, so importing them
+ * crashes at startup.
+ *
+ * We only ever *read* Markdown -- status rewriting is done as a surgical
+ * string splice against the original source (see `report.ts`), never by
+ * re-serialising the AST -- so the from-markdown handlers below are all we
+ * need. They are ported from the upstream implementations, minus `devlop`
+ * asserts.
+ */
+import type { Extension } from 'mdast-util-from-markdown';
+/** Enable `table` / `tableRow` / `tableCell` nodes. */
+export declare function gfmTableFromMarkdown(): Extension;
+/** Enable `listItem.checked` for `- [x]` / `- [ ]` items. */
+export declare function gfmTaskListItemFromMarkdown(): Extension;

package/dist/src/mdast-gfm.js

@@ -0,0 +1,90 @@
+/** Enable `table` / `tableRow` / `tableCell` nodes. */
+export function gfmTableFromMarkdown() {
+    return {
+        enter: {
+            table: enterTable,
+            tableData: enterCell,
+            tableHeader: enterCell,
+            tableRow: enterRow,
+        },
+        exit: {
+            codeText: exitCodeText,
+            table: exitNode,
+            tableData: exitNode,
+            tableHeader: exitNode,
+            tableRow: exitNode,
+        },
+    };
+}
+const enterTable = function (token) {
+    const align = token._align;
+    this.enter({
+        type: 'table',
+        align: (align ?? []).map((d) => (d === 'none' ? null : d)),
+        children: [],
+    }, token);
+    this.data.inTable = true;
+};
+const exitTable = function (token) {
+    this.exit(token);
+    this.data.inTable = undefined;
+};
+const enterRow = function (token) {
+    this.enter({ type: 'tableRow', children: [] }, token);
+};
+const enterCell = function (token) {
+    this.enter({ type: 'tableCell', children: [] }, token);
+};
+function exitNode(token) {
+    if (token.type === 'table')
+        return exitTable.call(this, token);
+    this.exit(token);
+}
+/** Inside a table, `\|` inside inline code means a literal pipe. */
+const exitCodeText = function (token) {
+    let value = this.resume();
+    if (this.data.inTable) {
+        value = value.replace(/\\([\\|])/g, (whole, char) => (char === '|' ? char : whole));
+    }
+    const node = this.stack[this.stack.length - 1];
+    node.value = value;
+    this.exit(token);
+};
+/** Enable `listItem.checked` for `- [x]` / `- [ ]` items. */
+export function gfmTaskListItemFromMarkdown() {
+    return {
+        exit: {
+            taskListCheckValueChecked: exitCheck,
+            taskListCheckValueUnchecked: exitCheck,
+            paragraph: exitParagraphWithTaskListItem,
+        },
+    };
+}
+const exitCheck = function (token) {
+    // Always inside a paragraph, inside a list item.
+    const node = this.stack[this.stack.length - 2];
+    node.checked = token.type === 'taskListCheckValueChecked';
+};
+/** Strip the space that followed the `[x]` marker from the item's text. */
+const exitParagraphWithTaskListItem = function (token) {
+    const parent = this.stack[this.stack.length - 2];
+    if (parent && parent.type === 'listItem' && typeof parent.checked === 'boolean') {
+        const node = this.stack[this.stack.length - 1];
+        const head = node.children[0];
+        if (head && head.type === 'text') {
+            const firstParagraph = parent.children.find((c) => c.type === 'paragraph');
+            if (firstParagraph === node) {
+                head.value = head.value.slice(1);
+                if (head.value.length === 0) {
+                    node.children.shift();
+                }
+                else if (node.position && head.position && typeof head.position.start.offset === 'number') {
+                    head.position.start.column++;
+                    head.position.start.offset++;
+                    node.position.start = { ...head.position.start };
+                }
+            }
+        }
+    }
+    this.exit(token);
+};

package/dist/src/mermaid.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A small, dependency-free Mermaid flowchart parser.
+ *
+ * Scope is deliberately the flowchart/graph family (and anything else built
+ * from `A --> B` statements, such as `stateDiagram-v2`). It resolves the one
+ * genuinely ambiguous piece of the grammar the same way Mermaid's own lexer
+ * does: a *complete* link is matched greedily before a link-with-label is
+ * considered, so `A --- B --- C` is two open links rather than one link
+ * labelled `B`.
+ */
+import type { MermaidGraph } from './types.ts';
+/** Raised for diagram source we cannot make sense of. */
+export declare class MermaidParseError extends Error {
+    readonly line: number;
+    constructor(message: string, line: number);
+}
+export declare function parseMermaid(source: string): MermaidGraph;

package/dist/src/mermaid.js

@@ -0,0 +1,304 @@
+/** Raised for diagram source we cannot make sense of. */
+export class MermaidParseError extends Error {
+    // Not a constructor parameter property: those are unsupported by Node's
+    // strip-only type stripping, and glue code may make Node load this as TS.
+    line;
+    constructor(message, line) {
+        super(`${message} (diagram line ${line})`);
+        this.name = 'MermaidParseError';
+        this.line = line;
+    }
+}
+/** A complete link: `-->`, `---`, `==>`, `-.->`, `~~~`. */
+const FULL_LINK = /^(?<lhead>[xo<])?(?<stem>-{2,}[-xo>]|={2,}[=xo>]|-\.+-[xo>]?|~{3,})/;
+/** The opening half of a labelled link: `-- text -->`. */
+const OPEN_LINK = /^(?<lhead>[xo<])?(?<stem>-{2,}|={2,}|-\.+)/;
+/** The closing half of a labelled link. */
+const CLOSE_LINK = /^(?<stem>-{2,}|={2,}|\.+-)(?<rhead>[xo>])?/;
+/** `-->|label|` */
+const PIPE_LABEL = /^\|(?<label>[^|]*)\|/;
+/** Shapes, longest delimiter first so `((x))` wins over `(x)`. */
+const SHAPES = [
+    [/^\(\(\((?<label>[\s\S]*?)\)\)\)/, 'doublecircle'],
+    [/^\(\((?<label>[\s\S]*?)\)\)/, 'circle'],
+    [/^\{\{(?<label>[\s\S]*?)\}\}/, 'hexagon'],
+    [/^\[\[(?<label>[\s\S]*?)\]\]/, 'subroutine'],
+    [/^\[\((?<label>[\s\S]*?)\)\]/, 'cylinder'],
+    [/^\(\[(?<label>[\s\S]*?)\]\)/, 'stadium'],
+    [/^\[\/(?<label>[\s\S]*?)\/\]/, 'parallelogram'],
+    [/^\[\\(?<label>[\s\S]*?)\\\]/, 'parallelogram-alt'],
+    [/^\[\/(?<label>[\s\S]*?)\\\]/, 'trapezoid'],
+    [/^\[\\(?<label>[\s\S]*?)\/\]/, 'trapezoid-alt'],
+    [/^\[(?<label>[\s\S]*?)\]/, 'rect'],
+    [/^\((?<label>[\s\S]*?)\)/, 'round'],
+    [/^\{(?<label>[\s\S]*?)\}/, 'diamond'],
+    [/^>(?<label>[\s\S]*?)\]/, 'asymmetric'],
+];
+const NODE_ID = /^(?:"(?<quoted>[^"]+)"|(?<bare>[A-Za-z0-9_][A-Za-z0-9_.:-]*))/;
+/** Statement keywords that carry styling, not structure. */
+const IGNORED = /^(?:style|classDef|class|click|linkStyle|direction|accTitle|accDescr)\b/;
+export function parseMermaid(source) {
+    const nodes = new Map();
+    const edges = [];
+    const subgraphs = [];
+    const stack = [];
+    let type = 'graph';
+    let direction = 'TB';
+    let headerSeen = false;
+    const statements = splitStatements(source);
+    for (const stmt of statements) {
+        const text = stmt.text;
+        if (!headerSeen) {
+            const header = /^(?<type>graph|flowchart(?:-v2)?|stateDiagram(?:-v2)?|erDiagram|classDiagram)\b\s*(?<dir>TB|TD|BT|RL|LR)?/i.exec(text);
+            if (header) {
+                type = header.groups.type.toLowerCase().replace(/-v2$/, '');
+                direction = (header.groups.dir ?? 'TB').toUpperCase();
+                headerSeen = true;
+                // A header line may carry a first statement after it on the same line.
+                const rest = text.slice(header[0].length).trim();
+                if (!rest)
+                    continue;
+                parseStatement({ text: rest, pos: 0, line: stmt.line });
+                continue;
+            }
+            // No recognisable header: treat the whole block as a bare flowchart.
+            headerSeen = true;
+        }
+        if (IGNORED.test(text))
+            continue;
+        const sub = /^subgraph\s+(?<rest>.+)$/i.exec(text);
+        if (sub) {
+            const { id, label } = parseSubgraphHeader(sub.groups.rest);
+            const entry = { id, label, nodes: [] };
+            subgraphs.push(entry);
+            stack.push(entry);
+            continue;
+        }
+        if (/^end$/i.test(text)) {
+            stack.pop();
+            continue;
+        }
+        parseStatement({ text, pos: 0, line: stmt.line });
+    }
+    /** Parse one `A --> B --> C` chain, including `&` fan-out. */
+    function parseStatement(cur) {
+        skipSpace(cur);
+        if (cur.pos >= cur.text.length)
+            return;
+        let left = readNodeGroup(cur);
+        if (!left) {
+            throw new MermaidParseError(`expected a node, found ${JSON.stringify(remainder(cur))}`, cur.line);
+        }
+        // A lone `A[Label]` statement just declares a node.
+        skipSpace(cur);
+        if (cur.pos >= cur.text.length)
+            return;
+        while (cur.pos < cur.text.length) {
+            const link = readLink(cur);
+            if (!link) {
+                throw new MermaidParseError(`expected a link, found ${JSON.stringify(remainder(cur))}`, cur.line);
+            }
+            skipSpace(cur);
+            const right = readNodeGroup(cur);
+            if (!right) {
+                throw new MermaidParseError(`link ${JSON.stringify(link.raw)} has no target node`, cur.line);
+            }
+            for (const from of left) {
+                for (const to of right) {
+                    edges.push({
+                        from,
+                        to,
+                        label: link.label,
+                        style: link.style,
+                        directed: link.directed,
+                        raw: link.raw,
+                    });
+                }
+            }
+            left = right;
+            skipSpace(cur);
+        }
+    }
+    /** `A` or `A & B` -- returns the ids, registering any inline declarations. */
+    function readNodeGroup(cur) {
+        const ids = [];
+        for (;;) {
+            skipSpace(cur);
+            const id = readNode(cur);
+            if (!id)
+                return ids.length ? ids : null;
+            ids.push(id);
+            skipSpace(cur);
+            if (cur.text[cur.pos] === '&') {
+                cur.pos++;
+                continue;
+            }
+            return ids;
+        }
+    }
+    /** Read `id` plus an optional shape, and record the node. */
+    function readNode(cur) {
+        const idMatch = NODE_ID.exec(cur.text.slice(cur.pos));
+        if (!idMatch)
+            return null;
+        const id = (idMatch.groups.quoted ?? idMatch.groups.bare).trim();
+        cur.pos += idMatch[0].length;
+        let label = null;
+        let shape = 'rect';
+        const rest = cur.text.slice(cur.pos);
+        for (const [re, name] of SHAPES) {
+            const m = re.exec(rest);
+            if (m) {
+                label = stripQuotes(m.groups.label ?? '').trim();
+                shape = name;
+                cur.pos += m[0].length;
+                break;
+            }
+        }
+        const existing = nodes.get(id);
+        if (existing) {
+            // A later declaration with a real label wins over a bare mention.
+            if (label !== null) {
+                existing.label = label;
+                existing.shape = shape;
+            }
+        }
+        else {
+            nodes.set(id, {
+                id,
+                label: label ?? id,
+                shape,
+                subgraph: stack.length ? stack[stack.length - 1].id : null,
+            });
+        }
+        const owner = stack[stack.length - 1];
+        if (owner && !owner.nodes.includes(id))
+            owner.nodes.push(id);
+        return id;
+    }
+    function readLink(cur) {
+        skipSpace(cur);
+        const rest = cur.text.slice(cur.pos);
+        // Greedy first: a complete link beats a labelled one, matching Mermaid's
+        // lexer. This is what keeps `A --- B --- C` from reading B as a label.
+        const full = FULL_LINK.exec(rest);
+        if (full) {
+            const raw = full[0];
+            cur.pos += raw.length;
+            let label = null;
+            const pipe = PIPE_LABEL.exec(cur.text.slice(cur.pos));
+            if (pipe) {
+                label = stripQuotes(pipe.groups.label ?? '').trim() || null;
+                cur.pos += pipe[0].length;
+            }
+            return { raw, label, style: styleOf(raw), directed: directedOf(raw, full.groups.lhead) };
+        }
+        const open = OPEN_LINK.exec(rest);
+        if (!open)
+            return null;
+        // `-- text -->`: scan forward for the closing half.
+        const after = cur.pos + open[0].length;
+        for (let i = after; i <= cur.text.length; i++) {
+            const close = CLOSE_LINK.exec(cur.text.slice(i));
+            if (!close)
+                continue;
+            const label = stripQuotes(cur.text.slice(after, i)).trim();
+            const raw = cur.text.slice(cur.pos, i + close[0].length);
+            cur.pos = i + close[0].length;
+            return {
+                raw,
+                label: label || null,
+                style: styleOf(raw),
+                directed: directedOf(raw, open.groups.lhead),
+            };
+        }
+        return null;
+    }
+    const graph = {
+        type,
+        direction,
+        nodes: [...nodes.values()],
+        edges,
+        subgraphs,
+        raw: source,
+        node: (id) => nodes.get(id),
+        from: (id) => edges.filter((e) => e.from === id),
+        to: (id) => edges.filter((e) => e.to === id),
+        hasEdge: (a, b) => edges.some((e) => e.from === a && e.to === b),
+        hasPath(a, b) {
+            const seen = new Set();
+            const queue = [a];
+            while (queue.length) {
+                const cur = queue.shift();
+                if (cur === b && cur !== a)
+                    return true;
+                if (seen.has(cur))
+                    continue;
+                seen.add(cur);
+                for (const e of edges) {
+                    if (e.from === cur)
+                        queue.push(e.to);
+                    else if (!e.directed && e.to === cur)
+                        queue.push(e.from);
+                }
+            }
+            return false;
+        },
+        roots: () => [...nodes.values()].filter((n) => !edges.some((e) => e.to === n.id)),
+        leaves: () => [...nodes.values()].filter((n) => !edges.some((e) => e.from === n.id)),
+    };
+    return graph;
+}
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+function splitStatements(source) {
+    const out = [];
+    const lines = source.split('\n');
+    lines.forEach((raw, i) => {
+        const withoutComment = raw.replace(/%%.*$/, '');
+        for (const part of withoutComment.split(';')) {
+            const text = part.trim();
+            if (text)
+                out.push({ text, line: i + 1 });
+        }
+    });
+    return out;
+}
+function parseSubgraphHeader(rest) {
+    // `subgraph id[Label]`, `subgraph id [Label]`, or `subgraph Just A Label`
+    const m = /^(?<id>[A-Za-z0-9_][A-Za-z0-9_.-]*)\s*(?:\[(?<label>[\s\S]*?)\]|\((?<round>[\s\S]*?)\))?$/.exec(rest.trim());
+    if (m) {
+        const id = m.groups.id;
+        const label = m.groups.label ?? m.groups.round;
+        return { id, label: stripQuotes(label ?? id).trim() };
+    }
+    const label = stripQuotes(rest.trim());
+    return { id: label, label };
+}
+function styleOf(raw) {
+    if (raw.includes('~'))
+        return 'invisible';
+    if (raw.includes('='))
+        return 'thick';
+    if (raw.includes('.'))
+        return 'dotted';
+    return 'normal';
+}
+function directedOf(raw, leftHead) {
+    return Boolean(leftHead) || /[>ox]$/.test(raw);
+}
+function stripQuotes(s) {
+    const t = s.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+function skipSpace(cur) {
+    while (cur.pos < cur.text.length && /\s/.test(cur.text[cur.pos]))
+        cur.pos++;
+}
+function remainder(cur) {
+    return cur.text.slice(cur.pos, cur.pos + 24);
+}

package/dist/src/parser.d.ts

@@ -0,0 +1,26 @@
+import { KNOWN_GLYPHS, type AnchorKind, type ParseResult, type SchemaField } from './types.ts';
+/**
+ * Comments the lookahead steps over when binding an anchor to its asset.
+ *
+ * Broader than the set we are allowed to *rewrite* (see `MANAGED_LINE_RE` in
+ * `report.ts`): an author's `<!-- verify: ./glue.ts -->` hint is skipped here
+ * so it cannot break a binding, but it is never ours to delete.
+ */
+export declare const SKIPPABLE_COMMENT_RE: RegExp;
+/** Human labels -> the asset kind they bind to. */
+export declare const LABEL_KINDS: Record<string, AnchorKind>;
+export declare function parseMarkdown(source: string, file?: string): ParseResult;
+/**
+ * Read a `<!-- verify: ./glue.ts -->` hint, if the document carries one.
+ *
+ * Scans HTML nodes rather than the raw source, so a hint shown as an *example*
+ * inside a fenced code block is not mistaken for a real one. Documentation
+ * about this tool is the obvious case, and it is exactly the kind of thing a
+ * regex over the whole file gets wrong.
+ */
+export declare function findGlueHint(source: string): string | null;
+/** `[itemsTotal: Currency, tax: Percentage]` -> fields. */
+export declare function parseSchema(raw: string): SchemaField[];
+/** `` `./a.ts#x`, `./b.ts` `` -> targets. */
+export declare function parseCovers(raw: string): string[];
+export { KNOWN_GLYPHS };