tarsec 0.4.5 → 0.4.7

package/dist/combinators.d.ts

@@ -7,6 +7,8 @@ import { CaptureParser, GeneralParser, InferManyReturnType, MergedCaptures, Merg
  * { captures: <array of captures> }
  * ```
  *
+ * If you're parsing characters only, prefer `takeWhile` for performance reasons.
+ *
  * @param parser - parser to run
  * @returns - parser that runs the given parser zero to many times,
  * and returns the result as an array
@@ -14,6 +16,7 @@ import { CaptureParser, GeneralParser, InferManyReturnType, MergedCaptures, Merg
 export declare function many<const T extends GeneralParser<any, any>>(parser: T): InferManyReturnType<T>;
 /**
  * Same as `many`, but fails if the parser doesn't match at least once.
+ * If you're parsing characters only, prefer `takeWhile1` for performance reasons.
  *
  * @param parser - parser to run
  * @returns a parser that runs the given parser one to many times,

package/dist/combinators.js

@@ -11,6 +11,8 @@ import { escape } from "./utils.js";
  * { captures: <array of captures> }
  * ```
  *
+ * If you're parsing characters only, prefer `takeWhile` for performance reasons.
+ *
  * @param parser - parser to run
  * @returns - parser that runs the given parser zero to many times,
  * and returns the result as an array
@@ -50,6 +52,7 @@ export function many(parser) {
 }
 /**
  * Same as `many`, but fails if the parser doesn't match at least once.
+ * If you're parsing characters only, prefer `takeWhile1` for performance reasons.
  *
  * @param parser - parser to run
  * @returns a parser that runs the given parser one to many times,

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,110 @@ 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.
+ * The matched value isn't used as data; itemBody normalises blanks to "". */
+const blankContinuation = seqR(many(oneOf(" \t")), or(char("\n"), eof));
+/* 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`.
+ *
+ * No silent fallback. CommonMark guarantees any non-empty buffer produces at
+ * least one block (worst case, a paragraph). The only legitimate empty case
+ * is an item whose first line is empty and which has no continuations — we
+ * handle that explicitly so the invariant `non-empty buf => at least one
+ * block` stays a real invariant. */
+const reparseBlocks = (buf) => {
+    if (buf === "")
+        return [];
+    const r = many1(lazy(() => blockEntry))(buf);
+    if (!r.success) {
+        throw new Error(`reparseBlocks: failed on non-empty buffer: ${JSON.stringify(buf)}`);
+    }
+    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 +260,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.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),

package/dist/parsers/markdown/references.js

@@ -75,14 +75,14 @@ export function resolveReferences(ast) {
             }
             return { type: "inline-text", content: `[^${obj.id}]` };
         }
-        // recurse into known child-bearing fields
+        // recurse into known child-bearing fields. Nested lists now live inside
+        // a list item's `content` (alongside other block children), so no
+        // dedicated `sublist` traversal is needed.
         const out = Object.assign({}, obj);
         for (const key of ["content", "items", "rows"]) {
             if (Array.isArray(obj[key]))
                 out[key] = obj[key].map(walk);
         }
-        if (obj.sublist)
-            out.sublist = walk(obj.sublist);
         return out;
     }
     return ast

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

@@ -76,11 +76,11 @@ export type InlineRefImage = {
     id: string;
 };
 export type ListItem = {
-    content: InlineMarkdown[];
-    sublist?: List;
+    content: Block[];
     /** GFM task-list state: `true` for `[x]`/`[X]`, `false` for `[ ]`, absent for plain items. */
     checked?: boolean;
 };
+export type Block = Paragraph | Heading | CodeBlock | List | BlockQuote | HorizontalRule | Table | HTMLBlock | Image | LinkDef | FootnoteDef;
 export type List = {
     type: "list";
     ordered: boolean;

package/dist/parsers.d.ts

@@ -48,6 +48,8 @@ export declare function noneOf(chars: string): Parser<string>;
  */
 export type CharPredicate = (code: number) => boolean;
 /**
+ * A faster version of many/ manyWithJoin for character-class scanning.
+ *
  * Consume the longest prefix of `input` whose characters all satisfy
  * the predicate (or are contained in the given char-class string). Always
  * succeeds; returns "" when nothing matches.

package/dist/parsers.js

@@ -126,6 +126,8 @@ function compileCharPredicate(charsOrPred) {
     return (code) => code < 128 ? ascii[code] === 1 : set.has(code);
 }
 /**
+ * A faster version of many/ manyWithJoin for character-class scanning.
+ *
  * Consume the longest prefix of `input` whose characters all satisfy
  * the predicate (or are contained in the given char-class string). Always
  * succeeds; returns "" when nothing matches.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {