@godxjp/block-editor 31.27.0

package/dist/index.js

@@ -0,0 +1,1817 @@
+"use client";
+
+// src/block-editor.tsx
+import * as React6 from "react";
+import { EditorContent, useEditor } from "@tiptap/react";
+import { FileText } from "lucide-react";
+import { normalize, parse as parse2, serialize } from "@godxjp/markdown/codec";
+import { Text as Text2 } from "@godxjp/ui/general";
+import { useTranslation } from "@godxjp/ui/i18n";
+
+// src/blocks.ts
+import { Extension } from "@tiptap/core";
+import { NodeSelection, TextSelection } from "@tiptap/pm/state";
+function blockStartAt(editor, pos) {
+  const { doc } = editor.state;
+  if (pos < 0 || pos > doc.content.size) return null;
+  const $pos = doc.resolve(pos);
+  if ($pos.depth === 0) {
+    return pos < doc.content.size ? pos : null;
+  }
+  return $pos.before(1);
+}
+function selectionBlockStart(editor) {
+  return blockStartAt(editor, editor.state.selection.from);
+}
+function nodeAt(editor, start) {
+  const node = editor.state.doc.nodeAt(start);
+  return node ? { node, end: start + node.nodeSize } : null;
+}
+function moveBlock(editor, start, direction) {
+  const current = nodeAt(editor, start);
+  if (!current) return null;
+  const { doc } = editor.state;
+  const $start = doc.resolve(start);
+  const index = $start.index(0);
+  const sibling = direction === -1 ? index > 0 ? doc.child(index - 1) : null : index < doc.childCount - 1 ? doc.child(index + 1) : null;
+  if (!sibling) return null;
+  const tr = editor.state.tr.delete(start, current.end);
+  const target = direction === -1 ? start - sibling.nodeSize : start + sibling.nodeSize;
+  tr.insert(target, current.node);
+  tr.setSelection(TextSelection.near(tr.doc.resolve(target + 1)));
+  editor.view.dispatch(tr.scrollIntoView());
+  return target;
+}
+function duplicateBlock(editor, start) {
+  const current = nodeAt(editor, start);
+  if (!current) return;
+  const tr = editor.state.tr.insert(current.end, current.node.copy(current.node.content));
+  tr.setSelection(TextSelection.near(tr.doc.resolve(current.end + 1)));
+  editor.view.dispatch(tr.scrollIntoView());
+}
+function deleteBlock(editor, start) {
+  const current = nodeAt(editor, start);
+  if (!current) return;
+  const tr = editor.state.tr.delete(start, current.end);
+  if (tr.doc.childCount === 0) tr.insert(0, editor.schema.nodes.paragraph.create());
+  tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(start, tr.doc.content.size))));
+  editor.view.dispatch(tr.scrollIntoView());
+}
+function focusBlock(editor, start) {
+  const current = nodeAt(editor, start);
+  if (!current) return;
+  const tr = editor.state.tr.setSelection(TextSelection.near(editor.state.doc.resolve(start + 1)));
+  editor.view.dispatch(tr);
+  editor.view.focus();
+}
+function insertParagraphAfter(editor, start) {
+  const current = nodeAt(editor, start);
+  if (!current) return null;
+  const tr = editor.state.tr.insert(current.end, editor.schema.nodes.paragraph.create());
+  tr.setSelection(TextSelection.create(tr.doc, current.end + 1));
+  editor.view.dispatch(tr.scrollIntoView());
+  editor.view.focus();
+  return current.end;
+}
+function startBlockDrag(editor, start, event) {
+  const { view } = editor;
+  const selection = NodeSelection.create(view.state.doc, start);
+  view.dispatch(view.state.tr.setSelection(selection));
+  view.dragging = { slice: selection.content(), move: true };
+  if (event.dataTransfer) {
+    event.dataTransfer.effectAllowed = "copyMove";
+    event.dataTransfer.setData("text/plain", "");
+    const dom = view.nodeDOM(start);
+    if (dom instanceof HTMLElement) event.dataTransfer.setDragImage(dom, 0, 0);
+  }
+}
+var BlockKeys = Extension.create({
+  name: "blockKeys",
+  addOptions() {
+    return { openMenu: () => void 0 };
+  },
+  addKeyboardShortcuts() {
+    const move = (direction) => () => {
+      const start = selectionBlockStart(this.editor);
+      return start != null && moveBlock(this.editor, start, direction) != null;
+    };
+    return {
+      "Alt-Shift-ArrowUp": move(-1),
+      "Alt-Shift-ArrowDown": move(1),
+      "Mod-/": () => {
+        const start = selectionBlockStart(this.editor);
+        if (start == null) return false;
+        this.options.openMenu(start);
+        return true;
+      }
+    };
+  }
+});
+
+// src/commands.tsx
+import { Extension as Extension2 } from "@tiptap/core";
+import { PluginKey } from "@tiptap/pm/state";
+import { Suggestion } from "@tiptap/suggestion";
+import {
+  ChevronRight,
+  Code,
+  Columns2,
+  Heading1,
+  Heading2,
+  Heading3,
+  Image as ImageIcon,
+  Info,
+  List,
+  ListChecks,
+  ListOrdered,
+  Minus,
+  Pilcrow,
+  Quote,
+  Table as TableIcon
+} from "lucide-react";
+import { jsx } from "react/jsx-runtime";
+var TURN_INTO = [
+  "text",
+  "heading1",
+  "heading2",
+  "heading3",
+  "bulletList",
+  "numberedList",
+  "taskList",
+  "quote",
+  "callout",
+  "code"
+];
+function builtinCommands(labels, insertImage) {
+  const commands = [
+    {
+      key: "text",
+      label: labels.text,
+      icon: /* @__PURE__ */ jsx(Pilcrow, {}),
+      keywords: ["paragraph", "p"],
+      run: (e) => e.chain().focus().setParagraph().run()
+    },
+    {
+      key: "heading1",
+      label: labels.heading1,
+      icon: /* @__PURE__ */ jsx(Heading1, {}),
+      keywords: ["h1", "title"],
+      run: (e) => e.chain().focus().setHeading({ level: 1 }).run()
+    },
+    {
+      key: "heading2",
+      label: labels.heading2,
+      icon: /* @__PURE__ */ jsx(Heading2, {}),
+      keywords: ["h2"],
+      run: (e) => e.chain().focus().setHeading({ level: 2 }).run()
+    },
+    {
+      key: "heading3",
+      label: labels.heading3,
+      icon: /* @__PURE__ */ jsx(Heading3, {}),
+      keywords: ["h3"],
+      run: (e) => e.chain().focus().setHeading({ level: 3 }).run()
+    },
+    {
+      key: "bulletList",
+      label: labels.bulletList,
+      icon: /* @__PURE__ */ jsx(List, {}),
+      keywords: ["ul", "bullet", "list"],
+      run: (e) => e.chain().focus().toggleBulletList().run()
+    },
+    {
+      key: "numberedList",
+      label: labels.numberedList,
+      icon: /* @__PURE__ */ jsx(ListOrdered, {}),
+      keywords: ["ol", "number", "ordered"],
+      run: (e) => e.chain().focus().toggleOrderedList().run()
+    },
+    {
+      key: "taskList",
+      label: labels.taskList,
+      icon: /* @__PURE__ */ jsx(ListChecks, {}),
+      keywords: ["todo", "task", "checkbox"],
+      run: (e) => e.chain().focus().toggleTaskList().run()
+    },
+    {
+      key: "quote",
+      label: labels.quote,
+      icon: /* @__PURE__ */ jsx(Quote, {}),
+      keywords: ["blockquote", ">"],
+      run: (e) => e.chain().focus().toggleBlockquote().run()
+    },
+    {
+      key: "callout",
+      label: labels.callout,
+      icon: /* @__PURE__ */ jsx(Info, {}),
+      keywords: ["note", "alert", "tip", "warning"],
+      run: (e) => e.chain().focus().wrapIn("callout", { kind: "note" }).run()
+    },
+    {
+      key: "code",
+      label: labels.code,
+      icon: /* @__PURE__ */ jsx(Code, {}),
+      keywords: ["codeblock", "```", "pre"],
+      run: (e) => e.chain().focus().setCodeBlock().run()
+    },
+    {
+      key: "divider",
+      label: labels.divider,
+      icon: /* @__PURE__ */ jsx(Minus, {}),
+      keywords: ["hr", "rule", "---"],
+      run: (e) => e.chain().focus().setHorizontalRule().run()
+    },
+    {
+      key: "table",
+      label: labels.table,
+      icon: /* @__PURE__ */ jsx(TableIcon, {}),
+      keywords: ["grid"],
+      run: (e) => e.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run()
+    },
+    {
+      key: "toggle",
+      label: labels.toggle,
+      icon: /* @__PURE__ */ jsx(ChevronRight, {}),
+      keywords: ["details", "collapse", "fold"],
+      run: (e) => e.chain().focus().setDetails().run()
+    },
+    {
+      key: "columns",
+      label: labels.columns,
+      icon: /* @__PURE__ */ jsx(Columns2, {}),
+      keywords: ["layout", "column", "split"],
+      run: (e) => e.chain().focus().insertContent({
+        type: "columns",
+        content: [
+          { type: "column", content: [{ type: "paragraph" }] },
+          { type: "column", content: [{ type: "paragraph" }] }
+        ]
+      }).run()
+    }
+  ];
+  if (insertImage) {
+    commands.splice(11, 0, {
+      key: "image",
+      label: labels.image,
+      icon: /* @__PURE__ */ jsx(ImageIcon, {}),
+      keywords: ["img", "picture", "photo", "media"],
+      run: insertImage
+    });
+  }
+  return commands;
+}
+var fold = (value) => value.normalize("NFKC").toLowerCase();
+function filterCommands(commands, query) {
+  const q = fold(query.trim());
+  if (!q) return [...commands];
+  const scored = commands.map((command) => {
+    const terms = [command.label, command.key, ...command.keywords ?? []].map(fold);
+    const score = terms.some((t) => t.startsWith(q)) ? 0 : terms.some((t) => t.includes(q)) ? 1 : 2;
+    return { command, score };
+  }).filter((entry) => entry.score < 2);
+  return scored.sort((a, b) => a.score - b.score).map((entry) => entry.command);
+}
+function suggestionTrigger(name, char, bridge, options = {}) {
+  return Extension2.create({
+    name,
+    addProseMirrorPlugins() {
+      return [
+        Suggestion({
+          editor: this.editor,
+          pluginKey: new PluginKey(name),
+          char,
+          allowSpaces: options.allowSpaces ?? false,
+          allowedPrefixes: options.allowedPrefixes === void 0 ? [" ", "\u3000"] : options.allowedPrefixes,
+          items: ({ query }) => bridge.current?.items(query) ?? [],
+          command: ({ editor, range, props }) => bridge.current?.pick(editor, range, props),
+          render: () => ({
+            onStart: (props) => bridge.current?.onStart(props),
+            onUpdate: (props) => bridge.current?.onUpdate(props),
+            onKeyDown: (props) => bridge.current?.onKeyDown(props) ?? false,
+            onExit: () => bridge.current?.onExit()
+          })
+        })
+      ];
+    }
+  });
+}
+
+// src/extensions.ts
+import { Extension as Extension3, Node, mergeAttributes, nodeInputRule } from "@tiptap/core";
+import { Plugin, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import StarterKit from "@tiptap/starter-kit";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
+import { Image } from "@tiptap/extension-image";
+import { Details, DetailsContent, DetailsSummary } from "@tiptap/extension-details";
+import { Placeholder } from "@tiptap/extensions";
+var ListTightness = Extension3.create({
+  name: "listTightness",
+  addGlobalAttributes() {
+    return [
+      {
+        types: ["bulletList", "orderedList", "taskList"],
+        attributes: {
+          tight: {
+            default: true,
+            parseHTML: (element) => element.getAttribute("data-tight") !== "false",
+            renderHTML: (attrs) => ({ "data-tight": attrs.tight ? "true" : "false" })
+          }
+        }
+      }
+    ];
+  }
+});
+var CellAlignment = Extension3.create({
+  name: "cellAlignment",
+  addGlobalAttributes() {
+    return [
+      {
+        types: ["tableHeader", "tableCell"],
+        attributes: {
+          align: {
+            default: null,
+            parseHTML: (element) => element.style.textAlign || null,
+            renderHTML: (attrs) => attrs.align ? { style: `text-align:${attrs.align}` } : {}
+          }
+        }
+      }
+    ];
+  }
+});
+var Callout = Node.create({
+  name: "callout",
+  group: "block",
+  content: "block+",
+  defining: true,
+  addOptions() {
+    return {
+      titles: {
+        note: "Note",
+        tip: "Tip",
+        important: "Important",
+        warning: "Warning",
+        caution: "Caution"
+      }
+    };
+  },
+  addAttributes() {
+    return {
+      kind: { default: "note" },
+      title: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="callout"]', contentElement: "div[data-callout-body]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const kind = node.attrs.kind;
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-type": "callout",
+        "data-kind": kind,
+        class: "ui-prose-callout",
+        role: "note"
+      }),
+      [
+        "p",
+        { class: "ui-prose-callout-title", contenteditable: "false" },
+        node.attrs.title ?? this.options.titles[kind] ?? kind
+      ],
+      ["div", { "data-callout-body": "" }, 0]
+    ];
+  }
+});
+function shares(widths) {
+  const explicit = widths.reduce((sum, w) => sum + (w ?? 0), 0);
+  const open = widths.filter((w) => w == null).length;
+  const each = open ? Math.max(1, (100 - explicit) / open) : 0;
+  return widths.map((w) => w ?? Math.round(each * 100) / 100);
+}
+var Columns = Node.create({
+  name: "columns",
+  group: "block",
+  content: "column{2,4}",
+  defining: true,
+  isolating: true,
+  parseHTML() {
+    return [{ tag: 'div[data-type="columns"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, { "data-type": "columns", class: "ui-prose-columns" }),
+      0
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey2("columnShares"),
+        props: {
+          decorations: (state) => {
+            const decorations = [];
+            state.doc.descendants((node, pos) => {
+              if (node.type.name !== "columns") return true;
+              const widths = [];
+              node.forEach((column) => widths.push(column.attrs.width ?? null));
+              const grow = shares(widths);
+              node.forEach((column, offset, index) => {
+                const from = pos + 1 + offset;
+                decorations.push(
+                  Decoration.node(from, from + column.nodeSize, {
+                    style: `--prose-column-grow:${grow[index]}`
+                  })
+                );
+              });
+              return true;
+            });
+            return DecorationSet.create(state.doc, decorations);
+          }
+        }
+      })
+    ];
+  }
+});
+var Column = Node.create({
+  name: "column",
+  content: "block+",
+  isolating: true,
+  addAttributes() {
+    return { width: { default: null } };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="column"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, { "data-type": "column", class: "ui-prose-column" }),
+      0
+    ];
+  }
+});
+var Wikilink = Node.create({
+  name: "wikilink",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return { target: { default: "" }, heading: { default: null }, label: { default: null } };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-wikilink]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const { target, heading, label } = node.attrs;
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-wikilink": target,
+        class: "ui-block-editor-wikilink"
+      }),
+      label ?? (heading ? `${target}#${heading}` : target)
+    ];
+  },
+  renderText({ node }) {
+    const { target, heading, label } = node.attrs;
+    return `[[${target}${heading ? `#${heading}` : ""}${label ? `|${label}` : ""}]]`;
+  },
+  addInputRules() {
+    return [
+      nodeInputRule({
+        find: /(?<!!)\[\[([^[\]\n|#]+)(?:#([^[\]\n|]+))?(?:\|([^[\]\n]+))?\]\]$/,
+        type: this.type,
+        getAttributes: (match) => ({
+          target: match[1].trim(),
+          heading: match[2]?.trim() ?? null,
+          label: match[3] ?? null
+        })
+      })
+    ];
+  }
+});
+var EmbedInline = Node.create({
+  name: "embedInline",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return { target: { default: "" } };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-embed]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-embed": node.attrs.target,
+        class: "ui-block-editor-embed-inline"
+      }),
+      `![[${node.attrs.target}]]`
+    ];
+  },
+  renderText({ node }) {
+    return `![[${node.attrs.target}]]`;
+  },
+  addInputRules() {
+    return [
+      nodeInputRule({
+        find: /!\[\[([^[\]\n|#]+)\]\]$/,
+        type: this.type,
+        getAttributes: (match) => ({ target: match[1].trim() })
+      })
+    ];
+  }
+});
+var RawInline = Node.create({
+  name: "rawInline",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return { source: { default: "" } };
+  },
+  parseHTML() {
+    return [{ tag: "code[data-raw-inline]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "code",
+      mergeAttributes(HTMLAttributes, {
+        "data-raw-inline": "",
+        class: "ui-block-editor-raw-inline"
+      }),
+      node.attrs.source
+    ];
+  },
+  renderText({ node }) {
+    return node.attrs.source;
+  }
+});
+var Embed = Node.create({
+  name: "embed",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return { target: { default: "" } };
+  },
+  parseHTML() {
+    return [{ tag: "div[data-embed]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-embed": node.attrs.target,
+        class: "ui-block-editor-embed"
+      }),
+      `![[${node.attrs.target}]]`
+    ];
+  }
+});
+var RawBlock = Node.create({
+  name: "rawBlock",
+  group: "block",
+  atom: true,
+  addAttributes() {
+    return { source: { default: "" } };
+  },
+  parseHTML() {
+    return [{ tag: "pre[data-raw-block]" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "pre",
+      mergeAttributes(HTMLAttributes, { "data-raw-block": "", class: "ui-block-editor-raw-block" }),
+      node.attrs.source
+    ];
+  }
+});
+function schemaExtensions(options) {
+  const resolve = options.resolveUrl;
+  return [
+    StarterKit.configure({
+      underline: false,
+      link: {
+        openOnClick: false,
+        autolink: true,
+        linkOnPaste: true,
+        HTMLAttributes: { rel: "noopener noreferrer nofollow", target: null }
+      },
+      heading: { levels: [1, 2, 3, 4, 5, 6] }
+    }),
+    ListTightness,
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Table.configure({ resizable: false }),
+    TableRow,
+    TableHeader,
+    TableCell,
+    CellAlignment,
+    Image.extend({
+      renderHTML({ HTMLAttributes }) {
+        const src = HTMLAttributes.src;
+        return [
+          "img",
+          mergeAttributes(HTMLAttributes, src && resolve ? { src: resolve(src) ?? src } : {})
+        ];
+      }
+    }).configure({ inline: true, allowBase64: false }),
+    Details.configure({ persist: false }),
+    DetailsSummary,
+    DetailsContent,
+    Callout.configure({ titles: options.calloutTitles }),
+    Columns,
+    Column,
+    Wikilink,
+    EmbedInline,
+    RawInline,
+    options.embed ?? Embed,
+    options.rawBlock ?? RawBlock,
+    Placeholder.configure({
+      includeChildren: true,
+      placeholder: ({ node }) => {
+        if (node.type.name === "heading")
+          return options.headingPlaceholder(node.attrs.level);
+        if (node.type.name === "detailsSummary") return options.togglePlaceholder;
+        return options.placeholder;
+      }
+    })
+  ];
+}
+
+// src/handle.tsx
+import * as React2 from "react";
+import { ArrowDown, ArrowUp, Copy, GripVertical, Plus, Trash2 } from "lucide-react";
+import { Button } from "@godxjp/ui/general";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger
+} from "@godxjp/ui/navigation";
+
+// src/labels.tsx
+import * as React from "react";
+var LabelsContext = React.createContext((key) => key);
+var useLabel = () => React.useContext(LabelsContext);
+
+// src/handle.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function BlockHandle({
+  editor,
+  host,
+  turnInto,
+  onAddBelow,
+  menuRequest
+}) {
+  const label = useLabel();
+  const [block, setBlock] = React2.useState(null);
+  const [menuOpen, setMenuOpen] = React2.useState(false);
+  const pinned = React2.useRef(null);
+  const place = React2.useCallback(
+    (start2) => {
+      if (start2 == null || !host) return setBlock(null);
+      const dom = editor.view.nodeDOM(start2);
+      if (!(dom instanceof HTMLElement)) return setBlock(null);
+      const top = dom.getBoundingClientRect().top - host.getBoundingClientRect().top;
+      setBlock((prev) => prev?.start === start2 && prev.top === top ? prev : { start: start2, top });
+    },
+    [editor, host]
+  );
+  React2.useEffect(() => {
+    if (!host) return void 0;
+    const onMove = (event) => {
+      if (menuOpen || event.pointerType === "touch") return;
+      const children = [...editor.view.dom.children];
+      const row = children.find((child) => {
+        const r = child.getBoundingClientRect();
+        return event.clientY >= r.top && event.clientY <= r.bottom;
+      });
+      if (!row) return;
+      place(blockStartAt(editor, editor.view.posAtDOM(row, 0)));
+    };
+    host.addEventListener("pointermove", onMove);
+    return () => host.removeEventListener("pointermove", onMove);
+  }, [editor, host, menuOpen, place]);
+  React2.useEffect(() => {
+    const onSelection = () => {
+      if (!menuOpen && editor.isFocused) place(selectionBlockStart(editor));
+    };
+    editor.on("selectionUpdate", onSelection);
+    editor.on("update", onSelection);
+    editor.on("focus", onSelection);
+    return () => {
+      editor.off("selectionUpdate", onSelection);
+      editor.off("update", onSelection);
+      editor.off("focus", onSelection);
+    };
+  }, [editor, menuOpen, place]);
+  React2.useEffect(() => {
+    if (!menuRequest) return;
+    place(menuRequest.start);
+    pinned.current = menuRequest.start;
+    setMenuOpen(true);
+  }, [menuRequest, place]);
+  if (!block || !editor.isEditable) return null;
+  const start = pinned.current ?? block.start;
+  const run = (action) => () => {
+    action();
+    pinned.current = null;
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "ui-block-editor-handle", style: { insetBlockStart: block.top }, children: [
+    /* @__PURE__ */ jsx2(
+      Button,
+      {
+        size: "icon-xs",
+        variant: "ghost",
+        "aria-label": label("addBlock"),
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => onAddBelow(block.start),
+        children: /* @__PURE__ */ jsx2(Plus, {})
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      DropdownMenu,
+      {
+        open: menuOpen,
+        onOpenChange: (open) => {
+          setMenuOpen(open);
+          if (open) pinned.current = block.start;
+          else pinned.current = null;
+        },
+        children: [
+          /* @__PURE__ */ jsx2(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx2(
+            Button,
+            {
+              size: "icon-xs",
+              variant: "ghost",
+              "aria-label": label("dragHandle"),
+              draggable: true,
+              onDragStart: (event) => startBlockDrag(editor, block.start, event.nativeEvent),
+              children: /* @__PURE__ */ jsx2(GripVertical, {})
+            }
+          ) }),
+          /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "start", "aria-label": label("blockActions"), children: [
+            /* @__PURE__ */ jsx2(DropdownMenuLabel, { children: label("blockActions") }),
+            /* @__PURE__ */ jsxs(DropdownMenuSub, { children: [
+              /* @__PURE__ */ jsx2(DropdownMenuSubTrigger, { children: label("turnInto") }),
+              /* @__PURE__ */ jsx2(DropdownMenuSubContent, { children: turnInto.map((command) => /* @__PURE__ */ jsxs(
+                DropdownMenuItem,
+                {
+                  onSelect: run(() => {
+                    focusBlock(editor, start);
+                    command.run(editor);
+                  }),
+                  children: [
+                    /* @__PURE__ */ jsx2("span", { className: "ui-block-editor-menu-icon", "aria-hidden": "true", children: command.icon }),
+                    command.label
+                  ]
+                },
+                command.key
+              )) })
+            ] }),
+            /* @__PURE__ */ jsxs(DropdownMenuItem, { onSelect: run(() => duplicateBlock(editor, start)), children: [
+              /* @__PURE__ */ jsx2(Copy, { "aria-hidden": "true" }),
+              label("duplicate")
+            ] }),
+            /* @__PURE__ */ jsxs(DropdownMenuItem, { onSelect: run(() => void moveBlock(editor, start, -1)), children: [
+              /* @__PURE__ */ jsx2(ArrowUp, { "aria-hidden": "true" }),
+              label("moveUp")
+            ] }),
+            /* @__PURE__ */ jsxs(DropdownMenuItem, { onSelect: run(() => void moveBlock(editor, start, 1)), children: [
+              /* @__PURE__ */ jsx2(ArrowDown, { "aria-hidden": "true" }),
+              label("moveDown")
+            ] }),
+            /* @__PURE__ */ jsx2(DropdownMenuSeparator, {}),
+            /* @__PURE__ */ jsxs(DropdownMenuItem, { variant: "destructive", onSelect: run(() => deleteBlock(editor, start)), children: [
+              /* @__PURE__ */ jsx2(Trash2, { "aria-hidden": "true" }),
+              label("delete")
+            ] })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+
+// src/messages.ts
+import { registerMessages } from "@godxjp/ui/i18n";
+var BLOCK_EDITOR_MESSAGES = {
+  ja: {
+    editor: "\u30A8\u30C7\u30A3\u30BF\u30FC",
+    placeholder: "\u300C/\u300D\u3067\u30D6\u30ED\u30C3\u30AF\u3092\u633F\u5165",
+    placeholderHeading: "\u898B\u51FA\u3057{level}",
+    placeholderToggle: "\u30C8\u30B0\u30EB",
+    blocks: "\u30D6\u30ED\u30C3\u30AF",
+    noResults: "\u8A72\u5F53\u3059\u308B\u30D6\u30ED\u30C3\u30AF\u304C\u3042\u308A\u307E\u305B\u3093",
+    text: "\u30C6\u30AD\u30B9\u30C8",
+    heading1: "\u898B\u51FA\u30571",
+    heading2: "\u898B\u51FA\u30572",
+    heading3: "\u898B\u51FA\u30573",
+    bulletList: "\u7B87\u6761\u66F8\u304D",
+    numberedList: "\u756A\u53F7\u4ED8\u304D\u30EA\u30B9\u30C8",
+    taskList: "ToDo\u30EA\u30B9\u30C8",
+    quote: "\u5F15\u7528",
+    callout: "\u30B3\u30FC\u30EB\u30A2\u30A6\u30C8",
+    code: "\u30B3\u30FC\u30C9",
+    divider: "\u533A\u5207\u308A\u7DDA",
+    table: "\u8868",
+    image: "\u753B\u50CF",
+    toggle: "\u30C8\u30B0\u30EB",
+    columns: "2\u5217",
+    addBlock: "\u4E0B\u306B\u30D6\u30ED\u30C3\u30AF\u3092\u8FFD\u52A0",
+    dragHandle: "\u30C9\u30E9\u30C3\u30B0\u3067\u79FB\u52D5\u3001\u30AF\u30EA\u30C3\u30AF\u3067\u30D6\u30ED\u30C3\u30AF\u306E\u64CD\u4F5C",
+    blockActions: "\u30D6\u30ED\u30C3\u30AF\u306E\u64CD\u4F5C",
+    turnInto: "\u30D6\u30ED\u30C3\u30AF\u306E\u7A2E\u985E\u3092\u5909\u66F4",
+    duplicate: "\u8907\u88FD",
+    delete: "\u524A\u9664",
+    moveUp: "\u4E0A\u3078\u79FB\u52D5",
+    moveDown: "\u4E0B\u3078\u79FB\u52D5",
+    formatting: "\u66F8\u5F0F",
+    bold: "\u592A\u5B57",
+    italic: "\u659C\u4F53",
+    strike: "\u53D6\u308A\u6D88\u3057\u7DDA",
+    inlineCode: "\u30B3\u30FC\u30C9",
+    link: "\u30EA\u30F3\u30AF",
+    linkUrl: "\u30EA\u30F3\u30AF\u5148\u306EURL",
+    applyLink: "\u9069\u7528",
+    removeLink: "\u30EA\u30F3\u30AF\u3092\u89E3\u9664",
+    uploading: "{name} \u3092\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u4E2D\u2026",
+    uploadFailed: "{name} \u3092\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002",
+    retry: "\u518D\u8A66\u884C",
+    remove: "\u524A\u9664",
+    rawBlock: "Markdown \u306E\u30BD\u30FC\u30B9",
+    editSource: "Markdown \u3092\u7DE8\u96C6",
+    done: "\u5B8C\u4E86",
+    embed: "\u57CB\u3081\u8FBC\u307F: {target}",
+    calloutNote: "\u30E1\u30E2",
+    calloutTip: "\u30D2\u30F3\u30C8",
+    calloutImportant: "\u91CD\u8981",
+    calloutWarning: "\u8B66\u544A",
+    calloutCaution: "\u6CE8\u610F"
+  },
+  en: {
+    editor: "Editor",
+    placeholder: "Type / for blocks",
+    placeholderHeading: "Heading {level}",
+    placeholderToggle: "Toggle",
+    blocks: "Blocks",
+    noResults: "No matching blocks",
+    text: "Text",
+    heading1: "Heading 1",
+    heading2: "Heading 2",
+    heading3: "Heading 3",
+    bulletList: "Bulleted list",
+    numberedList: "Numbered list",
+    taskList: "To-do list",
+    quote: "Quote",
+    callout: "Callout",
+    code: "Code",
+    divider: "Divider",
+    table: "Table",
+    image: "Image",
+    toggle: "Toggle",
+    columns: "2 columns",
+    addBlock: "Add a block below",
+    dragHandle: "Drag to move, click for block actions",
+    blockActions: "Block actions",
+    turnInto: "Turn into",
+    duplicate: "Duplicate",
+    delete: "Delete",
+    moveUp: "Move up",
+    moveDown: "Move down",
+    formatting: "Formatting",
+    bold: "Bold",
+    italic: "Italic",
+    strike: "Strikethrough",
+    inlineCode: "Code",
+    link: "Link",
+    linkUrl: "Link URL",
+    applyLink: "Apply",
+    removeLink: "Remove link",
+    uploading: "Uploading {name}\u2026",
+    uploadFailed: "Could not upload {name}.",
+    retry: "Retry",
+    remove: "Remove",
+    rawBlock: "Markdown source",
+    editSource: "Edit Markdown",
+    done: "Done",
+    embed: "Embed: {target}",
+    calloutNote: "Note",
+    calloutTip: "Tip",
+    calloutImportant: "Important",
+    calloutWarning: "Warning",
+    calloutCaution: "Caution"
+  },
+  vi: {
+    editor: "Tr\xECnh so\u1EA1n th\u1EA3o",
+    placeholder: "G\xF5 / \u0111\u1EC3 ch\xE8n kh\u1ED1i",
+    placeholderHeading: "Ti\xEAu \u0111\u1EC1 {level}",
+    placeholderToggle: "M\u1EE5c thu g\u1ECDn",
+    blocks: "Kh\u1ED1i",
+    noResults: "Kh\xF4ng c\xF3 kh\u1ED1i ph\xF9 h\u1EE3p",
+    text: "V\u0103n b\u1EA3n",
+    heading1: "Ti\xEAu \u0111\u1EC1 1",
+    heading2: "Ti\xEAu \u0111\u1EC1 2",
+    heading3: "Ti\xEAu \u0111\u1EC1 3",
+    bulletList: "Danh s\xE1ch g\u1EA1ch \u0111\u1EA7u d\xF2ng",
+    numberedList: "Danh s\xE1ch \u0111\xE1nh s\u1ED1",
+    taskList: "Danh s\xE1ch vi\u1EC7c c\u1EA7n l\xE0m",
+    quote: "Tr\xEDch d\u1EABn",
+    callout: "Ch\xFA th\xEDch n\u1ED5i b\u1EADt",
+    code: "M\xE3",
+    divider: "\u0110\u01B0\u1EDDng ph\xE2n c\xE1ch",
+    table: "B\u1EA3ng",
+    image: "H\xECnh \u1EA3nh",
+    toggle: "M\u1EE5c thu g\u1ECDn",
+    columns: "2 c\u1ED9t",
+    addBlock: "Th\xEAm kh\u1ED1i b\xEAn d\u01B0\u1EDBi",
+    dragHandle: "K\xE9o \u0111\u1EC3 di chuy\u1EC3n, b\u1EA5m \u0111\u1EC3 thao t\xE1c v\u1EDBi kh\u1ED1i",
+    blockActions: "Thao t\xE1c v\u1EDBi kh\u1ED1i",
+    turnInto: "Chuy\u1EC3n th\xE0nh",
+    duplicate: "Nh\xE2n b\u1EA3n",
+    delete: "Xo\xE1",
+    moveUp: "Chuy\u1EC3n l\xEAn",
+    moveDown: "Chuy\u1EC3n xu\u1ED1ng",
+    formatting: "\u0110\u1ECBnh d\u1EA1ng",
+    bold: "In \u0111\u1EADm",
+    italic: "In nghi\xEAng",
+    strike: "G\u1EA1ch ngang",
+    inlineCode: "M\xE3",
+    link: "Li\xEAn k\u1EBFt",
+    linkUrl: "URL li\xEAn k\u1EBFt",
+    applyLink: "\xC1p d\u1EE5ng",
+    removeLink: "B\u1ECF li\xEAn k\u1EBFt",
+    uploading: "\u0110ang t\u1EA3i {name} l\xEAn\u2026",
+    uploadFailed: "Kh\xF4ng t\u1EA3i \u0111\u01B0\u1EE3c {name} l\xEAn.",
+    retry: "Th\u1EED l\u1EA1i",
+    remove: "G\u1EE1 b\u1ECF",
+    rawBlock: "M\xE3 ngu\u1ED3n Markdown",
+    editSource: "S\u1EEDa Markdown",
+    done: "Xong",
+    embed: "Nh\xFAng: {target}",
+    calloutNote: "Ghi ch\xFA",
+    calloutTip: "M\u1EB9o",
+    calloutImportant: "Quan tr\u1ECDng",
+    calloutWarning: "C\u1EA3nh b\xE1o",
+    calloutCaution: "Th\u1EADn tr\u1ECDng"
+  }
+};
+var registered = false;
+function ensureBlockEditorMessages() {
+  if (registered) return;
+  registered = true;
+  for (const locale of ["ja", "en", "vi"]) {
+    registerMessages(locale, { blockEditor: BLOCK_EDITOR_MESSAGES[locale] });
+  }
+}
+
+// src/suggestion-menu.tsx
+import * as React3 from "react";
+import { Popover, PopoverAnchor, PopoverContent } from "@godxjp/ui/data-display";
+import { Command, CommandEmpty, CommandItem, CommandList } from "@godxjp/ui/data-entry";
+import { VisuallyHidden } from "@godxjp/ui/general";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function SuggestionMenu({
+  open,
+  rect,
+  host,
+  items,
+  active,
+  onActiveChange,
+  onPick,
+  onDismiss,
+  label,
+  empty,
+  countLabel,
+  editable
+}) {
+  const menuId = React3.useId();
+  const panel = () => editable?.ownerDocument.querySelector(`[data-block-editor-menu="${CSS.escape(menuId)}"]`);
+  const box = host?.getBoundingClientRect();
+  const anchorStyle = rect && box ? {
+    position: "absolute",
+    insetInlineStart: rect.left - box.left,
+    insetBlockStart: rect.top - box.top,
+    blockSize: rect.height,
+    inlineSize: 1,
+    pointerEvents: "none"
+  } : { position: "absolute", inlineSize: 0, blockSize: 0 };
+  const wired = React3.useRef(false);
+  React3.useEffect(() => {
+    if (!editable) return void 0;
+    if (!open) {
+      if (wired.current) {
+        editable.removeAttribute("aria-controls");
+        editable.removeAttribute("aria-activedescendant");
+        wired.current = false;
+      }
+      return void 0;
+    }
+    const apply = () => {
+      const list = panel()?.querySelector("[cmdk-list]")?.id;
+      const option = panel()?.querySelector('[cmdk-item][aria-selected="true"]')?.id;
+      editable.setAttribute("aria-haspopup", "listbox");
+      editable.setAttribute("aria-autocomplete", "list");
+      if (list) editable.setAttribute("aria-controls", list);
+      if (option) editable.setAttribute("aria-activedescendant", option);
+      else editable.removeAttribute("aria-activedescendant");
+      wired.current = true;
+    };
+    apply();
+    const frame = requestAnimationFrame(apply);
+    const observer = new MutationObserver(apply);
+    observer.observe(editable.ownerDocument.body, {
+      subtree: true,
+      childList: true,
+      attributes: true,
+      attributeFilter: ["aria-selected"]
+    });
+    return () => {
+      cancelAnimationFrame(frame);
+      observer.disconnect();
+    };
+  });
+  return /* @__PURE__ */ jsxs2(Popover, { open, onOpenChange: (next) => next ? void 0 : onDismiss(), children: [
+    /* @__PURE__ */ jsx3(PopoverAnchor, { style: anchorStyle, "aria-hidden": "true" }),
+    /* @__PURE__ */ jsx3(VisuallyHidden, { role: "status", "aria-live": "polite", children: open ? countLabel : "" }),
+    /* @__PURE__ */ jsx3(
+      PopoverContent,
+      {
+        "data-block-editor-menu": menuId,
+        flush: true,
+        align: "start",
+        "aria-label": label,
+        className: "ui-block-editor-menu",
+        onOpenAutoFocus: (event) => event.preventDefault(),
+        onCloseAutoFocus: (event) => event.preventDefault(),
+        children: /* @__PURE__ */ jsx3(
+          Command,
+          {
+            value: active ?? "",
+            onValueChange: onActiveChange,
+            shouldFilter: false,
+            label,
+            children: /* @__PURE__ */ jsxs2(CommandList, { label, children: [
+              /* @__PURE__ */ jsx3(CommandEmpty, { children: empty }),
+              items.map((item) => /* @__PURE__ */ jsxs2(
+                CommandItem,
+                {
+                  value: item.value,
+                  onMouseDown: (event) => event.preventDefault(),
+                  onSelect: () => onPick(item.value),
+                  children: [
+                    item.icon ? /* @__PURE__ */ jsx3("span", { className: "ui-block-editor-menu-icon", "aria-hidden": "true", children: item.icon }) : null,
+                    /* @__PURE__ */ jsxs2("span", { className: "ui-block-editor-menu-text", children: [
+                      /* @__PURE__ */ jsx3("span", { children: item.label }),
+                      item.description ? /* @__PURE__ */ jsx3("span", { className: "ui-block-editor-menu-description", children: item.description }) : null
+                    ] })
+                  ]
+                },
+                item.value
+              ))
+            ] })
+          }
+        )
+      }
+    )
+  ] });
+}
+
+// src/toolbar.tsx
+import * as React4 from "react";
+import { useEditorState } from "@tiptap/react";
+import { BubbleMenu } from "@tiptap/react/menus";
+import { Bold, Code as Code2, Italic, Link2, Strikethrough } from "lucide-react";
+import { Input, ToggleGroup, ToggleGroupItem } from "@godxjp/ui/data-entry";
+import { Button as Button2 } from "@godxjp/ui/general";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var MARKS = ["bold", "italic", "strike", "code"];
+function FormatToolbar({ editor }) {
+  const label = useLabel();
+  const [linking, setLinking] = React4.useState(false);
+  const [href, setHref] = React4.useState("");
+  const state = useEditorState({
+    editor,
+    selector: ({ editor: e }) => ({
+      marks: MARKS.filter((mark) => e.isActive(mark)),
+      link: e.getAttributes("link").href ?? null
+    })
+  });
+  const toggle = (next) => {
+    const chain = editor.chain().focus();
+    for (const mark of MARKS) {
+      const on = next.includes(mark);
+      if (on === state.marks.includes(mark)) continue;
+      if (mark === "bold") chain.toggleBold();
+      else if (mark === "italic") chain.toggleItalic();
+      else if (mark === "strike") chain.toggleStrike();
+      else chain.toggleCode();
+    }
+    chain.run();
+  };
+  const applyLink = () => {
+    const url = href.trim();
+    const chain = editor.chain().focus().extendMarkRange("link");
+    if (url) chain.setLink({ href: url }).run();
+    else chain.unsetLink().run();
+    setLinking(false);
+  };
+  return /* @__PURE__ */ jsx4(
+    BubbleMenu,
+    {
+      editor,
+      className: "ui-block-editor-toolbar",
+      shouldShow: ({ editor: e, state: s }) => e.isEditable && !s.selection.empty && !e.isActive("codeBlock") && s.selection.content().size > 0,
+      options: { placement: "top" },
+      children: linking ? /* @__PURE__ */ jsxs3(
+        "form",
+        {
+          className: "ui-block-editor-toolbar-link",
+          onSubmit: (event) => {
+            event.preventDefault();
+            applyLink();
+          },
+          children: [
+            /* @__PURE__ */ jsx4(
+              Input,
+              {
+                size: "sm",
+                type: "url",
+                inputMode: "url",
+                "aria-label": label("linkUrl"),
+                value: href,
+                onValueChange: setHref,
+                onKeyDown: (event) => {
+                  if (event.key === "Escape") {
+                    setLinking(false);
+                    editor.commands.focus();
+                  }
+                },
+                autoFocus: true
+              }
+            ),
+            /* @__PURE__ */ jsx4(Button2, { size: "sm", type: "submit", children: label("applyLink") }),
+            state.link ? /* @__PURE__ */ jsx4(
+              Button2,
+              {
+                size: "sm",
+                variant: "ghost",
+                onClick: () => {
+                  editor.chain().focus().extendMarkRange("link").unsetLink().run();
+                  setLinking(false);
+                },
+                children: label("removeLink")
+              }
+            ) : null
+          ]
+        }
+      ) : /* @__PURE__ */ jsxs3("div", { className: "ui-block-editor-toolbar-row", children: [
+        /* @__PURE__ */ jsxs3(
+          ToggleGroup,
+          {
+            type: "multiple",
+            size: "sm",
+            "aria-label": label("formatting"),
+            value: state.marks,
+            onValueChange: toggle,
+            children: [
+              /* @__PURE__ */ jsx4(ToggleGroupItem, { value: "bold", "aria-label": label("bold"), children: /* @__PURE__ */ jsx4(Bold, {}) }),
+              /* @__PURE__ */ jsx4(ToggleGroupItem, { value: "italic", "aria-label": label("italic"), children: /* @__PURE__ */ jsx4(Italic, {}) }),
+              /* @__PURE__ */ jsx4(ToggleGroupItem, { value: "strike", "aria-label": label("strike"), children: /* @__PURE__ */ jsx4(Strikethrough, {}) }),
+              /* @__PURE__ */ jsx4(ToggleGroupItem, { value: "code", "aria-label": label("inlineCode"), children: /* @__PURE__ */ jsx4(Code2, {}) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          Button2,
+          {
+            size: "icon-sm",
+            variant: state.link ? "secondary" : "ghost",
+            "aria-label": label("link"),
+            "aria-pressed": state.link != null,
+            onClick: () => {
+              setHref(state.link ?? "");
+              setLinking(true);
+            },
+            children: /* @__PURE__ */ jsx4(Link2, {})
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// src/views.tsx
+import * as React5 from "react";
+import { Node as Node2, mergeAttributes as mergeAttributes2 } from "@tiptap/core";
+import { NodeViewWrapper, ReactNodeViewRenderer } from "@tiptap/react";
+import { LoaderCircle, TriangleAlert } from "lucide-react";
+import { parse } from "@godxjp/markdown/codec";
+import { Textarea } from "@godxjp/ui/data-entry";
+import { Button as Button3, Text } from "@godxjp/ui/general";
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function RawBlockView({ node, editor, getPos, updateAttributes, selected }) {
+  const tr = useLabel();
+  const [editing, setEditing] = React5.useState(false);
+  const [draft, setDraft] = React5.useState(node.attrs.source);
+  const commit = () => {
+    setEditing(false);
+    const doc = parse(draft);
+    const pos = getPos();
+    const stillRaw = doc.content.length === 1 && doc.content[0].type === "rawBlock";
+    if (stillRaw || typeof pos !== "number") {
+      updateAttributes({ source: draft });
+      return;
+    }
+    editor.chain().focus().insertContentAt({ from: pos, to: pos + node.nodeSize }, doc.content).run();
+  };
+  return /* @__PURE__ */ jsxs4(
+    NodeViewWrapper,
+    {
+      className: "ui-block-editor-raw-block",
+      "data-selected": selected ? "" : void 0,
+      children: [
+        /* @__PURE__ */ jsxs4("div", { className: "ui-block-editor-raw-block-head", contentEditable: false, children: [
+          /* @__PURE__ */ jsx5(Text, { size: "xs", tone: "muted", children: tr("rawBlock") }),
+          editor.isEditable ? /* @__PURE__ */ jsx5(
+            Button3,
+            {
+              size: "xs",
+              variant: "ghost",
+              onClick: () => editing ? commit() : (setDraft(node.attrs.source), setEditing(true)),
+              children: editing ? tr("done") : tr("editSource")
+            }
+          ) : null
+        ] }),
+        editing ? /* @__PURE__ */ jsx5(
+          Textarea,
+          {
+            "aria-label": tr("rawBlock"),
+            value: draft,
+            rows: Math.min(12, Math.max(3, draft.split("\n").length)),
+            onValueChange: setDraft,
+            onKeyDown: (event) => {
+              event.stopPropagation();
+              if (event.key === "Escape") commit();
+            },
+            autoFocus: true
+          }
+        ) : /* @__PURE__ */ jsx5("pre", { className: "ui-block-editor-raw-block-source", contentEditable: false, children: node.attrs.source })
+      ]
+    }
+  );
+}
+function rawBlockNode() {
+  return RawBlock.extend({ addNodeView: () => ReactNodeViewRenderer(RawBlockView) });
+}
+function embedNode(render) {
+  function EmbedView({ node, selected }) {
+    const tr = useLabel();
+    const target = node.attrs.target;
+    return /* @__PURE__ */ jsx5(
+      NodeViewWrapper,
+      {
+        className: "ui-block-editor-embed",
+        "data-selected": selected ? "" : void 0,
+        contentEditable: false,
+        children: render ? render(target) : /* @__PURE__ */ jsx5(Text, { size: "sm", tone: "muted", children: tr("embed", { target }) })
+      }
+    );
+  }
+  return Embed.extend({ addNodeView: () => ReactNodeViewRenderer(EmbedView) });
+}
+function uploadNode(actions) {
+  function UploadView({ node }) {
+    const tr = useLabel();
+    const { id, name, status } = node.attrs;
+    return (
+      // A plain span, not NodeViewWrapper: Tiptap's wrapper spreads its `as` prop onto the DOM as an
+      // invalid attribute, and this inline view needs nothing else it adds (no drag).
+      /* @__PURE__ */ jsx5(
+        "span",
+        {
+          "data-node-view-wrapper": "",
+          className: "ui-block-editor-upload",
+          "data-status": status,
+          contentEditable: false,
+          children: status === "uploading" ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+            /* @__PURE__ */ jsx5(LoaderCircle, { className: "ui-block-editor-upload-spinner", "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx5(Text, { as: "span", size: "sm", tone: "muted", role: "status", children: tr("uploading", { name }) })
+          ] }) : /* @__PURE__ */ jsxs4(Fragment, { children: [
+            /* @__PURE__ */ jsx5(TriangleAlert, { "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx5(Text, { as: "span", size: "sm", tone: "destructive", role: "alert", children: tr("uploadFailed", { name }) }),
+            /* @__PURE__ */ jsx5(Button3, { size: "xs", variant: "ghost", onClick: () => actions.retry(id), children: tr("retry") }),
+            /* @__PURE__ */ jsx5(Button3, { size: "xs", variant: "ghost", onClick: () => actions.remove(id), children: tr("remove") })
+          ] })
+        }
+      )
+    );
+  }
+  return Node2.create({
+    name: "uploadPlaceholder",
+    group: "inline",
+    inline: true,
+    atom: true,
+    selectable: false,
+    addAttributes() {
+      return { id: { default: "" }, name: { default: "" }, status: { default: "uploading" } };
+    },
+    parseHTML() {
+      return [{ tag: "span[data-upload]" }];
+    },
+    renderHTML({ HTMLAttributes }) {
+      return ["span", mergeAttributes2(HTMLAttributes, { "data-upload": "" })];
+    },
+    addNodeView: () => ReactNodeViewRenderer(UploadView, { as: "span" })
+  });
+}
+
+// src/block-editor.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function useSuggestion(toMenuItem, items, pick) {
+  const [menu, setMenu] = React6.useState(null);
+  const menuRef = React6.useRef(menu);
+  menuRef.current = menu;
+  const bridge = React6.useRef(null);
+  const show = (props) => setMenu((prev) => {
+    const first = props.items[0] ? toMenuItem(props.items[0]).value : void 0;
+    const keep = prev?.active && props.items.some((i) => toMenuItem(i).value === prev.active);
+    return {
+      items: props.items,
+      active: keep ? prev.active : first,
+      rect: props.clientRect?.() ?? null,
+      command: props.command
+    };
+  });
+  bridge.current = {
+    items,
+    pick,
+    onStart: show,
+    onUpdate: show,
+    onExit: () => setMenu(null),
+    onKeyDown: ({ event }) => {
+      const current = menuRef.current;
+      if (!current) return false;
+      const values = current.items.map((i) => toMenuItem(i).value);
+      const at = Math.max(0, values.indexOf(current.active ?? ""));
+      if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+        if (!values.length) return true;
+        const next = values[(at + (event.key === "ArrowDown" ? 1 : -1) + values.length) % values.length];
+        setMenu({ ...current, active: next });
+        return true;
+      }
+      if (event.key === "Enter" || event.key === "Tab") {
+        const item = current.items[at];
+        if (!item) return false;
+        current.command(item);
+        return true;
+      }
+      if (event.key === "Escape") {
+        setMenu(null);
+        return true;
+      }
+      return false;
+    }
+  };
+  return { menu, setMenu, bridge };
+}
+var uploadSeq = 0;
+var BlockEditor = React6.forwardRef(
+  function BlockEditor2({
+    value: valueProp,
+    defaultValue = "",
+    onValueChange,
+    upload,
+    pickMedia,
+    uploadBlockedReason = null,
+    suggestWikilinks,
+    renderEmbed,
+    resolveUrl,
+    actions = [],
+    labels,
+    disabled = false,
+    readOnly = false,
+    autoFocus = false,
+    id,
+    className,
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledby,
+    "aria-describedby": ariaDescribedby
+  }, ref) {
+    ensureBlockEditorMessages();
+    const { t } = useTranslation();
+    const label = React6.useCallback(
+      (key, params) => labels?.[key] ?? t(`blockEditor.${key}`, params),
+      [labels, t]
+    );
+    const labelRef = React6.useRef(label);
+    labelRef.current = label;
+    const hostRef = React6.useRef(null);
+    const [host, setHost] = React6.useState(null);
+    const [status, setStatus] = React6.useState(null);
+    const [menuRequest, setMenuRequest] = React6.useState(
+      null
+    );
+    const fileInput = React6.useRef(null);
+    const live = React6.useRef({
+      onValueChange,
+      upload,
+      pickMedia,
+      uploadBlockedReason,
+      suggestWikilinks,
+      actions
+    });
+    live.current = {
+      onValueChange,
+      upload,
+      pickMedia,
+      uploadBlockedReason,
+      suggestWikilinks,
+      actions
+    };
+    const initial = valueProp ?? defaultValue;
+    const lastMarkdown = React6.useRef(normalize(initial));
+    const uploads = React6.useRef(/* @__PURE__ */ new Map());
+    const editorRef = React6.useRef(null);
+    const findUpload = (editor2, uploadId) => {
+      let found = null;
+      editor2.state.doc.descendants((node, pos) => {
+        if (found) return false;
+        if (node.type.name === "uploadPlaceholder" && node.attrs.id === uploadId)
+          found = { pos, size: node.nodeSize };
+        return true;
+      });
+      return found;
+    };
+    const runUpload = React6.useCallback((uploadId) => {
+      const entry = uploads.current.get(uploadId);
+      const editor2 = editorRef.current;
+      const store = live.current.upload;
+      if (!entry || !editor2 || !store) return;
+      const { file, controller } = entry;
+      store(file, { signal: controller.signal }).then((result) => {
+        const target = findUpload(editor2, uploadId);
+        uploads.current.delete(uploadId);
+        if (!target) return;
+        const name = result.name ?? file.name;
+        const node = file.type.startsWith("image/") ? { type: "image", attrs: { src: result.url, alt: name, title: null } } : {
+          type: "text",
+          text: name,
+          marks: [{ type: "link", attrs: { href: result.url, title: null } }]
+        };
+        editor2.chain().insertContentAt({ from: target.pos, to: target.pos + target.size }, node).run();
+      }).catch(() => {
+        if (controller.signal.aborted) return;
+        const target = findUpload(editor2, uploadId);
+        if (!target) return;
+        editor2.view.dispatch(editor2.state.tr.setNodeAttribute(target.pos, "status", "error"));
+      });
+    }, []);
+    const startUploads = React6.useCallback(
+      (editor2, files, at) => {
+        if (files.length === 0) return false;
+        const blocked = live.current.uploadBlockedReason;
+        if (blocked || !live.current.upload) {
+          if (blocked) setStatus(blocked);
+          return Boolean(blocked);
+        }
+        const nodes = files.map((file) => {
+          const uploadId = `upload-${++uploadSeq}`;
+          uploads.current.set(uploadId, { file, controller: new AbortController() });
+          return {
+            uploadId,
+            node: {
+              type: "uploadPlaceholder",
+              attrs: { id: uploadId, name: file.name, status: "uploading" }
+            }
+          };
+        });
+        const position = at ?? editor2.state.selection.from;
+        editor2.chain().focus().insertContentAt(
+          position,
+          nodes.map((n) => n.node)
+        ).run();
+        for (const { uploadId } of nodes) runUpload(uploadId);
+        return true;
+      },
+      [runUpload]
+    );
+    const uploadActions = React6.useMemo(
+      () => ({
+        retry: (uploadId) => {
+          const editor2 = editorRef.current;
+          const entry = uploads.current.get(uploadId);
+          if (!editor2 || !entry) return;
+          entry.controller = new AbortController();
+          const target = findUpload(editor2, uploadId);
+          if (target)
+            editor2.view.dispatch(
+              editor2.state.tr.setNodeAttribute(target.pos, "status", "uploading")
+            );
+          runUpload(uploadId);
+        },
+        remove: (uploadId) => {
+          const editor2 = editorRef.current;
+          const target = editor2 ? findUpload(editor2, uploadId) : null;
+          if (editor2 && target)
+            editor2.chain().focus().deleteRange({ from: target.pos, to: target.pos + target.size }).run();
+        }
+      }),
+      [runUpload]
+    );
+    const insertImage = React6.useCallback((editor2) => {
+      const pick = live.current.pickMedia;
+      if (pick) {
+        const at = editor2.state.selection.from;
+        void pick().then((media) => {
+          if (media)
+            editor2.chain().focus().insertContentAt(at, {
+              type: "image",
+              attrs: { src: media.url, alt: media.name ?? "", title: null }
+            }).run();
+        });
+        return;
+      }
+      fileInput.current?.click();
+    }, []);
+    const canInsertImage = Boolean(pickMedia || upload);
+    const commands = React6.useMemo(() => {
+      const builtin = builtinCommands(
+        Object.fromEntries(
+          Object.keys(BLOCK_EDITOR_MESSAGES.en).map((k) => [
+            k,
+            label(k)
+          ])
+        ),
+        canInsertImage ? insertImage : null
+      );
+      const host2 = actions.map((action) => ({
+        key: action.key,
+        label: action.label,
+        icon: action.icon,
+        keywords: action.keywords,
+        run: (editor2) => action.run({
+          editor: editor2,
+          insertMarkdown: (markdown) => editor2.chain().focus().insertContent(parse2(markdown).content).run(),
+          markdown: () => serialize(editor2.getJSON())
+        })
+      }));
+      return [...builtin, ...host2];
+    }, [actions, canInsertImage, insertImage, label]);
+    const commandsRef = React6.useRef(commands);
+    commandsRef.current = commands;
+    const turnInto = React6.useMemo(
+      () => commands.filter((c) => TURN_INTO.includes(c.key)),
+      [commands]
+    );
+    const slash = useSuggestion(
+      (c) => ({ value: c.key, label: c.label, icon: c.icon }),
+      (query) => filterCommands(commandsRef.current, query),
+      (editor2, range, command) => {
+        editor2.chain().focus().deleteRange(range).run();
+        command.run(editor2);
+      }
+    );
+    const wiki = useSuggestion(
+      (s) => ({
+        value: `${s.target}#${s.heading ?? ""}`,
+        label: s.label ?? s.target,
+        description: s.description,
+        icon: /* @__PURE__ */ jsx6(FileText, {})
+      }),
+      (query) => live.current.suggestWikilinks?.(query) ?? [],
+      (editor2, range, item) => {
+        editor2.chain().focus().deleteRange(range).insertContent({
+          type: "wikilink",
+          attrs: {
+            target: item.target,
+            heading: item.heading ?? null,
+            label: item.label ?? null
+          }
+        }).run();
+      }
+    );
+    const extensions = React6.useMemo(
+      () => [
+        ...schemaExtensions({
+          placeholder: labelRef.current("placeholder"),
+          headingPlaceholder: (level) => labelRef.current("placeholderHeading", { level }),
+          togglePlaceholder: labelRef.current("placeholderToggle"),
+          calloutTitles: {
+            note: labelRef.current("calloutNote"),
+            tip: labelRef.current("calloutTip"),
+            important: labelRef.current("calloutImportant"),
+            warning: labelRef.current("calloutWarning"),
+            caution: labelRef.current("calloutCaution")
+          },
+          embed: embedNode(renderEmbed),
+          rawBlock: rawBlockNode(),
+          resolveUrl
+        }),
+        uploadNode(uploadActions),
+        BlockKeys.configure({ openMenu: (start) => setMenuRequest({ start, nonce: Date.now() }) }),
+        suggestionTrigger("slashMenu", "/", slash.bridge),
+        // A Japanese keyboard types the full-width slash; it opens the same menu.
+        suggestionTrigger("slashMenuWide", "\uFF0F", slash.bridge),
+        suggestionTrigger("wikilinkMenu", "[[", wiki.bridge, {
+          allowSpaces: true,
+          allowedPrefixes: null
+        })
+      ],
+      // Built once per editor: labels are read through a ref, host callbacks through `live`.
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      []
+    );
+    const editor = useEditor({
+      extensions,
+      content: parse2(initial),
+      editable: !disabled && !readOnly,
+      autofocus: autoFocus ? "end" : false,
+      immediatelyRender: false,
+      editorProps: {
+        attributes: {
+          class: "ui-prose ui-block-editor-content",
+          role: "textbox",
+          "aria-multiline": "true",
+          ...id ? { id } : {},
+          ...ariaLabelledby ? { "aria-labelledby": ariaLabelledby } : { "aria-label": ariaLabel ?? label("editor") },
+          ...ariaDescribedby ? { "aria-describedby": ariaDescribedby } : {}
+        },
+        // Copy writes Markdown, so a block pasted into a plain-text field reads as the body does.
+        clipboardTextSerializer: (slice) => serialize({ type: "doc", content: slice.content.toJSON() }).trimEnd(),
+        handlePaste: (view, event) => {
+          const instance = editorRef.current;
+          if (!instance) return false;
+          const files = [...event.clipboardData?.files ?? []];
+          if (files.length) return startUploads(instance, files);
+          const html = event.clipboardData?.getData("text/html");
+          const text = event.clipboardData?.getData("text/plain");
+          if (!html && text && !view.state.selection.$from.parent.type.spec.code) {
+            const doc = parse2(text);
+            instance.chain().focus().insertContent(doc.content).run();
+            return true;
+          }
+          return false;
+        },
+        handleDrop: (view, event, _slice, moved) => {
+          const instance = editorRef.current;
+          if (moved || !instance) return false;
+          const files = [...event.dataTransfer?.files ?? []];
+          if (!files.length) return false;
+          const at = view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos;
+          event.preventDefault();
+          return startUploads(instance, files, at);
+        }
+      },
+      onUpdate: ({ editor: instance }) => {
+        const markdown = serialize(instance.getJSON());
+        for (const [uploadId, entry] of uploads.current) {
+          if (!findUpload(instance, uploadId)) {
+            entry.controller.abort();
+            uploads.current.delete(uploadId);
+          }
+        }
+        if (markdown === lastMarkdown.current) return;
+        lastMarkdown.current = markdown;
+        live.current.onValueChange?.(markdown);
+      }
+    });
+    editorRef.current = editor;
+    React6.useEffect(() => {
+      if (!editor || valueProp === void 0) return;
+      const next = normalize(valueProp);
+      if (next === lastMarkdown.current || editor.view.composing) return;
+      lastMarkdown.current = next;
+      editor.commands.setContent(parse2(valueProp), { emitUpdate: false });
+    }, [editor, valueProp]);
+    React6.useEffect(() => {
+      editor?.setEditable(!disabled && !readOnly);
+    }, [editor, disabled, readOnly]);
+    React6.useImperativeHandle(
+      ref,
+      () => ({
+        focus: () => editor?.commands.focus(),
+        markdown: () => editor ? serialize(editor.getJSON()) : lastMarkdown.current,
+        editor
+      }),
+      [editor]
+    );
+    const openSlashBelow = (start) => {
+      if (!editor) return;
+      if (insertParagraphAfter(editor, start) == null) return;
+      editor.chain().focus().insertContent("/").run();
+    };
+    const menuItems = (state) => (state?.items ?? []).map((c) => ({ value: c.key, label: c.label, icon: c.icon }));
+    return /* @__PURE__ */ jsx6(LabelsContext.Provider, { value: label, children: /* @__PURE__ */ jsxs5(
+      "div",
+      {
+        ref: (node) => {
+          hostRef.current = node;
+          setHost(node);
+        },
+        className: ["ui-block-editor", className].filter(Boolean).join(" "),
+        "data-disabled": disabled ? "" : void 0,
+        children: [
+          editor ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+            /* @__PURE__ */ jsx6(
+              BlockHandle,
+              {
+                editor,
+                host,
+                turnInto,
+                onAddBelow: openSlashBelow,
+                menuRequest
+              }
+            ),
+            /* @__PURE__ */ jsx6(FormatToolbar, { editor })
+          ] }) : null,
+          /* @__PURE__ */ jsx6(EditorContent, { editor }),
+          /* @__PURE__ */ jsx6(
+            SuggestionMenu,
+            {
+              open: slash.menu != null,
+              rect: slash.menu?.rect ?? null,
+              host,
+              items: menuItems(slash.menu),
+              active: slash.menu?.active,
+              onActiveChange: (active) => slash.setMenu((m) => m ? { ...m, active } : m),
+              onPick: (key) => {
+                const item = slash.menu?.items.find((c) => c.key === key);
+                if (item) slash.menu?.command(item);
+              },
+              onDismiss: () => slash.setMenu(null),
+              label: label("blocks"),
+              empty: label("noResults"),
+              countLabel: t("dataEntry.chatSuggestion.count", {
+                count: slash.menu?.items.length ?? 0
+              }),
+              editable: editor?.view.dom ?? null
+            }
+          ),
+          /* @__PURE__ */ jsx6(
+            SuggestionMenu,
+            {
+              open: wiki.menu != null,
+              rect: wiki.menu?.rect ?? null,
+              host,
+              items: (wiki.menu?.items ?? []).map((s) => ({
+                value: `${s.target}#${s.heading ?? ""}`,
+                label: s.label ?? s.target,
+                description: s.description,
+                icon: /* @__PURE__ */ jsx6(FileText, {})
+              })),
+              active: wiki.menu?.active,
+              onActiveChange: (active) => wiki.setMenu((m) => m ? { ...m, active } : m),
+              onPick: (value) => {
+                const item = wiki.menu?.items.find((s) => `${s.target}#${s.heading ?? ""}` === value);
+                if (item) wiki.menu?.command(item);
+              },
+              onDismiss: () => wiki.setMenu(null),
+              label: label("link"),
+              empty: label("noResults"),
+              countLabel: t("dataEntry.chatSuggestion.count", {
+                count: wiki.menu?.items.length ?? 0
+              }),
+              editable: editor?.view.dom ?? null
+            }
+          ),
+          status ? /* @__PURE__ */ jsx6(Text2, { size: "sm", tone: "destructive", role: "alert", className: "ui-block-editor-status", children: status }) : null,
+          canInsertImage && !pickMedia ? /* @__PURE__ */ jsx6(
+            "input",
+            {
+              ref: fileInput,
+              type: "file",
+              accept: "image/*",
+              hidden: true,
+              "aria-hidden": "true",
+              tabIndex: -1,
+              onChange: (event) => {
+                const files = [...event.currentTarget.files ?? []];
+                event.currentTarget.value = "";
+                if (editor) startUploads(editor, files);
+              }
+            }
+          ) : null
+        ]
+      }
+    ) });
+  }
+);
+export {
+  BLOCK_EDITOR_MESSAGES,
+  BlockEditor,
+  schemaExtensions
+};