@aicayzer/inkkit 0.0.17 → 0.0.18

package/dist/preserve.js

@@ -1,15 +1,93 @@
 import { parserCtx, remarkCtx } from '@milkdown/kit/core';
 import { serialize } from './dialect.js';
 import { restoreCodeEndings, finalCodeEnding } from './code-fences.js';
-import { sourceFrontmatter } from './literals.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');
@@ -108,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;
@@ -120,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) {
@@ -141,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] +
@@ -163,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(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;
@@ -205,10 +433,19 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
                             source.slice(to, childEnd)
                         : 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) &&
@@ -224,24 +461,81 @@ 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) +
-                withEnding(canonical.slice(newFrom, newTo), 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 withEnding(canonical.slice(newStart, newEnd), 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) {
@@ -267,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;
@@ -306,7 +600,6 @@ function semanticSignature(doc) {
     [
         'referenceContent',
         'referenceType',
-        'listPlaceholder',
         'marker',
         'id',
         'label',
@@ -330,12 +623,9 @@ 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, resemblance = true) {
+export function correspondence(before, after) {
     const result = new Array(after.length);
-    const work = {
-        budget: MATCHING_BUDGET,
-        similarity: resemblance ? SIMILARITY_BUDGET : 0,
-    };
+    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;
@@ -537,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;
@@ -580,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)
@@ -597,85 +905,423 @@ 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);
-            });
+            doc.forEach((node) => current.push(this.formOf(node)));
             const forms = this.blocks.map((block) => block.form);
-            const resembling = correspondence(forms, current);
             const processor = this.ctx.get(remarkCtx);
             const currentRawTree = processor.parse(canonical);
             const currentTree = processor.runSync(structuredClone(currentRawTree), {
@@ -683,67 +1329,60 @@ export class Preservation {
             });
             const parse = this.ctx.get(parserCtx);
             const normalized = (text) => text.replace(/\r\n?/g, '\n');
-            const reconstruct = (positions) => {
-                let output = '';
-                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';
-                    }
-                    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);
-                    }
+            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)
+                        gaps.push(this.source.slice(0, block.start));
                     else
-                        output += restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding));
-                    previous = position;
-                });
-                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;
-                // 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);
-                if (semanticSignature(reopened) === semanticSignature(doc)) {
-                    const actual = normalized(serialize(this.ctx, reopened));
-                    if (actual === normalized(canonical))
-                        return output;
-                    // Parsing may normalize loose-list spacing. Compare both reconstructed
-                    // source and intended canonical source after that same normalization.
-                    if (actual === normalized(serialize(this.ctx, parse(canonical))))
-                        return output;
+                        gaps.push(this.source.startsWith('\uFEFF') ? '\uFEFF' : '');
                 }
-                return undefined;
-            };
-            // Pairing by resemblance can leave a block in canonical form beside an
-            // authored neighbour it then merges with, such as two lists. The
-            // alignment's own pairing does not depend on resemblance, so try it too.
-            const output = reconstruct(resembling) ??
-                (() => {
-                    const aligned = correspondence(forms, current, false);
-                    // Unmatched blocks are holes, which every() would skip.
-                    return current.every((_, index) => aligned[index] === resembling[index])
-                        ? undefined
-                        : reconstruct(aligned);
-                })();
-            if (output !== undefined)
-                return output;
+                else if (previous != null && position === previous + 1 && block) {
+                    gaps.push(this.source.slice(this.blocks[previous].end, block.start));
+                }
+                else
+                    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;
+            // 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);
+            if (semanticSignature(reopened) === semanticSignature(doc)) {
+                const actual = normalized(serialize(this.ctx, reopened));
+                if (actual === normalized(canonical))
+                    return output;
+                // Parsing may normalize loose-list spacing. Compare both reconstructed
+                // source and intended canonical source after that same normalization.
+                if (actual === normalized(serialize(this.ctx, parse(canonical))))
+                    return output;
+            }
             throw new PreservationError('The edited Markdown cannot be reopened without changing its content');
         }
         catch (cause) {