@aicayzer/inkkit 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 August Cayzer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,6 @@
+InkKit includes editor behavior and source from PadPad and Memos.
+Copyright (c) 2026 August Cayzer. Licensed under the MIT License.
+Sources: https://github.com/aicayzer/padpad and https://github.com/aicayzer/memos
+
+Milkdown and other runtime dependencies retain their own licenses. They are
+installed as dependencies rather than embedded in this package.

package/README.md

@@ -1,3 +1,40 @@
-# Temporary Holding Version
+# InkKit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+InkKit is a TypeScript Markdown editor for offline web views and the web. It provides readable clipboard output, editable tables, optional host-managed images, and preservation of original Markdown and unsupported syntax.
+
+```sh
+npm install @aicayzer/inkkit
+```
+
+```ts
+import { InkKitEditor } from '@aicayzer/inkkit'
+import '@aicayzer/inkkit/style.css'
+
+const editor = await InkKitEditor.mount(document.getElementById('editor')!, {
+  changed(text, generation) {
+    /* Notify the host. */
+  },
+  stateChanged(state) {
+    /* Update formatting controls. */
+  },
+  openLink(href) {
+    /* Open through the host. */
+  },
+  copy(text) {
+    /* Write code-block text to the clipboard. */
+  },
+})
+editor.loadDocument({
+  documentId: 'note',
+  generation: 1,
+  format: 'md',
+  text: '# Hello\n',
+})
+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.
+
+See [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
+
+MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).

package/dist/autolink.d.ts

@@ -0,0 +1 @@
+export declare const autolinkInputRule: import("@milkdown/kit/utils").$InputRule;

package/dist/autolink.js

@@ -0,0 +1,18 @@
+import { linkSchema } from '@milkdown/kit/preset/commonmark';
+import { InputRule } from '@milkdown/kit/prose/inputrules';
+import { $inputRule } from '@milkdown/kit/utils';
+// A typed URL becomes a link once a space follows it; nothing links it otherwise.
+export const autolinkInputRule = $inputRule((ctx) => {
+    return new InputRule(/(?:^|\s)(https?:\/\/[^\s<>]+[^\s<>.,;:!?)\]])\s$/, (state, match, _start, end) => {
+        const url = match[1];
+        if (!url)
+            return null;
+        const to = end;
+        const from = to - url.length;
+        const mark = linkSchema.type(ctx).create({ href: url });
+        return state.tr
+            .addMark(from, to, mark)
+            .insertText(' ', end, end)
+            .removeStoredMark(mark);
+    });
+});

package/dist/clipboard.d.ts

@@ -0,0 +1,11 @@
+import { type Fragment, type Schema } from '@milkdown/kit/prose/model';
+import type { ClipboardOutput, DocumentContext, ImageAdapter } from './types.js';
+export interface ClipboardContent {
+    text: string;
+    html: string;
+}
+export declare function clipboardText(content: Fragment, missingImages?: ReadonlySet<string>): string;
+export declare function clipboardContent(content: Fragment, schema: Schema): ClipboardContent;
+export declare const visibleClipboard: import("@milkdown/kit/utils").$Prose;
+/** Export a frozen document fragment; presentation URLs never enter the clipboard. */
+export declare function portableClipboard(content: Fragment, schema: Schema, markdown: string, adapter: ImageAdapter | undefined, context: DocumentContext): Promise<ClipboardOutput>;

package/dist/clipboard.js

@@ -0,0 +1,140 @@
+import { DOMSerializer, } from '@milkdown/kit/prose/model';
+import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
+import { $prose } from '@milkdown/kit/utils';
+// Clipboard text is the visible document, not Markdown serialization: escaping
+// 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)));
+    const inline = content.firstChild?.isInline ?? false;
+    return blocks.join(inline ? '' : '\n\n');
+}
+function nodeText(node, missingImages) {
+    if (node.isText)
+        return node.text ?? '';
+    if (node.type.name === 'hardbreak' || node.type.name === 'hard_break')
+        return '\n';
+    if (node.type.name === 'bullet_list' || node.type.name === 'ordered_list') {
+        const items = [];
+        node.forEach((item, _offset, index) => {
+            const marker = node.type.name === 'ordered_list'
+                ? `${Number(node.attrs.order ?? 1) + index}. `
+                : '- ';
+            const task = item.attrs.checked == null ? '' : item.attrs.checked ? '[x] ' : '[ ] ';
+            const prefix = marker + task;
+            const indent = ' '.repeat(marker.length);
+            const blocks = [];
+            item.forEach((child, _childOffset, childIndex) => {
+                const text = nodeText(child, missingImages);
+                const nestedList = child.type.name === 'bullet_list' ||
+                    child.type.name === 'ordered_list';
+                const lines = text.split('\n');
+                const indented = lines
+                    .map((line, lineIndex) => childIndex === 0 && lineIndex === 0 ? prefix + line : indent + line)
+                    .join('\n');
+                // Nested lists follow their parent directly; subsequent paragraphs keep
+                // their blank line and every continuation stays inside its list item.
+                blocks.push((childIndex > 0 && !nestedList ? '\n' : '') + indented);
+            });
+            items.push(blocks.length ? blocks.join('\n') : prefix.trimEnd());
+        });
+        return items.join('\n');
+    }
+    if (node.type.name === 'image') {
+        const alt = String(node.attrs.alt ?? '').replace(/\|\d{1,5}$/, '') || 'Image';
+        return missingImages.has(String(node.attrs.src ?? ''))
+            ? `[${alt}: image unavailable]`
+            : alt;
+    }
+    if (node.type.name === 'table') {
+        const rows = [];
+        node.forEach((row) => {
+            const cells = [];
+            row.forEach((cell) => cells.push(clipboardText(cell.content, missingImages)));
+            rows.push(cells.join('\t'));
+        });
+        return rows.join('\n');
+    }
+    return clipboardText(node.content, missingImages);
+}
+export function clipboardContent(content, schema) {
+    const container = document.createElement('div');
+    const serializer = DOMSerializer.fromSchema(schema);
+    // Construct image elements without a source so detached clipboard DOM never
+    // fetches authored references or temporary presentation URLs.
+    const safe = new DOMSerializer({
+        ...serializer.nodes,
+        image: (node) => [
+            'img',
+            {
+                alt: String(node.attrs.alt ?? ''),
+                title: String(node.attrs.title ?? ''),
+            },
+        ],
+    }, serializer.marks);
+    container.append(safe.serializeFragment(content));
+    return { text: clipboardText(content), html: container.innerHTML };
+}
+export const visibleClipboard = $prose(() => new Plugin({
+    key: new PluginKey('visibleClipboard'),
+    props: {
+        clipboardTextSerializer: (slice) => clipboardText(slice.content),
+    },
+}));
+/** Export a frozen document fragment; presentation URLs never enter the clipboard. */
+export async function portableClipboard(content, schema, markdown, adapter, context) {
+    const base = clipboardContent(content, schema);
+    const container = document.createElement('div');
+    container.innerHTML = base.html;
+    const images = [];
+    const references = [];
+    content.descendants((node) => {
+        if (node.type.name === 'image')
+            references.push(String(node.attrs.src ?? ''));
+    });
+    const captured = [...container.querySelectorAll('img')].map((element, index) => {
+        const reference = references[index] ?? '';
+        const alt = element.getAttribute('alt')?.replace(/\|\d{1,5}$/, '') || 'Image';
+        element.removeAttribute('src');
+        element.removeAttribute('srcset');
+        return { element, reference, alt };
+    });
+    await Promise.all(captured.map(async ({ element, reference, alt }, index) => {
+        try {
+            if (!adapter)
+                throw new Error('The image is unavailable.');
+            const image = await adapter.exportImage(reference, { ...context });
+            if (!/^image\/(png|jpeg|gif|webp|avif|bmp|tiff)$/i.test(image.mimeType))
+                throw new Error('The image format cannot be exported.');
+            let binary = '';
+            for (const byte of image.bytes)
+                binary += String.fromCharCode(byte);
+            const portable = `data:${image.mimeType};base64,${btoa(binary)}`;
+            element.setAttribute('src', portable);
+            element.setAttribute('alt', alt);
+            images[index] = { reference, alt, image };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'The image is unavailable.';
+            const warning = document.createElement('span');
+            warning.textContent = `[${alt}: image unavailable]`;
+            element.replaceWith(warning);
+            images[index] = { reference, alt, error: message };
+        }
+    }));
+    // Scriptable links and event attributes are not part of semantic rich text.
+    for (const element of container.querySelectorAll('*')) {
+        for (const attribute of [...element.attributes])
+            if (attribute.name.startsWith('on') ||
+                ((attribute.name === 'href' || attribute.name === 'src') &&
+                    /^javascript:/i.test(attribute.value)))
+                element.removeAttribute(attribute.name);
+    }
+    const missing = new Set(images.filter((image) => image.error).map((image) => image.reference));
+    return {
+        text: clipboardText(content, missing),
+        html: container.innerHTML,
+        markdown,
+        images,
+    };
+}

package/dist/decorations.d.ts

@@ -0,0 +1,2 @@
+export declare function codeCopyPlugin(onCopy: (text: string) => void): import("@milkdown/kit/utils").$Prose;
+export declare const placeholderPlugin: import("@milkdown/kit/utils").$Prose;

package/dist/decorations.js

@@ -0,0 +1,66 @@
+import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
+import { Decoration, DecorationSet } from '@milkdown/kit/prose/view';
+import { $prose } from '@milkdown/kit/utils';
+const copyIcon = '<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="5.5" y="5.5" width="8" height="8" rx="1.5"/><path d="M10.5 5.5v-2a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2"/></svg>';
+const doneIcon = '<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3.5 8.5l3 3 6-6.5"/></svg>';
+// The button reads the block's text when clicked, so the same widget can stay
+// mounted while the block is edited.
+function copyButton(onCopy) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'copy';
+    button.setAttribute('aria-label', 'Copy');
+    button.innerHTML = copyIcon;
+    button.addEventListener('mousedown', (event) => event.preventDefault());
+    button.addEventListener('click', () => {
+        const code = button.closest('pre')?.querySelector('code');
+        onCopy(code?.textContent ?? '');
+        button.dataset.copied = '';
+        button.innerHTML = doneIcon;
+        window.setTimeout(() => {
+            delete button.dataset.copied;
+            button.innerHTML = copyIcon;
+        }, 1200);
+    });
+    return button;
+}
+export function codeCopyPlugin(onCopy) {
+    return $prose(() => new Plugin({
+        key: new PluginKey('codeCopy'),
+        props: {
+            decorations(state) {
+                const widgets = [];
+                state.doc.descendants((node, pos) => {
+                    if (node.type.name !== 'code_block')
+                        return true;
+                    widgets.push(Decoration.widget(pos + 1, () => copyButton(onCopy), {
+                        side: -1,
+                        key: 'copy',
+                        ignoreSelection: true,
+                    }));
+                    return false;
+                });
+                return DecorationSet.create(state.doc, widgets);
+            },
+        },
+    }));
+}
+export const placeholderPlugin = $prose(() => new Plugin({
+    key: new PluginKey('placeholder'),
+    props: {
+        decorations(state) {
+            const first = state.doc.firstChild;
+            if (state.doc.childCount !== 1 ||
+                !first?.isTextblock ||
+                first.type.name === 'heading' ||
+                first.content.size > 0)
+                return null;
+            return DecorationSet.create(state.doc, [
+                Decoration.node(0, first.nodeSize, {
+                    class: 'empty',
+                    'data-placeholder': 'Start typing…',
+                }),
+            ]);
+        },
+    },
+}));

package/dist/dialect.d.ts

@@ -0,0 +1,9 @@
+import type { Ctx, MilkdownPlugin } from '@milkdown/kit/ctx';
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import { type Options as StringifyOptions } from 'mdast-util-to-markdown';
+export declare const remarkDialectPlugin: import("@milkdown/kit/utils").$Remark<"remarkDialect", unknown>;
+export declare const tables: MilkdownPlugin[];
+export declare function createDialect(images: boolean): MilkdownPlugin[];
+export declare const dialect: MilkdownPlugin[];
+export declare const stringifyOptions: StringifyOptions;
+export declare function serialize(ctx: Ctx, doc?: ProseNode): string;

package/dist/dialect.js

@@ -0,0 +1,290 @@
+import { editorViewCtx, serializerCtx } from '@milkdown/kit/core';
+import { commonmark, 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 { $remark } from '@milkdown/kit/utils';
+import { autolinkInputRule } from './autolink.js';
+import { literalBlock, createLiteralPreservation } from './literals.js';
+import { gfmTableFromMarkdown, gfmTableToMarkdown } from 'mdast-util-gfm-table';
+import { gfmTable } from 'micromark-extension-gfm-table';
+import { defaultHandlers, } from 'mdast-util-to-markdown';
+import { gfmAutolinkLiteralFromMarkdown, gfmAutolinkLiteralToMarkdown, } from 'mdast-util-gfm-autolink-literal';
+import { gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown, } from 'mdast-util-gfm-strikethrough';
+import { gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown, } from 'mdast-util-gfm-task-list-item';
+import { gfmAutolinkLiteral } from 'micromark-extension-gfm-autolink-literal';
+import { gfmStrikethrough } from 'micromark-extension-gfm-strikethrough';
+import { gfmTaskListItem } from 'micromark-extension-gfm-task-list-item';
+const bareURL = /^https?:\/\/[^\s<>]+$/;
+// The literal form stops at these, so a URL ending in one would come back shorter than it went out.
+const endsInPunctuation = /[.,;:!?]$/;
+// What may sit against a bare URL without the reader running the two together.
+const beforeURL = /(^|[\s([*_~])$/;
+const afterURL = /^([\s.,;:!?)\]}<]|$)/;
+function balanced(url) {
+    let open = 0;
+    for (const character of url) {
+        if (character === '(')
+            open += 1;
+        else if (character === ')')
+            open -= 1;
+        if (open < 0)
+            return false;
+    }
+    return open === 0;
+}
+function textAt(parent, node, offset) {
+    const children = parent?.children;
+    const index = children?.indexOf(node) ?? -1;
+    return index < 0 ? undefined : children?.[index + 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) {
+    const [child, ...rest] = node.children;
+    if (node.title ||
+        rest.length > 0 ||
+        child?.type !== 'text' ||
+        child.value !== node.url)
+        return false;
+    if (!bareURL.test(node.url) ||
+        endsInPunctuation.test(node.url) ||
+        !balanced(node.url))
+        return false;
+    const before = textAt(parent, node, -1);
+    if (before && (before.type !== 'text' || !beforeURL.test(before.value)))
+        return false;
+    const after = textAt(parent, node, 1);
+    if (after && (after.type !== 'text' || !afterURL.test(after.value)))
+        return false;
+    return true;
+}
+const link = (node, parent, state, info) => writesBare(node, parent)
+    ? node.url
+    : defaultHandlers.link(node, parent, state, info);
+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) => {
+        const list = (data[key] ??= []);
+        list.push(value);
+    };
+    add('micromarkExtensions', gfmStrikethrough());
+    add('micromarkExtensions', gfmTaskListItem());
+    add('micromarkExtensions', gfmAutolinkLiteral());
+    add('micromarkExtensions', gfmTable());
+    add('fromMarkdownExtensions', gfmStrikethroughFromMarkdown());
+    add('fromMarkdownExtensions', gfmTaskListItemFromMarkdown());
+    add('fromMarkdownExtensions', gfmAutolinkLiteralFromMarkdown());
+    add('fromMarkdownExtensions', gfmTableFromMarkdown());
+    add('toMarkdownExtensions', gfmStrikethroughToMarkdown());
+    add('toMarkdownExtensions', gfmTaskListItemToMarkdown());
+    add('toMarkdownExtensions', gfmAutolinkLiteralToMarkdown());
+    add('toMarkdownExtensions', gfmTableToMarkdown());
+    add('toMarkdownExtensions', { handlers: { link } });
+}
+export const remarkDialectPlugin = $remark('remarkDialect', () => remarkDialect);
+// Keep authored spacer paragraphs; references remain literal instead of becoming 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) => {
+    const schema = base(ctx);
+    return {
+        ...schema,
+        toMarkdown: {
+            ...schema.toMarkdown,
+            runner(state, node) {
+                if (node.lastChild?.type.name === 'hardbreak') {
+                    state.openNode('paragraph');
+                    state.next(node.content.cut(0, node.content.size - node.lastChild.nodeSize));
+                    state.addNode('html', undefined, '<br />');
+                    state.closeNode();
+                    return;
+                }
+                if (node.content.size > 0)
+                    return schema.toMarkdown.runner(state, node);
+                state.openNode('paragraph');
+                state.addNode('html', undefined, '<br />');
+                state.closeNode();
+            },
+        },
+    };
+});
+// Soft Markdown breaks still serialize as a single newline. Display the actual
+// line boundary rather than a space, so changing editor mode never joins lines.
+const visibleSoftbreaks = hardbreakSchema.extendSchema((base) => (ctx) => {
+    const schema = base(ctx);
+    return {
+        ...schema,
+        attrs: { ...schema.attrs, isHTML: { default: false } },
+        parseDOM: [
+            {
+                tag: 'br[data-type="softbreak"]',
+                getAttrs: () => ({ isInline: true }),
+            },
+            {
+                tag: 'br[data-type="hardbreak"]',
+                getAttrs: () => ({ isInline: false }),
+            },
+            { tag: 'br', getAttrs: () => ({ isInline: false, isHTML: true }) },
+        ],
+        parseMarkdown: {
+            ...schema.parseMarkdown,
+            runner(state, node, type) {
+                if (node.data
+                    ?.inkkitHTMLBreak)
+                    state.addNode(type, { isInline: false, isHTML: true });
+                else
+                    schema.parseMarkdown.runner(state, node, type);
+            },
+        },
+        toMarkdown: {
+            ...schema.toMarkdown,
+            runner(state, node) {
+                if (node.attrs.isHTML)
+                    state.addNode('html', undefined, '<br />');
+                else
+                    schema.toMarkdown.runner(state, node);
+            },
+        },
+        toDOM: (node) => node.attrs.isInline
+            ? ['br', { 'data-type': 'softbreak' }]
+            : [
+                'br',
+                { 'data-type': node.attrs.isHTML ? 'htmlbreak' : 'hardbreak' },
+            ],
+    };
+});
+// Remark represents a missing title as null; the image schema accepts strings.
+const normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
+    const schema = base(ctx);
+    return {
+        ...schema,
+        parseDOM: [
+            {
+                tag: 'img[src]',
+                getAttrs(dom) {
+                    return {
+                        src: dom.getAttribute('src') ?? '',
+                        alt: dom.getAttribute('alt') ?? '',
+                        title: dom.getAttribute('title') ?? '',
+                    };
+                },
+            },
+        ],
+        parseMarkdown: {
+            ...schema.parseMarkdown,
+            runner(state, node, type) {
+                state.addNode(type, {
+                    src: String(node.url ?? ''),
+                    alt: String(node.alt ?? ''),
+                    title: String(node.title ?? ''),
+                });
+            },
+        },
+    };
+});
+export const tables = [
+    tableSchema.extendSchema((previous) => (ctx) => ({
+        ...previous(ctx),
+        content: 'table_header_row table_row*',
+    })),
+    tableHeaderRowSchema,
+    tableHeaderSchema.extendSchema((previous) => (ctx) => {
+        const schema = previous(ctx);
+        return {
+            ...schema,
+            attrs: { ...schema.attrs, alignment: { default: null } },
+            parseDOM: schema.parseDOM?.map((rule) => 'tag' in rule
+                ? {
+                    ...rule,
+                    getAttrs(dom) {
+                        const attrs = rule.getAttrs?.(dom);
+                        if (attrs === false)
+                            return false;
+                        return {
+                            ...attrs,
+                            alignment: dom.style.textAlign || dom.getAttribute('align') || null,
+                        };
+                    },
+                }
+                : rule),
+        };
+    }),
+    tableRowSchema,
+    tableCellSchema.extendSchema((previous) => (ctx) => {
+        const schema = previous(ctx);
+        return {
+            ...schema,
+            attrs: { ...schema.attrs, alignment: { default: null } },
+            parseDOM: schema.parseDOM?.map((rule) => 'tag' in rule
+                ? {
+                    ...rule,
+                    getAttrs(dom) {
+                        const attrs = rule.getAttrs?.(dom);
+                        if (attrs === false)
+                            return false;
+                        return {
+                            ...attrs,
+                            alignment: dom.style.textAlign || dom.getAttribute('align') || null,
+                        };
+                    },
+                }
+                : rule),
+        };
+    }),
+    tableEditingPlugin,
+    tableKeymap,
+    goToNextTableCellCommand,
+    goToPrevTableCellCommand,
+    insertTableCommand,
+    addRowBeforeCommand,
+    addRowAfterCommand,
+    addColBeforeCommand,
+    addColAfterCommand,
+    selectRowCommand,
+    selectColCommand,
+    deleteSelectedCellsCommand,
+    setAlignCommand,
+    exitTable,
+].flat();
+export function createDialect(images) {
+    return [
+        // Protect unsupported inline HTML before the empty-line plugin consumes break nodes.
+        createLiteralPreservation(images),
+        commonmarkWithLiteralReferences,
+        preserveSpacerParagraphs,
+        visibleSoftbreaks,
+        normalizedImages,
+        autolinkInputRule,
+        extendListItemSchemaForTask,
+        strikethroughAttr,
+        strikethroughSchema,
+        strikethroughInputRule,
+        strikethroughKeymap,
+        toggleStrikethroughCommand,
+        wrapInTaskListInputRule,
+        remarkDialectPlugin,
+        tables,
+        literalBlock,
+    ].flat();
+}
+export const dialect = createDialect(false);
+// One output form, so a document written back unchanged is byte-stable.
+export const stringifyOptions = {
+    bullet: '-',
+    emphasis: '*',
+    strong: '*',
+    fences: true,
+    listItemIndent: 'one',
+    rule: '-',
+};
+// Milkdown preserves authored spacer paragraphs with standalone Markdown HTML breaks.
+export function serialize(ctx, doc = ctx.get(editorViewCtx).state.doc) {
+    if (doc.childCount === 1 &&
+        doc.firstChild?.type.name === 'paragraph' &&
+        doc.firstChild.content.size === 0)
+        return '';
+    return ctx.get(serializerCtx)(doc);
+}