@aicayzer/inkkit 0.0.16 → 0.0.18

package/dist/preserve.js

@@ -1,14 +1,93 @@
 import { parserCtx, remarkCtx } from '@milkdown/kit/core';
 import { serialize } from './dialect.js';
 import { restoreCodeEndings, finalCodeEnding } from './code-fences.js';
+import { lineBreakHTML, sourceFrontmatter } from './literals.js';
+import { normalizeIdentifier } from 'micromark-util-normalize-identifier';
+// Line endings are the document's, not the node's: a CRLF source and its LF
+// canonical form describe the same text.
 function signature(node) {
-    return JSON.stringify(node, (key, value) => ['position', 'data', 'marker'].includes(key) ? undefined : value);
+    return JSON.stringify(node, function (key, value) {
+        if (['position', 'data', 'marker'].includes(key))
+            return undefined;
+        const holder = this;
+        // Every spelling of a line break reads back as the same break.
+        if (key === 'value' && holder.type === 'html' && lineBreakHTML(value))
+            return '<br />';
+        // A row read as ending in empty cells is the row written without them.
+        if (key === 'children' && holder.type === 'tableRow') {
+            let end = value.length;
+            while (end > 0 && !value[end - 1].children?.length)
+                end--;
+            return value.slice(0, end);
+        }
+        return typeof value === 'string' ? value.replace(/\r\n?/g, '\n') : value;
+    });
 }
 function ownShape(node) {
     return JSON.stringify(node, (key, value) => ['position', 'data', 'children', 'value', 'marker'].includes(key)
         ? undefined
         : value);
 }
+// The character that decides which list an item belongs to: its bullet, or the
+// delimiter after its number. Items with different ones start a new list.
+function markerAt(text, at) {
+    const match = /^(?:[-*+]|\d{1,9}[.)])/.exec(text.slice(at, at + 10));
+    return match
+        ? { at: at + match[0].length - 1, marker: match[0].at(-1) }
+        : undefined;
+}
+function relabel(text, offsets, marker) {
+    for (const offset of offsets) {
+        const found = markerAt(text, offset);
+        if (found &&
+            found.marker !== marker &&
+            /[-*+]/.test(found.marker) === /[-*+]/.test(marker))
+            text = text.slice(0, found.at) + marker + text.slice(found.at + 1);
+    }
+    return text;
+}
+function authoredMarker(list, source) {
+    const at = list.children?.[0]?.position?.start.offset;
+    return at == null ? undefined : markerAt(source, at)?.marker;
+}
+const sameList = (before, after) => before.type === 'list' &&
+    after.type === 'list' &&
+    before.ordered === after.ordered;
+// Canonical Markdown written into authored source. Items written into an
+// authored list take its marker, which they would otherwise split away from.
+// A list written beside an authored list takes a marker that list does not
+// use, which it would otherwise merge with.
+function canonicalSlice(marker, children, canonical, from, to, previous, next) {
+    let text = canonical.slice(from, to);
+    const offsets = (list) => (list.children ?? []).map((item) => item.position.start.offset - from);
+    if (marker)
+        return relabel(text, children.map((item) => item.position.start.offset - from), marker);
+    children.forEach((child, index) => {
+        if (child.type !== 'list') {
+            previous = undefined;
+            return;
+        }
+        const avoid = [previous, index === children.length - 1 ? next : undefined]
+            .filter((neighbour) => neighbour?.ordered === child.ordered)
+            .map((neighbour) => neighbour.marker);
+        const own = markerAt(canonical, child.children[0].position.start.offset)?.marker;
+        const choice = [
+            own,
+            ...(child.ordered ? ['.', ')'] : ['-', '*', '+']),
+        ].find((candidate) => candidate && !avoid.includes(candidate));
+        if (choice)
+            text = relabel(text, offsets(child), choice);
+        previous = { ordered: child.ordered, marker: choice ?? own ?? '' };
+    });
+    return text;
+}
+// The authored list a child is, as a neighbour of canonical Markdown.
+function authoredNeighbour(before, after, source) {
+    if (!before || !after || !sameList(before, after))
+        return undefined;
+    const marker = authoredMarker(before, source);
+    return marker ? { ordered: before.ordered, marker } : undefined;
+}
 function retainText(raw, before, after, quoteIndent = false, inTable = false) {
     before = before.replace(/\r\n?/g, '\n');
     after = after.replace(/\r\n?/g, '\n');
@@ -107,8 +186,90 @@ function retainBoundaryWhitespace(raw, canonical) {
         raw = raw.slice(0, -end.length) + encode(end);
     return raw;
 }
+// The pipes GFM splits a row at; an escaped pipe does not split it.
+function rowPipes(row) {
+    const pipes = [];
+    for (let index = 0; index < row.length; index++)
+        if (row[index] === '\\' && /[\\|]/.test(row[index + 1] ?? ''))
+            index++;
+        else if (row[index] === '|')
+            pipes.push(index);
+    const opening = pipes[0] === row.search(/\S/);
+    const last = row.trimEnd().length - 1;
+    const closing = pipes.at(-1) === last && (!opening || pipes.length > 1) ? last : undefined;
+    return {
+        opening,
+        closing,
+        cells: pipes.length + 1 - Number(opening) - Number(closing != null),
+    };
+}
+// A source row may stop before the header's last cell; the editor holds the
+// rest as empty cells, which stay unwritten until one of them gains content.
+// Then the new cells follow the row's own source, before its closing pipe.
+function retainShortRow(before, after, retain, source, canonical) {
+    const count = before.children.length;
+    const row = retain({ ...after, children: after.children.slice(0, count) });
+    let filled = after.children.length;
+    while (filled > count && !after.children[filled - 1].children?.length)
+        filled--;
+    if (filled === count)
+        return row;
+    const from = after.children[count].position?.start.offset;
+    const to = after.children[filled - 1].position?.end.offset;
+    const start = before.position?.start.offset;
+    const end = before.position?.end.offset;
+    if (from == null || to == null || start == null || end == null)
+        throw new PreservationError('A source token has no location');
+    const kept = rowPipes(row);
+    let output = (kept.closing == null ? row : row.slice(0, kept.closing)).trimEnd();
+    // Without an opening pipe, an empty first cell would not be read at all.
+    if (!kept.opening && !after.children[0].children?.length)
+        output = `|${output ? ' ' : ''}${output.trimStart()}`;
+    for (let cell = kept.cells; cell < count; cell++)
+        output += ' |';
+    // A cell that matches one of the row's own, such as one moved there, keeps
+    // that cell's authored text.
+    const contentOf = (cell) => [
+        cell.children[0].position.start.offset,
+        cell.children.at(-1).position.end.offset,
+    ];
+    const added = after
+        .children.slice(count, filled)
+        .map((cell) => {
+        const text = canonical.slice(cell.position.start.offset, cell.position.end.offset);
+        const original = cell.children?.length
+            ? before.children.find((candidate) => candidate.children?.length &&
+                signature(candidate) === signature(cell))
+            : undefined;
+        if (!original)
+            return text;
+        const [cellFrom, cellTo] = contentOf(cell);
+        const [sourceFrom, sourceTo] = contentOf(original);
+        const offset = cell.position.start.offset;
+        return (text.slice(0, cellFrom - offset) +
+            source.slice(sourceFrom, sourceTo) +
+            text.slice(cellTo - offset));
+    })
+        .join('');
+    const addedPipes = rowPipes(added);
+    const closing = kept.closing != null || rowPipes(source.slice(start, end)).closing != null;
+    return (`${output} ` +
+        (addedPipes.closing == null
+            ? added
+            : added.slice(0, addedPipes.closing)).trimEnd() +
+        (closing ? ' |' : ''));
+}
+// A `<br />` line, read as an HTML block or as a paragraph holding only it.
+function spacer(node) {
+    const html = node?.type === 'paragraph' ? node.children?.[0] : node;
+    return ((node?.type !== 'paragraph' || node.children?.length === 1) &&
+        html?.type === 'html' &&
+        lineBreakHTML(String(html.value)));
+}
 // Patch changed leaves so an adjacent edit retains authored delimiters and labels.
-function retainSource(before, after, source, canonical, lineEnding, inTable = false) {
+function retainSource(before, after, source, canonical, lineEnding, inTable = false, 
+// The header's cell count, for the rows of a table.
+width) {
     const start = before.position?.start.offset;
     const end = before.position?.end.offset;
     const newStart = after.position?.start.offset;
@@ -119,16 +280,25 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
     if (before.type === 'code' &&
         after.type === 'code' &&
         before.lang === after.lang) {
+        if ((before.value ?? '') === (after.value ?? ''))
+            return raw;
         const opening = /^([ \t>]*)(`{3,}|~{3,})([^\r\n]*)(\r?\n)/.exec(raw);
         if (opening) {
             const lines = raw.slice(opening[0].length).split(/\r?\n/);
             const closing = /^([ \t>]*)(`{3,}|~{3,})([ \t]*)$/.exec(lines.at(-1) ?? '');
             const originalLine = (before.value ?? '').replace(/\r\n?/g, '\n').split('\n')[0] ?? '';
-            const first = lines[0] ?? '';
-            const gutter = first.endsWith(originalLine)
-                ? first.slice(0, first.length - originalLine.length)
-                : opening[1];
-            const body = (after.value ?? '').replace(/\r\n?/g, '\n').split('\n');
+            // A fence whose code is empty or starts with a blank line has no line
+            // to take the indent from but its closing one.
+            const first = originalLine ? lines[0] : undefined;
+            const gutter = first === undefined
+                ? (closing?.[1] ?? opening[1])
+                : first.endsWith(originalLine)
+                    ? first.slice(0, first.length - originalLine.length)
+                    : opening[1];
+            // A code block without code is written as a fence with no line inside.
+            const body = after.value
+                ? after.value.replace(/\r\n?/g, '\n').split('\n')
+                : [];
             const character = opening[2][0];
             let length = opening[2].length;
             for (const line of body) {
@@ -140,8 +310,8 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
             return (opening[1] +
                 fence +
                 opening[3] +
-                lineEnding +
-                body.map((line) => gutter + line).join(lineEnding) +
+                body.map((line) => lineEnding + gutter + line).join('') +
+                (closing || body.length ? '' : opening[4]) +
                 (closing
                     ? lineEnding +
                         closing[1] +
@@ -162,33 +332,92 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
                     : String(after.url)) +
                 destination[3]);
     }
+    if (before.type === 'tableRow' &&
+        after.type === 'tableRow' &&
+        before.children &&
+        after.children &&
+        width != null &&
+        before.children.length < width &&
+        after.children.length === width)
+        return retainShortRow(before, after, (row) => retainSource(before, row, source, canonical, lineEnding, inTable), source, canonical);
+    if (before.type === 'tableCell' &&
+        after.type === 'tableCell' &&
+        !before.children?.length &&
+        after.children?.length) {
+        // An empty cell's range is only its pipe and padding, so its new content
+        // goes inside them rather than through the whole-range boundary check.
+        const from = after.children[0].position?.start.offset;
+        const to = after.children.at(-1).position?.end.offset;
+        if (from == null || to == null)
+            throw new PreservationError('A source token has no location');
+        const pipes = rowPipes(raw);
+        return `${pipes.opening ? '| ' : ''}${canonical.slice(from, to)} ${pipes.closing != null ? '|' : ''}`;
+    }
+    if (before.type === 'listItem' &&
+        after.type === 'listItem' &&
+        before.children &&
+        after.children &&
+        before.children.length === after.children.length + 1 &&
+        (spacer(before.children[0]) || before.children[0].type === 'paragraph') &&
+        after.children[0]?.type !== 'paragraph' &&
+        !spacer(after.children[0])) {
+        // The item now opens with an empty line before a block, which is written
+        // as no line. The blocks after it keep their authored source.
+        const retained = retainSource({ ...before, children: before.children.slice(1) }, { ...after, spread: before.spread }, source, canonical, lineEnding, inTable);
+        const first = before.children[0];
+        if (spacer(first))
+            return retained;
+        // An emptied first line is kept as the `<br />` line it reads back as.
+        const from = first.position.start.offset - start;
+        const to = first.position.end.offset - start;
+        return retained.startsWith(source.slice(start, before.children[1].position.start.offset))
+            ? retained.slice(0, from) + '<br />' + retained.slice(to)
+            : retained;
+    }
     if (before.type === 'text' && after.type === 'text')
-        return retainBoundaryWhitespace(retainText(raw, before.value, after.value, false, inTable), canonical.slice(newStart, newEnd));
+        return retainBoundaryWhitespace(withEnding(retainText(raw, before.value, after.value, false, inTable), lineEnding), canonical.slice(newStart, newEnd));
     if (signature(before) === signature(after) &&
         ownShape(before) === ownShape(after))
         return raw;
+    const marker = sameList(before, after)
+        ? authoredMarker(before, source)
+        : undefined;
     if (before.type === after.type &&
         ownShape(before) === ownShape(after) &&
         before.children &&
         after.children &&
         before.children.length === after.children.length) {
-        let output = '', previous = start;
-        const retained = new Set();
+        let output = '', at = start;
+        let previous;
+        const same = (candidate, incoming) => signature(candidate) === signature(incoming) &&
+            ownShape(candidate) === ownShape(incoming);
+        const reorderable = before.type === 'table' || before.type === 'tableRow';
+        // Equal rows or cells can differ in spelling, so each one that stayed in
+        // place keeps its own source before any moved one is matched.
+        const retained = new Set(reorderable
+            ? before.children.flatMap((child, index) => same(child, after.children[index]) ? [index] : [])
+            : []);
         before.children.forEach((child, index) => {
             const incoming = after.children[index];
-            const movedIndex = before.type === 'table' || before.type === 'tableRow'
-                ? before.children.findIndex((candidate, candidateIndex) => !retained.has(candidateIndex) &&
-                    signature(candidate) === signature(incoming) &&
-                    ownShape(candidate) === ownShape(incoming))
-                : -1;
+            const movedIndex = !reorderable
+                ? -1
+                : same(child, incoming)
+                    ? index
+                    : before.children.findIndex((candidate, candidateIndex) => !retained.has(candidateIndex) && same(candidate, incoming));
             const original = movedIndex < 0 ? child : before.children[movedIndex];
             if (movedIndex >= 0)
                 retained.add(movedIndex);
             const childStart = child.position?.start.offset, childEnd = child.position?.end.offset;
             if (childStart == null || childEnd == null)
                 throw new PreservationError('A source token has no location');
-            let retainedSource = retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === 'tableCell');
-            if (before.type === 'tableRow' && movedIndex >= 0) {
+            let retainedSource = incoming.type === 'list' && !sameList(original, incoming)
+                ? withEnding(canonicalSlice(undefined, [incoming], canonical, incoming.position.start.offset, incoming.position.end.offset, previous, authoredNeighbour(before.children[index + 1], after.children[index + 1], source)), lineEnding)
+                : retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === 'tableCell', before.type === 'table'
+                    ? before.children[0]?.children?.length
+                    : undefined);
+            if (before.type === 'tableRow' &&
+                movedIndex >= 0 &&
+                movedIndex !== index) {
                 // Cell positions own different pipe boundaries at the row edges.
                 const originalFrom = original.children?.[0]?.position?.start.offset;
                 const originalTo = original.children?.at(-1)?.position?.end.offset;
@@ -202,14 +431,21 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
                         ? source.slice(childStart, from) +
                             source.slice(originalFrom, originalTo) +
                             source.slice(to, childEnd)
-                        : canonical
-                            .slice(incoming.position.start.offset, incoming.position.end.offset)
-                            .replaceAll('\n', lineEnding);
+                        : withEnding(canonical.slice(incoming.position.start.offset, incoming.position.end.offset), lineEnding);
             }
-            output += source.slice(previous, childStart) + retainedSource;
-            previous = childEnd;
+            if (marker)
+                retainedSource = relabel(retainedSource, [0], marker);
+            previous =
+                incoming.type !== 'list'
+                    ? undefined
+                    : (authoredNeighbour(original, incoming, source) ?? {
+                        ordered: incoming.ordered,
+                        marker: markerAt(retainedSource, /^[ \t]*/.exec(retainedSource)[0].length)?.marker ?? '',
+                    });
+            output += source.slice(at, childStart) + retainedSource;
+            at = childEnd;
         });
-        return output + source.slice(previous, end);
+        return output + source.slice(at, end);
     }
     if (before.type === after.type &&
         ownShape(before) === ownShape(after) &&
@@ -225,24 +461,85 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
             signature(before.children[before.children.length - 1 - suffix]) ===
                 signature(after.children[after.children.length - 1 - suffix]))
             suffix++;
+        // A cell's range includes its pipe and padding, which would hide a space
+        // now at the edge of its content from the boundary check.
+        const cell = before.type === 'tableCell' &&
+            before.children.length > 0 &&
+            after.children.length > 0;
+        const first = cell ? before.children[0].position?.start.offset : start;
+        const last = cell ? before.children.at(-1).position?.end.offset : end;
+        const newFirst = cell ? after.children[0].position?.start.offset : newStart;
+        const newLast = cell ? after.children.at(-1).position?.end.offset : newEnd;
         const from = prefix
             ? before.children[prefix - 1].position?.end.offset
-            : start;
+            : first;
         const to = suffix
             ? before.children[before.children.length - suffix].position?.start.offset
-            : end;
+            : last;
         const newFrom = prefix
             ? after.children[prefix - 1].position?.end.offset
-            : newStart;
+            : newFirst;
         const newTo = suffix
             ? after.children[after.children.length - suffix].position?.start.offset
-            : newEnd;
-        if (from != null && to != null && newFrom != null && newTo != null)
-            return retainBoundaryWhitespace(source.slice(start, from) +
-                canonical.slice(newFrom, newTo).replaceAll('\n', lineEnding) +
-                source.slice(to, end), canonical.slice(newStart, newEnd));
+            : newLast;
+        if (first != null &&
+            last != null &&
+            newFirst != null &&
+            newLast != null &&
+            from != null &&
+            to != null &&
+            newFrom != null &&
+            newTo != null)
+            return (source.slice(start, first) +
+                retainBoundaryWhitespace(source.slice(first, from) +
+                    withEnding(canonicalSlice(marker, after.children.slice(prefix, after.children.length - suffix), canonical, newFrom, newTo, authoredNeighbour(before.children[prefix - 1], after.children[prefix - 1], source), authoredNeighbour(before.children[before.children.length - suffix], after.children[after.children.length - suffix], source)), lineEnding) +
+                    source.slice(to, last), canonical.slice(newFirst, newLast)) +
+                source.slice(last, end));
     }
-    return canonical.slice(newStart, newEnd).replaceAll('\n', lineEnding);
+    // A list can end after blank lines that its container gave it; keep the
+    // authored ones rather than add the canonical ones beside them, unless the
+    // list became tight or loose, which those lines can undo.
+    const lastAfter = after.children?.at(-1)?.position?.end.offset;
+    const lastBefore = before.children?.at(-1)?.position?.end.offset;
+    const trailing = marker != null &&
+        lastAfter != null &&
+        lastBefore != null &&
+        loose(before, source) === loose(after, canonical);
+    return (withEnding(canonicalSlice(marker, after.children ?? [], canonical, newStart, trailing ? lastAfter : newEnd), lineEnding) + (trailing ? source.slice(lastBefore, end) : ''));
+}
+// Whether blank lines separate a list's items or the blocks inside one. A
+// list's own spread can also count blank lines after its last item.
+function loose(list, text) {
+    const blank = (from, to) => from != null && to != null && /\n[ \t>]*\r?\n/.test(text.slice(from, to));
+    const gaps = (nodes) => nodes.some((node, index) => index
+        ? blank(nodes[index - 1].position?.end.offset, node.position?.start.offset)
+        : false);
+    const items = list.children ?? [];
+    return gaps(items) || items.some((item) => gaps(item.children ?? []));
+}
+// How a reference label is matched to a definition. Footnote labels, which
+// start with `^`, are a separate set.
+function definitionLabel(label) {
+    return label.startsWith('^')
+        ? '^' + normalizeIdentifier(label.slice(1))
+        : normalizeIdentifier(label);
+}
+// Whether two nodes have the same blocks, leaving inline content aside.
+function sameBlocks(left, right) {
+    if (left.type !== right.type || left.isTextblock !== right.isTextblock)
+        return false;
+    if (left.isTextblock)
+        return true;
+    if (left.childCount !== right.childCount)
+        return false;
+    for (let index = 0; index < left.childCount; index++)
+        if (!sameBlocks(left.child(index), right.child(index)))
+            return false;
+    return true;
+}
+// Canonical Markdown keeps authored CRLF inside literal blocks and code fences.
+function withEnding(text, lineEnding) {
+    return lineEnding === '\n' ? text : text.replace(/\r?\n/g, lineEnding);
 }
 function positionalNode(tree, transformed) {
     return (tree.children.find((node) => node.position?.start.offset === transformed.position?.start.offset &&
@@ -264,7 +561,7 @@ function blockForm(ctx, node) {
         return '<br />';
     return form(serialize(ctx, node.type.schema.topNodeType.create(null, [node])));
 }
-function semanticSignature(doc) {
+export function semanticSignature(doc) {
     const clean = (value) => {
         if (value.type === 'inkkit_wiki_link' && value.attrs) {
             const { raw: _raw, inTable: _inTable, ...attrs } = value.attrs;
@@ -303,7 +600,6 @@ function semanticSignature(doc) {
     [
         'referenceContent',
         'referenceType',
-        'listPlaceholder',
         'marker',
         'id',
         'label',
@@ -324,11 +620,12 @@ function withoutHeadingId(node) {
         : node;
 }
 const MATCHING_BUDGET = 1_000_000;
+const SIMILARITY_BUDGET = 4_000_000;
 // Unchanged blocks are anchored first, so a long document with many scattered
 // edits is matched as many short gaps rather than one wide span.
 export function correspondence(before, after) {
     const result = new Array(after.length);
-    const work = { budget: MATCHING_BUDGET };
+    const work = { budget: MATCHING_BUDGET, similarity: SIMILARITY_BUDGET };
     const spans = [{ b: 0, a: 0, bEnd: before.length, aEnd: after.length }];
     for (let span = spans.pop(); span; span = spans.pop()) {
         let { b, a, bEnd, aEnd } = span;
@@ -401,17 +698,21 @@ function uniqueAnchors(before, after, b, bEnd, a, aEnd) {
     }
     return anchors.reverse();
 }
-// Edit distance distinguishes replacements from insertions, so replacing a block
-// retains its surrounding whitespace without assigning it a neighbour's source.
+// Replacing a block costs more than inserting or deleting one, so an unchanged
+// block keeps its own copy rather than pairing with a deleted neighbour, and
+// less than both, so an edited block still keeps its surrounding whitespace.
+const INDEL = 2;
+const REPLACE = 3;
 function align(before, after, b, bEnd, a, aEnd, result, work) {
     const rows = bEnd - b + 1;
     const columns = aEnd - a + 1;
-    let width = Math.max(1, Math.abs(rows - columns));
+    const offset = Math.abs(rows - columns);
+    let width = Math.max(1, offset);
     for (;;) {
         const costs = [];
         const get = (i, j) => i < 0 || j < 0 || Math.abs(i - j) > width
-            ? width + 1
-            : (costs[i]?.[j - Math.max(0, i - width)] ?? width + 1);
+            ? Infinity
+            : (costs[i]?.[j - Math.max(0, i - width)] ?? Infinity);
         for (let i = 0; i < rows; i++) {
             const from = Math.max(0, i - width);
             const to = Math.min(columns - 1, i + width);
@@ -421,38 +722,102 @@ function align(before, after, b, bEnd, a, aEnd, result, work) {
             const row = new Uint32Array(to - from + 1);
             costs.push(row);
             for (let j = from; j <= to; j++) {
-                const change = before[b + i - 1] === after[a + j - 1] ? 0 : 1;
+                const change = before[b + i - 1] === after[a + j - 1] ? 0 : REPLACE;
                 row[j - from] =
                     i === 0
-                        ? j
+                        ? j * INDEL
                         : j === 0
-                            ? i
-                            : Math.min(get(i - 1, j) + 1, get(i, j - 1) + 1, get(i - 1, j - 1) + change);
+                            ? i * INDEL
+                            : Math.min(get(i - 1, j) + INDEL, get(i, j - 1) + INDEL, get(i - 1, j - 1) + change);
             }
         }
-        // A path with at most width edits cannot leave this diagonal band.
-        // Widen only when needed, charging every attempt to the same work budget.
-        if (get(rows - 1, columns - 1) > width) {
+        // A path that leaves the band takes at least width + 1 insertions or
+        // deletions away from the diagonal and width + 1 - offset back to its end,
+        // so a path inside the band that costs no more is optimal. Widen only when
+        // needed, charging every attempt to the same work budget.
+        if (width < Math.max(rows, columns) - 1 &&
+            get(rows - 1, columns - 1) > INDEL * (2 * (width + 1) - offset)) {
             width *= 2;
             continue;
         }
+        const unchanged = [];
         let i = rows - 1;
         let j = columns - 1;
         while (i || j) {
-            const change = i && j && before[b + i - 1] === after[a + j - 1] ? 0 : 1;
-            if (i && j && get(i, j) === get(i - 1, j - 1) + change) {
+            const same = i && j && before[b + i - 1] === after[a + j - 1];
+            if (i && j && get(i, j) === get(i - 1, j - 1) + (same ? 0 : REPLACE)) {
                 result[a + j - 1] = b + i - 1;
+                if (same)
+                    unchanged.push({ b: b + i - 1, a: a + j - 1 });
                 i--;
                 j--;
             }
-            else if (i && get(i, j) === get(i - 1, j) + 1)
+            else if (i && get(i, j) === get(i - 1, j) + INDEL)
                 i--;
             else
                 j--;
         }
+        unchanged.push({ b: b - 1, a: a - 1 });
+        unchanged.reverse().push({ b: bEnd, a: aEnd });
+        for (let index = 1; index < unchanged.length; index++)
+            pairSimilar(before, after, unchanged[index - 1].b + 1, unchanged[index].b, unchanged[index - 1].a + 1, unchanged[index].a, result, work);
         return;
     }
 }
+// Between unchanged blocks, edit distance prices every replacement alike, so
+// it cannot tell which original an edited block came from. Pair each with the
+// original it most resembles, keeping their order: typing in a block then keeps
+// its own source even when a neighbour was inserted or deleted beside it.
+function pairSimilar(before, after, b, bEnd, a, aEnd, result, work) {
+    const removed = bEnd - b;
+    const added = aEnd - a;
+    if (!removed || !added || (removed === 1 && added === 1))
+        return;
+    // Resemblance decides; among equally resembling pairings, more pairs keep
+    // more replaced blocks in place with their surrounding whitespace.
+    const bonus = 1 / (Math.min(removed, added) + 1);
+    // This is a refinement with its own budget of characters compared. When it
+    // runs out, the alignment's pairing stands rather than the edit failing.
+    if (removed * added > work.similarity)
+        return;
+    const weights = new Float64Array(removed * added);
+    for (let x = 0; x < removed; x++)
+        for (let y = 0; y < added; y++) {
+            const shared = similarity(before[b + x], after[a + y]);
+            work.similarity -= shared + 1;
+            if (work.similarity < 0)
+                return;
+            weights[x * added + y] = shared + bonus;
+        }
+    const best = Array.from({ length: removed + 1 }, () => new Float64Array(added + 1));
+    for (let x = 1; x <= removed; x++)
+        for (let y = 1; y <= added; y++)
+            best[x][y] = Math.max(best[x - 1][y], best[x][y - 1], best[x - 1][y - 1] + weights[(x - 1) * added + y - 1]);
+    for (let index = a; index < aEnd; index++)
+        result[index] = undefined;
+    for (let x = removed, y = added; x && y;) {
+        if (best[x][y] ===
+            best[x - 1][y - 1] + weights[(x - 1) * added + y - 1]) {
+            result[a + --y] = b + --x;
+        }
+        else if (best[x][y] === best[x - 1][y])
+            x--;
+        else
+            y--;
+    }
+}
+// Characters an edit left in place at the start and end of a block.
+function similarity(left, right) {
+    const limit = Math.min(left.length, right.length);
+    let prefix = 0;
+    while (prefix < limit && left[prefix] === right[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < limit - prefix &&
+        left[left.length - 1 - suffix] === right[right.length - 1 - suffix])
+        suffix++;
+    return prefix + suffix;
+}
 /** Retains the loaded source of blocks the edit leaves alone. */
 export class Preservation {
     ctx;
@@ -462,7 +827,12 @@ export class Preservation {
     lineEnding;
     originalForms = new Set();
     forms = new WeakMap();
-    textBlockEdits = new WeakMap();
+    blockEdits = new WeakMap();
+    itemEdits = new WeakMap();
+    definitionNodes = new Map();
+    // Undefined when a definition sits inside another block, where appending
+    // the top-level ones would not reproduce the document.
+    definitionSources;
     constructor(ctx, source) {
         this.ctx = ctx;
         this.source = source;
@@ -505,6 +875,19 @@ export class Preservation {
             }
             for (const block of this.blocks)
                 this.originalForms.add(block.form);
+            const definition = (node) => node.type === 'definition' || node.type === 'footnoteDefinition';
+            const nested = (node) => (node.children ?? []).some((child) => definition(child) || nested(child));
+            const top = rawTree.children;
+            if (!top.some(nested))
+                this.definitionSources = top.filter(definition).map((node) => {
+                    const raw = source.slice(node.position.start.offset + offset, node.position.end.offset + offset);
+                    // A footnote reference is never validated alone, so only its label
+                    // matters, and its body need not be parsed on every keystroke.
+                    const label = /^\[((?:\\[\s\S]|[^\\\]])*)\]:/.exec(raw)[1];
+                    return node.type === 'footnoteDefinition'
+                        ? { label: definitionLabel(label), text: `[${label}]: x` }
+                        : { label: definitionLabel(label), text: raw };
+                });
         }
         catch (cause) {
             if (cause instanceof PreservationError)
@@ -522,121 +905,475 @@ export class Preservation {
         return (this.source.slice(block.start, start + offset) +
             retainSource(block.ast, after, this.source.slice(offset), canonical, this.lineEnding));
     }
-    independentTextBlocks(doc) {
+    localEdits(doc) {
         if (this.baseline.childCount !== this.blocks.length ||
             doc.childCount !== this.blocks.length ||
             !doc.sameMarkup(this.baseline))
             return undefined;
         let output = '', previous = 0;
-        for (let index = 0; index < doc.childCount; index++) {
-            const node = doc.child(index);
-            const before = this.baseline.child(index);
-            const block = this.blocks[index];
-            if (node.eq(before))
+        let run = [];
+        for (let index = 0; index <= doc.childCount; index++) {
+            const node = index < doc.childCount ? doc.child(index) : undefined;
+            if (!node || node.eq(this.baseline.child(index))) {
+                if (run.length > 1 && !this.pairedInPlace(doc, run))
+                    return undefined;
+                run = [];
                 continue;
-            let retained = this.textBlockEdits.get(node);
+            }
+            run.push(index);
+            const block = this.blocks[index];
+            let retained = this.blockEdits.get(node);
             if (retained?.index !== index) {
-                const raw = this.source.slice(block.start, block.end);
-                const expected = withoutHeadingId(node);
-                // References and HTML/comments can depend on other blocks. Restrict
-                // local validation to text blocks without these context-sensitive forms.
-                const contextual = /[\[<]|%%/;
-                const textOnly = (block) => {
-                    let valid = true;
-                    block.forEach((child) => {
-                        if (!child.isText)
-                            valid = false;
-                    });
-                    return valid;
-                };
-                if (!['paragraph', 'heading'].includes(node.type.name) ||
-                    !expected.sameMarkup(withoutHeadingId(before)) ||
-                    !textOnly(node) ||
-                    !textOnly(before) ||
-                    contextual.test(raw) ||
-                    (index > 0 &&
-                        !/\r?\n[ \t]*\r?\n/.test(this.source.slice(this.blocks[index - 1].end, block.start))) ||
-                    (index + 1 < this.blocks.length &&
-                        !/\r?\n[ \t]*\r?\n/.test(this.source.slice(block.end, this.blocks[index + 1].start))))
-                    return undefined;
-                const canonical = blockForm(this.ctx, node);
-                if (contextual.test(canonical) ||
-                    (canonical !== block.form && this.originalForms.has(canonical)))
-                    return undefined;
-                const tree = this.ctx.get(remarkCtx).parse(canonical);
-                if (tree.children.length !== 1)
-                    return undefined;
-                const text = this.retainBlock(block, tree.children[0], canonical);
-                const reopened = this.ctx.get(parserCtx)(text);
-                if (reopened.childCount !== 1)
-                    return undefined;
-                if (!withoutHeadingId(reopened.firstChild).eq(expected))
+                const text = this.localBlock(index, node);
+                if (text === undefined)
                     return undefined;
                 retained = { index, text };
-                this.textBlockEdits.set(node, retained);
+                this.blockEdits.set(node, retained);
             }
             output += this.source.slice(previous, block.start) + retained.text;
             previous = block.end;
         }
-        return output + this.source.slice(previous);
+        output += this.source.slice(previous);
+        // Front matter is found by reading from the start of the file to the next
+        // delimiter line, which an edited block can supply.
+        const bom = (text) => text.replace(/^\uFEFF/, '');
+        return sourceFrontmatter(bom(output)) ===
+            sourceFrontmatter(bom(this.source))
+            ? output
+            : undefined;
+    }
+    // Whole-document matching pairs adjacent edited blocks by resemblance, which
+    // can pair one with its neighbour's original. Keep its result exactly.
+    pairedInPlace(doc, run) {
+        if (run.some((index) => ['bullet_list', 'ordered_list'].includes(doc.child(index).type.name)))
+            return false;
+        const before = run.map((index) => this.blocks[index].form);
+        const after = run.map((index) => this.formOf(doc.child(index)));
+        const result = run.map((_, at) => at);
+        pairSimilar(before, after, 0, run.length, 0, run.length, result, {
+            similarity: SIMILARITY_BUDGET,
+        });
+        return result.every((position, at) => position === at);
+    }
+    // Every definition in the source, in order. A block's links can depend on
+    // definitions and nothing else outside it, so parsing it with these gives
+    // the meaning it has in the document.
+    // The definitions a block's text can refer to: only a bracketed label that
+    // matches one can resolve, so the others need not be parsed with it.
+    definitions(text) {
+        if (this.definitionSources === undefined)
+            return undefined;
+        const labels = new Set();
+        for (const match of text.matchAll(/\[((?:\\[\s\S]|[^\\[\]])*)\]/g))
+            labels.add(definitionLabel(match[1]));
+        const sources = this.definitionSources
+            .filter((source) => labels.has(source.label))
+            .map((source) => source.text);
+        const appended = sources.join('\n\n');
+        let nodes = this.definitionNodes.get(appended);
+        if (nodes === undefined) {
+            nodes = appended ? this.ctx.get(parserCtx)(appended).childCount : 0;
+            this.definitionNodes.set(appended, nodes);
+        }
+        return { text: appended, blocks: sources.length, nodes };
+    }
+    // The block's text followed by what it can depend on elsewhere in the
+    // document, or undefined when that cannot be known from the block alone.
+    inContext(text) {
+        // HTML and %% comments can span blocks.
+        if (/<|%%/.test(text))
+            return undefined;
+        if (!text.includes('['))
+            return { text, blocks: 1, nodes: 1 };
+        const definitions = this.definitions(text);
+        if (!definitions)
+            return undefined;
+        return definitions.text
+            ? {
+                text: text + this.lineEnding.repeat(2) + definitions.text,
+                blocks: 1 + definitions.blocks,
+                nodes: 1 + definitions.nodes,
+            }
+            : { text, blocks: 1, nodes: 1 };
+    }
+    // The first block of text as the document would read it in place.
+    parseLocally(text) {
+        const local = this.inContext(text);
+        if (!local)
+            return undefined;
+        const parsed = this.ctx.get(parserCtx)(local.text);
+        return parsed.childCount === local.nodes ? parsed.firstChild : undefined;
+    }
+    // Canonical Markdown for a block and its source tree, read in the same
+    // context, so references in it resolve as they do in the document.
+    canonicalTree(text) {
+        const local = this.inContext(text);
+        if (!local)
+            return undefined;
+        const tree = this.ctx.get(remarkCtx).parse(local.text);
+        return tree.children.length === local.blocks
+            ? {
+                canonical: local.text,
+                node: tree.children[0],
+            }
+            : undefined;
+    }
+    // Inline content other than text and line breaks can depend on other blocks
+    // or carry attributes that a reparse does not reproduce.
+    static plainInline(node) {
+        let plain = true;
+        node.descendants((child) => {
+            if (child.isInline && !child.isText && child.type.name !== 'hardbreak')
+                plain = false;
+            return plain;
+        });
+        return plain;
+    }
+    separated(index) {
+        const block = this.blocks[index];
+        return ((index === 0 ||
+            /\r?\n[ \t]*\r?\n/.test(this.source.slice(this.blocks[index - 1].end, block.start))) &&
+            (index + 1 === this.blocks.length ||
+                /\r?\n[ \t]*\r?\n/.test(this.source.slice(block.end, this.blocks[index + 1].start))));
+    }
+    // Validates a changed block on its own when nothing outside it can change
+    // what it means, so a keystroke does not serialize and reparse the document.
+    localBlock(index, node) {
+        const before = this.baseline.child(index);
+        const block = this.blocks[index];
+        const expected = withoutHeadingId(node);
+        if (!expected.sameMarkup(withoutHeadingId(before)) ||
+            !this.separated(index))
+            return undefined;
+        if (node.type.name === 'bullet_list' || node.type.name === 'ordered_list')
+            return this.localItems(index, node);
+        const code = node.type.name === 'code_block';
+        // Indented code is rewritten fenced, and the blocks after it can then read
+        // differently.
+        if (code &&
+            !/^ {0,3}(?:`{3,}|~{3,})/.test(this.source.slice(block.start, block.end)))
+            return undefined;
+        if (!code &&
+            (!['paragraph', 'heading', 'table'].includes(node.type.name) ||
+                !Preservation.plainInline(node) ||
+                !Preservation.plainInline(before) ||
+                !this.inContext(this.source.slice(block.start, block.end))))
+            return undefined;
+        const form = this.formOf(node);
+        if (form !== block.form && this.originalForms.has(form))
+            return undefined;
+        // Code is literal, so only its fence decides where it ends.
+        const canonical = code
+            ? (() => {
+                const tree = this.ctx.get(remarkCtx).parse(form);
+                return tree.children.length === 1
+                    ? {
+                        canonical: form,
+                        node: tree.children[0],
+                    }
+                    : undefined;
+            })()
+            : this.canonicalTree(form);
+        if (!canonical)
+            return undefined;
+        const text = this.retainBlock(block, canonical.node, canonical.canonical);
+        const reopened = code
+            ? (() => {
+                const parsed = this.ctx.get(parserCtx)(text);
+                return parsed.childCount === 1 ? parsed.firstChild : undefined;
+            })()
+            : this.parseLocally(text);
+        // The authored fence is presentation the editor keeps from loading.
+        const same = (node) => code
+            ? node.type === expected.type &&
+                node.attrs.language === expected.attrs.language &&
+                node.content.eq(expected.content)
+            : withoutHeadingId(node).eq(expected);
+        return reopened && same(reopened) ? text : undefined;
+    }
+    formOf(node) {
+        let form = this.forms.get(node);
+        if (form == null) {
+            form = blockForm(this.ctx, node);
+            this.forms.set(node, form);
+        }
+        return form;
+    }
+    // A list is one block, so typing in one item of a long list validates that
+    // item alone, read as the only item of a list with the same marker.
+    localItems(index, node) {
+        const before = this.baseline.child(index);
+        const block = this.blocks[index];
+        const list = block.ast;
+        const offset = this.source.startsWith('\uFEFF') ? 1 : 0;
+        const source = this.source.slice(offset);
+        if (list.type !== 'list' ||
+            list.children?.length !== node.childCount ||
+            before.childCount !== node.childCount)
+            return undefined;
+        // Whole-document matching would read a list that now matches another one
+        // as moved there.
+        for (let other = 0; other < this.baseline.childCount; other++) {
+            const candidate = this.baseline.child(other);
+            if (other !== index &&
+                candidate.type === node.type &&
+                candidate.childCount === node.childCount &&
+                candidate.textContent === node.textContent)
+                return undefined;
+        }
+        const marker = authoredMarker(list, source);
+        let output = '';
+        let previous = block.start;
+        for (let at = 0; at < node.childCount; at++) {
+            const item = node.child(at);
+            if (item.eq(before.child(at)))
+                continue;
+            let retained = this.itemEdits.get(item);
+            if (retained?.index !== index || retained.item !== at) {
+                const text = this.localItem(node, item, before.child(at), list.children[at], source, marker);
+                if (text === undefined)
+                    return undefined;
+                retained = { index, item: at, text };
+                this.itemEdits.set(item, retained);
+            }
+            const ast = list.children[at];
+            output +=
+                this.source.slice(previous, ast.position.start.offset + offset) +
+                    retained.text;
+            previous = ast.position.end.offset + offset;
+        }
+        return output + this.source.slice(previous, block.end);
+    }
+    localItem(list, item, before, ast, source, marker) {
+        const start = ast.position.start.offset;
+        const end = ast.position.end.offset;
+        if (!item.sameMarkup(before) ||
+            !sameBlocks(item, before) ||
+            !Preservation.plainInline(item) ||
+            !Preservation.plainInline(before) ||
+            // The authored item is compared with the edit, so it must read the same
+            // in this context too.
+            !this.inContext(source.slice(start, end)))
+            return undefined;
+        const local = this.canonicalTree(form(serialize(this.ctx, list.type.schema.topNodeType.create(null, [
+            list.type.create(list.attrs, [item]),
+        ]))));
+        const after = local?.node.children?.[0];
+        if (!local || local.node.children.length !== 1 || !after)
+            return undefined;
+        // Whether an item is spread depends on the blank lines around it, which an
+        // edit that keeps its blocks does not change.
+        let text = retainSource(ast, { ...after, spread: ast.spread }, source, local.canonical, this.lineEnding);
+        if (marker)
+            text = relabel(text, [0], marker);
+        // The marker and the spaces after it set the column that continuation
+        // lines, and blocks after the list, are read against.
+        const content = ast.children?.[0]?.position?.start.offset;
+        if (content == null || !text.startsWith(source.slice(start, content)))
+            return undefined;
+        // An item with nothing on its first line has a different content column.
+        if (/^(?:[-*+]|\d{1,9}[.)])[ \t]*(?:\r?\n|$)/.test(text))
+            return undefined;
+        const indent = source.slice(source.lastIndexOf('\n', start - 1) + 1, start);
+        if (!/^[ \t]*$/.test(indent))
+            return undefined;
+        const reopened = this.parseLocally(indent + text);
+        if (reopened?.type !== list.type || reopened.childCount !== 1)
+            return undefined;
+        const reread = reopened.firstChild;
+        // The label and spacing of an item come from its list.
+        const { label: _label, spread: _spread, ...attrs } = reread.attrs;
+        const { label: _l, spread: _s, ...expected } = item.attrs;
+        return reread.type === item.type &&
+            JSON.stringify(attrs) === JSON.stringify(expected) &&
+            reread.content.eq(item.content)
+            ? text
+            : undefined;
+    }
+    // Two lists of one kind side by side are one list unless their markers
+    // differ, so each run of adjacent lists gets markers that alternate. A list
+    // written afresh changes first, then an edited list. An unchanged list keeps
+    // its source unless a move changed one of its neighbours; otherwise the
+    // reopen check refuses.
+    separateLists(doc, pieces, kept, positions, current) {
+        const kind = (index) => {
+            const name = doc.maybeChild(index)?.type.name;
+            return name === 'bullet_list' || name === 'ordered_list'
+                ? name
+                : undefined;
+        };
+        const marker = (index) => markerAt(pieces[index], /^[ \t]*/.exec(pieces[index])[0].length)
+            ?.marker;
+        const elsewhere = new Set(current.filter((_, index) => kept[index] !== 'unchanged'));
+        const moved = (index) => positions[index] == null && this.originalForms.has(current[index]);
+        // Beside its source neighbour, or beside new blocks only, with nothing
+        // between them in the source moved elsewhere.
+        const inPlace = (index, step) => {
+            const own = positions[index];
+            let next = index + step;
+            while (next >= 0 &&
+                next < pieces.length &&
+                positions[next] == null &&
+                !moved(next))
+                next += step;
+            if (next >= 0 && next < pieces.length && positions[next] == null)
+                return false;
+            const other = next < 0
+                ? -1
+                : next >= pieces.length
+                    ? this.blocks.length
+                    : positions[next];
+            if ((other - own) * step <= 0)
+                return false;
+            for (let at = own + step; at !== other; at += step)
+                if (elsewhere.has(this.blocks[at].form))
+                    return false;
+            return true;
+        };
+        // An unchanged list changes only to part from a list with its marker across
+        // a boundary that a move disturbed, and one moved on both sides first.
+        const cost = (index) => {
+            if (kept[index] === 'canonical')
+                return 1;
+            if (kept[index] === 'edited')
+                return 10;
+            const own = marker(index);
+            const sides = [-1, 1].map((step) => inPlace(index, step));
+            const collides = [-1, 1].some((step, side) => !sides[side] &&
+                kind(index + step) === kind(index) &&
+                marker(index + step) === own);
+            return collides
+                ? [50, 150][Number(sides[0]) + Number(sides[1])]
+                : Infinity;
+        };
+        for (let start = 0; start < pieces.length;) {
+            const list = kind(start);
+            let end = start + 1;
+            while (list && kind(end) === list)
+                end++;
+            const run = Array.from({ length: end - start }, (_, i) => start + i);
+            start = end;
+            if (run.length < 2 ||
+                run.every((index, i) => !i || marker(index) !== marker(index - 1)))
+                continue;
+            const markers = list === 'bullet_list' ? ['-', '*', '+'] : ['.', ')'];
+            const options = run.map((index) => {
+                const own = marker(index);
+                const change = cost(index);
+                const choices = own ? [{ marker: own, cost: 0, text: pieces[index] }] : [];
+                if (change !== Infinity)
+                    for (const choice of markers) {
+                        if (choice === own)
+                            continue;
+                        const text = this.relabelList(pieces[index], choice);
+                        if (text !== undefined)
+                            choices.push({ marker: choice, cost: change, text });
+                    }
+                return choices;
+            });
+            // Fewest and cheapest changes, with adjacent markers always different.
+            const best = options.map((choices) => choices.map(() => Infinity));
+            const from = options.map((choices) => choices.map(() => -1));
+            options[0].forEach((choice, j) => (best[0][j] = choice.cost));
+            for (let i = 1; i < options.length; i++)
+                options[i].forEach((choice, j) => {
+                    options[i - 1].forEach((previous, k) => {
+                        const total = best[i - 1][k] + choice.cost;
+                        if (previous.marker !== choice.marker && total < best[i][j]) {
+                            best[i][j] = total;
+                            from[i][j] = k;
+                        }
+                    });
+                });
+            const last = best.at(-1);
+            let j = last.indexOf(Math.min(...last));
+            if (j < 0 || last[j] === Infinity)
+                continue;
+            for (let i = options.length - 1; i >= 0; j = from[i][j], i--)
+                pieces[run[i]] = options[i][j].text;
+        }
+    }
+    relabelList(text, marker) {
+        const processor = this.ctx.get(remarkCtx);
+        const read = (text) => processor.parse(text).children;
+        const [list, ...rest] = read(text);
+        if (list?.type !== 'list' || rest.length)
+            return undefined;
+        const relabelled = relabel(text, list.children.map((item) => item.position.start.offset), marker);
+        const reread = read(relabelled);
+        // A bullet can turn an item into a thematic break, such as `* * *`.
+        return reread.length === 1 &&
+            signature(reread[0]) === signature(list) &&
+            markerAt(relabelled, list.children[0].position.start.offset)
+                ?.marker === marker
+            ? relabelled
+            : undefined;
     }
     serialize(doc) {
         if (doc.eq(this.baseline))
             return this.source;
         try {
-            const independent = this.independentTextBlocks(doc);
-            if (independent !== undefined)
-                return independent;
+            const local = this.localEdits(doc);
+            if (local !== undefined)
+                return local;
             const canonical = serialize(this.ctx, doc);
             if (canonical === '')
                 return this.source.startsWith('\uFEFF') ? '\uFEFF' : '';
             const current = [];
-            doc.forEach((node) => {
-                let fingerprint = this.forms.get(node);
-                if (fingerprint == null) {
-                    fingerprint = blockForm(this.ctx, node);
-                    this.forms.set(node, fingerprint);
-                }
-                current.push(fingerprint);
-            });
-            const positions = correspondence(this.blocks.map((block) => block.form), current);
+            doc.forEach((node) => current.push(this.formOf(node)));
+            const forms = this.blocks.map((block) => block.form);
             const processor = this.ctx.get(remarkCtx);
             const currentRawTree = processor.parse(canonical);
             const currentTree = processor.runSync(structuredClone(currentRawTree), {
                 value: canonical,
             });
-            let output = '';
+            const parse = this.ctx.get(parserCtx);
+            const normalized = (text) => text.replace(/\r\n?/g, '\n');
+            const positions = correspondence(forms, current);
+            const gaps = [];
+            const pieces = [];
+            const kept = [];
             let previous;
             current.forEach((text, index) => {
                 const position = positions[index];
                 const block = position == null ? undefined : this.blocks[position];
                 if (index === 0) {
                     if (position === 0 && block)
-                        output += this.source.slice(0, block.start);
-                    else if (this.source.startsWith('\uFEFF'))
-                        output += '\uFEFF';
+                        gaps.push(this.source.slice(0, block.start));
+                    else
+                        gaps.push(this.source.startsWith('\uFEFF') ? '\uFEFF' : '');
                 }
                 else if (previous != null && position === previous + 1 && block) {
-                    output += this.source.slice(this.blocks[previous].end, block.start);
-                }
-                else
-                    output += this.lineEnding.repeat(2);
-                if (block && block.form === text)
-                    output += this.source.slice(block.start, block.end);
-                else if (block && currentTree.children.length === current.length) {
-                    output += this.retainBlock(block, positionalNode(currentRawTree, currentTree.children[index]), canonical);
+                    gaps.push(this.source.slice(this.blocks[previous].end, block.start));
                 }
                 else
-                    output += restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), text.replaceAll('\n', this.lineEnding));
+                    gaps.push(this.lineEnding.repeat(2));
+                const kind = block && block.form === text
+                    ? 'unchanged'
+                    : block && currentTree.children.length === current.length
+                        ? 'edited'
+                        : 'canonical';
+                kept.push(kind);
+                pieces.push(kind === 'unchanged'
+                    ? this.source.slice(block.start, block.end)
+                    : kind === 'edited'
+                        ? this.retainBlock(block, positionalNode(currentRawTree, currentTree.children[index]), canonical)
+                        : restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding)));
                 previous = position;
             });
+            this.separateLists(doc, pieces, kept, positions, current);
+            let output = pieces.map((piece, index) => gaps[index] + piece).join('');
             if (previous === this.blocks.length - 1 && this.blocks.length)
                 output += this.source.slice(this.blocks[previous].end);
             else if (output)
                 output += finalCodeEnding(doc) ?? this.lineEnding;
-            const parse = this.ctx.get(parserCtx);
+            // A `---` rule that opens the file reads back as front matter when
+            // another `---` line follows, whether it is new or moved there.
+            const bom = output.startsWith('\uFEFF') ? 1 : 0;
+            if (doc.firstChild?.type.name === 'hr' &&
+                sourceFrontmatter(output.slice(bom))?.startsWith('---'))
+                output = output.slice(0, bom) + '***' + output.slice(bom + 3);
             const reopened = parse(output);
-            const normalized = (text) => text.replace(/\r\n?/g, '\n');
             if (semanticSignature(reopened) === semanticSignature(doc)) {
                 const actual = normalized(serialize(this.ctx, reopened));
                 if (actual === normalized(canonical))