@tabnas/markdown 0.4.2 → 0.5.1

package/README.md

@@ -1,6 +1,17 @@
 # @tabnas/markdown (TypeScript)
 
-A [Tabnas](https://github.com/tabnas/parser) grammar plugin that parses **CommonMark / GFM Markdown** into a JSON AST. Built on the bare `@tabnas/parser` engine.
+A CommonMark parser for the [Tabnas](https://github.com/tabnas/parser) engine.
+
+**This parser is conformant to CommonMark 0.31.2** — all 652 examples, across all 26
+sections of the spec suite, in both runtimes. The suite is vendored in this repository, so
+the claim is checkable: `npm run conformance` reports 652/652, with no build step and no
+engine installed. It runs with the GFM extensions off, which is what measuring CommonMark
+conformance means — with `gfm: true` the extensions deliberately change nine of those
+examples. It also implements **all five GFM extensions** — tables, task list
+items, autolink literals, strikethrough and disallowed raw HTML — 24/24 on the vendored
+GFM corpus, via `npm run conformance-gfm`.
+
+This is the canonical implementation; [`go/`](../go/README.md) is a port of it.
 
 [![npm version](https://img.shields.io/npm/v/@tabnas/markdown.svg)](https://npmjs.com/package/@tabnas/markdown)
 [![build](https://github.com/tabnas/markdown/actions/workflows/build.yml/badge.svg)](https://github.com/tabnas/markdown/actions/workflows/build.yml)
@@ -8,6 +19,78 @@ A [Tabnas](https://github.com/tabnas/parser) grammar plugin that parses **Common
 | ![Voxgig](https://www.voxgig.com/res/img/vgt01r.png) | This open source module is sponsored and supported by [Voxgig](https://www.voxgig.com). |
 | ---------------------------------------------------- | --------------------------------------------------------------------------------------- |
 
+## Two outputs
+
+**The AST is the primary output.** `parseDocument()` returns it directly; the renderer
+does not run.
+
+```js
+import { parseDocument } from '@tabnas/markdown'
+
+const doc = parseDocument('# Hello\n\nHello *world*')
+
+doc.children[0] // => { type: 'heading', depth: 1, children: [ { type: 'text', value: 'Hello' } ] }
+doc.children[1] // => { type: 'paragraph', children: [ { type: 'text', value: 'Hello ' }, { type: 'emphasis', children: [ { type: 'text', value: 'world' } ] } ] }
+```
+
+**HTML is available, on request, via `toHtml()`.** The CommonMark suite scores HTML
+output, so the renderer is what makes the 652/652 claim measurable; that it is useful to
+callers is a consequence.
+
+```js
+import { toHtml } from '@tabnas/markdown'
+
+toHtml('# Hello\n\nHello *world*') // => '<h1>Hello</h1>\n<p>Hello <em>world</em></p>\n'
+```
+
+**The HTML is not sanitized.** Raw HTML blocks and inline tags pass through verbatim, as
+CommonMark specifies. Put a sanitizer downstream of any untrusted Markdown.
+
+```js
+import { toHtml } from '@tabnas/markdown'
+
+toHtml('<img onerror="alert(1)">') // => '<img onerror="alert(1)">\n'
+```
+
+GFM's disallowed-raw-HTML filter (on with `gfm`, the default) rewrites the leading `<` of
+nine tag names — `title`, `textarea`, `style`, `xmp`, `iframe`, `noembed`, `noframes`,
+`script`, `plaintext` — and touches nothing else:
+
+```js
+import { toHtml } from '@tabnas/markdown'
+
+toHtml('<script>alert(1)</script>') // => '&lt;script>alert(1)&lt;/script>\n'
+```
+
+As a Tabnas plugin, `parse()` returns the same AST as `parseDocument()`:
+
+```js
+import { Tabnas } from '@tabnas/parser'
+import { Markdown } from '@tabnas/markdown'
+
+const tn = new Tabnas().use(Markdown)
+
+tn.parse('# Hello') // => { type: 'document', children: [ { type: 'heading', depth: 1, children: [ { type: 'text', value: 'Hello' } ] } ] }
+```
+
+`parseTree()` returns the native CommonMark node tree instead — it keeps `sourcepos` on
+block nodes, and can be walked or mutated and then rendered. See the
+[reference](doc/reference.md).
+
+GFM tables add three node types, in mdast's shape — `table`, `tableRow` and `tableCell`.
+`align` has one entry per column, `null` where the delimiter cell had no colon; there is
+no header flag, so the first row is the header row by convention, and every row has
+exactly as many cells as `align` has entries.
+
+```js
+import { parseDocument } from '@tabnas/markdown'
+
+const doc = parseDocument('| a | b |\n| :- | -: |\n| 1 | 2 |')
+
+doc.children[0].align // => [ 'left', 'right' ]
+doc.children[0].children[0].children[0] // => { type: 'tableCell', children: [ { type: 'text', value: 'a' } ] }
+```
+
 ## Install
 
 ```bash
@@ -16,21 +99,59 @@ npm install @tabnas/markdown @tabnas/parser
 
 `@tabnas/parser` (>=0) is the only peer dependency. Requires Node >=24.
 
-## Example
+## Specific to this runtime
+
+The parser is **engine-free**: nothing under `src/commonmark.ts` imports `@tabnas/parser`.
+Only `src/markdown.ts`, the plugin wiring, does. That is what lets the conformance runner
+work with no build step and no engine installed — it stages `src/*.ts` in a temp directory
+whose `package.json` says `"type": "module"` and runs them under Node's type stripping:
+
+```bash
+npm run conformance              # 652/652, all 26 sections
+npm run conformance -- --failures
+npm run conformance-gfm          # 24/24, all five extensions
+```
+
+The `// =>` assertions in this repo's Markdown are executed as tests
+(`test/doc-examples.test.ts`, and `tools/check-doc-examples.mjs` for the engine-free
+check), so a wrong expected value is a failing test.
+
+Options are `gfm` (default `true`) and `breaks` (default `false`). `gfm` gates five
+extensions together — tables, strikethrough, task list items, autolink literals (bare
+`www.` / `https://` / `a@b.co`) and the disallowed-raw-HTML filter. Footnotes are not
+implemented. With `gfm:false` the output is plain CommonMark.
+
+Footnotes are a GitHub product feature rather than part of the GFM spec suite, and their
+absence is quiet: `[^1]` is a valid CommonMark link label, so a footnote authored on
+GitHub renders as a broken link instead of raising an error.
 
 ```js
-import { Tabnas } from '@tabnas/parser'
-import { Markdown } from '@tabnas/markdown'
+import { toHtml } from '@tabnas/markdown'
 
-const j = new Tabnas().use(Markdown)
+toHtml('Text[^1]\n\n[^1]: note') // => '<p>Text<a href="note">^1</a></p>\n'
+```
 
-j.parse('# Hello\n\nHello *world*') // => { type: 'document', children: [{ type: 'heading', depth: 1, children: [{ type: 'text', value: 'Hello' }] }, { type: 'paragraph', children: [{ type: 'text', value: 'Hello ' }, { type: 'emphasis', children: [{ type: 'text', value: 'world' }] }] }] }
-j.parse('# Hello') // => { type: 'document', children: [{ type: 'heading', depth: 1, children: [{ type: 'text', value: 'Hello' }] }] }
+Nothing outside CommonMark and GFM is implemented — no math, front matter, definition
+lists, heading attributes, admonitions, wiki links, emoji shortcodes, highlight or
+sub/superscript. Each would need its own opt-in flag; `gfm` is not going to grow to mean
+"everything". Note one collision: GFM's single-tilde strikethrough takes the syntax other
+dialects use for subscript, so `H~2~O` is a deletion under the default `gfm:true`.
+
+```js
+import { toHtml } from '@tabnas/markdown'
+
+toHtml('H~2~O') // => '<p>H<del>2</del>O</p>\n'
 ```
 
 ## Documentation
 
-- [Tutorial](doc/tutorial.md) — first parse in 5 minutes.
+- [Tutorial](doc/tutorial.md) — first parse, start to finish.
 - [How-to guide](doc/guide.md) — task recipes.
-- [Reference](doc/reference.md) — API + options + AST.
-- [Concepts](doc/concepts.md) — how it works.
+- [Reference](doc/reference.md) — API, options, AST node types.
+- [Concepts](doc/concepts.md) — how it works, and why.
+
+Top-level [README](../README.md) · Go port: [go/README.md](../go/README.md).
+
+## License
+
+MIT. Copyright (c) Richard Rodger and other contributors.

package/dist/ast.d.ts

@@ -0,0 +1,113 @@
+import { MdNode } from './node.ts';
+import type { TableAlign } from './node.ts';
+import type { ParserOptions } from './options.ts';
+export type DocumentNode = {
+    type: 'document';
+    children: Block[];
+};
+export type Block = HeadingNode | ParagraphNode | BlockquoteNode | ListNode | ListItemNode | CodeNode | HtmlNode | ThematicBreakNode | TableNode;
+export type HeadingNode = {
+    type: 'heading';
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    children: Inline[];
+};
+export type ParagraphNode = {
+    type: 'paragraph';
+    children: Inline[];
+};
+export type BlockquoteNode = {
+    type: 'blockquote';
+    children: Block[];
+};
+export type ListNode = {
+    type: 'list';
+    ordered: boolean;
+    start: number | null;
+    spread: boolean;
+    children: ListItemNode[];
+};
+export type ListItemNode = {
+    type: 'listItem';
+    spread: boolean;
+    /**
+     * mdast's task list field: `true`/`false` for a GFM task list item
+     * (`- [x] foo`), `null` for an ordinary item — and therefore `null`
+     * everywhere when `gfm` is off.
+     */
+    checked: boolean | null;
+    children: Block[];
+};
+export type CodeNode = {
+    type: 'code';
+    lang: string | null;
+    meta: string | null;
+    value: string;
+};
+export type HtmlNode = {
+    type: 'html';
+    value: string;
+};
+export type ThematicBreakNode = {
+    type: 'thematicBreak';
+};
+/**
+ * A GFM table, in mdast's shape.
+ *
+ * `align` has one entry per column — `null` where the delimiter row gave no
+ * colon — and every row has exactly that many cells, since the block phase
+ * pads short rows and truncates long ones.
+ *
+ * mdast has no header flag: the **first** row is the header row, by
+ * convention, and this projection preserves that ordering from the tree.
+ */
+export type TableNode = {
+    type: 'table';
+    align: TableAlign[];
+    children: TableRowNode[];
+};
+export type TableRowNode = {
+    type: 'tableRow';
+    children: TableCellNode[];
+};
+export type TableCellNode = {
+    type: 'tableCell';
+    children: Inline[];
+};
+export type Inline = TextNode | EmphasisNode | StrongNode | InlineCodeNode | LinkNode | ImageNode | BreakNode | DeleteNode | HtmlNode;
+export type TextNode = {
+    type: 'text';
+    value: string;
+};
+export type EmphasisNode = {
+    type: 'emphasis';
+    children: Inline[];
+};
+export type StrongNode = {
+    type: 'strong';
+    children: Inline[];
+};
+export type InlineCodeNode = {
+    type: 'inlineCode';
+    value: string;
+};
+export type LinkNode = {
+    type: 'link';
+    url: string;
+    title: string | null;
+    children: Inline[];
+};
+export type ImageNode = {
+    type: 'image';
+    url: string;
+    title: string | null;
+    alt: string;
+};
+export type BreakNode = {
+    type: 'break';
+};
+export type DeleteNode = {
+    type: 'delete';
+    children: Inline[];
+};
+/** Project a parsed native tree into the public JSON AST. */
+export declare function toAst(doc: MdNode, opts: ParserOptions): DocumentNode;

package/dist/ast.js

@@ -0,0 +1,273 @@
+"use strict";
+/* Copyright (c) 2021-2026 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAst = toAst;
+/** Plain-text flattening of an image's inline children, for `alt`. */
+function collectAltText(node) {
+    let out = '';
+    let child = node.firstChild;
+    while (child) {
+        if ('text' === child.type || 'code' === child.type || 'html_inline' === child.type) {
+            out += child.literal ?? '';
+        }
+        else if ('softbreak' === child.type || 'linebreak' === child.type) {
+            out += '\n';
+        }
+        else {
+            out += collectAltText(child);
+        }
+        child = child.next;
+    }
+    return out;
+}
+/**
+ * mdast semantics: an item is spread when two of its children are separated by
+ * a *blank line* — not merely when it has more than one child. `- a\n  - b`
+ * holds a paragraph and a nested list with no blank line between them, and is
+ * not spread; `- a\n\n  - b` is.
+ *
+ * Derived from the block parser's `sourcepos` rather than tracked separately:
+ * consecutive children whose line ranges are not adjacent must have had a
+ * blank line between them.
+ */
+function itemIsSpread(item) {
+    let child = item.firstChild;
+    while (child && child.next) {
+        const endLine = child.sourcepos[1][0];
+        const nextStartLine = child.next.sourcepos[0][0];
+        if (nextStartLine > endLine + 1)
+            return true;
+        child = child.next;
+    }
+    return false;
+}
+function inlineChildren(node, opts) {
+    const out = [];
+    const pushText = (value) => {
+        if ('' === value)
+            return;
+        const last = out[out.length - 1];
+        if (last && 'text' === last.type)
+            last.value += value;
+        else
+            out.push({ type: 'text', value });
+    };
+    let child = node.firstChild;
+    while (child) {
+        switch (child.type) {
+            case 'text':
+                pushText(child.literal ?? '');
+                break;
+            case 'softbreak':
+                // Documented behaviour: a soft break reads as a space in the AST.
+                if (opts.breaks)
+                    out.push({ type: 'break' });
+                else
+                    pushText(' ');
+                break;
+            case 'linebreak':
+                out.push({ type: 'break' });
+                break;
+            case 'code':
+                out.push({ type: 'inlineCode', value: child.literal ?? '' });
+                break;
+            case 'html_inline':
+                out.push({ type: 'html', value: child.literal ?? '' });
+                break;
+            case 'emph':
+                out.push({ type: 'emphasis', children: inlineChildren(child, opts) });
+                break;
+            case 'strong':
+                out.push({ type: 'strong', children: inlineChildren(child, opts) });
+                break;
+            case 'del':
+                out.push({ type: 'delete', children: inlineChildren(child, opts) });
+                break;
+            case 'link':
+                out.push({
+                    type: 'link',
+                    url: child.destination ?? '',
+                    title: child.title ?? null,
+                    children: inlineChildren(child, opts),
+                });
+                break;
+            case 'image':
+                out.push({
+                    type: 'image',
+                    url: child.destination ?? '',
+                    title: child.title ?? null,
+                    alt: collectAltText(child),
+                });
+                break;
+            default:
+                // A block node cannot appear here in a well-formed tree; skipping is
+                // safer than emitting a node the published types do not allow.
+                break;
+        }
+        child = child.next;
+    }
+    return out;
+}
+/** Containers whose children are blocks rather than inlines. */
+const BLOCK_CONTAINERS = {
+    document: true,
+    block_quote: true,
+    list: true,
+    item: true,
+};
+/**
+ * Project a container's block children.
+ *
+ * Iterative rather than recursive, because the recursion depth here is the
+ * document's container nesting depth, which untrusted input controls directly:
+ * `'> '.repeat(4000)` is 8 KB of Markdown that the block parser and the HTML
+ * renderer both handle, but that overflowed the stack in this projection —
+ * crashing the package's primary API on input the rest of the pipeline
+ * survives.
+ *
+ * Two passes. The first walks the block tree with an explicit stack, recording
+ * nodes in an order where every parent precedes its descendants. Building in
+ * reverse then guarantees a node's children are already built when it is
+ * reached, so `buildBlock` can look them up instead of recursing.
+ *
+ * The Go port keeps the recursive form: goroutine stacks grow on demand and it
+ * projects 100k-deep nesting without trouble, so the same defect does not
+ * arise there.
+ */
+function blockChildren(node, opts) {
+    const order = [];
+    const stack = [];
+    for (let c = node.lastChild; c; c = c.prev)
+        stack.push(c);
+    while (0 < stack.length) {
+        const n = stack.pop();
+        order.push(n);
+        if (true === BLOCK_CONTAINERS[n.type]) {
+            for (let c = n.lastChild; c; c = c.prev)
+                stack.push(c);
+        }
+    }
+    const built = new Map();
+    for (let i = order.length - 1; 0 <= i; i--) {
+        const n = order[i];
+        const block = buildBlock(n, opts, built);
+        if (null !== block)
+            built.set(n, block);
+    }
+    const out = [];
+    for (let c = node.firstChild; c; c = c.next) {
+        const b = built.get(c);
+        if (undefined !== b)
+            out.push(b);
+    }
+    return out;
+}
+/** Children of `n` that have already been built, in source order. */
+function builtChildren(n, built) {
+    const out = [];
+    for (let c = n.firstChild; c; c = c.next) {
+        const b = built.get(c);
+        if (undefined !== b)
+            out.push(b);
+    }
+    return out;
+}
+function buildBlock(node, opts, built) {
+    switch (node.type) {
+        case 'paragraph':
+            return { type: 'paragraph', children: inlineChildren(node, opts) };
+        case 'heading':
+            return {
+                type: 'heading',
+                depth: node.level,
+                children: inlineChildren(node, opts),
+            };
+        case 'thematic_break':
+            return { type: 'thematicBreak' };
+        case 'block_quote':
+            return { type: 'blockquote', children: builtChildren(node, built) };
+        case 'code_block': {
+            const info = (node.info ?? '').trim();
+            let lang = null;
+            let meta = null;
+            if ('' !== info) {
+                const sp = info.search(/\s/);
+                if (-1 === sp) {
+                    lang = info;
+                }
+                else {
+                    lang = info.slice(0, sp);
+                    meta = info.slice(sp + 1).trim() || null;
+                }
+            }
+            // The native tree keeps the trailing newline because the spec's HTML
+            // for `<pre><code>` includes it; mdast's `code.value` does not. Strip
+            // exactly one, not all, so a block that genuinely ends in a blank line
+            // keeps it.
+            const raw = node.literal ?? '';
+            const value = raw.endsWith('\n') ? raw.slice(0, -1) : raw;
+            return { type: 'code', lang, meta, value };
+        }
+        case 'html_block':
+            return { type: 'html', value: node.literal ?? '' };
+        case 'table': {
+            // Built here rather than through `built`, because a table's children are
+            // rows and cells rather than blocks — `blockChildren` never descends
+            // into one. The nesting is a fixed three levels deep, so unlike the
+            // block containers this cannot be driven past the stack by input.
+            const rows = [];
+            for (let row = node.firstChild; row; row = row.next) {
+                if ('table_row' !== row.type)
+                    continue;
+                const cells = [];
+                for (let cell = row.firstChild; cell; cell = cell.next) {
+                    if ('table_cell' !== cell.type)
+                        continue;
+                    cells.push({ type: 'tableCell', children: inlineChildren(cell, opts) });
+                }
+                rows.push({ type: 'tableRow', children: cells });
+            }
+            return { type: 'table', align: node.tableAlign ?? [], children: rows };
+        }
+        case 'list': {
+            const data = node.listData;
+            const ordered = 'ordered' === data?.type;
+            const items = [];
+            let child = node.firstChild;
+            while (child) {
+                if ('item' === child.type) {
+                    items.push({
+                        type: 'listItem',
+                        spread: itemIsSpread(child),
+                        checked: child.checked,
+                        children: builtChildren(child, built),
+                    });
+                }
+                child = child.next;
+            }
+            return {
+                type: 'list',
+                ordered,
+                start: ordered ? (data?.start ?? 1) : null,
+                spread: !(data?.tight ?? true),
+                children: items,
+            };
+        }
+        case 'item':
+            // Only reachable if an item is somehow detached from its list; a list
+            // builds its own items above.
+            return {
+                type: 'listItem',
+                spread: itemIsSpread(node),
+                checked: node.checked,
+                children: builtChildren(node, built),
+            };
+        default:
+            return null;
+    }
+}
+/** Project a parsed native tree into the public JSON AST. */
+function toAst(doc, opts) {
+    return { type: 'document', children: blockChildren(doc, opts) };
+}
+//# sourceMappingURL=ast.js.map

package/dist/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"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"}

package/dist/block.d.ts

@@ -0,0 +1,10 @@
+import { MdNode } from './node.ts';
+import type { ParserOptions, RefMap } from './options.ts';
+/**
+ * Phase 1: build the block tree and collect link reference definitions.
+ * Paragraph and heading text is left raw in `stringContent` for phase 2.
+ */
+export declare function parseBlocks(input: string, options: ParserOptions): {
+    doc: MdNode;
+    refmap: RefMap;
+};