mdrefine 0.2.0-rc.2 → 0.2.0

package/dist/rules/style.js

@@ -1,7 +1,10 @@
 import { walk } from "../syntax/walk.js";
 import stringWidth from "string-width";
-import { range } from "../syntax/parse.js";
+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 { changesForgeHeading, headingAttributeBlock } from "../workspace/heading-attributes.js";
+import { takesFinalLineEnding, takesLines, underlinedHeadings, underlineEdit } from "./blocks.js";
 export function optionsSchema(properties) {
     return { type: "object", properties, additionalProperties: false };
 }
@@ -21,6 +24,54 @@ function lineBounds(source, start, end) {
         lineEnd++;
     return [lineStart, lineEnd];
 }
+const lineIndexes = new WeakMap();
+function lineIndex(document) {
+    let index = lineIndexes.get(document);
+    if (!index) {
+        const breaks = [];
+        for (let at = 0; at < document.source.length; at++)
+            if (document.source[at] === "\r" || document.source[at] === "\n")
+                breaks.push(at);
+        lineIndexes.set(document, (index = { breaks, found: new Map() }));
+    }
+    return index;
+}
+/** The number of values in the sorted `values` that are less than `limit`. */
+function countBelow(values, limit) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        if (values[middle] < limit)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+/** `lineBounds` for a document, from its line index. */
+function indexedLineBounds(document, start, end) {
+    const { breaks } = lineIndex(document);
+    const before = countBelow(breaks, start);
+    const after = countBelow(breaks, end);
+    return [before ? breaks[before - 1] + 1 : 0, breaks[after] ?? document.source.length];
+}
+/**
+ * Where `text` occurs in the document between `from` and `to`, wholly: the
+ * last occurrence, or -1 for none.
+ */
+function lastWithin(document, text, from, to) {
+    const { found } = lineIndex(document);
+    let positions = found.get(text);
+    if (!positions) {
+        positions = [];
+        for (let at = document.source.indexOf(text); at >= 0; at = document.source.indexOf(text, at + 1))
+            positions.push(at);
+        found.set(text, positions);
+    }
+    const last = positions[countBelow(positions, to - text.length + 1) - 1];
+    return last !== undefined && last >= from ? last : -1;
+}
 /**
  * Gitea does not parse a `_` run as an emphasis delimiter when the next `_` on
  * its physical line starts `_.py`, or when the run itself does and no `_`
@@ -28,8 +79,8 @@ function lineBounds(source, start, end) {
  * else on the line, code spans included: a line containing `_.py` before or
  * after an edit can gain or lose emphasis when markers change or lines join.
  */
-export function giteaPyLine(source, start, end) {
-    return source.slice(...lineBounds(source, start, end)).includes("_.py");
+export function giteaPyLine(document, start, end) {
+    return lastWithin(document, "_.py", ...indexedLineBounds(document, start, end)) >= 0;
 }
 /** Forgejo and its upstream Gitea build on goldmark with shared extensions. */
 const goldmarkForges = { forgejo: "Forgejo", gitea: "Gitea" };
@@ -38,11 +89,214 @@ const goldmarkForges = { forgejo: "Forgejo", gitea: "Gitea" };
  * Gitea where enabled, render as math. GFM parses emphasis and code spans
  * there, and changing them would change the formula.
  */
-function inForgeMath(source, start, end) {
-    const [lineStart, lineEnd] = lineBounds(source, start, end);
-    const before = source.slice(lineStart, start);
-    return (before.lastIndexOf("\\(") > before.lastIndexOf("\\)") &&
-        source.slice(end, lineEnd).includes("\\)"));
+export function inForgeMath(document, start, end) {
+    const [lineStart, lineEnd] = indexedLineBounds(document, start, end);
+    return (lastWithin(document, "\\(", lineStart, start) > lastWithin(document, "\\)", lineStart, start) &&
+        lastWithin(document, "\\)", end, lineEnd) >= 0);
+}
+/** The blocks whose inline content the parser reads, and pairs delimiters in, as a whole. */
+const inlineBlocks = new Set(["paragraph", "heading", "tableCell"]);
+/** Whether the character at `index` is escaped by an odd number of backslashes before it. */
+function escaped(source, index) {
+    let count = 0;
+    while (source[index - count - 1] === "\\")
+        count++;
+    return count % 2 === 1;
+}
+/**
+ * How micromark classifies a character next to a delimiter run: 1 for
+ * whitespace and for the start or end of the text, 2 for punctuation and
+ * symbols, and 0 for anything else. It looks at UTF-16 code units, so half of
+ * a surrogate pair counts as anything else.
+ */
+function characterGroup(character) {
+    if (character === undefined || /\s/.test(character))
+        return 1;
+    return /\p{P}|\p{S}/u.test(character) ? 2 : 0;
+}
+/**
+ * Whether the installed micromark lets a run of `*` or `_` next to the other
+ * marker open and close whatever else surrounds it, as
+ * micromark-core-commonmark did before 2.0.4. It is read from the parse of
+ * `*_c_*a`, whose last `*` then closes emphasis.
+ */
+let markersLoosen;
+function markersLoosenRuns() {
+    markersLoosen ??= parse("*_c_*a", "commonmark").tree.children.some((block) => block.type === "paragraph" && block.children[0]?.type === "emphasis");
+    return markersLoosen;
+}
+/**
+ * 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.
+ */
+function delimiterRuns(positions, at, gfm) {
+    const runs = [];
+    for (const position of positions) {
+        const last = runs.at(-1);
+        if (last && last.end === position && at(position) === last.marker)
+            last.end++;
+        else
+            runs.push({
+                marker: at(position),
+                start: position,
+                end: position + 1,
+                open: false,
+                close: false,
+            });
+    }
+    const loosen = markersLoosenRuns();
+    const attention = (character) => (gfm && character === "~") || (loosen && (character === "*" || character === "_"));
+    for (const run of runs) {
+        const previous = at(run.start - 1);
+        const next = at(run.end);
+        const before = characterGroup(previous);
+        const after = characterGroup(next);
+        const open = after === 0 || (after === 2 && before !== 0) || attention(next);
+        const close = before === 0 || (before === 2 && after !== 0) || attention(previous);
+        run.open = run.marker === "*" ? open : open && (before !== 0 || !close);
+        run.close = run.marker === "*" ? close : close && (after !== 0 || !open);
+    }
+    return runs;
+}
+/**
+ * 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.
+ */
+function pairings(runs) {
+    const left = runs.map((run) => ({ ...run }));
+    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;
+            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)
+                    continue;
+                if ((opener.close || closer.open) && closeSize % 3 && !((openSize + closeSize) % 3))
+                    continue;
+                break;
+            }
+            if (found < 0)
+                break;
+            const opener = left[found];
+            const use = opener.end - opener.start > 1 && closeSize > 1 ? 2 : 1;
+            opener.end -= use;
+            closer.start += use;
+            pairs.push(`${opener.end}:${closer.start}:${use}`);
+            for (let between = found + 1; between < index; between++)
+                left[between].end = left[between].start;
+        }
+    }
+    return pairs.sort();
+}
+/**
+ * The `*` and `_` characters that micromark reads as delimiters in the text of
+ * `scope`, a block or a link whose text it pairs delimiters in on its own: the
+ * markers of emphasis, and unescaped characters left as text. Also the
+ * emphasis there, as `start:end:size` strings, and whether changing markers
+ * could change how they pair: when a character left as text could open or
+ * close emphasis, as in `*a _b* c_`, or when one run holds the markers of two
+ * emphases, or a marker and text, as in `***a***` or `*****a***`.
+ */
+function scopeDelimiters(source, scope) {
+    const positions = [];
+    const markers = new Set();
+    const emphasis = [];
+    const literal = new Set();
+    const visit = (node) => {
+        if (node !== scope && (node.type === "link" || node.type === "linkReference"))
+            return;
+        if (node.type === "emphasis" || node.type === "strong") {
+            const [a, b] = range(node);
+            const size = node.type === "strong" ? 2 : 1;
+            emphasis.push(`${a}:${b}:${size}`);
+            markers.add(`${a}:${a + size}`).add(`${b - size}:${b}`);
+            for (let i = 0; i < size; i++)
+                positions.push(a + i, b - size + i);
+        }
+        else if (node.type === "text") {
+            const [a, b] = range(node);
+            for (let i = a; i < b; i++)
+                if ((source[i] === "*" || source[i] === "_") && !escaped(source, i)) {
+                    positions.push(i);
+                    literal.add(i);
+                }
+        }
+        if ("children" in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(scope);
+    positions.sort((a, b) => a - b);
+    const suspicious = delimiterRuns(positions, (index) => source[index], true).some((run) => {
+        if (markers.has(`${run.start}:${run.end}`))
+            return false;
+        for (let index = run.start; index < run.end; index++)
+            if (literal.has(index))
+                return run.open || run.close;
+        return true;
+    });
+    return { positions, emphasis: emphasis.sort(), suspicious };
+}
+/** A link label as CommonMark compares labels: whitespace collapsed and case folded. */
+const normalizedLabel = (label) => label
+    .replace(/[\t\n\r ]+/g, " ")
+    .trim()
+    .toLowerCase()
+    .toUpperCase();
+/** The labels of the document's definitions and footnotes that hold `*` or `_`, normalized. */
+function markerLabels(tree) {
+    const labels = [];
+    walk(tree, (node) => {
+        if ((node.type === "definition" || node.type === "footnoteDefinition") &&
+            node.label &&
+            /[*_]/.test(node.label))
+            labels.push(normalizedLabel(node.label));
+    });
+    return labels;
+}
+/**
+ * The first lines of the document's Obsidian callouts and GitHub, Forgejo, or
+ * Gitea alerts, from the marker on, which hold an Obsidian callout's title and
+ * an alert's marker on its own.
+ */
+function calloutTitles(document) {
+    const titles = [];
+    if (document.dialect !== "commonmark")
+        walk(document.tree, "blockquote", (quote) => {
+            const first = quote.children[0];
+            if (first?.type !== "paragraph")
+                return;
+            const [start] = range(first);
+            const end = lineBounds(document.source, start, start)[1];
+            if (startsWithMarker(document.source.slice(start, end), first))
+                titles.push([start, end]);
+        });
+    return titles;
+}
+/**
+ * Visit the nodes of `type` with their scope: the innermost link, whose text
+ * micromark pairs delimiters in on its own, or else the block that holds them.
+ */
+function eachInline(tree, type, visitor) {
+    const step = (node, scope) => {
+        if (inlineBlocks.has(node.type) || node.type === "link" || node.type === "linkReference")
+            scope = node;
+        if (node.type === type)
+            visitor(node, scope);
+        if ("children" in node)
+            for (const child of node.children)
+                step(child, scope);
+    };
+    step(tree, tree);
 }
 function markerRule(type, fallback) {
     return {
@@ -52,11 +306,17 @@ function markerRule(type, fallback) {
         schema: optionsSchema({ marker: { enum: ["*", "_"] } }),
         check({ document, options }) {
             const findings = [];
-            walk(document.tree, type, (node) => {
+            const { source } = document;
+            const gfm = document.dialect !== "commonmark";
+            const size = type === "strong" ? 2 : 1;
+            const marker = String(options.marker ?? fallback).repeat(size);
+            const labels = markerLabels(document.tree);
+            const titles = calloutTitles(document);
+            /** The ranges of the emphasis to change, by the scope that holds them. */
+            const candidates = new Map();
+            eachInline(document.tree, type, (node, scope) => {
                 const [start, end] = range(node);
-                const size = type === "strong" ? 2 : 1;
-                const marker = String(options.marker ?? fallback).repeat(size);
-                const original = document.source.slice(start, end);
+                const original = source.slice(start, end);
                 if (original.startsWith(marker))
                     return;
                 // Underscores cannot delimit intraword emphasis. Preserve these valid forms.
@@ -69,7 +329,7 @@ function markerRule(type, fallback) {
                 const neighbours = [start - 1, end, start + size, end - size - 1].map((index) => document.source[index]);
                 if (neighbours.includes(marker[0]))
                     return;
-                if (goldmarkForges[document.dialect] && inForgeMath(document.source, start, end))
+                if (goldmarkForges[document.dialect] && inForgeMath(document, start, end))
                     return;
                 // Forgejo, and Gitea before 1.26, build a heading's anchor from its last
                 // line as written, keeping `_` and dropping `*`, and both read a trailing
@@ -77,84 +337,420 @@ function markerRule(type, fallback) {
                 if (changesForgeHeading(document, start, end))
                     return;
                 if (document.dialect === "gitea" &&
-                    (giteaPyLine(document.source, start, end) ||
+                    (giteaPyLine(document, start, end) ||
                         document.source.startsWith(".py", end) ||
                         document.source.startsWith(".py", start + size)))
                     return;
-                for (const [a, b] of [
-                    [start, start + size],
-                    [end - size, end],
-                ]) {
-                    findings.push({
-                        start: a,
-                        end: b,
-                        message: `Use ${JSON.stringify(marker)} for ${type}.`,
-                        edit: { start: a, end: b, text: marker },
-                    });
+                // GitHub, Forgejo, and Gitea end dollar math only at dollars that no
+                // `_` follows, so a marker after a `$` can decide where math ends.
+                if (gfm &&
+                    document.dialect !== "obsidian" &&
+                    (source[start - 1] === "$" || source[end - size - 1] === "$"))
+                    return;
+                // Emphasis that begins on the line of a callout's or alert's marker
+                // and ends below it is text on that line, whose markers would change.
+                if (titles.length &&
+                    /[\r\n]/.test(original) &&
+                    titles.some(([a, b]) => start >= a && start < b && end > b))
+                    return;
+                // The text of a collapsed or shortcut reference, such as `[*Title*][]`
+                // or `[*Title*]`, is also its label, which would no longer match the
+                // definition's.
+                if (scope.type === "linkReference" && scope.referenceType !== "full")
+                    return;
+                // Text in brackets that would match a definition with the new markers
+                // would become a reference.
+                if (labels.length) {
+                    const rewritten = normalizedLabel(marker + original.slice(size, -size) + marker);
+                    if (labels.some((label) => label.includes(rewritten)))
+                        return;
                 }
+                // micromark lets a run next to a `~` open and close, so a new marker
+                // that a `~` separates from another `*` or `_` like it could pair with it.
+                const reaches = (index, step) => {
+                    while (source[index] === "~")
+                        index += step;
+                    return source[index] === marker[0];
+                };
+                if (gfm &&
+                    (reaches(start - 1, -1) ||
+                        reaches(end, 1) ||
+                        reaches(start + size, 1) ||
+                        reaches(end - size - 1, -1)))
+                    return;
+                const list = candidates.get(scope) ?? [];
+                list.push([start, end]);
+                candidates.set(scope, list);
             });
-            return findings;
+            /** The positions of the markers of the emphasis in `ranges`. */
+            const markers = (ranges) => {
+                const set = new Set();
+                for (const [start, end] of ranges)
+                    for (let i = 0; i < size; i++)
+                        set.add(start + i).add(end - size + i);
+                return set;
+            };
+            for (const [scope, list] of candidates) {
+                let accepted = list;
+                // The parser's pairing of delimiter runs is modelled, and the markers
+                // change where the model, which has to reproduce the parse, pairs the
+                // same runs with the new markers: all of them, or else those that can
+                // be added one at a time. Where the model cannot be used, markers
+                // change only when no run could pair differently, which it could when
+                // a `*` or `_` in the same text did not pair, or when two emphases
+                // 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 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("~");
+                const modelled = !tilde && positions.length <= 500 && pairing(new Set()) === expected;
+                if (!modelled)
+                    accepted =
+                        suspicious || (tilde && positions.some((at) => source[at] === marker[0])) ? [] : list;
+                else if (pairing(markers(list)) !== expected) {
+                    accepted = [];
+                    let changed = new Set();
+                    for (const item of list) {
+                        const trial = new Set([...changed, ...markers([item])]);
+                        if (pairing(trial) !== expected)
+                            continue;
+                        changed = trial;
+                        accepted.push(item);
+                    }
+                }
+                for (const [start, end] of accepted)
+                    for (const [a, b] of [
+                        [start, start + size],
+                        [end - size, end],
+                    ]) {
+                        findings.push({
+                            start: a,
+                            end: b,
+                            message: `Use ${JSON.stringify(marker)} for ${type}.`,
+                            edit: { start: a, end: b, text: marker },
+                        });
+                    }
+            }
+            return findings.sort((a, b) => a.start - b.start);
         },
     };
 }
-// Whitespace inside an inline node is protected; only text-node whitespace can wrap.
-function wrappingAtoms(words, extraOpener) {
-    const atoms = [];
+/**
+ * Join words into the atoms that reflow puts on lines. Whitespace-only words
+ * separate atoms; whitespace inside a word, such as in a code span, does not.
+ */
+function wrappingAtoms(words, openers, dollars) {
+    const separated = [];
     let current = "";
     for (const word of words) {
         if (/^[ \t]+$/.test(word)) {
             if (current)
-                atoms.push(current);
+                separated.push(current);
             current = "";
         }
         else
             current += word;
     }
     if (current)
-        atoms.push(current);
+        separated.push(current);
     // Keep atoms that would open a block or underline a Setext heading at the
-    // start of a line attached to the preceding atom.
-    for (let i = 1; i < atoms.length; i++) {
-        if (lineOpener.test(atoms[i]) || extraOpener?.test(atoms[i])) {
-            atoms.splice(i - 1, 2, `${atoms[i - 1]} ${atoms[i]}`);
-            i--;
-        }
+    // start of a line attached to the preceding atom, and so a dollar that
+    // could end math there.
+    const joined = [];
+    let dollarBefore = false;
+    for (const atom of separated) {
+        if (joined.length &&
+            (openers.some((opener) => opener.test(atom)) ||
+                (dollars?.start && dollarBefore && atom.startsWith("$"))))
+            joined[joined.length - 1] += ` ${atom}`;
+        else
+            joined.push(atom);
+        if (atom.includes("$"))
+            dollarBefore = true;
     }
     // An atom ending in an unescaped backslash would become a hard break at the
-    // end of a line; keep it attached to the following atom.
-    for (let i = 0; i < atoms.length - 1; i++) {
-        if (/(?:^|[^\\])(?:\\\\)*\\$/.test(atoms[i])) {
-            atoms.splice(i, 2, `${atoms[i]} ${atoms[i + 1]}`);
-            i--;
-        }
+    // end of a line; keep it attached to the following atom, and so one ending
+    // in a dollar that could begin math there.
+    let lastDollar = -1;
+    joined.forEach((atom, index) => {
+        if (atom.includes("$"))
+            lastDollar = index;
+    });
+    const atoms = [];
+    for (let i = 0; i < joined.length; i++) {
+        let atom = joined[i];
+        while (i < joined.length - 1 &&
+            (/(?:^|[^\\])(?:\\\\)*\\$/.test(atom) || (i < lastDollar && dollars?.end?.(atom))))
+            atom += ` ${joined[++i]}`;
+        atoms.push(atom);
     }
     return atoms;
 }
-// List markers, ATX and Setext heading markers, block quotes, thematic breaks,
-// fences, math, Obsidian comments, HTML blocks, and footnote definitions.
-const lineOpener = /^(?:[-+*]|\d+[.)]|#{1,6}|>|[-*_]{3,}|-{2,}|=+|~{3,}|`{3,}|\$\$|%%|<[!?/A-Za-z]|\[\^[^\]]+\]:)/;
+/**
+ * Words that open a block or underline a heading at the start of a line, the
+ * way CommonMark does with them: as a whole word only. These are list markers,
+ * ATX heading markers, and runs of the character of a thematic break or a
+ * Setext underline, which a line of such words alone forms. A word that only
+ * starts with those characters, such as `--config`, `*delta*`, `#tag`, or
+ * `-5`, opens nothing.
+ */
+const wordOpener = /^(?:[-+*]|\d{1,9}[.)]|#{1,6}|\*+|-+|_+|=+)$/;
+/**
+ * The words of a GFM table's delimiter row, which a line of them alone forms
+ * below a line that then becomes the table's header row.
+ */
+const delimiterRowWord = /^[|:-]*[|-][|:-]*$/;
+/**
+ * Word starts that open a block whatever follows them on the line: block
+ * quotes, fences, math, Obsidian comments, HTML blocks, and footnote
+ * definitions.
+ */
+const prefixOpener = /^(?:>|~{3,}|`{3,}|\$\$|%%|<[!?/A-Za-z]|\[\^[^\]]+\]:)/;
+/** A word that ends in an unescaped dollar, which can begin dollar math at the end of a line. */
+const dollarEnd = /(?:^|[^\\])(?:\\\\)*\$$/;
+/**
+ * A paragraph's first word that would open a thematic break or TOML front
+ * matter alone on the first line. The paragraph's first line holds more than
+ * this word, so it opened neither there.
+ */
+const firstWordAlone = /^(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|\+\+\+)$/;
+/**
+ * The start of a fence or of display math, which the first line of a
+ * paragraph can start with when what follows on the line, such as a backtick
+ * after a backtick fence, keeps it from opening one.
+ */
+const fenceStart = /^(?:`{3,}|~{3,}|\$\$)/;
+/** A link reference definition's label and colon, which a paragraph can start with. */
+const definitionStart = /^\[(?:[^[\]\\]|\\[^])+\]:/;
+/** A GFM table's delimiter row, such as `| --- | :-: |`, after any container markers. */
+const delimiterRow = /^[ \t>]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+/**
+ * Whether text that the parser read as a paragraph or a heading's text has a
+ * table delimiter row as its second line. GitHub reads a table there, and so
+ * does the parser, except directly below a table that ends in a list item or
+ * block quote, where it reads the lines as text (issue #283). Joining the lines
+ * or adding a blank line above them would change what GitHub or the parser
+ * reads.
+ */
+function misreadTable(text) {
+    const second = text.split(lineBreak, 2)[1];
+    return second !== undefined && second.includes("|") && delimiterRow.test(second);
+}
 // Forgejo and Gitea additionally open display math with `\[` and definition
 // descriptions with `:` followed by at least one space or tab, so only a bare
 // `:` atom could open one at the start of a reflowed line.
 const forgeLineOpener = /^(?::$|\\\[)/;
-/** Split text at source whitespace, except inside protected source ranges. */
-function splitWords(text, base, ranges) {
-    if (!ranges.length)
-        return text.split(/([ \t]+)/).filter(Boolean);
-    const words = [];
-    let cursor = 0;
-    for (const match of text.matchAll(/[ \t]+/g)) {
-        const at = base + match.index;
-        if (ranges.some(([from, to]) => at > from && at < to))
-            continue;
-        if (match.index > cursor)
-            words.push(text.slice(cursor, match.index));
-        words.push(match[0]);
-        cursor = match.index + match[0].length;
+/**
+ * Site-generator syntax at the start of a line: a container such as
+ * Docusaurus's `:::note`, or a template tag such as Liquid's `{% tab %}` or
+ * `{{ title }}`. Site generators read it by line, and no dialect gives it
+ * meaning, so a paragraph with a line that starts with it keeps its lines, and
+ * a word that starts with it stays on the line before it (issue #296).
+ */
+const siteSyntax = /^(?::::|\{%|\{\{)/;
+/**
+ * The template tags in `text`, which starts at offset `base`, that each lie on
+ * one line, such as Liquid's `{% data x %}` or `{{ page.title }}`: wrapping
+ * keeps them whole.
+ */
+function templateTags(text, base) {
+    const ranges = [];
+    if (!text.includes("{%") && !text.includes("{{"))
+        return ranges;
+    let at = base;
+    for (const line of text.split(/(?<=\n|\r(?!\n))/)) {
+        for (const [open, close] of [
+            ["{%", "%}"],
+            ["{{", "}}"],
+        ])
+            for (let from = 0;;) {
+                const opener = line.indexOf(open, from);
+                const closer = opener < 0 ? -1 : line.indexOf(close, opener + open.length);
+                if (closer < 0)
+                    break;
+                ranges.push([at + opener, at + closer + close.length]);
+                from = closer + close.length;
+            }
+        at += line.length;
+    }
+    return ranges;
+}
+/** Whether a line of a paragraph, after its container markers, starts with `siteSyntax`. */
+function startsSiteSyntax(text) {
+    return text
+        .split(lineBreak)
+        .some((line, index) => siteSyntax.test(index ? line.replace(/^[ \t>]+/, "") : line));
+}
+/**
+ * A list, heading, or block quote marker as the whole first word of a
+ * paragraph, with more words after it. Directly below text, the parser reads
+ * a marker that would open an empty list item there, such as the second `-` of
+ * `- -`, as text, and the paragraph can continue on the next line. Joining the
+ * next word to the marker would open the block. On Forgejo and Gitea, a bare
+ * `:` joined to the next word would turn a paragraph above it into the term of
+ * a definition list.
+ */
+const leadingMarker = /^(?:[-+*]|\d{1,9}[.)]|#{1,6}|>)[ \t\r\n]/;
+/**
+ * The positions of a paragraph's source where whitespace is not a wrapping
+ * opportunity: those strictly inside a protected source range.
+ */
+class Protection {
+    start;
+    mask;
+    constructor(start, end) {
+        this.start = start;
+        this.mask = new Uint8Array(Math.max(0, end - start));
+    }
+    add(from, to) {
+        this.mask.fill(1, Math.max(0, from + 1 - this.start), Math.max(0, to - this.start));
+    }
+    has(at) {
+        return this.mask[at - this.start] === 1;
+    }
+    /** Split text that starts at offset `base` at whitespace outside protected ranges. */
+    split(text, base) {
+        const words = [];
+        let cursor = 0;
+        for (const match of text.matchAll(/[ \t]+/g)) {
+            if (this.has(base + match.index))
+                continue;
+            if (match.index > cursor)
+                words.push(text.slice(cursor, match.index));
+            words.push(match[0]);
+            cursor = match.index + match[0].length;
+        }
+        if (cursor < text.length)
+            words.push(text.slice(cursor));
+        return words;
+    }
+}
+/**
+ * Inline containers whose text reflow wraps like the paragraph's own: a line
+ * ending in them renders as a space, like one between words. Their delimiters,
+ * and a link's destination, title, or reference label, stay attached to the
+ * neighboring words.
+ */
+const wrappable = new Set(["emphasis", "strong", "delete", "link", "linkReference"]);
+const lineBreakIn = {
+    html: "inline HTML",
+    inlineMath: "math",
+    obsidianComment: "an Obsidian comment",
+};
+function located(node) {
+    return node.position?.start.offset !== undefined && node.position.end.offset !== undefined;
+}
+function holds(node, type) {
+    let found = false;
+    walk(node, (child) => {
+        if (child.type === type)
+            found = true;
+    });
+    return found;
+}
+/**
+ * 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. 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, wholeLinks) {
+    const atoms = [];
+    const breaks = [];
+    let unlocated = false;
+    const destination = { reason: "line break in a link destination or title" };
+    const visit = (parent) => {
+        for (const child of parent.children) {
+            if (child.type === "text")
+                continue;
+            if (!located(child)) {
+                unlocated = true;
+                continue;
+            }
+            const [a, b] = range(child);
+            if (b <= 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 &&
+                !holds(child, "html")) {
+                if (child.type === "link" || child.type === "linkReference") {
+                    const close = labelEnd(child) ?? range(child.children.at(-1))[1];
+                    atoms.push({ from: close, to: b, joining: destination });
+                }
+                visit(child);
+            }
+            else if (child.type === "inlineCode")
+                atoms.push({ from: a, to: b, joining: "code" });
+            else if ((child.type === "image" || child.type === "imageReference") && labelEnd(child)) {
+                const close = labelEnd(child);
+                atoms.push({ from: a, to: close, joining: "description" });
+                atoms.push({ from: close, to: b, joining: destination });
+            }
+            else {
+                const name = lineBreakIn[child.type] ?? (holds(child, "html") ? "inline HTML" : undefined);
+                const reason = `line break in ${name ?? "inline syntax"}`;
+                atoms.push({ from: a, to: b, joining: { reason } });
+            }
+        }
+    };
+    visit(paragraph);
+    atoms.sort((x, y) => x.from - y.from);
+    return { atoms, breaks, unlocated };
+}
+/** The atom whose source holds `at`, among atoms sorted by position. */
+function atomAt(atoms, at) {
+    let low = 0;
+    let high = atoms.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const atom = atoms[middle];
+        if (at <= atom.from)
+            high = middle - 1;
+        else if (at >= atom.to)
+            low = middle + 1;
+        else
+            return atom;
     }
-    if (cursor < text.length)
-        words.push(text.slice(cursor));
-    return words;
+    return undefined;
+}
+/**
+ * The width of a line or line prefix, with a tab advancing to the next
+ * multiple of four columns, the tab stop that CommonMark uses for indentation.
+ */
+function lineWidth(text, measure) {
+    if (!text.includes("\t"))
+        return measure(text);
+    let width = 0;
+    for (const part of text.split(/(\t)/))
+        width += part === "\t" ? 4 - (width % 4) : measure(part);
+    return width;
+}
+/** Whether text parses as a single paragraph. */
+function oneParagraph(text, dialect) {
+    const { children } = parse(text, dialect).tree;
+    return children.length === 1 && children[0].type === "paragraph";
 }
 /**
  * Syntax that Forgejo and Gitea render but GFM parses as prose. A line starting
@@ -217,6 +813,38 @@ function giteaPyParagraph(source, node, start, end) {
     }
     return false;
 }
+/** Inline nodes whose source joined lines cannot change. */
+const obsidianOpaque = new Set(["inlineCode", "inlineMath", "wikiLink", "obsidianHighlight"]);
+/**
+ * Whether joining an Obsidian paragraph's lines could create a highlight or a
+ * wikilink. The parser reads neither across a line break, so `==` and `[[` or
+ * `]]` that it left as text, outside code, math, and the highlights and links
+ * that it did read, could pair up once two lines become one.
+ */
+function obsidianMarkers(source, node, start, end) {
+    if (!/==|\[\[|\]\]/.test(source.slice(start, end)))
+        return false;
+    const opaque = [];
+    walk(node, (child) => {
+        if (obsidianOpaque.has(child.type))
+            opaque.push(range(child));
+    });
+    let text = "";
+    let cursor = start;
+    for (const [a, b] of opaque.sort((x, y) => x[0] - y[0])) {
+        if (b <= cursor)
+            continue;
+        // A space keeps the text on both sides from forming a marker.
+        text += source.slice(cursor, Math.max(cursor, a)) + " ";
+        cursor = Math.min(Math.max(cursor, b), end);
+    }
+    text += source.slice(cursor, end);
+    return /==|\[\[|\]\]/.test(text);
+}
+/** A line's container prefix, with list item markers and checkboxes made blank. */
+function continuationOf(prefix) {
+    return prefix.replace(/(?:[-+*]|\d+[.)]|\[[xX ]\])(?=\s)/g, (value) => " ".repeat(value.length));
+}
 const wrap = {
     description: "Reflow paragraphs using configurable width and protected inline atoms.",
     kind: "style",
@@ -248,15 +876,35 @@ const wrap = {
                     start++;
             }
             let original = document.source.slice(start, end);
-            let calloutHeader = document.dialect === "obsidian" &&
+            const forge = goldmarkForges[document.dialect];
+            // An Obsidian callout or a GitHub, Forgejo, or Gitea alert keeps the line
+            // with its marker, and its title in Obsidian, as written. On Forgejo and
+            // Gitea, a marker written as `\[!NOTE]` starts like display math, and
+            // its paragraph stays as written.
+            let calloutHeader = document.dialect !== "commonmark" &&
                 parent?.type === "blockquote" &&
                 index === 0 &&
-                /^\[![\w-]+\]/.test(original);
+                startsWithMarker(original, node) &&
+                !(forge && original.startsWith("\\["));
+            /** Whether the lines to wrap are the body below that line, in the same paragraph. */
+            let belowHeader = false;
             let lineStart = start;
             while (lineStart > 0 && !/[\r\n]/.test(document.source[lineStart - 1]))
                 lineStart--;
             let prefix = document.source.slice(lineStart, start);
-            const continuation = prefix.replace(/(?:[-+*]|\d+[.)]|\[[xX ]\])(?=\s)/g, (value) => " ".repeat(value.length));
+            const continuation = continuationOf(prefix);
+            // Directly below a link reference definition, a paragraph can start with
+            // a lazy continuation line, which lacks some of the container markers of
+            // the lines around it. The later lines' prefixes cannot be told from it.
+            const above = index ? parent?.children[index - 1] : undefined;
+            let lazyStart = false;
+            if (above?.type === "definition" &&
+                above.position.end.line === node.position.start.line - 1) {
+                const [definitionStart] = range(above);
+                const definitionLine = lineBounds(document.source, definitionStart, definitionStart)[0];
+                lazyStart =
+                    continuationOf(document.source.slice(definitionLine, definitionStart)) !== continuation;
+            }
             if (calloutHeader) {
                 const headerBreak = lineBreak.exec(original);
                 const headerEnd = headerBreak ? start + headerBreak.index : end;
@@ -272,7 +920,7 @@ const wrap = {
                     });
                 // Keep unusual continuations and inline syntax spanning the boundary untouched.
                 if (supported) {
-                    if (options.reportUnbreakable === true && measure(prefix + header) > width)
+                    if (options.reportUnbreakable === true && lineWidth(prefix + header, measure) > width)
                         findings.push({
                             start,
                             end: start + header.length,
@@ -285,11 +933,48 @@ const wrap = {
                     children = children.filter((child) => range(child)[1] > start);
                     prefix = continuation;
                     calloutHeader = false;
+                    belowHeader = true;
                 }
             }
-            const forge = goldmarkForges[document.dialect];
-            const extraOpener = forge ? forgeLineOpener : undefined;
-            let protectedRanges = [];
+            const openers = [wordOpener, prefixOpener, siteSyntax];
+            if (document.dialect !== "commonmark")
+                openers.push(delimiterRowWord);
+            if (forge)
+                openers.push(forgeLineOpener);
+            const { source } = document;
+            // GitHub and Obsidian end dollar math at a single dollar after a line
+            // ending, but not after a space, so a word that starts with `$` stays on
+            // the line of the word before it when a dollar comes before it. Obsidian
+            // also begins math at a single dollar before a line ending, but not
+            // before a space, so a word that ends in a dollar of its text, such as a
+            // lone `$`, stays on the line of the word after it when a dollar comes
+            // after it. Forgejo and Gitea have neither condition.
+            const maths = [];
+            if (document.dialect === "obsidian")
+                walk(node, "inlineMath", (math) => {
+                    maths.push(source.slice(...range(math)));
+                });
+            const dollars = {
+                start: document.dialect === "github" || document.dialect === "obsidian",
+                ...(document.dialect === "obsidian"
+                    ? {
+                        end: (atom) => dollarEnd.test(atom) && !maths.some((math) => atom.endsWith(math)),
+                    }
+                    : {}),
+            };
+            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);
+            // Forgejo and Gitea protections apply before paragraphs are skipped, so
+            // that diagnostics still count one-line math and shortlinks as atoms.
+            const protections = forge
+                ? forgeProtections(source, start, end, forge)
+                : { ranges: [] };
+            for (const [from, to] of protections.ranges)
+                protection.add(from, to);
+            for (const [from, to] of templateTags(source.slice(start, end), start))
+                protection.add(from, to);
             const reportUnbreakable = () => findings.push({
                 start,
                 end,
@@ -301,7 +986,6 @@ const wrap = {
                 let breakable = false;
                 let unbreakable = false;
                 let offset = start;
-                let childIndex = 0;
                 for (const line of original.split(/(?<=\n|\r(?!\n))/)) {
                     const content = line.replace(/(?:\r\n|\r|\n)$/, "");
                     const container = offset === start
@@ -312,29 +996,20 @@ const wrap = {
                     const linePrefix = offset === start ? prefix : container;
                     // An Obsidian title occupies one physical line, even when it contains spaces.
                     if (calloutHeader && offset === start) {
-                        if (measure(prefix + content) > width)
+                        if (lineWidth(prefix + content, measure) > width)
                             unbreakable = true;
                         offset += line.length;
                         continue;
                     }
-                    const words = [];
-                    while (childIndex < children.length && range(children[childIndex])[1] <= offset)
-                        childIndex++;
-                    for (let i = childIndex; i < children.length; i++) {
-                        const child = children[i];
-                        const [a, b] = range(child);
-                        if (a >= offset + content.length)
-                            break;
-                        if (child.type === "break")
-                            continue;
-                        const from = Math.max(a, offset + container.length);
-                        const raw = document.source.slice(from, Math.min(b, offset + content.length));
-                        if (!raw)
-                            continue;
-                        words.push(...(child.type === "text" ? splitWords(raw, from, protectedRanges) : [raw]));
-                    }
-                    const atoms = wrappingAtoms(words, extraOpener);
-                    const available = width - measure(linePrefix);
+                    // Hard-break markers do not count toward the width.
+                    let contentEnd = offset + content.length;
+                    for (const [a] of inline.breaks)
+                        if (a >= offset && a < contentEnd)
+                            contentEnd = a;
+                    const from = offset + container.length;
+                    const words = protection.split(source.slice(from, contentEnd), from);
+                    const atoms = wrappingAtoms(words, openers, dollars);
+                    const available = width - lineWidth(linePrefix, measure);
                     if (measure(words.join("").trimEnd()) > available) {
                         if (atoms.length > 1)
                             breakable = true;
@@ -352,87 +1027,143 @@ const wrap = {
                 if (options.reportUnbreakable === true && unbreakable)
                     reportUnbreakable();
             };
-            const reason = children.some((child) => child.type === "break")
+            // Only the first paragraph of a block quote can be a callout, so a
+            // paragraph elsewhere that starts with a linked image, `[![`, is wrapped.
+            // Below the line of a marker, the paragraph's text no longer starts the
+            // lines to wrap.
+            const markerLike = /^\[![^\]]+\]/;
+            const startsLikeMarker = parent?.type === "blockquote" &&
+                index === 0 &&
+                (belowHeader ? markerLike.test(original) : startsWithMarker(original, node, markerLike));
+            const reason = inline.breaks.length
                 ? "hard line break"
                 : children.some((child) => child.type === "html")
                     ? "inline HTML"
-                    : /^\[![^\]]+\]/.test(original)
+                    : startsLikeMarker
                         ? "callout header"
-                        : /(?:^|\s)\^[\w-]+\s*$/.test(original)
+                        : blockIdentifier(document.source, node)
                             ? "block identifier"
-                            : !/^[\s>\-*+\d.[\]xX)]*$/.test(prefix)
-                                ? "unsupported container prefix"
-                                : undefined;
-            // Protections are computed first so that skipped paragraphs still
-            // classify one-line math and shortlinks as single atoms in diagnostics.
-            const protections = forge
-                ? forgeProtections(document.source, start, end, forge)
-                : { ranges: [] };
-            protectedRanges = protections.ranges;
+                            : leadingMarker.test(original) || (forge && /^:(?:\r|\n)/.test(original))
+                                ? "leading block marker"
+                                : document.dialect !== "commonmark" && misreadTable(original)
+                                    ? "table delimiter row as its second line"
+                                    : startsSiteSyntax(original)
+                                        ? "site-generator syntax at the start of a line"
+                                        : lazyStart
+                                            ? "lazy first line"
+                                            : !/^[\s>\-*+\d.[\]xX)]*$/.test(prefix)
+                                                ? "unsupported container prefix"
+                                                : document.dialect === "obsidian" &&
+                                                    obsidianMarkers(source, node, start, end)
+                                                    ? "Obsidian `==`, `[[`, or `]]` outside highlights and links"
+                                                    : inline.unlocated
+                                                        ? "inline syntax without a source position"
+                                                        : undefined;
             const skipped = reason ??
                 protections.reason ??
-                (document.dialect === "gitea" && giteaPyParagraph(document.source, node, start, end)
+                (document.dialect === "gitea" && giteaPyParagraph(source, node, start, end)
                     ? "Gitea `_.py` emphasis exception"
                     : undefined);
             if (skipped) {
                 reportSkipped(skipped);
                 return;
             }
+            // Collect the words line by line, without the container prefixes. A line
+            // ending between words, or in the text of emphasis or a link, separates
+            // words like a space. One inside an atom joins its lines with the space
+            // that it renders as, or keeps the paragraph as written.
             const words = [];
-            let unsupported = false;
-            for (const child of children) {
-                const [a, b] = range(child);
-                const from = Math.max(a, start);
-                const raw = document.source.slice(from, b);
-                // Odd pieces are the line breaks, so each line's source offset is known.
-                const pieces = raw.split(/(\r\n|\r|\n)/);
-                const lines = [];
-                let at = from;
-                for (let i = 0; i < pieces.length; i += 2) {
-                    let line = pieces[i];
-                    let lineAt = at;
-                    at += line.length + (pieces[i + 1]?.length ?? 0);
-                    if (i > 0 && continuation && line.startsWith(continuation)) {
+            let failure;
+            const pieces = original.split(/(\r\n|\r|\n)/);
+            let at = start;
+            let lineEnd = start;
+            for (let i = 0; i < pieces.length && !failure; i += 2) {
+                let line = pieces[i];
+                let lineAt = at;
+                at += line.length + (pieces[i + 1]?.length ?? 0);
+                if (i > 0) {
+                    if (continuation && line.startsWith(continuation)) {
                         line = line.slice(continuation.length);
                         lineAt += continuation.length;
                     }
-                    else if (i > 0 && continuation && /^[\s>]/.test(line))
-                        unsupported = true;
-                    if (child.type !== "text") {
-                        lines.push(line);
-                        continue;
+                    else if (continuation && /^[\s>]/.test(line)) {
+                        failure = "unsupported continuation";
+                        break;
                     }
-                    // Preserve escaping and entities. Split only ordinary source whitespace.
-                    if (i > 0)
+                    const last = words.at(-1);
+                    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(" ");
-                    words.push(...splitWords(line, lineAt, protectedRanges));
-                }
-                if (child.type !== "text") {
-                    if (raw.includes("\n"))
-                        unsupported = true;
-                    words.push(lines.join(" "));
+                    else if (last === undefined || /^[ \t]+$/.test(last))
+                        failure = "line break in inline syntax";
+                    else if (joining === "code" || joining === "description") {
+                        // In an image description, two spaces or a backslash before the
+                        // line ending make a hard break, and other spaces collapse; in a
+                        // code span, the spaces before it are code. The spaces and tabs
+                        // after it go, as `codeSpanText` reads the span, also the
+                        // indentation below a task item's checkbox, which the parser
+                        // keeps. A lazy line, which keeps them, is not supported above.
+                        if (joining === "description" && /(?: {2}|\\)$/.test(last))
+                            failure = "hard line break";
+                        const trimmed = line.replace(/^[ \t]+/, "");
+                        lineAt += line.length - trimmed.length;
+                        line = trimmed;
+                        words[words.length - 1] = `${joining === "code" ? last : last.trimEnd()} `;
+                    }
+                    else
+                        failure = "reason" in joining ? joining.reason : "line break in inline syntax";
                 }
+                words.push(...protection.split(line, lineAt));
+                lineEnd = lineAt + line.length;
             }
-            if (unsupported) {
-                reportSkipped("multiline inline syntax or unsupported continuation");
+            if (failure) {
+                reportSkipped(failure);
                 return;
             }
-            const atoms = wrappingAtoms(words, extraOpener);
-            const output = [];
-            let line = "";
-            let available = width - measure(prefix);
-            for (const atom of atoms) {
-                const candidate = line ? `${line} ${atom}` : atom;
-                if (line && measure(candidate) > available) {
-                    output.push(line);
-                    line = atom;
-                    available = width - measure(continuation);
+            const atoms = wrappingAtoms(words, openers, dollars);
+            if (!atoms.length)
+                return;
+            // The first line keeps the words after a first word that would open a
+            // block alone on the line, until the line can no longer open one, and
+            // below an alert's or callout's marker line, after a run of `=` or `-`
+            // that would underline that line as a heading.
+            while (atoms.length > 1 &&
+                (firstWordAlone.test(atoms[0]) ||
+                    (belowHeader && /^(?:=+|-+)$/.test(atoms[0])) ||
+                    (fenceStart.test(atoms[0]) && !oneParagraph(atoms[0], document.dialect))))
+                atoms.splice(0, 2, `${atoms[0]} ${atoms[1]}`);
+            /** Fill lines greedily, with the first `first` atoms on the first line. */
+            const fill = (first) => {
+                const lines = [];
+                let line = atoms.slice(0, first).join(" ");
+                let linePrefix = prefix;
+                for (let i = first; i < atoms.length; i++) {
+                    const candidate = `${line} ${atoms[i]}`;
+                    if (lineWidth(linePrefix + candidate, measure) > width) {
+                        lines.push(line);
+                        line = atoms[i];
+                        linePrefix = continuation;
+                    }
+                    else
+                        line = candidate;
                 }
-                else
-                    line = candidate;
+                if (line)
+                    lines.push(line);
+                return lines;
+            };
+            let output = fill(1);
+            // A paragraph that starts like a link reference definition becomes one
+            // when a line ends after the definition's destination or title. Keep
+            // words on the first line until the lines read as one paragraph again.
+            if (output.length > 1 && atoms[0].startsWith("[") && definitionStart.test(atoms.join(" "))) {
+                let first = atoms.findIndex((atom) => atom.includes("]:")) + 1;
+                while (output.length > 1 && !oneParagraph(output.join("\n"), document.dialect))
+                    output = fill(++first);
             }
-            if (line)
-                output.push(line);
             const replacement = output.join(newline + continuation);
             if (replacement !== original)
                 findings.push({
@@ -442,19 +1173,21 @@ const wrap = {
                     edit: { start, end, text: replacement },
                 });
             if (options.reportUnbreakable === true &&
-                (prefix + replacement).split(lineBreak).some((line) => measure(line) > width))
+                (prefix + replacement).split(lineBreak).some((line) => lineWidth(line, measure) > width))
                 reportUnbreakable();
         });
         return findings;
     },
 };
 const table = {
-    description: "Align GFM table cells while preserving their inline source.",
+    description: "Align or compact GFM table cells while preserving their inline source.",
     kind: "style",
     phase: "block",
-    schema: optionsSchema({}),
-    check({ document }) {
+    schema: optionsSchema({ style: { enum: ["aligned", "compact"] } }),
+    check({ document, options }) {
         const findings = [];
+        // A compact table has one space around each cell and the shortest delimiters.
+        const compact = options.style === "compact";
         const newline = lineEnding(document.source);
         walk(document.tree, "table", (node) => {
             const [start, end] = range(node);
@@ -471,9 +1204,10 @@ const table = {
             const count = node.align?.length ?? rows[0]?.length ?? 0;
             if (rows.some((row) => row.length > count))
                 return;
-            const widths = Array.from({ length: count }, (_, i) => Math.max(3, ...rows.map((row) => stringWidth(row[i] ?? ""))));
+            const widths = Array.from({ length: count }, (_, i) => compact ? 3 : Math.max(3, ...rows.map((row) => stringWidth(row[i] ?? ""))));
+            const pad = (cell, i) => compact ? cell : cell + " ".repeat(widths[i] - stringWidth(cell));
             // Keep each row's own cell count: adding cells to a short row changes the parsed table.
-            const rendered = rows.map((row) => `| ${row.map((cell, i) => cell + " ".repeat(widths[i] - stringWidth(cell))).join(" | ")} |`);
+            const rendered = rows.map((row) => `| ${row.map(pad).join(" | ")} |`);
             rendered.splice(1, 0, `| ${widths
                 .map((width, i) => {
                 const align = node.align?.[i];
@@ -487,13 +1221,148 @@ const table = {
                 findings.push({
                     start,
                     end,
-                    message: "Align table cells.",
+                    message: compact ? "Write the table compactly." : "Align table cells.",
                     edit: { start, end, text: replacement },
                 });
         });
         return findings;
     },
 };
+/** 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]|$)/;
+/** 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)
+        node = node.children.at(-1);
+    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
+ * what they mean or what a comment or callout applies to.
+ */
+function together(document, parent, index, directiveLines) {
+    const before = parent.children[index - 1];
+    const after = parent.children[index];
+    const { source } = document;
+    const [beforeStart, beforeEnd] = range(before);
+    const [afterStart, afterEnd] = range(after);
+    // Front matter is not part of the document's text.
+    if (["yaml", "toml"].includes(before.type))
+        return true;
+    // An unclosed HTML comment or block at the end of a list would take in the blank line.
+    if (takesLines(before))
+        return true;
+    // Other tools, too, read a comment as applying to the line below it, and
+    // `mdtools-disable-next-line` does: a blank line would take that line's place.
+    if (before.type === "html" && /^<!--[^]*-->$/.test(before.value.trim()))
+        return true;
+    if (directiveLines.has(after.position.start.line - 1))
+        return true;
+    // The line that opens a callout or alert stays with the body below it.
+    if (index === 1 &&
+        parent.type === "blockquote" &&
+        before.type === "paragraph" &&
+        before.position.start.line === before.position.end.line &&
+        startsWithMarker(source.slice(beforeStart, beforeEnd), before))
+        return true;
+    // Obsidian may attach a block identifier on its own line to the block above.
+    const alone = document.dialect === "obsidian" ? blockIdentifier(source, after) : undefined;
+    if (alone && source.slice(afterStart, afterEnd).trimEnd() === `^${alone.id}`)
+        return true;
+    // Directly below a table that ends inside a list or block quote, the parser
+    // reads the next table as a paragraph, or as the text of a heading
+    // underlined below it, while GitHub reads a table, and a blank line would
+    // make it a table there as well.
+    if (document.dialect !== "commonmark" &&
+        (after.type === "paragraph" || after.type === "heading") &&
+        misreadTable(source.slice(afterStart, afterEnd)))
+        return true;
+    // In a block quote, the parser counts a line of quote markers below a list
+    // that ends in an empty footnote definition as part of the list item, which
+    // makes the item loose.
+    const last = lastBlock(before);
+    if (parent.type === "blockquote" &&
+        before.type === "list" &&
+        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))
+        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);
+}
+const blockSpacing = {
+    description: "Separate headings and lists from neighboring blocks with a blank line.",
+    kind: "style",
+    phase: "block",
+    schema: optionsSchema({}),
+    check({ document }) {
+        const { source } = document;
+        const findings = [];
+        const newline = lineEnding(source);
+        const directiveLines = new Set();
+        if (source.includes("mdtools-"))
+            walk(document.tree, "html", (node) => {
+                if (directive(node.value)?.kind === "disable-next-line")
+                    directiveLines.add(node.position.end.line);
+            });
+        // Only the blocks of the document and of block quotes are compared. A
+        // blank line between the blocks of a list item makes its list loose.
+        walk(document.tree, (parent) => {
+            if (parent.type !== "root" && parent.type !== "blockquote")
+                return;
+            for (let index = 1; index < parent.children.length; index++) {
+                const before = parent.children[index - 1];
+                const after = parent.children[index];
+                const subject = [after, before].find((node) => node.type === "heading" || node.type === "list");
+                // A plugin's syntax can add a node without a source position.
+                const located = [before, after].every(({ position }) => position?.start.offset !== undefined && position.end.offset !== undefined);
+                if (!subject || !located || together(document, parent, index, directiveLines))
+                    continue;
+                const end = range(before)[1];
+                const start = range(after)[0];
+                const lineStart = lineBounds(source, start, start)[0];
+                const breakStart = lineStart - (source.startsWith("\r\n", lineStart - 2) ? 2 : 1);
+                if (breakStart < end)
+                    continue;
+                // A blank line, or one with only quote markers, already separates them.
+                const previous = source.slice(lineBounds(source, breakStart, breakStart)[0], breakStart);
+                if (blankLine.test(previous))
+                    continue;
+                // The block's own line holds the quote markers that the new line needs.
+                const prefix = source.slice(lineStart, start);
+                if (!blankLine.test(prefix))
+                    continue;
+                const kind = subject.type === "heading" ? "heading" : "list";
+                findings.push({
+                    start: subject === after ? start : end,
+                    message: `Add a blank line ${subject === after ? "before" : "after"} the ${kind}.`,
+                    edit: {
+                        start: breakStart,
+                        end: lineStart,
+                        text: source.slice(breakStart, lineStart) + prefix.replace(/[ \t]+$/, "") + newline,
+                    },
+                });
+            }
+        });
+        return findings;
+    },
+};
 export const styleRules = {
     "style/wrap": wrap,
     "style/inline-code": {
@@ -503,22 +1372,39 @@ export const styleRules = {
         schema: optionsSchema({}),
         check({ document }) {
             const findings = [];
+            const { source } = document;
             const forge = goldmarkForges[document.dialect] !== undefined;
+            // In Obsidian, the inline nodes whose source joined lines cannot change.
+            const opaque = [];
+            if (document.dialect === "obsidian")
+                walk(document.tree, (node) => {
+                    if (obsidianOpaque.has(node.type) || node.type === "obsidianComment")
+                        opaque.push(range(node));
+                });
+            const titles = calloutTitles(document);
             let headingEnd = 0;
+            let blockStart = 0;
             walk(document.tree, (node) => {
                 if (node.type === "heading" && forge)
                     headingEnd = range(node)[1];
+                if (inlineBlocks.has(node.type))
+                    blockStart = range(node)[0];
                 if (node.type !== "inlineCode")
                     return;
                 const [start, end] = range(node);
-                if (!/[\r\n]/.test(document.source.slice(start, end)))
+                if (!/[\r\n]/.test(source.slice(start, end)))
                     return;
                 // Forgejo and Gitea look for a heading's attribute block on its last
                 // text line, and Forgejo also builds the anchor from that line alone.
                 // Joining lines would change what that line holds.
                 if (start < headingEnd)
                     return;
-                if (document.dialect === "gitea" && giteaPyLine(document.source, start, end))
+                // Joining keeps the spaces and tabs that start a lazy continuation line,
+                // as GitHub shows them; commonmark.js drops them, and the other
+                // dialects' renderers were not observed there.
+                if (document.dialect !== "github" && lazyIndentation(node))
+                    return;
+                if (document.dialect === "gitea" && giteaPyLine(document, start, end))
                     return;
                 // Joining lines could put a `\(` and `\)` on one line and turn them into math.
                 if (forge) {
@@ -526,9 +1412,48 @@ export const styleRules = {
                     if (lines.includes("\\(") && lines.includes("\\)"))
                         return;
                 }
-                const value = node.value.replace(/\r\n|\r|\n/g, " ");
+                // Joining would move text onto the line of a callout's or alert's
+                // marker, which holds an Obsidian callout's title.
+                if (titles.some(([a, b]) => start >= a && start < b))
+                    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
+                    // runs to the next `==` or `]]`, even inside this or another span.
+                    const [from, to] = lineBounds(source, start, end);
+                    const lines = source.slice(from, to);
+                    let text = "";
+                    let cursor = from;
+                    for (const [a, b] of opaque) {
+                        if (b <= cursor || a >= to)
+                            continue;
+                        // A space keeps the text on both sides from forming a marker.
+                        text += source.slice(cursor, Math.max(cursor, a)) + " ";
+                        cursor = Math.min(b, to);
+                    }
+                    text += source.slice(cursor, to);
+                    if ((text.includes("==") && (lines.match(/==/g) ?? []).length > 1) ||
+                        (text.includes("[[") && lines.includes("]]")))
+                        return;
+                }
+                // The joined span holds the text that GitHub shows. A space at each end
+                // keeps a backtick there from joining the fence, or spaces there from
+                // being taken off.
+                const value = codeSpanText(node);
                 const longest = Math.max(0, ...(value.match(/`+/g) ?? []).map((run) => run.length));
                 const marker = "`".repeat(longest + 1);
+                // An earlier run of the new backticks that the parser left as text, or
+                // that lies in a link destination, would pair with the new opening one.
+                // The span's own backticks cannot have such a run before them.
+                if (marker.length !== /^`+/.exec(source.slice(start, end))[0].length) {
+                    const before = source.slice(blockStart, start);
+                    for (const run of before.matchAll(/`+/g)) {
+                        const length = run[0].length;
+                        if (length === marker.length ||
+                            (escaped(before, run.index) && length - 1 === marker.length))
+                            return;
+                    }
+                }
                 const pad = /^`|`$/.test(value) || (/^ .* $/.test(value) && /[^ ]/.test(value)) ? " " : "";
                 findings.push({
                     start,
@@ -548,8 +1473,10 @@ export const styleRules = {
         kind: "style",
         phase: "document",
         schema: optionsSchema({}),
-        check({ document: { source } }) {
-            if (!source || /[\r\n]$/.test(source))
+        check({ document }) {
+            const { source } = document;
+            // An unclosed block at the end, such as an HTML comment, would take in the line ending.
+            if (!source || /[\r\n]$/.test(source) || takesFinalLineEnding(document))
                 return [];
             return [
                 {
@@ -561,21 +1488,65 @@ export const styleRules = {
         },
     },
     "style/heading": {
-        description: "Use ATX headings.",
+        description: "Use ATX or Setext headings, without closing sequences.",
         kind: "style",
         phase: "block",
-        schema: optionsSchema({}),
-        check({ document }) {
+        schema: optionsSchema({
+            style: { enum: ["atx", "setext", "consistent"] },
+            closing: { enum: ["remove", "keep"] },
+        }),
+        check({ document, options }) {
             const findings = [];
+            const { source } = document;
+            // Only levels 1 and 2 can be underlined; deeper headings keep their `#`.
+            const underlined = underlinedHeadings(document, options.style);
             walk(document.tree, "heading", (node) => {
-                const [start, end] = range(node);
-                if (document.source[start] === "#" || node.position.start.column !== 1)
-                    return;
+                const [headingStart, end] = range(node);
                 const first = node.children[0];
                 const last = node.children.at(-1);
-                if (!first || !last)
+                // An ATX heading is one line, a Setext heading also has its underline.
+                if (!/[\r\n]/.test(source.slice(headingStart, end))) {
+                    const edit = underlined ? underlineEdit(document, node) : undefined;
+                    if (edit) {
+                        findings.push({
+                            start: edit.start,
+                            end: edit.end,
+                            message: "Use an underlined heading.",
+                            edit,
+                        });
+                        return;
+                    }
+                    if (options.closing === "keep")
+                        return;
+                    const textEnd = last
+                        ? range(last)[1]
+                        : headingStart + /^#*/.exec(source.slice(headingStart))[0].length;
+                    const lineEnd = lineBounds(source, textEnd, textEnd)[1];
+                    if (!/^[ \t]+#+[ \t]*$/.test(source.slice(textEnd, lineEnd)))
+                        return;
+                    // Gitea before 1.26 reads an attribute block that a closing sequence
+                    // follows, and Forgejo and later Gitea versions do not.
+                    if (goldmarkForges[document.dialect] &&
+                        first &&
+                        headingAttributeBlock(source.slice(range(first)[0], textEnd)))
+                        return;
+                    findings.push({
+                        start: textEnd,
+                        end: lineEnd,
+                        message: "Remove the closing # sequence.",
+                        edit: { start: textEnd, end: lineEnd, text: "" },
+                    });
+                    return;
+                }
+                if (underlined || !first || !last)
+                    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.
+                const start = range(first)[0];
+                if (lineBounds(source, start, start)[0] !== start)
                     return;
-                let text = document.source.slice(range(first)[0], range(last)[1]);
+                let text = source.slice(start, range(last)[1]);
                 if (/[\r\n]/.test(text))
                     return;
                 // A trailing run of # after whitespace would become an ATX closing
@@ -598,6 +1569,7 @@ export const styleRules = {
             return findings;
         },
     },
+    "style/block-spacing": blockSpacing,
 };
 /** Collect source-positioned nodes for rule/plugin consumers. */
 export function nodesOfType(document, type) {