@aicayzer/inkkit 0.0.16 → 0.0.17

package/dist/dialect.js

@@ -99,6 +99,16 @@ function remarkDialect() {
                     ? value.replace(/^[ \t]+|[ \t]+$/g, (spaces) => spaces.replaceAll(' ', ' ').replaceAll('\t', '	'))
                     : value;
             },
+            thematicBreak(node, parent, state) {
+                const value = defaultHandlers.thematicBreak(node, parent, state);
+                // A document opening with `---` reads back as front matter when
+                // another `---` line follows.
+                return parent?.type === 'root' &&
+                    parent.children.length > 1 &&
+                    parent.children[0] === node
+                    ? value.replaceAll('-', '*')
+                    : value;
+            },
         },
     });
     add('toMarkdownExtensions', { handlers: { link, code: fencedCodeHandler } });

package/dist/preserve.d.ts

@@ -3,7 +3,7 @@ import type { Node as ProseNode } from '@milkdown/kit/prose/model';
 export declare class PreservationError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-export declare function correspondence(before: string[], after: string[]): Array<number | undefined>;
+export declare function correspondence(before: string[], after: string[], resemblance?: boolean): Array<number | undefined>;
 /** Retains the loaded source of blocks the edit leaves alone. */
 export declare class Preservation {
     private readonly ctx;

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 &&
@@ -324,11 +327,15 @@ 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) {
+export function correspondence(before, after, resemblance = true) {
     const result = new Array(after.length);
-    const work = { budget: MATCHING_BUDGET };
+    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;
@@ -401,17 +408,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 +432,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;
@@ -599,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.16",
+  "version": "0.0.17",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",