@aicayzer/inkkit 0.0.15 → 0.0.17

package/dist/preserve.js

@@ -1,6 +1,7 @@
 import { parserCtx, remarkCtx } from '@milkdown/kit/core';
 import { serialize } from './dialect.js';
 import { restoreCodeEndings, finalCodeEnding } from './code-fences.js';
+import { sourceFrontmatter } from './literals.js';
 function signature(node) {
     return JSON.stringify(node, (key, value) => ['position', 'data', 'marker'].includes(key) ? undefined : value);
 }
@@ -163,7 +164,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
                 destination[3]);
     }
     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;
@@ -202,9 +203,7 @@ 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;
@@ -239,10 +238,14 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
             : newEnd;
         if (from != null && to != null && newFrom != null && newTo != null)
             return retainBoundaryWhitespace(source.slice(start, from) +
-                canonical.slice(newFrom, newTo).replaceAll('\n', lineEnding) +
+                withEnding(canonical.slice(newFrom, newTo), lineEnding) +
                 source.slice(to, end), canonical.slice(newStart, newEnd));
     }
-    return canonical.slice(newStart, newEnd).replaceAll('\n', lineEnding);
+    return withEnding(canonical.slice(newStart, newEnd), lineEnding);
+}
+// 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 &&
@@ -323,74 +326,207 @@ function withoutHeadingId(node) {
         ? node.type.create({ ...node.attrs, id: '' }, node.content, node.marks)
         : node;
 }
-// Edit distance distinguishes replacements from insertions, so replacing a block
-// retains its surrounding whitespace without assigning it a neighbour's source.
-function correspondence(before, after) {
+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) {
     const result = new Array(after.length);
-    let head = 0;
-    while (head < before.length &&
-        head < after.length &&
-        before[head] === after[head]) {
-        result[head] = head;
-        head++;
+    const work = {
+        budget: MATCHING_BUDGET,
+        similarity: resemblance ? SIMILARITY_BUDGET : 0,
+    };
+    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;
+        while (b < bEnd && a < aEnd && before[b] === after[a])
+            result[a++] = b++;
+        while (b < bEnd && a < aEnd && before[bEnd - 1] === after[aEnd - 1])
+            result[--aEnd] = --bEnd;
+        if (b === bEnd || a === aEnd)
+            continue;
+        work.budget -= bEnd - b + (aEnd - a);
+        if (work.budget < 0)
+            throw tooManyBlocks();
+        const anchors = uniqueAnchors(before, after, b, bEnd, a, aEnd);
+        if (!anchors.length) {
+            align(before, after, b, bEnd, a, aEnd, result, work);
+            continue;
+        }
+        for (const anchor of anchors) {
+            result[anchor.a] = anchor.b;
+            spans.push({ b, a, bEnd: anchor.b, aEnd: anchor.a });
+            b = anchor.b + 1;
+            a = anchor.a + 1;
+        }
+        spans.push({ b, a, bEnd, aEnd });
     }
-    let endBefore = before.length;
-    let endAfter = after.length;
-    while (endBefore > head &&
-        endAfter > head &&
-        before[endBefore - 1] === after[endAfter - 1]) {
-        result[--endAfter] = --endBefore;
+    return result;
+}
+function tooManyBlocks() {
+    return new PreservationError('The edit changes too many blocks to preserve safely');
+}
+// Blocks that occur exactly once on each side, in the longest subsequence whose
+// order the two sides share. A repeated block is never an anchor: which copy it
+// belongs to is not known until its neighbours are placed.
+function uniqueAnchors(before, after, b, bEnd, a, aEnd) {
+    const once = (list, from, to) => {
+        const at = new Map();
+        for (let i = from; i < to; i++)
+            at.set(list[i], at.has(list[i]) ? -1 : i);
+        return at;
+    };
+    const beforeAt = once(before, b, bEnd);
+    const afterAt = once(after, a, aEnd);
+    const pairs = [];
+    for (let i = a; i < aEnd; i++) {
+        const match = beforeAt.get(after[i]);
+        if (match != null && match >= 0 && afterAt.get(after[i]) === i)
+            pairs.push({ b: match, a: i });
+    }
+    // Patience sorting: tails[k] ends the best increasing subsequence of length k + 1.
+    const tails = [];
+    const previous = new Array(pairs.length);
+    for (const [index, pair] of pairs.entries()) {
+        let low = 0;
+        let high = tails.length;
+        while (low < high) {
+            const middle = (low + high) >> 1;
+            if (pairs[tails[middle]].b < pair.b)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        previous[index] = low ? tails[low - 1] : -1;
+        tails[low] = index;
     }
-    const rows = endBefore - head + 1;
-    const columns = endAfter - head + 1;
-    let budget = 1_000_000;
-    let width = Math.max(1, Math.abs(rows - columns));
+    const anchors = [];
+    let at = tails.length ? tails[tails.length - 1] : -1;
+    while (at >= 0) {
+        anchors.push(pairs[at]);
+        at = previous[at];
+    }
+    return anchors.reverse();
+}
+// 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;
+    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);
-            budget -= to - from + 1;
-            if (budget < 0)
-                throw new PreservationError('The edit changes too many blocks to preserve safely');
+            work.budget -= to - from + 1;
+            if (work.budget < 0)
+                throw tooManyBlocks();
             const row = new Uint32Array(to - from + 1);
             costs.push(row);
             for (let j = from; j <= to; j++) {
-                const change = before[head + i - 1] === after[head + 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[head + i - 1] === after[head + j - 1] ? 0 : 1;
-            if (i && j && get(i, j) === get(i - 1, j - 1) + change) {
-                result[head + j - 1] = head + i - 1;
+            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--;
         }
-        break;
+        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--;
     }
-    return result;
+}
+// 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 {
@@ -538,53 +674,76 @@ export class Preservation {
                 }
                 current.push(fingerprint);
             });
-            const positions = correspondence(this.blocks.map((block) => block.form), current);
+            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), {
                 value: canonical,
             });
-            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);
-                }
-                else
-                    output += restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), text.replaceAll('\n', 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;
             const parse = this.ctx.get(parserCtx);
-            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))
-                    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;
-            }
+            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);
+                    }
+                    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;
+                }
+                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;
             throw new PreservationError('The edited Markdown cannot be reopened without changing its content');
         }
         catch (cause) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",