@aicayzer/inkkit 0.0.17 → 0.0.18

package/dist/literals.js

@@ -4,11 +4,15 @@ const unsupported = new Set(['html', 'image', 'imageReference']);
 export function sourceFrontmatter(source) {
     return /^(---|\+\+\+)\r?\n[\s\S]*?\r?\n\1(?:\r?\n|$)/.exec(source)?.[0];
 }
+export function lineBreakHTML(value) {
+    return ['<br />', '<br>', '<br >', '<br/>'].includes(value.trim());
+}
 function restoreInlineBreaks(node) {
-    if ((node.type === 'paragraph' || node.type === 'heading') &&
-        node.children.length > 1) {
-        node.children = node.children.map((child) => child.type === 'html' &&
-            ['<br />', '<br>', '<br >', '<br/>'].includes(child.value.trim())
+    // A cell cannot hold a line ending, so even a lone break there is content.
+    if (((node.type === 'paragraph' || node.type === 'heading') &&
+        node.children.length > 1) ||
+        node.type === 'tableCell') {
+        node.children = node.children.map((child) => child.type === 'html' && lineBreakHTML(child.value)
             ? {
                 type: 'break',
                 data: { inkkitHTMLBreak: true },
@@ -21,16 +25,17 @@ function restoreInlineBreaks(node) {
 }
 function containsUnsupported(node, images, inline = false) {
     // Only a standalone break represents a spacer; inline HTML must remain literal.
-    if (!inline &&
-        node.type === 'html' &&
-        ['<br />', '<br>', '<br >', '<br/>'].includes(node.value.trim()))
+    if (!inline && node.type === 'html' && lineBreakHTML(node.value))
         return false;
     if (node.type === 'paragraph' && node.children.length === 1) {
         const child = node.children[0];
-        if (child?.type === 'html' &&
-            ['<br />', '<br>', '<br >', '<br/>'].includes(child.value.trim()))
+        if (child?.type === 'html' && lineBreakHTML(child.value))
             return false;
     }
+    // GFM ignores cells past the header's count, so a grid cannot show them.
+    if (node.type === 'table' &&
+        node.children.some((row) => row.children.length > (node.children[0]?.children.length ?? 0)))
+        return true;
     return ((unsupported.has(node.type) && !(images && node.type === 'image')) ||
         ('children' in node &&
             node.children.some((child) => containsUnsupported(child, images, inline || node.type === 'paragraph' || node.type === 'heading'))));

package/dist/mermaid.d.ts

@@ -1,8 +1,28 @@
 import type { Node as ProseNode } from '@milkdown/kit/prose/model';
 import { type PortableImage } from './types.js';
 export declare function isMermaid(node: ProseNode): boolean;
-export declare function validateDiagram(source: string): void;
+interface Annotations {
+    names: string[];
+    rest: string;
+}
+export declare function validateDiagram(source: string): Annotations;
+interface ParsedDiagram {
+    type: string;
+    db: unknown;
+}
+interface Mermaid {
+    initialize(config: object): void;
+    render(id: string, text: string, container?: Element): Promise<{
+        svg: string;
+    }>;
+    mermaidAPI: {
+        getDiagramFromText(text: string): Promise<ParsedDiagram>;
+    };
+}
+export declare function registerMermaid(load: () => Promise<Mermaid>): void;
+export declare const diagramsAvailable: () => boolean;
 export declare function safeDiagramSVG(svg: string): string;
 export declare function renderDiagram(source: string): Promise<string>;
 export declare function diagramImage(source: string): Promise<PortableImage>;
 export declare function mermaidPreview(onError: (error: Error) => void): import("@milkdown/kit/utils").$Prose;
+export {};

package/dist/mermaid.js

@@ -11,16 +11,48 @@ const refusal = 'HTML, styles, actions, resources and diagram configuration are
 // CSS functions that can load an image or display another element. Mermaid's
 // own styles use none of them apart from url() for in-document markers.
 const cssResource = /url\s*\(\s*[^#\s]|(?:image-set|cross-fade|image|element|src)\s*\(/i;
+// Annotation syntax in the positions the pinned grammars read it: class
+// annotations on their own line, before a class name or after `class Name`, and
+// the state diagram fork, join and choice markers after `state Name`.
+const annotationName = String.raw `\w(?:[\w -]*\w)?`;
+const classAnnotation = new RegExp(String.raw `(?<=^[ \t]*(?:class[ \t]+[^\s<>"]+(?:\["[^"\n<>]*"\])?[ \t]+)?)<<(${annotationName})>>(?=[ \t{]|$)`, 'gm');
+const stateAnnotation = /(?<=^[ \t]*state[ \t]+[^\s<>"]+[ \t]+)<<(fork|join|choice)>>(?=[ \t]*$)/gim;
+const stateBrackets = /^[ \t]*state[ \t].*\[\[(fork|join|choice)\]\]/gim;
+// Separates the annotations that Mermaid may read from the rest of the source,
+// which must pass the HTML check. Whether each one became an annotation is
+// checked in the parse result.
+function annotations(source) {
+    const header = /^\s*(?:%%[^\n]*\n\s*)*(classDiagram|stateDiagram)/.exec(source)?.[1];
+    const pattern = header === 'classDiagram'
+        ? classAnnotation
+        : header === 'stateDiagram'
+            ? stateAnnotation
+            : undefined;
+    if (!pattern)
+        return { names: [], rest: source };
+    const names = [];
+    const rest = source.replace(pattern, (_, name) => {
+        names.push(header === 'stateDiagram' ? name.toLowerCase() : name);
+        return '';
+    });
+    // The class lexer skips comments, so a comment after << would hide an
+    // annotation name from the HTML check.
+    if (header === 'classDiagram' && /<<\s*%%/.test(rest))
+        throw new Error(refusal);
+    return { names, rest };
+}
 export function validateDiagram(source) {
     if (source.length > 30000)
         throw new Error('The diagram exceeds the 30,000 character rendering limit.');
     if (!/^\s*(?:%%[^\n]*\n\s*)*(?:flowchart|graph|sequenceDiagram|classDiagram|stateDiagram(?:-v2)?|erDiagram|pie)\b/.test(source))
         throw new Error('This diagram type is not supported. The source is retained.');
+    const found = annotations(source);
     // Mermaid can load image bytes before sanitising its result, so resource and
     // configuration syntax is refused anywhere in the source, labels included.
     // Statements are checked separately, in Mermaid's parse result.
-    if (/%%\{|^\s*---|<\s*[a-z!/?]|&(?:#\w+|[a-z]+);|@\{|\$\$|(?:https?|data|file|javascript|vbscript|blob):|\/\/|url\s*\(|image-set\s*\(|cross-fade\s*\(|@import|\\/im.test(source))
+    if (/%%\{|^\s*---|<\s*[a-z!/?]|&(?:#\w+|[a-z]+);|@\{|\$\$|(?:https?|data|file|javascript|vbscript|blob):|\/\/|url\s*\(|image-set\s*\(|cross-fade\s*\(|@import|\\/im.test(found.rest))
         throw new Error(refusal);
+    return found;
 }
 const entries = (value) => value instanceof Map ? [...value.values()] : Array.isArray(value) ? value : [];
 const filled = (value) => value instanceof Map
@@ -34,14 +66,17 @@ const filled = (value) => value instanceof Map
 const clickable = (classes) => (Array.isArray(classes) ? classes : String(classes ?? '').split(/\s+/))
     .map(String)
     .includes('clickable');
-function statementIn(node, kinds, seen = new Set()) {
+const unchecked = () => new Error('The diagram could not be checked. The source is retained.');
+// Visits each object reachable from node once, until visit returns true.
+function walk(node, visit, seen = new Set()) {
     if (typeof node !== 'object' || node === null || seen.has(node))
         return false;
     seen.add(node);
-    if (kinds.includes(String(node.stmt)))
+    if (visit(node))
         return true;
-    return Object.values(node).some((value) => statementIn(value, kinds, seen));
+    return Object.values(node).some((value) => walk(value, visit, seen));
 }
+const statementIn = (node, kinds) => walk(node, (entry) => kinds.includes(String(entry.stmt)));
 // Refuses styles, class definitions, link styles, links, click handlers,
 // tooltips, icons and images wherever the grammar accepted them. The names are
 // those of the pinned Mermaid's diagram databases; if one is missing, the
@@ -50,13 +85,13 @@ function refuseDirectives({ type, db }) {
     const store = db;
     const field = (name) => {
         if (!(name in store))
-            throw new Error('The diagram could not be checked. The source is retained.');
+            throw unchecked();
         return store[name];
     };
     const read = (name) => {
         const accessor = field(name);
         if (typeof accessor !== 'function')
-            throw new Error('The diagram could not be checked. The source is retained.');
+            throw unchecked();
         return accessor.call(db);
     };
     let found;
@@ -109,6 +144,48 @@ function refuseDirectives({ type, db }) {
     if (found)
         throw new Error(refusal);
 }
+// Each annotation taken out of the source check must be one that Mermaid read
+// as an annotation. One read as text, in a note or a multi-line label, would
+// put angle brackets in a label.
+function refuseStrayAnnotations({ type, db }, source, names) {
+    if (names.length === 0)
+        return;
+    const store = db;
+    const expected = [...names];
+    const parsed = [];
+    if (type === 'classDiagram') {
+        if (typeof store.getClasses !== 'function')
+            throw unchecked();
+        for (const node of entries(store.getClasses.call(db))) {
+            if (!Array.isArray(node.annotations))
+                throw unchecked();
+            parsed.push(...node.annotations.map(String));
+        }
+    }
+    else if (type === 'stateDiagram') {
+        if (!('rootDoc' in store))
+            throw unchecked();
+        walk(store.rootDoc, ({ stmt, type }) => {
+            if (stmt === 'state' && /^(?:fork|join|choice)$/.test(String(type)))
+                parsed.push(String(type));
+        });
+        // [[fork]] syntax on a state line makes the same states without angle
+        // brackets.
+        for (const [, name] of source.matchAll(stateBrackets))
+            expected.push(name.toLowerCase());
+    }
+    else
+        throw new Error(refusal);
+    if (parsed.sort().join('\n') !== expected.sort().join('\n'))
+        throw new Error(refusal);
+}
+let loadMermaid;
+// The package's main entry registers Mermaid. The core entry does not, so a
+// host that imports only the core entry does not bundle it.
+export function registerMermaid(load) {
+    loadMermaid = load;
+}
+export const diagramsAvailable = () => loadMermaid !== undefined;
 let sequence = 0;
 let queue = Promise.resolve();
 const cache = new Map();
@@ -139,8 +216,12 @@ export function safeDiagramSVG(svg) {
     return root.outerHTML;
 }
 export function renderDiagram(source) {
+    const load = loadMermaid;
+    if (!load)
+        return Promise.reject(new Error('Diagram rendering is not included in this build. The source is retained.'));
+    let names;
     try {
-        validateDiagram(source);
+        names = validateDiagram(source).names;
     }
     catch (error) {
         return Promise.reject(error);
@@ -149,7 +230,7 @@ export function renderDiagram(source) {
     if (previous)
         return previous;
     const rendered = queue.then(async () => {
-        const { default: mermaid } = await import('mermaid');
+        const mermaid = await load();
         mermaid.initialize({
             startOnLoad: false,
             securityLevel: 'strict',
@@ -196,7 +277,9 @@ export function renderDiagram(source) {
         // again on the same text; the public parse does not return the diagram. It
         // skips render's configuration step, so the two parse alike only because
         // the source check refuses %%{ directives and front matter.
-        refuseDirectives(await mermaid.mermaidAPI.getDiagramFromText(source));
+        const parsed = await mermaid.mermaidAPI.getDiagramFromText(source);
+        refuseDirectives(parsed);
+        refuseStrayAnnotations(parsed, source, names);
         // Mermaid measures text while laying out, so the holder must be attached
         // and rendered. Such a holder can load CSS resources before sanitising,
         // which is why the source and the parse result are checked first.

package/dist/paste-html.d.ts

@@ -8,12 +8,20 @@ export declare function isRewrittenElement(element: Element): boolean;
  * `!important` do not matter. Style sheets are not consulted.
  */
 export declare function keepsWhitespace(element: Element): boolean;
+/**
+ * WebKit writes a space beside an inline element to the clipboard as a
+ * non-breaking space in a `span.Apple-converted-space`, to protect it from
+ * the destination's whitespace collapse. Only such a span is converted back:
+ * a non-breaking space anywhere else was authored.
+ */
+export declare function restoreConvertedSpaces(root: ParentNode): void;
 /**
  * Rewrites common web-page elements to ones the importer already understands.
  * Elements that will stay literal source are not entered, so their content is
  * preserved exactly.
  */
 export declare function normalizeClipboardHTML(root: Node): void;
+export declare function isBlockElement(element: Element): boolean;
 /**
  * Collapses source whitespace the way a browser renders it: runs become one
  * space, and none remains at the edges of a block or beside a line break.

package/dist/paste-html.js

@@ -158,6 +158,21 @@ function declarations(style) {
     result.push(current);
     return result;
 }
+/**
+ * WebKit writes a space beside an inline element to the clipboard as a
+ * non-breaking space in a `span.Apple-converted-space`, to protect it from
+ * the destination's whitespace collapse. Only such a span is converted back:
+ * a non-breaking space anywhere else was authored.
+ */
+export function restoreConvertedSpaces(root) {
+    for (const span of root.querySelectorAll('span.Apple-converted-space'))
+        restoreConvertedSpace(span);
+}
+function restoreConvertedSpace(span) {
+    for (const node of span.childNodes)
+        if (node.nodeType === Node.TEXT_NODE)
+            node.data = node.data.replace(/\u00a0/g, ' ');
+}
 /**
  * Rewrites common web-page elements to ones the importer already understands.
  * Elements that will stay literal source are not entered, so their content is
@@ -211,6 +226,9 @@ export function normalizeClipboardHTML(root) {
         else {
             if (tag === 'LI')
                 markTask(element);
+            else if (tag === 'SPAN' &&
+                element.classList.contains('Apple-converted-space'))
+                restoreConvertedSpace(element);
             normalizeClipboardHTML(element);
         }
     }
@@ -249,6 +267,9 @@ const blocks = new Set([
     'FOOTER',
     'HR',
 ]);
+export function isBlockElement(element) {
+    return blocks.has(element.tagName);
+}
 // Bolds the inline content of a term. Paragraphs, headings and divisions
 // inside it each become one bold paragraph; other blocks are kept as they are.
 function boldInto(target, nodes) {

package/dist/paste.d.ts

@@ -14,6 +14,7 @@ export declare class PasteController {
     private active?;
     private readonly key;
     private dead;
+    private claimed;
     get pending(): boolean;
     readonly plugin: import("@milkdown/kit/utils").$Prose;
     constructor(options: PasteControllerOptions);
@@ -22,5 +23,11 @@ export declare class PasteController {
     cancelPending(): void;
     destroy(): void;
     private assertContext;
+    /**
+     * Inserts dropped content as whole blocks, so none joins the block beside
+     * it, and puts the caret after them.
+     */
+    private insertBlocks;
+    /** Imports the input at the selection, or in place of `target`. */
     private run;
 }

package/dist/paste.js

@@ -3,8 +3,10 @@ import { DOMParser as ProseParser, DOMSerializer, Fragment, Slice, } from '@milk
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { $prose } from '@milkdown/kit/utils';
 import { pasteSpreadsheet } from './spreadsheet.js';
+import { importableSlice, topLevel } from './html-import.js';
+import { blockDropRange, caretAfter } from './drop-placement.js';
 import { isImage } from './image-blocks.js';
-import { collapseClipboardWhitespace, isRewrittenElement, isRichElement, normalizeClipboardHTML, } from './paste-html.js';
+import { collapseClipboardWhitespace, isBlockElement, isRewrittenElement, isRichElement, normalizeClipboardHTML, } from './paste-html.js';
 import { avoidReferenceCollisions, markdownFromHTML, } from './reference-clipboard.js';
 import { InkKitError, } from './types.js';
 export class PasteController {
@@ -12,6 +14,7 @@ export class PasteController {
     active;
     key = new PluginKey('inkkitPaste');
     dead = false;
+    claimed = false;
     get pending() {
         return this.active != null;
     }
@@ -34,30 +37,51 @@ export class PasteController {
                 },
             },
             props: {
-                handlePaste: (view, event) => {
-                    const data = event.clipboardData;
-                    if (!data || !view.editable)
+                handleDOMEvents: {
+                    paste: (view, event) => {
+                        // ProseMirror parses the clipboard before asking handlePaste,
+                        // and this controller then imports it again itself.
+                        this.claimed = claimsPaste(view, event) !== false;
+                        queueMicrotask(() => {
+                            this.claimed = false;
+                        });
                         return false;
-                    if (view.state.selection.$from.parent.type.spec.code)
+                    },
+                    // A drop of HTML from outside the editor imports as a paste of
+                    // whole blocks, placed as dropped images are. ProseMirror keeps
+                    // moves within the editor and drops of plain text.
+                    drop: (view, event) => {
+                        const data = event.dataTransfer;
+                        if (!data?.getData('text/html') ||
+                            !view.editable ||
+                            view.dragging)
+                            return false;
+                        event.preventDefault();
+                        const target = blockDropRange(view, event.clientX, event.clientY);
+                        view.focus();
+                        void this.run({
+                            text: data.getData('text/plain'),
+                            html: data.getData('text/html'),
+                            plainText: this.options.literalText?.() ?? false,
+                        }, [...data.files].filter((file) => file.type.startsWith('image/')), target).catch((error) => options.onError?.(error));
+                        return true;
+                    },
+                },
+                // Pastes and drops that ProseMirror inserts itself.
+                transformPasted: (slice, view, plain) => this.claimed || plain || view.dragging
+                    ? slice
+                    : importableSlice(this.options.ctx(), slice),
+                handlePaste: (view, event) => {
+                    this.claimed = false;
+                    const claim = claimsPaste(view, event);
+                    if (claim === false)
                         return false;
+                    const data = event.clipboardData;
                     const text = data.getData('text/plain');
                     const html = data.getData('text/html');
-                    const metadata = data.getData('vscode-editor-data');
-                    if (metadata) {
-                        try {
-                            const value = JSON.parse(metadata);
-                            if (!value ||
-                                typeof value !== 'object' ||
-                                !('mode' in value) ||
-                                typeof value.mode !== 'string')
-                                throw new Error('Invalid VS Code clipboard metadata');
-                            // Retain the provider's code-language behaviour for valid metadata.
-                            return false;
-                        }
-                        catch {
-                            void this.paste({ text, plainText: true }).catch((error) => options.onError?.(error));
-                            return true;
-                        }
+                    if (claim === 'plain') {
+                        void this.paste({ text, plainText: true }).catch((error) => options.onError?.(error));
+                        return true;
                     }
                     const files = [...data.files].filter((file) => file.type.startsWith('image/'));
                     void this.run({
@@ -94,7 +118,18 @@ export class PasteController {
             current.generation !== context.generation)
             throw new InkKitError('stale-document', 'The document changed while images were importing.');
     }
-    async run(input, files = []) {
+    /**
+     * Inserts dropped content as whole blocks, so none joins the block beside
+     * it, and puts the caret after them.
+     */
+    insertBlocks(view, slice, range) {
+        const blocks = Fragment.fromArray(topLevel(view.state.schema, slice.content));
+        const tr = view.state.tr.replaceWith(range.from, range.to, blocks);
+        const end = tr.mapping.map(range.to);
+        view.dispatch(tr.setSelection(caretAfter(tr.doc, end)).scrollIntoView());
+    }
+    /** Imports the input at the selection, or in place of `target`. */
+    async run(input, files = [], target) {
         if (this.dead)
             throw new InkKitError('destroyed', 'The editor was destroyed.');
         if (this.pending)
@@ -106,10 +141,10 @@ export class PasteController {
             return;
         if (view.composing)
             throw new InkKitError('composition', 'Finish composing text before pasting.');
-        const operation = {
-            from: view.state.selection.from,
-            to: view.state.selection.to,
-        };
+        const operation = target
+            ? { ...target }
+            : { from: view.state.selection.from, to: view.state.selection.to };
+        const inCode = () => view.state.doc.resolve(this.anchor(operation).from).parent.type.spec.code;
         this.active = operation;
         this.options.onPendingChanged?.();
         try {
@@ -123,19 +158,17 @@ export class PasteController {
             this.assertContext(context, operation);
             const schema = view.state.schema;
             let slice;
-            const plainText = input.plainText ||
-                this.options.literalText?.() ||
-                view.state.selection.$from.parent.type.spec.code;
+            const plainText = input.plainText || this.options.literalText?.() || inCode();
             if (!plainText &&
                 input.markdown == null &&
-                pasteSpreadsheet(ctx, { ...input, images }))
+                pasteSpreadsheet(ctx, { ...input, images }, target && dropRange(view.state.doc, this.anchor(operation))))
                 return;
             const markdown = plainText
                 ? undefined
                 : (input.markdown ??
                     (input.html ? markdownFromHTML(input.html) : undefined));
             if (plainText) {
-                if (view.state.selection.$from.parent.type.spec.code) {
+                if (inCode()) {
                     const anchor = this.anchor(operation);
                     view.dispatch(view.state.tr.insertText(input.text, anchor.from, anchor.to));
                     return;
@@ -238,16 +271,6 @@ export class PasteController {
                     literal.textContent = element.outerHTML;
                     element.replaceWith(literal);
                 }
-                const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT);
-                const comments = [];
-                while (walker.nextNode())
-                    comments.push(walker.currentNode);
-                for (const comment of comments) {
-                    const literal = document.createElement('pre');
-                    literal.className = 'literal-markdown';
-                    literal.textContent = `<!--${comment.data}-->`;
-                    comment.replaceWith(literal);
-                }
                 for (const table of [...container.querySelectorAll('table')]) {
                     if (table.parentElement?.closest('table'))
                         continue;
@@ -270,6 +293,18 @@ export class PasteController {
                     }
                 }
                 collapseClipboardWhitespace(container);
+                // An authored comment is read in Markdown as an InkKit comment, so it
+                // imports as one, after whitespace collapse has passed it by.
+                const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT);
+                const comments = [];
+                while (walker.nextNode())
+                    comments.push(walker.currentNode);
+                for (const comment of comments) {
+                    const element = document.createElement(inlineComment(comment) ? 'span' : 'div');
+                    element.setAttribute('data-inkkit-comment', 'html');
+                    element.textContent = comment.data;
+                    comment.replaceWith(element);
+                }
                 const imported = new Map();
                 const elements = [...container.querySelectorAll('img')];
                 const uniqueSources = new Set(elements.map((element) => element.getAttribute('src') ?? ''));
@@ -334,9 +369,9 @@ export class PasteController {
                     slice = new Slice(hydrate(parsed).content, 0, 0);
                 }
                 else
-                    slice = ProseParser.fromSchema(schema).parseSlice(container, {
+                    slice = importableSlice(ctx, ProseParser.fromSchema(schema).parseSlice(container, {
                         preserveWhitespace: true,
-                    });
+                    }));
             }
             else if (images.length) {
                 const nodes = [];
@@ -400,7 +435,25 @@ export class PasteController {
                     ? remapped.firstChild.content
                     : remapped.content, slice.openStart, slice.openEnd);
             }
+            if (target) {
+                this.insertBlocks(view, slice, dropRange(view.state.doc, anchor));
+                return;
+            }
             const insertion = view.state.doc.resolve(anchor.from);
+            // Blocks pasted into an empty top-level paragraph take its place whole,
+            // as a drop does; joining the first of them into it could lose a
+            // wrapper whose only content was empty.
+            if (anchor.from === anchor.to &&
+                insertion.depth === 1 &&
+                insertion.parent.type.name === 'paragraph' &&
+                insertion.parent.content.size === 0 &&
+                slice.content.firstChild?.isBlock) {
+                this.insertBlocks(view, slice, {
+                    from: insertion.before(),
+                    to: insertion.after(),
+                });
+                return;
+            }
             // An isolated block such as a table cannot fit inside an empty paragraph.
             // Replace that empty block rather than retaining a spurious spacer.
             if (anchor.from === anchor.to &&
@@ -425,6 +478,62 @@ export class PasteController {
         }
     }
 }
+/**
+ * The range a drop replaces, mapped to the current document. It replaces an
+ * empty paragraph only while that is still empty, so text typed there while
+ * images import is kept, and the drop then follows it.
+ */
+function dropRange(doc, range) {
+    const node = doc.nodeAt(range.from);
+    return range.from < range.to &&
+        node?.type.name === 'paragraph' &&
+        node.content.size === 0 &&
+        range.from + node.nodeSize === range.to
+        ? range
+        : { from: range.to, to: range.to };
+}
+/**
+ * Whether `handlePaste` takes the paste, and as what. Valid VS Code metadata
+ * keeps the provider's code-language behaviour; invalid metadata pastes plain
+ * text.
+ */
+function claimsPaste(view, event) {
+    const data = event.clipboardData;
+    if (!data || !view.editable)
+        return false;
+    if (view.state.selection.$from.parent.type.spec.code)
+        return false;
+    const metadata = data.getData('vscode-editor-data');
+    if (!metadata)
+        return 'import';
+    try {
+        const value = JSON.parse(metadata);
+        return value &&
+            typeof value === 'object' &&
+            'mode' in value &&
+            typeof value.mode === 'string'
+            ? false
+            : 'plain';
+    }
+    catch {
+        return 'plain';
+    }
+}
+// Inside text or an element that holds text, a comment is part of a line.
+function inlineComment(comment) {
+    const parent = comment.parentElement;
+    if (parent && /^(?:P|H[1-6]|TD|TH|LI|DT|DD)$/.test(parent.tagName))
+        return true;
+    if (parent && isRichElement(parent) && !isBlockElement(parent))
+        return true;
+    for (const sibling of comment.parentNode?.childNodes ?? [])
+        if ((sibling.nodeType === Node.TEXT_NODE && sibling.textContent?.trim()) ||
+            (sibling.nodeType === Node.ELEMENT_NODE &&
+                isRichElement(sibling) &&
+                !isBlockElement(sibling)))
+            return true;
+    return false;
+}
 function insideRewrittenContent(element) {
     for (let parent = element.parentElement; parent; parent = parent.parentElement)
         if (!isRewrittenElement(parent))

package/dist/preserve.d.ts

@@ -3,7 +3,8 @@ 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[], resemblance?: boolean): Array<number | undefined>;
+export declare function semanticSignature(doc: ProseNode): string;
+export declare function correspondence(before: string[], after: string[]): Array<number | undefined>;
 /** Retains the loaded source of blocks the edit leaves alone. */
 export declare class Preservation {
     private readonly ctx;
@@ -13,9 +14,25 @@ export declare class Preservation {
     private readonly lineEnding;
     private readonly originalForms;
     private readonly forms;
-    private readonly textBlockEdits;
+    private readonly blockEdits;
+    private readonly itemEdits;
+    private readonly definitionNodes;
+    private readonly definitionSources?;
     constructor(ctx: Ctx, source: string);
     private retainBlock;
-    private independentTextBlocks;
+    private localEdits;
+    private pairedInPlace;
+    private definitions;
+    private inContext;
+    private parseLocally;
+    private canonicalTree;
+    private static plainInline;
+    private separated;
+    private localBlock;
+    private formOf;
+    private localItems;
+    private localItem;
+    private separateLists;
+    private relabelList;
     serialize(doc: ProseNode): string;
 }