@vamos-ui/react 0.0.0-stage → 0.2.0

package/dist/editor/items.js

@@ -0,0 +1,195 @@
+"use client";
+// The insertable things (text blocks, registry blocks, patterns) shared by the "/" menu and the
+// inserter, plus "turn into" targets for the bubble menu and the block menu.
+import * as React from "react";
+import { NodeSelection } from "@tiptap/pm/state";
+import { AlignLeft, Blocks, Code2, Columns2, FileText, Heading1, Heading2, Heading3, Heading4, HelpCircle, Image as ImageIcon, LayoutTemplate, List, ListOrdered, Mail, MapPin, Megaphone, MessageSquareQuote, Minus, MousePointerClick, Quote, Sparkles, Star, Table2, Tag, Users, Video, } from "lucide-react";
+import { COMPONENT_BLOCK, createBlockId, toProseMirror } from "./convert.js";
+import { insertAfterBlock, withoutIds } from "./commands.js";
+const ICONS = {
+    "layout-template": LayoutTemplate,
+    "help-circle": HelpCircle,
+    "circle-help": HelpCircle,
+    "message-square-quote": MessageSquareQuote,
+    megaphone: Megaphone,
+    "mouse-pointer-click": MousePointerClick,
+    tag: Tag,
+    star: Star,
+    users: Users,
+    image: ImageIcon,
+    video: Video,
+    "map-pin": MapPin,
+    mail: Mail,
+    "columns-2": Columns2,
+    "file-text": FileText,
+    sparkles: Sparkles,
+    table: Table2,
+    quote: Quote,
+};
+export const iconForBlock = (name) => (name && ICONS[name]) || Blocks;
+const mediaCategory = new Set(["media", "embed"]);
+const layoutCategory = new Set(["layout"]);
+/** The text block items ("Text", "Heading 2", "Bulleted list"…). */
+export function textItems(t, opts = {}) {
+    const p = (text) => ({ type: "paragraph", ...(text ? { content: [{ type: "text", text }] } : null) });
+    const items = [
+        { id: "paragraph", title: t("paragraph"), hint: t("paragraphHint"), group: "text", keywords: ["text", "paragraph", "p", "body"], icon: AlignLeft, blockType: "paragraph", build: () => p() },
+        { id: "heading-2", title: t("heading2"), hint: t("headingHint"), group: "text", keywords: ["h2", "heading", "title", "section"], icon: Heading2, blockType: "heading", shortcut: "##", build: () => ({ type: "heading", attrs: { level: 2 } }) },
+        { id: "heading-3", title: t("heading3"), hint: t("headingHint"), group: "text", keywords: ["h3", "heading", "subtitle"], icon: Heading3, blockType: "heading", shortcut: "###", build: () => ({ type: "heading", attrs: { level: 3 } }) },
+        { id: "heading-4", title: t("heading4"), hint: t("headingHint"), group: "text", keywords: ["h4", "heading"], icon: Heading4, blockType: "heading", shortcut: "####", build: () => ({ type: "heading", attrs: { level: 4 } }) },
+        { id: "bullet-list", title: t("bulletList"), hint: t("bulletListHint"), group: "text", keywords: ["ul", "bullet", "list", "unordered"], icon: List, blockType: "list", shortcut: "-", build: () => ({ type: "bulletList", content: [{ type: "listItem", content: [p()] }] }) },
+        { id: "ordered-list", title: t("orderedList"), hint: t("orderedListHint"), group: "text", keywords: ["ol", "numbered", "ordered", "steps"], icon: ListOrdered, blockType: "list", shortcut: "1.", build: () => ({ type: "orderedList", content: [{ type: "listItem", content: [p()] }] }) },
+        { id: "quote", title: t("quote"), hint: t("quoteHint"), group: "text", keywords: ["blockquote", "quote", "citation", "testimonial"], icon: Quote, blockType: "quote", shortcut: ">", build: () => ({ type: "blockquote", content: [p()] }) },
+        { id: "code", title: t("code"), hint: t("codeHint"), group: "text", keywords: ["code", "snippet", "pre"], icon: Code2, blockType: "code", shortcut: "```", build: () => ({ type: "codeBlock" }) },
+        { id: "divider", title: t("divider"), hint: t("dividerHint"), group: "layout", keywords: ["hr", "divider", "rule", "separator", "line"], icon: Minus, blockType: "divider", shortcut: "---", build: () => [{ type: "horizontalRule" }, p()] },
+    ];
+    if (!opts.richText) {
+        items.splice(1, 0, { id: "heading-1", title: t("heading1"), hint: t("headingHint"), group: "text", keywords: ["h1", "heading", "title"], icon: Heading1, blockType: "heading", shortcut: "#", build: () => ({ type: "heading", attrs: { level: 1 } }) });
+        items.push({
+            id: "table",
+            title: t("table"),
+            hint: t("tableHint"),
+            group: "layout",
+            keywords: ["table", "grid", "rows", "columns", "spreadsheet"],
+            icon: Table2,
+            blockType: "table",
+            build: () => {
+                const cell = (type) => ({ type, content: [p()] });
+                return {
+                    type: "table",
+                    content: [
+                        { type: "tableRow", content: [cell("tableHeader"), cell("tableHeader"), cell("tableHeader")] },
+                        { type: "tableRow", content: [cell("tableCell"), cell("tableCell"), cell("tableCell")] },
+                        { type: "tableRow", content: [cell("tableCell"), cell("tableCell"), cell("tableCell")] },
+                    ],
+                };
+            },
+        }, { id: "image", title: t("image"), hint: t("imageHint"), group: "media", keywords: ["image", "photo", "picture", "img", "figure"], icon: ImageIcon, blockType: "image", build: () => ({ type: "image", attrs: { src: null } }) });
+    }
+    return items;
+}
+/** One item per registered component block. */
+export function registryItems(registry) {
+    return registry.list({ region: "body" }).map((def) => ({
+        id: `block:${def.type}`,
+        title: def.title,
+        hint: def.description,
+        group: mediaCategory.has(def.category) ? "media" : layoutCategory.has(def.category) ? "layout" : "blocks",
+        keywords: [def.type, def.category, ...(def.keywords ?? [])],
+        icon: iconForBlock(def.icon),
+        blockType: def.type,
+        def,
+        build: (lang) => {
+            const variant = def.defaultVariant ?? def.variants?.[0];
+            return { type: COMPONENT_BLOCK, attrs: { id: createBlockId(), blockType: def.type, v: def.version, variant: variant ?? null, props: structuredCloneSafe(def.sample(variant, lang)) } };
+        },
+    }));
+}
+export function patternItems(patterns, registry) {
+    return patterns.map((pt) => ({
+        id: `pattern:${pt.id}`,
+        title: pt.title,
+        hint: pt.description ?? pt.category,
+        group: "patterns",
+        keywords: [pt.category, pt.id],
+        icon: LayoutTemplate,
+        blockType: "pattern",
+        pattern: pt,
+        build: () => (toProseMirror(pt.doc, registry).content ?? []).map(withoutIds),
+    }));
+}
+function structuredCloneSafe(v) {
+    try {
+        return v === undefined ? v : JSON.parse(JSON.stringify(v));
+    }
+    catch {
+        return v;
+    }
+}
+/** Filters items by `allowedBlocks` (block types; patterns pass when every block inside is allowed). */
+export function filterAllowed(items, allowed) {
+    if (!allowed)
+        return items;
+    const set = new Set(allowed);
+    return items.filter((it) => (it.pattern ? it.pattern.doc.blocks.every((b) => set.has(b.type)) : set.has(it.blockType)));
+}
+/** Inserts an item: replaces `range` (the "/query" text) or goes after the current block. Selects component blocks. */
+export function runInsert(editor, item, opts) {
+    const content = item.build(opts.lang);
+    let pos;
+    if (opts.range) {
+        editor.chain().focus().deleteRange(opts.range).run();
+        const $from = editor.state.selection.$from;
+        const parent = $from.depth >= 1 ? $from.node(1) : null;
+        const isEmptyPara = parent?.type.name === "paragraph" && parent.content.size === 0;
+        pos = $from.depth >= 1 ? $from.before(1) : $from.pos;
+        if (isEmptyPara)
+            editor.chain().insertContentAt({ from: pos, to: pos + parent.nodeSize }, content).run();
+        else {
+            pos = pos + (parent?.nodeSize ?? 0);
+            editor.chain().insertContentAt(pos, content).run();
+        }
+    }
+    else {
+        pos = insertAfterBlock(editor, content, opts.at);
+    }
+    const inserted = editor.state.doc.nodeAt(pos);
+    if (inserted && (inserted.type.name === COMPONENT_BLOCK || (inserted.type.name === "image" && !inserted.attrs.src))) {
+        editor.view.dispatch(editor.state.tr.setSelection(NodeSelection.create(editor.state.doc, pos)).scrollIntoView());
+    }
+    else if (inserted) {
+        editor.chain().focus().setTextSelection(Math.min(pos + 1, editor.state.doc.content.size)).run();
+    }
+    editor.view.focus();
+    return pos;
+}
+/** "Turn into" targets for a text block. */
+export function turnIntoItems(t) {
+    return [
+        { id: "paragraph", label: t("paragraph"), icon: AlignLeft, run: (e) => e.chain().focus().setParagraph().run(), active: (e) => e.isActive("paragraph") && !e.isActive("bulletList") && !e.isActive("orderedList") && !e.isActive("blockquote") },
+        { id: "heading-2", label: t("heading2"), icon: Heading2, run: (e) => e.chain().focus().setHeading({ level: 2 }).run(), active: (e) => e.isActive("heading", { level: 2 }) },
+        { id: "heading-3", label: t("heading3"), icon: Heading3, run: (e) => e.chain().focus().setHeading({ level: 3 }).run(), active: (e) => e.isActive("heading", { level: 3 }) },
+        { id: "heading-4", label: t("heading4"), icon: Heading4, run: (e) => e.chain().focus().setHeading({ level: 4 }).run(), active: (e) => e.isActive("heading", { level: 4 }) },
+        { id: "bullet-list", label: t("bulletList"), icon: List, run: (e) => e.chain().focus().toggleBulletList().run(), active: (e) => e.isActive("bulletList") },
+        { id: "ordered-list", label: t("orderedList"), icon: ListOrdered, run: (e) => e.chain().focus().toggleOrderedList().run(), active: (e) => e.isActive("orderedList") },
+        { id: "quote", label: t("quote"), icon: Quote, run: (e) => e.chain().focus().toggleBlockquote().run(), active: (e) => e.isActive("blockquote") },
+        { id: "code", label: t("code"), icon: Code2, run: (e) => e.chain().focus().toggleCodeBlock().run(), active: (e) => e.isActive("codeBlock") },
+    ];
+}
+/** Human title of a block node for announcements and menus. */
+export function blockTitle(node, registry, t) {
+    switch (node.type.name) {
+        case "paragraph":
+            return t("paragraph");
+        case "heading":
+            return t(`heading${Math.min(4, Math.max(1, Number(node.attrs.level) || 2))}`);
+        case "bulletList":
+            return t("bulletList");
+        case "orderedList":
+            return t("orderedList");
+        case "blockquote":
+            return t("quote");
+        case "codeBlock":
+            return t("code");
+        case "horizontalRule":
+            return t("divider");
+        case "table":
+            return t("table");
+        case "image":
+            return t("image");
+        case COMPONENT_BLOCK: {
+            const type = String(node.attrs.blockType ?? "");
+            return registry.get(type)?.title ?? type;
+        }
+        default:
+            return node.type.name;
+    }
+}
+/** The block type of a PM node in VamosDoc terms (for allowedBlocks). */
+export function docTypeOf(name, attrs) {
+    const map = { paragraph: "paragraph", heading: "heading", bulletList: "list", orderedList: "list", blockquote: "quote", codeBlock: "code", horizontalRule: "divider", table: "table", image: "image" };
+    return name === COMPONENT_BLOCK ? String(attrs.blockType) : (map[name] ?? name);
+}
+export const useStableItems = (factory, deps) => 
+// eslint-disable-next-line react-hooks/exhaustive-deps
+React.useMemo(factory, deps);

package/dist/editor/labels.d.ts

@@ -0,0 +1,119 @@
+export declare const blockEditorLabels: {
+    editorLabel: string;
+    placeholder: string;
+    placeholderRichText: string;
+    placeholderHeading: string;
+    placeholderListItem: string;
+    placeholderQuote: string;
+    placeholderCode: string;
+    paragraph: string;
+    paragraphHint: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    heading4: string;
+    headingHint: string;
+    bulletList: string;
+    bulletListHint: string;
+    orderedList: string;
+    orderedListHint: string;
+    quote: string;
+    quoteHint: string;
+    code: string;
+    codeHint: string;
+    divider: string;
+    dividerHint: string;
+    table: string;
+    tableHint: string;
+    image: string;
+    imageHint: string;
+    formatting: string;
+    bold: string;
+    italic: string;
+    underline: string;
+    strike: string;
+    inlineCode: string;
+    highlight: string;
+    subscript: string;
+    superscript: string;
+    link: string;
+    linkEdit: string;
+    linkRemove: string;
+    linkApply: string;
+    linkPlaceholder: string;
+    linkNewTab: string;
+    linkInvalid: string;
+    turnInto: string;
+    undo: string;
+    redo: string;
+    groupText: string;
+    groupMedia: string;
+    groupLayout: string;
+    groupBlocks: string;
+    groupPatterns: string;
+    insert: string;
+    insertBelow: string;
+    searchBlocks: string;
+    noBlocks: string;
+    noBlocksPlain: string;
+    blocks: string;
+    patterns: string;
+    preview: string;
+    dragHandle: string;
+    blockMenu: string;
+    duplicate: string;
+    moveUp: string;
+    moveDown: string;
+    copyAnchor: string;
+    delete: string;
+    hide: string;
+    show: string;
+    unknownBlock: string;
+    unknownBlockHint: string;
+    invalidBlock: string;
+    editBlock: string;
+    hiddenBadge: string;
+    imageUrl: string;
+    imageUrlPlaceholder: string;
+    imageAdd: string;
+    imageUpload: string;
+    imageUploading: string;
+    imageFailed: string;
+    caption: string;
+    captionPlaceholder: string;
+    altText: string;
+    altTextHint: string;
+    decorative: string;
+    missingAlt: string;
+    inspector: string;
+    noSelection: string;
+    noSelectionHint: string;
+    variant: string;
+    anchor: string;
+    anchorHint: string;
+    content: string;
+    style: string;
+    advanced: string;
+    addItem: string;
+    removeItem: string;
+    itemN: string;
+    moveItemUp: string;
+    moveItemDown: string;
+    empty: string;
+    locale: string;
+    outline: string;
+    outlineEmpty: string;
+    words: string;
+    readingTime: string;
+    skippedLevel: string;
+    multipleH1: string;
+    imagesWithoutAlt: string;
+    announceInserted: string;
+    announceDeleted: string;
+    announceMovedUp: string;
+    announceMovedDown: string;
+    announceDuplicated: string;
+    announceSelected: string;
+    announceCopied: string;
+};
+export type BlockEditorLabels = typeof blockEditorLabels;

package/dist/editor/labels.js

@@ -0,0 +1,130 @@
+// Built-in strings of the block editor (`blockEditor` namespace). English defaults; translations
+// come from the locale dictionary or the `labels` prop.
+export const blockEditorLabels = {
+    editorLabel: "Content",
+    placeholder: "Type / to add a block",
+    placeholderRichText: "Write something…",
+    placeholderHeading: "Heading",
+    placeholderListItem: "List item",
+    placeholderQuote: "Quote",
+    placeholderCode: "Code",
+    // text blocks
+    paragraph: "Text",
+    paragraphHint: "Plain paragraph",
+    heading1: "Heading 1",
+    heading2: "Heading 2",
+    heading3: "Heading 3",
+    heading4: "Heading 4",
+    headingHint: "Section title",
+    bulletList: "Bulleted list",
+    bulletListHint: "Simple list",
+    orderedList: "Numbered list",
+    orderedListHint: "Steps in order",
+    quote: "Quote",
+    quoteHint: "Pull quote or testimonial",
+    code: "Code",
+    codeHint: "Monospaced snippet",
+    divider: "Divider",
+    dividerHint: "Thin horizontal rule",
+    table: "Table",
+    tableHint: "3 × 3 grid with a header row",
+    image: "Image",
+    imageHint: "Upload or paste a URL",
+    // marks / toolbar
+    formatting: "Text formatting",
+    bold: "Bold",
+    italic: "Italic",
+    underline: "Underline",
+    strike: "Strikethrough",
+    inlineCode: "Inline code",
+    highlight: "Highlight",
+    subscript: "Subscript",
+    superscript: "Superscript",
+    link: "Link",
+    linkEdit: "Edit link",
+    linkRemove: "Remove link",
+    linkApply: "Apply",
+    linkPlaceholder: "Paste a link or search pages",
+    linkNewTab: "Open in a new tab",
+    linkInvalid: "Use a web address, a path, #anchor, mailto: or tel:",
+    turnInto: "Turn into",
+    undo: "Undo",
+    redo: "Redo",
+    // groups
+    groupText: "Text",
+    groupMedia: "Media",
+    groupLayout: "Layout",
+    groupBlocks: "Blocks",
+    groupPatterns: "Patterns",
+    // inserter / slash
+    insert: "Add block",
+    insertBelow: "Add block below",
+    searchBlocks: "Search blocks",
+    noBlocks: "No blocks match “{query}”",
+    noBlocksPlain: "No matching blocks",
+    blocks: "Blocks",
+    patterns: "Patterns",
+    preview: "Preview",
+    // drag handle / block menu
+    dragHandle: "Drag to move, click for block options",
+    blockMenu: "Block options",
+    duplicate: "Duplicate",
+    moveUp: "Move up",
+    moveDown: "Move down",
+    copyAnchor: "Copy link to block",
+    delete: "Delete",
+    hide: "Hide on site",
+    show: "Show on site",
+    // component blocks
+    unknownBlock: "Unknown block “{type}”",
+    unknownBlockHint: "Module disabled? The content is kept and saved as is.",
+    invalidBlock: "{count, plural, one {# field needs attention} other {# fields need attention}}",
+    editBlock: "Edit {title}",
+    hiddenBadge: "Hidden",
+    // image
+    imageUrl: "Image URL",
+    imageUrlPlaceholder: "https://…",
+    imageAdd: "Insert image",
+    imageUpload: "Upload",
+    imageUploading: "Uploading {name}…",
+    imageFailed: "Upload failed",
+    caption: "Caption",
+    captionPlaceholder: "Add a caption",
+    altText: "Alt text",
+    altTextHint: "Describe the image for people who can't see it.",
+    decorative: "Decorative image (no alt text)",
+    missingAlt: "Missing alt text",
+    // inspector
+    inspector: "Block settings",
+    noSelection: "Select a block",
+    noSelectionHint: "Click a page block on the canvas to edit its settings here. Text is edited in place.",
+    variant: "Variant",
+    anchor: "Anchor",
+    anchorHint: "Used in links like /page#{anchor}.",
+    content: "Content",
+    style: "Style",
+    advanced: "Advanced",
+    addItem: "Add {label}",
+    removeItem: "Remove {label}",
+    itemN: "Item {n}",
+    moveItemUp: "Move {label} up",
+    moveItemDown: "Move {label} down",
+    empty: "Empty",
+    locale: "Language: {locale}",
+    // outline
+    outline: "Outline",
+    outlineEmpty: "Headings you add appear here.",
+    words: "{count, plural, one {# word} other {# words}}",
+    readingTime: "{count, plural, one {# min read} other {# min read}}",
+    skippedLevel: "Skipped level: H{from} → H{to}",
+    multipleH1: "More than one H1 on the page",
+    imagesWithoutAlt: "{count, plural, one {# image without alt text} other {# images without alt text}}",
+    // announcements
+    announceInserted: "{title} added",
+    announceDeleted: "{title} deleted",
+    announceMovedUp: "{title} moved up",
+    announceMovedDown: "{title} moved down",
+    announceDuplicated: "{title} duplicated",
+    announceSelected: "{title} selected. Arrows move between blocks, Alt+Shift+Arrow moves it, Enter edits.",
+    announceCopied: "Link copied",
+};

package/dist/editor/markdown.d.ts

@@ -0,0 +1,14 @@
+import type { BlockNode } from "../blocks/schema/types.js";
+import type { RichInline, RichMark } from "../blocks/schema/rich-doc.js";
+/** Heuristic: does plain text look like Markdown worth converting? */
+export declare function looksLikeMarkdown(text: string): boolean;
+/** Markdown inline syntax → runs with marks. */
+export declare function parseInlineMarkdown(src: string, marks?: RichMark[]): RichInline[];
+/** Markdown → VamosDoc blocks (paragraph, heading, list, quote, code, divider, table). */
+export declare function markdownToBlocks(markdown: string): BlockNode[];
+/**
+ * Cleans Word / Google Docs / LibreOffice clipboard HTML before ProseMirror parses it: drops
+ * Office namespaces, conditional comments, inline styles, classes, fonts and empty spans, and
+ * maps Google Docs' styled spans to semantic bold/italic.
+ */
+export declare function cleanPastedHtml(html: string): string;

package/dist/editor/markdown.js

@@ -0,0 +1,209 @@
+// Paste conversion: Markdown → blocks, Word / Google Docs HTML → clean HTML for the schema parser.
+// Small on purpose: covers what people paste (headings, lists, quotes, fences, rules, tables,
+// emphasis, code, links), not the whole CommonMark spec.
+import { sanitizeHref } from "../blocks/schema/safety.js";
+import { createBlockId } from "./convert.js";
+/** Heuristic: does plain text look like Markdown worth converting? */
+export function looksLikeMarkdown(text) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length < 2 && !/^(#{1,6}\s|>\s|[-*+]\s|\d+[.)]\s|```)/.test(text))
+        return /\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\)/.test(text);
+    let hits = 0;
+    for (const l of lines)
+        if (/^(#{1,6}\s|>\s?|\s*[-*+]\s|\s*\d+[.)]\s|```|---\s*$|\|.+\|)/.test(l))
+            hits++;
+    return hits >= 1;
+}
+const INLINE_RE = /(`[^`]+`)|(\*\*[^*]+\*\*|__[^_]+__)|(\*[^*\s][^*]*\*|_[^_\s][^_]*_)|(~~[^~]+~~)|(==[^=]+==)|(\[[^\]]+\]\([^)\s]+(?:\s+"[^"]*")?\))/;
+/** Markdown inline syntax → runs with marks. */
+export function parseInlineMarkdown(src, marks = []) {
+    const out = [];
+    let rest = src;
+    const push = (text, m) => {
+        if (!text)
+            return;
+        const prev = out[out.length - 1];
+        if (prev && !("type" in prev) && JSON.stringify(prev.marks ?? []) === JSON.stringify(m))
+            prev.text += text;
+        else
+            out.push(m.length ? { text, marks: m } : { text });
+    };
+    while (rest) {
+        const m = INLINE_RE.exec(rest);
+        if (!m) {
+            push(rest, marks);
+            break;
+        }
+        push(rest.slice(0, m.index), marks);
+        const tok = m[0];
+        if (m[1])
+            push(tok.slice(1, -1), [...marks, { type: "code" }]);
+        else if (m[2])
+            out.push(...parseInlineMarkdown(tok.slice(2, -2), [...marks, { type: "bold" }]));
+        else if (m[3])
+            out.push(...parseInlineMarkdown(tok.slice(1, -1), [...marks, { type: "italic" }]));
+        else if (m[4])
+            out.push(...parseInlineMarkdown(tok.slice(2, -2), [...marks, { type: "strike" }]));
+        else if (m[5])
+            out.push(...parseInlineMarkdown(tok.slice(2, -2), [...marks, { type: "highlight" }]));
+        else if (m[6]) {
+            const lm = /^\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]*)")?\)$/.exec(tok);
+            const href = sanitizeHref(lm[2]);
+            if (href)
+                out.push(...parseInlineMarkdown(lm[1], [{ type: "link", href, ...(lm[3] ? { title: lm[3] } : null) }, ...marks]));
+            else
+                push(lm[1], marks);
+        }
+        rest = rest.slice(m.index + tok.length);
+    }
+    return out;
+}
+const id = () => createBlockId();
+/** Markdown → VamosDoc blocks (paragraph, heading, list, quote, code, divider, table). */
+export function markdownToBlocks(markdown) {
+    const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+    const blocks = [];
+    let paragraph = [];
+    let lists = [];
+    const flushParagraph = () => {
+        if (!paragraph.length)
+            return;
+        const content = [];
+        paragraph.forEach((l, i) => {
+            if (i > 0)
+                content.push({ type: "br" });
+            content.push(...parseInlineMarkdown(l.trim()));
+        });
+        blocks.push({ id: id(), type: "paragraph", content });
+        paragraph = [];
+    };
+    const closeLists = () => {
+        lists = [];
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Fenced code
+        const fence = /^\s*```\s*([\w+-]*)\s*$/.exec(line);
+        if (fence) {
+            flushParagraph();
+            closeLists();
+            const body = [];
+            i++;
+            while (i < lines.length && !/^\s*```\s*$/.test(lines[i]))
+                body.push(lines[i++]);
+            const content = body.flatMap((l, j) => [...(j > 0 ? [{ type: "br" }] : []), ...(l ? [{ text: l }] : [])]);
+            blocks.push({ id: id(), type: "code", content, ...(fence[1] ? { props: { language: fence[1] } } : null) });
+            continue;
+        }
+        if (!line.trim()) {
+            flushParagraph();
+            closeLists();
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*?)\s*#*\s*$/.exec(line);
+        if (heading) {
+            flushParagraph();
+            closeLists();
+            blocks.push({ id: id(), type: "heading", props: { level: heading[1].length }, content: parseInlineMarkdown(heading[2]) });
+            continue;
+        }
+        if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
+            flushParagraph();
+            closeLists();
+            blocks.push({ id: id(), type: "divider" });
+            continue;
+        }
+        if (/^\s*>/.test(line)) {
+            flushParagraph();
+            closeLists();
+            const body = [];
+            while (i < lines.length && /^\s*>/.test(lines[i]))
+                body.push(lines[i++].replace(/^\s*>\s?/, ""));
+            i--;
+            const inner = markdownToBlocks(body.join("\n"));
+            const only = inner.length === 1 && inner[0].type === "paragraph" ? inner[0] : null;
+            blocks.push(only ? { id: id(), type: "quote", content: only.content } : { id: id(), type: "quote", slots: { items: inner } });
+            continue;
+        }
+        // GFM table: header row, separator row, body rows.
+        if (/^\s*\|.*\|\s*$/.test(line) && i + 1 < lines.length && /^\s*\|?\s*:?-{2,}/.test(lines[i + 1])) {
+            flushParagraph();
+            closeLists();
+            const cells = (l) => l.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim());
+            const rows = [];
+            rows.push({ id: id(), type: "table-row", slots: { items: cells(line).map((c) => ({ id: id(), type: "table-cell", props: { header: true }, content: parseInlineMarkdown(c) })) } });
+            i += 2;
+            while (i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i])) {
+                rows.push({ id: id(), type: "table-row", slots: { items: cells(lines[i]).map((c) => ({ id: id(), type: "table-cell", content: parseInlineMarkdown(c) })) } });
+                i++;
+            }
+            i--;
+            blocks.push({ id: id(), type: "table", slots: { items: rows } });
+            continue;
+        }
+        const item = /^(\s*)([-*+]|(\d+)[.)])\s+(.*)$/.exec(line);
+        if (item) {
+            flushParagraph();
+            const indent = item[1].replace(/\t/g, "    ").length;
+            const ordered = !!item[3];
+            const li = { id: id(), type: "list-item", content: parseInlineMarkdown(item[4]) };
+            while (lists.length && lists[lists.length - 1].indent > indent)
+                lists.pop();
+            const top = lists[lists.length - 1];
+            if (top && top.indent === indent && !!top.node.props?.ordered === ordered) {
+                top.node.slots.items.push(li);
+            }
+            else if (top && indent > top.indent) {
+                const parentItem = top.node.slots.items[top.node.slots.items.length - 1];
+                const list = { id: id(), type: "list", ...(ordered ? { props: { ordered: true } } : null), slots: { items: [li] } };
+                parentItem.slots = { items: [...(parentItem.slots?.items ?? []), list] };
+                lists.push({ indent, node: list });
+            }
+            else {
+                const start = ordered ? Number(item[3]) : 1;
+                const list = { id: id(), type: "list", ...(ordered ? { props: { ordered: true, ...(start !== 1 ? { start } : null) } } : null), slots: { items: [li] } };
+                blocks.push(list);
+                lists = [{ indent, node: list }];
+            }
+            continue;
+        }
+        if (lists.length)
+            closeLists();
+        paragraph.push(line);
+    }
+    flushParagraph();
+    return blocks;
+}
+/**
+ * Cleans Word / Google Docs / LibreOffice clipboard HTML before ProseMirror parses it: drops
+ * Office namespaces, conditional comments, inline styles, classes, fonts and empty spans, and
+ * maps Google Docs' styled spans to semantic bold/italic.
+ */
+export function cleanPastedHtml(html) {
+    let out = html
+        .replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, "")
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/<\/?(o|w|v|m|st1):[^>]*>/gi, "")
+        .replace(/<(meta|link|style|script|xml|title)[^>]*>[\s\S]*?<\/\1>/gi, "")
+        .replace(/<(meta|link)[^>]*\/?>(?!<\/)/gi, "");
+    // Google Docs wraps everything in <b style="font-weight:normal" id="docs-internal-guid-…">.
+    out = out.replace(/<b[^>]*id="docs-internal-guid[^"]*"[^>]*>([\s\S]*?)<\/b>/gi, "$1");
+    // Styled spans → semantic marks.
+    out = out.replace(/<span([^>]*)style="([^"]*)"([^>]*)>([\s\S]*?)<\/span>/gi, (_m, _a, style, _b, inner) => {
+        let s = inner;
+        if (/font-style:\s*italic/i.test(style))
+            s = `<em>${s}</em>`;
+        if (/font-weight:\s*(bold|[6-9]00)/i.test(style))
+            s = `<strong>${s}</strong>`;
+        if (/text-decoration[^;]*underline/i.test(style))
+            s = `<u>${s}</u>`;
+        if (/text-decoration[^;]*line-through/i.test(style))
+            s = `<s>${s}</s>`;
+        return s;
+    });
+    out = out
+        .replace(/\s(style|class|lang|align|face|size|color|width|height|valign|dir|id)="[^"]*"/gi, "")
+        .replace(/<\/?(font|span)[^>]*>/gi, "")
+        .replace(/<p>\s*(&nbsp;| )?\s*<\/p>/gi, "");
+    return out;
+}