@tessera-editor/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2538 @@
+// src/nodes/hint.ts
+import { Node, mergeAttributes, wrappingInputRule } from "@tiptap/core";
+var Hint = Node.create({
+  name: "hint",
+  group: "block",
+  content: "block+",
+  defining: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      variant: {
+        default: "info",
+        parseHTML: (element) => element.getAttribute("data-variant") || "info",
+        renderHTML: (attributes) => ({ "data-variant": String(attributes.variant) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="hint"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({ "data-type": "hint" }, this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setHint: (variant = "info") => ({ commands }) => commands.wrapIn(this.name, { variant }),
+      toggleHint: () => ({ commands }) => commands.toggleWrap(this.name)
+    };
+  },
+  addInputRules() {
+    return [
+      wrappingInputRule({
+        find: /^(!{2}) $/,
+        type: this.type,
+        keepMarks: true,
+        keepAttributes: true
+      })
+    ];
+  }
+});
+
+// src/nodes/collapsible.ts
+import { Node as Node2, mergeAttributes as mergeAttributes2, InputRule } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+function collapsibleJSON() {
+  return {
+    type: "collapsible",
+    attrs: { open: true },
+    content: [
+      { type: "collapsibleSummary" },
+      {
+        type: "collapsibleContent",
+        content: [{ type: "paragraph" }]
+      }
+    ]
+  };
+}
+var Collapsible = Node2.create({
+  name: "collapsible",
+  group: "block",
+  content: "collapsibleSummary collapsibleContent",
+  defining: true,
+  isolating: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      open: {
+        default: true,
+        parseHTML: (element) => element.getAttribute("data-open") !== "false",
+        renderHTML: (attributes) => ({ "data-open": String(attributes.open) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="collapsible"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-type": "collapsible" }, this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      insertCollapsible: () => ({ state, chain }) => {
+        const { $from } = state.selection;
+        if ($from.parent.type.name !== "paragraph") {
+          return false;
+        }
+        const from = $from.before();
+        const to = $from.after();
+        return chain().insertContentAt({ from, to }, collapsibleJSON()).command(({ tr, dispatch }) => {
+          if (dispatch) {
+            tr.setSelection(TextSelection.near(tr.doc.resolve(from + 2)));
+          }
+          return true;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      new InputRule({
+        find: /^(>{2}) $/,
+        handler: ({ state, range, chain }) => {
+          const $from = state.doc.resolve(range.from);
+          if ($from.parent.type.name !== "paragraph") {
+            return;
+          }
+          const from = $from.before();
+          const to = $from.after();
+          chain().insertContentAt({ from, to }, collapsibleJSON()).command(({ tr, dispatch }) => {
+            if (dispatch) {
+              tr.setSelection(TextSelection.near(tr.doc.resolve(from + 2)));
+            }
+            return true;
+          }).run();
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    const nodeName = this.name;
+    return [
+      new Plugin({
+        key: new PluginKey("tesseraCollapsibleToggle"),
+        props: {
+          // Click on the summary toggles open/closed; collapsed state survives reload
+          // because it is a node attribute, not CSS state.
+          handleClickOn: (view, _pos, node, nodePos, event) => {
+            if (node.type.name !== nodeName) {
+              return false;
+            }
+            const target = event.target;
+            if (!target?.closest('[data-type="collapsible-summary"]')) {
+              return false;
+            }
+            view.dispatch(
+              view.state.tr.setNodeMarkup(nodePos, void 0, {
+                ...node.attrs,
+                open: !node.attrs.open
+              })
+            );
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+var CollapsibleSummary = Node2.create({
+  name: "collapsibleSummary",
+  group: "",
+  content: "inline*",
+  defining: true,
+  parseHTML() {
+    return [{ tag: 'div[data-type="collapsible-summary"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-type": "collapsible-summary" }, HTMLAttributes), 0];
+  }
+});
+var CollapsibleContent = Node2.create({
+  name: "collapsibleContent",
+  group: "",
+  content: "block+",
+  parseHTML() {
+    return [{ tag: 'div[data-type="collapsible-content"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes2({ "data-type": "collapsible-content" }, HTMLAttributes), 0];
+  }
+});
+
+// src/nodes/image.ts
+import { Node as Node3, mergeAttributes as mergeAttributes3 } from "@tiptap/core";
+var ImageBlock = Node3.create({
+  name: "imageBlock",
+  inline: false,
+  group: "block",
+  draggable: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      src: { default: null },
+      alt: { default: null },
+      title: { default: null },
+      width: { default: null },
+      align: { default: "center" }
+    };
+  },
+  parseHTML() {
+    return [
+      { tag: 'img[data-type="tessera-image"]' },
+      // plain <img> pasted from outside becomes a block image
+      { tag: "img[src]:not([data-type])" }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const style = node.attrs.width ? `width: ${Number(node.attrs.width)}px` : void 0;
+    return [
+      "img",
+      mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": "tessera-image",
+        "data-align": String(node.attrs.align),
+        style
+      })
+    ];
+  },
+  addCommands() {
+    return {
+      setImage: (options) => ({ commands }) => commands.insertContent({ type: this.name, attrs: options })
+    };
+  }
+});
+
+// src/nodes/table.ts
+import { Table, TableRow, TableCell, TableHeader } from "@tiptap/extension-table";
+var TABLE_COLUMN_KINDS = [
+  "text",
+  "checkbox",
+  "select",
+  "multiSelect",
+  "number",
+  "date",
+  "link"
+];
+function tableToCsvAt(editor) {
+  const table = locateTable(editor.state);
+  return table ? tableNodeToCsv(table.node) : null;
+}
+function locateTable(state) {
+  const { $from } = state.selection;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type.name === "table") {
+      return { pos: $from.before(depth), node };
+    }
+  }
+  return null;
+}
+function columnCount(table) {
+  const firstRow = table.content.firstChild;
+  return firstRow ? firstRow.childCount : 0;
+}
+function normalizeTypes(types, cols) {
+  const list = Array.isArray(types) ? [...types] : [];
+  while (list.length < cols) {
+    list.push("text");
+  }
+  return list.slice(0, cols);
+}
+function cellSortValue(row, index, kind) {
+  const cell = row.maybeChild(index);
+  if (!cell) {
+    return null;
+  }
+  const value = cell.attrs.value;
+  switch (kind) {
+    case "checkbox":
+      return value === true || value === "true";
+    case "number": {
+      if (typeof value === "number") {
+        return value;
+      }
+      const parsed = Number(String(value ?? cell.textContent).trim());
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    case "date":
+      return typeof value === "string" && value ? value : null;
+    case "select":
+      return Array.isArray(value) ? value[0] ?? null : value ?? null;
+    case "multiSelect":
+      return Array.isArray(value) ? [...value].sort().join(" \u2027 ") : null;
+    default:
+      return cell.textContent.trim() || null;
+  }
+}
+function csvEscape(text) {
+  if (/[",\n]/.test(text)) {
+    return `"${text.replace(/"/g, '""')}"`;
+  }
+  return text;
+}
+function tableNodeToCsv(table) {
+  const types = normalizeTypes(table.attrs.types, columnCount(table));
+  const lines = [];
+  table.forEach((row) => {
+    const isHeaderRow = row.content.firstChild?.type.name === "tableHeader";
+    const cells = [];
+    row.forEach((cell, _offset, index) => {
+      const kind = isHeaderRow ? "text" : types[index] ?? "text";
+      const value = cell.attrs.value;
+      let text;
+      switch (kind) {
+        case "checkbox":
+          text = value === true || value === "true" ? "\u2714" : "";
+          break;
+        case "select":
+        case "multiSelect":
+          text = Array.isArray(value) ? value.join(" / ") : String(value ?? "");
+          break;
+        case "date":
+          text = String(value ?? "");
+          break;
+        case "number":
+        case "link":
+          text = value === null || value === void 0 ? cell.textContent : String(value);
+          break;
+        default:
+          text = cell.textContent;
+      }
+      cells.push(csvEscape(text.trim()));
+    });
+    lines.push(cells.join(","));
+  });
+  return lines.join("\n");
+}
+var AiTable = Table.extend({
+  name: "table",
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      types: {
+        default: [],
+        parseHTML: (element) => {
+          try {
+            const raw = element.getAttribute("data-types");
+            return raw ? JSON.parse(raw) : [];
+          } catch {
+            return [];
+          }
+        },
+        renderHTML: (attributes) => ({
+          "data-types": JSON.stringify(attributes.types ?? [])
+        })
+      },
+      freezeFirstCol: {
+        default: true,
+        parseHTML: (element) => element.getAttribute("data-freeze-first") !== "false",
+        renderHTML: (attributes) => ({ "data-freeze-first": String(attributes.freezeFirstCol) })
+      }
+    };
+  },
+  addCommands() {
+    const parent = this.parent?.() ?? {};
+    return {
+      ...parent,
+      insertTableTyped: (options = {}) => ({ commands }) => commands.insertTable({
+        rows: options.rows ?? 3,
+        cols: options.cols ?? 3,
+        withHeaderRow: options.withHeaderRow ?? true
+      }),
+      setColumnType: (index, kind) => ({ state, dispatch, tr }) => {
+        const table = locateTable(state);
+        if (!table || index < 0 || index >= columnCount(table.node)) {
+          return false;
+        }
+        const types = normalizeTypes(table.node.attrs.types, columnCount(table.node));
+        types[index] = kind;
+        if (dispatch) {
+          tr.setNodeMarkup(table.pos, void 0, { ...table.node.attrs, types });
+          dispatch(tr);
+        }
+        return true;
+      },
+      sortTableByColumn: (index, direction) => ({ state, dispatch, tr }) => {
+        const table = locateTable(state);
+        if (!table) {
+          return false;
+        }
+        const rows = [];
+        table.node.forEach((row) => rows.push(row));
+        const hasHeader = rows.length > 0 && rows[0].content.firstChild?.type.name === "tableHeader";
+        const header = hasHeader ? rows[0] : null;
+        const body = hasHeader ? rows.slice(1) : rows.slice();
+        if (body.length === 0 || index >= columnCount(table.node)) {
+          return false;
+        }
+        const types = normalizeTypes(table.node.attrs.types, columnCount(table.node));
+        const kind = types[index] ?? "text";
+        const dir = direction === "asc" ? 1 : -1;
+        const sorted = [...body].sort((a, b) => {
+          const va = cellSortValue(a, index, kind);
+          const vb = cellSortValue(b, index, kind);
+          if (va === vb) {
+            return 0;
+          }
+          if (va === null) {
+            return 1;
+          }
+          if (vb === null) {
+            return -1;
+          }
+          return va < vb ? -dir : dir;
+        });
+        const start = table.pos + 1 + (header ? header.nodeSize : 0);
+        const end = table.pos + table.node.nodeSize - 1;
+        if (dispatch) {
+          tr.replaceWith(start, end, sorted);
+          dispatch(tr);
+        }
+        return true;
+      }
+    };
+  }
+});
+function valueAttr() {
+  return {
+    default: null,
+    parseHTML: (element) => {
+      const raw = element.getAttribute("data-value");
+      if (raw === null || raw === "") {
+        return null;
+      }
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    },
+    renderHTML: (attributes) => ({
+      "data-value": attributes.value === null || attributes.value === void 0 ? "" : JSON.stringify(attributes.value)
+    })
+  };
+}
+var AiTableCell = TableCell.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      value: valueAttr()
+    };
+  }
+});
+var AiTableHeader = TableHeader.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      value: valueAttr()
+    };
+  }
+});
+
+// src/nodes/embed.ts
+import { Node as Node4, mergeAttributes as mergeAttributes4 } from "@tiptap/core";
+var EmbedBlock = Node4.create({
+  name: "embedBlock",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      src: { default: null },
+      title: { default: null },
+      height: { default: 360 },
+      allowScripts: { default: false }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="tessera-embed"]' }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes4(HTMLAttributes, {
+        "data-type": "tessera-embed",
+        "data-src": String(node.attrs.src ?? ""),
+        "data-height": String(node.attrs.height),
+        "data-allow-scripts": String(node.attrs.allowScripts)
+      })
+    ];
+  },
+  addCommands() {
+    return {
+      insertEmbed: (attrs) => ({ commands }) => commands.insertContent({ type: this.name, attrs })
+    };
+  }
+});
+
+// src/nodes/toc.ts
+import { Node as Node5, mergeAttributes as mergeAttributes5 } from "@tiptap/core";
+var TocBlock = Node5.create({
+  name: "tocBlock",
+  group: "block",
+  atom: true,
+  draggable: true,
+  parseHTML() {
+    return [{ tag: 'div[data-type="tessera-toc"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes5(HTMLAttributes, { "data-type": "tessera-toc" })];
+  },
+  addCommands() {
+    return {
+      insertToc: () => ({ commands }) => commands.insertContent({ type: this.name })
+    };
+  }
+});
+
+// src/marks/ai.ts
+import { Mark, mergeAttributes as mergeAttributes6 } from "@tiptap/core";
+var AiAttribution = Mark.create({
+  name: "aiAttribution",
+  inclusive: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      pending: {
+        default: true,
+        parseHTML: (element) => element.getAttribute("data-pending") !== "false",
+        renderHTML: (attributes) => ({ "data-pending": String(attributes.pending) })
+      },
+      action: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-action"),
+        renderHTML: (attributes) => attributes.action ? { "data-action": String(attributes.action) } : {}
+      },
+      agent: {
+        default: "ai",
+        parseHTML: (element) => element.getAttribute("data-agent") ?? "ai",
+        renderHTML: (attributes) => ({ "data-agent": String(attributes.agent) })
+      },
+      ts: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-ai]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes6({ "data-ai": "" }, this.options.HTMLAttributes, HTMLAttributes)];
+  }
+});
+
+// src/marks/comment.ts
+import { Mark as Mark2, Extension, mergeAttributes as mergeAttributes7 } from "@tiptap/core";
+import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+var CommentMark = Mark2.create({
+  name: "comment",
+  inclusive: false,
+  addAttributes() {
+    return {
+      threadId: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-thread-id"),
+        renderHTML: (attributes) => ({ "data-thread-id": String(attributes.threadId ?? "") })
+      },
+      resolved: {
+        default: false,
+        parseHTML: (element) => element.getAttribute("data-resolved") === "true",
+        renderHTML: (attributes) => ({ "data-resolved": String(attributes.resolved) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-thread-id]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes7({ "data-comment": "" }, HTMLAttributes)];
+  }
+});
+function listCommentRanges(state) {
+  const seen = /* @__PURE__ */ new Map();
+  state.doc.descendants((node, pos) => {
+    for (const m of node.marks) {
+      if (m.type.name === "comment" && typeof m.attrs.threadId === "string") {
+        const from = pos;
+        const to = pos + node.nodeSize;
+        const existing = seen.get(m.attrs.threadId);
+        if (!existing) {
+          seen.set(m.attrs.threadId, { threadId: m.attrs.threadId, from, to, resolved: Boolean(m.attrs.resolved) });
+        } else {
+          existing.to = Math.max(existing.to, to);
+          existing.resolved = existing.resolved && Boolean(m.attrs.resolved);
+        }
+      }
+    }
+    return true;
+  });
+  return [...seen.values()].sort((a, b) => a.from - b.from);
+}
+var CommentCommands = Extension.create({
+  name: "tesseraCommentCommands",
+  addCommands() {
+    return {
+      addCommentThread: (threadId) => ({ commands }) => commands.setMark("comment", { threadId, resolved: false }),
+      setCommentResolved: (threadId, resolved) => ({ state, tr, dispatch }) => {
+        let touched = false;
+        state.doc.descendants((node, pos) => {
+          node.marks.filter((m) => m.type.name === "comment" && m.attrs.threadId === threadId).forEach((m) => {
+            const next = state.schema.marks.comment.create({ ...m.attrs, resolved });
+            tr.removeMark(pos, pos + node.nodeSize, m);
+            tr.addMark(pos, pos + node.nodeSize, next);
+            touched = true;
+          });
+          return true;
+        });
+        if (touched && dispatch) {
+          dispatch(tr);
+        }
+        return touched;
+      },
+      removeCommentThread: (threadId) => ({ state, tr, dispatch }) => {
+        let touched = false;
+        state.doc.descendants((node, pos) => {
+          if (node.marks.some((m) => m.type.name === "comment" && m.attrs.threadId === threadId)) {
+            tr.removeMark(pos, pos + node.nodeSize, state.schema.marks.comment);
+            touched = true;
+          }
+          return true;
+        });
+        if (touched && dispatch) {
+          dispatch(tr);
+        }
+        return touched;
+      },
+      focusNextCommentThread: () => ({ state, tr, dispatch }) => {
+        const ranges = listCommentRanges(state);
+        if (ranges.length === 0) {
+          return false;
+        }
+        const anchor = state.selection.from;
+        const next = ranges.find((r) => r.from > anchor) ?? ranges[0];
+        if (dispatch) {
+          tr.setSelection(TextSelection2.create(state.doc, next.from, next.to));
+          dispatch(tr);
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// src/marks/placeholder.ts
+import { Mark as Mark3, mergeAttributes as mergeAttributes8, Extension as Extension2 } from "@tiptap/core";
+var PlaceholderMark = Mark3.create({
+  name: "tesseraPlaceholder",
+  addAttributes() {
+    return {
+      kind: {
+        default: "text",
+        parseHTML: (element) => element.getAttribute("data-kind") ?? "text",
+        renderHTML: (attributes) => ({ "data-kind": String(attributes.kind) })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="tessera-placeholder"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes8({ "data-type": "tessera-placeholder" }, HTMLAttributes)];
+  }
+});
+var PlaceholderCommands = Extension2.create({
+  name: "tesseraPlaceholderCommands",
+  addCommands() {
+    return {
+      togglePlaceholderMark: (kind = "text") => ({ commands }) => commands.toggleMark("tesseraPlaceholder", { kind }),
+      insertPlaceholderToken: (kind, label) => ({ chain }) => chain().insertContent({
+        type: "text",
+        text: label,
+        marks: [{ type: "tesseraPlaceholder", attrs: { kind } }]
+      }).run()
+    };
+  }
+});
+
+// src/extensions/input-rules.ts
+import { Extension as Extension3, wrappingInputRule as wrappingInputRule2, markInputRule } from "@tiptap/core";
+var TesseraInputRules = Extension3.create({
+  name: "tesseraInputRules",
+  addInputRules() {
+    const taskList = this.editor.schema.nodes.taskList;
+    const highlight = this.editor.schema.marks.highlight;
+    const rules = [];
+    if (taskList) {
+      rules.push(
+        wrappingInputRule2({
+          find: /^\[\] $/,
+          type: taskList
+        })
+      );
+    }
+    if (highlight) {
+      rules.push(
+        markInputRule({
+          find: /::([^:]+)::$/,
+          type: highlight
+        })
+      );
+    }
+    return rules;
+  }
+});
+
+// src/extensions/shortcuts.ts
+import { Extension as Extension4 } from "@tiptap/core";
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+var TesseraShortcuts = Extension4.create({
+  name: "tesseraShortcuts",
+  priority: 500,
+  addCommands() {
+    return {
+      moveBlockUp: () => ({ state, tr, dispatch }) => swapBlock(state, tr, dispatch, -1),
+      moveBlockDown: () => ({ state, tr, dispatch }) => swapBlock(state, tr, dispatch, 1)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-1": () => this.editor.commands.toggleHeading({ level: 1 }),
+      "Mod-Shift-2": () => this.editor.commands.toggleHeading({ level: 2 }),
+      "Mod-Shift-3": () => this.editor.commands.toggleHeading({ level: 3 }),
+      "Mod-Shift-4": () => this.editor.commands.toggleHeading({ level: 4 }),
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList(),
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList(),
+      "Mod-Shift-c": () => this.editor.commands.toggleTaskList(),
+      "Mod-Alt-h": () => this.editor.commands.toggleHint(),
+      "Mod-j": () => this.editor.commands.toggleCode(),
+      "Mod-Shift-9": () => this.editor.commands.toggleCodeBlock(),
+      "Mod-Shift-.": () => this.editor.commands.toggleBlockquote(),
+      "Mod-e": () => {
+        this.editor.emit("tessera:formatPanel", { kind: "color" });
+        return true;
+      },
+      "Mod-k": () => {
+        this.editor.emit("tessera:linkPanel", {});
+        return true;
+      },
+      "Mod-f": () => {
+        this.editor.emit("tessera:findPanel", {});
+        return true;
+      },
+      "Mod-Shift-k": () => {
+        this.editor.emit("tessera:askPanel", {});
+        return true;
+      },
+      "Mod-Alt-s": () => this.editor.commands.insertTableTyped({ withHeaderRow: true }),
+      "Mod-Alt-t": () => this.editor.commands.insertTableTyped({ withHeaderRow: false }),
+      "Mod-Alt-p": () => this.editor.commands.togglePlaceholderMark("text"),
+      "Mod-Alt-m": () => {
+        this.editor.emit("tessera:commentPanel", {});
+        return true;
+      },
+      "Alt-ArrowUp": () => this.editor.commands.moveBlockUp(),
+      "Alt-ArrowDown": () => this.editor.commands.moveBlockDown()
+    };
+  }
+});
+function swapBlock(state, tr, dispatch, direction) {
+  const { $from } = state.selection;
+  if ($from.depth < 1) {
+    return false;
+  }
+  const index = $from.index(0);
+  const other = index + direction;
+  if (other < 0 || other >= state.doc.childCount) {
+    return false;
+  }
+  const node = state.doc.child(index);
+  const otherNode = state.doc.child(other);
+  const pos = $from.before(1);
+  const nodeStart = direction === -1 ? pos - otherNode.nodeSize : pos;
+  const rangeEnd = nodeStart + otherNode.nodeSize + node.nodeSize;
+  if (dispatch) {
+    const content = direction === -1 ? [node, otherNode] : [otherNode, node];
+    tr.replaceWith(nodeStart, rangeEnd, content);
+    const anchor = tr.mapping.map(state.selection.anchor);
+    tr.setSelection(TextSelection3.near(tr.doc.resolve(Math.min(anchor, tr.doc.content.size))));
+    dispatch(tr);
+  }
+  return true;
+}
+
+// src/extensions/find-replace.ts
+import { Extension as Extension5 } from "@tiptap/core";
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var findReplaceKey = new PluginKey2("tesseraFindReplace");
+function computeMatches(doc, query) {
+  if (!query) {
+    return [];
+  }
+  const matches = [];
+  const needle = query.toLowerCase();
+  doc.descendants((node, pos) => {
+    if (node.isText && node.text) {
+      const haystack = node.text.toLowerCase();
+      let idx = haystack.indexOf(needle);
+      while (idx !== -1) {
+        matches.push({ from: pos + idx, to: pos + idx + needle.length });
+        idx = haystack.indexOf(needle, idx + needle.length);
+      }
+    }
+    return true;
+  });
+  return matches;
+}
+var TesseraFindReplace = Extension5.create({
+  name: "tesseraFindReplace",
+  addStorage() {
+    return {
+      query: "",
+      matches: [],
+      active: 0,
+      visible: false
+    };
+  },
+  addCommands() {
+    return {
+      openFindPanel: () => ({ tr, dispatch }) => {
+        if (dispatch) {
+          tr.setMeta(findReplaceKey, { type: "open" });
+          dispatch(tr);
+        }
+        return true;
+      },
+      closeFindPanel: () => ({ tr, dispatch }) => {
+        if (dispatch) {
+          tr.setMeta(findReplaceKey, { type: "close" });
+          dispatch(tr);
+        }
+        return true;
+      },
+      setFindQuery: (query) => ({ tr, dispatch }) => {
+        if (dispatch) {
+          tr.setMeta(findReplaceKey, { type: "query", query });
+          dispatch(tr);
+        }
+        return true;
+      },
+      findNext: () => ({ tr, state, dispatch }) => {
+        const s = findReplaceKey.getState(state);
+        if (!s || s.matches.length === 0) {
+          return false;
+        }
+        if (dispatch) {
+          tr.setMeta(findReplaceKey, { type: "active", active: (s.active + 1) % s.matches.length });
+          dispatch(tr);
+        }
+        return true;
+      },
+      findPrev: () => ({ tr, state, dispatch }) => {
+        const s = findReplaceKey.getState(state);
+        if (!s || s.matches.length === 0) {
+          return false;
+        }
+        if (dispatch) {
+          tr.setMeta(findReplaceKey, {
+            type: "active",
+            active: (s.active - 1 + s.matches.length) % s.matches.length
+          });
+          dispatch(tr);
+        }
+        return true;
+      },
+      replaceCurrent: (replacement) => ({ state, tr, dispatch }) => {
+        const s = findReplaceKey.getState(state);
+        if (!s || s.matches.length === 0) {
+          return false;
+        }
+        const m = s.matches[s.active];
+        if (!m) {
+          return false;
+        }
+        if (dispatch) {
+          tr.insertText(replacement, m.from, m.to);
+          tr.setMeta(findReplaceKey, { type: "requery" });
+          dispatch(tr);
+        }
+        return true;
+      },
+      replaceAll: (replacement) => ({ state, tr, dispatch }) => {
+        const s = findReplaceKey.getState(state);
+        if (!s || s.matches.length === 0) {
+          return false;
+        }
+        if (dispatch) {
+          for (let i = s.matches.length - 1; i >= 0; i--) {
+            const m = s.matches[i];
+            tr.insertText(replacement, m.from, m.to);
+          }
+          tr.setMeta(findReplaceKey, { type: "requery" });
+          dispatch(tr);
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin2({
+        key: findReplaceKey,
+        state: {
+          init: () => ({ query: "", matches: [], active: 0, visible: false }),
+          apply: (tr, prev, _oldState, newState) => {
+            const meta = tr.getMeta(findReplaceKey);
+            let next = null;
+            if (meta?.type === "open") {
+              next = { ...prev, visible: true };
+            } else if (meta?.type === "close") {
+              next = { ...prev, visible: false, matches: [], query: "", active: 0 };
+            } else if (meta?.type === "query") {
+              const matches = computeMatches(newState.doc, meta.query);
+              next = { query: meta.query, matches, active: 0, visible: true };
+            } else if (meta?.type === "active") {
+              next = { ...prev, active: meta.active };
+            } else if (meta?.type === "requery") {
+              next = { ...prev, matches: [], active: 0 };
+            }
+            if (!next) {
+              if (prev.query && prev.visible && tr.docChanged) {
+                const matches = computeMatches(newState.doc, prev.query);
+                return { ...prev, matches, active: 0 };
+              }
+              return prev;
+            }
+            this.storage.query = next.query;
+            this.storage.matches = next.matches;
+            this.storage.active = next.active;
+            this.storage.visible = next.visible;
+            return next;
+          }
+        },
+        props: {
+          decorations(state) {
+            const s = findReplaceKey.getState(state);
+            if (!s || !s.visible || s.matches.length === 0) {
+              return DecorationSet.empty;
+            }
+            const decorations = s.matches.map(
+              (m, i) => Decoration.inline(m.from, m.to, {
+                class: i === s.active ? "tessera-find-match tessera-find-match--active" : "tessera-find-match"
+              })
+            );
+            return DecorationSet.create(state.doc, decorations);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/slash.ts
+import { Extension as Extension6 } from "@tiptap/core";
+import Suggestion from "@tiptap/suggestion";
+import { PluginKey as PluginKey3 } from "@tiptap/pm/state";
+
+// src/i18n.ts
+var tesseraMessages = {
+  "zh-CN": {
+    // placeholder
+    placeholderEmpty: "\u8F93\u5165 / \u5524\u8D77\u83DC\u5355\uFF0C\u6216\u76F4\u63A5\u5F00\u59CB\u4E66\u5199\u2026",
+    // slash menu groups
+    groupBasic: "\u57FA\u7840\u5757",
+    groupAdvanced: "\u9AD8\u7EA7\u5757",
+    groupAi: "AI",
+    // slash items
+    itemText: "\u6587\u672C",
+    itemTextDesc: "\u666E\u901A\u6BB5\u843D",
+    itemH1: "\u6807\u9898 1",
+    itemH2: "\u6807\u9898 2",
+    itemH3: "\u6807\u9898 3",
+    itemH4: "\u6807\u9898 4",
+    itemBullet: "\u65E0\u5E8F\u5217\u8868",
+    itemBulletDesc: "\u7B80\u5355\u7684\u9879\u76EE\u7B26\u53F7\u5217\u8868",
+    itemOrdered: "\u6709\u5E8F\u5217\u8868",
+    itemOrderedDesc: "\u5E26\u7F16\u53F7\u7684\u5217\u8868",
+    itemTask: "\u4EFB\u52A1\u6E05\u5355",
+    itemTaskDesc: "\u7528\u590D\u9009\u6846\u8DDF\u8E2A\u5F85\u529E",
+    itemQuote: "\u5F15\u7528",
+    itemQuoteDesc: "\u5F15\u7528\u4E00\u6BB5\u6587\u5B57",
+    itemCode: "\u4EE3\u7801\u5757",
+    itemCodeDesc: "\u5E26\u8BED\u6CD5\u9AD8\u4EAE\u7684\u4EE3\u7801",
+    itemDivider: "\u5206\u5272\u7EBF",
+    itemDividerDesc: "\u6C34\u5E73\u5206\u5272\u7EBF",
+    itemHint: "\u63D0\u793A\u5757",
+    itemHintDesc: "\u9192\u76EE\u7684\u4FE1\u606F/\u8B66\u544A\u5BB9\u5668\uFF08!! + \u7A7A\u683C\uFF09",
+    itemCollapsible: "\u6298\u53E0\u5757",
+    itemCollapsibleDesc: "\u53EF\u6298\u53E0\u7684\u5185\u5BB9\u533A\uFF08>> + \u7A7A\u683C\uFF09",
+    itemImage: "\u56FE\u7247",
+    itemImageDesc: "\u4E0A\u4F20\u6216\u7C98\u8D34\u56FE\u7247",
+    itemImageUrl: "\u56FE\u7247\u94FE\u63A5",
+    // AI slash items
+    itemSummarize: "AI \u6458\u8981",
+    itemSummarizeDesc: "\u4E3A\u6574\u7BC7\u6587\u6863\u751F\u6210 TL;DR",
+    itemAsk: "AI \u95EE\u7B54",
+    itemAskDesc: "\u9488\u5BF9\u5F53\u524D\u6587\u6863\u63D0\u95EE",
+    itemImprove: "AI \u6539\u5199",
+    itemImproveDesc: "\u6539\u5199\u9009\u4E2D\u7684\u6587\u5B57",
+    // selection toolbar
+    tooltipBold: "\u52A0\u7C97",
+    tooltipItalic: "\u659C\u4F53",
+    tooltipUnderline: "\u4E0B\u5212\u7EBF",
+    tooltipStrike: "\u5220\u9664\u7EBF",
+    tooltipCode: "\u884C\u5185\u4EE3\u7801",
+    tooltipColor: "\u6587\u5B57\u989C\u8272",
+    tooltipHighlight: "\u9AD8\u4EAE",
+    tooltipLink: "\u94FE\u63A5",
+    tooltipComment: "\u8BC4\u8BBA\uFF08v1.x\uFF09",
+    tooltipTurnCollapsible: "\u8F6C\u4E3A\u6298\u53E0\u5757",
+    tooltipMore: "\u66F4\u591A",
+    tooltipImprove: "AI \u6539\u5199",
+    tooltipCopyMarkdown: "\u590D\u5236\u4E3A Markdown",
+    // color/highlight panel
+    colorDefault: "\u9ED8\u8BA4",
+    highlightNone: "\u65E0\u9AD8\u4EAE",
+    // link panel
+    linkPlaceholder: "\u94FE\u63A5\u5730\u5740\u2026",
+    linkApply: "\u5E94\u7528",
+    linkRemove: "\u79FB\u9664\u94FE\u63A5",
+    linkOpen: "\u6253\u5F00",
+    // empty-line toolbar
+    emptyLineExpand: "\u5C55\u5F00\u5168\u90E8\u5757",
+    // find & replace
+    findPlaceholder: "\u67E5\u627E\u2026",
+    replacePlaceholder: "\u66FF\u6362\u4E3A\u2026",
+    findNext: "\u4E0B\u4E00\u4E2A",
+    findPrev: "\u4E0A\u4E00\u4E2A",
+    replaceOne: "\u66FF\u6362",
+    replaceAll: "\u5168\u90E8\u66FF\u6362",
+    findCount: (n) => `${n} \u4E2A\u7ED3\u679C`,
+    findClose: "\u5173\u95ED",
+    // image
+    imageUploadFailed: "\u56FE\u7247\u4E0A\u4F20\u5931\u8D25",
+    imageAlignLeft: "\u5DE6\u5BF9\u9F50",
+    imageAlignCenter: "\u5C45\u4E2D",
+    imageAlignFull: "\u5168\u5BBD",
+    // AI panel
+    aiTitle: "AI",
+    aiAskPlaceholder: "\u9488\u5BF9\u672C\u6587\u6863\u63D0\u95EE\u2026",
+    aiSend: "\u53D1\u9001",
+    aiThinking: "\u601D\u8003\u4E2D\u2026",
+    aiAccept: "\u63A5\u53D7",
+    aiReject: "\u62D2\u7EDD",
+    aiImprovePrompt: "\u6539\u5199\u8981\u6C42\uFF08\u53EF\u9009\uFF09\u2026",
+    aiImproveRun: "\u6267\u884C",
+    aiStreaming: "\u751F\u6210\u4E2D\u2026",
+    aiRuntimeMissing: "\u672A\u6CE8\u5165 AI Runtime\uFF0C\u6B64\u64CD\u4F5C\u4E0D\u53EF\u7528",
+    // v1.1: tables
+    itemTable: "\u8868\u683C",
+    itemTableDesc: "\u5E26\u7C7B\u578B\u5316\u5217\u7684\u7ED3\u6784\u5316\u8868\u683C\uFF08\u2318\u2325S\uFF09",
+    itemTableSimple: "\u65E0\u8868\u5934\u8868\u683C",
+    itemTableSimpleDesc: "\u7EAF\u6587\u672C\u7B80\u6613\u5E03\u5C40\u8868\uFF08\u2318\u2325T\uFF09",
+    colTypeText: "\u6587\u672C",
+    colTypeCheckbox: "\u590D\u9009\u6846",
+    colTypeSelect: "\u5355\u9009\u6807\u7B7E",
+    colTypeMultiSelect: "\u591A\u9009\u6807\u7B7E",
+    colTypeNumber: "\u6570\u5B57",
+    colTypeDate: "\u65E5\u671F",
+    colTypeLink: "\u94FE\u63A5",
+    colMenuTitle: "\u5217\u64CD\u4F5C",
+    colMenuSortAsc: "\u5347\u5E8F\u6392\u5E8F",
+    colMenuSortDesc: "\u964D\u5E8F\u6392\u5E8F",
+    colMenuInsertLeft: "\u5DE6\u4FA7\u63D2\u5165\u5217",
+    colMenuInsertRight: "\u53F3\u4FA7\u63D2\u5165\u5217",
+    colMenuDelete: "\u5220\u9664\u6B64\u5217",
+    colMenuType: "\u5217\u7C7B\u578B",
+    rowMenuTitle: "\u884C\u64CD\u4F5C",
+    rowMenuInsertAbove: "\u4E0A\u65B9\u63D2\u5165\u884C",
+    rowMenuInsertBelow: "\u4E0B\u65B9\u63D2\u5165\u884C",
+    rowMenuDelete: "\u5220\u9664\u6B64\u884C",
+    tableDelete: "\u5220\u9664\u8868\u683C",
+    tableCopyCsv: "\u590D\u5236\u4E3A CSV",
+    tableToggleHeader: "\u5207\u6362\u8868\u5934",
+    cellEmpty: "\u7A7A",
+    // v1.1: history
+    itemHistory: "\u7248\u672C\u5386\u53F2",
+    historyTitle: "\u7248\u672C\u5386\u53F2",
+    historyEmpty: "\u6682\u65E0\u5FEB\u7167\uFF08\u7F16\u8F91\u540E\u7A7A\u95F2\u81EA\u52A8\u4FDD\u5B58\uFF0C\u6216\u624B\u52A8\u6355\u83B7\uFF09",
+    historyCapture: "\u6355\u83B7\u5FEB\u7167",
+    historyRestore: "\u6062\u590D\u6B64\u7248\u672C",
+    historyCurrent: "\u5F53\u524D",
+    historyDiffAdded: "\u65B0\u589E",
+    historyDiffRemoved: "\u5220\u9664",
+    historyDiffChanged: "\u4FEE\u6539",
+    historyConfirmRestore: "\u6062\u590D\u5230\u8BE5\u7248\u672C\uFF1F\u5F53\u524D\u5185\u5BB9\u5C06\u88AB\u66FF\u6362\uFF08\u53EF\u64A4\u9500\uFF09",
+    // v1.1: comments
+    tooltipCommentV11: "\u8BC4\u8BBA",
+    commentTitle: "\u8BC4\u8BBA",
+    commentEmpty: "\u6682\u65E0\u8BC4\u8BBA",
+    commentPlaceholder: "\u5199\u4E0B\u8BC4\u8BBA\u2026\uFF08Shift+Enter \u6362\u884C\uFF09",
+    commentSend: "\u53D1\u9001",
+    commentResolve: "\u89E3\u51B3",
+    commentReopen: "\u91CD\u65B0\u6253\u5F00",
+    commentDelete: "\u5220\u9664",
+    commentResolvedBadge: "\u5DF2\u89E3\u51B3",
+    commentCount: (n) => `${n} \u6761\u8BC4\u8BBA`,
+    // v1.1: embed / toc / placeholder
+    itemEmbed: "\u5D4C\u5165",
+    itemEmbedDesc: "\u5D4C\u5165\u5916\u90E8\u7F51\u9875\uFF08iframe \u6C99\u7BB1\uFF09",
+    itemToc: "\u76EE\u5F55",
+    itemTocDesc: "\u81EA\u52A8\u751F\u6210\u5168\u6587\u5927\u7EB2\uFF08H1\u2013H4\uFF09",
+    embedPlaceholder: "\u7C98\u8D34\u8981\u5D4C\u5165\u7684\u94FE\u63A5\u2026",
+    embedApply: "\u5D4C\u5165",
+    embedInvalid: "\u65E0\u6548\u94FE\u63A5",
+    embedOpen: "\u6253\u5F00\u539F\u94FE\u63A5",
+    tocEmpty: "\u6682\u65E0\u6807\u9898\u2014\u2014\u6DFB\u52A0 H1\u2013H4 \u540E\u81EA\u52A8\u51FA\u73B0",
+    placeholderText: "\u5F85\u8865\u5145",
+    placeholderPerson: "\u5F85\u586B\u4EBA",
+    placeholderDate: "\u5F85\u586B\u65E5\u671F",
+    // v1.1: block context menu
+    menuCopyAnchor: "\u590D\u5236\u951A\u94FE\u63A5",
+    menuCopyBlockId: "\u590D\u5236\u5757 ID",
+    menuDeleteBlock: "\u5220\u9664\u6B64\u5757"
+  },
+  "en-US": {
+    placeholderEmpty: "Type / for blocks, or just start writing\u2026",
+    groupBasic: "Basic blocks",
+    groupAdvanced: "Advanced blocks",
+    groupAi: "AI",
+    itemText: "Text",
+    itemTextDesc: "Plain paragraph",
+    itemH1: "Heading 1",
+    itemH2: "Heading 2",
+    itemH3: "Heading 3",
+    itemH4: "Heading 4",
+    itemBullet: "Bullet list",
+    itemBulletDesc: "Simple bulleted list",
+    itemOrdered: "Numbered list",
+    itemOrderedDesc: "List with numbering",
+    itemTask: "Task list",
+    itemTaskDesc: "Track to-dos with checkboxes",
+    itemQuote: "Quote",
+    itemQuoteDesc: "Quote a passage",
+    itemCode: "Code block",
+    itemCodeDesc: "Code with syntax highlighting",
+    itemDivider: "Divider",
+    itemDividerDesc: "Horizontal rule",
+    itemHint: "Hint",
+    itemHintDesc: "Callout container (!! + space)",
+    itemCollapsible: "Collapsible",
+    itemCollapsibleDesc: "Foldable section (>> + space)",
+    itemImage: "Image",
+    itemImageDesc: "Upload or paste an image",
+    itemImageUrl: "Image URL",
+    itemSummarize: "AI Summarize",
+    itemSummarizeDesc: "Generate a TL;DR for this doc",
+    itemAsk: "AI Ask",
+    itemAskDesc: "Ask questions about this doc",
+    itemImprove: "AI Improve",
+    itemImproveDesc: "Rewrite the selection",
+    tooltipBold: "Bold",
+    tooltipItalic: "Italic",
+    tooltipUnderline: "Underline",
+    tooltipStrike: "Strikethrough",
+    tooltipCode: "Inline code",
+    tooltipColor: "Text color",
+    tooltipHighlight: "Highlight",
+    tooltipLink: "Link",
+    tooltipComment: "Comment (v1.x)",
+    tooltipTurnCollapsible: "Turn into collapsible",
+    tooltipMore: "More",
+    tooltipImprove: "AI Improve",
+    tooltipCopyMarkdown: "Copy as Markdown",
+    colorDefault: "Default",
+    highlightNone: "No highlight",
+    linkPlaceholder: "Link URL\u2026",
+    linkApply: "Apply",
+    linkRemove: "Remove link",
+    linkOpen: "Open",
+    emptyLineExpand: "Show all blocks",
+    findPlaceholder: "Find\u2026",
+    replacePlaceholder: "Replace with\u2026",
+    findNext: "Next",
+    findPrev: "Prev",
+    replaceOne: "Replace",
+    replaceAll: "Replace all",
+    findCount: (n) => `${n} result${n === 1 ? "" : "s"}`,
+    findClose: "Close",
+    imageUploadFailed: "Image upload failed",
+    imageAlignLeft: "Align left",
+    imageAlignCenter: "Center",
+    imageAlignFull: "Full width",
+    aiTitle: "AI",
+    aiAskPlaceholder: "Ask about this doc\u2026",
+    aiSend: "Send",
+    aiThinking: "Thinking\u2026",
+    aiAccept: "Accept",
+    aiReject: "Reject",
+    aiImprovePrompt: "Instruction (optional)\u2026",
+    aiImproveRun: "Run",
+    aiStreaming: "Generating\u2026",
+    aiRuntimeMissing: "No AI Runtime injected; action unavailable",
+    // v1.1: tables
+    itemTable: "Table",
+    itemTableDesc: "Structured table with typed columns (\u2318\u2325S)",
+    itemTableSimple: "Table (no header)",
+    itemTableSimpleDesc: "Plain layout table without header (\u2318\u2325T)",
+    colTypeText: "Text",
+    colTypeCheckbox: "Checkbox",
+    colTypeSelect: "Select tag",
+    colTypeMultiSelect: "Multi-select",
+    colTypeNumber: "Number",
+    colTypeDate: "Date",
+    colTypeLink: "Link",
+    colMenuTitle: "Column",
+    colMenuSortAsc: "Sort ascending",
+    colMenuSortDesc: "Sort descending",
+    colMenuInsertLeft: "Insert column left",
+    colMenuInsertRight: "Insert column right",
+    colMenuDelete: "Delete column",
+    colMenuType: "Column type",
+    rowMenuTitle: "Row",
+    rowMenuInsertAbove: "Insert row above",
+    rowMenuInsertBelow: "Insert row below",
+    rowMenuDelete: "Delete row",
+    tableDelete: "Delete table",
+    tableCopyCsv: "Copy as CSV",
+    tableToggleHeader: "Toggle header row",
+    cellEmpty: "Empty",
+    // v1.1: history
+    itemHistory: "Version history",
+    historyTitle: "Version history",
+    historyEmpty: "No snapshots yet (auto-captured when idle, or capture manually)",
+    historyCapture: "Capture snapshot",
+    historyRestore: "Restore this version",
+    historyCurrent: "Current",
+    historyDiffAdded: "Added",
+    historyDiffRemoved: "Removed",
+    historyDiffChanged: "Changed",
+    historyConfirmRestore: "Restore this version? Current content will be replaced (undoable)",
+    // v1.1: comments
+    tooltipCommentV11: "Comment",
+    commentTitle: "Comments",
+    commentEmpty: "No comments yet",
+    commentPlaceholder: "Write a comment\u2026 (Shift+Enter for newline)",
+    commentSend: "Send",
+    commentResolve: "Resolve",
+    commentReopen: "Reopen",
+    commentDelete: "Delete",
+    commentResolvedBadge: "Resolved",
+    commentCount: (n) => `${n} comment${n === 1 ? "" : "s"}`,
+    // v1.1: embed / toc / placeholder
+    itemEmbed: "Embed",
+    itemEmbedDesc: "Embed an external page (sandboxed iframe)",
+    itemToc: "Table of contents",
+    itemTocDesc: "Auto outline from H1\u2013H4",
+    embedPlaceholder: "Paste a link to embed\u2026",
+    embedApply: "Embed",
+    embedInvalid: "Invalid URL",
+    embedOpen: "Open original",
+    tocEmpty: "No headings yet \u2014 add H1\u2013H4 and they appear here",
+    placeholderText: "to fill in",
+    placeholderPerson: "assignee",
+    placeholderDate: "due date",
+    // v1.1: block context menu
+    menuCopyAnchor: "Copy anchor link",
+    menuCopyBlockId: "Copy block ID",
+    menuDeleteBlock: "Delete block"
+  }
+};
+function createTesseraT(locale = "zh-CN") {
+  const table = tesseraMessages[locale] ?? tesseraMessages["zh-CN"];
+  return (key) => table[key] ?? key;
+}
+
+// src/extensions/slash.ts
+function chainDelete(editor, range) {
+  return editor.chain().focus().deleteRange(range);
+}
+function defaultSlashItems(t) {
+  return [
+    {
+      id: "text",
+      group: "basic",
+      title: t("itemText"),
+      description: t("itemTextDesc"),
+      keywords: ["text", "paragraph", "\u6587\u672C", "\u6BB5\u843D"],
+      command: ({ editor, range }) => chainDelete(editor, range).setParagraph().run()
+    },
+    {
+      id: "h1",
+      group: "basic",
+      title: t("itemH1"),
+      shortcut: "\u2318\u21E71",
+      keywords: ["heading", "title", "\u6807\u9898"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleHeading({ level: 1 }).run()
+    },
+    {
+      id: "h2",
+      group: "basic",
+      title: t("itemH2"),
+      shortcut: "\u2318\u21E72",
+      keywords: ["heading", "title", "\u6807\u9898"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleHeading({ level: 2 }).run()
+    },
+    {
+      id: "h3",
+      group: "basic",
+      title: t("itemH3"),
+      shortcut: "\u2318\u21E73",
+      keywords: ["heading", "title", "\u6807\u9898"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleHeading({ level: 3 }).run()
+    },
+    {
+      id: "h4",
+      group: "basic",
+      title: t("itemH4"),
+      shortcut: "\u2318\u21E74",
+      keywords: ["heading", "title", "\u6807\u9898"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleHeading({ level: 4 }).run()
+    },
+    {
+      id: "bulletList",
+      group: "basic",
+      title: t("itemBullet"),
+      description: t("itemBulletDesc"),
+      shortcut: "\u2318\u21E78",
+      keywords: ["bullet", "list", "unordered", "\u5217\u8868"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleBulletList().run()
+    },
+    {
+      id: "orderedList",
+      group: "basic",
+      title: t("itemOrdered"),
+      description: t("itemOrderedDesc"),
+      shortcut: "\u2318\u21E77",
+      keywords: ["ordered", "list", "numbered", "\u5217\u8868"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleOrderedList().run()
+    },
+    {
+      id: "taskList",
+      group: "basic",
+      title: t("itemTask"),
+      description: t("itemTaskDesc"),
+      shortcut: "\u2318\u21E7C",
+      keywords: ["task", "todo", "checkbox", "\u4EFB\u52A1", "\u6E05\u5355"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleTaskList().run()
+    },
+    {
+      id: "quote",
+      group: "basic",
+      title: t("itemQuote"),
+      description: t("itemQuoteDesc"),
+      shortcut: "\u2318\u21E7.",
+      keywords: ["quote", "blockquote", "\u5F15\u7528"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleBlockquote().run()
+    },
+    {
+      id: "codeBlock",
+      group: "advanced",
+      title: t("itemCode"),
+      description: t("itemCodeDesc"),
+      shortcut: "\u2318\u21E79",
+      keywords: ["code", "\u4EE3\u7801"],
+      command: ({ editor, range }) => chainDelete(editor, range).toggleCodeBlock().run()
+    },
+    {
+      id: "divider",
+      group: "advanced",
+      title: t("itemDivider"),
+      description: t("itemDividerDesc"),
+      keywords: ["divider", "hr", "rule", "\u5206\u5272\u7EBF"],
+      command: ({ editor, range }) => chainDelete(editor, range).setHorizontalRule().run()
+    },
+    {
+      id: "hint",
+      group: "advanced",
+      title: t("itemHint"),
+      description: t("itemHintDesc"),
+      shortcut: "\u2318\u2325H",
+      keywords: ["hint", "callout", "info", "\u63D0\u793A"],
+      command: ({ editor, range }) => chainDelete(editor, range).setHint().run()
+    },
+    {
+      id: "collapsible",
+      group: "advanced",
+      title: t("itemCollapsible"),
+      description: t("itemCollapsibleDesc"),
+      keywords: ["collapsible", "fold", "details", "\u6298\u53E0"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertCollapsible().run()
+    },
+    {
+      id: "image",
+      group: "advanced",
+      title: t("itemImage"),
+      description: t("itemImageDesc"),
+      keywords: ["image", "picture", "photo", "\u56FE\u7247"],
+      command: ({ editor, range }) => {
+        chainDelete(editor, range).run();
+        editor.emit("tessera:insertImage", {});
+      }
+    },
+    {
+      id: "table",
+      group: "advanced",
+      title: t("itemTable"),
+      description: t("itemTableDesc"),
+      shortcut: "\u2318\u2325S",
+      keywords: ["table", "\u8868\u683C"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertTableTyped({ withHeaderRow: true }).run()
+    },
+    {
+      id: "table-simple",
+      group: "advanced",
+      title: t("itemTableSimple"),
+      description: t("itemTableSimpleDesc"),
+      shortcut: "\u2318\u2325T",
+      keywords: ["table", "simple", "\u8868\u683C"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertTableTyped({ withHeaderRow: false }).run()
+    },
+    {
+      id: "embed",
+      group: "advanced",
+      title: t("itemEmbed"),
+      description: t("itemEmbedDesc"),
+      keywords: ["embed", "iframe", "\u5D4C\u5165"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertEmbed({ src: "" }).run()
+    },
+    {
+      id: "toc",
+      group: "advanced",
+      title: t("itemToc"),
+      description: t("itemTocDesc"),
+      keywords: ["toc", "outline", "\u76EE\u5F55", "\u5927\u7EB2"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertToc().run()
+    },
+    {
+      id: "placeholder-person",
+      group: "advanced",
+      title: t("placeholderPerson"),
+      keywords: ["somebody", "person", "owner", "\u5F85\u586B\u4EBA"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertPlaceholderToken("person", t("placeholderPerson")).run()
+    },
+    {
+      id: "placeholder-date",
+      group: "advanced",
+      title: t("placeholderDate"),
+      keywords: ["date", "due", "\u5F85\u586B\u65E5\u671F"],
+      command: ({ editor, range }) => chainDelete(editor, range).insertPlaceholderToken("date", t("placeholderDate")).run()
+    },
+    {
+      id: "history",
+      group: "advanced",
+      title: t("itemHistory"),
+      keywords: ["history", "version", "snapshot", "\u5386\u53F2", "\u7248\u672C"],
+      command: ({ editor, range }) => {
+        chainDelete(editor, range).run();
+        editor.emit("tessera:historyPanel", {});
+      }
+    }
+  ];
+}
+var SlashMenu = Extension6.create({
+  name: "tesseraSlashMenu",
+  addOptions() {
+    return {
+      locale: "zh-CN",
+      extraItems: void 0,
+      includeAiItems: false,
+      render: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    const options = this.options;
+    const t = createTesseraT(options.locale);
+    const items = [
+      ...defaultSlashItems(t),
+      ...options.extraItems?.({ editor, t }) ?? []
+    ];
+    return [
+      Suggestion({
+        editor,
+        pluginKey: new PluginKey3("tesseraSlashMenu"),
+        char: "/",
+        startOfLine: true,
+        items: ({ query }) => {
+          const q = query.toLowerCase();
+          if (!q) {
+            return items;
+          }
+          return items.filter(
+            (item) => item.title.toLowerCase().includes(q) || item.id.toLowerCase().includes(q) || item.keywords?.some((k) => k.toLowerCase().includes(q))
+          );
+        },
+        command: ({ editor: e, range, props }) => {
+          ;
+          props.command({ editor: e, range });
+        },
+        render: options.render
+      })
+    ];
+  }
+});
+
+// src/extensions/emoji.ts
+import { Extension as Extension7 } from "@tiptap/core";
+import { PluginKey as PluginKey4 } from "@tiptap/pm/state";
+import Suggestion2 from "@tiptap/suggestion";
+var EMOJI_ITEMS = [
+  { char: "\u{1F600}", name: "grinning", keywords: ["face", "happy", "smile"] },
+  { char: "\u{1F604}", name: "smile", keywords: ["face", "happy", "joy"] },
+  { char: "\u{1F601}", name: "beaming", keywords: ["face", "grin"] },
+  { char: "\u{1F602}", name: "joy", keywords: ["face", "tears", "lol"] },
+  { char: "\u{1F923}", name: "rofl", keywords: ["face", "laugh", "floor"] },
+  { char: "\u{1F60A}", name: "blush", keywords: ["face", "happy", "warm"] },
+  { char: "\u{1F642}", name: "slight_smile", keywords: ["face", "smile"] },
+  { char: "\u{1F609}", name: "wink", keywords: ["face"] },
+  { char: "\u{1F60D}", name: "heart_eyes", keywords: ["face", "love"] },
+  { char: "\u{1F618}", name: "kiss", keywords: ["face", "love"] },
+  { char: "\u{1F61C}", name: "zany", keywords: ["face", "crazy", "tongue"] },
+  { char: "\u{1F914}", name: "thinking", keywords: ["face", "hmm"] },
+  { char: "\u{1F917}", name: "hug", keywords: ["face"] },
+  { char: "\u{1F928}", name: "eyebrow", keywords: ["face", "suspicious"] },
+  { char: "\u{1F610}", name: "neutral", keywords: ["face", "meh"] },
+  { char: "\u{1F634}", name: "sleeping", keywords: ["face", "zzz"] },
+  { char: "\u{1F62A}", name: "sleepy", keywords: ["face", "tired"] },
+  { char: "\u{1F62B}", name: "tired", keywords: ["face", "exhausted"] },
+  { char: "\u{1F973}", name: "partying", keywords: ["face", "celebrate"] },
+  { char: "\u{1F60E}", name: "cool", keywords: ["face", "sunglasses"] },
+  { char: "\u{1F913}", name: "nerd", keywords: ["face", "glasses"] },
+  { char: "\u{1F62D}", name: "sob", keywords: ["face", "cry", "tears"] },
+  { char: "\u{1F621}", name: "angry", keywords: ["face", "rage"] },
+  { char: "\u{1F631}", name: "scream", keywords: ["face", "fear"] },
+  { char: "\u{1F92F}", name: "exploding_head", keywords: ["face", "mind", "blown"] },
+  { char: "\u{1F97A}", name: "pleading", keywords: ["face", "puppy"] },
+  { char: "\u{1F607}", name: "innocent", keywords: ["face", "angel", "halo"] },
+  { char: "\u{1F91D}", name: "handshake", keywords: ["hands", "deal"] },
+  { char: "\u{1F44D}", name: "thumbsup", keywords: ["hand", "ok", "like", "yes"] },
+  { char: "\u{1F44E}", name: "thumbsdown", keywords: ["hand", "dislike", "no"] },
+  { char: "\u{1F44C}", name: "ok_hand", keywords: ["hand"] },
+  { char: "\u270C\uFE0F", name: "victory", keywords: ["hand", "peace"] },
+  { char: "\u{1F91E}", name: "crossed_fingers", keywords: ["hand", "luck"] },
+  { char: "\u{1F44F}", name: "clap", keywords: ["hands", "praise"] },
+  { char: "\u{1F64F}", name: "pray", keywords: ["hands", "thanks"] },
+  { char: "\u{1F4AA}", name: "muscle", keywords: ["arm", "strong"] },
+  { char: "\u2764\uFE0F", name: "heart", keywords: ["love", "red"] },
+  { char: "\u{1F9E1}", name: "orange_heart", keywords: ["love"] },
+  { char: "\u{1F49B}", name: "yellow_heart", keywords: ["love"] },
+  { char: "\u{1F49A}", name: "green_heart", keywords: ["love"] },
+  { char: "\u{1F499}", name: "blue_heart", keywords: ["love"] },
+  { char: "\u{1F49C}", name: "purple_heart", keywords: ["love"] },
+  { char: "\u{1F5A4}", name: "black_heart", keywords: ["love"] },
+  { char: "\u{1F494}", name: "broken_heart", keywords: ["love", "sad"] },
+  { char: "\u2B50", name: "star", keywords: ["favorite"] },
+  { char: "\u{1F31F}", name: "glowing_star", keywords: ["star", "shine"] },
+  { char: "\u2728", name: "sparkles", keywords: ["magic", "shine", "ai"] },
+  { char: "\u{1F525}", name: "fire", keywords: ["hot", "flame"] },
+  { char: "\u26A1", name: "zap", keywords: ["lightning", "fast"] },
+  { char: "\u{1F4A1}", name: "bulb", keywords: ["idea", "light"] },
+  { char: "\u2705", name: "check", keywords: ["done", "ok", "complete"] },
+  { char: "\u274C", name: "x", keywords: ["wrong", "no", "cancel"] },
+  { char: "\u26A0\uFE0F", name: "warning", keywords: ["caution", "alert"] },
+  { char: "\u2753", name: "question", keywords: ["ask", "help"] },
+  { char: "\u2757", name: "exclamation", keywords: ["important"] },
+  { char: "\u{1F680}", name: "rocket", keywords: ["ship", "launch", "fast"] },
+  { char: "\u{1F389}", name: "tada", keywords: ["party", "celebrate", "congrats"] },
+  { char: "\u{1F38A}", name: "confetti", keywords: ["party"] },
+  { char: "\u{1F3AF}", name: "dart", keywords: ["target", "goal"] },
+  { char: "\u{1F4CC}", name: "pushpin", keywords: ["pin"] },
+  { char: "\u{1F4CE}", name: "paperclip", keywords: ["attach"] },
+  { char: "\u{1F4DD}", name: "memo", keywords: ["note", "doc", "write"] },
+  { char: "\u{1F4C5}", name: "calendar", keywords: ["date", "schedule"] },
+  { char: "\u23F0", name: "alarm", keywords: ["clock", "time"] },
+  { char: "\u{1F4B0}", name: "moneybag", keywords: ["money", "cash"] },
+  { char: "\u{1F381}", name: "gift", keywords: ["present"] },
+  { char: "\u2615", name: "coffee", keywords: ["drink", "tea"] },
+  { char: "\u{1F355}", name: "pizza", keywords: ["food"] },
+  { char: "\u{1F308}", name: "rainbow", keywords: ["color"] },
+  { char: "\u2600\uFE0F", name: "sunny", keywords: ["weather", "sun"] },
+  { char: "\u{1F319}", name: "crescent", keywords: ["weather", "moon", "night"] },
+  { char: "\u2601\uFE0F", name: "cloud", keywords: ["weather"] },
+  { char: "\u{1F440}", name: "eyes", keywords: ["look", "watch"] },
+  { char: "\u{1F916}", name: "robot", keywords: ["ai", "bot"] },
+  { char: "\u{1F41E}", name: "bug", keywords: ["insect", "error"] }
+];
+function filterEmojiItems(query, items = EMOJI_ITEMS) {
+  const q = query.toLowerCase();
+  if (!q) {
+    return items;
+  }
+  return items.filter(
+    (item) => item.name.toLowerCase().includes(q) || item.keywords.some((k) => k.toLowerCase().includes(q))
+  );
+}
+var EmojiMenu = Extension7.create({
+  name: "tesseraEmojiMenu",
+  addOptions() {
+    return {
+      render: void 0,
+      extraItems: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    const items = [...EMOJI_ITEMS, ...options.extraItems?.() ?? []];
+    return [
+      Suggestion2({
+        editor: this.editor,
+        pluginKey: new PluginKey4("tesseraEmojiMenu"),
+        char: ":",
+        startOfLine: false,
+        items: ({ query }) => filterEmojiItems(query, items),
+        command: ({ editor: e, range, props }) => {
+          e.chain().focus().insertContentAt(range, `${props.char} `).run();
+        },
+        render: options.render
+      })
+    ];
+  }
+});
+
+// src/extensions/history.ts
+import { Extension as Extension9 } from "@tiptap/core";
+import { Plugin as Plugin3, PluginKey as PluginKey5 } from "@tiptap/pm/state";
+
+// src/services.ts
+import { Extension as Extension8 } from "@tiptap/core";
+var TesseraServices = Extension8.create({
+  name: "tesseraServices",
+  addStorage() {
+    return {
+      upload: void 0,
+      storage: void 0,
+      comments: void 0,
+      identity: void 0
+    };
+  }
+});
+function servicesBag(editor) {
+  return editor.storage.tesseraServices;
+}
+function getUploadService(editor) {
+  return servicesBag(editor)?.upload;
+}
+function getStorageService(editor) {
+  return servicesBag(editor)?.storage;
+}
+function getCommentStore(editor) {
+  return servicesBag(editor)?.comments;
+}
+function getIdentityService(editor) {
+  return servicesBag(editor)?.identity;
+}
+
+// src/extensions/history.ts
+var historyKey = new PluginKey5("tesseraHistory");
+var TesseraHistory = Extension9.create({
+  name: "tesseraHistory",
+  addOptions() {
+    return {
+      idleMs: 5 * 60 * 1e3,
+      minIntervalMs: 60 * 1e3,
+      label: void 0
+    };
+  },
+  addCommands() {
+    return {
+      captureSnapshot: (label) => ({ editor, state }) => {
+        const storage = getStorageService(editor);
+        if (!storage) {
+          return false;
+        }
+        const doc = editor.getJSON();
+        const snapshot = {
+          id: `snap-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+          ts: Date.now(),
+          doc,
+          label: label ?? this.options.label?.()
+        };
+        void storage.saveSnapshot(snapshot).then(() => {
+          editor.emit("tessera:snapshotSaved", { snapshot });
+        });
+        const tr = state.tr.setMeta(historyKey, { type: "captured", ts: snapshot.ts });
+        editor.view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    const options = this.options;
+    return [
+      new Plugin3({
+        key: historyKey,
+        state: {
+          init: () => ({ lastChange: 0, lastCapture: 0, timer: null }),
+          apply: (tr, prev) => {
+            const meta = tr.getMeta(historyKey);
+            if (meta?.type === "captured") {
+              return { ...prev, lastCapture: meta.ts ?? Date.now() };
+            }
+            if (!tr.docChanged) {
+              return prev;
+            }
+            return { ...prev, lastChange: Date.now() };
+          }
+        },
+        view() {
+          return {
+            update: (_view, prevState) => {
+              const before = historyKey.getState(prevState);
+              const after = historyKey.getState(editor.state);
+              if (!before || !after || after.lastChange === before.lastChange) {
+                return;
+              }
+              const storage = getStorageService(editor);
+              if (!storage) {
+                return;
+              }
+              const s = historyKey.getState(editor.state);
+              if (s?.timer) {
+                clearTimeout(s.timer);
+              }
+              const timer = setTimeout(() => {
+                const now = Date.now();
+                const cur = historyKey.getState(editor.state);
+                if (!cur || now - cur.lastChange < options.idleMs - 50) {
+                  return;
+                }
+                if (now - cur.lastCapture < options.minIntervalMs) {
+                  return;
+                }
+                editor.commands.captureSnapshot();
+              }, options.idleMs);
+              const st = historyKey.getState(editor.state);
+              if (st) {
+                st.timer = timer;
+              }
+            },
+            destroy() {
+              const s = historyKey.getState(editor.state);
+              if (s?.timer) {
+                clearTimeout(s.timer);
+              }
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/context-menu.ts
+import { Extension as Extension10 } from "@tiptap/core";
+import { Plugin as Plugin4 } from "@tiptap/pm/state";
+var BlockContextMenu = Extension10.create({
+  name: "tesseraBlockMenu",
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    return [
+      new Plugin4({
+        props: {
+          handleDOMEvents: {
+            contextmenu: (view, event) => {
+              const coords = view.posAtCoords({ left: event.clientX, top: event.clientY });
+              if (!coords) {
+                return false;
+              }
+              const $pos = view.state.doc.resolve(coords.pos);
+              for (let depth = $pos.depth; depth >= 1; depth--) {
+                const node = $pos.node(depth);
+                if (typeof node.attrs.id === "string") {
+                  editor.emit("tessera:blockMenu", {
+                    blockId: node.attrs.id,
+                    blockType: node.type.name,
+                    clientX: event.clientX,
+                    clientY: event.clientY
+                  });
+                  event.preventDefault();
+                  return true;
+                }
+              }
+              return false;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/gallery.ts
+import { Extension as Extension11 } from "@tiptap/core";
+import { Plugin as Plugin5, PluginKey as PluginKey6 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+var galleryKey = new PluginKey6("tesseraGallery");
+function findGalleryRuns(doc) {
+  const runs = [];
+  let start = -1;
+  let size = 0;
+  doc.forEach((node, offset) => {
+    if (node.type.name === "imageBlock") {
+      if (start < 0) {
+        start = offset;
+        size = 0;
+      }
+      size += 1;
+    } else if (start >= 0) {
+      if (size >= 2) {
+        runs.push({ from: start, to: offset, size });
+      }
+      start = -1;
+      size = 0;
+    }
+  });
+  if (start >= 0 && size >= 2) {
+    runs.push({ from: start, to: doc.content.size, size });
+  }
+  return runs;
+}
+function galleryDecorations(doc) {
+  const decorations = [];
+  for (const run of findGalleryRuns(doc)) {
+    let index = 0;
+    doc.nodesBetween(run.from, run.to, (node, pos) => {
+      if (node.type.name !== "imageBlock") {
+        return false;
+      }
+      const attrs = {
+        "data-gallery": "true",
+        "data-gallery-index": String(index),
+        "data-gallery-size": String(run.size)
+      };
+      decorations.push(Decoration2.node(pos, pos + node.nodeSize, attrs));
+      index += 1;
+      return false;
+    });
+  }
+  return DecorationSet2.create(doc, decorations);
+}
+var TesseraGallery = Extension11.create({
+  name: "tesseraGallery",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin5({
+        key: galleryKey,
+        state: {
+          init: (_config, state) => galleryDecorations(state.doc),
+          apply: (tr, old) => tr.docChanged ? galleryDecorations(tr.doc) : old
+        },
+        props: {
+          decorations(state) {
+            return galleryKey.getState(state);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/metrics.ts
+import { Extension as Extension12 } from "@tiptap/core";
+
+// src/markdown.ts
+import MarkdownIt from "markdown-it";
+import { DOMParser as PMDOMParser, DOMSerializer } from "@tiptap/pm/model";
+import { MarkdownSerializer, defaultMarkdownSerializer } from "prosemirror-markdown";
+function taskListPlugin(md2) {
+  md2.core.ruler.after("inline", "tessera-tasklist", (state) => {
+    const tokens = state.tokens;
+    const taskItems = /* @__PURE__ */ new Set();
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i].type !== "inline") continue;
+      let p = -1;
+      if (tokens[i - 1]?.type === "paragraph_open") p = i - 2;
+      if (p === -1 || tokens[p]?.type !== "list_item_open") continue;
+      const children = tokens[i].children;
+      if (!children || children.length === 0) continue;
+      const first = children[0];
+      const m = /^\[([ xX])\]\s+/.exec(first.content ?? "");
+      if (!m) continue;
+      first.content = (first.content ?? "").slice(m[0].length);
+      for (let j = 1; j < children.length; j++) {
+        const child = children[j];
+        child.content = (child.content ?? "").replace(/^\[([ xX])\]\s+/, "");
+      }
+      tokens[p].attrSet?.("data-type", "taskItem");
+      tokens[p].attrSet?.("data-checked", m[1] === " " ? "false" : "true");
+      taskItems.add(p);
+    }
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i].type !== "bullet_list_open") continue;
+      for (let j = i + 1; j < tokens.length; j++) {
+        if (tokens[j].type === "bullet_list_close") break;
+        if (tokens[j].type === "list_item_open" && taskItems.has(j)) {
+          tokens[i].attrSet?.("data-type", "taskList");
+          break;
+        }
+      }
+    }
+  });
+}
+var md = MarkdownIt({ html: true, linkify: true }).use(
+  // structural mismatch is only in the type layer (markdown-it Token typings)
+  taskListPlugin
+);
+function stripIds(json) {
+  const walk = (node) => {
+    const attrs = node.attrs && "id" in node.attrs ? Object.fromEntries(Object.entries(node.attrs).filter(([k]) => k !== "id")) : node.attrs;
+    return {
+      ...node,
+      attrs,
+      content: node.content?.map(walk)
+    };
+  };
+  return walk(json);
+}
+function nodeToHtml(node) {
+  const clean = node.type.schema.nodeFromJSON(stripIds(node.toJSON()));
+  const dom = DOMSerializer.fromSchema(node.type.schema).serializeNode(clean);
+  return dom.outerHTML;
+}
+function createMarkdownSerializer(schema) {
+  const nodes = {
+    ...defaultMarkdownSerializer.nodes
+  };
+  const rep = (s, n) => " ".repeat(n);
+  nodes.bulletList = (state, node) => {
+    state.renderList(node, "  ", () => "- ");
+    state.closeBlock(node);
+  };
+  nodes.orderedList = (state, node) => {
+    const start = Number(node.attrs.order ?? 1);
+    const maxW = String(start + node.childCount - 1).length;
+    const space = rep(" ", maxW + 2);
+    state.renderList(node, space, (i) => {
+      const n = String(start + i);
+      return rep(" ", maxW - n.length) + n + ". ";
+    });
+    state.closeBlock(node);
+  };
+  nodes.listItem = (state, node) => {
+    state.renderContent(node);
+  };
+  nodes.codeBlock = (state, node) => {
+    state.write("```" + (node.attrs.language ?? "") + "\n");
+    state.write(node.textContent);
+    state.write("\n```");
+    state.closeBlock(node);
+  };
+  nodes.horizontalRule = (state, node) => {
+    state.write("---");
+    state.closeBlock(node);
+  };
+  nodes.hardBreak = (state) => {
+    state.write("\\\n");
+  };
+  nodes.taskList = (state, node) => {
+    state.renderList(node, "  ", () => "- ");
+    state.closeBlock(node);
+  };
+  nodes.taskItem = (state, node) => {
+    state.write(node.attrs.checked ? "[x] " : "[ ] ");
+    state.renderContent(node);
+  };
+  nodes.hint = (state, node) => {
+    state.write(nodeToHtml(node));
+    state.closeBlock(node);
+  };
+  nodes.collapsible = (state, node) => {
+    state.write(nodeToHtml(node));
+    state.closeBlock(node);
+  };
+  nodes.imageBlock = (state, node) => {
+    state.write(nodeToHtml(node));
+    state.closeBlock(node);
+  };
+  nodes.table = (state, node) => {
+    state.write(nodeToHtml(node));
+    state.closeBlock(node);
+  };
+  nodes.tableRow = () => {
+  };
+  nodes.tableCell = () => {
+  };
+  nodes.tableHeader = () => {
+  };
+  nodes.embedBlock = (state, node) => {
+    state.write(nodeToHtml(node));
+    state.closeBlock(node);
+  };
+  nodes.tocBlock = (state, node) => {
+    state.write('<div data-type="tessera-toc"></div>');
+    state.closeBlock(node);
+  };
+  const marks = {
+    ...defaultMarkdownSerializer.marks,
+    bold: { open: "**", close: "**", mixable: true, expelEnclosingWhitespace: true },
+    italic: { open: "*", close: "*", mixable: true, expelEnclosingWhitespace: true },
+    strike: { open: "~~", close: "~~", mixable: true, expelEnclosingWhitespace: true },
+    code: { open: "`", close: "`", escape: false },
+    link: {
+      open: "[",
+      close: (state, mark) => `](${mark.attrs.href})`,
+      mixable: false
+    },
+    underline: { open: "<u>", close: "</u>", mixable: true, expelEnclosingWhitespace: true },
+    highlight: { open: "<mark>", close: "</mark>", mixable: true, expelEnclosingWhitespace: true },
+    // transparent passthroughs: these marks carry no Markdown syntax.
+    // Omitting them makes prosemirror-markdown THROW on export (crashes the
+    // host app) — textStyle always accompanies Color, and aiAttribution rides
+    // on AI-written text.
+    textStyle: { open: "", close: "", mixable: true },
+    color: { open: "", close: "", mixable: true },
+    aiAttribution: { open: "", close: "", mixable: true },
+    tesseraPlaceholder: { open: "", close: "", mixable: true },
+    comment: { open: "", close: "", mixable: true }
+  };
+  return new MarkdownSerializer(nodes, marks);
+}
+function docToMarkdown(doc, schema) {
+  const isNode = typeof doc.nodeSize === "number" && typeof doc.type === "object";
+  const realDoc = isNode ? doc : schema.nodeFromJSON(doc);
+  return createMarkdownSerializer(schema).serialize(realDoc);
+}
+function markdownToDoc(markdown, schema) {
+  const html = md.render(markdown);
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  const parsed = PMDOMParser.fromSchema(schema).parse(container);
+  return parsed.toJSON();
+}
+function stableJson(json) {
+  const clone = JSON.parse(JSON.stringify(json));
+  const walk = (node) => {
+    if (node.attrs && "id" in node.attrs) {
+      const { id: _drop, ...rest } = node.attrs;
+      if (Object.keys(rest).length === 0) {
+        delete node.attrs;
+      } else {
+        node.attrs = rest;
+      }
+    }
+    node.marks = node.marks?.map((mark) => {
+      if (mark.attrs) {
+        const attrs = Object.fromEntries(
+          Object.entries(mark.attrs).filter(([, v]) => v !== null && v !== "")
+        );
+        return { ...mark, attrs };
+      }
+      return mark;
+    });
+    if (node.type === "codeBlock" && node.content) {
+      node.content = node.content.map(
+        (child) => child.type === "text" ? { ...child, text: (child.text ?? "").replace(/\s+$/, "") } : child
+      );
+      node.content = node.content.filter((child) => !(child.type === "text" && child.text === ""));
+    }
+    node.content?.forEach(walk);
+  };
+  walk(clone);
+  return clone;
+}
+
+// src/extensions/metrics.ts
+function measureTesseraMetrics(editor) {
+  let images = 0;
+  let tables = 0;
+  editor.state.doc.descendants((node) => {
+    if (node.type.name === "imageBlock") images += 1;
+    if (node.type.name === "table") tables += 1;
+    return true;
+  });
+  const started = performance.now();
+  docToMarkdown(editor.state.doc, editor.state.schema);
+  const serializeMs = Math.round((performance.now() - started) * 100) / 100;
+  return {
+    blocks: editor.state.doc.childCount,
+    words: editor.state.doc.textBetween(0, editor.state.doc.content.size, " ", " ").split(/\s+/).filter(Boolean).length,
+    images,
+    tables,
+    mountedNodeViews: editor.view ? editor.view.dom.querySelectorAll("[data-node-view-wrapper]").length : 0,
+    serializeMs
+  };
+}
+var TesseraMetrics = Extension12.create({
+  name: "tesseraMetrics"
+});
+function getTesseraMetrics(editor) {
+  return measureTesseraMetrics(editor);
+}
+
+// src/extensions/word-paste.ts
+import { Extension as Extension13 } from "@tiptap/core";
+import { Plugin as Plugin6, PluginKey as PluginKey7 } from "@tiptap/pm/state";
+
+// src/wordpaste.ts
+function isWordHtml(html) {
+  return html.includes("urn:schemas-microsoft-com:office:word") || html.includes("urn:schemas-microsoft-com:office:office") || /mso-[\w-]+/.test(html) || /\bMso\w+/.test(html) || /<w:/i.test(html) || /<o:/i.test(html);
+}
+function cleanWordHtml(html) {
+  let out = html;
+  out = out.replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, "");
+  out = out.replace(/<!--[\s\S]*?-->/g, "");
+  out = out.replace(/<(style|script)\b[\s\S]*?<\/\1>/gi, "");
+  out = out.replace(/<(meta|link)\b[^>]*>/gi, "");
+  out = out.replace(/<\?xml[^>]*\?>/gi, "");
+  out = out.replace(/<!DOCTYPE[^>]*>/gi, "");
+  out = out.replace(/<\/?[a-z][a-z0-9]*:[^>]*>/gi, "");
+  out = out.replace(/\s(class|style|lang|xml:lang|face)\s*=\s*"[^"]*"/gi, "");
+  out = out.replace(/\s(class|style|lang|xml:lang|face)\s*=\s*'[^']*'/gi, "");
+  out = out.replace(/&nbsp;/gi, " ");
+  let prev = "";
+  while (out !== prev) {
+    prev = out;
+    out = out.replace(/<p\b[^>]*>(\s|<br\s*\/?>)*<\/p>/gi, "");
+  }
+  return out.trim();
+}
+
+// src/extensions/word-paste.ts
+var TesseraWordPaste = Extension13.create({
+  name: "tesseraWordPaste",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin6({
+        key: new PluginKey7("tesseraWordPaste"),
+        props: {
+          transformPastedHTML(html) {
+            return isWordHtml(html) ? cleanWordHtml(html) : html;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/blockmenu.ts
+function findBlockPosById(editor, id) {
+  let found = null;
+  editor.state.doc.forEach((node, offset) => {
+    if (found === null && node.attrs.id === id) {
+      found = offset;
+    }
+  });
+  return found;
+}
+function deleteBlockById(editor, id) {
+  const pos = findBlockPosById(editor, id);
+  if (pos === null) {
+    return false;
+  }
+  const node = editor.state.doc.nodeAt(pos);
+  if (!node) {
+    return false;
+  }
+  const tr = editor.state.tr.delete(pos, pos + node.nodeSize);
+  editor.view.dispatch(tr);
+  return true;
+}
+function blockAnchorUrl(blockId2) {
+  return `${location.origin}${location.pathname}#block-${blockId2}`;
+}
+
+// src/preset.ts
+import StarterKit from "@tiptap/starter-kit";
+import { TaskList, TaskItem } from "@tiptap/extension-list";
+import { TextStyle } from "@tiptap/extension-text-style";
+import { Color } from "@tiptap/extension-color";
+import { Highlight } from "@tiptap/extension-highlight";
+import { UniqueID } from "@tiptap/extension-unique-id";
+import { Placeholder } from "@tiptap/extensions";
+var ID_BLOCK_TYPES = [
+  "paragraph",
+  "heading",
+  "bulletList",
+  "orderedList",
+  "taskList",
+  "listItem",
+  "taskItem",
+  "blockquote",
+  "codeBlock",
+  "horizontalRule",
+  "hint",
+  "collapsible",
+  "imageBlock",
+  "table",
+  "tableRow",
+  "embedBlock",
+  "tocBlock"
+];
+function createTesseraExtensions(options = {}) {
+  const t = createTesseraT(options.locale ?? "zh-CN");
+  return [
+    StarterKit.configure({
+      heading: { levels: [1, 2, 3, 4] },
+      link: {
+        openOnClick: false,
+        autolink: true,
+        defaultProtocol: "https"
+      }
+      // undoRedo keeps defaults (newGroupDelay 500ms): streaming AI chunks
+      // arriving faster than that already merge into one undo step.
+    }),
+    TextStyle,
+    Color,
+    Highlight.configure({ multicolor: true }),
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Hint,
+    Collapsible,
+    CollapsibleSummary,
+    CollapsibleContent,
+    ImageBlock,
+    AiTable,
+    TableRow,
+    AiTableCell,
+    AiTableHeader,
+    EmbedBlock,
+    TocBlock,
+    AiAttribution,
+    CommentMark,
+    CommentCommands,
+    PlaceholderMark,
+    PlaceholderCommands,
+    UniqueID.configure({
+      types: ID_BLOCK_TYPES,
+      attributeName: "id"
+    }),
+    Placeholder.configure({
+      placeholder: ({ node }) => node.type.name === "paragraph" ? t("placeholderEmpty") : "",
+      showOnlyWhenEditable: true
+    }),
+    TesseraInputRules,
+    TesseraShortcuts,
+    TesseraFindReplace,
+    TesseraHistory.configure({ idleMs: options.historyIdleMs }),
+    BlockContextMenu,
+    SlashMenu.configure({ locale: options.locale ?? "zh-CN" }),
+    EmojiMenu,
+    TesseraGallery,
+    TesseraMetrics,
+    TesseraWordPaste,
+    TesseraServices
+  ];
+}
+
+// src/diff.ts
+function topLevel(doc) {
+  return doc.content ?? [];
+}
+function blockId(block) {
+  const id = block.attrs?.id;
+  return typeof id === "string" ? id : null;
+}
+function collectText(node) {
+  let text = "";
+  if (node.text) {
+    text += node.text;
+  }
+  for (const child of node.content ?? []) {
+    text += collectText(child);
+  }
+  return text;
+}
+function tokenize(text) {
+  return text.match(/[\u4e00-\u9fa5]|[a-zA-Z0-9]+|\s+|[^\sa-zA-Z0-9\u4e00-\u9fa5]/g) ?? [];
+}
+function wordDiff(beforeText, afterText) {
+  const a = tokenize(beforeText);
+  const b = tokenize(afterText);
+  if (a.length * b.length > 4e6) {
+    return [
+      { text: beforeText, type: "del" },
+      { text: afterText, type: "add" }
+    ];
+  }
+  const dp = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    }
+  }
+  const parts = [];
+  const push = (text, type) => {
+    const last = parts[parts.length - 1];
+    if (last && last.type === type) {
+      last.text += text;
+    } else {
+      parts.push({ text, type });
+    }
+  };
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      push(a[i], "same");
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      push(a[i], "del");
+      i++;
+    } else {
+      push(b[j], "add");
+      j++;
+    }
+  }
+  while (i < a.length) {
+    push(a[i++], "del");
+  }
+  while (j < b.length) {
+    push(b[j++], "add");
+  }
+  return parts;
+}
+function sameBlock(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function diffDocs(before, after) {
+  const beforeBlocks = topLevel(before);
+  const afterBlocks = topLevel(after);
+  const afterById = /* @__PURE__ */ new Map();
+  for (const block of afterBlocks) {
+    const id = blockId(block);
+    if (id) {
+      afterById.set(id, block);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const block of beforeBlocks) {
+    const id = blockId(block);
+    if (id && afterById.has(id)) {
+      seen.add(id);
+      const next = afterById.get(id);
+      if (sameBlock(block, next)) {
+        entries.push({ kind: "unchanged", id, before: block, after: next });
+      } else {
+        entries.push({ kind: "changed", id, before: block, after: next, wordDiff: wordDiff(collectText(block), collectText(next)) });
+      }
+    } else {
+      entries.push({ kind: "removed", id: id ?? void 0, before: block });
+    }
+  }
+  for (const block of afterBlocks) {
+    const id = blockId(block);
+    if (id && seen.has(id)) {
+      continue;
+    }
+    if (!id || !beforeBlocks.some((b) => blockId(b) === id)) {
+      entries.push({ kind: "added", id: id ?? void 0, after: block });
+    }
+  }
+  return entries;
+}
+function diffSummary(entries) {
+  let added = 0;
+  let removed = 0;
+  let changed = 0;
+  for (const entry of entries) {
+    if (entry.kind === "added") added++;
+    else if (entry.kind === "removed") removed++;
+    else if (entry.kind === "changed") changed++;
+  }
+  return { added, removed, changed };
+}
+
+// src/writeback.ts
+function getTopLevelBlocks(editor) {
+  const blocks = [];
+  editor.state.doc.forEach((node, offset) => {
+    blocks.push({ id: node.attrs.id ?? null, type: node.type.name, pos: offset, node });
+  });
+  return blocks;
+}
+function findBlockPosById2(editor, id) {
+  let found = null;
+  editor.state.doc.forEach((node, offset) => {
+    if (found === null && node.attrs.id === id) {
+      found = offset;
+    }
+  });
+  return found;
+}
+function newBlockId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `tessera-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function resolveBlocks(editor, blocks) {
+  return blocks.map((json) => {
+    const clean = { ...json };
+    clean.attrs = { ...clean.attrs ?? {}, id: newBlockId() };
+    return editor.state.schema.nodeFromJSON(clean);
+  });
+}
+function modifyRange(editor, options) {
+  const blocks = getTopLevelBlocks(editor).filter((b) => b.id);
+  if (blocks.length === 0) {
+    return false;
+  }
+  const ids = blocks.map((b) => b.id);
+  const fromId = options.fromId ?? ids[0];
+  const toId = options.toId ?? fromId;
+  let fromIndex = ids.indexOf(fromId);
+  let toIndex = ids.indexOf(toId);
+  if (fromIndex === -1 || toIndex === -1) {
+    return false;
+  }
+  if (fromIndex > toIndex) {
+    ;
+    [fromIndex, toIndex] = [toIndex, fromIndex];
+  }
+  const fromBlock = blocks[fromIndex];
+  const toBlock = blocks[toIndex];
+  const from = fromBlock.pos;
+  const to = toBlock.pos + toBlock.node.nodeSize;
+  const nodes = resolveBlocks(editor, options.content);
+  const tr = editor.state.tr;
+  tr.replaceWith(from, to, nodes);
+  editor.view.dispatch(tr);
+  return true;
+}
+function appendBlocks(editor, options) {
+  const nodes = resolveBlocks(editor, options.content);
+  if (nodes.length === 0) {
+    return false;
+  }
+  let insertPos = editor.state.doc.content.size;
+  if (options.afterId) {
+    const pos = findBlockPosById2(editor, options.afterId);
+    if (pos === null) {
+      return false;
+    }
+    const node = editor.state.doc.nodeAt(pos);
+    if (!node) {
+      return false;
+    }
+    insertPos = pos + node.nodeSize;
+  }
+  const tr = editor.state.tr;
+  tr.insert(insertPos, nodes);
+  editor.view.dispatch(tr);
+  return true;
+}
+function removeBlocks(editor, ids) {
+  if (ids.length === 0) {
+    return false;
+  }
+  const ranges = [];
+  editor.state.doc.forEach((node, offset) => {
+    if (node.attrs.id && ids.includes(node.attrs.id)) {
+      ranges.push({ from: offset, to: offset + node.nodeSize });
+    }
+  });
+  if (ranges.length === 0) {
+    return false;
+  }
+  const tr = editor.state.tr;
+  for (let i = ranges.length - 1; i >= 0; i--) {
+    tr.delete(ranges[i].from, ranges[i].to);
+  }
+  editor.view.dispatch(tr);
+  return true;
+}
+function getBlockJson(editor, id) {
+  const pos = findBlockPosById2(editor, id);
+  if (pos === null) {
+    return null;
+  }
+  const node = editor.state.doc.nodeAt(pos);
+  return node ? node.toJSON() : null;
+}
+export {
+  AiAttribution,
+  AiTable,
+  AiTableCell,
+  AiTableHeader,
+  TableRow as AiTableRow,
+  BlockContextMenu,
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleSummary,
+  CommentCommands,
+  CommentMark,
+  EMOJI_ITEMS,
+  EmbedBlock,
+  EmojiMenu,
+  Hint,
+  ID_BLOCK_TYPES,
+  ImageBlock,
+  PlaceholderCommands,
+  PlaceholderMark,
+  SlashMenu,
+  TABLE_COLUMN_KINDS,
+  TesseraFindReplace,
+  TesseraGallery,
+  TesseraHistory,
+  TesseraInputRules,
+  TesseraMetrics,
+  TesseraServices,
+  TesseraShortcuts,
+  TesseraWordPaste,
+  TocBlock,
+  appendBlocks,
+  blockAnchorUrl,
+  cleanWordHtml,
+  createMarkdownSerializer,
+  createTesseraExtensions,
+  createTesseraT,
+  defaultSlashItems,
+  deleteBlockById,
+  diffDocs,
+  diffSummary,
+  docToMarkdown,
+  filterEmojiItems,
+  findBlockPosById,
+  findGalleryRuns,
+  findReplaceKey,
+  galleryKey,
+  getBlockJson,
+  getCommentStore,
+  getIdentityService,
+  getStorageService,
+  getTesseraMetrics,
+  getTopLevelBlocks,
+  getUploadService,
+  historyKey,
+  isWordHtml,
+  listCommentRanges,
+  markdownToDoc,
+  measureTesseraMetrics,
+  modifyRange,
+  normalizeTypes,
+  removeBlocks,
+  stableJson,
+  tableNodeToCsv,
+  tableToCsvAt,
+  tesseraMessages,
+  wordDiff
+};
+//# sourceMappingURL=index.js.map