tarsec 0.4.6 → 0.5.0

package/dist/parsers/bash/lists.js

@@ -0,0 +1,85 @@
+/** Pipelines, `&&`/`||` chains, and command lists.
+ *
+ * The core fail-closed rule lives here: commands are SEPARATED by `;`,
+ * `&`, or newline. A construct that stops early leaves text no separator
+ * precedes, which fails the enclosing parse instead of becoming a
+ * phantom second command (the way `files=(a b c)` would otherwise parse
+ * as an assignment followed by a subshell). */
+import { lazy, many, optional, or, seq } from "../../combinators.js";
+import { trace } from "../../trace.js";
+import { bangToken, bashLexemes, linebreak, newlineToken, } from "./lexemes.js";
+import { commandParser as commandParserImport } from "./commands.js";
+const L = bashLexemes;
+// Deferred to parse time: see the module-cycle note in commands.ts.
+const commandParser = lazy(() => commandParserImport);
+const pipeOperator = seq([or(L.operator("|&"), L.operator("|")), linebreak], (results) => results[0]);
+// Explicit seq/many instead of sepBy1: `echo hi |` must FAIL, not parse
+// as `echo hi` with the `|` silently swallowed.
+const pipelineParser = seq([
+    optional(bangToken),
+    commandParser,
+    many(seq([pipeOperator, commandParser], (results) => results[1])),
+], (results) => ({
+    tag: "pipeline",
+    negated: results[0] !== null,
+    commands: [results[1], ...results[2]],
+}));
+const andOrTail = seq([or(L.operator("&&"), L.operator("||")), linebreak, pipelineParser], (results) => ({
+    op: results[0],
+    pipeline: results[2],
+}));
+const andOrParser = seq([pipelineParser, many(andOrTail)], (results) => ({
+    tag: "andOr",
+    first: results[0],
+    rest: results[1],
+}));
+const itemSeparator = or(seq([L.operator("&"), linebreak], () => ({ background: true })), seq([L.operator(";"), linebreak], () => ({ background: false })), seq([newlineToken, linebreak], () => ({ background: false })));
+const listBody = seq([
+    andOrParser,
+    many(seq([itemSeparator, andOrParser], (results) => ({
+        separator: results[0],
+        command: results[1],
+    }))),
+    optional(itemSeparator),
+], (results) => {
+    const pairs = results[1];
+    const trailing = results[2];
+    const commands = [results[0], ...pairs.map((pair) => pair.command)];
+    // Separator i follows command i and carries its `&` marker.
+    const separators = [
+        ...pairs.map((pair) => pair.separator),
+        trailing,
+    ];
+    const items = commands.map((command, index) => {
+        var _a;
+        return ({
+            tag: "listItem",
+            command,
+            background: ((_a = separators[index]) === null || _a === void 0 ? void 0 : _a.background) === true,
+        });
+    });
+    return {
+        list: { tag: "list", items },
+        endedWithSeparator: trailing !== null,
+    };
+});
+const EMPTY_LIST = { tag: "list", items: [] };
+const list0Impl = trace("bash:list0", seq([L.whitespace, linebreak, optional(listBody)], (results) => { var _a, _b; return (_b = (_a = results[2]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : EMPTY_LIST; }));
+const list1Impl = trace("bash:list1", seq([L.whitespace, linebreak, listBody], (results) => results[2].list));
+const list1WithEndImpl = seq([L.whitespace, linebreak, listBody], (results) => results[2]);
+/** A possibly-empty command list. Empty lists are only legal where bash
+ * allows them: the top level, `$()`, and case-item bodies. Declared as a
+ * function so the words/lists/commands module cycle is safe under any
+ * import order. */
+export function list0(input) {
+    return list0Impl(input);
+}
+/** A command list with at least one command — the body of every compound
+ * command, subshell, and group. */
+export function list1(input) {
+    return list1Impl(input);
+}
+/** `list1`, but also reporting whether it ended with a separator. */
+export function list1WithEnd(input) {
+    return list1WithEndImpl(input);
+}

package/dist/parsers/bash/types.d.ts

@@ -0,0 +1,136 @@
+/** AST types for the bash parser. See `index.ts` for the supported subset. */
+/** One piece of a word. Adjacent parts concatenate: `e'f'"g"$h` is a single
+ * word of four parts. */
+export type WordPart = {
+    tag: "literal";
+    text: string;
+} | {
+    tag: "singleQuoted";
+    text: string;
+} | {
+    tag: "doubleQuoted";
+    parts: WordPart[];
+} | {
+    tag: "variable";
+    name: string;
+} | {
+    tag: "paramExpansion";
+    expression: string;
+} | {
+    tag: "commandSubstitution";
+    command: List;
+} | {
+    tag: "arithmeticExpansion";
+    expression: string;
+};
+export type BashWord = {
+    tag: "word";
+    parts: WordPart[];
+};
+/** `name=value` (or `name=` with a null value) before a command. */
+export type Assignment = {
+    tag: "assignment";
+    name: string;
+    value: BashWord | null;
+};
+/** A redirect like `> out.txt`, `2>&1`, or `<<< "$str"`. `fd` is the
+ * explicit file descriptor (`2` in `2>`), or null for the default. */
+export type Redirect = {
+    tag: "redirect";
+    fd: number | null;
+    op: string;
+    target: BashWord;
+};
+export type SimpleCommand = {
+    tag: "simpleCommand";
+    assignments: Assignment[];
+    words: BashWord[];
+    redirects: Redirect[];
+};
+export type IfCommand = {
+    tag: "if";
+    cond: List;
+    thenBody: List;
+    elifs: {
+        cond: List;
+        thenBody: List;
+    }[];
+    elseBody: List | null;
+    redirects: Redirect[];
+};
+export type LoopCommand = {
+    tag: "loop";
+    kind: "while" | "until";
+    cond: List;
+    body: List;
+    redirects: Redirect[];
+};
+export type ForCommand = {
+    tag: "for";
+    variable: string;
+    /** The `in word...` list, or null for the implicit `in "$@"`. */
+    words: BashWord[] | null;
+    body: List;
+    redirects: Redirect[];
+};
+export type CaseItem = {
+    patterns: BashWord[];
+    body: List;
+    /** `;;`, `;&`, `;;&`, or null when the final item ends at `esac`. */
+    terminator: string | null;
+};
+export type CaseCommand = {
+    tag: "case";
+    subject: BashWord;
+    items: CaseItem[];
+    redirects: Redirect[];
+};
+export type Subshell = {
+    tag: "subshell";
+    body: List;
+    redirects: Redirect[];
+};
+export type Group = {
+    tag: "group";
+    body: List;
+    redirects: Redirect[];
+};
+/** `(( expression ))` as a command. The expression is kept as raw text. */
+export type ArithmeticCommand = {
+    tag: "arithmeticCommand";
+    expression: string;
+    redirects: Redirect[];
+};
+export type FunctionDef = {
+    tag: "functionDef";
+    name: string;
+    body: Command;
+};
+export type Command = SimpleCommand | IfCommand | LoopCommand | ForCommand | CaseCommand | Subshell | Group | ArithmeticCommand | FunctionDef;
+/** One or more commands joined by `|` (or `|&`), optionally negated. */
+export type Pipeline = {
+    tag: "pipeline";
+    negated: boolean;
+    commands: Command[];
+};
+/** Pipelines joined by `&&` / `||`, left to right. */
+export type AndOr = {
+    tag: "andOr";
+    first: Pipeline;
+    rest: {
+        op: "&&" | "||";
+        pipeline: Pipeline;
+    }[];
+};
+export type ListItem = {
+    tag: "listItem";
+    command: AndOr;
+    /** True when the command was followed by `&`. */
+    background: boolean;
+};
+/** A sequence of commands separated by `;`, `&`, or newlines — the top
+ * level of a script, and the body of every compound command. */
+export type List = {
+    tag: "list";
+    items: ListItem[];
+};

package/dist/parsers/bash/types.js

@@ -0,0 +1,2 @@
+/** AST types for the bash parser. See `index.ts` for the supported subset. */
+export {};

package/dist/parsers/bash/words.d.ts

@@ -0,0 +1,22 @@
+import { Parser, ParserResult } from "../../types.js";
+import { BashWord } from "./types.js";
+/** Balanced parens, for `$(( ))` and `(( ))`. Sound because quotes are
+ * not delimiters in bash arithmetic. Declared as a function so the
+ * words/commands module cycle is safe under any import order. */
+export declare function parenBody(input: string): ParserResult<string>;
+/** A word: quoting and expansions handled, trailing whitespace eaten.
+ * Declared as a function so the words/lists/commands module cycle is
+ * safe under any import order. */
+export declare function wordParser(input: string): ParserResult<BashWord>;
+/** A word shaped like an assignment (`name=` / `name+=`). At command
+ * position this is never a plain command word: `name=` was already taken
+ * by the assignment parser, so what reaches here is unsupported syntax
+ * (append, arrays) and must fail rather than parse as a command. */
+export declare const assignmentLookalike: Parser<string>;
+/** A word at command position: rejects reserved words standing alone,
+ * which is how body lists stop at `fi`/`done`/`esac`. Quoted or extended
+ * words (`"fi"`, `fi.txt`) pass, matching bash. */
+export declare function commandWord(input: string): ParserResult<BashWord>;
+/** A run of identifier characters, shared with the assignment parser.
+ * Declared as a function for module-cycle safety. */
+export declare function identifierRun(input: string): ParserResult<string>;

package/dist/parsers/bash/words.js

@@ -0,0 +1,112 @@
+/** Words: quoting, escapes, and expansions. A word is one or more
+ * adjacent parts; only the whole word is a lexeme, so parts never eat
+ * trailing whitespace (`$(pwd) x` must not glue `x` onto the word). */
+import { lazy, many, many1, many1WithJoin, map, not, or, seq, } from "../../combinators.js";
+import { anyChar, char, compileCharPredicate, label, oneOf, str, takeWhile, takeWhile1, } from "../../parsers.js";
+import { trace } from "../../trace.js";
+import { bashLexemes, METACHARACTERS, reservedToken } from "./lexemes.js";
+import { list0 as list0Import } from "./lists.js";
+function literal(text) {
+    return { tag: "literal", text };
+}
+/** Merge adjacent literal parts so ASTs read naturally. */
+function mergeLiterals(parts) {
+    const merged = [];
+    for (const part of parts) {
+        const previous = merged[merged.length - 1];
+        if (part.tag === "literal" && (previous === null || previous === void 0 ? void 0 : previous.tag) === "literal") {
+            merged[merged.length - 1] = literal(previous.text + part.text);
+        }
+        else {
+            merged.push(part);
+        }
+    }
+    return merged;
+}
+const WORD_STOP = METACHARACTERS + "'\"`$\\";
+const isWordStop = compileCharPredicate(WORD_STOP);
+const NOT_SINGLE_QUOTE = (code) => code !== 0x27; // '
+const plainRun = map(takeWhile1((code) => !isWordStop(code), "word characters"), literal);
+// No escapes exist inside single quotes; scanning to the next quote is
+// exactly bash's rule.
+const singleQuoted = label("a single-quoted string", seq([char("'"), takeWhile(NOT_SINGLE_QUOTE), char("'")], (results) => ({ tag: "singleQuoted", text: results[1] })));
+const IDENT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+const SPECIAL_VARIABLES = "?!#@*$-0123456789";
+// No lone-`$` fallback: a `$` that starts no supported expansion is a
+// parse error, which is what makes `$'...'` and `$"..."` fail loudly.
+const variablePart = seq([char("$"), or(oneOf(SPECIAL_VARIABLES), many1WithJoin(oneOf(IDENT_CHARS)))], (results) => ({ tag: "variable", name: results[1] }));
+// Balanced braces by recursion instead of a depth counter: a body is a
+// sequence of non-brace runs and nested `{...}` groups.
+const braceBody = map(many(or(takeWhile1((code) => code !== 0x7b && code !== 0x7d, "brace content"), // { }
+seq([char("{"), lazy(() => braceBody), char("}")], (results) => "{" + results[1] + "}"))), (chunks) => chunks.join(""));
+const paramExpansion = seq([str("${"), braceBody, char("}")], (results) => ({
+    tag: "paramExpansion",
+    expression: results[1],
+}));
+const parenBodyImpl = map(many(or(takeWhile1((code) => code !== 0x28 && code !== 0x29, "paren content"), // ( )
+seq([char("("), lazy(() => parenBodyImpl), char(")")], (results) => "(" + results[1] + ")"))), (chunks) => chunks.join(""));
+/** Balanced parens, for `$(( ))` and `(( ))`. Sound because quotes are
+ * not delimiters in bash arithmetic. Declared as a function so the
+ * words/commands module cycle is safe under any import order. */
+export function parenBody(input) {
+    return parenBodyImpl(input);
+}
+const arithmeticExpansion = seq([str("$(("), parenBody, str("))")], (results) => ({
+    tag: "arithmeticExpansion",
+    expression: results[1],
+}));
+// `char(")")`, not `symbol(")")`: word parts must not eat trailing
+// whitespace. `list0` is deferred to parse time: see the module-cycle
+// note in commands.ts.
+const commandSubstitution = seq([str("$("), lazy(() => list0Import), char(")")], (results) => ({
+    tag: "commandSubstitution",
+    command: results[1],
+}));
+const unquotedEscape = seq([char("\\"), anyChar], 
+// Backslash-newline inside a word disappears (line continuation).
+(results) => literal(results[1] === "\n" ? "" : results[1]));
+const DQ_ESCAPABLE = '"$`\\';
+const doubleQuoteEscape = or(seq([char("\\"), oneOf(DQ_ESCAPABLE)], (results) => literal(results[1])), seq([char("\\"), char("\n")], () => literal("")), 
+// Backslash before any other character stays literal.
+map(char("\\"), () => literal("\\")));
+const isDoubleQuoteStop = compileCharPredicate('"$`\\');
+const doubleQuoteLiteral = map(takeWhile1((code) => !isDoubleQuoteStop(code), "string characters"), literal);
+// No backtick alternative: an unescaped backtick inside double quotes
+// fails the parse (backtick substitution is unsupported; use `$()`).
+const doubleQuoted = seq([
+    char('"'),
+    many(or(arithmeticExpansion, commandSubstitution, paramExpansion, variablePart, doubleQuoteEscape, doubleQuoteLiteral)),
+    char('"'),
+], (results) => ({
+    tag: "doubleQuoted",
+    parts: mergeLiterals(results[1]),
+}));
+const wordPart = or(singleQuoted, doubleQuoted, arithmeticExpansion, commandSubstitution, paramExpansion, variablePart, unquotedEscape, plainRun);
+const wordParserImpl = bashLexemes.lexeme(trace("bash:word", map(many1(wordPart), (parts) => ({
+    tag: "word",
+    parts: mergeLiterals(parts),
+}))));
+/** A word: quoting and expansions handled, trailing whitespace eaten.
+ * Declared as a function so the words/lists/commands module cycle is
+ * safe under any import order. */
+export function wordParser(input) {
+    return wordParserImpl(input);
+}
+/** A word shaped like an assignment (`name=` / `name+=`). At command
+ * position this is never a plain command word: `name=` was already taken
+ * by the assignment parser, so what reaches here is unsupported syntax
+ * (append, arrays) and must fail rather than parse as a command. */
+export const assignmentLookalike = seq([many1WithJoin(oneOf(IDENT_CHARS)), or(str("+="), str("="))], (results) => results[0]);
+const commandWordImpl = seq([not(reservedToken), not(assignmentLookalike), wordParser], (results) => results[2]);
+/** A word at command position: rejects reserved words standing alone,
+ * which is how body lists stop at `fi`/`done`/`esac`. Quoted or extended
+ * words (`"fi"`, `fi.txt`) pass, matching bash. */
+export function commandWord(input) {
+    return commandWordImpl(input);
+}
+const identifierRunImpl = many1WithJoin(oneOf(IDENT_CHARS));
+/** A run of identifier characters, shared with the assignment parser.
+ * Declared as a function for module-cycle safety. */
+export function identifierRun(input) {
+    return identifierRunImpl(input);
+}

package/dist/parsers/markdown/blocks.d.ts

@@ -1,5 +1,5 @@
 import { Parser } from "../../types.js";
-import { Heading, CodeBlock, BlockQuote, Paragraph, HorizontalRule, List, Table, HTMLBlock } from "./types.js";
+import { Heading, CodeBlock, BlockQuote, Paragraph, HorizontalRule, List, Table, HTMLBlock, Block } from "./types.js";
 export { imageParser } from "./inline.js";
 export declare const headingParser: Parser<Heading>;
 export declare const codeBlockParser: Parser<CodeBlock>;
@@ -12,3 +12,5 @@ export declare const htmlBlockParser: Parser<HTMLBlock>;
 export declare const tableParser: Parser<Table>;
 export declare const horizontalRuleParser: Parser<HorizontalRule>;
 export declare const paragraphParser: Parser<Paragraph>;
+export declare const blockAlt: Parser<Block>;
+export declare const blockEntry: Parser<Block>;

package/dist/parsers/markdown/blocks.js

@@ -1,8 +1,10 @@
 import { seqC, seqR, capture, optional, or, manyTillStr, many1Till, exactly, many, many1, many1WithJoin, map, not, lazy, } from "../../combinators.js";
-import { str, spaces, char, eof, set, alphanum, oneOf, noneOf, } from "../../parsers.js";
+import { str, spaces, char, eof, set, alphanum, oneOf, noneOf, newline, } from "../../parsers.js";
+import { success, failure } from "../../types.js";
+import { linkDefinitionParser, footnoteDefinitionParser, } from "./references.js";
 import { digit, letter } from "../../parsers.js";
 import { manyTill } from "../../combinators.js";
-import { inlineMarkdownParser, softBreakParser } from "./inline.js";
+import { inlineMarkdownParser, imageParser, softBreakParser } from "./inline.js";
 export { imageParser } from "./inline.js";
 const languageChar = or(alphanum, oneOf("_+#.-"));
 const languageTag = many1WithJoin(languageChar);
@@ -76,39 +78,117 @@ export const setextHeadingParser = map(_setextRaw, (caps) => {
             : [{ type: "inline-text", content: caps.content }],
     };
 });
-const unorderedMarker = map(oneOf("-*+"), () => ({ ord: false, start: 1 }));
-const orderedMarker = map(seqC(capture(many1WithJoin(digit), "digits"), char(".")), ({ digits }) => ({ ord: true, start: parseInt(digits, 10) }));
+const unorderedMarker = map(oneOf("-*+"), () => ({ ord: false, start: 1, width: 1 }));
+const orderedMarker = map(seqC(capture(many1WithJoin(digit), "digits"), char(".")), ({ digits }) => ({
+    ord: true,
+    start: parseInt(digits, 10),
+    width: digits.length + 1,
+}));
+const anyMarker = or(unorderedMarker, orderedMarker);
 const indentOf = (n) => n > 0 ? str(" ".repeat(n)) : str("");
 /* GFM task-list checkbox: `[ ]` (unchecked), `[x]` or `[X]` (checked).
  * Must be followed by a single space (consumed) to count as a checkbox. */
 const taskCheckbox = map(seqC(char("["), capture(or(char(" "), char("x"), char("X")), "mark"), str("] ")), ({ mark }) => mark !== " ");
-const itemHeadOf = (indent, markerParser) => map(seqC(indentOf(indent), capture(markerParser, "marker"), char(" "), capture(optional(taskCheckbox), "checked"), capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ marker, checked, line }) => {
-    const raw = { marker, line };
-    if (checked !== null)
-        raw.checked = checked;
-    return raw;
-});
-const parseInline = (line) => {
-    const inline = many1(inlineMarkdownParser)(line);
-    return inline.success ? inline.result : [];
+/* The first line of an item's content — everything after the marker+space
+ * (and optional checkbox), up to `\n`. */
+const itemFirstLine = map(seqC(capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ line }) => line);
+/* A continuation line: exactly k spaces of indent, then the rest of the line.
+ * The strip IS the parse — `indentOf(k)` consumes the leading indent. */
+const continuationLine = (k) => map(seqC(indentOf(k), capture(manyTillStr("\n"), "line"), or(char("\n"), eof)), ({ line }) => line);
+/* A blank line at line-start. `blocks.ts` already defines `blankLine` below,
+ * but that variant starts with `\n` (designed for inter-block separators).
+ * Here we're already past the previous `\n`, so we need a line-start variant.
+ *
+ * We do NOT allow `eof` here: at end-of-input with no trailing whitespace
+ * this would succeed without consuming anything, and `many(itemContentLine(k))`
+ * would either spin or append a phantom blank. The final line of an item body
+ * is handled by `continuationLine`'s own `or(char("\n"), eof)`. The matched
+ * value isn't used as data; itemBody normalises blanks to "". */
+const blankContinuation = seqR(many(oneOf(" \t")), char("\n"));
+/* One line of item body (after the first). Heterogeneous return type:
+ *   - continuationLine -> string (the dedented line text)
+ *   - blankContinuation -> unknown (discardable seqR output)
+ * itemBody normalises blanks to "" inline so a wrapper `map` is unnecessary. */
+const itemContentLine = (k) => or(continuationLine(k), blankContinuation);
+/* Reparse an item's collected body as a sequence of blocks via `blockEntry`.
+ *
+ * List item bodies can legitimately begin with blank lines — e.g.
+ * `- \n\n  - inner` collects `"\n- inner"`, and `- ` alone collects `"\n"`.
+ * Strip leading newlines (they carry no AST content) before handing to
+ * `many1(blockEntry)`. After trimming, the invariant `non-empty buf =>
+ * at least one block` holds (CommonMark falls back to a paragraph), so a
+ * parse failure here is a genuine parser bug worth surfacing. */
+const reparseBlocks = (buf) => {
+    const trimmed = buf.replace(/^\n+/, "");
+    if (trimmed === "")
+        return [];
+    const r = many1(lazy(() => blockEntry))(trimmed);
+    if (!r.success) {
+        throw new Error(`reparseBlocks: failed on non-empty buffer: ${JSON.stringify(trimmed)}`);
+    }
+    return r.result;
 };
-// One list item: an item-head followed by an optional sublist at +2 indent.
-const itemWithSublist = (indent, markerParser) => map(seqC(capture(itemHeadOf(indent, markerParser), "raw"), capture(optional(lazy(() => listParserAt(indent + 2))), "sublist")), ({ raw, sublist }) => {
-    const item = { content: parseInline(raw.line) };
-    if (sublist)
-        item.sublist = sublist;
-    if (raw.checked !== undefined)
-        item.checked = raw.checked;
-    return { marker: raw.marker, item };
+/* Full item content: first line + zero-or-more continuation lines, joined
+ * with `\n` and reparsed. */
+const itemBody = (k) => map(seqC(capture(itemFirstLine, "first"), capture(many(itemContentLine(k)), "rest")), ({ first, rest }) => {
+    const lines = [
+        first,
+        ...rest.map((r) => (typeof r === "string" ? r : "")),
+    ];
+    return reparseBlocks(lines.join("\n"));
 });
-// A list of one or more items that all share a marker family.
-const listOf = (indent, markerParser) => map(seqC(capture(itemWithSublist(indent, markerParser), "first"), capture(many(itemWithSublist(indent, markerParser)), "rest")), ({ first, rest }) => ({
-    type: "list",
-    ordered: first.marker.ord,
-    start: first.marker.start,
-    items: [first.item, ...rest.map((r) => r.item)],
-}));
-const listParserAt = (indent) => or(listOf(indent, unorderedMarker), listOf(indent, orderedMarker));
+/* Item parser at marker column c. Handwritten because `k` is derived from the
+ * parsed marker's width — `seqC` runs its children in fixed order with no data
+ * flow between them, so we sequence by hand to thread `marker.width` into
+ * `itemBody(k)`. Same shape as `inlineCodeParser` (inline.ts:179), which
+ * threads the opener's tick count into its closer for the same reason. */
+const itemParser = (c) => (input) => {
+    const head = seqC(indentOf(c), capture(anyMarker, "marker"), char(" "), capture(optional(taskCheckbox), "checked"))(input);
+    if (!head.success)
+        return head;
+    const { marker, checked } = head.result;
+    const k = c + marker.width + 1;
+    const body = itemBody(k)(head.rest);
+    if (!body.success)
+        return body;
+    const item = { content: body.result };
+    if (checked !== null)
+        item.checked = checked;
+    return success({ marker, item }, body.rest);
+};
+/* An item whose marker family matches the locked one. Fails (without
+ * consuming) if the family changed. */
+const itemMatching = (c, ord) => (input) => {
+    const r = itemParser(c)(input);
+    if (!r.success)
+        return r;
+    if (r.result.marker.ord !== ord) {
+        return failure("list marker family changed", input);
+    }
+    return r;
+};
+/* A list at column c. Marker family locked by the first item; subsequent
+ * items use `itemMatching` to enforce the lock. */
+const listOf = (c) => (input) => {
+    const first = itemParser(c)(input);
+    if (!first.success)
+        return first;
+    const ord = first.result.marker.ord;
+    const rest = many(itemMatching(c, ord))(first.rest);
+    if (!rest.success)
+        return rest;
+    const items = [
+        first.result.item,
+        ...rest.result.map((r) => r.item),
+    ];
+    return success({
+        type: "list",
+        ordered: ord,
+        start: first.result.marker.start,
+        items,
+    }, rest.rest);
+};
+const listParserAt = (indent) => listOf(indent);
 export const listParser = listParserAt(0);
 /* Tables.
  *
@@ -187,3 +267,11 @@ seqR(char("<"), or(letter, oneOf("/!?"))));
 const paragraphSoftBreak = map(seqR(softBreakParser, not(blockInterrupt)), () => ({ type: "inline-soft-break" }));
 const paragraphInline = map(seqC(not(blankLine), capture(or(paragraphSoftBreak, inlineMarkdownParser), "node")), ({ node }) => node);
 export const paragraphParser = map(many1(paragraphInline), (content) => ({ type: "paragraph", content: content }));
+/* Top-level block dispatcher. Lives here (rather than in index.ts) so
+ * `listParser`'s `reparseBlocks` can recurse through it via `lazy`. */
+export const blockAlt = or(setextHeadingParser, horizontalRuleParser, headingParser, codeBlockParser, indentedCodeBlockParser, tableParser, blockQuoteParser, listParser, htmlBlockParser, linkDefinitionParser, footnoteDefinitionParser, paragraphParser, imageParser);
+/* A block followed by zero-or-more trailing newlines. Blocks differ in
+ * whether they consume their own terminating "\n" (e.g. headingParser does,
+ * codeBlock doesn't), so `sepBy(many1(newline), block)` won't work — it
+ * would fail to separate two blocks when the first already ate its newline. */
+export const blockEntry = map(seqC(capture(blockAlt, "b"), many(newline)), ({ b }) => b);

package/dist/parsers/markdown/index.d.ts

@@ -3,5 +3,6 @@ export * from "./inline.js";
 export * from "./blocks.js";
 export * from "./references.js";
 export * from "./frontmatter.js";
+import { MarkdownNode } from "./types.js";
 import { Parser } from "../../types.js";
-export declare const markdownParser: Parser<unknown[]>;
+export declare const markdownParser: Parser<MarkdownNode[]>;

package/dist/parsers/markdown/index.js

@@ -3,18 +3,11 @@ export * from "./inline.js";
 export * from "./blocks.js";
 export * from "./references.js";
 export * from "./frontmatter.js";
-import { seq, or, optional, many, capture, seqC, map } from "../../combinators.js";
-import { spaces, newline } from "../../parsers.js";
-import { headingParser, codeBlockParser, blockQuoteParser, paragraphParser, imageParser, horizontalRuleParser, setextHeadingParser, indentedCodeBlockParser, listParser, tableParser, htmlBlockParser, } from "./blocks.js";
-import { linkDefinitionParser, footnoteDefinitionParser, resolveReferences, } from "./references.js";
+import { seq, optional, many, map } from "../../combinators.js";
+import { spaces } from "../../parsers.js";
+import { blockEntry } from "./blocks.js";
+import { resolveReferences } from "./references.js";
 import { frontmatterParser } from "./frontmatter.js";
-const blockAlt = or(setextHeadingParser, horizontalRuleParser, headingParser, codeBlockParser, indentedCodeBlockParser, tableParser, blockQuoteParser, listParser, htmlBlockParser, linkDefinitionParser, footnoteDefinitionParser, paragraphParser, imageParser);
-// A block followed by zero-or-more trailing newlines. Blocks differ in whether
-// they consume their own terminating "\n" (e.g. headingParser does, codeBlock
-// doesn't), so we can't use sepBy(many1(newline), block) — it would fail to
-// separate two blocks when the first already ate its newline (e.g. a heading
-// directly followed by a list with no intervening blank line).
-const blockEntry = map(seqC(capture(blockAlt, "b"), many(newline)), ({ b }) => b);
 const _markdownParser = seq([
     optional(frontmatterParser),
     optional(spaces),