mdrefine 0.2.0 → 0.2.2

package/dist/rules/style.js

@@ -2,7 +2,8 @@ import { walk } from "../syntax/walk.js";
 import stringWidth from "string-width";
 import { directive } from "../core/directives.js";
 import { blockIdentifier } from "../syntax/block-identifier.js";
-import { codeSpanText, labelEnd, lazyIndentation, parse, range, startsWithMarker, } from "../syntax/parse.js";
+import { misreadLists } from "../syntax/misread-lists.js";
+import { codeSpanText, joinsTomlFrontMatter, labelEnd, lazyIndentation, parse, range, startsWithMarker, } from "../syntax/parse.js";
 import { changesForgeHeading, headingAttributeBlock } from "../workspace/heading-attributes.js";
 import { takesFinalLineEnding, takesLines, underlinedHeadings, underlineEdit } from "./blocks.js";
 export function optionsSchema(properties) {
@@ -128,11 +129,13 @@ function markersLoosenRuns() {
 /**
  * The delimiter runs at `positions`, sorted, with the characters that `at`
  * gives. Whether a run can open or close follows micromark, which also lets a
- * run next to a `~` in GFM do both. Container markers such as `>` count as
- * punctuation here, while micromark sees the line ending before them; the
- * caller compares the result with the parse.
+ * run next to a `~` in GFM do both, and in some versions one next to another
+ * `*` or `_`; with `commonmark`, it follows CommonMark, where those characters
+ * are punctuation. Container markers such as `>` count as punctuation here,
+ * while micromark sees the line ending before them; the caller compares the
+ * result with the parse.
  */
-function delimiterRuns(positions, at, gfm) {
+function delimiterRuns(positions, at, gfm, commonmark = false) {
     const runs = [];
     for (const position of positions) {
         const last = runs.at(-1);
@@ -147,8 +150,9 @@ function delimiterRuns(positions, at, gfm) {
                 close: false,
             });
     }
-    const loosen = markersLoosenRuns();
-    const attention = (character) => (gfm && character === "~") || (loosen && (character === "*" || character === "_"));
+    const loosen = !commonmark && markersLoosenRuns();
+    const attention = (character) => (!commonmark && gfm && character === "~") ||
+        (loosen && (character === "*" || character === "_"));
     for (const run of runs) {
         const previous = at(run.start - 1);
         const next = at(run.end);
@@ -165,21 +169,23 @@ function delimiterRuns(positions, at, gfm) {
  * The emphasis and strong emphasis that micromark makes of `runs`, as
  * `start:end:size` strings: each closing run, in order, pairs with the nearest
  * opening run of its marker before it, except where the rule of three forbids
- * it, and the runs between them become text.
+ * it, and the runs between them become text. micromark applies the rule to the
+ * parts of two runs that are left; with `whole`, it counts the whole runs, as
+ * CommonMark, GitHub, and the reference parsers do (issue #323).
  */
-function pairings(runs) {
-    const left = runs.map((run) => ({ ...run }));
+function pairings(runs, whole = false) {
+    const left = runs.map((run) => ({ ...run, size: run.end - run.start }));
     const pairs = [];
     for (let index = 0; index < left.length; index++) {
         const closer = left[index];
         while (closer.close && closer.end > closer.start) {
-            const closeSize = closer.end - closer.start;
+            const closeSize = whole ? closer.size : closer.end - closer.start;
             let found = index - 1;
             for (; found >= 0; found--) {
                 const opener = left[found];
-                const openSize = opener.end - opener.start;
-                if (!opener.open || !openSize || opener.marker !== closer.marker)
+                if (!opener.open || opener.end === opener.start || opener.marker !== closer.marker)
                     continue;
+                const openSize = whole ? opener.size : opener.end - opener.start;
                 if ((opener.close || closer.open) && closeSize % 3 && !((openSize + closeSize) % 3))
                     continue;
                 break;
@@ -187,7 +193,7 @@ function pairings(runs) {
             if (found < 0)
                 break;
             const opener = left[found];
-            const use = opener.end - opener.start > 1 && closeSize > 1 ? 2 : 1;
+            const use = opener.end - opener.start > 1 && closer.end - closer.start > 1 ? 2 : 1;
             opener.end -= use;
             closer.start += use;
             pairs.push(`${opener.end}:${closer.start}:${use}`);
@@ -298,6 +304,25 @@ function eachInline(tree, type, visitor) {
     };
     step(tree, tree);
 }
+/**
+ * Whether the text in `node`, outside code and other literal nodes, holds an
+ * unescaped run of tildes that could mark strikethrough in `dialect`, one or
+ * two tildes or in Obsidian two, while `scope`, where such runs pair, holds
+ * another.
+ */
+function holdsStrikethroughRun(node, scope, source, dialect) {
+    const pattern = dialect === "obsidian" ? "(?<![\\\\~])~~(?!~)" : "(?<![\\\\~])~{1,2}(?!~)";
+    const runs = located(scope) ? source.slice(...range(scope)).match(new RegExp(pattern, "g")) : [];
+    if (located(scope) && (runs?.length ?? 0) < 2)
+        return false;
+    const run = new RegExp(pattern);
+    let found = false;
+    walk(node, "text", (text) => {
+        if (!found && located(text) && run.test(source.slice(...range(text))))
+            found = true;
+    });
+    return found;
+}
 function markerRule(type, fallback) {
     return {
         description: `Choose ${type} delimiters without reprinting their contents.`,
@@ -378,6 +403,27 @@ function markerRule(type, fallback) {
                         reaches(start + size, 1) ||
                         reaches(end - size - 1, -1)))
                     return;
+                // micromark pairs emphasis and strikethrough in separate passes, in the
+                // order that their first delimiters appear in the paragraph, while
+                // GitHub pairs whichever closes first. So emphasis whose text holds a
+                // run of tildes that could mark strikethrough may be strikethrough and
+                // text there, and its markers what GitHub shows (issue #320).
+                if (gfm && holdsStrikethroughRun(node, scope, source, document.dialect))
+                    return;
+                // GitHub reads a `_` that a run of tildes separates from a letter or
+                // digit as inside a word, where it neither opens nor closes, while the
+                // parser reads emphasis there (issue #322).
+                const tildesToWord = (index, step) => {
+                    if (source[index] !== "~")
+                        return false;
+                    while (source[index] === "~")
+                        index += step;
+                    return /[\p{L}\p{N}]/u.test(source[index] ?? "");
+                };
+                if (gfm &&
+                    (marker[0] === "_" || original[0] === "_") &&
+                    (tildesToWord(start - 1, -1) || tildesToWord(end, 1)))
+                    return;
                 const list = candidates.get(scope) ?? [];
                 list.push([start, end]);
                 candidates.set(scope, list);
@@ -401,7 +447,11 @@ function markerRule(type, fallback) {
                 // share a run of markers, as in `***a***` or `*a****c***`.
                 const { positions, emphasis, suspicious } = scopeDelimiters(source, scope);
                 const expected = emphasis.join(" ");
-                const pairing = (changed) => pairings(delimiterRuns(positions, (at) => (changed.has(at) ? marker[0] : source[at]), gfm)).join(" ");
+                // micromark's pairing, or with `commonmark` CommonMark's.
+                const pairing = (changed, commonmark = false) => pairings(delimiterRuns(positions, (at) => (changed.has(at) ? marker[0] : source[at]), gfm, commonmark), commonmark).join(" ");
+                // Both micromark's pairing and CommonMark's, which renderers follow,
+                // have to stay the same with the new markers.
+                const kept = (changed) => pairing(changed) === expected && pairing(changed, true) === expected;
                 // micromark pairs `~` in a pass of its own, which can come first, and
                 // lets a run next to a `~` pair with one of the new marker, as in `_f~*a*e_`.
                 const tilde = gfm && source.slice(...range(scope)).includes("~");
@@ -409,12 +459,16 @@ function markerRule(type, fallback) {
                 if (!modelled)
                     accepted =
                         suspicious || (tilde && positions.some((at) => source[at] === marker[0])) ? [] : list;
-                else if (pairing(markers(list)) !== expected) {
+                // Where CommonMark pairs the text as written differently, the parser
+                // misread it, and renderers show other emphasis (issue #323).
+                else if (pairing(new Set(), true) !== expected)
+                    accepted = [];
+                else if (!kept(markers(list))) {
                     accepted = [];
                     let changed = new Set();
                     for (const item of list) {
                         const trial = new Set([...changed, ...markers([item])]);
-                        if (pairing(trial) !== expected)
+                        if (!kept(trial))
                             continue;
                         changed = trial;
                         accepted.push(item);
@@ -702,7 +756,15 @@ function inlineAtoms(paragraph, start, wholeLinks) {
                 visit(child);
             }
             else if (child.type === "inlineCode")
-                atoms.push({ from: a, to: b, joining: "code" });
+                atoms.push({
+                    from: a,
+                    to: b,
+                    // The spaces that start a lazy continuation line stay in the span,
+                    // which joining would drop, as after `>* ` with no space (issue #339).
+                    joining: lazyIndentation(child)
+                        ? { reason: "code span continuing on an indented lazy line" }
+                        : "code",
+                });
             else if ((child.type === "image" || child.type === "imageReference") && labelEnd(child)) {
                 const close = labelEnd(child);
                 atoms.push({ from: a, to: close, joining: "description" });
@@ -1109,6 +1171,11 @@ const wrap = {
                         // keeps. A lazy line, which keeps them, is not supported above.
                         if (joining === "description" && /(?: {2}|\\)$/.test(last))
                             failure = "hard line break";
+                        // In a code span, a backslash before the line ending is a hard
+                        // break wherever the backticks do not pair, as on GitHub after an
+                        // unpaired longer run (issue #335).
+                        if (joining === "code" && last.endsWith("\\"))
+                            failure = "backslash at a line end in a code span";
                         const trimmed = line.replace(/^[ \t]+/, "");
                         lineAt += line.length - trimmed.length;
                         line = trimmed;
@@ -1230,19 +1297,19 @@ const table = {
 };
 /** A line holding nothing but block quote markers and blank space. */
 const blankLine = /^[ \t>]*$/;
-/**
- * A list item or quote marker followed by another list marker on its line,
- * including the ones that cannot open a list there, such as `* * *`.
- */
-const nestedListStart = /^[ \t]*(?:[-+*]|\d{1,9}[.)]|>)[ \t>]*(?:[-+*]|\d{1,9}[.)])(?:[ \t]|$)/;
+const blockContainers = ["blockquote", "list", "listItem", "footnoteDefinition"];
 /** The innermost last block of a container, where its text ends. */
 function lastBlock(node) {
-    while (["blockquote", "list", "listItem", "footnoteDefinition"].includes(node.type) &&
-        "children" in node &&
-        node.children.length)
+    while (blockContainers.includes(node.type) && "children" in node && node.children.length)
         node = node.children.at(-1);
     return node;
 }
+/** The innermost first block of a container, where its text starts. */
+function firstBlock(node) {
+    while (blockContainers.includes(node.type) && "children" in node && node.children.length)
+        node = node.children[0];
+    return node;
+}
 /**
  * Whether two neighboring blocks have to stay as they are, although one of
  * them is a heading or a list, because a blank line between them would change
@@ -1294,17 +1361,24 @@ function together(document, parent, index, directiveLines) {
         last.type === "footnoteDefinition" &&
         !last.children.length)
         return true;
-    // Directly below text or a link reference definition, the parser does not
-    // start a list that would be empty or not start at 1, though it does below
-    // a blank line: there, `- -` is a list item holding the text `-`, and `-`
-    // underlined with `---` is a heading. Such a list could start on the first
-    // line of a list or quote, and such a line could begin an underlined heading.
-    if (!["paragraph", "definition"].includes(lastBlock(before).type))
+    // Renderers may read a list where the parser read text that starts with a
+    // list marker, the blocks indented below it inside that list's last item,
+    // and a list after those as more of its items (issue #191). A blank line
+    // above a list or quote that starts with such text, as `- -` or `- 2. Step`
+    // directly below text, would make the parser read the list too, and one
+    // between the blocks of such a list would make it loose.
+    const misread = misreadLists(document);
+    if (misread.nested.has(after) ||
+        (after.type === "list" && misread.next.has(after)) ||
+        misread.text.has(firstBlock(after)))
+        return true;
+    // Directly below text or a link reference definition, `-` underlined with
+    // `---` is a heading, and below a blank line an empty list item and a
+    // thematic break.
+    if (after.type !== "heading" || !["paragraph", "definition"].includes(lastBlock(before).type))
         return false;
     const firstLine = source.slice(afterStart, lineBounds(source, afterStart, afterStart)[1]);
-    if (after.type === "heading")
-        return !/^[ \t]*#/.test(firstLine);
-    return (after.type === "list" || after.type === "blockquote") && nestedListStart.test(firstLine);
+    return !/^[ \t]*#/.test(firstLine);
 }
 const blockSpacing = {
     description: "Separate headings and lists from neighboring blocks with a blank line.",
@@ -1416,6 +1490,11 @@ export const styleRules = {
                 // marker, which holds an Obsidian callout's title.
                 if (titles.some(([a, b]) => start >= a && start < b))
                     return;
+                // Where its backticks do not pair, as on GitHub after an unpaired
+                // longer run, a backslash at the end of a line is a hard line break
+                // (issue #335).
+                if (/\\(?:\r\n|\r|\n)/.test(source.slice(start, end)))
+                    return;
                 if (document.dialect === "obsidian") {
                     // Obsidian reads highlights and wikilinks only within a line. Once
                     // the lines are one, an `==` or `[[` left as text could open one that
@@ -1540,6 +1619,10 @@ export const styleRules = {
                 }
                 if (underlined || !first || !last)
                     return;
+                // Renderers without TOML front matter read its lines as part of a
+                // heading underlined directly below it (issue #333).
+                if (joinsTomlFrontMatter(document.tree, node))
+                    return;
                 // Below link reference definitions, the heading's position starts at
                 // the first definition; its own text starts on a later line. Headings
                 // that are indented or inside lists or block quotes are left as written.