mdrefine 0.2.0-rc.3 → 0.2.1

package/dist/rules/style.js

@@ -128,11 +128,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 +149,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 +168,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 +192,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 +303,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 +402,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 +446,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 +458,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);
@@ -654,9 +707,11 @@ function holds(node, type) {
  * The inline nodes of a paragraph, from `start` on, that reflow keeps whole,
  * sorted by position, and the hard line breaks anywhere in it. A container
  * that holds inline HTML is kept whole too, because HTML can make the
- * whitespace inside it significant.
+ * whitespace inside it significant. With `wholeLinks`, the text of a link is
+ * kept whole as an image's description is: Obsidian's Live Preview shows a
+ * link whose text spans lines as Markdown source (issue #306).
  */
-function inlineAtoms(paragraph, start) {
+function inlineAtoms(paragraph, start, wholeLinks) {
     const atoms = [];
     const breaks = [];
     let unlocated = false;
@@ -674,6 +729,21 @@ function inlineAtoms(paragraph, start) {
                 continue;
             if (child.type === "break")
                 breaks.push([a, b]);
+            else if (wholeLinks &&
+                (child.type === "link" || child.type === "linkReference") &&
+                child.children.length &&
+                labelEnd(child) &&
+                !holds(child, "html")) {
+                // The code spans, images, and other atoms in the text keep their own
+                // joining; between them, a line ending joins with the space that it
+                // renders as, as in an image's description.
+                const close = labelEnd(child);
+                const inner = atoms.length;
+                visit(child);
+                const within = atoms.splice(inner).sort((x, y) => x.from - y.from);
+                atoms.push({ from: a, to: close, joining: { within } });
+                atoms.push({ from: close, to: b, joining: destination });
+            }
             else if (wrappable.has(child.type) &&
                 "children" in child &&
                 child.children.length &&
@@ -945,7 +1015,7 @@ const wrap = {
                     }
                     : {}),
             };
-            const inline = inlineAtoms(node, start);
+            const inline = inlineAtoms(node, start, document.dialect === "obsidian");
             const protection = new Protection(start, end);
             for (const atom of inline.atoms)
                 protection.add(atom.from, atom.to);
@@ -1074,9 +1144,11 @@ const wrap = {
                         break;
                     }
                     const last = words.at(-1);
-                    const joining = protection.has(lineEnd)
+                    let joining = protection.has(lineEnd)
                         ? (atomAt(inline.atoms, lineEnd)?.joining ?? { reason: "line break in inline syntax" })
                         : undefined;
+                    if (joining && typeof joining === "object" && "within" in joining)
+                        joining = atomAt(joining.within, lineEnd)?.joining ?? "description";
                     if (!joining)
                         words.push(" ");
                     else if (last === undefined || /^[ \t]+$/.test(last))
@@ -1096,7 +1168,7 @@ const wrap = {
                         words[words.length - 1] = `${joining === "code" ? last : last.trimEnd()} `;
                     }
                     else
-                        failure = joining.reason;
+                        failure = "reason" in joining ? joining.reason : "line break in inline syntax";
                 }
                 words.push(...protection.split(line, lineAt));
                 lineEnd = lineAt + line.length;