@aicayzer/inkkit 0.0.1 → 0.0.2

package/README.md

@@ -33,8 +33,10 @@ editor.loadDocument({
 const snapshot = editor.snapshot(1)
 ```
 
-Markdown includes CommonMark, task lists, strikethrough, autolinks and GFM tables. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. Footnote editing and RTF files are not included in 0.0.1.
+Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
 
 See [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
 
+Planned work and release scope are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones). Releases 0.0.2 and 0.0.3 are authorised for sequential delivery; targets from 0.0.4 remain provisional.
+
 MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).

package/dist/clipboard.js

@@ -5,11 +5,20 @@ import { $prose } from '@milkdown/kit/utils';
 // punctuation or trailing spaces here leaks source syntax into other apps.
 export function clipboardText(content, missingImages = new Set()) {
     const blocks = [];
-    content.forEach((node) => blocks.push(nodeText(node, missingImages)));
+    content.forEach((node) => {
+        if (node.type.name !== 'reference_definition')
+            blocks.push(nodeText(node, missingImages));
+    });
     const inline = content.firstChild?.isInline ?? false;
     return blocks.join(inline ? '' : '\n\n');
 }
 function nodeText(node, missingImages) {
+    if (node.type.name === 'reference_definition')
+        return '';
+    if (node.type.name === 'footnote_reference')
+        return `[${node.attrs.label}]`;
+    if (node.type.name === 'footnote_definition')
+        return `[${node.attrs.label}] ${clipboardText(node.content, missingImages)}`;
     if (node.isText)
         return node.text ?? '';
     if (node.type.name === 'hardbreak' || node.type.name === 'hard_break')
@@ -73,6 +82,17 @@ export function clipboardContent(content, schema) {
         ],
     }, serializer.marks);
     container.append(safe.serializeFragment(content));
+    for (const definition of container.querySelectorAll('[data-inkkit-reference-definition]'))
+        definition.remove();
+    for (const reference of container.querySelectorAll('[data-inkkit-footnote-reference]')) {
+        reference.removeAttribute('tabindex');
+        reference.removeAttribute('role');
+    }
+    for (const definition of container.querySelectorAll('[data-inkkit-footnote-definition]')) {
+        const label = document.createElement('span');
+        label.textContent = `[${definition.getAttribute('data-inkkit-label')}] `;
+        definition.prepend(label);
+    }
     return { text: clipboardText(content), html: container.innerHTML };
 }
 export const visibleClipboard = $prose(() => new Plugin({
@@ -100,6 +120,7 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
         return { element, reference, alt };
     });
     await Promise.all(captured.map(async ({ element, reference, alt }, index) => {
+        element.setAttribute('data-inkkit-image-slot', String(index));
         try {
             if (!adapter)
                 throw new Error('The image is unavailable.');

package/dist/dialect.js

@@ -4,6 +4,7 @@ import { extendListItemSchemaForTask, strikethroughAttr, strikethroughInputRule,
 import { $remark } from '@milkdown/kit/utils';
 import { autolinkInputRule } from './autolink.js';
 import { literalBlock, createLiteralPreservation } from './literals.js';
+import { references, remarkReferencesPlugin } from './references.js';
 import { gfmTableFromMarkdown, gfmTableToMarkdown } from 'mdast-util-gfm-table';
 import { gfmTable } from 'micromark-extension-gfm-table';
 import { defaultHandlers, } from 'mdast-util-to-markdown';
@@ -63,7 +64,6 @@ const link = (node, parent, state, info) => writesBare(node, parent)
 link.peek = (node, parent, state) => writesBare(node, parent)
     ? node.url[0]
     : defaultHandlers.link.peek(node, parent, state);
-// Footnotes remain literal until the editor supports editing their definitions.
 function remarkDialect() {
     const data = this.data();
     const add = (key, value) => {
@@ -85,7 +85,7 @@ function remarkDialect() {
     add('toMarkdownExtensions', { handlers: { link } });
 }
 export const remarkDialectPlugin = $remark('remarkDialect', () => remarkDialect);
-// Keep authored spacer paragraphs; references remain literal instead of becoming inline links.
+// Reference links retain their authored form instead of expanding to inline links.
 const commonmarkWithLiteralReferences = commonmark.filter((plugin) => !remarkInlineLinkPlugin.includes(plugin));
 // The preset drops the final empty paragraph, which makes trailing spacers shrink on each reload.
 const preserveSpacerParagraphs = paragraphSchema.extendSchema((base) => (ctx) => {
@@ -251,9 +251,11 @@ export const tables = [
 ].flat();
 export function createDialect(images) {
     return [
+        remarkReferencesPlugin,
         // Protect unsupported inline HTML before the empty-line plugin consumes break nodes.
         createLiteralPreservation(images),
         commonmarkWithLiteralReferences,
+        references,
         preserveSpacerParagraphs,
         visibleSoftbreaks,
         normalizedImages,

package/dist/editor.d.ts

@@ -52,6 +52,7 @@ export declare class InkKitEditor {
     private plain;
     private root;
     private clickHandler?;
+    private footnoteKeyHandler?;
     private copyHandler?;
     private originalSource;
     private generation;
@@ -103,4 +104,7 @@ export declare class InkKitEditor {
     private quote;
     private unquote;
     format(command: FormatCommand, arg?: string | number): void;
+    editReferenceDefinition(label: string, destination: string, title?: string): boolean;
+    insertFootnote(label?: string): void;
+    navigateFootnote(target: 'definition' | 'reference'): boolean;
 }

package/dist/editor.js

@@ -1,5 +1,5 @@
 import { Editor, defaultValueCtx, editorViewCtx, editorViewOptionsCtx, remarkStringifyOptionsCtx, rootCtx, } from '@milkdown/kit/core';
-import { visibleClipboard, portableClipboard, clipboardText } from './clipboard.js';
+import { visibleClipboard, portableClipboard, clipboardText, clipboardContent, } from './clipboard.js';
 import { clipboard } from '@milkdown/kit/plugin/clipboard';
 import { history } from '@milkdown/kit/plugin/history';
 import { cursor } from '@milkdown/kit/plugin/cursor';
@@ -9,11 +9,13 @@ import { NodeRange, Fragment, Slice, } from '@milkdown/kit/prose/model';
 import { keydownHandler, keymap } from '@milkdown/kit/prose/keymap';
 import { liftListItem } from '@milkdown/kit/prose/schema-list';
 import { findWrapping, liftTarget } from '@milkdown/kit/prose/transform';
-import { AllSelection, Plugin, PluginKey, Selection, TextSelection, } from '@milkdown/kit/prose/state';
+import { AllSelection, NodeSelection, Plugin, PluginKey, Selection, TextSelection, } from '@milkdown/kit/prose/state';
 import { $prose, callCommand, replaceAll, } from '@milkdown/kit/utils';
 import { codeCopyPlugin, placeholderPlugin } from './decorations.js';
 import { createDialect, serialize, stringifyOptions } from './dialect.js';
 import { Preservation } from './preserve.js';
+import { normaliseLabel, referenceDefinitions, footnoteDefinitions, } from './references.js';
+import { selectionMarkdown, selectionContent, referenceMetadata, withReferenceMetadata, } from './reference-clipboard.js';
 import { imageView } from './images.js';
 import { tablePlugins, tableCommand } from './tables.js';
 import { InkKitError, } from './types.js';
@@ -240,6 +242,7 @@ export class InkKitEditor {
     plain;
     root;
     clickHandler;
+    footnoteKeyHandler;
     copyHandler;
     originalSource = '';
     generation = 0;
@@ -346,14 +349,17 @@ export class InkKitEditor {
         try {
             markdown = all
                 ? snapshot.text
-                : serialize(this.editor.ctx, schema.topNodeType.create(null, valid));
+                : selectionMarkdown(this.editor.ctx, doc, valid);
         }
         catch (error) {
             throw new InkKitError('preservation', error instanceof Error
                 ? error.message
                 : 'Cannot copy the selected Markdown');
         }
-        const result = await portableClipboard(content, schema, markdown, this.options.images, this.context());
+        const result = await portableClipboard(all ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context());
+        const metadata = referenceMetadata(this.editor.ctx, doc, content);
+        if (metadata != null)
+            result.html = withReferenceMetadata(result.html, metadata);
         this.assertCurrent(snapshot.generation);
         if (snapshot.documentId !== this.documentId || epoch !== this.documentEpoch)
             throw new InkKitError('stale-document', 'Document changed');
@@ -423,6 +429,8 @@ export class InkKitEditor {
         this.pasteController.destroy();
         if (this.clickHandler)
             this.root.removeEventListener('click', this.clickHandler);
+        if (this.footnoteKeyHandler)
+            this.root.removeEventListener('keydown', this.footnoteKeyHandler, true);
         if (this.copyHandler) {
             this.root.removeEventListener('copy', this.copyHandler, true);
             this.root.removeEventListener('cut', this.copyHandler, true);
@@ -433,7 +441,14 @@ export class InkKitEditor {
     // The app's bindings, replaced whole whenever they change; the plugin stays.
     keymapPlugin = $prose(() => new Plugin({
         key: new PluginKey('appKeymap'),
-        props: { handleKeyDown: (view, event) => this.keys(view, event) },
+        props: {
+            handleKeyDown: (view, event) => {
+                if (event.altKey && event.key === 'Enter') {
+                    return this.navigateFootnote(event.shiftKey ? 'reference' : 'definition');
+                }
+                return this.keys(view, event);
+            },
+        },
     }));
     static async mount(root, events, options = {}) {
         const instance = new InkKitEditor(events, options);
@@ -520,7 +535,40 @@ export class InkKitEditor {
         instance.plain.addEventListener('compositionend', () => {
             instance.plainComposing = false;
         });
+        const activateFootnote = (event) => {
+            const element = event.target.closest('[data-inkkit-footnote-reference]');
+            if (!element)
+                return false;
+            const identifier = element.getAttribute('data-inkkit-footnote-reference');
+            const view = instance.editor.ctx.get(editorViewCtx);
+            let position;
+            view.state.doc.descendants((node, pos) => {
+                if (position == null &&
+                    node.type.name === 'footnote_reference' &&
+                    node.attrs.identifier === identifier)
+                    position = pos;
+            });
+            if (position == null)
+                return false;
+            event.preventDefault();
+            try {
+                view.dispatch(view.state.tr.setSelection(NodeSelection.create(view.state.doc, position)));
+                instance.navigateFootnote('definition');
+            }
+            catch (error) {
+                events.error?.(error instanceof Error ? error : new Error(String(error)));
+            }
+            return true;
+        };
+        instance.footnoteKeyHandler = (event) => {
+            if ((event.key === 'Enter' || event.key === ' ') &&
+                activateFootnote(event))
+                event.stopPropagation();
+        };
+        root.addEventListener('keydown', instance.footnoteKeyHandler, true);
         instance.clickHandler = (event) => {
+            if (activateFootnote(event))
+                return;
             const anchor = event.target.closest('a[href]');
             if (anchor && event.metaKey) {
                 event.preventDefault();
@@ -533,13 +581,38 @@ export class InkKitEditor {
                 return;
             const view = instance.editor.ctx.get(editorViewCtx);
             const fragment = view.state.selection.content().content;
+            const expanded = selectionContent(view.state.doc, fragment);
             let hasImages = false;
-            fragment.descendants((node) => {
+            expanded.descendants((node) => {
                 if (node.type.name === 'image')
                     hasImages = true;
             });
-            if (!hasImages)
+            if (!hasImages) {
+                if (!event.clipboardData || fragment.size === 0)
+                    return;
+                event.preventDefault();
+                event.stopPropagation();
+                try {
+                    instance.snapshot();
+                    const content = expanded;
+                    const valid = fragment.firstChild?.isInline
+                        ? Fragment.from(view.state.schema.nodes.paragraph.create(null, fragment))
+                        : fragment;
+                    const markdown = selectionMarkdown(instance.editor.ctx, view.state.doc, valid);
+                    const output = clipboardContent(content, view.state.schema);
+                    event.clipboardData.setData('text/plain', output.text);
+                    const metadata = referenceMetadata(instance.editor.ctx, view.state.doc, valid);
+                    event.clipboardData.setData('text/html', metadata != null
+                        ? withReferenceMetadata(output.html, metadata)
+                        : output.html);
+                    if (event.type === 'cut')
+                        view.dispatch(view.state.tr.deleteSelection().scrollIntoView());
+                }
+                catch (error) {
+                    events.error?.(error instanceof Error ? error : new Error(String(error)));
+                }
                 return;
+            }
             event.preventDefault();
             event.stopPropagation();
             if (events.clipboard) {
@@ -564,7 +637,7 @@ export class InkKitEditor {
             }
             else {
                 const container = document.createElement('div');
-                container.textContent = clipboardText(fragment);
+                container.textContent = clipboardText(expanded);
                 event.clipboardData?.setData('text/plain', container.textContent ?? '');
                 event.clipboardData?.setData('text/html', container.outerHTML);
                 events.error?.(new InkKitError('image-unavailable', 'The host must provide a clipboard handler to copy images'));
@@ -961,6 +1034,17 @@ export class InkKitEditor {
                 toggleTaskList(this.editor.ctx);
                 break;
             case 'link': {
+                const view = this.editor.ctx.get(editorViewCtx);
+                const reference = view.state.selection.$from
+                    .marks()
+                    .find((mark) => mark.type.name === 'link' && mark.attrs.identifier) ??
+                    view.state.doc
+                        .nodeAt(view.state.selection.from)
+                        ?.marks.find((mark) => mark.type.name === 'link' && mark.attrs.identifier);
+                if (reference && typeof arg === 'string') {
+                    this.editReferenceDefinition(String(reference.attrs.identifier), arg);
+                    break;
+                }
                 const payload = typeof arg === 'string' ? { href: arg } : {};
                 const toggle = () => run(toggleLinkCommand.key, payload);
                 if (!state.marks.includes('link') ||
@@ -971,4 +1055,95 @@ export class InkKitEditor {
         }
         this.focus();
     }
+    editReferenceDefinition(label, destination, title) {
+        this.assertCurrent();
+        if (this.formatType === 'txt')
+            return false;
+        const view = this.editor.ctx.get(editorViewCtx);
+        const definitions = referenceDefinitions(view.state.doc);
+        const definition = definitions.get(normaliseLabel(label)) ??
+            [...definitions.values()].find(({ node }) => normaliseLabel(String(node.attrs.label)) === normaliseLabel(label));
+        if (!definition)
+            return false;
+        view.dispatch(view.state.tr.setNodeMarkup(definition.pos, undefined, {
+            ...definition.node.attrs,
+            url: destination,
+            title: title ?? definition.node.attrs.title,
+        }));
+        return true;
+    }
+    insertFootnote(label) {
+        this.assertCurrent();
+        if (this.formatType === 'txt')
+            return;
+        const view = this.editor.ctx.get(editorViewCtx);
+        const definitions = footnoteDefinitions(view.state.doc);
+        if (label == null) {
+            let number = 1;
+            const labels = new Set(definitions.keys());
+            for (const match of this.snapshot().text.matchAll(/\[\^([^\]\r\n]+)\]/g))
+                labels.add(normaliseLabel(match[1]));
+            view.state.doc.descendants((node) => {
+                if (node.type.name === 'footnote_reference')
+                    labels.add(String(node.attrs.identifier));
+            });
+            while (labels.has(normaliseLabel(String(number))))
+                number++;
+            label = String(number);
+        }
+        if (!label || /[\s\[\]\\]/.test(label) || label.length > 999)
+            throw new Error('A footnote label must be 1–999 characters without whitespace, brackets or backslashes');
+        const identifier = normaliseLabel(label);
+        const reference = view.state.schema.nodes.footnote_reference.create({
+            label,
+            identifier,
+        });
+        const tr = view.state.tr.insert(view.state.selection.to, reference);
+        if (!definitions.has(identifier)) {
+            const definition = view.state.schema.nodes.footnote_definition.create({ label, identifier }, view.state.schema.nodes.paragraph.create());
+            const position = tr.doc.content.size;
+            tr.insert(position, definition).setSelection(TextSelection.create(tr.doc, position + 2));
+        }
+        view.dispatch(tr.scrollIntoView());
+        this.focus();
+    }
+    navigateFootnote(target) {
+        this.assertCurrent();
+        if (this.formatType === 'txt')
+            return false;
+        const view = this.editor.ctx.get(editorViewCtx);
+        const { $from } = view.state.selection;
+        let identifier;
+        for (let depth = $from.depth; depth > 0; depth--) {
+            const node = $from.node(depth);
+            if (node.type.name === 'footnote_definition')
+                identifier = String(node.attrs.identifier);
+        }
+        const at = view.state.doc.nodeAt(view.state.selection.from);
+        const adjacent = at?.type.name === 'footnote_reference' ? at : $from.nodeBefore;
+        if (adjacent?.type.name === 'footnote_reference')
+            identifier = String(adjacent.attrs.identifier);
+        if (!identifier)
+            return false;
+        let position;
+        if (target === 'definition') {
+            const found = footnoteDefinitions(view.state.doc).get(identifier);
+            if (found)
+                position = found.pos + 2;
+        }
+        else
+            view.state.doc.descendants((node, pos) => {
+                if (position == null &&
+                    node.type.name === 'footnote_reference' &&
+                    node.attrs.identifier === identifier)
+                    position = pos;
+            });
+        if (position == null)
+            return false;
+        view.dispatch(view.state.tr
+            .setSelection(TextSelection.near(view.state.doc.resolve(position)))
+            .scrollIntoView());
+        this.focus();
+        return true;
+    }
 }

package/dist/literals.d.ts

@@ -3,6 +3,9 @@ interface InkKitLiteral extends Literal {
     type: 'inkkitLiteral';
 }
 declare module 'mdast' {
+    interface BlockContentMap {
+        inkkitLiteral: InkKitLiteral;
+    }
     interface RootContentMap {
         inkkitLiteral: InkKitLiteral;
     }

package/dist/literals.js

@@ -1,11 +1,5 @@
 import { $node, $remark } from '@milkdown/kit/utils';
-const unsupported = new Set([
-    'html',
-    'image',
-    'imageReference',
-    'definition',
-    'linkReference',
-]);
+const unsupported = new Set(['html', 'image', 'imageReference']);
 function restoreInlineBreaks(node) {
     if ((node.type === 'paragraph' || node.type === 'heading') &&
         node.children.length > 1) {
@@ -37,6 +31,18 @@ function containsUnsupported(node, images, inline = false) {
         ('children' in node &&
             node.children.some((child) => containsUnsupported(child, images, inline || node.type === 'paragraph' || node.type === 'heading'))));
 }
+function containsUnresolved(node, source) {
+    if (node.type === 'text') {
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        if (start == null || end == null)
+            return false;
+        const raw = source.slice(start, end);
+        return /(?<!\\)\[\^[^\]\n]+\]|(?<!\\)\[[^\]\n]+\](?:\[[^\]\n]*\])?/.test(raw);
+    }
+    return ('children' in node &&
+        node.children.some((child) => containsUnresolved(child, source)));
+}
 // Keep syntax we cannot faithfully edit as literal text, without making the rest
 // of the document a source editor or allowing HTML and image network requests.
 export function createLiteralPreservation(images) {
@@ -46,6 +52,24 @@ export function createLiteralPreservation(images) {
         const source = String(file.value).replace(/^\uFEFF/, '');
         const frontmatter = /^(---|\+\+\+)\r?\n[\s\S]*?\r?\n\1(?:\r?\n|$)/.exec(source);
         const frontmatterEnd = frontmatter?.[0].length ?? 0;
+        const preserveBlock = (node, depth = 0) => {
+            if (node.type === 'footnoteDefinition') {
+                node.children = node.children.map((child) => preserveBlock(child, depth + 1));
+                return node;
+            }
+            const start = node.position?.start.offset;
+            const end = node.position?.end.offset;
+            if (start == null ||
+                end == null ||
+                (!containsUnsupported(node, images) &&
+                    !containsUnresolved(node, source)))
+                return node;
+            let raw = source.slice(start, end);
+            // Definition indentation is restored by the footnote serializer.
+            for (let index = 0; index < depth; index++)
+                raw = raw.replace(/\r?\n(?: {4}|\t)/g, '\n');
+            return { type: 'inkkitLiteral', value: raw, position: node.position };
+        };
         const blocks = [];
         if (frontmatter)
             blocks.push({
@@ -81,16 +105,7 @@ export function createLiteralPreservation(images) {
                     });
                 continue;
             }
-            const raw = source.slice(start, end);
-            const footnote = node.type !== 'code' && /\[\^[^\]]+\]/.test(raw);
-            if (containsUnsupported(node, images) || footnote)
-                blocks.push({
-                    type: 'inkkitLiteral',
-                    value: raw,
-                    position: node.position,
-                });
-            else
-                blocks.push(node);
+            blocks.push(preserveBlock(node));
         }
         tree.children = blocks;
     });

package/dist/paste.js

@@ -2,6 +2,7 @@ import { editorViewCtx, parserCtx } from '@milkdown/kit/core';
 import { DOMParser as ProseParser, Fragment, Slice, } from '@milkdown/kit/prose/model';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { $prose } from '@milkdown/kit/utils';
+import { avoidReferenceCollisions, markdownFromHTML, } from './reference-clipboard.js';
 import { InkKitError, } from './types.js';
 export class PasteController {
     options;
@@ -113,6 +114,10 @@ export class PasteController {
             const plainText = input.plainText ||
                 this.options.literalText?.() ||
                 view.state.selection.$from.parent.type.spec.code;
+            const markdown = plainText
+                ? undefined
+                : (input.markdown ??
+                    (input.html ? markdownFromHTML(input.html) : undefined));
             if (plainText) {
                 if (view.state.selection.$from.parent.type.spec.code) {
                     const anchor = operation;
@@ -131,6 +136,21 @@ export class PasteController {
                 const template = document.createElement('template');
                 template.innerHTML = input.html;
                 const container = template.content;
+                if (markdown == null) {
+                    // Native destinations can keep node metadata after dropping the
+                    // Markdown wrapper and its definitions. Import their visible HTML.
+                    for (const element of container.querySelectorAll('[data-inkkit-reference],[data-inkkit-footnote-reference],[data-inkkit-footnote-definition]')) {
+                        for (const name of [
+                            'data-inkkit-reference',
+                            'data-inkkit-footnote-reference',
+                            'data-inkkit-footnote-definition',
+                            'data-inkkit-label',
+                            'data-inkkit-reference-type',
+                            'data-inkkit-reference-content',
+                        ])
+                            element.removeAttribute(name);
+                    }
+                }
                 // Native HTML clipboards add encoding metadata. Obsidian's reading
                 // view also copies its title and collapse controls with document HTML.
                 for (const metadata of container.querySelectorAll('meta[charset]'))
@@ -183,6 +203,7 @@ export class PasteController {
                     'TD',
                     'IMG',
                     'SPAN',
+                    'SUP',
                     'DIV',
                     'FONT',
                     'SECTION',
@@ -271,9 +292,33 @@ export class PasteController {
                             : 'The pasted image is unavailable.'));
                     }
                 }
-                slice = ProseParser.fromSchema(schema).parseSlice(container, {
-                    preserveWhitespace: true,
-                });
+                if (markdown != null) {
+                    const parsed = ctx.get(parserCtx)(markdown);
+                    let imageIndex = 0;
+                    const hydrate = (node) => {
+                        if (node.type.name === 'image') {
+                            const slot = /^inkkit-clipboard-image:(\d+)$/.exec(String(node.attrs.src));
+                            const position = slot ? Number(slot[1]) : imageIndex++;
+                            const element = elements.some((element) => element.hasAttribute('data-inkkit-image-slot'))
+                                ? elements.find((element) => Number(element.getAttribute('data-inkkit-image-slot')) ===
+                                    position)
+                                : elements[position];
+                            if (!element || !container.contains(element))
+                                return schema.text(`[${node.attrs.alt || 'Image'}: image unavailable]`);
+                            return node.type.create({ ...node.attrs, src: element.getAttribute('src') }, null, node.marks);
+                        }
+                        if (node.isText)
+                            return node;
+                        const children = [];
+                        node.forEach((child) => children.push(hydrate(child)));
+                        return node.copy(Fragment.fromArray(children));
+                    };
+                    slice = new Slice(hydrate(parsed).content, 0, 0);
+                }
+                else
+                    slice = ProseParser.fromSchema(schema).parseSlice(container, {
+                        preserveWhitespace: true,
+                    });
             }
             else if (images.length) {
                 const nodes = [];
@@ -310,7 +355,8 @@ export class PasteController {
             else {
                 const selection = view.state.selection;
                 const text = input.text.trim();
-                if (!selection.empty &&
+                if (markdown == null &&
+                    !selection.empty &&
                     /^https?:\/\/\S+$/.test(text) &&
                     schema.marks.link) {
                     const anchor = operation;
@@ -320,13 +366,22 @@ export class PasteController {
                         .removeStoredMark(mark));
                     return;
                 }
-                const doc = ctx.get(parserCtx)(input.text);
+                const doc = ctx.get(parserCtx)(markdown ?? input.text);
                 slice = new Slice(doc.content, 0, 0);
             }
             this.assertContext(context, operation);
             if (!view.editable || this.options.editable?.() === false)
                 return;
             const anchor = operation;
+            if (!plainText) {
+                const valid = slice.content.firstChild?.isInline
+                    ? Fragment.from(schema.nodes.paragraph.create(null, slice.content))
+                    : slice.content;
+                const remapped = avoidReferenceCollisions(schema.topNodeType.create(null, valid), view.state.doc);
+                slice = new Slice(slice.content.firstChild?.isInline
+                    ? remapped.firstChild.content
+                    : remapped.content, slice.openStart, slice.openEnd);
+            }
             const insertion = view.state.doc.resolve(anchor.from);
             // An isolated block such as a table cannot fit inside an empty paragraph.
             // Replace that empty block rather than retaining a spurious spacer.