@aicayzer/inkkit 0.0.16 → 0.0.18

package/README.md

@@ -15,6 +15,8 @@ A Markdown editor for the web and for apps that host a web view. It edits format
 npm install @aicayzer/inkkit
 ```
 
+An app that does not render diagrams can import from `@aicayzer/inkkit/core` instead. That entry leaves Mermaid out of the app's bundle and keeps diagrams as editable source. See [Builds without diagrams](docs/api.md#builds-without-diagrams).
+
 ## Use
 
 ```ts

package/dist/callouts.d.ts

@@ -7,7 +7,6 @@ interface Callout extends Parent {
     fold: string;
     title: string;
     titleSource: string;
-    listPlaceholder: boolean;
     children: RootContent[];
 }
 declare module 'mdast' {

package/dist/callouts.js

@@ -1,5 +1,6 @@
 import { $node, $prose, $remark } from '@milkdown/kit/utils';
 import { editorLabels } from './labels.js';
+import { singleLine } from './references.js';
 import { remarkCtx } from '@milkdown/kit/core';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { defaultHandlers } from 'mdast-util-to-markdown';
@@ -37,7 +38,7 @@ function remarkCallouts() {
     });
     return (tree, file) => {
         const source = String(file.value).replace(/^\uFEFF/, '');
-        const visit = (node, parent, index) => {
+        const visit = (node) => {
             if (node.type === 'blockquote') {
                 const start = node.position?.start.offset, end = node.position?.end.offset;
                 const raw = start == null || end == null ? '' : source.slice(start, end);
@@ -117,14 +118,13 @@ function remarkCallouts() {
                             .slice(header.length - (match[4]?.length ?? 0))
                             .trimEnd(),
                         titleSource: match[4]?.trimEnd() ?? '',
-                        listPlaceholder: parent?.type === 'listItem' && index === 0,
                         children: children.map((child) => visit(child)),
                         position: node.position,
                     };
                 }
             }
             if ('children' in node)
-                node.children = node.children.map((child, index) => visit(child, node, index));
+                node.children = node.children.map((child) => visit(child));
             return node;
         };
         tree.children = tree.children.map((node) => visit(node));
@@ -141,7 +141,6 @@ export const calloutSchema = $node('inkkit_callout', (ctx) => ({
         fold: { default: '' },
         title: { default: '' },
         titleSource: { default: null },
-        listPlaceholder: { default: false },
     },
     parseDOM: [
         {
@@ -152,34 +151,25 @@ export const calloutSchema = $node('inkkit_callout', (ctx) => ({
                 const kind = (dom.getAttribute('data-inkkit-callout') ?? '').toUpperCase();
                 const marker = dom.getAttribute('data-inkkit-marker') ?? `[!${kind}]`;
                 const fold = dom.getAttribute('data-inkkit-fold') ?? '';
-                const titleSource = dom.getAttribute('data-inkkit-title');
-                const placeholder = dom.getAttribute('data-inkkit-list-placeholder');
-                const previous = dom.previousElementSibling;
-                const titleHeader = titleSource == null
-                    ? undefined
-                    : plainHeader(ctx.get(remarkCtx), `${marker} ${titleSource}`);
+                // A title read from the visible text is written with its punctuation
+                // escaped, so it reads back as the same plain text.
+                const visibleTitle = singleLine(dom.querySelector('.inkkit-callout-title')?.textContent ?? '').trim();
+                const titleSource = dom.getAttribute('data-inkkit-title') ??
+                    visibleTitle.replace(/[!-/:-@[-`{-~]/g, '\\$&');
+                const titleHeader = plainHeader(ctx.get(remarkCtx), `${marker} ${titleSource}`);
                 if (!kinds.has(kind) ||
                     !/^\[![A-Za-z]+\]$/.test(marker) ||
                     marker.slice(2, -1).toUpperCase() !== kind ||
                     !['', '+', '-'].includes(fold) ||
-                    (titleSource != null &&
-                        (/[\r\n]/.test(titleSource) || titleHeader == null)))
+                    /[\r\n]/.test(titleSource) ||
+                    titleHeader == null)
                     return false;
                 return {
                     kind,
                     marker,
                     fold,
-                    title: titleHeader == null
-                        ? (dom.querySelector('.inkkit-callout-title')?.textContent ?? '')
-                        : titleHeader.slice(marker.length + 1).trimEnd(),
+                    title: titleHeader.slice(marker.length + 1).trimEnd(),
                     titleSource,
-                    listPlaceholder: placeholder == null
-                        ? dom.parentElement?.tagName === 'LI' &&
-                            (!previous ||
-                                (previous.tagName === 'P' &&
-                                    !previous.textContent &&
-                                    !previous.childElementCount))
-                        : placeholder === 'true',
                 };
             },
         },
@@ -192,7 +182,6 @@ export const calloutSchema = $node('inkkit_callout', (ctx) => ({
             'data-inkkit-marker': node.attrs.marker,
             'data-inkkit-fold': node.attrs.fold,
             'data-inkkit-title': node.attrs.titleSource ?? node.attrs.title,
-            'data-inkkit-list-placeholder': String(node.attrs.listPlaceholder),
         },
         [
             'strong',
@@ -213,7 +202,6 @@ export const calloutSchema = $node('inkkit_callout', (ctx) => ({
                 fold: node.fold,
                 title: node.title,
                 titleSource: node.titleSource,
-                listPlaceholder: node.listPlaceholder,
             });
             state.next(node.children);
             state.closeNode();
@@ -222,17 +210,6 @@ export const calloutSchema = $node('inkkit_callout', (ctx) => ({
     toMarkdown: {
         match: (node) => node.type.name === 'inkkit_callout',
         runner(state, node) {
-            const parent = state.top();
-            const first = parent?.children?.[0];
-            // Lists require a leading paragraph even when their authored first block is a callout.
-            if (node.attrs.listPlaceholder &&
-                parent?.type === 'listItem' &&
-                parent.children?.length === 1 &&
-                first?.type === 'paragraph' &&
-                first.children?.length === 1 &&
-                first.children[0]?.type === 'html' &&
-                first.children[0].value === '<br />')
-                parent.children = [];
             state.openNode('inkkitCallout', undefined, { ...node.attrs });
             state.next(node.content);
             state.closeNode();

package/dist/code-fences.js

@@ -11,6 +11,8 @@ function readFence(value) {
         fence.marker.length <= 30000 &&
         typeof fence.info === 'string' &&
         !/[\r\n]/.test(fence.info) &&
+        // A backtick in the info string of a backtick fence is not a fence.
+        !(fence.marker[0] === '`' && fence.info.includes('`')) &&
         typeof fence.close === 'string' &&
         (!fence.close ||
             new RegExp(`^${fence.marker[0]}{${fence.marker.length},}$`).test(fence.close)) &&
@@ -61,6 +63,9 @@ export const preservingCodeBlocks = codeBlockSchema.extendSchema((base) => (ctx)
                     let authoredFence = null;
                     try {
                         authoredFence = readFence(JSON.parse(dom.getAttribute('data-inkkit-fence') ?? 'null'));
+                        // An unclosed fence would take in the content that follows it.
+                        if (!authoredFence?.close)
+                            authoredFence = null;
                     }
                     catch {
                         /* Ordinary code stays usable without provenance. */
@@ -108,7 +113,7 @@ export const fencedCodeHandler = (node, parent, state, info) => {
         return defaultHandlers.code(node, parent, state, info);
     const character = fence.marker[0];
     let length = fence.marker.length;
-    const body = node.value.replace(/\r\n?/g, '\n');
+    const body = (node.value ?? '').replace(/\r\n?/g, '\n');
     for (const line of body.split('\n')) {
         const run = new RegExp(`^ {0,3}(${character}+)[ \\t]*$`).exec(line);
         if (run)

package/dist/comments.d.ts

@@ -1,4 +1,5 @@
 import { Fragment, type Node as ProseNode } from '@milkdown/kit/prose/model';
+import { type Transaction } from '@milkdown/kit/prose/state';
 import type { EditorView } from '@milkdown/kit/prose/view';
 import type { Literal } from 'mdast';
 export type CommentSyntax = 'html' | 'obsidian';
@@ -49,6 +50,26 @@ export declare const commentBlock: import("@milkdown/kit/utils").$Node;
 export declare const commentVisibility: import("@milkdown/kit/utils").$Prose;
 export declare function setCommentVisibility(view: EditorView, visible: boolean): void;
 export declare const comments: (import("@milkdown/kit/utils").$Node | import("@milkdown/kit/utils").$Prose)[];
+/**
+ * Whether text inside a comment ends it early for a reader other than InkKit.
+ * HTML ends a comment at `-->` or `--!>`, and treats a start of `>` or `->` as
+ * an empty comment. A `%%` comment ends at its next `%%`.
+ */
+export declare function commentTextEndsEarly(syntax: string, text: string): boolean;
+/**
+ * Refuses an edit that gives a comment text which ends it early. A comment
+ * that already held that text before the edit is left alone, so a note that
+ * has one still loads and can be edited elsewhere.
+ */
+export declare function assertCommentsEndWhereWritten(before: ProseNode, after: ProseNode): void;
+/** Marks a transaction that replaces the document with source given as written. */
+export declare const sourceReplacement = "inkkit:sourceReplacement";
+/**
+ * Whether an edit is typed or inserted by a person in the formatted editor. A
+ * history step restores a document the editor already accepted, and a source
+ * replacement is the author's own text, so neither is checked.
+ */
+export declare function isWrittenEdit(tr: Transaction): boolean;
 export declare function isComment(node: ProseNode): boolean;
 export declare function shareableFragment(content: Fragment): Fragment;
 export declare function commentSelectionContent(doc: ProseNode, from: number, to: number, content: Fragment): Fragment;

package/dist/comments.js

@@ -1,5 +1,6 @@
 import { $node, $prose, $remark } from '@milkdown/kit/utils';
 import { Fragment } from '@milkdown/kit/prose/model';
+import { isHistoryTransaction } from '@milkdown/kit/prose/history';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { isImageBlock } from './image-blocks.js';
 import { fromMarkdown } from 'mdast-util-from-markdown';
@@ -322,11 +323,16 @@ function commentNode(inline) {
             {
                 tag: `${inline ? 'span' : 'div'}[data-inkkit-comment]`,
                 preserveWhitespace: 'full',
-                getAttrs: (dom) => ({
-                    syntax: dom.getAttribute('data-inkkit-comment') === 'obsidian'
+                getAttrs(dom) {
+                    const syntax = dom.getAttribute('data-inkkit-comment') === 'obsidian'
                         ? 'obsidian'
-                        : 'html',
-                }),
+                        : 'html';
+                    // Text that would end the comment early would leave the rest as
+                    // Markdown, so it stays plain text.
+                    if (commentTextEndsEarly(syntax, dom.textContent ?? ''))
+                        return false;
+                    return { syntax };
+                },
             },
         ],
         toDOM: (node) => [
@@ -384,6 +390,51 @@ export function setCommentVisibility(view, visible) {
         .setMeta('addToHistory', false));
 }
 export const comments = [commentInline, commentBlock, commentVisibility].flat();
+/**
+ * Whether text inside a comment ends it early for a reader other than InkKit.
+ * HTML ends a comment at `-->` or `--!>`, and treats a start of `>` or `->` as
+ * an empty comment. A `%%` comment ends at its next `%%`.
+ */
+export function commentTextEndsEarly(syntax, text) {
+    return syntax === 'obsidian'
+        ? text.includes('%%')
+        : /^-?>/.test(text) || text.includes('-->') || text.includes('--!>');
+}
+/**
+ * Refuses an edit that gives a comment text which ends it early. A comment
+ * that already held that text before the edit is left alone, so a note that
+ * has one still loads and can be edited elsewhere.
+ */
+export function assertCommentsEndWhereWritten(before, after) {
+    const unsafe = (doc, visit) => doc.descendants((node) => {
+        if (!isComment(node))
+            return true;
+        if (commentTextEndsEarly(node.attrs.syntax, node.textContent))
+            visit(`${node.attrs.syntax}:${node.textContent}`);
+        return false;
+    });
+    let allowed;
+    unsafe(after, (key) => {
+        if (!allowed) {
+            allowed = new Map();
+            unsafe(before, (known) => allowed.set(known, (allowed.get(known) ?? 0) + 1));
+        }
+        const remaining = allowed.get(key) ?? 0;
+        if (remaining === 0)
+            throw new Error('A comment cannot contain text that would end it early');
+        allowed.set(key, remaining - 1);
+    });
+}
+/** Marks a transaction that replaces the document with source given as written. */
+export const sourceReplacement = 'inkkit:sourceReplacement';
+/**
+ * Whether an edit is typed or inserted by a person in the formatted editor. A
+ * history step restores a document the editor already accepted, and a source
+ * replacement is the author's own text, so neither is checked.
+ */
+export function isWrittenEdit(tr) {
+    return !isHistoryTransaction(tr) && !tr.getMeta(sourceReplacement);
+}
 export function isComment(node) {
     return (node.type.name === 'comment_inline' || node.type.name === 'comment_block');
 }

package/dist/core.d.ts

@@ -0,0 +1,7 @@
+export { InkKitEditor } from './editor.js';
+export type { EditorEvents, EditorOptions, TextInputPreferences, CommandState, EditingMode, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
+export type { TableCommand, TableOptions } from './tables.js';
+export type { Heading } from './outline.js';
+export { InkKitError } from './types.js';
+export type { DocumentFormat, DocumentContext, DocumentInput, DocumentSnapshot, EditorErrorCode, ImageAdapter, WikiLinkReference, WikiLinkAdapter, FileReference, FileContext, FilePresentation, FileAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, TextRange, ReadableTextSnapshot, TextRect, ViewportInsets, ViewportOptions, ViewportSnapshot, } from './types.js';
+export type { EditorLabels } from './labels.js';

package/dist/core.js

@@ -0,0 +1,2 @@
+export { InkKitEditor } from './editor.js';
+export { InkKitError } from './types.js';

package/dist/cursor.d.ts

@@ -0,0 +1,2 @@
+import { dropIndicatorConfig } from '@milkdown/kit/plugin/cursor';
+export declare const cursor: (import("@milkdown/kit/utils").$Ctx<dropIndicatorConfig, "dropIndicatorConfig"> | import("@milkdown/kit/utils").$Ctx<import("@milkdown/kit/plugin/cursor").DropIndicatorState, "dropIndicatorState"> | import("@milkdown/kit/utils").$Prose)[];

package/dist/cursor.js

@@ -0,0 +1,40 @@
+import { dropIndicatorConfig, dropIndicatorDOMPlugin, dropIndicatorState, gapCursorPlugin, } from '@milkdown/kit/plugin/cursor';
+import { Plugin } from '@milkdown/kit/prose/state';
+import { $prose } from '@milkdown/kit/utils';
+import { createDropIndicatorPlugin } from 'prosemirror-drop-indicator';
+// Milkdown's drop indicator, except that it does not hide once the editor is
+// gone. The indicator hides 30 ms after a drop or drag end, and setting its
+// state after the editor is destroyed throws.
+const dropIndicator = $prose((ctx) => {
+    let live = false;
+    const plugin = createDropIndicatorPlugin({
+        onShow: (options) => ctx.set(dropIndicatorState.key, options),
+        onHide: () => {
+            if (live)
+                ctx.set(dropIndicatorState.key, null);
+        },
+        onDrag: () => true,
+    });
+    const view = plugin.spec.view;
+    return new Plugin({
+        ...plugin.spec,
+        view(editorView) {
+            live = true;
+            const inner = view(editorView);
+            return {
+                ...inner,
+                destroy() {
+                    live = false;
+                    inner.destroy?.();
+                },
+            };
+        },
+    });
+});
+export const cursor = [
+    gapCursorPlugin,
+    dropIndicatorConfig,
+    dropIndicatorState,
+    dropIndicatorDOMPlugin,
+    dropIndicator,
+].flat();

package/dist/dialect.js

@@ -1,14 +1,16 @@
 import { editorViewCtx, serializerCtx } from '@milkdown/kit/core';
 import { commonmark, docSchema, hardbreakSchema, imageSchema, paragraphSchema, remarkInlineLinkPlugin, } from '@milkdown/kit/preset/commonmark';
 import { extendListItemSchemaForTask, strikethroughAttr, strikethroughInputRule, strikethroughKeymap, strikethroughSchema, toggleStrikethroughCommand, wrapInTaskListInputRule, tableSchema, tableHeaderRowSchema, tableHeaderSchema, tableRowSchema, tableCellSchema, tableEditingPlugin, tableKeymap, goToNextTableCellCommand, goToPrevTableCellCommand, insertTableCommand, addRowBeforeCommand, addRowAfterCommand, addColBeforeCommand, addColAfterCommand, selectRowCommand, selectColCommand, deleteSelectedCellsCommand, setAlignCommand, exitTable, } from '@milkdown/kit/preset/gfm';
-import { $node, $remark } from '@milkdown/kit/utils';
+import { $node, $prose, $remark } from '@milkdown/kit/utils';
+import { keymap } from '@milkdown/kit/prose/keymap';
 import { autolinkInputRule } from './autolink.js';
+import { isScriptAddress } from './link-safety.js';
 import { sourceAttribute } from './source.js';
 import { linkedSyntax, wikiLinkSchema, namedFileMarkdown, fileReference, } from './linked-syntax.js';
 import { normalizeTableAlignment, normalizeTableColumnAlignment, } from './table-alignment.js';
 import { preservingCodeBlocks, remarkCodeFences, fencedCodeHandler, } from './code-fences.js';
 import { literalBlock, createLiteralPreservation } from './literals.js';
-import { imageAttrs, imageBlocks, markdownImageAttrs, readParagraph, } from './image-blocks.js';
+import { imageAttrs, imageBlockName, imageBlocks, markdownImageAttrs, readParagraph, } from './image-blocks.js';
 import { references, remarkReferencesPlugin } from './references.js';
 import { callouts, remarkCalloutsPlugin } from './callouts.js';
 import { inlineHighlight } from './inline-highlight.js';
@@ -47,7 +49,7 @@ function textAt(parent, node, offset) {
 }
 /** A link whose text is its own URL is written as the bare URL, the way it was typed. Only where reading
  *  it back gives the same link again: nothing may run into it at either end. */
-function writesBare(node, parent) {
+function writesBare(node, parent, inCell) {
     const [child, ...rest] = node.children;
     if (node.title ||
         rest.length > 0 ||
@@ -64,12 +66,16 @@ function writesBare(node, parent) {
     const after = textAt(parent, node, 1);
     if (after && (after.type !== 'text' || !afterURL.test(after.value)))
         return false;
-    return true;
+    // Spaces that end a cell are written as character references, which a bare URL would run into.
+    return !(inCell &&
+        after?.type === 'text' &&
+        /^[ \t]+$/.test(after.value) &&
+        parent?.children.at(-1) === after);
 }
-const link = (node, parent, state, info) => writesBare(node, parent)
+const link = (node, parent, state, info) => writesBare(node, parent, state.stack.includes('tableCell'))
     ? node.url
     : defaultHandlers.link(node, parent, state, info);
-link.peek = (node, parent, state) => writesBare(node, parent)
+link.peek = (node, parent, state) => writesBare(node, parent, state.stack.includes('tableCell'))
     ? node.url[0]
     : defaultHandlers.link.peek(node, parent, state);
 function remarkDialect() {
@@ -94,14 +100,45 @@ function remarkDialect() {
         handlers: {
             text(node, parent, state, info) {
                 const value = defaultHandlers.text(node, parent, state, info);
-                // GFM trims literal whitespace at cell edges on reopening.
-                return state.stack.includes('tableCell')
-                    ? value.replace(/^[ \t]+|[ \t]+$/g, (spaces) => spaces.replaceAll(' ', ' ').replaceAll('\t', '	'))
+                // GFM trims spaces and tabs at the edges of a cell on reopening, so
+                // only the start of its first node and the end of its last need
+                // encoding. Inside a mark or link, delimiters stand before the pipe.
+                if (!state.stack.includes('tableCell') ||
+                    (parent?.type !== 'paragraph' && parent?.type !== 'tableCell'))
+                    return value;
+                const siblings = parent.children;
+                const encode = (spaces) => spaces.replaceAll(' ', ' ').replaceAll('\t', '	');
+                return value
+                    .replace(/^[ \t]+/, (spaces) => siblings[0] === node ? encode(spaces) : spaces)
+                    .replace(/[ \t]+$/, (spaces) => siblings.at(-1) === node ? encode(spaces) : spaces);
+            },
+            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 } });
+    return padShortRows;
+}
+// GFM reads a row with fewer cells than its header as ending in empty cells.
+// The editor holds them from the start; otherwise table editing adds them
+// after the first edit, and again after every Undo.
+function padShortRows(node) {
+    if (node.type === 'table') {
+        const width = node.children[0]?.children.length ?? 0;
+        for (const row of node.children)
+            while (row.children.length < width)
+                row.children.push({ type: 'tableCell', children: [] });
+    }
+    if ('children' in node)
+        node.children.forEach(padShortRows);
 }
 export const remarkDialectPlugin = $remark('remarkDialect', () => remarkDialect);
 // Reference links retain their authored form instead of expanding to inline links.
@@ -190,8 +227,11 @@ const normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
             {
                 tag: 'img[src]',
                 getAttrs(dom) {
+                    const src = dom.getAttribute('src') ?? '';
+                    if (isScriptAddress(src))
+                        return false;
                     return {
-                        src: dom.getAttribute('src') ?? '',
+                        src,
                         alt: dom.getAttribute('alt') ?? '',
                         title: dom.getAttribute('title') ?? '',
                     };
@@ -224,6 +264,61 @@ const normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
         },
     };
 });
+// The preset drops a cell's final break, and a paragraph writes an empty one as
+// the spacer `<br />`; either reads back differently, so a cell writes its
+// paragraph's content directly.
+function cellToMarkdown(base) {
+    return {
+        ...base,
+        runner(state, node) {
+            if (node.childCount === 1 && node.firstChild.type.name === 'paragraph')
+                state.openNode('tableCell').next(node.firstChild.content).closeNode();
+            else
+                base.runner(state, node);
+        },
+    };
+}
+// A cell cannot hold a line ending, so Shift-Enter there inserts the `<br />`
+// a cell reads back. The preset's command would instead split the paragraph
+// when it already ends in a break, which reshapes the table.
+const cellBreakKeymap = $prose(() => keymap({
+    'Shift-Enter': (state, dispatch) => {
+        const { $from } = state.selection;
+        if (!/^table_(cell|header)$/.test($from.node(-1)?.type.name ?? ''))
+            return false;
+        dispatch?.(state.tr
+            // A break inside a mark or link would be inline HTML there, which
+            // a cell does not read back as a break.
+            .replaceSelectionWith(state.schema.nodes.hardbreak.create({ isHTML: true }), false)
+            .scrollIntoView());
+        return true;
+    },
+}));
+// A list item that opens with a block, such as a code fence, is held with the
+// empty first paragraph the schema requires. Written out, that paragraph would
+// be a spacer `<br />` line; without it the item reads back the same.
+const listItems = extendListItemSchemaForTask.extendSchema((previous) => (ctx) => {
+    const schema = previous(ctx);
+    return {
+        ...schema,
+        toMarkdown: {
+            ...schema.toMarkdown,
+            runner(state, node) {
+                const [first, second] = [node.firstChild, node.maybeChild(1)];
+                // A task item's checkbox is written on its first line.
+                if (node.attrs.checked == null &&
+                    first?.type.name === 'paragraph' &&
+                    first.content.size === 0 &&
+                    second &&
+                    second.type.name !== 'paragraph' &&
+                    // An image block reads back as a paragraph in that position.
+                    second.type.name !== imageBlockName)
+                    node = node.copy(node.content.cut(first.nodeSize));
+                schema.toMarkdown.runner(state, node);
+            },
+        },
+    };
+});
 export const tables = [
     tableSchema.extendSchema((previous) => (ctx) => ({
         ...previous(ctx),
@@ -235,6 +330,7 @@ export const tables = [
         return {
             ...schema,
             attrs: { ...schema.attrs, alignment: { default: null } },
+            toMarkdown: cellToMarkdown(schema.toMarkdown),
             parseDOM: schema.parseDOM?.map((rule) => 'tag' in rule
                 ? {
                     ...rule,
@@ -257,6 +353,7 @@ export const tables = [
         return {
             ...schema,
             attrs: { ...schema.attrs, alignment: { default: null } },
+            toMarkdown: cellToMarkdown(schema.toMarkdown),
             parseDOM: schema.parseDOM?.map((rule) => 'tag' in rule
                 ? {
                     ...rule,
@@ -290,6 +387,7 @@ export const tables = [
 ].flat();
 export function createDialect(images, wikiLinks = false, files = false) {
     return [
+        cellBreakKeymap,
         remarkCodeFences,
         remarkReferencesPlugin,
         remarkCalloutsPlugin,
@@ -316,7 +414,7 @@ export function createDialect(images, wikiLinks = false, files = false) {
         normalizedImages,
         imageBlocks,
         autolinkInputRule,
-        extendListItemSchemaForTask,
+        listItems,
         strikethroughAttr,
         strikethroughSchema,
         strikethroughInputRule,

package/dist/drop-placement.d.ts

@@ -0,0 +1,19 @@
+import type { Node } from '@milkdown/kit/prose/model';
+import { Selection } from '@milkdown/kit/prose/state';
+import type { EditorView } from '@milkdown/kit/prose/view';
+/**
+ * Where blocks dropped at a point go: in place of an empty top-level
+ * paragraph at or beside the point, otherwise after the top-level block under the
+ * point, or beside a top-level leaf such as an image rather than inside it. The result is a range
+ * to replace; an insertion point has `from` equal to `to`.
+ */
+export declare function blockDropRange(view: EditorView, x: number, y: number): {
+    from: number;
+    to: number;
+};
+/**
+ * A caret just after inserted blocks that end at `pos`: at the end of the
+ * last text block, or a gap cursor after a block that holds no text, such as
+ * a rule or table. It never selects a node, so typing never replaces one.
+ */
+export declare function caretAfter(doc: Node, pos: number): Selection;

package/dist/drop-placement.js

@@ -0,0 +1,47 @@
+import { GapCursor } from '@milkdown/kit/prose/gapcursor';
+import { Selection, TextSelection } from '@milkdown/kit/prose/state';
+/**
+ * Where blocks dropped at a point go: in place of an empty top-level
+ * paragraph at or beside the point, otherwise after the top-level block under the
+ * point, or beside a top-level leaf such as an image rather than inside it. The result is a range
+ * to replace; an insertion point has `from` equal to `to`.
+ */
+export function blockDropRange(view, x, y) {
+    const { doc, selection } = view.state;
+    const hit = view.posAtCoords({ left: x, top: y });
+    const $pos = doc.resolve(hit?.pos ?? selection.from);
+    // Only an empty paragraph is a placeholder; an empty heading or code block
+    // was written.
+    const empty = (node) => node?.type.name === 'paragraph' && node.content.size === 0;
+    if ($pos.depth === 1 && empty($pos.parent))
+        return { from: $pos.before(1), to: $pos.after(1) };
+    if ($pos.depth > 0)
+        return { from: $pos.after(1), to: $pos.after(1) };
+    // A point in the margin beside an empty paragraph, as in an empty note.
+    if (empty($pos.nodeAfter))
+        return { from: $pos.pos, to: $pos.pos + $pos.nodeAfter.nodeSize };
+    if (empty($pos.nodeBefore))
+        return { from: $pos.pos - $pos.nodeBefore.nodeSize, to: $pos.pos };
+    const leaf = hit && hit.inside >= 0 && doc.resolve(hit.inside).depth === 0
+        ? doc.nodeAt(hit.inside)
+        : null;
+    const at = leaf ? hit.inside + leaf.nodeSize : $pos.pos;
+    return { from: at, to: at };
+}
+/**
+ * A caret just after inserted blocks that end at `pos`: at the end of the
+ * last text block, or a gap cursor after a block that holds no text, such as
+ * a rule or table. It never selects a node, so typing never replaces one.
+ */
+export function caretAfter(doc, pos) {
+    const $pos = doc.resolve(pos);
+    if ($pos.nodeBefore?.isTextblock)
+        return TextSelection.create(doc, pos - 1);
+    // `valid` is public at run time but missing from the type declarations.
+    const gap = GapCursor;
+    if (gap.valid($pos))
+        return new GapCursor($pos);
+    return (TextSelection.findFrom($pos, -1, true) ??
+        TextSelection.findFrom($pos, 1, true) ??
+        Selection.near($pos));
+}