md-verified 0.1.0

package/dist/src/parser.js

@@ -0,0 +1,423 @@
+/**
+ * Markdown -> anchors.
+ *
+ * An *anchor* is a blockquote of the form
+ *
+ *     > 🛠️ **Verified Data:** `validateOrder`
+ *     > **Schema:** `[itemsTotal: Currency, total: Currency]`
+ *
+ * immediately followed by a native Markdown asset -- a table, a Mermaid code
+ * block, or a list. The blockquote renders as an ordinary callout everywhere;
+ * nothing here requires a custom renderer.
+ *
+ * Binding is done by *lookahead*: we take the next block-level node, skipping
+ * only the HTML comments this framework writes itself (so a file that has
+ * already been annotated with `<!-- ERROR: ... -->` still binds correctly on
+ * the next run).
+ */
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { gfmTable } from 'micromark-extension-gfm-table';
+import { gfmTaskListItem } from 'micromark-extension-gfm-task-list-item';
+import { gfmTableFromMarkdown, gfmTaskListItemFromMarkdown } from "./mdast-gfm.js";
+import { coerce } from "./coerce.js";
+import { parseMermaid } from "./mermaid.js";
+import { KNOWN_GLYPHS, STATUS_GLYPH, } from "./types.js";
+/** First line of an anchor: optional glyph, bold label, backticked id. */
+const ANCHOR_RE = /^\s*(?:(?<status>[^\s*`]+)\s+)?\*\*\s*Verified\s+(?<label>[A-Za-z][A-Za-z0-9 _-]*?)\s*:?\s*\*\*\s*:?\s*`(?<id>[^`]+)`\s*(?<rest>.*)$/u;
+/** A review blockquote: `> [glyph] **Reviewed:** `id``. Binds to no asset. */
+const REVIEW_RE = /^\s*(?:(?<status>[^\s*`]+)\s+)?\*\*\s*Reviewed\s*:?\s*\*\*\s*:?\s*`(?<id>[^`]+)`\s*(?<rest>.*)$/u;
+/** Subsequent lines: `**Key:** value`. */
+const META_RE = /^\s*\*\*\s*(?<key>[A-Za-z][A-Za-z0-9 _-]*?)\s*:?\s*\*\*\s*:?\s*(?<value>.*)$/u;
+/**
+ * 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 const SKIPPABLE_COMMENT_RE = /^<!--\s*(?:ERROR|REVIEW|verify)\b/i;
+/** Human labels -> the asset kind they bind to. */
+export const LABEL_KINDS = {
+    data: 'table',
+    table: 'table',
+    rows: 'table',
+    examples: 'table',
+    cases: 'table',
+    dataset: 'table',
+    matrix: 'table',
+    flow: 'mermaid',
+    diagram: 'mermaid',
+    graph: 'mermaid',
+    mermaid: 'mermaid',
+    flowchart: 'mermaid',
+    states: 'mermaid',
+    sequence: 'mermaid',
+    list: 'list',
+    steps: 'list',
+    rules: 'list',
+    checklist: 'list',
+    items: 'list',
+};
+/** Optional pointer to glue code: `<!-- verify: ./spec.verify.ts -->`. */
+const GLUE_HINT_RE = /<!--\s*verify(?:-glue)?:\s*(?<path>[^\s>]+?)\s*-->/i;
+export function parseMarkdown(source, file = '<memory>') {
+    const tree = fromMarkdown(source, {
+        extensions: [gfmTable(), gfmTaskListItem()],
+        mdastExtensions: [gfmTableFromMarkdown(), gfmTaskListItemFromMarkdown()],
+    });
+    const anchors = [];
+    const reviews = [];
+    const problems = [];
+    const children = tree.children;
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        if (node.type !== 'blockquote')
+            continue;
+        const lines = quoteLines(source, node);
+        // A review covers the section it sits in; it binds to no asset, so there
+        // is no lookahead to do.
+        const reviewHead = REVIEW_RE.exec(lines[0] ?? '');
+        if (reviewHead) {
+            reviews.push(buildReview(source, children, i, node, reviewHead, lines));
+            continue;
+        }
+        const head = ANCHOR_RE.exec(lines[0] ?? '');
+        if (!head)
+            continue;
+        const line = node.position.start.line;
+        const id = head.groups.id.trim();
+        const label = head.groups.label.trim();
+        const declared = LABEL_KINDS[label.toLowerCase()] ?? null;
+        const status = statusFromGlyph(head.groups.status);
+        const meta = parseMeta(lines.slice(1));
+        // Lookahead: the next block node, skipping comments we wrote ourselves.
+        let j = i + 1;
+        while (j < children.length && isManagedComment(children[j]))
+            j++;
+        const target = children[j];
+        if (!target) {
+            problems.push({ id, line, message: `anchor \`${id}\` has nothing after it to verify` });
+            continue;
+        }
+        const actual = kindOfNode(target);
+        if (!actual) {
+            problems.push({
+                id,
+                line,
+                message: `anchor \`${id}\` is followed by a ${describe(target)}; expected a table, a mermaid code block, or a list`,
+            });
+            continue;
+        }
+        if (declared && declared !== actual) {
+            problems.push({
+                id,
+                line,
+                message: `anchor \`${id}\` says "Verified ${label}" (a ${declared}) but the next block is a ${actual}`,
+            });
+            continue;
+        }
+        // An asset we cannot read is a *defect*, not a reason to drop the anchor:
+        // the anchor still binds, still fails, and still gets annotated, which is
+        // the whole point of writing state back into the document.
+        let data;
+        let defect = null;
+        try {
+            data = extract(source, target, actual, meta);
+        }
+        catch (err) {
+            defect = err.message;
+            data = emptyData(actual);
+        }
+        anchors.push({
+            id,
+            kind: actual,
+            label,
+            status,
+            meta,
+            defect,
+            data,
+            line,
+            quoteRange: { start: node.position.start.offset, end: node.position.end.offset },
+            targetRange: { start: target.position.start.offset, end: target.position.end.offset },
+            gapRange: { start: node.position.end.offset, end: target.position.start.offset },
+        });
+        i = j - 1; // resume scanning just before the bound target
+    }
+    return { file, source, tree, anchors, reviews, problems };
+}
+/**
+ * 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 function findGlueHint(source) {
+    const tree = fromMarkdown(source, {
+        extensions: [gfmTable(), gfmTaskListItem()],
+        mdastExtensions: [gfmTableFromMarkdown(), gfmTaskListItemFromMarkdown()],
+    });
+    let hint = null;
+    const walk = (node) => {
+        if (hint)
+            return;
+        if (node.type === 'html') {
+            const found = GLUE_HINT_RE.exec(node.value)?.groups?.path;
+            if (found) {
+                hint = found;
+                return;
+            }
+        }
+        for (const child of node.children ?? [])
+            walk(child);
+    };
+    walk(tree);
+    return hint;
+}
+// ---------------------------------------------------------------------------
+// extraction
+// ---------------------------------------------------------------------------
+function extract(source, node, kind, meta) {
+    if (kind === 'table')
+        return extractTable(source, node, meta);
+    if (kind === 'mermaid')
+        return parseMermaid(node.value ?? '');
+    return extractList(source, node);
+}
+function extractTable(source, node, meta) {
+    const rows = node.children ?? [];
+    if (rows.length === 0)
+        throw new Error('table has no header row');
+    const headers = (rows[0].children ?? []).map((cell) => cellText(source, cell));
+    const align = (node.align ?? []).map((a) => a === 'left' || a === 'right' || a === 'center' ? a : null);
+    const schema = meta.Schema ? parseSchema(meta.Schema) : null;
+    if (schema && schema.length !== headers.length) {
+        throw new Error(`schema declares ${schema.length} field(s) but the table has ${headers.length} column(s)`);
+    }
+    const dataRows = [];
+    const defects = [];
+    for (let r = 1; r < rows.length; r++) {
+        const cells = (rows[r].children ?? []).map((cell) => cellText(source, cell));
+        // GFM pads short rows and drops extra cells.
+        while (cells.length < headers.length)
+            cells.push('');
+        cells.length = headers.length;
+        const raw = {};
+        const row = {};
+        let failure = null;
+        headers.forEach((header, c) => {
+            const text = cells[c];
+            raw[header] = text;
+            const field = schema?.[c];
+            let value = text;
+            if (field) {
+                try {
+                    value = coerce(text, field.type, field.optional);
+                }
+                catch (err) {
+                    // Record the first bad cell and keep the raw text, so the row is
+                    // reported once rather than once per column.
+                    failure ??= `column ${JSON.stringify(header)}: ${err.message}`;
+                }
+            }
+            row[header] = value;
+            // Schema field names are aliases onto the same coerced value.
+            if (field && field.name !== header)
+                row[field.name] = value;
+        });
+        const line = rows[r].position?.start.line ?? 0;
+        if (failure) {
+            // A row we cannot trust never reaches a handler.
+            defects.push({ index: r - 1, line, message: failure });
+            continue;
+        }
+        define(row, '$index', r - 1);
+        define(row, '$line', line);
+        define(row, '$raw', Object.freeze(raw));
+        define(row, '$cells', Object.freeze(cells));
+        define(row, '$headers', Object.freeze([...headers]));
+        dataRows.push(row);
+    }
+    return { headers, align, rows: dataRows, defects, schema };
+}
+function extractList(source, node) {
+    const flat = [];
+    const walk = (list, depth) => (list.children ?? []).map((li, index) => {
+        const nested = (li.children ?? []).filter((c) => c.type === 'list');
+        const body = (li.children ?? []).filter((c) => c.type !== 'list');
+        const text = body
+            .map((c) => source.slice(c.position.start.offset, c.position.end.offset))
+            .join('\n')
+            .trim();
+        const item = {
+            text,
+            checked: typeof li.checked === 'boolean' ? li.checked : null,
+            depth,
+            index,
+            line: li.position?.start.line ?? 0,
+            children: nested.flatMap((n) => walk(n, depth + 1)),
+        };
+        flat.push(item);
+        return item;
+    });
+    const items = walk(node, 0);
+    // `flat` is built depth-first as a side effect; re-sort into document order.
+    flat.sort((a, b) => a.line - b.line);
+    return { ordered: Boolean(node.ordered), items, flat };
+}
+/** `[itemsTotal: Currency, tax: Percentage]` -> fields. */
+export function parseSchema(raw) {
+    let text = raw.trim().replace(/^`+|`+$/g, '').trim();
+    if (text.startsWith('[') && text.endsWith(']'))
+        text = text.slice(1, -1);
+    return splitTopLevel(text)
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const idx = part.indexOf(':');
+        if (idx === -1) {
+            throw new Error(`schema field ${JSON.stringify(part)} is missing a type (want "name: Type")`);
+        }
+        let name = part.slice(0, idx).trim();
+        const type = part.slice(idx + 1).trim();
+        const optional = name.endsWith('?');
+        if (optional)
+            name = name.slice(0, -1).trim();
+        if (!name)
+            throw new Error(`schema field ${JSON.stringify(part)} is missing a name`);
+        if (!type)
+            throw new Error(`schema field ${JSON.stringify(name)} is missing a type`);
+        return { name, type, optional };
+    });
+}
+/** Split on commas that are not nested inside brackets. */
+function splitTopLevel(text) {
+    const out = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of text) {
+        if ('[({<'.includes(ch))
+            depth++;
+        else if ('])}>'.includes(ch))
+            depth--;
+        if (ch === ',' && depth === 0) {
+            out.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    out.push(current);
+    return out;
+}
+function buildReview(source, children, index, node, head, lines) {
+    const meta = parseMeta(lines.slice(1));
+    const id = head.groups.id.trim();
+    let covers = [];
+    let defect = null;
+    try {
+        covers = parseCovers(meta.Covers ?? '');
+        if (covers.length === 0) {
+            defect = `review \`${id}\` declares no **Covers:** targets, so there is nothing to go stale against`;
+        }
+    }
+    catch (err) {
+        defect = `review \`${id}\`: ${err.message}`;
+    }
+    // Error comments go between the review and whatever follows it.
+    let j = index + 1;
+    while (j < children.length && isManagedComment(children[j]))
+        j++;
+    const gapEnd = children[j]?.position?.start.offset ?? source.length;
+    return {
+        id,
+        status: statusFromGlyph(head.groups.status),
+        covers,
+        digest: meta.Digest ? meta.Digest.replace(/`/g, '').trim() || null : null,
+        defect,
+        meta,
+        line: node.position.start.line,
+        quoteRange: { start: node.position.start.offset, end: node.position.end.offset },
+        gapRange: { start: node.position.end.offset, end: gapEnd },
+    };
+}
+/** `` `./a.ts#x`, `./b.ts` `` -> targets. */
+export function parseCovers(raw) {
+    return splitTopLevel(raw.replace(/`/g, ''))
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+/** A safe placeholder for an anchor whose asset could not be read. */
+function emptyData(kind) {
+    if (kind === 'table')
+        return { headers: [], align: [], rows: [], defects: [], schema: null };
+    if (kind === 'list')
+        return { ordered: false, items: [], flat: [] };
+    return parseMermaid('');
+}
+// ---------------------------------------------------------------------------
+// small helpers
+// ---------------------------------------------------------------------------
+/** Blockquote source with the `>` markers stripped, one entry per line. */
+function quoteLines(source, node) {
+    const raw = source.slice(node.position.start.offset, node.position.end.offset);
+    return raw.split('\n').map((l) => l.replace(/^\s*>\s?/, ''));
+}
+function parseMeta(lines) {
+    const meta = {};
+    for (const line of lines) {
+        const m = META_RE.exec(line);
+        if (!m)
+            continue;
+        meta[m.groups.key.trim()] = m.groups.value.trim();
+    }
+    return meta;
+}
+function statusFromGlyph(glyph) {
+    if (!glyph)
+        return 'pending';
+    const bare = glyph.replace(/️/g, '');
+    for (const [status, g] of Object.entries(STATUS_GLYPH)) {
+        if (g.replace(/️/g, '') === bare)
+            return status;
+    }
+    return 'pending';
+}
+function isManagedComment(node) {
+    return node.type === 'html' && SKIPPABLE_COMMENT_RE.test(node.value.trim());
+}
+function kindOfNode(node) {
+    if (node.type === 'table')
+        return 'table';
+    if (node.type === 'list')
+        return 'list';
+    if (node.type === 'code' && (node.lang ?? '').toLowerCase() === 'mermaid')
+        return 'mermaid';
+    return null;
+}
+function describe(node) {
+    if (node.type === 'code')
+        return `${node.lang ?? 'plain'} code block`;
+    return `${node.type} block`;
+}
+function cellText(source, cell) {
+    const start = cell?.position?.start?.offset;
+    const end = cell?.position?.end?.offset;
+    if (typeof start !== 'number' || typeof end !== 'number')
+        return '';
+    // Cell tokens span their delimiters; strip the outer pipes but leave any
+    // escaped `\|` inside the content alone.
+    let text = source.slice(start, end);
+    if (text.startsWith('|'))
+        text = text.slice(1);
+    if (text.endsWith('|') && !text.endsWith('\\|'))
+        text = text.slice(0, -1);
+    return text.trim();
+}
+/** Attach `$`-prefixed metadata without polluting `Object.keys(row)`. */
+function define(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: false, writable: false });
+}
+export { KNOWN_GLYPHS };

package/dist/src/references.d.ts

@@ -0,0 +1,33 @@
+import type { Root } from 'mdast';
+import type { ParseProblem, ParseResult } from './types.ts';
+/** A link, image, or link definition found in the prose. */
+export interface Reference {
+    kind: 'link' | 'image' | 'definition';
+    /** The URL exactly as written, or the identifier for a shorthand reference. */
+    url: string;
+    /** Path portion, decoded. `null` for in-document and shorthand references. */
+    target: string | null;
+    /** Fragment after `#`, decoded. */
+    fragment: string | null;
+    line: number;
+    column: number;
+}
+export interface ReferenceOptions {
+    /**
+     * Check that fragment-linked symbols exist. On by default. Modules are read,
+     * never imported, so nothing in the checked project is executed.
+     */
+    symbols?: boolean;
+}
+/** Collect every reference in a document, in source order. */
+export declare function collectReferences(tree: Root): Reference[];
+/**
+ * Check every reference in a parsed document. Returns diagnostics in the same
+ * shape as parse problems, so they flow through the runner unchanged.
+ */
+export declare function checkReferences(parsed: ParseResult, options?: ReferenceOptions): Promise<ParseProblem[]>;
+/** Forget cached lookups. Tests that write fixtures on the fly need this. */
+export declare function clearReferenceCache(): void;
+/** GitHub-compatible heading slugs, including its `-1` disambiguation. */
+export declare function headingSlugs(tree: Root): Set<string>;
+export declare function slugify(text: string): string;

package/dist/src/references.js

@@ -0,0 +1,198 @@
+/**
+ * Referential integrity for the prose around the anchors.
+ *
+ * Anchors verify the *assets* in a document. This pass verifies its
+ * *references*: links to files that have been moved, in-document anchors that
+ * no longer resolve, and -- where the author asks for it with a fragment --
+ * symbols that no longer exist.
+ *
+ * It deliberately checks nothing implicit. A document opts in by linking; bare
+ * inline code is never treated as a symbol, because `$10.00`, `--write` and
+ * `[itemsTotal: Currency]` are all inline code in a perfectly healthy spec.
+ */
+import { dirname, extname, resolve as resolvePath } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { clearSymbolCache, exportedNames } from "./symbols.js";
+/** File extensions we are willing to import to enumerate exports. */
+const MODULE_EXTS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+/** Extensions we can read headings out of. */
+const MARKDOWN_EXTS = new Set(['.md', '.markdown', '.mdx']);
+/** Collect every reference in a document, in source order. */
+export function collectReferences(tree) {
+    const found = [];
+    // `linkReference` nodes are not collected: their target is the `definition`
+    // they resolve to, which is checked directly. A reference with no definition
+    // never becomes a node at all -- CommonMark leaves it as literal text -- so
+    // there is nothing in the tree to flag.
+    walk(tree, (node) => {
+        if (node.type === 'link' || node.type === 'image' || node.type === 'definition') {
+            found.push({ ...split(node.url), kind: node.type, ...at(node) });
+        }
+    });
+    return found;
+}
+/**
+ * Check every reference in a parsed document. Returns diagnostics in the same
+ * shape as parse problems, so they flow through the runner unchanged.
+ */
+export async function checkReferences(parsed, options = {}) {
+    const docPath = resolvePath(parsed.file);
+    // An in-memory document has no directory to resolve relative links against.
+    if (!existsSync(docPath))
+        return [];
+    const dir = dirname(docPath);
+    const problems = [];
+    const headings = headingSlugs(parsed.tree);
+    const report = (ref, message) => problems.push({ id: null, line: ref.line, column: ref.column, message });
+    for (const ref of collectReferences(parsed.tree)) {
+        if (isExternal(ref.url))
+            continue;
+        // A bare `#fragment` points inside this document.
+        if (ref.target === null || ref.target === '') {
+            if (ref.fragment && !headings.has(ref.fragment)) {
+                report(ref, `broken anchor: #${ref.fragment}${suggest(ref.fragment, [...headings])}`);
+            }
+            continue;
+        }
+        const targetPath = resolvePath(dir, ref.target);
+        if (!existsSync(targetPath)) {
+            report(ref, `broken link: ${ref.url} (no such file)`);
+            continue;
+        }
+        if (!ref.fragment)
+            continue;
+        const ext = extname(targetPath).toLowerCase();
+        if (MARKDOWN_EXTS.has(ext)) {
+            const slugs = await markdownSlugs(targetPath);
+            if (slugs && !slugs.has(ref.fragment)) {
+                report(ref, `broken anchor: ${ref.url} (no such heading)${suggest(ref.fragment, [...slugs])}`);
+            }
+            continue;
+        }
+        if (MODULE_EXTS.has(ext) && options.symbols !== false) {
+            const exports = exportedNames(targetPath);
+            if (exports instanceof Error) {
+                report(ref, `could not read ${ref.target}: ${exports.message}`);
+            }
+            else if (!exports.has(ref.fragment)) {
+                report(ref, `broken symbol: ${ref.url} (no export named \`${ref.fragment}\`)${suggest(ref.fragment, [...exports])}`);
+            }
+        }
+    }
+    return problems;
+}
+// ---------------------------------------------------------------------------
+// resolution
+// ---------------------------------------------------------------------------
+const slugCache = new Map();
+async function markdownSlugs(path) {
+    const cached = slugCache.get(path);
+    if (cached !== undefined)
+        return cached;
+    let slugs = null;
+    try {
+        // Imported lazily: only documents that are actually anchor-linked are read.
+        const { parseMarkdown } = await import("./parser.js");
+        slugs = headingSlugs(parseMarkdown(await readFile(path, 'utf8'), path).tree);
+    }
+    catch {
+        slugs = null;
+    }
+    slugCache.set(path, slugs);
+    return slugs;
+}
+/** Forget cached lookups. Tests that write fixtures on the fly need this. */
+export function clearReferenceCache() {
+    slugCache.clear();
+    clearSymbolCache();
+}
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+function walk(node, visit) {
+    visit(node);
+    for (const child of node.children ?? [])
+        walk(child, visit);
+}
+function at(node) {
+    return { line: node.position?.start.line ?? 0, column: node.position?.start.column ?? 0 };
+}
+function isExternal(url) {
+    return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith('//');
+}
+function split(url) {
+    const hash = url.indexOf('#');
+    if (hash === -1)
+        return { url, target: decode(url), fragment: null };
+    return {
+        url,
+        target: hash === 0 ? null : decode(url.slice(0, hash)),
+        fragment: decode(url.slice(hash + 1)),
+    };
+}
+function decode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+/** GitHub-compatible heading slugs, including its `-1` disambiguation. */
+export function headingSlugs(tree) {
+    const slugs = new Set();
+    const seen = new Map();
+    walk(tree, (node) => {
+        if (node.type !== 'heading')
+            return;
+        const base = slugify(textOf(node));
+        if (!base)
+            return;
+        const n = seen.get(base) ?? 0;
+        seen.set(base, n + 1);
+        slugs.add(n === 0 ? base : `${base}-${n}`);
+    });
+    return slugs;
+}
+export function slugify(text) {
+    return text
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s_-]/gu, '')
+        .replace(/\s/g, '-');
+}
+function textOf(node) {
+    let out = '';
+    walk(node, (n) => {
+        if (n.type === 'text' || n.type === 'inlineCode')
+            out += n.value;
+    });
+    return out;
+}
+/** " (did you mean `x`?)" when something close enough exists. */
+function suggest(needle, haystack) {
+    let best = null;
+    let bestScore = Infinity;
+    for (const candidate of haystack) {
+        const score = distance(needle.toLowerCase(), candidate.toLowerCase());
+        if (score < bestScore) {
+            bestScore = score;
+            best = candidate;
+        }
+    }
+    // Close enough to be a typo rather than a different thing entirely.
+    const limit = Math.max(2, Math.floor(needle.length / 3));
+    return best && bestScore <= limit ? ` (did you mean \`${best}\`?)` : '';
+}
+function distance(a, b) {
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const row = [i];
+        for (let j = 1; j <= b.length; j++) {
+            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = row;
+    }
+    return prev[b.length];
+}