tarsec 0.3.0 → 0.3.2

package/dist/parsers/markdown/index.js

@@ -3,20 +3,22 @@ export * from "./inline.js";
 export * from "./blocks.js";
 export * from "./references.js";
 export * from "./frontmatter.js";
-import { seq, sepBy, or, optional, many1, map } from "../../combinators.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 { frontmatterParser } from "./frontmatter.js";
-// Block separator: one or more newlines (with optional trailing horizontal
-// whitespace). Crucially this does NOT consume leading indentation on the
-// next block — so a 4-space indented code block isn't dewhitespaced before
-// indentedCodeBlockParser ever sees it.
-const blockSeparator = many1(newline);
+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),
-    sepBy(blockSeparator, or(setextHeadingParser, horizontalRuleParser, headingParser, codeBlockParser, indentedCodeBlockParser, tableParser, blockQuoteParser, listParser, htmlBlockParser, linkDefinitionParser, footnoteDefinitionParser, paragraphParser, imageParser)),
+    many(blockEntry),
     optional(spaces),
 ], (r) => {
     const fm = r[0];

package/dist/parsers/markdown/inline.js

@@ -2,11 +2,17 @@ import { seqC, seqR, capture, captureCaptures, or, not, map, many, many1, many1T
 import { str, char, eof, set, oneOf, alphanum, noneOf, digit, letter, anyChar } from "../../parsers.js";
 import { success, failure } from "../../types.js";
 import { optional, between } from "../../combinators.js";
-// Stop inline-text at any single delimiter char OR at a hard-break sequence
-// ("  \n"+). Using many1Till with an `or` of delimiters makes the stop set
-// composable rather than embedded inside a regex. `]` is included so that
-// inline-text inside a link-text (`[...]`) terminates at the closing `]`.
-const inlineTextStop = or(oneOf("*_`[]!<~\\&\n"), str("  "));
+// The "two-or-more trailing spaces then `\n`" half of a hard break. Shared
+// between `hardBreakParser` (which emits the hard-break node) and
+// `inlineTextStop` (which uses it to know where to stop). Keeping these in
+// sync matters: if the run pattern here disagreed with what `hardBreakParser`
+// accepts, inline-text could either swallow a real hard break or — as the
+// previous `str("  ")` did — stop on any incidental double-space (e.g. a
+// 2-space line indent inside a list-item continuation) and freeze the
+// surrounding paragraph at zero progress.
+const hardBreakSpaces = seqR(str("  "), many(char(" ")), char("\n"));
+// `]` is included so inline-text inside a link-text (`[...]`) ends at the `]`.
+const inlineTextStop = or(oneOf("*_`[]!<~\\&\n"), hardBreakSpaces);
 export const inlineTextParser = map(many1Till(inlineTextStop), (content) => ({ type: "inline-text", content }));
 /**
  * Run `inlineMarkdownParser` repeatedly until `stop` would match at the
@@ -219,7 +225,7 @@ export const imageParser = map(seqC(str("!["), capture(iManyTillStr("]("), "alt"
 });
 export const hardBreakParser = map(or(
 // two-or-more trailing spaces then newline
-seqR(str("  "), many(char(" ")), char("\n")), 
+hardBreakSpaces, 
 // backslash then newline
 seqR(char("\\"), char("\n"))), () => ({ type: "inline-hard-break" }));
 /** A single `\n` that is *not* part of a blank line (which would terminate the

package/package.json

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