@x12i/editor 1.0.0 → 1.1.0

package/dist/react.js

@@ -0,0 +1,4439 @@
+"use client";
+import {
+  BLOCK_ID_NODES,
+  CALLOUT_VARIANTS,
+  HIGHLIGHT_TOKENS,
+  TEXT_COLOR_TOKENS,
+  buildOutlineTree,
+  createEmptyDocument,
+  documentToMarkdown,
+  documentToTiptap,
+  emojiForShortcode,
+  generateBlockId,
+  getOutline,
+  inlineToPlainText,
+  isHighlightToken,
+  isTextColorToken,
+  normalizeUrlInput,
+  sanitizeMediaUrl,
+  sanitizeUrl,
+  slugifyHeading,
+  tiptapToDocument
+} from "./chunk-FYXMOAJT.js";
+
+// src/react/editor.tsx
+import { useCallback as useCallback3, useEffect as useEffect10, useImperativeHandle, useMemo as useMemo3, useRef as useRef13, useState as useState12 } from "react";
+import { EditorContent, useEditor } from "@tiptap/react";
+import { exitSuggestion } from "@tiptap/suggestion";
+
+// src/react/ai-assist-menu.tsx
+import { useEffect, useRef, useState } from "react";
+import { Button, Spinner } from "@x12i/ui";
+
+// src/react/internal/glyphs.tsx
+import { jsx } from "react/jsx-runtime";
+var PATHS = {
+  undo: "M6 3 3 6l3 3 M3 6h6a4 4 0 0 1 0 8H6",
+  redo: "m10 3 3 3-3 3 M13 6H7a4 4 0 0 0 0 8h3",
+  bold: "M4 2.5h4.5a2.5 2.5 0 0 1 0 5H4z M4 7.5h5a2.75 2.75 0 0 1 0 5.5H4z",
+  italic: "M7 3h5 M4 13h5 M10 3 6 13",
+  underline: "M4 2.5V8a4 4 0 0 0 8 0V2.5 M3 14h10",
+  strike: "M3 8h10 M10.8 5.2C10.5 3.9 9.4 3 8 3 6.3 3 5.2 4 5.2 5.2c0 1 .6 1.7 1.8 2 M5.2 10.8C5.5 12.1 6.6 13 8 13c1.7 0 2.8-1 2.8-2.2 0-.4-.1-.7-.3-1",
+  code: "m6 4-4 4 4 4 M10 4l4 4-4 4",
+  highlight: "m9 2.5 4.5 4.5-5 5H5.5V8.5z M3 14h10",
+  color: "M4.5 11 8 3l3.5 8 M5.7 8.5h4.6 M3 14.5h10",
+  link: "M6.8 9.2a3 3 0 0 0 4.2 0l2-2a3 3 0 0 0-4.2-4.2l-1 1 M9.2 6.8a3 3 0 0 0-4.2 0l-2 2A3 3 0 0 0 7.200 13l1-1",
+  bullets: "M6 4h8 M6 8h8 M6 12h8 M2.5 4h.1 M2.5 8h.1 M2.5 12h.1",
+  numbers: "M6.5 4h7.500 M6.5 8h7.500 M6.5 12h7.500 M2 3.200l1-.7V6 M2 9.700c0-1.100 2-1.100 2 0 0 1-2 1.500-2 2.300h2",
+  tasks: "m2 3.500 1.200 1.200L5.200 2.800 M2 9l1.200 1.200L5.200 8.300 M7.500 4h6.500 M7.500 9.500h6.500",
+  indent: "M2 3h12 M8 7h6 M8 11h6 M2 14h12 M2 6l3 2.500L2 11",
+  outdent: "M2 3h12 M8 7h6 M8 11h6 M2 14h12 M5 6 2 8.500 5 11",
+  quote: "M3 3.500v9 M7 5h7 M7 8h7 M7 11h4.500",
+  divider: "M2 8h12 M5 4.500h.1 M8 4.500h.1 M11 4.500h.1 M5 11.500h.1 M8 11.500h.1 M11 11.500h.1",
+  table: "M2 3h12v10H2z M2 6.500h12 M2 9.800h12 M6 3v10 M10 3v10",
+  image: "M2 3h12v10H2z m0 8 4-4 3 3 2-2 3 3 M10.500 5.800h.1",
+  up: "M8 13V3 M4 7l4-4 4 4",
+  down: "M8 3v10 M4 9l4 4 4-4",
+  duplicate: "M5.500 5.500h8v8h-8z M10.500 5.500v-3h-8v8h3",
+  more: "M3.500 8h.1 M8 8h.1 M12.500 8h.1",
+  heading: "M3.500 3v10 M12.500 3v10 M3.500 8h9",
+  grip: "M6 3.500h.1 M10 3.500h.1 M6 8h.1 M10 8h.1 M6 12.500h.1 M10 12.500h.1",
+  chevron: "m4 6 4 4 4-4",
+  check: "m3.500 8.500 3 3 6-7",
+  close: "m4 4 8 8 M12 4l-8 8",
+  copy: "M5.500 5.500h8v8h-8z M10.500 5.500v-3h-8v8h3",
+  trash: "M3 4.500h10 M6 4.500v-2h4v2 M4.500 4.500l.6 9h5.800l.6-9 M7 7v4 M9 7v4",
+  edit: "m3 13 .8-3L11 2.800a1.400 1.400 0 0 1 2 2L5.800 12z M9.800 4l2 2",
+  plus: "M8 3v10 M3 8h10",
+  sparkle: "M8 2l1.200 3.800L13 7l-3.800 1.200L8 12l-1.200-3.800L3 7l3.800-1.200z",
+  info: "M8 14A6 6 0 1 0 8 2a6 6 0 0 0 0 12z M8 7.500V11 M8 5h.1",
+  success: "M8 14A6 6 0 1 0 8 2a6 6 0 0 0 0 12z m-2.500-6 2 2 3-3.500",
+  warning: "M8 2.500 14 13H2z M8 7v3 M8 11.500h.1",
+  danger: "M8 14A6 6 0 1 0 8 2a6 6 0 0 0 0 12z m-2-8 4 4 m0-4-4 4",
+  neutral: "M3 3h10v10H3z M5.500 6h5 M5.500 8h5 M5.500 10h3",
+  file: "M4 2h5l3 3v9H4z M9 2v3h3",
+  bookmark: "M3 8h3 M10 8h3 M6 5h4a3 3 0 0 1 0 6H6a3 3 0 0 1 0-6z",
+  chevronEnd: "m6 4 4 4-4 4",
+  unlink: "M6.800 9.200a3 3 0 0 0 4.200 0l2-2a3 3 0 0 0-4.200-4.200l-1 1 M9.200 6.800a3 3 0 0 0-4.200 0l-2 2A3 3 0 0 0 7.200 13l1-1 M2 2l12 12"
+};
+function Glyph({ name, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      "data-kit": "editor-glyph",
+      viewBox: "0 0 16 16",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 1.5,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      focusable: "false",
+      ...props,
+      children: /* @__PURE__ */ jsx("path", { d: PATHS[name] })
+    }
+  );
+}
+
+// src/react/messages.ts
+import { createContext, useContext } from "react";
+var BLOCK_KINDS = [
+  "paragraph",
+  "heading1",
+  "heading2",
+  "heading3",
+  "heading4",
+  "quote",
+  "callout",
+  "toggle",
+  "bulletList",
+  "numberedList",
+  "taskList",
+  "code",
+  "equation",
+  "divider",
+  "table",
+  "image",
+  "video",
+  "audio",
+  "file",
+  "bookmark",
+  "columns",
+  "pageBreak",
+  "toc",
+  "chart",
+  "diagram",
+  "dataView",
+  "ai"
+];
+var defaultMessages = {
+  editorLabel: "Document editor",
+  placeholder: "Write something, or press / for blocks",
+  viewLabel: "Document",
+  toolbar: {
+    label: "Formatting",
+    undo: "Undo",
+    redo: "Redo",
+    blockType: "Block type",
+    bold: "Bold",
+    italic: "Italic",
+    underline: "Underline",
+    strike: "Strikethrough",
+    code: "Inline code",
+    highlight: "Highlight",
+    textColor: "Text color",
+    clearColor: "Default color",
+    link: "Link",
+    bulletList: "Bulleted list",
+    numberedList: "Numbered list",
+    taskList: "Task list",
+    indent: "Increase indent",
+    outdent: "Decrease indent",
+    quote: "Quote",
+    divider: "Divider",
+    table: "Insert table",
+    image: "Insert image",
+    selectionMenu: "Text formatting"
+  },
+  tokens: {
+    "color.text.secondary": "Gray",
+    "color.text.link": "Link blue",
+    "color.accent.default": "Accent",
+    "color.status.success.foreground": "Green",
+    "color.status.warning.foreground": "Orange",
+    "color.status.danger.foreground": "Red",
+    "color.status.info.foreground": "Blue",
+    "color.chart.categorical.4": "Magenta",
+    "color.highlight": "Yellow",
+    "color.accent.subtle": "Accent",
+    "color.status.success.background": "Green",
+    "color.status.warning.background": "Orange",
+    "color.status.danger.background": "Red",
+    "color.status.info.background": "Blue"
+  },
+  blocks: {
+    paragraph: { name: "Text", description: "Plain paragraph text", keywords: "paragraph plain body" },
+    heading1: { name: "Heading 1", description: "Large section heading", keywords: "h1 title header" },
+    heading2: { name: "Heading 2", description: "Medium section heading", keywords: "h2 subtitle header" },
+    heading3: { name: "Heading 3", description: "Small section heading", keywords: "h3 header" },
+    heading4: { name: "Heading 4", description: "Smallest section heading", keywords: "h4 header" },
+    quote: { name: "Quote", description: "Quote another voice", keywords: "blockquote citation" },
+    callout: { name: "Callout", description: "Highlight a note or warning", keywords: "note alert info warning tip admonition" },
+    toggle: { name: "Toggle", description: "Content that expands and collapses", keywords: "collapse details accordion expand" },
+    bulletList: { name: "Bulleted list", description: "A simple list of points", keywords: "ul unordered bullets" },
+    numberedList: { name: "Numbered list", description: "A list with numbers", keywords: "ol ordered steps" },
+    taskList: { name: "Task list", description: "Track to-dos with checkboxes", keywords: "todo checklist checkbox" },
+    code: { name: "Code", description: "A block of code with a language", keywords: "snippet pre programming" },
+    equation: { name: "Equation", description: "A formula written in LaTeX", keywords: "math latex formula" },
+    divider: { name: "Divider", description: "A horizontal rule between sections", keywords: "hr rule line separator" },
+    table: { name: "Table", description: "Rows and columns of data", keywords: "grid rows columns" },
+    image: { name: "Image", description: "An image with alternative text", keywords: "picture photo figure" },
+    video: { name: "Video", description: "Embed a video by URL", keywords: "movie clip" },
+    audio: { name: "Audio", description: "Embed audio by URL", keywords: "sound podcast" },
+    file: { name: "File", description: "Link to a downloadable file", keywords: "attachment download pdf" },
+    bookmark: { name: "Bookmark", description: "A link shown as a card", keywords: "link url website card" },
+    columns: { name: "Columns", description: "Side by side blocks", keywords: "layout two three" },
+    pageBreak: { name: "Page break", description: "Start a new page when printing", keywords: "print pdf" },
+    toc: { name: "Table of contents", description: "Links to every heading", keywords: "outline toc navigation" },
+    chart: { name: "Chart", description: "A chart built from data", keywords: "graph plot bar line pie" },
+    diagram: { name: "Diagram", description: "A flow or system diagram", keywords: "flowchart mermaid graph" },
+    dataView: { name: "Data view", description: "A saved view of a dataset", keywords: "table grid records query" },
+    ai: { name: "AI block", description: "Ask AI to write or summarize", keywords: "assistant generate gpt llm" }
+  },
+  groups: {
+    basic: "Basic blocks",
+    lists: "Lists",
+    media: "Media",
+    advanced: "Advanced",
+    embeds: "Embeds"
+  },
+  callouts: {
+    info: "Info",
+    success: "Success",
+    warning: "Warning",
+    danger: "Danger",
+    neutral: "Note"
+  },
+  slash: {
+    label: "Insert a block",
+    noResults: "No matching blocks",
+    resultCount: "{count, plural, one {# block available} other {# blocks available}}",
+    instructions: "Type to filter, use the arrow keys to choose, Enter to insert, Escape to close"
+  },
+  blockMenu: {
+    label: "Block actions",
+    trigger: "Block actions (Ctrl+/)",
+    duplicate: "Duplicate",
+    delete: "Delete",
+    turnInto: "Turn into",
+    moveUp: "Move up",
+    moveDown: "Move down",
+    insertBelow: "Add paragraph below"
+  },
+  table: {
+    addRowBefore: "Add row above",
+    addRowAfter: "Add row below",
+    addColumnBefore: "Add column before",
+    addColumnAfter: "Add column after",
+    deleteRow: "Delete row",
+    deleteColumn: "Delete column",
+    toggleHeaderRow: "Header row",
+    toggleHeaderColumn: "Header column",
+    deleteTable: "Delete table",
+    controls: "Table controls"
+  },
+  linkDialog: {
+    title: "Link",
+    urlLabel: "Link address",
+    urlHint: "Use http, https, mailto, tel, or a relative path",
+    invalid: "This address is not allowed. Use http, https, mailto, tel or a relative path.",
+    required: "Enter a link address.",
+    apply: "Apply",
+    remove: "Remove link",
+    cancel: "Cancel"
+  },
+  imageDialog: {
+    title: "Insert image",
+    editTitle: "Edit image",
+    urlLabel: "Image address",
+    altLabel: "Alternative text",
+    altHint: "Describe the image for people who cannot see it",
+    altRequired: "Describe the image, or mark it as decorative.",
+    decorative: "This image is decorative and needs no description",
+    captionLabel: "Caption (optional)",
+    urlRequired: "Enter an image address.",
+    urlInvalid: "This address is not allowed. Use http, https, a relative path, or a data:image URL.",
+    insert: "Insert",
+    update: "Update",
+    cancel: "Cancel"
+  },
+  code: {
+    language: "Code language",
+    plainText: "Plain text",
+    copy: "Copy code",
+    copied: "Copied"
+  },
+  task: {
+    done: "Mark as not done: {text}",
+    todo: "Mark as done: {text}",
+    emptyLabel: "empty task"
+  },
+  toggle: {
+    expand: "Expand",
+    collapse: "Collapse",
+    summaryPlaceholder: "Toggle title"
+  },
+  equation: {
+    label: "LaTeX equation",
+    placeholder: "Type LaTeX, for example E = mc^2"
+  },
+  embed: {
+    groupLabel: "{type}: {title}",
+    untitled: "Untitled",
+    edit: "Edit",
+    remove: "Remove",
+    moveUp: "Move up",
+    moveDown: "Move down",
+    toolbar: "Block tools",
+    request: "Choose content for this block",
+    previewHint: "Preview of the block data. Connect a renderer to draw it.",
+    showData: "Show data",
+    dataset: "Dataset",
+    prompt: "Prompt",
+    result: "Result",
+    engine: "Engine",
+    unknown: "This block type is not supported here. Its data is kept."
+  },
+  media: {
+    file: "File",
+    download: "Download {name}",
+    bookmark: "Bookmark",
+    open: "Open {title}",
+    unsafe: "This address is not allowed",
+    image: "Image",
+    imageDecorative: "Decorative image",
+    imageEdit: "Edit image",
+    video: "Video",
+    audio: "Audio",
+    urlLabel: "Address",
+    nameLabel: "Name",
+    set: "Set"
+  },
+  ai: {
+    menuLabel: "AI assistant",
+    improve: "Improve writing",
+    shorten: "Make shorter",
+    continue: "Continue writing",
+    fixGrammar: "Fix spelling and grammar",
+    custom: "Ask AI",
+    customLabel: "Instruction",
+    run: "Run",
+    accept: "Accept",
+    reject: "Reject",
+    cancel: "Stop",
+    generating: "Writing a suggestion",
+    preview: "Suggestion",
+    error: "The assistant could not finish: {message}",
+    noSelection: "Select some text first",
+    done: "Suggestion ready",
+    prompts: {
+      improve: "Improve the clarity and flow of the text while keeping its meaning",
+      shorten: "Make the text shorter while keeping its meaning",
+      continue: "Continue writing from where the text ends"
+    }
+  },
+  status: {
+    saved: "Saved",
+    markOn: "{name} on",
+    markOff: "{name} off",
+    blockMoved: "Block moved to position {position} of {total}",
+    blockMovedUp: "Block moved up",
+    blockMovedDown: "Block moved down",
+    blockDuplicated: "Block duplicated",
+    blockDeleted: "Block deleted",
+    blockTurnedInto: "Turned into {name}",
+    linkApplied: "Link applied",
+    linkRemoved: "Link removed",
+    imageInserted: "Image inserted",
+    copied: "Copied to clipboard",
+    undone: "Undone",
+    redone: "Redone",
+    aiApplied: "Suggestion applied",
+    cannotMove: "This block cannot move further"
+  },
+  directions: { up: "up", down: "down" }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMessages(base, overrides) {
+  if (!overrides) return base;
+  const merge = (target, source) => {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (value === void 0) continue;
+      const current = result[key];
+      result[key] = isPlainObject(value) && isPlainObject(current) ? merge(current, value) : value;
+    }
+    return result;
+  };
+  return merge(base, overrides);
+}
+function matchBrace(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "{") depth += 1;
+    else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function formatMessage(template, values = {}, locale) {
+  let out = "";
+  let index = 0;
+  while (index < template.length) {
+    const char = template[index];
+    if (char !== "{") {
+      out += char;
+      index += 1;
+      continue;
+    }
+    const end = matchBrace(template, index);
+    if (end === -1) {
+      out += template.slice(index);
+      break;
+    }
+    const inner = template.slice(index + 1, end);
+    const plural = /^\s*([\w-]+)\s*,\s*plural\s*,([\s\S]*)$/.exec(inner);
+    if (plural) {
+      const name = plural[1];
+      const count = Number(values[name] ?? 0);
+      const branches = /* @__PURE__ */ new Map();
+      const body = plural[2];
+      let cursor = 0;
+      while (cursor < body.length) {
+        const selector = /^\s*(=\d+|[a-z]+)\s*\{/.exec(body.slice(cursor));
+        if (!selector) break;
+        const open = cursor + selector[0].length - 1;
+        const close = matchBrace(body, open);
+        if (close === -1) break;
+        branches.set(selector[1], body.slice(open + 1, close));
+        cursor = close + 1;
+      }
+      let category;
+      try {
+        category = new Intl.PluralRules(locale).select(count);
+      } catch {
+        category = count === 1 ? "one" : "other";
+      }
+      const chosen = branches.get(`=${count}`) ?? branches.get(category) ?? branches.get("other") ?? "";
+      out += formatMessage(chosen.replace(/#/g, String(count)), values, locale);
+    } else {
+      const name = inner.trim();
+      out += name in values ? String(values[name]) : `{${inner}}`;
+    }
+    index = end + 1;
+  }
+  return out;
+}
+function createTranslator(messages, locale) {
+  return {
+    messages,
+    locale,
+    format: (template, values) => formatMessage(template, values, locale)
+  };
+}
+var MessagesContext = createContext(createTranslator(defaultMessages));
+function useTranslator() {
+  return useContext(MessagesContext);
+}
+function useMessages() {
+  return useContext(MessagesContext).messages;
+}
+
+// src/react/ai-assist-menu.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function AiAssistMenu({ assist, editor, onClose }) {
+  const t = useTranslator();
+  const m = t.messages.ai;
+  const firstRef = useRef(null);
+  const acceptRef = useRef(null);
+  const [instruction, setInstruction] = useState("");
+  const { status } = assist;
+  useEffect(() => {
+    firstRef.current?.focus();
+  }, []);
+  useEffect(() => {
+    if (status === "preview") acceptRef.current?.focus();
+  }, [status]);
+  const close = () => {
+    assist.reject();
+    onClose();
+    editor.commands.focus();
+  };
+  const custom = (event) => {
+    event.preventDefault();
+    const text = instruction.trim();
+    if (text !== "") void assist.run("rewrite", { tone: text });
+  };
+  const busy = status === "running";
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      role: "group",
+      "aria-label": m.menuLabel,
+      "data-kit": "editor-ai",
+      "data-status": status,
+      onKeyDown: (event) => {
+        if (event.key === "Escape") {
+          event.preventDefault();
+          event.stopPropagation();
+          close();
+        }
+      },
+      children: status === "idle" || status === "error" ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { "data-kit": "editor-ai-actions", children: [
+          /* @__PURE__ */ jsx2(Button, { ref: firstRef, type: "button", size: "sm", variant: "soft", tone: "neutral", onMouseDown: (event) => event.preventDefault(), onClick: () => void assist.run("rewrite", { tone: m.prompts.improve }), children: m.improve }),
+          /* @__PURE__ */ jsx2(Button, { type: "button", size: "sm", variant: "soft", tone: "neutral", onMouseDown: (event) => event.preventDefault(), onClick: () => void assist.run("summarize", { tone: m.prompts.shorten }), children: m.shorten }),
+          /* @__PURE__ */ jsx2(Button, { type: "button", size: "sm", variant: "soft", tone: "neutral", onMouseDown: (event) => event.preventDefault(), onClick: () => void assist.run("continue", { tone: m.prompts.continue }), children: m.continue }),
+          /* @__PURE__ */ jsx2(Button, { type: "button", size: "sm", variant: "soft", tone: "neutral", onMouseDown: (event) => event.preventDefault(), onClick: () => void assist.run("fix-grammar"), children: m.fixGrammar })
+        ] }),
+        /* @__PURE__ */ jsxs("form", { "data-kit": "editor-ai-custom", onSubmit: custom, children: [
+          /* @__PURE__ */ jsxs("label", { "data-kit": "editor-field", children: [
+            /* @__PURE__ */ jsx2("span", { "data-kit": "editor-field-label", children: m.customLabel }),
+            /* @__PURE__ */ jsx2("input", { "data-kit": "editor-input", type: "text", dir: "auto", value: instruction, onChange: (event) => setInstruction(event.target.value) })
+          ] }),
+          /* @__PURE__ */ jsx2(Button, { type: "submit", size: "sm", variant: "solid", tone: "accent", disabled: instruction.trim() === "", children: m.run })
+        ] }),
+        status === "error" && assist.error ? /* @__PURE__ */ jsx2("p", { role: "alert", "data-kit": "editor-error", children: assist.error }) : null
+      ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs("div", { "data-kit": "editor-ai-preview", "aria-busy": busy, children: [
+          /* @__PURE__ */ jsxs("p", { "data-kit": "editor-ai-preview-label", children: [
+            busy ? /* @__PURE__ */ jsx2(Spinner, { size: "xs", label: m.generating }) : /* @__PURE__ */ jsx2(Glyph, { name: "sparkle" }),
+            /* @__PURE__ */ jsx2("span", { children: busy ? m.generating : m.preview })
+          ] }),
+          /* @__PURE__ */ jsx2("div", { "data-kit": "editor-ai-preview-text", dir: "auto", tabIndex: 0, role: "region", "aria-label": m.preview, children: assist.preview })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { "data-kit": "editor-ai-actions", children: [
+          /* @__PURE__ */ jsx2(Button, { ref: acceptRef, type: "button", size: "sm", variant: "solid", tone: "accent", disabled: busy, onClick: () => {
+            assist.accept();
+            onClose();
+          }, children: m.accept }),
+          busy ? /* @__PURE__ */ jsx2(Button, { type: "button", size: "sm", variant: "outline", tone: "neutral", onClick: assist.cancel, children: m.cancel }) : null,
+          /* @__PURE__ */ jsx2(Button, { type: "button", size: "sm", variant: "ghost", tone: "neutral", onClick: close, children: m.reject })
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/react/block-menu.tsx
+import { useState as useState3 } from "react";
+
+// src/react/commands.ts
+import { NodeSelection, Selection, TextSelection } from "@tiptap/pm/state";
+var CONTAINERS = /* @__PURE__ */ new Set(["doc", "toggle", "column"]);
+var ITEMS = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LISTS = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+function isMovable(node, parent) {
+  const name = node.type.name;
+  if (ITEMS.has(name)) return LISTS.has(parent.type.name);
+  return BLOCK_ID_NODES.includes(name) && CONTAINERS.has(parent.type.name);
+}
+function blockAt(state, pos) {
+  if (pos < 0 || pos > state.doc.content.size) return null;
+  const $pos = state.doc.resolve(pos);
+  const node = $pos.nodeAfter;
+  if (!node) return null;
+  return { pos, node, parent: $pos.parent, index: $pos.index() };
+}
+function findBlock(state, options = {}) {
+  const items = options.items ?? true;
+  if (options.at !== void 0) return blockAt(state, options.at);
+  const { selection } = state;
+  if (selection instanceof NodeSelection) {
+    const parent = selection.$from.parent;
+    if (isMovable(selection.node, parent) && (items || !ITEMS.has(selection.node.type.name))) {
+      return { pos: selection.from, node: selection.node, parent, index: selection.$from.index() };
+    }
+  }
+  const { $from } = selection;
+  for (let depth = $from.depth; depth >= 1; depth -= 1) {
+    const node = $from.node(depth);
+    const parent = $from.node(depth - 1);
+    if (!isMovable(node, parent)) continue;
+    if (!items && ITEMS.has(node.type.name)) continue;
+    return { pos: $from.before(depth), node, parent, index: $from.index(depth - 1) };
+  }
+  return null;
+}
+function moveBlock(editor, direction, at) {
+  const { state, view } = editor;
+  const location = findBlock(state, at === void 0 ? {} : { at });
+  const none = { moved: false, position: location ? location.index + 1 : 0, total: location ? location.parent.childCount : 0 };
+  if (!location) return none;
+  const { pos, node, parent, index } = location;
+  const siblingIndex = index + direction;
+  if (siblingIndex < 0 || siblingIndex >= parent.childCount) return none;
+  const sibling = parent.child(siblingIndex);
+  if (sibling.type.name === "toggleSummary" || node.type.name === "toggleSummary") return none;
+  const { selection } = state;
+  const wasNode = selection instanceof NodeSelection && selection.from === pos;
+  const offset = Math.max(0, selection.from - pos);
+  const tr = state.tr;
+  let newPos;
+  if (direction < 0) {
+    newPos = pos - sibling.nodeSize;
+    tr.delete(pos, pos + node.nodeSize).insert(newPos, node);
+  } else {
+    newPos = pos + sibling.nodeSize;
+    tr.insert(pos + node.nodeSize + sibling.nodeSize, node).delete(pos, pos + node.nodeSize);
+  }
+  if (wasNode) tr.setSelection(NodeSelection.create(tr.doc, newPos));
+  else tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(newPos + offset, tr.doc.content.size)), 1));
+  view.dispatch(tr.scrollIntoView());
+  return { moved: true, position: siblingIndex + 1, total: parent.childCount };
+}
+function duplicateBlock(editor, at) {
+  const { state, view } = editor;
+  const location = findBlock(state, at === void 0 ? {} : { at });
+  if (!location) return false;
+  const { pos, node } = location;
+  const tr = state.tr;
+  const insertAt = pos + node.nodeSize;
+  tr.insert(insertAt, node);
+  const wasNode = state.selection instanceof NodeSelection && state.selection.from === pos;
+  if (wasNode) tr.setSelection(NodeSelection.create(tr.doc, insertAt));
+  else tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(insertAt + 1, tr.doc.content.size)), 1));
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function deleteBlock(editor, at) {
+  const { state, view } = editor;
+  let location = findBlock(state, at === void 0 ? {} : { at });
+  if (!location) return false;
+  if (ITEMS.has(location.node.type.name) && location.parent.childCount === 1) {
+    const $pos = state.doc.resolve(location.pos);
+    const list = blockAt(state, $pos.before($pos.depth));
+    if (list) location = list;
+  }
+  const { pos, node, parent } = location;
+  const tr = state.tr;
+  const isLastBlock = parent.type.name === "doc" && parent.childCount === 1;
+  const paragraph = state.schema.nodes.paragraph;
+  if (isLastBlock && paragraph) {
+    tr.replaceWith(pos, pos + node.nodeSize, paragraph.create());
+    tr.setSelection(TextSelection.near(tr.doc.resolve(1), 1));
+  } else {
+    tr.delete(pos, pos + node.nodeSize);
+    const target = Math.min(pos, tr.doc.content.size);
+    tr.setSelection(Selection.near(tr.doc.resolve(target), -1));
+  }
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function currentBlockKind(editor) {
+  if (editor.isActive("heading")) {
+    const level = editor.getAttributes("heading").level;
+    if (level === 1 || level === 2 || level === 3 || level === 4) return `heading${level}`;
+  }
+  const order = [
+    ["taskList", "taskList"],
+    ["bulletList", "bulletList"],
+    ["orderedList", "numberedList"],
+    ["codeBlock", "code"],
+    ["equation", "equation"],
+    ["callout", "callout"],
+    ["blockquote", "quote"],
+    ["toggle", "toggle"],
+    ["table", "table"]
+  ];
+  for (const [name, kind] of order) if (editor.isActive(name)) return kind;
+  const { selection } = editor.state;
+  if (selection instanceof NodeSelection) {
+    const byNode = {
+      image: "image",
+      media: "video",
+      file: "file",
+      bookmark: "bookmark",
+      columns: "columns",
+      pageBreak: "pageBreak",
+      tableOfContents: "toc",
+      chart: "chart",
+      diagram: "diagram",
+      dataView: "dataView",
+      aiBlock: "ai",
+      horizontalRule: "divider"
+    };
+    const kind = byNode[selection.node.type.name];
+    if (kind) return kind;
+  }
+  return "paragraph";
+}
+function getSelectionInfo(editor) {
+  const { state } = editor;
+  const { selection } = state;
+  const marks = Object.keys(editor.schema.marks).filter((name) => editor.isActive(name));
+  const location = findBlock(state);
+  const id = location && typeof location.node.attrs.id === "string" ? location.node.attrs.id : null;
+  return {
+    empty: selection.empty,
+    text: selection.empty ? "" : state.doc.textBetween(selection.from, selection.to, "\n"),
+    blockId: id,
+    marks,
+    blockKind: currentBlockKind(editor)
+  };
+}
+var TEXT_KINDS = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading1",
+  "heading2",
+  "heading3",
+  "heading4",
+  "quote",
+  "callout",
+  "bulletList",
+  "numberedList",
+  "taskList",
+  "code"
+]);
+var DOCUMENT_TYPE_KINDS = {
+  quote: "quote",
+  callout: "callout",
+  toggle: "toggle",
+  divider: "divider",
+  "bulleted-list": "bulletList",
+  "numbered-list": "numberedList",
+  "task-list": "taskList",
+  code: "code",
+  equation: "equation",
+  table: "table",
+  image: "image",
+  video: "video",
+  audio: "audio",
+  file: "file",
+  bookmark: "bookmark",
+  columns: "columns",
+  "page-break": "pageBreak",
+  "table-of-contents": "toc",
+  chart: "chart",
+  diagram: "diagram",
+  "data-view": "dataView",
+  ai: "ai",
+  paragraph: "paragraph"
+};
+function normalizeBlockKind(type, attrs = {}) {
+  if (type === "heading") {
+    const level = typeof attrs.level === "number" ? Math.min(4, Math.max(1, Math.round(attrs.level))) : 1;
+    return `heading${level}`;
+  }
+  if (Object.prototype.hasOwnProperty.call(DOCUMENT_TYPE_KINDS, type)) return DOCUMENT_TYPE_KINDS[type] ?? null;
+  return BLOCK_KINDS.includes(type) ? type : null;
+}
+var TURN_INTO_KINDS = [
+  "paragraph",
+  "heading1",
+  "heading2",
+  "heading3",
+  "heading4",
+  "quote",
+  "callout",
+  "bulletList",
+  "numberedList",
+  "taskList",
+  "code"
+];
+function isTurnIntoKind(kind) {
+  return TEXT_KINDS.has(kind);
+}
+function turnInto(editor, kind, attrs = {}) {
+  const chain = () => editor.chain().focus();
+  switch (kind) {
+    case "paragraph":
+      return chain().clearNodes().run();
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "heading4": {
+      const level = Number(kind.slice(-1));
+      return chain().clearNodes().setHeading({ level }).run();
+    }
+    case "quote":
+      return editor.isActive("blockquote") ? true : chain().clearNodes().setBlockquote().run();
+    case "callout":
+      return chain().clearNodes().setNode("callout", { variant: typeof attrs.variant === "string" ? attrs.variant : "info" }).run();
+    case "code":
+      return chain().clearNodes().setNode("codeBlock").run();
+    case "bulletList":
+      return editor.isActive("bulletList") ? true : chain().toggleBulletList().run();
+    case "numberedList":
+      return editor.isActive("orderedList") ? true : chain().toggleOrderedList().run();
+    case "taskList":
+      return editor.isActive("taskList") ? true : chain().toggleTaskList().run();
+    default:
+      return false;
+  }
+}
+function embedKindToType(kind) {
+  switch (kind) {
+    case "chart":
+      return "chart";
+    case "diagram":
+      return "diagram";
+    case "dataView":
+      return "data-view";
+    case "ai":
+      return "ai";
+    default:
+      return null;
+  }
+}
+function defaultEmbedPayload(type) {
+  switch (type) {
+    case "chart":
+      return {
+        title: "",
+        mark: "bar",
+        data: { values: [] },
+        x: { field: "x", type: "category" },
+        y: { field: "y", type: "number" },
+        a11y: { description: "" }
+      };
+    case "diagram":
+      return { engine: "mermaid", source: "graph TD\n  A[Start] --> B[Finish]" };
+    case "data-view":
+      return { dataset: "", view: { version: 1, name: "", columns: [], sort: [], filter: [] } };
+    default:
+      return { prompt: "" };
+  }
+}
+function blockTemplate(kind, attrs = {}) {
+  const text = (value) => typeof value === "string" && value !== "" ? [{ type: "text", text: value }] : [];
+  switch (kind) {
+    case "paragraph":
+      return { type: "paragraph" };
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "heading4":
+      return { type: "heading", attrs: { level: Number(kind.slice(-1)) } };
+    case "quote":
+      return { type: "blockquote", content: [{ type: "paragraph" }] };
+    case "callout":
+      return { type: "callout", attrs: { variant: typeof attrs.variant === "string" ? attrs.variant : "info" } };
+    case "toggle":
+      return { type: "toggle", content: [{ type: "toggleSummary" }, { type: "paragraph" }] };
+    case "bulletList":
+      return { type: "bulletList", content: [{ type: "listItem", content: [{ type: "paragraph" }] }] };
+    case "numberedList":
+      return { type: "orderedList", content: [{ type: "listItem", content: [{ type: "paragraph" }] }] };
+    case "taskList":
+      return { type: "taskList", content: [{ type: "taskItem", attrs: { checked: false }, content: [{ type: "paragraph" }] }] };
+    case "code":
+      return { type: "codeBlock", attrs: { language: typeof attrs.language === "string" ? attrs.language : null } };
+    case "equation":
+      return { type: "equation", content: text(attrs.latex) };
+    case "divider":
+      return { type: "horizontalRule" };
+    case "table": {
+      const rows = typeof attrs.rows === "number" ? attrs.rows : 3;
+      const columns = typeof attrs.columns === "number" ? attrs.columns : 3;
+      return {
+        type: "table",
+        attrs: { headerRow: true },
+        content: Array.from({ length: rows }, (_, row) => ({
+          type: "tableRow",
+          content: Array.from({ length: columns }, () => ({
+            type: row === 0 ? "tableHeader" : "tableCell",
+            content: [{ type: "paragraph" }]
+          }))
+        }))
+      };
+    }
+    case "image":
+      return {
+        type: "image",
+        attrs: { src: attrs.src ?? "", alt: attrs.alt ?? "", caption: attrs.caption ?? null, align: attrs.align ?? null, width: attrs.width ?? null }
+      };
+    case "video":
+    case "audio":
+      return { type: "media", attrs: { kind, src: attrs.src ?? "", caption: attrs.caption ?? null } };
+    case "file":
+      return { type: "file", attrs: { src: attrs.src ?? "", name: attrs.name ?? "", size: attrs.size ?? null } };
+    case "bookmark":
+      return { type: "bookmark", attrs: { url: attrs.url ?? "", title: attrs.title ?? null, description: attrs.description ?? null } };
+    case "columns":
+      return {
+        type: "columns",
+        content: Array.from({ length: typeof attrs.count === "number" ? Math.max(2, attrs.count) : 2 }, () => ({
+          type: "column",
+          content: [{ type: "paragraph" }]
+        }))
+      };
+    case "pageBreak":
+      return { type: "pageBreak" };
+    case "toc":
+      return { type: "tableOfContents" };
+    case "chart":
+      return { type: "chart", attrs: { spec: attrs.spec ?? defaultEmbedPayload("chart") } };
+    case "diagram": {
+      const payload = { ...defaultEmbedPayload("diagram"), ...attrs };
+      return { type: "diagram", attrs: { engine: payload.engine, diagram: payload.diagram ?? null, source: payload.source ?? null } };
+    }
+    case "dataView": {
+      const payload = { ...defaultEmbedPayload("data-view"), ...attrs };
+      return { type: "dataView", attrs: { dataset: payload.dataset, view: payload.view } };
+    }
+    case "ai":
+      return { type: "aiBlock", attrs: { prompt: typeof attrs.prompt === "string" ? attrs.prompt : "", result: attrs.result ?? null } };
+    default:
+      return null;
+  }
+}
+function updateBlockAttrs(editor, id, attrs) {
+  let target = null;
+  editor.state.doc.descendants((node, pos) => {
+    if (target === null && node.attrs.id === id) target = { pos, node };
+    return target === null;
+  });
+  const found = target;
+  if (!found) return false;
+  const { state, view } = editor;
+  view.dispatch(state.tr.setNodeMarkup(found.pos, void 0, { ...found.node.attrs, ...attrs }));
+  return true;
+}
+function isEmptyParagraph(node) {
+  return node.type.name === "paragraph" && node.content.size === 0;
+}
+function insertNode(editor, json) {
+  const { state, view } = editor;
+  let node;
+  try {
+    node = state.schema.nodeFromJSON(json);
+  } catch {
+    return null;
+  }
+  const location = findBlock(state, { items: false });
+  const tr = state.tr;
+  let start;
+  if (location && isEmptyParagraph(location.node)) {
+    start = location.pos;
+    tr.replaceWith(location.pos, location.pos + location.node.nodeSize, node);
+  } else if (location) {
+    start = location.pos + location.node.nodeSize;
+    tr.insert(start, node);
+  } else {
+    start = tr.doc.content.size;
+    tr.insert(start, node);
+  }
+  const inserted = tr.doc.nodeAt(start);
+  const parentIsDoc = location ? location.parent.type.name === "doc" : true;
+  const emptyParagraph = state.schema.nodes.paragraph;
+  if (inserted && emptyParagraph && parentIsDoc && !inserted.isTextblock && start + inserted.nodeSize === tr.doc.content.size) {
+    tr.insert(start + inserted.nodeSize, emptyParagraph.create());
+  }
+  const selectable = inserted !== null && inserted.isAtom && !inserted.isText;
+  if (selectable) tr.setSelection(NodeSelection.create(tr.doc, start));
+  else tr.setSelection(TextSelection.near(tr.doc.resolve(Math.min(start + 1, tr.doc.content.size)), 1));
+  view.dispatch(tr.scrollIntoView());
+  const placed = editor.state.doc.nodeAt(start);
+  return placed && typeof placed.attrs.id === "string" ? placed.attrs.id : null;
+}
+function applyBlockKind(editor, kind, attrs = {}) {
+  if (isTurnIntoKind(kind)) {
+    const ok = turnInto(editor, kind, attrs);
+    if (!ok) return null;
+    const location = findBlock(editor.state, { items: false });
+    return location && typeof location.node.attrs.id === "string" ? location.node.attrs.id : null;
+  }
+  const template = blockTemplate(kind, attrs);
+  return template ? insertNode(editor, template) : null;
+}
+function insertBlockKind(editor, kind, attrs = {}) {
+  if (isTurnIntoKind(kind)) {
+    const location = findBlock(editor.state, { items: false });
+    if (location && !isEmptyParagraph(location.node)) {
+      const at = location.pos + location.node.nodeSize;
+      editor.chain().insertContentAt(at, { type: "paragraph" }).setTextSelection(at + 1).run();
+    }
+  }
+  return applyBlockKind(editor, kind, attrs);
+}
+function execEditorCommand(editor, command, openBlockMenu) {
+  const chain = () => editor.chain().focus();
+  switch (command) {
+    case "undo":
+      return chain().undo().run();
+    case "redo":
+      return chain().redo().run();
+    case "bold":
+      return chain().toggleBold().run();
+    case "italic":
+      return chain().toggleItalic().run();
+    case "underline":
+      return chain().toggleUnderline().run();
+    case "strike":
+      return chain().toggleStrike().run();
+    case "code":
+      return chain().toggleCode().run();
+    case "clearMarks":
+      return chain().unsetAllMarks().run();
+    case "bulletList":
+      return chain().toggleBulletList().run();
+    case "numberedList":
+      return chain().toggleOrderedList().run();
+    case "taskList":
+      return chain().toggleTaskList().run();
+    case "indent":
+      return indent(editor, 1);
+    case "outdent":
+      return indent(editor, -1);
+    case "quote":
+      return chain().toggleBlockquote().run();
+    case "divider":
+      return chain().setHorizontalRule().run();
+    case "paragraph":
+    case "heading1":
+    case "heading2":
+    case "heading3":
+    case "heading4":
+      return turnInto(editor, command);
+    case "codeBlock":
+      return turnInto(editor, "code");
+    case "moveBlockUp":
+      return moveBlock(editor, -1).moved;
+    case "moveBlockDown":
+      return moveBlock(editor, 1).moved;
+    case "duplicateBlock":
+      return duplicateBlock(editor);
+    case "deleteBlock":
+      return deleteBlock(editor);
+    case "selectAll":
+      return chain().selectAll().run();
+    case "openBlockMenu":
+      if (openBlockMenu) {
+        openBlockMenu();
+        return true;
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function indent(editor, direction) {
+  for (const name of ["taskItem", "listItem"]) {
+    if (editor.isActive(name)) {
+      const chain = editor.chain().focus();
+      return direction > 0 ? chain.sinkListItem(name).run() : chain.liftListItem(name).run();
+    }
+  }
+  return false;
+}
+
+// src/react/internal/menu.tsx
+import {
+  useEffect as useEffect2,
+  useId,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { IconButton } from "@x12i/ui";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function MenuList({ label, items, onClose, autoFocus = true, initialId, ref }) {
+  const listRef = useRef2(null);
+  const typeahead = useRef2({ text: "", timer: void 0 });
+  const enabled = () => Array.from(listRef.current?.querySelectorAll("[role^='menuitem']:not([aria-disabled='true'])") ?? []);
+  useEffect2(() => {
+    if (!autoFocus) return;
+    const list = enabled();
+    const preferred = list.find((element) => element.dataset.id === initialId) ?? list.find((element) => element.getAttribute("aria-checked") === "true") ?? list[0];
+    preferred?.focus();
+  }, []);
+  useEffect2(() => {
+    const state = typeahead.current;
+    return () => clearTimeout(state.timer);
+  }, []);
+  const onKeyDown = (event) => {
+    const list = enabled();
+    const index = list.indexOf(document.activeElement);
+    const focusAt = (next) => {
+      event.preventDefault();
+      list[(next + list.length) % list.length]?.focus();
+    };
+    switch (event.key) {
+      case "ArrowDown":
+        focusAt(index + 1);
+        return;
+      case "ArrowUp":
+        focusAt(index === -1 ? list.length - 1 : index - 1);
+        return;
+      case "Home":
+        focusAt(0);
+        return;
+      case "End":
+        focusAt(list.length - 1);
+        return;
+      case "Escape":
+        event.preventDefault();
+        event.stopPropagation();
+        onClose("escape");
+        return;
+      case "Tab":
+        onClose("tab");
+        return;
+      default:
+        break;
+    }
+    if (event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey && event.key !== " ") {
+      const state = typeahead.current;
+      clearTimeout(state.timer);
+      state.text += event.key.toLowerCase();
+      state.timer = setTimeout(() => {
+        state.text = "";
+      }, 600);
+      const ordered = [...list.slice(index + 1), ...list.slice(0, index + 1)];
+      const match = ordered.find((element) => (element.textContent ?? "").trim().toLowerCase().startsWith(state.text));
+      match?.focus();
+    }
+  };
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: (node) => {
+        listRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      role: "menu",
+      "aria-label": label,
+      "data-kit": "editor-menu",
+      tabIndex: -1,
+      onKeyDown,
+      children: items.map((item) => {
+        const role = item.role ?? "menuitem";
+        return /* @__PURE__ */ jsxs2("div", { role: "none", "data-kit": "editor-menu-entry", children: [
+          item.heading ? /* @__PURE__ */ jsx3("div", { role: "presentation", "data-kit": "editor-menu-heading", children: item.heading }) : null,
+          /* @__PURE__ */ jsxs2(
+            "button",
+            {
+              type: "button",
+              role,
+              "data-kit": "editor-menu-item",
+              "data-id": item.id,
+              tabIndex: -1,
+              "aria-checked": role === "menuitem" ? void 0 : item.checked === true,
+              "aria-disabled": item.disabled ? true : void 0,
+              onMouseDown: (event) => event.preventDefault(),
+              onClick: () => {
+                if (item.disabled) return;
+                item.onSelect();
+                onClose("select");
+              },
+              children: [
+                item.icon ? /* @__PURE__ */ jsx3("span", { "data-kit": "editor-menu-icon", children: item.icon }) : null,
+                item.swatch ? /* @__PURE__ */ jsx3("span", { "data-kit": "editor-swatch", "data-token": item.swatch, "aria-hidden": "true" }) : null,
+                /* @__PURE__ */ jsx3("span", { "data-kit": "editor-menu-label", children: item.label }),
+                role !== "menuitem" && item.checked ? /* @__PURE__ */ jsx3(Glyph, { name: "check", "data-kit": "editor-menu-check" }) : null
+              ]
+            }
+          )
+        ] }, item.id);
+      })
+    }
+  );
+}
+function MenuButton({ label, title, menuLabel, items, children, text, disabled, pressed, onOpenChange }) {
+  const [open, setOpen] = useState2(false);
+  const wrapRef = useRef2(null);
+  const buttonRef = useRef2(null);
+  const menuId = useId();
+  const change = (next) => {
+    setOpen(next);
+    onOpenChange?.(next);
+  };
+  useEffect2(() => {
+    if (!open) return;
+    const onPointerDown = (event) => {
+      if (wrapRef.current && event.target instanceof Node && !wrapRef.current.contains(event.target)) {
+        setOpen(false);
+        onOpenChange?.(false);
+      }
+    };
+    document.addEventListener("pointerdown", onPointerDown);
+    return () => document.removeEventListener("pointerdown", onPointerDown);
+  }, [open, onOpenChange]);
+  return /* @__PURE__ */ jsxs2("span", { ref: wrapRef, "data-kit": "editor-menu-wrap", children: [
+    /* @__PURE__ */ jsxs2(
+      IconButton,
+      {
+        ref: buttonRef,
+        label,
+        title: title ?? label,
+        variant: pressed ? "soft" : "ghost",
+        tone: "neutral",
+        size: "sm",
+        disabled,
+        "data-toolbar-item": "",
+        "data-has-text": text ? "" : void 0,
+        "aria-haspopup": "menu",
+        "aria-expanded": open,
+        "aria-controls": open ? menuId : void 0,
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => change(!open),
+        onKeyDown: (event) => {
+          if (event.key === "ArrowDown" && !open) {
+            event.preventDefault();
+            change(true);
+          }
+        },
+        children: [
+          children,
+          text ? /* @__PURE__ */ jsx3("span", { "data-kit": "editor-toolbar-text", children: text }) : null
+        ]
+      }
+    ),
+    open ? /* @__PURE__ */ jsx3("div", { id: menuId, "data-kit": "editor-popup", "data-placement": "below", children: /* @__PURE__ */ jsx3(
+      MenuList,
+      {
+        label: menuLabel,
+        items,
+        onClose: (reason) => {
+          change(false);
+          if (reason === "escape" || reason === "tab") buttonRef.current?.focus();
+        }
+      }
+    ) }) : null
+  ] });
+}
+
+// src/react/internal/position.ts
+function isRtl(element) {
+  const owner = element.closest("[dir]")?.getAttribute("dir");
+  if (owner === "rtl") return true;
+  if (owner === "ltr") return false;
+  return typeof getComputedStyle === "function" && getComputedStyle(element).direction === "rtl";
+}
+function positionNear(surface, rect, edge) {
+  const box = surface.getBoundingClientRect();
+  const x = isRtl(surface) ? box.right - rect.right : rect.left - box.left;
+  const y = (edge === "top" ? rect.top : rect.bottom) - box.top;
+  return { x: Number.isFinite(x) ? Math.max(0, x) : 0, y: Number.isFinite(y) ? Math.max(0, y) : 0 };
+}
+
+// src/react/block-menu.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function BlockMenu({ editor, surfaceRef, onClose, announce }) {
+  const t = useTranslator();
+  const m = t.messages;
+  const [position2] = useState3(() => {
+    const surface = surfaceRef.current;
+    if (!surface) return { x: 0, y: 0 };
+    try {
+      return positionNear(surface, editor.view.coordsAtPos(editor.state.selection.from), "bottom");
+    } catch {
+      return { x: 0, y: 0 };
+    }
+  });
+  const current = currentBlockKind(editor);
+  const turnable = current !== null && TURN_INTO_KINDS.includes(current);
+  const items = [
+    ...turnable ? TURN_INTO_KINDS.map(
+      (kind, index) => ({
+        id: `turn-${kind}`,
+        label: m.blocks[kind].name,
+        role: "menuitemradio",
+        checked: current === kind,
+        heading: index === 0 ? m.blockMenu.turnInto : void 0,
+        onSelect: () => {
+          if (turnInto(editor, kind)) announce(t.format(m.status.blockTurnedInto, { name: m.blocks[kind].name }));
+        }
+      })
+    ) : [],
+    {
+      id: "move-up",
+      label: m.blockMenu.moveUp,
+      onSelect: () => {
+        const result = moveBlock(editor, -1);
+        announce(result.moved ? t.format(m.status.blockMoved, { position: result.position, total: result.total }) : m.status.cannotMove);
+      }
+    },
+    {
+      id: "move-down",
+      label: m.blockMenu.moveDown,
+      onSelect: () => {
+        const result = moveBlock(editor, 1);
+        announce(result.moved ? t.format(m.status.blockMoved, { position: result.position, total: result.total }) : m.status.cannotMove);
+      }
+    },
+    {
+      id: "duplicate",
+      label: m.blockMenu.duplicate,
+      onSelect: () => {
+        if (duplicateBlock(editor)) announce(m.status.blockDuplicated);
+      }
+    },
+    {
+      id: "insert-below",
+      label: m.blockMenu.insertBelow,
+      onSelect: () => {
+        const location = findBlock(editor.state, { items: false });
+        if (!location) return;
+        const at = location.pos + location.node.nodeSize;
+        editor.chain().insertContentAt(at, { type: "paragraph" }).setTextSelection(at + 1).run();
+      }
+    },
+    {
+      id: "delete",
+      label: m.blockMenu.delete,
+      onSelect: () => {
+        if (deleteBlock(editor)) announce(m.status.blockDeleted);
+      }
+    }
+  ];
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      "data-kit": "editor-popup",
+      "data-placement": "below",
+      style: { "--kit-editor-x": `${position2.x}px`, "--kit-editor-y": `${position2.y}px` },
+      children: /* @__PURE__ */ jsx4(
+        MenuList,
+        {
+          label: m.blockMenu.label,
+          items,
+          onClose: () => {
+            onClose();
+            editor.commands.focus();
+          }
+        }
+      )
+    }
+  );
+}
+
+// src/react/bubble-menu.tsx
+import { useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+import { useEditorState } from "@tiptap/react";
+
+// src/react/internal/platform.ts
+function isApplePlatform() {
+  if (typeof navigator === "undefined") return false;
+  return /Mac|iPhone|iPad|iPod/i.test(navigator.platform || navigator.userAgent || "");
+}
+function modKey() {
+  return isApplePlatform() ? "\u2318" : "Ctrl";
+}
+function shortcut(...keys) {
+  return [modKey(), ...keys].join("+");
+}
+
+// src/react/internal/roving.ts
+import { useEffect as useEffect3, useRef as useRef3 } from "react";
+var ITEM_SELECTOR = "[data-toolbar-item]:not([disabled]):not([aria-disabled='true'])";
+function itemsOf(container) {
+  return Array.from(container.querySelectorAll(ITEM_SELECTOR));
+}
+function isRtl2(container) {
+  const owner = container.closest("[dir]");
+  const value = owner?.getAttribute("dir");
+  if (value === "rtl") return true;
+  if (value === "ltr") return false;
+  return typeof getComputedStyle === "function" && getComputedStyle(container).direction === "rtl";
+}
+function useRovingToolbar(containerRef) {
+  const activeRef = useRef3(0);
+  const apply = () => {
+    const container = containerRef.current;
+    if (!container) return;
+    const items = itemsOf(container);
+    if (items.length === 0) return;
+    const index = Math.min(activeRef.current, items.length - 1);
+    activeRef.current = index;
+    items.forEach((item, position2) => {
+      item.tabIndex = position2 === index ? 0 : -1;
+    });
+  };
+  useEffect3(apply);
+  const onFocusCapture = (event) => {
+    const container = containerRef.current;
+    if (!container) return;
+    const items = itemsOf(container);
+    const index = items.indexOf(event.target);
+    if (index !== -1 && index !== activeRef.current) {
+      activeRef.current = index;
+      apply();
+    }
+  };
+  const onKeyDown = (event) => {
+    const container = containerRef.current;
+    if (!container || event.defaultPrevented) return;
+    if (event.altKey || event.ctrlKey || event.metaKey) return;
+    const target = event.target;
+    if (target.closest("[role='menu'], [role='dialog'], input, textarea")) return;
+    const items = itemsOf(container);
+    const current = items.indexOf(target.closest("[data-toolbar-item]") ?? target);
+    if (current === -1) return;
+    const rtl = isRtl2(container);
+    let wanted;
+    switch (event.key) {
+      case "ArrowRight":
+        wanted = rtl ? current - 1 : current + 1;
+        break;
+      case "ArrowLeft":
+        wanted = rtl ? current + 1 : current - 1;
+        break;
+      case "Home":
+        wanted = 0;
+        break;
+      case "End":
+        wanted = items.length - 1;
+        break;
+      default:
+        return;
+    }
+    event.preventDefault();
+    const next = (wanted + items.length) % items.length;
+    activeRef.current = next;
+    apply();
+    items[next]?.focus();
+  };
+  return { onKeyDown, onFocusCapture };
+}
+
+// src/react/internal/tool-button.tsx
+import { IconButton as IconButton2 } from "@x12i/ui";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function ToolButton({ label, keys, pressed, disabled, onClick, children }) {
+  return /* @__PURE__ */ jsx5(
+    IconButton2,
+    {
+      label,
+      title: keys ? `${label} (${keys})` : label,
+      variant: pressed ? "soft" : "ghost",
+      tone: pressed ? "accent" : "neutral",
+      size: "sm",
+      disabled,
+      "aria-pressed": pressed,
+      "data-toolbar-item": "",
+      onMouseDown: (event) => event.preventDefault(),
+      onClick,
+      children
+    }
+  );
+}
+
+// src/react/bubble-menu.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function sameMarks(a, b) {
+  return a === b || !!a && !!b && Object.keys(a).every((key) => a[key] === b[key]);
+}
+function BubbleMenu({ editor, surfaceRef, onOpenLink, onOpenAi, announce }) {
+  const t = useTranslator();
+  const m = t.messages;
+  const barRef = useRef4(null);
+  const roving = useRovingToolbar(barRef);
+  const [position2, setPosition] = useState4(null);
+  const marks = useEditorState({
+    editor,
+    selector: ({ editor: current }) => current ? {
+      bold: current.isActive("bold"),
+      italic: current.isActive("italic"),
+      underline: current.isActive("underline"),
+      strike: current.isActive("strike"),
+      code: current.isActive("code"),
+      link: current.isActive("link")
+    } : null,
+    equalityFn: sameMarks
+  });
+  useEffect4(() => {
+    let timer;
+    const update = () => {
+      const surface = surfaceRef.current;
+      const { selection } = editor.state;
+      const focusInside = editor.view.hasFocus() || (barRef.current?.contains(document.activeElement) ?? false);
+      const show = surface !== null && editor.isEditable && focusInside && selection instanceof TextSelection2 && !selection.empty && !selection.$from.parent.type.spec.code;
+      if (!show) {
+        setPosition(null);
+        return;
+      }
+      try {
+        const rect = editor.view.coordsAtPos(selection.from);
+        setPosition(positionNear(surface, rect, "top"));
+      } catch {
+        setPosition({ x: 0, y: 0 });
+      }
+    };
+    const delayed = () => {
+      clearTimeout(timer);
+      timer = setTimeout(update, 0);
+    };
+    editor.on("selectionUpdate", update);
+    editor.on("focus", update);
+    editor.on("blur", delayed);
+    return () => {
+      clearTimeout(timer);
+      editor.off("selectionUpdate", update);
+      editor.off("focus", update);
+      editor.off("blur", delayed);
+    };
+  }, [editor, surfaceRef]);
+  if (!position2 || !marks) return null;
+  const toggle = (command, name, active) => () => {
+    execEditorCommand(editor, command);
+    announce(t.format(active ? m.status.markOff : m.status.markOn, { name }));
+  };
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ref: barRef,
+      role: "toolbar",
+      "aria-label": m.toolbar.selectionMenu,
+      "data-kit": "editor-bubble",
+      style: { "--kit-editor-x": `${position2.x}px`, "--kit-editor-y": `${position2.y}px` },
+      onFocusCapture: roving.onFocusCapture,
+      onKeyDown: (event) => {
+        if (event.key === "Escape") {
+          event.preventDefault();
+          editor.commands.focus();
+          return;
+        }
+        roving.onKeyDown(event);
+      },
+      children: [
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.bold, keys: shortcut("B"), pressed: marks.bold, onClick: toggle("bold", m.toolbar.bold, marks.bold), children: /* @__PURE__ */ jsx6(Glyph, { name: "bold" }) }),
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.italic, keys: shortcut("I"), pressed: marks.italic, onClick: toggle("italic", m.toolbar.italic, marks.italic), children: /* @__PURE__ */ jsx6(Glyph, { name: "italic" }) }),
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.underline, keys: shortcut("U"), pressed: marks.underline, onClick: toggle("underline", m.toolbar.underline, marks.underline), children: /* @__PURE__ */ jsx6(Glyph, { name: "underline" }) }),
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.strike, keys: shortcut("Shift", "S"), pressed: marks.strike, onClick: toggle("strike", m.toolbar.strike, marks.strike), children: /* @__PURE__ */ jsx6(Glyph, { name: "strike" }) }),
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.code, keys: shortcut("E"), pressed: marks.code, onClick: toggle("code", m.toolbar.code, marks.code), children: /* @__PURE__ */ jsx6(Glyph, { name: "code" }) }),
+        /* @__PURE__ */ jsx6(ToolButton, { label: m.toolbar.link, keys: shortcut("K"), pressed: marks.link, onClick: onOpenLink, children: /* @__PURE__ */ jsx6(Glyph, { name: "link" }) }),
+        onOpenAi ? /* @__PURE__ */ jsx6(ToolButton, { label: m.ai.menuLabel, onClick: onOpenAi, children: /* @__PURE__ */ jsx6(Glyph, { name: "sparkle" }) }) : null
+      ]
+    }
+  );
+}
+
+// src/react/context.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var noop = () => void 0;
+var defaultEditorUi = {
+  editable: false,
+  blockRenderers: {},
+  announce: noop,
+  onEditBlock: void 0,
+  onRequestBlock: void 0,
+  openImageDialog: noop,
+  openLinkDialog: noop,
+  openBlockMenu: noop
+};
+var EditorUiContext = createContext2(defaultEditorUi);
+function useEditorUi() {
+  return useContext2(EditorUiContext);
+}
+var EngineContext = createContext2(null);
+
+// src/react/extensions/index.ts
+import { Extension as Extension4 } from "@tiptap/core";
+import Placeholder from "@tiptap/extension-placeholder";
+import { TaskItem } from "@tiptap/extension-task-item";
+import { TaskList } from "@tiptap/extension-task-list";
+import StarterKit from "@tiptap/starter-kit";
+
+// src/react/extensions/block-id.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+var blockIdKey = new PluginKey("kitBlockId");
+var BLOCK_CONTAINERS = /* @__PURE__ */ new Set(["doc", "toggle", "column"]);
+var ITEM_NODES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LIST_NODES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+var BlockId = Extension.create({
+  name: "blockId",
+  addGlobalAttributes() {
+    return [
+      {
+        types: [...BLOCK_ID_NODES],
+        attributes: {
+          id: {
+            default: null,
+            keepOnSplit: false,
+            parseHTML: (element) => element.getAttribute("data-block-id"),
+            renderHTML: (attributes) => typeof attributes.id === "string" && attributes.id !== "" ? { "data-block-id": attributes.id } : {}
+          }
+        }
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: blockIdKey,
+        appendTransaction: (transactions, _oldState, newState) => {
+          if (!transactions.some((transaction) => transaction.docChanged)) return null;
+          const seen = /* @__PURE__ */ new Set();
+          const fixes = [];
+          newState.doc.descendants((node, pos, parent) => {
+            const name = node.type.name;
+            if (!BLOCK_ID_NODES.includes(name) || parent === null) return;
+            const parentName = parent.type.name;
+            const carriesId = ITEM_NODES.has(name) ? LIST_NODES.has(parentName) : BLOCK_CONTAINERS.has(parentName) && !(LIST_NODES.has(name) && ITEM_NODES.has(parentName));
+            if (!carriesId) return;
+            const current = node.attrs.id;
+            if (typeof current === "string" && current !== "" && !seen.has(current)) {
+              seen.add(current);
+              return;
+            }
+            let id = generateBlockId();
+            while (seen.has(id)) id = generateBlockId();
+            seen.add(id);
+            fixes.push({ pos, attrs: { ...node.attrs, id } });
+          });
+          if (fixes.length === 0) return null;
+          const tr = newState.tr;
+          for (const fix of fixes) tr.setNodeMarkup(fix.pos, void 0, fix.attrs);
+          tr.setMeta("addToHistory", false);
+          return tr;
+        }
+      })
+    ];
+  }
+});
+
+// src/react/extensions/block-keys.ts
+import { Extension as Extension2 } from "@tiptap/core";
+import { NodeSelection as NodeSelection2 } from "@tiptap/pm/state";
+
+// src/react/extensions/attrs.ts
+function jsonAttribute(name, fallback = null) {
+  const dataName = `data-${name}`;
+  return {
+    default: fallback,
+    parseHTML: (element) => {
+      const raw = element.getAttribute(dataName);
+      if (raw === null || raw === "") return fallback;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return fallback;
+      }
+    },
+    renderHTML: (attributes) => {
+      const value = attributes[name];
+      return value === null || value === void 0 ? {} : { [dataName]: JSON.stringify(value) };
+    }
+  };
+}
+function dataAttribute(name, fallback = null, parse) {
+  const dataName = `data-${name}`;
+  return {
+    default: fallback,
+    parseHTML: (element) => {
+      const raw = element.getAttribute(dataName);
+      if (raw === null) return fallback;
+      return parse ? parse(raw) : raw;
+    },
+    renderHTML: (attributes) => {
+      const value = attributes[name];
+      return value === null || value === void 0 || value === "" ? {} : { [dataName]: String(value) };
+    }
+  };
+}
+var EMBED_NODE_NAMES = {
+  chart: "chart",
+  diagram: "diagram",
+  "data-view": "dataView",
+  ai: "aiBlock"
+};
+function embedTypeOfNode(name) {
+  for (const [type, nodeName] of Object.entries(EMBED_NODE_NAMES)) if (nodeName === name) return type;
+  return null;
+}
+function attrsToPayload(type, attrs) {
+  switch (type) {
+    case "chart":
+      return attrs.spec ?? {};
+    case "diagram": {
+      const payload = { engine: attrs.engine ?? "mermaid" };
+      if (attrs.diagram !== null && attrs.diagram !== void 0) payload.diagram = attrs.diagram;
+      if (typeof attrs.source === "string") payload.source = attrs.source;
+      return payload;
+    }
+    case "data-view":
+      return { dataset: typeof attrs.dataset === "string" ? attrs.dataset : "", view: attrs.view ?? {} };
+    default: {
+      const payload = { prompt: typeof attrs.prompt === "string" ? attrs.prompt : "" };
+      if (attrs.result !== null && attrs.result !== void 0) payload.result = attrs.result;
+      return payload;
+    }
+  }
+}
+function payloadToAttrs(type, payload) {
+  const value = payload;
+  switch (type) {
+    case "chart":
+      return { spec: payload };
+    case "diagram":
+      return { engine: value.engine ?? "mermaid", diagram: value.diagram ?? null, source: value.source ?? null };
+    case "data-view":
+      return { dataset: value.dataset ?? "", view: value.view ?? null };
+    default:
+      return { prompt: value.prompt ?? "", result: value.result ?? null };
+  }
+}
+function payloadTitle(type, payload) {
+  const value = payload ?? {};
+  const text = (candidate) => typeof candidate === "string" ? candidate.trim() : "";
+  switch (type) {
+    case "chart":
+      return text(value.title);
+    case "diagram": {
+      const diagram = value.diagram;
+      return text(diagram?.title) || text(diagram?.name);
+    }
+    case "data-view": {
+      const view = value.view;
+      return text(view?.name) || text(value.dataset);
+    }
+    default:
+      return text(value.prompt).slice(0, 80);
+  }
+}
+
+// src/react/extensions/block-keys.ts
+var BlockKeys = Extension2.create({
+  name: "blockKeys",
+  addOptions() {
+    return { runtime: null };
+  },
+  addKeyboardShortcuts() {
+    const runtime = this.options.runtime;
+    if (!runtime) return {};
+    const move = (direction) => () => {
+      const ui = runtime.ui();
+      if (!ui.editable) return false;
+      const result = moveBlock(this.editor, direction);
+      const t = runtime.translator();
+      if (result.total > 0) {
+        ui.announce(
+          result.moved ? t.format(t.messages.status.blockMoved, { position: result.position, total: result.total }) : t.messages.status.cannotMove
+        );
+      }
+      return true;
+    };
+    return {
+      "Alt-Shift-ArrowUp": move(-1),
+      "Alt-Shift-ArrowDown": move(1),
+      "Mod-/": () => {
+        const ui = runtime.ui();
+        if (!ui.editable) return false;
+        ui.openBlockMenu();
+        return true;
+      },
+      "Mod-k": () => {
+        const ui = runtime.ui();
+        if (!ui.editable) return false;
+        ui.openLinkDialog();
+        return true;
+      },
+      Enter: () => {
+        const ui = runtime.ui();
+        const { selection } = this.editor.state;
+        if (!ui.editable || !(selection instanceof NodeSelection2)) return false;
+        const type = embedTypeOfNode(selection.node.type.name);
+        const handler = ui.onEditBlock;
+        const id = selection.node.attrs.id;
+        if (!type || !handler || typeof id !== "string") return false;
+        const payload = attrsToPayload(type, selection.node.attrs);
+        void Promise.resolve(handler(type, payload)).then((next) => {
+          if (next === null || next === void 0) return;
+          updateBlockAttrs(this.editor, id, payloadToAttrs(type, next));
+          this.editor.commands.focus();
+        });
+        return true;
+      }
+    };
+  }
+});
+
+// src/react/extensions/marks.ts
+import { mergeAttributes, Mark } from "@tiptap/core";
+import Highlight from "@tiptap/extension-highlight";
+function tokenAttribute(isAllowed, fallback) {
+  return {
+    token: {
+      default: fallback,
+      parseHTML: (element) => {
+        const token = element.getAttribute("data-token");
+        return isAllowed(token) ? token : fallback;
+      },
+      renderHTML: (attributes) => isAllowed(attributes.token) ? { "data-token": attributes.token } : {}
+    }
+  };
+}
+var TextColor = Mark.create({
+  name: "color",
+  addAttributes() {
+    return tokenAttribute(isTextColorToken, null);
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-kit="editor-text-color"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes({ "data-kit": "editor-text-color" }, HTMLAttributes), 0];
+  }
+});
+var KitHighlight = Highlight.extend({
+  addAttributes() {
+    return tokenAttribute(isHighlightToken, "color.highlight");
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["mark", mergeAttributes({ "data-kit": "editor-highlight" }, HTMLAttributes), 0];
+  }
+});
+
+// src/react/extensions/nodes.ts
+import { InputRule, mergeAttributes as mergeAttributes2, Node as Node2, textblockTypeInputRule } from "@tiptap/core";
+import Image from "@tiptap/extension-image";
+import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+import { ReactNodeViewRenderer } from "@tiptap/react";
+
+// src/react/blocks/embed.tsx
+import { createElement as createElement2 } from "react";
+
+// src/react/blocks/frame.tsx
+import { useRef as useRef5 } from "react";
+import { NodeViewWrapper } from "@tiptap/react";
+import { IconButton as IconButton3 } from "@x12i/ui";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function AtomFrame({ view, label, kind, children, onEdit, editLabel }) {
+  const { editor, getPos, selected } = view;
+  const ui = useEditorUi();
+  const t = useTranslator();
+  const m = t.messages;
+  const toolbarRef = useRef5(null);
+  const roving = useRovingToolbar(toolbarRef);
+  const position2 = () => {
+    const pos = getPos();
+    return typeof pos === "number" ? pos : void 0;
+  };
+  const move = (direction) => {
+    const pos = position2();
+    if (pos === void 0) return;
+    const result = moveBlock(editor, direction, pos);
+    ui.announce(
+      result.moved ? t.format(m.status.blockMoved, { position: result.position, total: result.total }) : m.status.cannotMove
+    );
+    editor.commands.focus();
+  };
+  const remove = () => {
+    const pos = position2();
+    if (pos === void 0) return;
+    if (deleteBlock(editor, pos)) ui.announce(m.status.blockDeleted);
+    editor.commands.focus();
+  };
+  const showTools = ui.editable && selected;
+  return /* @__PURE__ */ jsxs4(
+    NodeViewWrapper,
+    {
+      "data-kit": "editor-frame",
+      "data-block": kind,
+      "data-selected": selected ? "" : void 0,
+      role: "group",
+      "aria-label": label,
+      children: [
+        /* @__PURE__ */ jsx7("div", { "data-kit": "editor-frame-body", children }),
+        showTools ? /* @__PURE__ */ jsxs4(
+          "div",
+          {
+            ref: toolbarRef,
+            role: "toolbar",
+            "aria-label": m.embed.toolbar,
+            "data-kit": "editor-frame-toolbar",
+            contentEditable: false,
+            ...roving,
+            children: [
+              onEdit ? /* @__PURE__ */ jsx7(IconButton3, { label: editLabel ?? m.embed.edit, title: editLabel ?? m.embed.edit, variant: "ghost", tone: "neutral", size: "sm", "data-toolbar-item": "", onClick: onEdit, children: /* @__PURE__ */ jsx7(Glyph, { name: "edit" }) }) : null,
+              /* @__PURE__ */ jsx7(IconButton3, { label: m.embed.moveUp, title: m.embed.moveUp, variant: "ghost", tone: "neutral", size: "sm", "data-toolbar-item": "", onClick: () => move(-1), children: /* @__PURE__ */ jsx7(Glyph, { name: "up" }) }),
+              /* @__PURE__ */ jsx7(IconButton3, { label: m.embed.moveDown, title: m.embed.moveDown, variant: "ghost", tone: "neutral", size: "sm", "data-toolbar-item": "", onClick: () => move(1), children: /* @__PURE__ */ jsx7(Glyph, { name: "down" }) }),
+              /* @__PURE__ */ jsx7(IconButton3, { label: m.embed.remove, title: m.embed.remove, variant: "ghost", tone: "neutral", size: "sm", "data-toolbar-item": "", onClick: remove, children: /* @__PURE__ */ jsx7(Glyph, { name: "trash" }) })
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/react/blocks/preview.tsx
+import { Component, createElement, useMemo } from "react";
+import { Badge } from "@x12i/ui";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var EMBED_KIND = {
+  chart: "chart",
+  diagram: "diagram",
+  "data-view": "dataView",
+  ai: "ai"
+};
+var MAX_JSON_LENGTH = 4e3;
+function stringify(value) {
+  try {
+    const text = JSON.stringify(value, null, 2) ?? "";
+    return text.length > MAX_JSON_LENGTH ? `${text.slice(0, MAX_JSON_LENGTH)}
+\u2026` : text;
+  } catch {
+    return "";
+  }
+}
+function facts(payload) {
+  if (typeof payload !== "object" || payload === null) return [];
+  const out = [];
+  for (const [key, value] of Object.entries(payload)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      const text = String(value);
+      if (text !== "" && key !== "source") out.push([key, text.length > 120 ? `${text.slice(0, 120)}\u2026` : text]);
+    } else if (Array.isArray(value)) {
+      out.push([key, String(value.length)]);
+    }
+    if (out.length >= 6) break;
+  }
+  return out;
+}
+function describe(type, payload) {
+  const value = payload ?? {};
+  if (type === "chart") {
+    const a11y = value.a11y;
+    return typeof a11y?.description === "string" ? a11y.description : "";
+  }
+  if (type === "diagram") return typeof value.source === "string" ? value.source.split("\n").slice(0, 4).join("\n") : "";
+  if (type === "ai") return typeof value.prompt === "string" ? value.prompt : "";
+  return "";
+}
+function EmbedPreview({ type, payload, title }) {
+  const m = useMessages();
+  const json = useMemo(() => stringify(payload), [payload]);
+  const summary = useMemo(() => facts(payload), [payload]);
+  const description = describe(type, payload);
+  return /* @__PURE__ */ jsxs5("div", { "data-kit": "editor-embed-card", "data-embed": type, children: [
+    /* @__PURE__ */ jsxs5("div", { "data-kit": "editor-embed-head", children: [
+      /* @__PURE__ */ jsx8(Badge, { tone: "accent", size: "sm", children: m.blocks[EMBED_KIND[type]].name }),
+      /* @__PURE__ */ jsx8("strong", { "data-kit": "editor-embed-title", children: title || m.embed.untitled })
+    ] }),
+    description ? /* @__PURE__ */ jsx8("p", { "data-kit": "editor-embed-description", children: description }) : null,
+    summary.length > 0 ? /* @__PURE__ */ jsx8("dl", { "data-kit": "editor-embed-facts", children: summary.map(([key, value]) => /* @__PURE__ */ jsxs5("div", { "data-kit": "editor-embed-fact", children: [
+      /* @__PURE__ */ jsx8("dt", { children: key }),
+      /* @__PURE__ */ jsx8("dd", { children: value })
+    ] }, key)) }) : null,
+    /* @__PURE__ */ jsxs5("details", { "data-kit": "editor-embed-data", children: [
+      /* @__PURE__ */ jsx8("summary", { children: m.embed.showData }),
+      /* @__PURE__ */ jsx8("pre", { tabIndex: 0, children: /* @__PURE__ */ jsx8("code", { children: json }) })
+    ] }),
+    /* @__PURE__ */ jsx8("p", { "data-kit": "editor-embed-hint", children: m.embed.previewHint })
+  ] });
+}
+var RendererBoundary = class extends Component {
+  state = { failed: false };
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  render() {
+    return this.state.failed ? this.props.fallback : this.props.children;
+  }
+};
+function EmbedBody({ type, id, payload, selected = false }) {
+  const ui = useEditorUi();
+  const title = payloadTitle(type, payload);
+  const fallback = /* @__PURE__ */ jsx8(EmbedPreview, { type, payload, title });
+  const renderer = ui.blockRenderers[type];
+  if (!renderer) return fallback;
+  return /* @__PURE__ */ jsx8(RendererBoundary, { fallback, children: createElement(renderer, { type, id, payload, title, editable: ui.editable, selected }) });
+}
+function embedFromAttrs(type, attrs) {
+  const payload = attrsToPayload(type, attrs);
+  return { payload, title: payloadTitle(type, payload) };
+}
+
+// src/react/blocks/unknown-preview.tsx
+import { Badge as Badge2 } from "@x12i/ui";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+function UnknownPreview({ blockType, payload }) {
+  const m = useMessages();
+  let json;
+  try {
+    json = JSON.stringify(payload, null, 2) ?? "";
+  } catch {
+    json = "";
+  }
+  return /* @__PURE__ */ jsxs6("div", { "data-kit": "editor-embed-card", "data-embed": "unknown", children: [
+    /* @__PURE__ */ jsx9("div", { "data-kit": "editor-embed-head", children: /* @__PURE__ */ jsx9(Badge2, { tone: "warning", size: "sm", children: blockType }) }),
+    /* @__PURE__ */ jsx9("p", { "data-kit": "editor-embed-hint", children: m.embed.unknown }),
+    /* @__PURE__ */ jsxs6("details", { "data-kit": "editor-embed-data", children: [
+      /* @__PURE__ */ jsx9("summary", { children: m.embed.showData }),
+      /* @__PURE__ */ jsx9("pre", { tabIndex: 0, children: /* @__PURE__ */ jsx9("code", { children: json.length > 4e3 ? `${json.slice(0, 4e3)}
+\u2026` : json }) })
+    ] })
+  ] });
+}
+
+// src/react/blocks/embed.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function EmbedView({ view, type }) {
+  const ui = useEditorUi();
+  const t = useTranslator();
+  const attrs = view.node.attrs;
+  const { payload, title } = embedFromAttrs(type, attrs);
+  const id = typeof attrs.id === "string" ? attrs.id : "";
+  const kindName = t.messages.blocks[EMBED_KIND[type]].name;
+  const label = t.format(t.messages.embed.groupLabel, { type: kindName, title: title || t.messages.embed.untitled });
+  const onEdit = ui.editable && ui.onEditBlock ? () => {
+    const handler = ui.onEditBlock;
+    if (!handler) return;
+    void Promise.resolve(handler(type, payload)).then((next) => {
+      if (next === null || next === void 0) return;
+      view.updateAttributes(payloadToAttrs(type, next));
+      view.editor.commands.focus();
+    });
+  } : void 0;
+  return /* @__PURE__ */ jsx10(AtomFrame, { view, kind: type, label, onEdit, children: /* @__PURE__ */ jsx10(EmbedBody, { type, id, payload, selected: view.selected }) });
+}
+function make(type) {
+  return function EmbedNodeView(view) {
+    return createElement2(EmbedView, { view, type });
+  };
+}
+var ChartView = make("chart");
+var DiagramView = make("diagram");
+var DataViewView = make("data-view");
+var AiBlockView = make("ai");
+function UnknownBlockView(view) {
+  const ui = useEditorUi();
+  const t = useTranslator();
+  const attrs = view.node.attrs;
+  const blockType = typeof attrs.blockType === "string" ? attrs.blockType : "unknown";
+  const payload = typeof attrs.payload === "object" && attrs.payload !== null ? attrs.payload : {};
+  const id = typeof attrs.id === "string" ? attrs.id : "";
+  const custom = ui.blockRenderers.unknown;
+  return /* @__PURE__ */ jsx10(AtomFrame, { view, kind: "unknown", label: `${t.messages.embed.unknown} ${blockType}`, children: custom ? createElement2(custom, {
+    id,
+    blockType,
+    payload,
+    editable: ui.editable
+  }) : /* @__PURE__ */ jsx10(UnknownPreview, { blockType, payload }) });
+}
+
+// src/react/blocks/media.tsx
+import { useId as useId2, useState as useState5 } from "react";
+import { Button as Button2 } from "@x12i/ui";
+
+// src/react/internal/inline.tsx
+import { Fragment as Fragment2 } from "react";
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var APPLY_ORDER = ["code", "strike", "underline", "italic", "bold", "highlight", "color", "link"];
+function wrap(children, mark, key) {
+  switch (mark.type) {
+    case "bold":
+      return /* @__PURE__ */ jsx11("strong", { children }, key);
+    case "italic":
+      return /* @__PURE__ */ jsx11("em", { children }, key);
+    case "underline":
+      return /* @__PURE__ */ jsx11("u", { children }, key);
+    case "strike":
+      return /* @__PURE__ */ jsx11("s", { children }, key);
+    case "code":
+      return /* @__PURE__ */ jsx11("code", { children }, key);
+    case "link": {
+      const href = sanitizeUrl(mark.href);
+      return href === null ? /* @__PURE__ */ jsx11(Fragment2, { children }, key) : /* @__PURE__ */ jsx11("a", { href, rel: "noopener noreferrer", children }, key);
+    }
+    case "color":
+      return isTextColorToken(mark.token) ? /* @__PURE__ */ jsx11("span", { "data-kit": "editor-text-color", "data-token": mark.token, children }, key) : /* @__PURE__ */ jsx11(Fragment2, { children }, key);
+    case "highlight":
+      return isHighlightToken(mark.token) ? /* @__PURE__ */ jsx11("mark", { "data-kit": "editor-highlight", "data-token": mark.token, children }, key) : /* @__PURE__ */ jsx11(Fragment2, { children }, key);
+    default:
+      return children;
+  }
+}
+function renderNode(node, key) {
+  switch (node.type) {
+    case "text": {
+      const lines = node.text.split("\n");
+      let content = lines.map((line, index) => /* @__PURE__ */ jsxs7(Fragment2, { children: [
+        index > 0 ? /* @__PURE__ */ jsx11("br", {}) : null,
+        line
+      ] }, index));
+      const marks = node.marks ?? [];
+      for (const type of APPLY_ORDER) {
+        for (const mark of marks) if (mark.type === type) content = wrap(content, mark, `${key}-${type}`);
+      }
+      return /* @__PURE__ */ jsx11(Fragment2, { children: content }, key);
+    }
+    case "mention":
+      return /* @__PURE__ */ jsxs7("span", { "data-kit": "editor-mention", "data-kind": node.kind, children: [
+        node.kind === "person" ? "@" : "",
+        node.label
+      ] }, key);
+    case "emoji": {
+      const char = emojiForShortcode(node.shortcode);
+      return char === null ? /* @__PURE__ */ jsx11(Fragment2, { children: `:${node.shortcode}:` }, key) : /* @__PURE__ */ jsx11("span", { "data-kit": "editor-emoji", role: "img", "aria-label": node.shortcode.replace(/[_-]+/g, " "), children: char }, key);
+    }
+    default:
+      return null;
+  }
+}
+function InlineContent({ inline }) {
+  return /* @__PURE__ */ jsx11(Fragment3, { children: (inline ?? []).map((node, index) => renderNode(node, String(index))) });
+}
+
+// src/react/blocks/media.tsx
+import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+function asInline(value) {
+  return Array.isArray(value) && value.length > 0 ? value : null;
+}
+function position(view) {
+  const pos = view.getPos();
+  return typeof pos === "number" ? pos : void 0;
+}
+function UrlForm({
+  fields,
+  onSubmit
+}) {
+  const t = useTranslator();
+  const idBase = useId2();
+  const [values, setValues] = useState5({});
+  const [error, setError] = useState5(null);
+  const submit = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    setError(onSubmit(values));
+  };
+  return /* @__PURE__ */ jsxs8("form", { "data-kit": "editor-url-form", onSubmit: submit, noValidate: true, children: [
+    fields.map((field, index) => /* @__PURE__ */ jsxs8("label", { "data-kit": "editor-field", children: [
+      /* @__PURE__ */ jsx12("span", { "data-kit": "editor-field-label", children: field.label }),
+      /* @__PURE__ */ jsx12(
+        "input",
+        {
+          id: `${idBase}-${field.name}`,
+          "data-kit": "editor-input",
+          type: "text",
+          inputMode: index === 0 ? "url" : "text",
+          value: values[field.name] ?? "",
+          required: field.required,
+          "aria-invalid": error !== null && index === 0 ? true : void 0,
+          "aria-describedby": error !== null && index === 0 ? `${idBase}-error` : void 0,
+          onChange: (event) => setValues((previous) => ({ ...previous, [field.name]: event.target.value }))
+        }
+      )
+    ] }, field.name)),
+    /* @__PURE__ */ jsx12(Button2, { type: "submit", size: "sm", variant: "soft", tone: "accent", children: t.messages.media.set }),
+    error ? /* @__PURE__ */ jsx12("p", { id: `${idBase}-error`, role: "alert", "data-kit": "editor-error", children: error }) : null
+  ] });
+}
+function ImageView(view) {
+  const ui = useEditorUi();
+  const m = useTranslator().messages;
+  const attrs = view.node.attrs;
+  const src = sanitizeMediaUrl(attrs.src);
+  const alt = typeof attrs.alt === "string" ? attrs.alt : "";
+  const caption = asInline(attrs.caption);
+  const align = attrs.align === "start" || attrs.align === "center" || attrs.align === "end" ? attrs.align : void 0;
+  const width = typeof attrs.width === "number" && attrs.width > 0 ? attrs.width : void 0;
+  const pos = position(view);
+  return /* @__PURE__ */ jsx12(
+    AtomFrame,
+    {
+      view,
+      kind: "image",
+      label: alt || m.media.imageDecorative,
+      onEdit: ui.editable ? () => ui.openImageDialog(pos) : void 0,
+      editLabel: m.media.imageEdit,
+      children: /* @__PURE__ */ jsxs8("figure", { "data-kit": "editor-image", "data-align": align, children: [
+        src ? /* @__PURE__ */ jsx12("img", { src, alt, style: width ? { inlineSize: width } : void 0 }) : /* @__PURE__ */ jsx12("p", { "data-kit": "editor-error", children: m.media.unsafe }),
+        caption ? /* @__PURE__ */ jsx12("figcaption", { dir: "auto", children: /* @__PURE__ */ jsx12(InlineContent, { inline: caption }) }) : null
+      ] })
+    }
+  );
+}
+function MediaView(view) {
+  const ui = useEditorUi();
+  const m = useTranslator().messages;
+  const attrs = view.node.attrs;
+  const kind = attrs.kind === "audio" ? "audio" : "video";
+  const rawSrc = typeof attrs.src === "string" ? attrs.src : "";
+  const src = rawSrc === "" ? null : sanitizeMediaUrl(rawSrc);
+  const caption = asInline(attrs.caption);
+  const name = kind === "audio" ? m.media.audio : m.media.video;
+  return /* @__PURE__ */ jsx12(AtomFrame, { view, kind, label: name, children: /* @__PURE__ */ jsxs8("figure", { "data-kit": "editor-media", "data-kind": kind, children: [
+    src ? kind === "audio" ? /* @__PURE__ */ jsx12("audio", { controls: true, src, "aria-label": name }) : /* @__PURE__ */ jsx12("video", { controls: true, src, "aria-label": name }) : ui.editable && rawSrc === "" ? /* @__PURE__ */ jsx12(
+      UrlForm,
+      {
+        fields: [{ name: "src", label: m.media.urlLabel, required: true }],
+        onSubmit: (values) => {
+          const next = sanitizeMediaUrl(normalizeUrlInput(values.src ?? ""));
+          if (next === null) return m.media.unsafe;
+          view.updateAttributes({ src: next });
+          return null;
+        }
+      }
+    ) : /* @__PURE__ */ jsx12("p", { "data-kit": "editor-error", children: m.media.unsafe }),
+    caption ? /* @__PURE__ */ jsx12("figcaption", { dir: "auto", children: /* @__PURE__ */ jsx12(InlineContent, { inline: caption }) }) : null
+  ] }) });
+}
+function formatSize(bytes, locale) {
+  const units = [
+    [1024 ** 3, "gigabyte"],
+    [1024 ** 2, "megabyte"],
+    [1024, "kilobyte"]
+  ];
+  const [factor, unit] = units.find(([size]) => bytes >= size) ?? [1, "byte"];
+  try {
+    return new Intl.NumberFormat(locale, { style: "unit", unit, unitDisplay: "narrow", maximumFractionDigits: 1 }).format(bytes / factor);
+  } catch {
+    return String(bytes);
+  }
+}
+function FileView(view) {
+  const ui = useEditorUi();
+  const t = useTranslator();
+  const m = t.messages;
+  const attrs = view.node.attrs;
+  const rawSrc = typeof attrs.src === "string" ? attrs.src : "";
+  const href = rawSrc === "" ? null : sanitizeUrl(rawSrc);
+  const name = typeof attrs.name === "string" && attrs.name !== "" ? attrs.name : m.media.file;
+  const size = typeof attrs.size === "number" && attrs.size >= 0 ? attrs.size : null;
+  return /* @__PURE__ */ jsx12(AtomFrame, { view, kind: "file", label: name, children: href ? /* @__PURE__ */ jsxs8("a", { "data-kit": "editor-file", href, download: name, rel: "noopener noreferrer", "aria-label": t.format(m.media.download, { name }), children: [
+    /* @__PURE__ */ jsx12(Glyph, { name: "file" }),
+    /* @__PURE__ */ jsx12("span", { "data-kit": "editor-file-name", dir: "auto", children: name }),
+    size !== null ? /* @__PURE__ */ jsx12("span", { "data-kit": "editor-file-size", children: formatSize(size, t.locale) }) : null
+  ] }) : ui.editable && rawSrc === "" ? /* @__PURE__ */ jsx12(
+    UrlForm,
+    {
+      fields: [
+        { name: "src", label: m.media.urlLabel, required: true },
+        { name: "name", label: m.media.nameLabel }
+      ],
+      onSubmit: (values) => {
+        const next = sanitizeUrl(normalizeUrlInput(values.src ?? ""));
+        if (next === null) return m.media.unsafe;
+        view.updateAttributes({ src: next, name: (values.name ?? "").trim() || next });
+        return null;
+      }
+    }
+  ) : /* @__PURE__ */ jsx12("p", { "data-kit": "editor-error", children: m.media.unsafe }) });
+}
+function BookmarkView(view) {
+  const ui = useEditorUi();
+  const t = useTranslator();
+  const m = t.messages;
+  const attrs = view.node.attrs;
+  const rawUrl = typeof attrs.url === "string" ? attrs.url : "";
+  const href = rawUrl === "" ? null : sanitizeUrl(rawUrl);
+  const title = typeof attrs.title === "string" && attrs.title !== "" ? attrs.title : rawUrl;
+  const description = typeof attrs.description === "string" ? attrs.description : "";
+  let host = "";
+  if (href) {
+    try {
+      host = new URL(href).host;
+    } catch {
+      host = "";
+    }
+  }
+  return /* @__PURE__ */ jsx12(AtomFrame, { view, kind: "bookmark", label: title || m.media.bookmark, children: href ? /* @__PURE__ */ jsxs8("a", { "data-kit": "editor-bookmark", href, rel: "noopener noreferrer", "aria-label": t.format(m.media.open, { title }), children: [
+    /* @__PURE__ */ jsx12(Glyph, { name: "bookmark" }),
+    /* @__PURE__ */ jsxs8("span", { "data-kit": "editor-bookmark-text", children: [
+      /* @__PURE__ */ jsx12("strong", { dir: "auto", children: title }),
+      description ? /* @__PURE__ */ jsx12("span", { dir: "auto", children: description }) : null,
+      host ? /* @__PURE__ */ jsx12("small", { children: host }) : null
+    ] })
+  ] }) : ui.editable && rawUrl === "" ? /* @__PURE__ */ jsx12(
+    UrlForm,
+    {
+      fields: [
+        { name: "url", label: m.media.urlLabel, required: true },
+        { name: "title", label: m.media.nameLabel }
+      ],
+      onSubmit: (values) => {
+        const next = sanitizeUrl(normalizeUrlInput(values.url ?? ""));
+        if (next === null) return m.media.unsafe;
+        const label = (values.title ?? "").trim();
+        view.updateAttributes({ url: next, title: label === "" ? null : label });
+        return null;
+      }
+    }
+  ) : /* @__PURE__ */ jsx12("p", { "data-kit": "editor-error", children: m.media.unsafe }) });
+}
+
+// src/react/blocks/text.tsx
+import { useEffect as useEffect5, useRef as useRef6, useState as useState6 } from "react";
+import { NodeViewContent, NodeViewWrapper as NodeViewWrapper2 } from "@tiptap/react";
+
+// src/react/extensions/toggle-registry.ts
+var registry = /* @__PURE__ */ new WeakMap();
+function registerToggle(editor, id, control) {
+  let controls = registry.get(editor);
+  if (!controls) {
+    controls = /* @__PURE__ */ new Map();
+    registry.set(editor, controls);
+  }
+  controls.set(id, control);
+  return () => {
+    const current = registry.get(editor);
+    if (current?.get(id) === control) current.delete(id);
+  };
+}
+function toggleControl(editor, id) {
+  return registry.get(editor)?.get(id);
+}
+
+// src/react/internal/languages.ts
+var CODE_LANGUAGES = [
+  "bash",
+  "c",
+  "cpp",
+  "csharp",
+  "css",
+  "diff",
+  "go",
+  "html",
+  "java",
+  "javascript",
+  "json",
+  "kotlin",
+  "markdown",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "sql",
+  "swift",
+  "typescript",
+  "yaml"
+];
+var LANGUAGE_NAMES = {
+  cpp: "C++",
+  csharp: "C#",
+  c: "C",
+  css: "CSS",
+  html: "HTML",
+  javascript: "JavaScript",
+  json: "JSON",
+  php: "PHP",
+  sql: "SQL",
+  typescript: "TypeScript",
+  yaml: "YAML",
+  bash: "Bash",
+  go: "Go",
+  java: "Java",
+  kotlin: "Kotlin",
+  markdown: "Markdown",
+  python: "Python",
+  ruby: "Ruby",
+  rust: "Rust",
+  swift: "Swift",
+  diff: "Diff"
+};
+function languageName(language) {
+  return LANGUAGE_NAMES[language] ?? language;
+}
+
+// src/react/blocks/text.tsx
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+function variantOf(value) {
+  return CALLOUT_VARIANTS.find((variant) => variant === value) ?? "info";
+}
+function CalloutView({ node, updateAttributes }) {
+  const ui = useEditorUi();
+  const m = useTranslator().messages;
+  const variant = variantOf(node.attrs.variant);
+  return /* @__PURE__ */ jsxs9(NodeViewWrapper2, { "data-kit": "editor-callout", "data-variant": variant, role: "note", "aria-label": m.callouts[variant], children: [
+    /* @__PURE__ */ jsx13("span", { "data-kit": "editor-callout-icon", contentEditable: false, children: /* @__PURE__ */ jsx13(Glyph, { name: variant }) }),
+    /* @__PURE__ */ jsx13(NodeViewContent, { "data-kit": "editor-callout-content", dir: "auto" }),
+    ui.editable ? /* @__PURE__ */ jsx13(
+      "select",
+      {
+        "data-kit": "editor-callout-kind",
+        contentEditable: false,
+        "aria-label": m.blocks.callout.name,
+        value: variant,
+        onChange: (event) => updateAttributes({ variant: variantOf(event.target.value) }),
+        children: CALLOUT_VARIANTS.map((option) => /* @__PURE__ */ jsx13("option", { value: option, children: m.callouts[option] }, option))
+      }
+    ) : null
+  ] });
+}
+function ToggleView({ editor, node }) {
+  const m = useTranslator().messages;
+  const [open, setOpen] = useState6(true);
+  const id = typeof node.attrs.id === "string" ? node.attrs.id : "";
+  useEffect5(() => {
+    if (id === "") return;
+    return registerToggle(editor, id, { toggle: () => setOpen((value) => !value), open: () => setOpen(true) });
+  }, [editor, id]);
+  return /* @__PURE__ */ jsxs9(NodeViewWrapper2, { "data-kit": "editor-toggle", "data-open": open ? "true" : "false", children: [
+    /* @__PURE__ */ jsx13(
+      "button",
+      {
+        type: "button",
+        "data-kit": "editor-toggle-button",
+        contentEditable: false,
+        "aria-expanded": open,
+        "aria-label": open ? m.toggle.collapse : m.toggle.expand,
+        title: open ? m.toggle.collapse : m.toggle.expand,
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => setOpen((value) => !value),
+        children: /* @__PURE__ */ jsx13(Glyph, { name: "chevron", "data-open": open ? "true" : "false" })
+      }
+    ),
+    /* @__PURE__ */ jsx13(NodeViewContent, { "data-kit": "editor-toggle-content" })
+  ] });
+}
+function CodeBlockView({ editor, node, updateAttributes }) {
+  const ui = useEditorUi();
+  const m = useTranslator().messages;
+  const language = typeof node.attrs.language === "string" ? node.attrs.language : "";
+  const known = language === "" || CODE_LANGUAGES.includes(language);
+  const [copied, setCopied] = useState6(false);
+  const timer = useRef6(void 0);
+  useEffect5(() => () => clearTimeout(timer.current), []);
+  const copy = () => {
+    const text = node.textContent;
+    const done = () => {
+      setCopied(true);
+      ui.announce(m.status.copied);
+      clearTimeout(timer.current);
+      timer.current = setTimeout(() => setCopied(false), 2e3);
+    };
+    if (typeof navigator !== "undefined" && navigator.clipboard) {
+      void navigator.clipboard.writeText(text).then(done, () => void 0);
+    }
+    editor.commands.focus();
+  };
+  return /* @__PURE__ */ jsxs9(NodeViewWrapper2, { "data-kit": "editor-code", "data-language": language || void 0, children: [
+    /* @__PURE__ */ jsxs9("div", { "data-kit": "editor-code-bar", contentEditable: false, children: [
+      ui.editable ? /* @__PURE__ */ jsxs9(
+        "select",
+        {
+          "data-kit": "editor-code-language",
+          "aria-label": m.code.language,
+          value: language,
+          onChange: (event) => updateAttributes({ language: event.target.value === "" ? null : event.target.value }),
+          children: [
+            /* @__PURE__ */ jsx13("option", { value: "", children: m.code.plainText }),
+            known ? null : /* @__PURE__ */ jsx13("option", { value: language, children: language }),
+            CODE_LANGUAGES.map((option) => /* @__PURE__ */ jsx13("option", { value: option, children: languageName(option) }, option))
+          ]
+        }
+      ) : /* @__PURE__ */ jsx13("span", { "data-kit": "editor-code-language-label", children: language ? languageName(language) : m.code.plainText }),
+      /* @__PURE__ */ jsxs9("button", { type: "button", "data-kit": "editor-code-copy", onMouseDown: (event) => event.preventDefault(), onClick: copy, children: [
+        /* @__PURE__ */ jsx13(Glyph, { name: copied ? "check" : "copy" }),
+        /* @__PURE__ */ jsx13("span", { children: copied ? m.code.copied : m.code.copy })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx13("pre", { dir: "ltr", children: /* @__PURE__ */ jsx13(NodeViewContent, { as: "code" }) })
+  ] });
+}
+function collectHeadings(editor) {
+  const out = [];
+  editor.state.doc.descendants((node) => {
+    if (node.type.name !== "heading") return;
+    const text = node.textContent.trim();
+    const level = Number(node.attrs.level);
+    if (text !== "" && typeof node.attrs.id === "string") out.push({ id: node.attrs.id, level, text });
+  });
+  return out;
+}
+function sameHeadings(a, b) {
+  return a.length === b.length && a.every((item, index) => item.id === b[index]?.id && item.text === b[index]?.text && item.level === b[index]?.level);
+}
+function Entries({ nodes, onJump }) {
+  return /* @__PURE__ */ jsx13("ol", { children: nodes.map((item) => /* @__PURE__ */ jsxs9("li", { children: [
+    /* @__PURE__ */ jsx13(
+      "a",
+      {
+        href: `#${slugifyHeading(item.text)}`,
+        dir: "auto",
+        onClick: (event) => {
+          event.preventDefault();
+          onJump(item.id);
+        },
+        children: item.text
+      }
+    ),
+    item.children.length > 0 ? /* @__PURE__ */ jsx13(Entries, { nodes: item.children, onJump }) : null
+  ] }, item.id)) });
+}
+function TableOfContentsView({ editor }) {
+  const m = useTranslator().messages;
+  const [headings, setHeadings] = useState6(() => collectHeadings(editor));
+  useEffect5(() => {
+    const update = () => setHeadings((previous) => {
+      const next = collectHeadings(editor);
+      return sameHeadings(previous, next) ? previous : next;
+    });
+    update();
+    editor.on("update", update);
+    return () => {
+      editor.off("update", update);
+    };
+  }, [editor]);
+  const jump = (id) => {
+    let target = -1;
+    editor.state.doc.descendants((node, pos) => {
+      if (target === -1 && node.type.name === "heading" && node.attrs.id === id) target = pos;
+      return target === -1;
+    });
+    if (target === -1) return;
+    editor.chain().focus().setTextSelection(target + 1).scrollIntoView().run();
+  };
+  const tree = buildOutlineTree(headings);
+  return /* @__PURE__ */ jsx13(NodeViewWrapper2, { "data-kit": "editor-toc", role: "navigation", "aria-label": m.blocks.toc.name, contentEditable: false, children: tree.length > 0 ? /* @__PURE__ */ jsx13(Entries, { nodes: tree, onJump: jump }) : /* @__PURE__ */ jsx13("p", { "data-kit": "editor-toc-empty", children: m.blocks.toc.description }) });
+}
+
+// src/react/extensions/nodes.ts
+var KitDocument = Node2.create({
+  name: "doc",
+  topNode: true,
+  content: "block+"
+});
+var Callout = Node2.create({
+  name: "callout",
+  group: "block",
+  content: "inline*",
+  defining: true,
+  addAttributes() {
+    return {
+      variant: {
+        default: "info",
+        parseHTML: (element) => CALLOUT_VARIANTS.find((variant) => variant === element.getAttribute("data-variant")) ?? "info",
+        renderHTML: (attributes) => ({ "data-variant": String(attributes.variant ?? "info") })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-callout"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-callout", role: "note" }, HTMLAttributes), 0];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(CalloutView);
+  },
+  addKeyboardShortcuts() {
+    const leave = () => {
+      const { selection } = this.editor.state;
+      const { $anchor, empty } = selection;
+      if (!empty || $anchor.parent.type.name !== this.name || $anchor.parent.content.size !== 0) return false;
+      return this.editor.commands.setNode("paragraph");
+    };
+    return { Enter: leave, Backspace: leave };
+  }
+});
+var ToggleSummary = Node2.create({
+  name: "toggleSummary",
+  content: "inline*",
+  defining: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-toggle-summary"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-toggle-summary" }, HTMLAttributes), 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      // Enter in the summary opens the toggle and continues in its first block.
+      Enter: () => {
+        const { $from, empty } = this.editor.state.selection;
+        if (!empty || $from.parent.type.name !== this.name) return false;
+        const toggle = $from.node($from.depth - 1);
+        const id = toggle.attrs.id;
+        if (typeof id === "string") toggleControl(this.editor, id)?.open();
+        const after = $from.after();
+        return this.editor.commands.command(({ tr }) => {
+          tr.setSelection(TextSelection3.near(tr.doc.resolve(after), 1));
+          return true;
+        });
+      }
+    };
+  }
+});
+var Toggle = Node2.create({
+  name: "toggle",
+  group: "block",
+  content: "toggleSummary block+",
+  defining: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-toggle"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-toggle", "data-open": "true" }, HTMLAttributes), 0];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(ToggleView);
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Alt-Enter": () => {
+        const { $from } = this.editor.state.selection;
+        for (let depth = $from.depth; depth >= 0; depth -= 1) {
+          const node = $from.node(depth);
+          if (node.type.name !== this.name) continue;
+          const id = node.attrs.id;
+          if (typeof id !== "string") return false;
+          const control = toggleControl(this.editor, id);
+          control?.toggle();
+          return control !== void 0;
+        }
+        return false;
+      }
+    };
+  }
+});
+var Columns = Node2.create({
+  name: "columns",
+  group: "block",
+  content: "column+",
+  defining: true,
+  isolating: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-columns"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-columns" }, HTMLAttributes), 0];
+  }
+});
+var Column = Node2.create({
+  name: "column",
+  content: "block+",
+  defining: true,
+  isolating: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-column"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-column" }, HTMLAttributes), 0];
+  }
+});
+var Equation = Node2.create({
+  name: "equation",
+  group: "block",
+  content: "text*",
+  marks: "",
+  code: true,
+  defining: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-equation"]', preserveWhitespace: "full" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-equation", dir: "ltr" }, HTMLAttributes), ["code", 0]];
+  }
+});
+var FENCE_LANGUAGE = "([a-zA-Z0-9+#_-]*)";
+var CodeBlock = Node2.create({
+  name: "codeBlock",
+  group: "block",
+  content: "text*",
+  marks: "",
+  code: true,
+  defining: true,
+  addAttributes() {
+    return {
+      language: {
+        default: null,
+        parseHTML: (element) => {
+          const direct = element.getAttribute("data-language");
+          if (direct) return direct;
+          const match = /language-([\w+#-]+)/.exec(element.querySelector("code")?.getAttribute("class") ?? "");
+          return match?.[1] ?? null;
+        },
+        renderHTML: (attributes) => typeof attributes.language === "string" && attributes.language !== "" ? { "data-language": attributes.language } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "pre", preserveWhitespace: "full" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["pre", mergeAttributes2({ dir: "ltr" }, HTMLAttributes), ["code", 0]];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(CodeBlockView);
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.toggleNode(this.name, "paragraph"),
+      // Backspace at the very start turns the block back into a paragraph.
+      Backspace: () => {
+        const { empty, $anchor } = this.editor.state.selection;
+        if (!empty || $anchor.parent.type.name !== this.name || $anchor.parentOffset !== 0) return false;
+        return this.editor.commands.clearNodes();
+      },
+      // Mod+Enter leaves the block (Tab stays free to move focus out of the editor).
+      "Mod-Enter": () => {
+        const { $from } = this.editor.state.selection;
+        if ($from.parent.type.name !== this.name) return false;
+        return this.editor.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      textblockTypeInputRule({
+        find: new RegExp(`^\`\`\`${FENCE_LANGUAGE}[\\s\\n]$`),
+        type: this.type,
+        getAttributes: (match) => ({ language: match[1] || null })
+      }),
+      textblockTypeInputRule({
+        find: new RegExp(`^~~~${FENCE_LANGUAGE}[\\s\\n]$`),
+        type: this.type,
+        getAttributes: (match) => ({ language: match[1] || null })
+      })
+    ];
+  }
+});
+var PageBreak = Node2.create({
+  name: "pageBreak",
+  group: "block",
+  atom: true,
+  selectable: true,
+  parseHTML() {
+    return [{ tag: 'hr[data-kit="editor-page-break"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["hr", mergeAttributes2({ "data-kit": "editor-page-break" }, HTMLAttributes)];
+  }
+});
+var TableOfContents = Node2.create({
+  name: "tableOfContents",
+  group: "block",
+  atom: true,
+  selectable: true,
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-toc"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-toc" }, HTMLAttributes)];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(TableOfContentsView);
+  }
+});
+var KitImage = Image.extend({
+  name: "image",
+  draggable: false,
+  addAttributes() {
+    return {
+      src: { default: null },
+      alt: { default: "" },
+      caption: jsonAttribute("caption"),
+      align: dataAttribute("align"),
+      width: dataAttribute("width", null, (raw) => {
+        const value = Number(raw);
+        return Number.isFinite(value) && value > 0 ? value : null;
+      })
+    };
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(ImageView);
+  }
+});
+var Media = Node2.create({
+  name: "media",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      kind: dataAttribute("kind", "video"),
+      src: dataAttribute("src", ""),
+      caption: jsonAttribute("caption")
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-media-block"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-media-block" }, HTMLAttributes)];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(MediaView);
+  }
+});
+var FileBlock = Node2.create({
+  name: "file",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      src: dataAttribute("src", ""),
+      name: dataAttribute("name", ""),
+      size: dataAttribute("size", null, (raw) => {
+        const value = Number(raw);
+        return Number.isFinite(value) && value >= 0 ? value : null;
+      })
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-file-block"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-file-block" }, HTMLAttributes)];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(FileView);
+  }
+});
+var Bookmark = Node2.create({
+  name: "bookmark",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      url: dataAttribute("url", ""),
+      title: dataAttribute("title"),
+      description: dataAttribute("description")
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-bookmark-block"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-bookmark-block" }, HTMLAttributes)];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(BookmarkView);
+  }
+});
+function createEmbed(name, type, attributes, view) {
+  return Node2.create({
+    name,
+    group: "block",
+    atom: true,
+    selectable: true,
+    isolating: true,
+    addAttributes() {
+      return attributes;
+    },
+    parseHTML() {
+      return [{ tag: `div[data-kit="editor-embed-block"][data-embed="${type}"]` }];
+    },
+    renderHTML({ HTMLAttributes }) {
+      return ["div", mergeAttributes2({ "data-kit": "editor-embed-block", "data-embed": type }, HTMLAttributes)];
+    },
+    addNodeView() {
+      return ReactNodeViewRenderer(view);
+    }
+  });
+}
+var Chart = createEmbed("chart", "chart", { spec: jsonAttribute("spec", {}) }, ChartView);
+var Diagram = createEmbed(
+  "diagram",
+  "diagram",
+  {
+    engine: dataAttribute("engine", "mermaid"),
+    diagram: jsonAttribute("diagram"),
+    source: dataAttribute("source")
+  },
+  DiagramView
+);
+var DataView = createEmbed(
+  "dataView",
+  "data-view",
+  { dataset: dataAttribute("dataset", ""), view: jsonAttribute("view", {}) },
+  DataViewView
+);
+var AiBlock = createEmbed(
+  "aiBlock",
+  "ai",
+  { prompt: dataAttribute("prompt", ""), result: jsonAttribute("result") },
+  AiBlockView
+);
+var UnknownBlock = Node2.create({
+  name: "unknownBlock",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      blockType: dataAttribute("block-type", "unknown"),
+      payload: jsonAttribute("payload", {})
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-kit="editor-unknown-block"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-kit": "editor-unknown-block" }, HTMLAttributes)];
+  },
+  addNodeView() {
+    return ReactNodeViewRenderer(UnknownBlockView);
+  }
+});
+var Mention = Node2.create({
+  name: "mention",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      kind: dataAttribute("kind", "person"),
+      id: dataAttribute("id", ""),
+      label: dataAttribute("label", "")
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-kit="editor-mention"]' }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const prefix = node.attrs.kind === "person" ? "@" : "";
+    return ["span", mergeAttributes2({ "data-kit": "editor-mention" }, HTMLAttributes), `${prefix}${String(node.attrs.label ?? "")}`];
+  },
+  renderText({ node }) {
+    return `${node.attrs.kind === "person" ? "@" : ""}${String(node.attrs.label ?? "")}`;
+  }
+});
+var Emoji = Node2.create({
+  name: "emoji",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return { shortcode: dataAttribute("shortcode", "") };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-kit="editor-emoji"]' }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const shortcode = String(node.attrs.shortcode ?? "");
+    return [
+      "span",
+      mergeAttributes2({ "data-kit": "editor-emoji", role: "img", "aria-label": shortcode.replace(/[_-]+/g, " ") }, HTMLAttributes),
+      emojiForShortcode(shortcode) ?? `:${shortcode}:`
+    ];
+  },
+  renderText({ node }) {
+    const shortcode = String(node.attrs.shortcode ?? "");
+    return emojiForShortcode(shortcode) ?? `:${shortcode}:`;
+  },
+  addInputRules() {
+    return [
+      new InputRule({
+        find: /:([a-z0-9_+-]+):$/,
+        handler: ({ state, range, match }) => {
+          const shortcode = match[1];
+          if (!shortcode || emojiForShortcode(shortcode) === null) return null;
+          state.tr.replaceWith(range.from, range.to, this.type.create({ shortcode }));
+          return void 0;
+        }
+      })
+    ];
+  }
+});
+var KitTable = Table.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      headerRow: { default: null, rendered: false },
+      headerColumn: { default: null, rendered: false }
+    };
+  }
+}).configure({ resizable: false, HTMLAttributes: { "data-kit": "editor-table" } });
+
+// src/react/extensions/slash.ts
+import { Extension as Extension3 } from "@tiptap/core";
+import { PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import Suggestion from "@tiptap/suggestion";
+
+// src/react/slash-items.ts
+var SLASH_GROUP_ORDER = ["basic", "lists", "media", "advanced", "embeds"];
+var GROUP_OF = {
+  paragraph: "basic",
+  heading1: "basic",
+  heading2: "basic",
+  heading3: "basic",
+  heading4: "basic",
+  quote: "basic",
+  callout: "basic",
+  toggle: "basic",
+  code: "basic",
+  equation: "basic",
+  divider: "basic",
+  bulletList: "lists",
+  numberedList: "lists",
+  taskList: "lists",
+  image: "media",
+  video: "media",
+  audio: "media",
+  file: "media",
+  bookmark: "media",
+  table: "advanced",
+  columns: "advanced",
+  pageBreak: "advanced",
+  toc: "advanced",
+  chart: "embeds",
+  diagram: "embeds",
+  dataView: "embeds",
+  ai: "embeds"
+};
+function allSlashItems(messages) {
+  const items = BLOCK_KINDS.map((kind) => ({
+    kind,
+    group: GROUP_OF[kind],
+    name: messages.blocks[kind].name,
+    description: messages.blocks[kind].description
+  }));
+  return SLASH_GROUP_ORDER.flatMap((group) => items.filter((item) => item.group === group));
+}
+function normalize(text) {
+  return text.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase();
+}
+function filterSlashItems(query, messages, items = allSlashItems(messages)) {
+  const needle = normalize(query.trim());
+  if (needle === "") return [...items];
+  const scored = [];
+  items.forEach((item, index) => {
+    const name = normalize(item.name);
+    const keywords = normalize(messages.blocks[item.kind].keywords);
+    const description = normalize(item.description);
+    const words = `${name} ${keywords}`.split(/\s+/);
+    let score = -1;
+    if (name.startsWith(needle)) score = 0;
+    else if (words.some((word) => word.startsWith(needle))) score = 1;
+    else if (name.includes(needle) || keywords.includes(needle)) score = 2;
+    else if (description.includes(needle)) score = 3;
+    if (score !== -1) scored.push({ item, score, index });
+  });
+  return scored.sort((a, b) => a.score - b.score || a.index - b.index).map((entry) => entry.item);
+}
+
+// src/react/extensions/slash.ts
+var slashPluginKey = new PluginKey2("kitSlashMenu");
+async function runSlashItem(editor, range, item, runtime) {
+  const ui = runtime.ui();
+  const t = runtime.translator();
+  editor.chain().focus().deleteRange(range).run();
+  if (item.kind === "image") {
+    ui.openImageDialog();
+    return;
+  }
+  let attrs = {};
+  const type = embedKindToType(item.kind);
+  if (type && ui.onRequestBlock) {
+    const payload = await ui.onRequestBlock(type);
+    if (payload === null || payload === void 0) return;
+    attrs = type === "chart" ? { spec: payload } : payload;
+    editor.commands.focus();
+  }
+  if (applyBlockKind(editor, item.kind, attrs) !== null) {
+    ui.announce(t.format(t.messages.status.blockTurnedInto, { name: item.name }));
+  }
+}
+var SlashCommand = Extension3.create({
+  name: "slashCommand",
+  addOptions() {
+    return { runtime: null };
+  },
+  addProseMirrorPlugins() {
+    const runtime = this.options.runtime;
+    if (!runtime) return [];
+    return [
+      Suggestion({
+        editor: this.editor,
+        pluginKey: slashPluginKey,
+        char: "/",
+        allowSpaces: false,
+        allowedPrefixes: [" "],
+        allow: ({ state, range }) => {
+          if (!runtime.slashEnabled() || !runtime.ui().editable) return false;
+          return !state.doc.resolve(range.from).parent.type.spec.code;
+        },
+        items: ({ query }) => {
+          const messages = runtime.translator().messages;
+          return filterSlashItems(query, messages, allSlashItems(messages));
+        },
+        command: ({ editor, range, props }) => {
+          void runSlashItem(editor, range, props, runtime);
+        },
+        render: () => ({
+          onStart: (props) => runtime.slash?.onStart(props),
+          onUpdate: (props) => runtime.slash?.onUpdate(props),
+          onKeyDown: (props) => runtime.slash?.onKeyDown(props) ?? false,
+          onExit: () => runtime.slash?.onExit()
+        })
+      })
+    ];
+  }
+});
+
+// src/react/extensions/index.ts
+var AUTO_DIRECTION_NODES = ["paragraph", "heading", "blockquote", "bulletList", "orderedList", "taskList", "tableCell", "tableHeader", "toggleSummary"];
+var AutoDirection = Extension4.create({
+  name: "autoDirection",
+  addGlobalAttributes() {
+    return [
+      {
+        types: AUTO_DIRECTION_NODES,
+        attributes: {
+          dir: {
+            default: null,
+            keepOnSplit: false,
+            parseHTML: () => null,
+            renderHTML: () => ({ dir: "auto" })
+          }
+        }
+      }
+    ];
+  }
+});
+function createExtensions({ runtime, extra = [] }) {
+  return [
+    KitDocument,
+    StarterKit.configure({
+      document: false,
+      codeBlock: false,
+      trailingNode: false,
+      heading: { levels: [1, 2, 3, 4] },
+      link: {
+        openOnClick: false,
+        autolink: true,
+        linkOnPaste: true,
+        isAllowedUri: (url) => sanitizeUrl(url) !== null,
+        HTMLAttributes: { rel: "noopener noreferrer", target: null }
+      }
+    }),
+    TextColor,
+    KitHighlight,
+    TaskList.configure({ HTMLAttributes: { "data-kit": "editor-task-list" } }),
+    TaskItem.configure({
+      nested: true,
+      HTMLAttributes: { "data-kit": "editor-task-item" },
+      a11y: {
+        checkboxLabel: (node, checked) => {
+          const t = runtime.translator();
+          const text = node.textContent.trim() || t.messages.task.emptyLabel;
+          return formatMessage(checked ? t.messages.task.done : t.messages.task.todo, { text }, t.locale);
+        }
+      }
+    }),
+    Callout,
+    Toggle,
+    ToggleSummary,
+    Columns,
+    Column,
+    Equation,
+    CodeBlock,
+    KitTable,
+    TableRow,
+    TableHeader,
+    TableCell,
+    KitImage.configure({ allowBase64: true }),
+    Media,
+    FileBlock,
+    Bookmark,
+    PageBreak,
+    TableOfContents,
+    Chart,
+    Diagram,
+    DataView,
+    AiBlock,
+    UnknownBlock,
+    Mention,
+    Emoji,
+    BlockId,
+    AutoDirection,
+    Placeholder.configure({
+      includeChildren: true,
+      // The engine calls this while it applies a transaction, when `editor.state` can still be the previous
+      // state, so it must not look positions up in it. Paragraphs always get the text; the stylesheet only
+      // shows it for paragraphs that are not inside lists, tables, quotes or callouts.
+      placeholder: ({ node }) => {
+        const messages = runtime.translator().messages;
+        switch (node.type.name) {
+          case "heading": {
+            const level = Number(node.attrs.level);
+            return level >= 1 && level <= 4 ? messages.blocks[`heading${level}`].name : "";
+          }
+          case "toggleSummary":
+            return messages.toggle.summaryPlaceholder;
+          case "equation":
+            return messages.equation.placeholder;
+          case "paragraph":
+            return runtime.placeholder();
+          default:
+            return "";
+        }
+      }
+    }),
+    BlockKeys.configure({ runtime }),
+    SlashCommand.configure({ runtime }),
+    ...extra
+  ];
+}
+
+// src/react/extensions/runtime.ts
+function createRuntime() {
+  return {
+    ui: () => {
+      throw new Error("The editor runtime is not connected.");
+    },
+    translator: () => {
+      throw new Error("The editor runtime is not connected.");
+    },
+    placeholder: () => "",
+    slashEnabled: () => false,
+    slash: null
+  };
+}
+
+// src/react/image-dialog.tsx
+import { useRef as useRef8, useState as useState7 } from "react";
+import { Button as Button3 } from "@x12i/ui";
+
+// src/react/internal/dialog.tsx
+import { useEffect as useEffect6, useId as useId3, useRef as useRef7 } from "react";
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+var FOCUSABLE = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled]):not([type='hidden'])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])"
+].join(",");
+function Dialog({ open, title, onClose, children, initialFocus, restoreFocus, describedBy }) {
+  const titleId = useId3();
+  const panelRef = useRef7(null);
+  const restoreRef = useRef7(restoreFocus);
+  restoreRef.current = restoreFocus;
+  useEffect6(() => {
+    if (!open) return;
+    const previous = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    const panel = panelRef.current;
+    const target = initialFocus?.current ?? panel?.querySelector(FOCUSABLE) ?? panel;
+    target?.focus();
+    const onFocusIn = (event) => {
+      const current = panelRef.current;
+      if (current && event.target instanceof Node && !current.contains(event.target)) {
+        (current.querySelector(FOCUSABLE) ?? current).focus();
+      }
+    };
+    document.addEventListener("focusin", onFocusIn);
+    return () => {
+      document.removeEventListener("focusin", onFocusIn);
+      if (restoreRef.current) restoreRef.current();
+      else if (previous?.isConnected) previous.focus();
+    };
+  }, [open]);
+  if (!open) return null;
+  const onKeyDown = (event) => {
+    if (event.key === "Escape") {
+      event.stopPropagation();
+      event.preventDefault();
+      onClose();
+      return;
+    }
+    if (event.key !== "Tab") return;
+    const panel = panelRef.current;
+    if (!panel) return;
+    const focusable = Array.from(panel.querySelectorAll(FOCUSABLE));
+    if (focusable.length === 0) {
+      event.preventDefault();
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = document.activeElement;
+    if (event.shiftKey && (active === first || !panel.contains(active))) {
+      event.preventDefault();
+      last.focus();
+    } else if (!event.shiftKey && (active === last || !panel.contains(active))) {
+      event.preventDefault();
+      first.focus();
+    }
+  };
+  return /* @__PURE__ */ jsx14(
+    "div",
+    {
+      "data-kit": "editor-dialog-backdrop",
+      onMouseDown: (event) => {
+        if (event.target === event.currentTarget) onClose();
+      },
+      children: /* @__PURE__ */ jsxs10(
+        "div",
+        {
+          ref: panelRef,
+          role: "dialog",
+          "aria-modal": "true",
+          "aria-labelledby": titleId,
+          "aria-describedby": describedBy,
+          "data-kit": "editor-dialog",
+          tabIndex: -1,
+          onKeyDown,
+          children: [
+            /* @__PURE__ */ jsx14("h2", { id: titleId, "data-kit": "editor-dialog-title", children: title }),
+            children
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/react/internal/field.tsx
+import { useId as useId4 } from "react";
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+function Field({ label, hint, error, required, children }) {
+  const base = useId4();
+  const hintId = `${base}-hint`;
+  const errorId = `${base}-error`;
+  const describedBy = [error ? errorId : null, hint ? hintId : null].filter(Boolean).join(" ") || void 0;
+  return /* @__PURE__ */ jsxs11("div", { "data-kit": "editor-field", children: [
+    /* @__PURE__ */ jsx15("label", { htmlFor: base, "data-kit": "editor-field-label", children: label }),
+    children({
+      id: base,
+      "aria-describedby": describedBy,
+      "aria-invalid": error ? true : void 0,
+      "aria-required": required ? true : void 0
+    }),
+    hint ? /* @__PURE__ */ jsx15("p", { id: hintId, "data-kit": "editor-field-hint", children: hint }) : null,
+    error ? /* @__PURE__ */ jsx15("p", { id: errorId, role: "alert", "data-kit": "editor-error", children: error }) : null
+  ] });
+}
+
+// src/react/image-dialog.tsx
+import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function ImageDialog({ editor, pos, onClose, announce }) {
+  const t = useTranslator();
+  const m = t.messages.imageDialog;
+  const existing = pos === void 0 ? null : editor.state.doc.nodeAt(pos);
+  const current = existing && existing.type.name === "image" ? existing : null;
+  const currentCaption = Array.isArray(current?.attrs.caption) ? current?.attrs.caption : null;
+  const [src, setSrc] = useState7(typeof current?.attrs.src === "string" ? current.attrs.src : "");
+  const [alt, setAlt] = useState7(typeof current?.attrs.alt === "string" ? current.attrs.alt : "");
+  const [decorative, setDecorative] = useState7(current !== null && current.attrs.alt === "" && src !== "");
+  const [caption, setCaption] = useState7(currentCaption ? inlineToPlainText(currentCaption) : "");
+  const [errors, setErrors] = useState7({});
+  const srcRef = useRef8(null);
+  const altRef = useRef8(null);
+  const submit = (event) => {
+    event.preventDefault();
+    const next = {};
+    const value = src.trim();
+    const safe = value === "" ? null : sanitizeMediaUrl(normalizeUrlInput(value));
+    if (value === "") next.src = m.urlRequired;
+    else if (safe === null) next.src = m.urlInvalid;
+    if (!decorative && alt.trim() === "") next.alt = m.altRequired;
+    if (next.src || next.alt) {
+      setErrors(next);
+      (next.src ? srcRef : altRef).current?.focus();
+      return;
+    }
+    const text = caption.trim();
+    const keepCaption = currentCaption !== null && text === inlineToPlainText(currentCaption).trim();
+    const captionValue = keepCaption ? currentCaption : text === "" ? null : [{ type: "text", text }];
+    const altValue = decorative ? "" : alt.trim();
+    if (current && pos !== void 0) {
+      editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, void 0, { ...current.attrs, src: safe, alt: altValue, caption: captionValue }));
+    } else {
+      const template = blockTemplate("image", { src: safe, alt: altValue, caption: captionValue });
+      if (template) insertNode(editor, template);
+    }
+    announce(t.messages.status.imageInserted);
+    onClose();
+  };
+  return /* @__PURE__ */ jsx16(Dialog, { open: true, title: current ? m.editTitle : m.title, onClose, initialFocus: srcRef, restoreFocus: () => editor.commands.focus(), children: /* @__PURE__ */ jsxs12("form", { onSubmit: submit, noValidate: true, "data-kit": "editor-dialog-form", children: [
+    /* @__PURE__ */ jsx16(Field, { label: m.urlLabel, error: errors.src ?? null, required: true, children: (control) => /* @__PURE__ */ jsx16(
+      "input",
+      {
+        ...control,
+        ref: srcRef,
+        "data-kit": "editor-input",
+        type: "text",
+        inputMode: "url",
+        autoComplete: "off",
+        spellCheck: false,
+        dir: "ltr",
+        value: src,
+        onChange: (event) => {
+          setSrc(event.target.value);
+          setErrors((previous) => ({ ...previous, src: void 0 }));
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsx16(Field, { label: m.altLabel, hint: m.altHint, error: errors.alt ?? null, required: !decorative, children: (control) => /* @__PURE__ */ jsx16(
+      "input",
+      {
+        ...control,
+        ref: altRef,
+        "data-kit": "editor-input",
+        type: "text",
+        dir: "auto",
+        disabled: decorative,
+        value: decorative ? "" : alt,
+        onChange: (event) => {
+          setAlt(event.target.value);
+          setErrors((previous) => ({ ...previous, alt: void 0 }));
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs12("label", { "data-kit": "editor-checkbox", children: [
+      /* @__PURE__ */ jsx16(
+        "input",
+        {
+          type: "checkbox",
+          checked: decorative,
+          onChange: (event) => {
+            setDecorative(event.target.checked);
+            setErrors((previous) => ({ ...previous, alt: void 0 }));
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx16("span", { children: m.decorative })
+    ] }),
+    /* @__PURE__ */ jsx16(Field, { label: m.captionLabel, children: (control) => /* @__PURE__ */ jsx16("input", { ...control, "data-kit": "editor-input", type: "text", dir: "auto", value: caption, onChange: (event) => setCaption(event.target.value) }) }),
+    /* @__PURE__ */ jsxs12("div", { "data-kit": "editor-dialog-actions", children: [
+      /* @__PURE__ */ jsx16(Button3, { type: "submit", variant: "solid", tone: "accent", size: "sm", children: current ? m.update : m.insert }),
+      /* @__PURE__ */ jsx16(Button3, { type: "button", variant: "ghost", tone: "neutral", size: "sm", onClick: onClose, children: m.cancel })
+    ] })
+  ] }) });
+}
+
+// src/react/internal/equal.ts
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
+  }
+  const left = a;
+  const right = b;
+  const keys = Object.keys(left).filter((key) => left[key] !== void 0);
+  const otherKeys = Object.keys(right).filter((key) => right[key] !== void 0);
+  return keys.length === otherKeys.length && keys.every((key) => deepEqual(left[key], right[key]));
+}
+
+// src/react/internal/live-region.tsx
+import { useCallback, useEffect as useEffect7, useRef as useRef9, useState as useState8 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+function useLiveRegion(clearAfterMs = 4e3) {
+  const [message, setMessage] = useState8("");
+  const timer = useRef9(void 0);
+  useEffect7(() => () => clearTimeout(timer.current), []);
+  const announce = useCallback(
+    (next) => {
+      setMessage((previous) => previous === next ? `${next}\xA0` : next);
+      clearTimeout(timer.current);
+      timer.current = setTimeout(() => setMessage(""), clearAfterMs);
+    },
+    [clearAfterMs]
+  );
+  return { message, announce };
+}
+function LiveRegion({ message }) {
+  return /* @__PURE__ */ jsx17("div", { "data-kit": "editor-status", role: "status", "aria-live": "polite", "aria-atomic": "true", children: message });
+}
+
+// src/react/link-dialog.tsx
+import { useRef as useRef10, useState as useState9 } from "react";
+import { Button as Button4 } from "@x12i/ui";
+import { jsx as jsx18, jsxs as jsxs13 } from "react/jsx-runtime";
+function LinkDialog({ editor, initialHref, onClose, announce }) {
+  const t = useTranslator();
+  const m = t.messages.linkDialog;
+  const [href, setHref] = useState9(initialHref);
+  const [error, setError] = useState9(null);
+  const inputRef = useRef10(null);
+  const hasLink = initialHref !== "";
+  const apply = (event) => {
+    event.preventDefault();
+    const value = href.trim();
+    if (value === "") {
+      setError(m.required);
+      inputRef.current?.focus();
+      return;
+    }
+    const next = sanitizeUrl(normalizeUrlInput(value));
+    if (next === null) {
+      setError(m.invalid);
+      inputRef.current?.focus();
+      return;
+    }
+    const chain = editor.chain().focus();
+    if (editor.isActive("link")) chain.extendMarkRange("link").setLink({ href: next }).run();
+    else if (editor.state.selection.empty) {
+      chain.insertContent({ type: "text", text: next, marks: [{ type: "link", attrs: { href: next } }] }).run();
+    } else chain.setLink({ href: next }).run();
+    announce(t.messages.status.linkApplied);
+    onClose();
+  };
+  const remove = () => {
+    editor.chain().focus().extendMarkRange("link").unsetLink().run();
+    announce(t.messages.status.linkRemoved);
+    onClose();
+  };
+  return /* @__PURE__ */ jsx18(Dialog, { open: true, title: m.title, onClose, initialFocus: inputRef, restoreFocus: () => editor.commands.focus(), children: /* @__PURE__ */ jsxs13("form", { onSubmit: apply, noValidate: true, "data-kit": "editor-dialog-form", children: [
+    /* @__PURE__ */ jsx18(Field, { label: m.urlLabel, hint: m.urlHint, error, required: true, children: (control) => /* @__PURE__ */ jsx18(
+      "input",
+      {
+        ...control,
+        ref: inputRef,
+        "data-kit": "editor-input",
+        type: "text",
+        inputMode: "url",
+        autoComplete: "off",
+        spellCheck: false,
+        dir: "ltr",
+        value: href,
+        onChange: (event) => {
+          setHref(event.target.value);
+          setError(null);
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsxs13("div", { "data-kit": "editor-dialog-actions", children: [
+      /* @__PURE__ */ jsx18(Button4, { type: "submit", variant: "solid", tone: "accent", size: "sm", children: m.apply }),
+      hasLink ? /* @__PURE__ */ jsx18(Button4, { type: "button", variant: "outline", tone: "neutral", size: "sm", onClick: remove, children: m.remove }) : null,
+      /* @__PURE__ */ jsx18(Button4, { type: "button", variant: "ghost", tone: "neutral", size: "sm", onClick: onClose, children: m.cancel })
+    ] })
+  ] }) });
+}
+
+// src/react/slash-menu.tsx
+import { useEffect as useEffect8, useId as useId5, useLayoutEffect, useState as useState10 } from "react";
+import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
+function SlashMenu({ view, activeIndex, surfaceRef, onHover, onSelect, onIds }) {
+  const t = useTranslator();
+  const m = t.messages;
+  const ui = useEditorUi();
+  const base = useId5();
+  const [position2, setPosition] = useState10({ x: 0, y: 0 });
+  const count = view.items.length;
+  const listboxId = `${base}-listbox`;
+  const optionId = (index) => `${base}-option-${index}`;
+  const active = count > 0 ? Math.min(activeIndex, count - 1) : -1;
+  useLayoutEffect(() => {
+    const surface = surfaceRef.current;
+    const rect = view.clientRect?.();
+    if (!surface || !rect) return;
+    setPosition(positionNear(surface, rect, "bottom"));
+  }, [view, surfaceRef]);
+  useEffect8(() => {
+    onIds({ listbox: count > 0 ? listboxId : null, active: active >= 0 ? optionId(active) : null });
+  }, [count, active, listboxId, onIds]);
+  useEffect8(() => () => onIds({ listbox: null, active: null }), [onIds]);
+  useEffect8(() => {
+    ui.announce(count > 0 ? t.format(m.slash.resultCount, { count }) : m.slash.noResults);
+  }, [count]);
+  useEffect8(() => {
+    if (active < 0) return;
+    document.getElementById(optionId(active))?.scrollIntoView?.({ block: "nearest" });
+  }, [active]);
+  const groups = SLASH_GROUP_ORDER.map((group) => ({
+    group,
+    items: view.items.map((item, index) => ({ item, index })).filter((entry) => entry.item.group === group)
+  })).filter((entry) => entry.items.length > 0);
+  return /* @__PURE__ */ jsx19("div", { "data-kit": "editor-popup", "data-placement": "below", style: { "--kit-editor-x": `${position2.x}px`, "--kit-editor-y": `${position2.y}px` }, children: count === 0 ? /* @__PURE__ */ jsx19("div", { "data-kit": "editor-slash-empty", children: m.slash.noResults }) : /* @__PURE__ */ jsx19("div", { id: listboxId, role: "listbox", "aria-label": m.slash.label, "data-kit": "editor-slash", children: groups.map(({ group, items }) => /* @__PURE__ */ jsxs14("div", { role: "group", "aria-label": m.groups[group], "data-kit": "editor-slash-group", children: [
+    /* @__PURE__ */ jsx19("div", { role: "presentation", "data-kit": "editor-slash-heading", "aria-hidden": "true", children: m.groups[group] }),
+    items.map(({ item, index }) => /* @__PURE__ */ jsxs14(
+      "div",
+      {
+        id: optionId(index),
+        role: "option",
+        "aria-selected": index === active,
+        "data-kit": "editor-slash-option",
+        "data-active": index === active ? "" : void 0,
+        onMouseDown: (event) => event.preventDefault(),
+        onMouseMove: () => onHover(index),
+        onClick: () => onSelect(item),
+        children: [
+          /* @__PURE__ */ jsx19("span", { "data-kit": "editor-slash-name", children: item.name }),
+          /* @__PURE__ */ jsx19("span", { "data-kit": "editor-slash-description", children: item.description })
+        ]
+      },
+      item.kind
+    ))
+  ] }, group)) }) });
+}
+
+// src/react/toolbar.tsx
+import { useRef as useRef11 } from "react";
+import { useEditorState as useEditorState2 } from "@tiptap/react";
+import { Divider } from "@x12i/ui";
+import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
+function tableHeaders(editor) {
+  const { $from } = editor.state.selection;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const table = $from.node(depth);
+    if (table.type.name !== "table") continue;
+    let headerRow = table.childCount > 0;
+    let headerColumn = table.childCount > 0;
+    table.forEach((row, _offset, rowIndex) => {
+      row.forEach((cell, _cellOffset, columnIndex) => {
+        const header = cell.type.name === "tableHeader";
+        if (rowIndex === 0 && !header) headerRow = false;
+        if (columnIndex === 0 && !header) headerColumn = false;
+      });
+    });
+    return { headerRow, headerColumn };
+  }
+  return { headerRow: false, headerColumn: false };
+}
+function readState(editor) {
+  if (!editor) return null;
+  const table = tableHeaders(editor);
+  const highlight = editor.getAttributes("highlight").token;
+  const color = editor.getAttributes("color").token;
+  const can = editor.can();
+  return {
+    bold: editor.isActive("bold"),
+    italic: editor.isActive("italic"),
+    underline: editor.isActive("underline"),
+    strike: editor.isActive("strike"),
+    code: editor.isActive("code"),
+    link: editor.isActive("link"),
+    bulletList: editor.isActive("bulletList"),
+    numberedList: editor.isActive("orderedList"),
+    taskList: editor.isActive("taskList"),
+    quote: editor.isActive("blockquote"),
+    canUndo: can.undo(),
+    canRedo: can.redo(),
+    canIndent: can.sinkListItem("listItem") || can.sinkListItem("taskItem"),
+    canOutdent: can.liftListItem("listItem") || can.liftListItem("taskItem"),
+    inTable: editor.isActive("table"),
+    headerRow: table.headerRow,
+    headerColumn: table.headerColumn,
+    kind: currentBlockKind(editor),
+    highlight: typeof highlight === "string" ? highlight : null,
+    color: typeof color === "string" ? color : null
+  };
+}
+function sameState(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return Object.keys(a).every((key) => a[key] === b[key]);
+}
+function EditorToolbar({ editor, onOpenLink, onOpenImage, onOpenBlockMenu, onOpenAi, announce, children, className }) {
+  const t = useTranslator();
+  const m = t.messages;
+  const ref = useRef11(null);
+  const roving = useRovingToolbar(ref);
+  const state = useEditorState2({ editor, selector: () => readState(editor), equalityFn: sameState });
+  const run = (command) => {
+    if (editor) execEditorCommand(editor, command, onOpenBlockMenu);
+  };
+  const toggleMark = (command, name, active) => () => {
+    run(command);
+    announce?.(t.format(active ? m.status.markOff : m.status.markOn, { name }));
+  };
+  const disabled = editor === null || state === null || !editor.isEditable;
+  const s = state ?? {
+    bold: false,
+    italic: false,
+    underline: false,
+    strike: false,
+    code: false,
+    link: false,
+    bulletList: false,
+    numberedList: false,
+    taskList: false,
+    quote: false,
+    canUndo: false,
+    canRedo: false,
+    canIndent: false,
+    canOutdent: false,
+    inTable: false,
+    headerRow: false,
+    headerColumn: false,
+    kind: null,
+    highlight: null,
+    color: null
+  };
+  const blockItems = TURN_INTO_KINDS.map((kind) => ({
+    id: kind,
+    label: m.blocks[kind].name,
+    role: "menuitemradio",
+    checked: s.kind === kind,
+    onSelect: () => {
+      if (editor && turnInto(editor, kind)) announce?.(t.format(m.status.blockTurnedInto, { name: m.blocks[kind].name }));
+    }
+  }));
+  const paletteItems = (tokens, current, mark) => [
+    {
+      id: "none",
+      label: m.toolbar.clearColor,
+      role: "menuitemradio",
+      checked: current === null,
+      onSelect: () => {
+        if (editor) editor.chain().focus().unsetMark(mark).run();
+      }
+    },
+    ...tokens.map((token) => ({
+      id: token,
+      label: m.tokens[token] ?? token,
+      role: "menuitemradio",
+      checked: current === token,
+      swatch: token,
+      onSelect: () => {
+        if (editor) editor.chain().focus().setMark(mark, { token }).run();
+      }
+    }))
+  ];
+  const tableItems = [
+    { id: "row-before", label: m.table.addRowBefore, onSelect: () => editor?.chain().focus().addRowBefore().run() },
+    { id: "row-after", label: m.table.addRowAfter, onSelect: () => editor?.chain().focus().addRowAfter().run() },
+    { id: "col-before", label: m.table.addColumnBefore, onSelect: () => editor?.chain().focus().addColumnBefore().run() },
+    { id: "col-after", label: m.table.addColumnAfter, onSelect: () => editor?.chain().focus().addColumnAfter().run() },
+    { id: "row-delete", label: m.table.deleteRow, onSelect: () => editor?.chain().focus().deleteRow().run() },
+    { id: "col-delete", label: m.table.deleteColumn, onSelect: () => editor?.chain().focus().deleteColumn().run() },
+    {
+      id: "header-row",
+      label: m.table.toggleHeaderRow,
+      role: "menuitemcheckbox",
+      checked: s.headerRow,
+      // The converter reads the header state from the cells, so the stored hint needs no update.
+      onSelect: () => editor?.chain().focus().toggleHeaderRow().run()
+    },
+    {
+      id: "header-column",
+      label: m.table.toggleHeaderColumn,
+      role: "menuitemcheckbox",
+      checked: s.headerColumn,
+      onSelect: () => editor?.chain().focus().toggleHeaderColumn().run()
+    },
+    { id: "table-delete", label: m.table.deleteTable, onSelect: () => editor?.chain().focus().deleteTable().run() }
+  ];
+  const insertTable = () => {
+    const template = blockTemplate("table");
+    if (editor && template) insertNode(editor, template);
+  };
+  const turnIntoAvailable = s.kind !== null && TURN_INTO_KINDS.includes(s.kind);
+  return /* @__PURE__ */ jsxs15(
+    "div",
+    {
+      ref,
+      role: "toolbar",
+      "aria-label": m.toolbar.label,
+      "data-kit": "editor-toolbar",
+      className,
+      ...roving,
+      children: [
+        /* @__PURE__ */ jsxs15("div", { "data-kit": "editor-toolbar-group", children: [
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.undo, keys: shortcut("Z"), disabled: disabled || !s.canUndo, onClick: () => run("undo"), children: /* @__PURE__ */ jsx20(Glyph, { name: "undo" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.redo, keys: shortcut("Shift", "Z"), disabled: disabled || !s.canRedo, onClick: () => run("redo"), children: /* @__PURE__ */ jsx20(Glyph, { name: "redo" }) })
+        ] }),
+        /* @__PURE__ */ jsx20(Divider, { orientation: "vertical", decorative: true }),
+        /* @__PURE__ */ jsx20("div", { "data-kit": "editor-toolbar-group", children: /* @__PURE__ */ jsx20(
+          MenuButton,
+          {
+            label: `${m.toolbar.blockType}: ${s.kind ? m.blocks[s.kind].name : m.blocks.paragraph.name}`,
+            title: m.toolbar.blockType,
+            menuLabel: m.toolbar.blockType,
+            items: blockItems,
+            text: s.kind ? m.blocks[s.kind].name : m.blocks.paragraph.name,
+            disabled: disabled || !turnIntoAvailable,
+            children: /* @__PURE__ */ jsx20(Glyph, { name: "heading" })
+          }
+        ) }),
+        /* @__PURE__ */ jsx20(Divider, { orientation: "vertical", decorative: true }),
+        /* @__PURE__ */ jsxs15("div", { "data-kit": "editor-toolbar-group", children: [
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.bold, keys: shortcut("B"), pressed: s.bold, disabled, onClick: toggleMark("bold", m.toolbar.bold, s.bold), children: /* @__PURE__ */ jsx20(Glyph, { name: "bold" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.italic, keys: shortcut("I"), pressed: s.italic, disabled, onClick: toggleMark("italic", m.toolbar.italic, s.italic), children: /* @__PURE__ */ jsx20(Glyph, { name: "italic" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.underline, keys: shortcut("U"), pressed: s.underline, disabled, onClick: toggleMark("underline", m.toolbar.underline, s.underline), children: /* @__PURE__ */ jsx20(Glyph, { name: "underline" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.strike, keys: shortcut("Shift", "S"), pressed: s.strike, disabled, onClick: toggleMark("strike", m.toolbar.strike, s.strike), children: /* @__PURE__ */ jsx20(Glyph, { name: "strike" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.code, keys: shortcut("E"), pressed: s.code, disabled, onClick: toggleMark("code", m.toolbar.code, s.code), children: /* @__PURE__ */ jsx20(Glyph, { name: "code" }) }),
+          /* @__PURE__ */ jsx20(MenuButton, { label: m.toolbar.highlight, menuLabel: m.toolbar.highlight, items: paletteItems(HIGHLIGHT_TOKENS, s.highlight, "highlight"), pressed: s.highlight !== null, disabled, children: /* @__PURE__ */ jsx20(Glyph, { name: "highlight" }) }),
+          /* @__PURE__ */ jsx20(MenuButton, { label: m.toolbar.textColor, menuLabel: m.toolbar.textColor, items: paletteItems(TEXT_COLOR_TOKENS, s.color, "color"), pressed: s.color !== null, disabled, children: /* @__PURE__ */ jsx20(Glyph, { name: "color" }) }),
+          onOpenLink ? /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.link, keys: shortcut("K"), pressed: s.link, disabled, onClick: onOpenLink, children: /* @__PURE__ */ jsx20(Glyph, { name: "link" }) }) : null
+        ] }),
+        /* @__PURE__ */ jsx20(Divider, { orientation: "vertical", decorative: true }),
+        /* @__PURE__ */ jsxs15("div", { "data-kit": "editor-toolbar-group", children: [
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.bulletList, keys: shortcut("Shift", "8"), pressed: s.bulletList, disabled, onClick: () => run("bulletList"), children: /* @__PURE__ */ jsx20(Glyph, { name: "bullets" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.numberedList, keys: shortcut("Shift", "7"), pressed: s.numberedList, disabled, onClick: () => run("numberedList"), children: /* @__PURE__ */ jsx20(Glyph, { name: "numbers" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.taskList, keys: shortcut("Shift", "9"), pressed: s.taskList, disabled, onClick: () => run("taskList"), children: /* @__PURE__ */ jsx20(Glyph, { name: "tasks" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.outdent, keys: "Shift+Tab", disabled: disabled || !s.canOutdent, onClick: () => run("outdent"), children: /* @__PURE__ */ jsx20(Glyph, { name: "outdent" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.indent, keys: "Tab", disabled: disabled || !s.canIndent, onClick: () => run("indent"), children: /* @__PURE__ */ jsx20(Glyph, { name: "indent" }) })
+        ] }),
+        /* @__PURE__ */ jsx20(Divider, { orientation: "vertical", decorative: true }),
+        /* @__PURE__ */ jsxs15("div", { "data-kit": "editor-toolbar-group", children: [
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.quote, keys: shortcut("Shift", "B"), pressed: s.quote, disabled, onClick: () => run("quote"), children: /* @__PURE__ */ jsx20(Glyph, { name: "quote" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.divider, disabled, onClick: () => run("divider"), children: /* @__PURE__ */ jsx20(Glyph, { name: "divider" }) }),
+          /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.table, disabled, onClick: insertTable, children: /* @__PURE__ */ jsx20(Glyph, { name: "table" }) }),
+          s.inTable ? /* @__PURE__ */ jsx20(MenuButton, { label: m.table.controls, menuLabel: m.table.controls, items: tableItems, disabled, children: /* @__PURE__ */ jsx20(Glyph, { name: "more" }) }) : null,
+          onOpenImage ? /* @__PURE__ */ jsx20(ToolButton, { label: m.toolbar.image, disabled, onClick: onOpenImage, children: /* @__PURE__ */ jsx20(Glyph, { name: "image" }) }) : null
+        ] }),
+        onOpenAi || onOpenBlockMenu || children ? /* @__PURE__ */ jsx20(Divider, { orientation: "vertical", decorative: true }) : null,
+        /* @__PURE__ */ jsxs15("div", { "data-kit": "editor-toolbar-group", children: [
+          onOpenAi ? /* @__PURE__ */ jsx20(ToolButton, { label: m.ai.menuLabel, disabled, onClick: onOpenAi, children: /* @__PURE__ */ jsx20(Glyph, { name: "sparkle" }) }) : null,
+          onOpenBlockMenu ? /* @__PURE__ */ jsx20(ToolButton, { label: m.blockMenu.label, keys: shortcut("/"), disabled, onClick: onOpenBlockMenu, children: /* @__PURE__ */ jsx20(Glyph, { name: "more" }) }) : null,
+          children
+        ] })
+      ]
+    }
+  );
+}
+
+// src/react/use-ai-assist.ts
+import { useCallback as useCallback2, useEffect as useEffect9, useRef as useRef12, useState as useState11 } from "react";
+var CONTEXT_CHARACTERS = 2e3;
+function textToContent(text) {
+  const inline = (paragraph) => paragraph.split("\n").flatMap((line, index) => {
+    const nodes = [];
+    if (index > 0) nodes.push({ type: "hardBreak" });
+    if (line !== "") nodes.push({ type: "text", text: line });
+    return nodes;
+  });
+  const paragraphs = text.trim().split(/\n{2,}/);
+  if (paragraphs.length === 1) return inline(paragraphs[0] ?? "");
+  return paragraphs.map((paragraph) => ({ type: "paragraph", content: inline(paragraph) }));
+}
+function useAiAssist({ provider, editor, announce }) {
+  const t = useTranslator();
+  const [status, setStatus] = useState11("idle");
+  const [command, setCommand] = useState11(null);
+  const [preview, setPreview] = useState11("");
+  const [error, setError] = useState11(null);
+  const abortRef = useRef12(null);
+  const rangeRef = useRef12(null);
+  const textRef = useRef12("");
+  useEffect9(() => () => abortRef.current?.abort(), []);
+  const say = useCallback2((message) => announce?.(message), [announce]);
+  const run = useCallback2(
+    async (next, options = {}) => {
+      if (!provider || !editor) return;
+      const { selection, doc } = editor.state;
+      let input = selection.empty ? "" : doc.textBetween(selection.from, selection.to, "\n");
+      if (input === "" && next === "continue") {
+        const before = doc.textBetween(0, selection.from, "\n");
+        input = before.slice(-CONTEXT_CHARACTERS);
+      }
+      if (input.trim() === "") {
+        setCommand(next);
+        setStatus("error");
+        setError(t.messages.ai.noSelection);
+        return;
+      }
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      rangeRef.current = { from: selection.from, to: selection.to };
+      textRef.current = "";
+      setCommand(next);
+      setPreview("");
+      setError(null);
+      setStatus("running");
+      say(t.messages.ai.generating);
+      try {
+        const stream = provider.run({
+          command: next,
+          selection: input,
+          ...options.tone === void 0 ? {} : { tone: options.tone },
+          signal: controller.signal
+        });
+        for await (const chunk of stream) {
+          if (controller.signal.aborted) break;
+          textRef.current += chunk;
+          setPreview(textRef.current);
+        }
+        if (abortRef.current !== controller) return;
+        setStatus(textRef.current === "" ? "idle" : "preview");
+        if (textRef.current !== "") say(t.messages.ai.done);
+      } catch (cause) {
+        if (controller.signal.aborted) {
+          if (abortRef.current === controller) setStatus(textRef.current === "" ? "idle" : "preview");
+          return;
+        }
+        const message = cause instanceof Error ? cause.message : String(cause);
+        setError(formatMessage(t.messages.ai.error, { message }, t.locale));
+        setStatus("error");
+      }
+    },
+    [provider, editor, say, t]
+  );
+  const cancel = useCallback2(() => {
+    abortRef.current?.abort();
+  }, []);
+  const reject = useCallback2(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    textRef.current = "";
+    rangeRef.current = null;
+    setPreview("");
+    setError(null);
+    setCommand(null);
+    setStatus("idle");
+  }, []);
+  const accept = useCallback2(() => {
+    const range = rangeRef.current;
+    const text = textRef.current;
+    if (!editor || !range || text === "") return;
+    const content = textToContent(text);
+    const chain = editor.chain().focus();
+    if (command === "continue") {
+      const before = editor.state.doc.textBetween(Math.max(0, range.to - 1), range.to);
+      const separator = before !== "" && !/\s/.test(before) ? [{ type: "text", text: " " }] : [];
+      const inline = content[0]?.type === "text" || content[0]?.type === "hardBreak";
+      chain.insertContentAt(range.to, inline ? [...separator, ...content] : content).run();
+    } else {
+      chain.insertContentAt({ from: range.from, to: range.to }, content).run();
+    }
+    say(t.messages.status.aiApplied);
+    reject();
+  }, [editor, command, say, reject, t]);
+  return { available: provider !== void 0, status, command, preview, error, run, accept, reject, cancel };
+}
+
+// src/react/view.tsx
+import { createElement as createElement3, Fragment as Fragment4, useMemo as useMemo2 } from "react";
+import { Fragment as Fragment5, jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
+function formatBytes(size, locale) {
+  const units = [
+    [1024 ** 3, "gigabyte"],
+    [1024 ** 2, "megabyte"],
+    [1024, "kilobyte"]
+  ];
+  const [factor, unit] = units.find(([bytes]) => size >= bytes) ?? [1, "byte"];
+  try {
+    return new Intl.NumberFormat(locale, { style: "unit", unit, unitDisplay: "narrow", maximumFractionDigits: 1 }).format(size / factor);
+  } catch {
+    return String(size);
+  }
+}
+function OutlineList({ nodes, ctx }) {
+  if (nodes.length === 0) return null;
+  return /* @__PURE__ */ jsx21("ol", { children: nodes.map((node) => /* @__PURE__ */ jsxs16("li", { children: [
+    /* @__PURE__ */ jsx21("a", { href: `#${ctx.idPrefix}${node.id}`, dir: "auto", children: node.text }),
+    /* @__PURE__ */ jsx21(OutlineList, { nodes: node.children, ctx })
+  ] }, node.id)) });
+}
+function Items({ items, kind, ctx }) {
+  const Tag = kind === "ol" ? "ol" : "ul";
+  return /* @__PURE__ */ jsx21(Tag, { "data-kit": kind === "task" ? "editor-task-list" : void 0, dir: "auto", children: items.map((item) => {
+    const nested = item.children && item.children.length > 0 ? /* @__PURE__ */ jsx21(Items, { items: item.children, kind, ctx }) : null;
+    if (kind === "task") {
+      const checked = item.checked === true;
+      const labelId = `${ctx.idPrefix}${item.id}-label`;
+      return /* @__PURE__ */ jsxs16("li", { "data-kit": "editor-task-item", "data-checked": checked ? "true" : "false", children: [
+        /* @__PURE__ */ jsx21("input", { type: "checkbox", checked, disabled: true, readOnly: true, "aria-labelledby": labelId }),
+        /* @__PURE__ */ jsx21("span", { id: labelId, dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: item.content }) }),
+        nested
+      ] }, item.id);
+    }
+    return /* @__PURE__ */ jsxs16("li", { dir: "auto", children: [
+      /* @__PURE__ */ jsx21(InlineContent, { inline: item.content }),
+      nested
+    ] }, item.id);
+  }) });
+}
+function Caption({ caption }) {
+  return caption && caption.length > 0 ? /* @__PURE__ */ jsx21("figcaption", { dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: caption }) }) : null;
+}
+function TableBlock({ block }) {
+  const rows = block.rows ?? [];
+  const renderRow = (row, rowIndex) => /* @__PURE__ */ jsx21("tr", { children: row.map((cell, columnIndex) => {
+    const header = cell.header === true || block.headerRow === true && rowIndex === 0 || block.headerColumn === true && columnIndex === 0;
+    let scope;
+    if (header && block.headerRow === true && rowIndex === 0) scope = "col";
+    else if (header && block.headerColumn === true && columnIndex === 0) scope = "row";
+    const props = {
+      key: columnIndex,
+      scope,
+      colSpan: cell.colSpan && cell.colSpan > 1 ? cell.colSpan : void 0,
+      rowSpan: cell.rowSpan && cell.rowSpan > 1 ? cell.rowSpan : void 0,
+      dir: "auto"
+    };
+    return createElement3(header ? "th" : "td", props, /* @__PURE__ */ jsx21(InlineContent, { inline: cell.content }));
+  }) }, rowIndex);
+  const headRow = block.headerRow === true ? rows[0] : void 0;
+  const bodyRows = headRow ? rows.slice(1) : rows;
+  return /* @__PURE__ */ jsx21("div", { "data-kit": "editor-table-wrapper", "data-block-id": block.id, children: /* @__PURE__ */ jsxs16("table", { "data-kit": "editor-table", children: [
+    headRow ? /* @__PURE__ */ jsx21("thead", { children: renderRow(headRow, 0) }) : null,
+    /* @__PURE__ */ jsx21("tbody", { children: bodyRows.map((row, index) => renderRow(row, headRow ? index + 1 : index)) })
+  ] }) });
+}
+function Embed({ block, type, payload }) {
+  const t = useTranslator();
+  const title = payloadTitle(type, payload);
+  const label = t.format(t.messages.embed.groupLabel, {
+    type: t.messages.blocks[EMBED_KIND[type]].name,
+    title: title || t.messages.embed.untitled
+  });
+  return /* @__PURE__ */ jsx21("figure", { "data-block-id": block.id, "data-kit": "editor-embed", "data-embed": type, role: "group", "aria-label": label, children: /* @__PURE__ */ jsx21(EmbedBody, { type, id: block.id, payload }) });
+}
+function BlockView({ block, ctx }) {
+  const { t } = ctx;
+  const m = t.messages;
+  const id = block.id;
+  switch (block.type) {
+    case "paragraph":
+      return /* @__PURE__ */ jsx21("p", { "data-block-id": id, dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: block.content }) });
+    case "heading": {
+      const level = Math.min(4, Math.max(1, Math.round(block.level)));
+      return createElement3(
+        `h${level}`,
+        { id: `${ctx.idPrefix}${id}`, "data-block-id": id, dir: "auto" },
+        /* @__PURE__ */ jsx21(InlineContent, { inline: block.content })
+      );
+    }
+    case "quote":
+      return /* @__PURE__ */ jsx21("blockquote", { "data-block-id": id, dir: "auto", children: /* @__PURE__ */ jsx21("p", { dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: block.content }) }) });
+    case "callout": {
+      const variant = CALLOUT_VARIANTS.find((candidate) => candidate === block.variant) ?? "info";
+      return /* @__PURE__ */ jsxs16("div", { "data-block-id": id, "data-kit": "editor-callout", "data-variant": variant, role: "note", "aria-label": m.callouts[variant], children: [
+        /* @__PURE__ */ jsx21("span", { "data-kit": "editor-callout-icon", children: /* @__PURE__ */ jsx21(Glyph, { name: variant }) }),
+        /* @__PURE__ */ jsx21("div", { "data-kit": "editor-callout-content", dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: block.content }) })
+      ] });
+    }
+    case "toggle":
+      return /* @__PURE__ */ jsxs16("details", { "data-block-id": id, "data-kit": "editor-toggle", open: true, children: [
+        /* @__PURE__ */ jsx21("summary", { dir: "auto", children: /* @__PURE__ */ jsx21(InlineContent, { inline: block.summary }) }),
+        /* @__PURE__ */ jsx21(Blocks, { blocks: block.children ?? [], ctx })
+      ] });
+    case "divider":
+      return /* @__PURE__ */ jsx21("hr", { "data-block-id": id });
+    case "bulleted-list":
+      return /* @__PURE__ */ jsx21(Items, { items: block.items ?? [], kind: "ul", ctx });
+    case "numbered-list":
+      return /* @__PURE__ */ jsx21(Items, { items: block.items ?? [], kind: "ol", ctx });
+    case "task-list":
+      return /* @__PURE__ */ jsx21(Items, { items: block.items ?? [], kind: "task", ctx });
+    case "code": {
+      const language = block.language && /^[\w+#-]+$/.test(block.language) ? block.language : void 0;
+      return /* @__PURE__ */ jsx21("pre", { "data-block-id": id, "data-kit": "editor-code-block", "data-language": language, dir: "ltr", children: /* @__PURE__ */ jsx21("code", { className: language ? `language-${language}` : void 0, children: block.code }) });
+    }
+    case "equation":
+      return /* @__PURE__ */ jsx21("pre", { "data-block-id": id, "data-kit": "editor-equation", dir: "ltr", children: /* @__PURE__ */ jsx21("code", { children: block.latex }) });
+    case "table":
+      return /* @__PURE__ */ jsx21(TableBlock, { block });
+    case "image": {
+      const src = sanitizeMediaUrl(block.src);
+      return /* @__PURE__ */ jsxs16("figure", { "data-block-id": id, "data-kit": "editor-image", "data-align": block.align, children: [
+        src ? /* @__PURE__ */ jsx21("img", { src, alt: block.alt ?? "", loading: "lazy", decoding: "async", width: block.width }) : null,
+        /* @__PURE__ */ jsx21(Caption, { caption: block.caption })
+      ] });
+    }
+    case "video":
+    case "audio": {
+      const src = sanitizeMediaUrl(block.src);
+      const label = block.type === "audio" ? m.media.audio : m.media.video;
+      return /* @__PURE__ */ jsxs16("figure", { "data-block-id": id, "data-kit": "editor-media", "data-kind": block.type, children: [
+        src ? block.type === "audio" ? /* @__PURE__ */ jsx21("audio", { src, controls: true, preload: "none", "aria-label": label }) : /* @__PURE__ */ jsx21("video", { src, controls: true, preload: "none", "aria-label": label }) : null,
+        /* @__PURE__ */ jsx21(Caption, { caption: block.caption })
+      ] });
+    }
+    case "file": {
+      const href = sanitizeUrl(block.src);
+      return /* @__PURE__ */ jsxs16("p", { "data-block-id": id, "data-kit": "editor-file", dir: "auto", children: [
+        href ? /* @__PURE__ */ jsx21("a", { href, download: true, rel: "noopener noreferrer", children: block.name }) : block.name,
+        typeof block.size === "number" ? /* @__PURE__ */ jsxs16("span", { "data-kit": "editor-file-size", children: [
+          " (",
+          formatBytes(block.size, t.locale),
+          ")"
+        ] }) : null
+      ] });
+    }
+    case "bookmark": {
+      const href = sanitizeUrl(block.url);
+      const inner = /* @__PURE__ */ jsxs16(Fragment5, { children: [
+        block.title ? /* @__PURE__ */ jsx21("strong", { dir: "auto", children: block.title }) : block.url,
+        block.description ? /* @__PURE__ */ jsx21("span", { dir: "auto", children: block.description }) : null
+      ] });
+      return href ? /* @__PURE__ */ jsx21("a", { "data-block-id": id, "data-kit": "editor-bookmark", href, rel: "noopener noreferrer", children: inner }) : /* @__PURE__ */ jsx21("div", { "data-block-id": id, "data-kit": "editor-bookmark", children: inner });
+    }
+    case "columns":
+      return /* @__PURE__ */ jsx21("div", { "data-block-id": id, "data-kit": "editor-columns", "data-count": (block.columns ?? []).length, children: (block.columns ?? []).map((column, index) => /* @__PURE__ */ jsx21("div", { "data-kit": "editor-column", children: /* @__PURE__ */ jsx21(Blocks, { blocks: column, ctx }) }, index)) });
+    case "page-break":
+      return /* @__PURE__ */ jsx21("hr", { "data-block-id": id, "data-kit": "editor-page-break" });
+    case "table-of-contents":
+      return /* @__PURE__ */ jsx21("nav", { "data-block-id": id, "data-kit": "editor-toc", "aria-label": m.blocks.toc.name, children: /* @__PURE__ */ jsx21(OutlineList, { nodes: ctx.outline, ctx }) });
+    case "chart":
+      return /* @__PURE__ */ jsx21(Embed, { block, type: "chart", payload: block.spec });
+    case "diagram":
+      return /* @__PURE__ */ jsx21(Embed, { block, type: "diagram", payload: { engine: block.engine, diagram: block.diagram, source: block.source } });
+    case "data-view":
+      return /* @__PURE__ */ jsx21(Embed, { block, type: "data-view", payload: { dataset: block.dataset, view: block.view } });
+    case "ai":
+      return /* @__PURE__ */ jsx21(Embed, { block, type: "ai", payload: { prompt: block.prompt, result: block.result } });
+    default: {
+      const unknown = block;
+      if (!ctx.unknown) return null;
+      return createElement3(
+        ctx.unknown,
+        { id: typeof unknown.id === "string" ? unknown.id : "", blockType: String(unknown.type), payload: unknown, editable: false }
+      );
+    }
+  }
+}
+function Blocks({ blocks, ctx }) {
+  return /* @__PURE__ */ jsx21(Fragment5, { children: blocks.map((block, index) => /* @__PURE__ */ jsx21(Fragment4, { children: /* @__PURE__ */ jsx21(BlockView, { block, ctx }) }, `${block.id}-${index}`)) });
+}
+function EditorView({
+  value,
+  blockRenderers,
+  messages,
+  locale,
+  className,
+  idPrefix = "kit-",
+  "aria-label": ariaLabel,
+  "aria-labelledby": ariaLabelledby
+}) {
+  const translator = useMemo2(() => createTranslator(mergeMessages(defaultMessages, messages), locale), [messages, locale]);
+  const ui = useMemo2(() => ({ ...defaultEditorUi, editable: false, blockRenderers: blockRenderers ?? {} }), [blockRenderers]);
+  const outline = useMemo2(() => buildOutlineTree(getOutline(value)), [value]);
+  const ctx = useMemo2(
+    () => ({ idPrefix, outline, t: translator, unknown: ui.blockRenderers.unknown }),
+    [idPrefix, outline, translator, ui]
+  );
+  const label = ariaLabelledby ? void 0 : ariaLabel ?? translator.messages.viewLabel;
+  return /* @__PURE__ */ jsx21(MessagesContext.Provider, { value: translator, children: /* @__PURE__ */ jsx21(EditorUiContext.Provider, { value: ui, children: /* @__PURE__ */ jsx21(
+    "div",
+    {
+      "data-kit": "editor-view",
+      role: "document",
+      "aria-label": label,
+      "aria-labelledby": ariaLabelledby,
+      lang: locale,
+      className,
+      children: /* @__PURE__ */ jsx21(Blocks, { blocks: value.blocks ?? [], ctx })
+    }
+  ) }) });
+}
+
+// src/react/editor.tsx
+import { jsx as jsx22, jsxs as jsxs17 } from "react/jsx-runtime";
+function snapshot(props) {
+  return { items: props.items, query: props.query, clientRect: props.clientRect ?? null };
+}
+function Editor(props) {
+  const {
+    value,
+    defaultValue,
+    editable = true,
+    autoFocus,
+    blockRenderers,
+    extensions,
+    messages,
+    locale,
+    toolbar = true,
+    selectionMenu = true,
+    aiProvider,
+    className,
+    toolbarEnd,
+    onEditBlock,
+    onRequestBlock,
+    "aria-label": ariaLabel,
+    "aria-labelledby": ariaLabelledby
+  } = props;
+  const translator = useMemo3(() => createTranslator(mergeMessages(defaultMessages, messages), locale), [messages, locale]);
+  const { message: statusMessage, announce } = useLiveRegion();
+  const initialRef = useRef13(null);
+  if (initialRef.current === null) {
+    const doc = value ?? defaultValue ?? createEmptyDocument();
+    const warnings = [];
+    initialRef.current = { doc, json: documentToTiptap(doc, { warnings }), warnings };
+  }
+  const initial = initialRef.current;
+  const latest = useRef13(props);
+  latest.current = props;
+  const editorRef = useRef13(null);
+  const lastDocRef = useRef13(initial.doc);
+  const titleRef = useRef13(initial.doc.title);
+  const surfaceRef = useRef13(null);
+  const timerRef = useRef13(void 0);
+  const pendingRef = useRef13(false);
+  const [dialog, setDialog] = useState12(null);
+  const [slash, setSlash] = useState12(null);
+  const [slashIndex, setSlashIndex] = useState12(0);
+  const [slashIds, setSlashIds] = useState12({ listbox: null, active: null });
+  const slashState = useRef13({ props: null, index: 0 });
+  const readDocument = useCallback3(() => {
+    const editor2 = editorRef.current;
+    if (!editor2) return lastDocRef.current;
+    const doc = tiptapToDocument(editor2.getJSON());
+    return titleRef.current === void 0 ? doc : { ...doc, title: titleRef.current };
+  }, []);
+  const writeDocument = useCallback3((doc) => {
+    const editor2 = editorRef.current;
+    titleRef.current = doc.title;
+    lastDocRef.current = doc;
+    if (!editor2) return;
+    const warnings = [];
+    editor2.commands.setContent(documentToTiptap(doc, { warnings }), { emitUpdate: false });
+    if (warnings.length > 0) latest.current.onWarnings?.(warnings);
+  }, []);
+  const emit = useCallback3(() => {
+    pendingRef.current = false;
+    clearTimeout(timerRef.current);
+    let doc;
+    try {
+      doc = readDocument();
+    } catch {
+      return;
+    }
+    lastDocRef.current = doc;
+    latest.current.onChange?.(doc);
+  }, [readDocument]);
+  const schedule = useCallback3(() => {
+    const wait = latest.current.debounce ?? 0;
+    if (wait <= 0) {
+      emit();
+      return;
+    }
+    pendingRef.current = true;
+    clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(emit, wait);
+  }, [emit]);
+  useEffect10(
+    () => () => {
+      clearTimeout(timerRef.current);
+      if (pendingRef.current) emit();
+    },
+    [emit]
+  );
+  const runtimeRef = useRef13(null);
+  if (runtimeRef.current === null) runtimeRef.current = createRuntime();
+  const runtime = runtimeRef.current;
+  const openLinkDialog = useCallback3(() => {
+    const editor2 = editorRef.current;
+    if (!editor2) return;
+    const href = editor2.getAttributes("link").href;
+    setDialog({ kind: "link", href: typeof href === "string" ? href : "" });
+  }, []);
+  const openImageDialog = useCallback3((pos) => setDialog({ kind: "image", pos }), []);
+  const openBlockMenu = useCallback3(() => setDialog({ kind: "block-menu" }), []);
+  const closeDialog = useCallback3(() => setDialog(null), []);
+  const ui = useMemo3(
+    () => ({
+      ...defaultEditorUi,
+      editable,
+      blockRenderers: blockRenderers ?? {},
+      announce,
+      onEditBlock,
+      onRequestBlock,
+      openImageDialog,
+      openLinkDialog,
+      openBlockMenu
+    }),
+    [editable, blockRenderers, announce, onEditBlock, onRequestBlock, openImageDialog, openLinkDialog, openBlockMenu]
+  );
+  runtime.ui = () => ui;
+  runtime.translator = () => translator;
+  runtime.placeholder = () => latest.current.placeholder ?? translator.messages.placeholder;
+  runtime.slashEnabled = () => latest.current.slashMenu !== false;
+  const bridge = useMemo3(
+    () => ({
+      onStart: (suggestion) => {
+        slashState.current = { props: suggestion, index: 0 };
+        setSlash(snapshot(suggestion));
+        setSlashIndex(0);
+      },
+      onUpdate: (suggestion) => {
+        const previous = slashState.current;
+        const count = suggestion.items.length;
+        const index = previous.props && previous.props.query === suggestion.query ? Math.min(previous.index, Math.max(0, count - 1)) : 0;
+        slashState.current = { props: suggestion, index };
+        setSlash(snapshot(suggestion));
+        setSlashIndex(index);
+      },
+      onKeyDown: ({ event }) => {
+        const current = slashState.current;
+        if (!current.props) return false;
+        const count = current.props.items.length;
+        const go = (index) => {
+          slashState.current = { ...current, index };
+          setSlashIndex(index);
+        };
+        switch (event.key) {
+          case "ArrowDown":
+            if (count === 0) return true;
+            go((current.index + 1) % count);
+            return true;
+          case "ArrowUp":
+            if (count === 0) return true;
+            go((current.index - 1 + count) % count);
+            return true;
+          case "Enter":
+          case "Tab": {
+            const item = current.props.items[current.index];
+            if (!item) return false;
+            current.props.command(item);
+            return true;
+          }
+          case "Escape": {
+            const editor2 = editorRef.current;
+            if (editor2) exitSuggestion(editor2.view, slashPluginKey);
+            return true;
+          }
+          default:
+            return false;
+        }
+      },
+      onExit: () => {
+        slashState.current = { props: null, index: 0 };
+        setSlash(null);
+      }
+    }),
+    []
+  );
+  runtime.slash = bridge;
+  const builtExtensions = useMemo3(
+    () => createExtensions({ runtime, ...extensions ? { extra: extensions } : {} }),
+    // Extensions are created once; props they depend on are read through the runtime.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const attributes = {
+    "data-kit": "editor-content",
+    role: editable ? "textbox" : "document",
+    ...editable ? { "aria-multiline": "true" } : {},
+    ...ariaLabelledby ? { "aria-labelledby": ariaLabelledby } : { "aria-label": ariaLabel ?? translator.messages.editorLabel },
+    ...locale ? { lang: locale } : {},
+    ...slashIds.listbox ? { "aria-controls": slashIds.listbox } : {},
+    ...slashIds.active ? { "aria-activedescendant": slashIds.active } : {}
+  };
+  const api = useMemo3(
+    () => ({
+      getDocument: () => readDocument(),
+      setDocument: (doc) => writeDocument(doc),
+      focus: (position2) => {
+        editorRef.current?.commands.focus(position2 ?? null);
+      },
+      insertBlock: async (type, attrs = {}) => {
+        const editor2 = editorRef.current;
+        if (!editor2) return null;
+        const kind = normalizeBlockKind(type, attrs);
+        if (kind === null) return null;
+        let payload = attrs;
+        const embed = embedKindToType(kind);
+        const request = latest.current.onRequestBlock;
+        if (embed && request && Object.keys(attrs).length === 0) {
+          const result = await request(embed);
+          if (result === null || result === void 0) return null;
+          payload = embed === "chart" ? { spec: result } : result;
+        }
+        editor2.commands.focus();
+        return insertBlockKind(editor2, kind, payload);
+      },
+      exec: (command) => {
+        const editor2 = editorRef.current;
+        return editor2 ? execEditorCommand(editor2, command, () => setDialog({ kind: "block-menu" })) : false;
+      },
+      getMarkdown: () => documentToMarkdown(readDocument()),
+      getOutline: () => getOutline(readDocument()),
+      getEngine: () => editorRef.current,
+      announce: (text) => announce(text)
+    }),
+    [readDocument, writeDocument, announce]
+  );
+  useImperativeHandle(props.ref, () => api, [api]);
+  const editor = useEditor({
+    extensions: builtExtensions,
+    content: initial.json,
+    editable,
+    autofocus: autoFocus === true ? "end" : autoFocus === "start" || autoFocus === "end" ? autoFocus : false,
+    immediatelyRender: false,
+    shouldRerenderOnTransaction: false,
+    injectCSS: false,
+    editorProps: { attributes },
+    onCreate: ({ editor: created }) => {
+      editorRef.current = created;
+      if (initial.warnings.length > 0) latest.current.onWarnings?.(initial.warnings);
+      latest.current.onReady?.(api);
+    },
+    onUpdate: () => schedule(),
+    onSelectionUpdate: ({ editor: current }) => latest.current.onSelectionChange?.(getSelectionInfo(current))
+  });
+  editorRef.current = editor;
+  useEffect10(() => {
+    if (!editor || value === void 0) return;
+    if (value === lastDocRef.current) return;
+    if (deepEqual(readDocument(), value)) {
+      lastDocRef.current = value;
+      return;
+    }
+    writeDocument(value);
+  }, [editor, value, readDocument, writeDocument]);
+  useEffect10(() => {
+    if (editor && editor.isEditable !== editable) editor.setEditable(editable, false);
+  }, [editor, editable]);
+  const assist = useAiAssist({ provider: aiProvider, editor, announce });
+  const openAi = assist.available ? () => setDialog({ kind: "ai" }) : void 0;
+  const onSlashIds = useCallback3((ids) => {
+    setSlashIds((previous) => previous.listbox === ids.listbox && previous.active === ids.active ? previous : ids);
+  }, []);
+  const onSlashSelect = useCallback3((item) => {
+    slashState.current.props?.command(item);
+  }, []);
+  const onSlashHover = useCallback3((index) => {
+    slashState.current = { ...slashState.current, index };
+    setSlashIndex(index);
+  }, []);
+  return /* @__PURE__ */ jsx22(MessagesContext.Provider, { value: translator, children: /* @__PURE__ */ jsx22(EditorUiContext.Provider, { value: ui, children: /* @__PURE__ */ jsx22(EngineContext.Provider, { value: editor, children: /* @__PURE__ */ jsxs17("div", { "data-kit": "editor", "data-editable": editable ? "" : void 0, className, children: [
+    toolbar && editable ? /* @__PURE__ */ jsx22(
+      EditorToolbar,
+      {
+        editor,
+        onOpenLink: openLinkDialog,
+        onOpenImage: () => openImageDialog(),
+        onOpenBlockMenu: openBlockMenu,
+        onOpenAi: openAi,
+        announce,
+        children: toolbarEnd
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs17("div", { "data-kit": "editor-surface", ref: surfaceRef, children: [
+      editor ? /* @__PURE__ */ jsx22(EditorContent, { editor, "data-kit": "editor-body" }) : /* @__PURE__ */ jsx22(
+        EditorView,
+        {
+          value: initial.doc,
+          ...blockRenderers ? { blockRenderers } : {},
+          ...messages ? { messages } : {},
+          ...locale ? { locale } : {},
+          ...ariaLabel ? { "aria-label": ariaLabel } : {},
+          ...ariaLabelledby ? { "aria-labelledby": ariaLabelledby } : {}
+        }
+      ),
+      editor && editable && selectionMenu ? /* @__PURE__ */ jsx22(BubbleMenu, { editor, surfaceRef, onOpenLink: openLinkDialog, ...openAi ? { onOpenAi: openAi } : {}, announce }) : null,
+      editor && editable && slash ? /* @__PURE__ */ jsx22(
+        SlashMenu,
+        {
+          view: slash,
+          activeIndex: slashIndex,
+          surfaceRef,
+          onHover: onSlashHover,
+          onSelect: onSlashSelect,
+          onIds: onSlashIds
+        }
+      ) : null,
+      editor && dialog?.kind === "block-menu" ? /* @__PURE__ */ jsx22(BlockMenu, { editor, surfaceRef, onClose: closeDialog, announce }) : null,
+      editor && dialog?.kind === "ai" ? /* @__PURE__ */ jsx22(AiAssistMenu, { assist, editor, onClose: closeDialog }) : null
+    ] }),
+    /* @__PURE__ */ jsx22(LiveRegion, { message: statusMessage }),
+    editor && dialog?.kind === "link" ? /* @__PURE__ */ jsx22(LinkDialog, { editor, initialHref: dialog.href, onClose: closeDialog, announce }) : null,
+    editor && dialog?.kind === "image" ? /* @__PURE__ */ jsx22(ImageDialog, { editor, ...dialog.pos === void 0 ? {} : { pos: dialog.pos }, onClose: closeDialog, announce }) : null
+  ] }) }) }) });
+}
+export {
+  AiAssistMenu,
+  BLOCK_KINDS,
+  Editor,
+  EditorToolbar,
+  EditorView,
+  EmbedPreview,
+  allSlashItems,
+  createExtensions,
+  createRuntime,
+  createTranslator,
+  defaultMessages,
+  filterSlashItems,
+  formatMessage,
+  mergeMessages,
+  textToContent,
+  useAiAssist,
+  useMessages,
+  useTranslator
+};
+//# sourceMappingURL=react.js.map