@thescaffold/editor-addons 0.0.0

package/dist/index.mjs

@@ -0,0 +1,4111 @@
+// src/base/commands/index.ts
+function CommandsAddon() {
+  return {
+    id: "x/commands",
+    dependencies: ["x/schema"],
+    impl: CommandsAddonImpl
+  };
+}
+var CommandsAddonImpl = {
+  id: "x/commands",
+  init(ctx) {
+    ctx.commands.register({
+      id: "selectAll",
+      label: "Select All",
+      shortcut: "Mod-a",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+
+// src/base/history/index.ts
+function HistoryAddon() {
+  return { id: "x/history", impl: HistoryAddonImpl };
+}
+var HistoryAddonImpl = {
+  id: "x/history",
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "undo",
+      label: "Undo",
+      icon: "undo",
+      shortcut: "Mod-z",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.dispatchPmCommand("undo")
+    });
+    ctx.commands.register({
+      id: "redo",
+      label: "Redo",
+      icon: "redo",
+      shortcut: "Mod-Shift-z",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.dispatchPmCommand("redo")
+    });
+    return {};
+  }
+};
+
+// src/base/input-rules/index.ts
+function InputRulesAddon() {
+  return {
+    id: "x/input-rules",
+    dependencies: ["x/schema"],
+    impl: InputRulesAddonImpl
+  };
+}
+var InputRulesAddonImpl = {
+  id: "x/input-rules",
+  init(_ctx) {
+    return {};
+  }
+};
+
+// src/base/keymap/index.ts
+function KeymapAddon(config) {
+  return {
+    id: "x/keymap",
+    config,
+    dependencies: ["x/commands"],
+    impl: KeymapAddonImpl
+  };
+}
+var IS_MAC = typeof navigator !== "undefined" && /Mac|iP(hone|ad|od)/.test(navigator.platform);
+function normalizeShortcut(shortcut) {
+  return shortcut.split("-").map((part) => part.trim().toLowerCase()).filter(Boolean).sort((a, b) => {
+    const order = ["mod", "meta", "ctrl", "alt", "shift"];
+    const ai = order.indexOf(a);
+    const bi = order.indexOf(b);
+    if (ai === -1 && bi === -1) return 0;
+    if (ai === -1) return 1;
+    if (bi === -1) return -1;
+    return ai - bi;
+  }).join("-");
+}
+function eventToShortcut(e) {
+  const parts = [];
+  if (e.metaKey || e.ctrlKey) parts.push("mod");
+  if (e.altKey) parts.push("alt");
+  if (e.shiftKey) parts.push("shift");
+  let key = e.key;
+  if (key.length === 1) key = key.toLowerCase();
+  if (key === " ") key = "space";
+  parts.push(key.toLowerCase());
+  return parts.join("-");
+}
+var KeymapAddonImpl = {
+  id: "x/keymap",
+  init(ctx, config = {}) {
+    const disabled = new Set(config.disabled ?? []);
+    const overrides = config.overrides ?? {};
+    const handleKeydown = (e) => {
+      const shortcut = eventToShortcut(e);
+      for (const cmd of ctx.commands.getAll()) {
+        if (disabled.has(cmd.id)) continue;
+        const cmdShortcut = overrides[cmd.id] ?? cmd.shortcut;
+        if (!cmdShortcut) continue;
+        if (normalizeShortcut(cmdShortcut) === shortcut) {
+          if (cmd.isEnabled?.(ctx) === false) continue;
+          e.preventDefault();
+          cmd.execute(ctx);
+          return;
+        }
+      }
+    };
+    const content = ctx.getSlot("content");
+    const target = content ?? document;
+    target.addEventListener("keydown", handleKeydown, true);
+    return {
+      destroy() {
+        target.removeEventListener(
+          "keydown",
+          handleKeydown,
+          true
+        );
+      }
+    };
+  }
+};
+
+// src/base/schema/index.ts
+function SchemaAddon(config) {
+  return { id: "x/schema", config, impl: SchemaAddonImpl };
+}
+var SchemaAddonImpl = {
+  id: "x/schema",
+  initSchema(ctx, _config = {}) {
+    ctx.addNode({
+      name: "doc",
+      content: "block+"
+    });
+    ctx.addNode({
+      name: "paragraph",
+      group: "block",
+      content: "inline*",
+      attrs: {
+        align: { default: null },
+        indent: { default: 0 },
+        lineHeight: { default: null }
+      },
+      parseDOM: [
+        {
+          tag: "p",
+          getAttrs: (el) => {
+            const e = el;
+            return {
+              align: e.style.textAlign || null,
+              indent: parseInt(e.dataset["indent"] ?? "0", 10) || 0,
+              lineHeight: e.style.lineHeight || null
+            };
+          }
+        }
+      ],
+      toDOM: (node) => {
+        const style = [];
+        if (node.attrs.align) style.push(`text-align:${node.attrs.align}`);
+        if (node.attrs.lineHeight)
+          style.push(`line-height:${node.attrs.lineHeight}`);
+        const attrs = {};
+        if (style.length > 0) attrs["style"] = style.join(";");
+        if (node.attrs.indent > 0)
+          attrs["data-indent"] = String(node.attrs.indent);
+        return ["p", attrs, 0];
+      }
+    });
+    ctx.addNode({
+      name: "text",
+      group: "inline"
+    });
+    ctx.addNode({
+      name: "hardBreak",
+      group: "inline",
+      inline: true,
+      selectable: false,
+      parseDOM: [{ tag: "br" }],
+      toDOM: () => ["br"]
+    });
+  },
+  init(_ctx, _config = {}) {
+    return {};
+  }
+};
+
+// src/marks/index.ts
+function BoldAddon() {
+  return { id: "x/bold", dependencies: ["x/schema"], impl: BoldAddonImpl };
+}
+var BoldAddonImpl = {
+  id: "x/bold",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "bold",
+      parseDOM: [
+        { tag: "strong" },
+        { tag: "b" },
+        { style: "font-weight=bold" }
+      ],
+      toDOM: () => ["strong", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "bold",
+      label: "Bold",
+      icon: "bold",
+      shortcut: "Mod-b",
+      isEnabled: (c) => c.selection.canHaveMark("bold"),
+      isActive: (c) => c.selection.hasMark("bold"),
+      execute: (c) => {
+        c.addMark("bold");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function ItalicAddon() {
+  return { id: "x/italic", dependencies: ["x/schema"], impl: ItalicAddonImpl };
+}
+var ItalicAddonImpl = {
+  id: "x/italic",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "italic",
+      parseDOM: [{ tag: "em" }, { tag: "i" }, { style: "font-style=italic" }],
+      toDOM: () => ["em", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "italic",
+      label: "Italic",
+      icon: "italic",
+      shortcut: "Mod-i",
+      isEnabled: (c) => c.selection.canHaveMark("italic"),
+      isActive: (c) => c.selection.hasMark("italic"),
+      execute: (c) => {
+        c.addMark("italic");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function UnderlineAddon() {
+  return {
+    id: "x/underline",
+    dependencies: ["x/schema"],
+    impl: UnderlineAddonImpl
+  };
+}
+var UnderlineAddonImpl = {
+  id: "x/underline",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "underline",
+      parseDOM: [{ tag: "u" }, { style: "text-decoration=underline" }],
+      toDOM: () => ["u", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "underline",
+      label: "Underline",
+      icon: "underline",
+      shortcut: "Mod-u",
+      isEnabled: (c) => c.selection.canHaveMark("underline"),
+      isActive: (c) => c.selection.hasMark("underline"),
+      execute: (c) => {
+        c.addMark("underline");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function StrikethroughAddon() {
+  return {
+    id: "x/strikethrough",
+    dependencies: ["x/schema"],
+    impl: StrikethroughAddonImpl
+  };
+}
+var StrikethroughAddonImpl = {
+  id: "x/strikethrough",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "strikethrough",
+      parseDOM: [{ tag: "s" }, { tag: "del" }, { tag: "strike" }],
+      toDOM: () => ["s", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "strikethrough",
+      label: "Strikethrough",
+      icon: "strikethrough",
+      isEnabled: (c) => c.selection.canHaveMark("strikethrough"),
+      isActive: (c) => c.selection.hasMark("strikethrough"),
+      execute: (c) => {
+        c.addMark("strikethrough");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function InlineCodeAddon() {
+  return {
+    id: "x/inline-code",
+    dependencies: ["x/schema"],
+    impl: InlineCodeAddonImpl
+  };
+}
+var InlineCodeAddonImpl = {
+  id: "x/inline-code",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "code",
+      parseDOM: [{ tag: "code" }],
+      toDOM: () => ["code", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "inlineCode",
+      label: "Inline Code",
+      icon: "code",
+      isEnabled: (c) => c.selection.canHaveMark("code"),
+      isActive: (c) => c.selection.hasMark("code"),
+      execute: (c) => {
+        c.addMark("code");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function SubscriptAddon() {
+  return {
+    id: "x/subscript",
+    dependencies: ["x/schema"],
+    impl: SubscriptAddonImpl
+  };
+}
+var SubscriptAddonImpl = {
+  id: "x/subscript",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "subscript",
+      excludes: "superscript",
+      parseDOM: [{ tag: "sub" }],
+      toDOM: () => ["sub", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "subscript",
+      label: "Subscript",
+      icon: "subscript",
+      isEnabled: (c) => c.selection.canHaveMark("subscript"),
+      isActive: (c) => c.selection.hasMark("subscript"),
+      execute: (c) => {
+        c.addMark("subscript");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function SuperscriptAddon() {
+  return {
+    id: "x/superscript",
+    dependencies: ["x/schema"],
+    impl: SuperscriptAddonImpl
+  };
+}
+var SuperscriptAddonImpl = {
+  id: "x/superscript",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "superscript",
+      excludes: "subscript",
+      parseDOM: [{ tag: "sup" }],
+      toDOM: () => ["sup", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "superscript",
+      label: "Superscript",
+      icon: "superscript",
+      isEnabled: (c) => c.selection.canHaveMark("superscript"),
+      isActive: (c) => c.selection.hasMark("superscript"),
+      execute: (c) => {
+        c.addMark("superscript");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function HighlightAddon(config) {
+  return {
+    id: "x/highlight",
+    config,
+    dependencies: ["x/schema"],
+    impl: HighlightAddonImpl
+  };
+}
+var HighlightAddonImpl = {
+  id: "x/highlight",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "highlight",
+      attrs: { color: { default: "#ffff00" } },
+      parseDOM: [{ tag: "mark" }],
+      toDOM: (mark) => [
+        "mark",
+        { style: `background:${mark.attrs.color}` },
+        0
+      ]
+    });
+  },
+  init(ctx, config = {}) {
+    ctx.commands.register({
+      id: "highlight",
+      label: "Highlight",
+      icon: "highlight",
+      isEnabled: (c) => c.selection.canHaveMark("highlight"),
+      isActive: (c) => c.selection.hasMark("highlight"),
+      execute: (c) => {
+        c.addMark("highlight", { color: config.defaultColor ?? "#ffff00" });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function TextColorAddon(config) {
+  return {
+    id: "x/text-color",
+    config,
+    dependencies: ["x/schema"],
+    impl: TextColorAddonImpl
+  };
+}
+var TextColorAddonImpl = {
+  id: "x/text-color",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "textColor",
+      attrs: { color: { default: null } },
+      parseDOM: [{ style: "color", getAttrs: (v) => ({ color: v }) }],
+      toDOM: (mark) => [
+        "span",
+        { style: `color:${mark.attrs.color}` },
+        0
+      ]
+    });
+  },
+  init(ctx, config = {}) {
+    ctx.commands.register({
+      id: "textColor",
+      label: "Text Color",
+      icon: "text-color",
+      isEnabled: (c) => c.selection.canHaveMark("textColor"),
+      isActive: (c) => c.selection.hasMark("textColor"),
+      execute: (c) => {
+        c.addMark("textColor", { color: config.defaultColor ?? "#000000" });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "clearTextColor",
+      label: "Clear Text Color",
+      isEnabled: (c) => c.selection.hasMark("textColor"),
+      isActive: () => false,
+      execute: (c) => {
+        c.removeMark("textColor");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function FontFamilyAddon(config) {
+  return {
+    id: "x/font-family",
+    config,
+    dependencies: ["x/schema"],
+    impl: FontFamilyAddonImpl
+  };
+}
+var FontFamilyAddonImpl = {
+  id: "x/font-family",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "fontFamily",
+      attrs: { family: { default: null } },
+      parseDOM: [
+        { style: "font-family", getAttrs: (v) => ({ family: v }) }
+      ],
+      toDOM: (mark) => [
+        "span",
+        { style: `font-family:${mark.attrs.family}` },
+        0
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "fontFamily",
+      label: "Font Family",
+      icon: "font-family",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const family = args?.family;
+        if (!family) return false;
+        c.addMark("fontFamily", { family });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "clearFontFamily",
+      label: "Clear Font Family",
+      isEnabled: (c) => c.selection.hasMark("fontFamily"),
+      isActive: () => false,
+      execute: (c) => {
+        c.removeMark("fontFamily");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function FontSizeAddon(config) {
+  return {
+    id: "x/font-size",
+    config,
+    dependencies: ["x/schema"],
+    impl: FontSizeAddonImpl
+  };
+}
+var FontSizeAddonImpl = {
+  id: "x/font-size",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "fontSize",
+      attrs: { size: { default: null } },
+      parseDOM: [
+        { style: "font-size", getAttrs: (v) => ({ size: v }) }
+      ],
+      toDOM: (mark) => [
+        "span",
+        { style: `font-size:${mark.attrs.size}` },
+        0
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "fontSize",
+      label: "Font Size",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const size = args?.size;
+        if (!size) return false;
+        c.addMark("fontSize", { size });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "increaseFontSize",
+      label: "Increase Font Size",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "decreaseFontSize",
+      label: "Decrease Font Size",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "clearFontSize",
+      label: "Clear Font Size",
+      isEnabled: (c) => c.selection.hasMark("fontSize"),
+      isActive: () => false,
+      execute: (c) => {
+        c.removeMark("fontSize");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function ClearFormattingAddon() {
+  return {
+    id: "x/clear-formatting",
+    dependencies: ["x/commands"],
+    impl: ClearFormattingAddonImpl
+  };
+}
+var ClearFormattingAddonImpl = {
+  id: "x/clear-formatting",
+  init(ctx) {
+    ctx.commands.register({
+      id: "clearFormatting",
+      label: "Clear Formatting",
+      icon: "clear-formatting",
+      shortcut: "Mod-\\",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        for (const m of c.schema.getMarks()) c.removeMark(m.name);
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/formatting/index.ts
+function AlignmentAddon() {
+  return {
+    id: "x/alignment",
+    dependencies: ["x/schema"],
+    impl: AlignmentAddonImpl
+  };
+}
+var AlignmentAddonImpl = {
+  id: "x/alignment",
+  init(ctx) {
+    const setAttrs = (c, patch) => c.setBlockAttrs(patch);
+    for (const align of ["left", "center", "right", "justify"]) {
+      const id = `align${align.charAt(0).toUpperCase()}${align.slice(1)}`;
+      ctx.commands.register({
+        id,
+        label: `Align ${align.charAt(0).toUpperCase()}${align.slice(1)}`,
+        icon: `align-${align}`,
+        isEnabled: () => true,
+        isActive: () => false,
+        execute: (c) => setAttrs(c, { align })
+      });
+    }
+    return {};
+  }
+};
+function LineHeightAddon(config) {
+  return {
+    id: "x/line-height",
+    config,
+    dependencies: ["x/schema"],
+    impl: LineHeightAddonImpl
+  };
+}
+var LineHeightAddonImpl = {
+  id: "x/line-height",
+  init(ctx) {
+    ctx.commands.register({
+      id: "lineHeight",
+      label: "Line Height",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const value = args?.value;
+        if (value == null) return false;
+        return c.setBlockAttrs({ lineHeight: String(value) });
+      }
+    });
+    return {};
+  }
+};
+function ParagraphSpacingAddon() {
+  return {
+    id: "x/paragraph-spacing",
+    dependencies: ["x/schema"],
+    impl: ParagraphSpacingAddonImpl
+  };
+}
+var ParagraphSpacingAddonImpl = {
+  id: "x/paragraph-spacing",
+  init(ctx) {
+    ctx.commands.register({
+      id: "paragraphSpacing",
+      label: "Paragraph Spacing",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const value = args?.value;
+        if (value == null) return false;
+        return c.setBlockAttrs({ paragraphSpacing: String(value) });
+      }
+    });
+    return {};
+  }
+};
+function IndentAddon() {
+  return { id: "x/indent", dependencies: ["x/schema"], impl: IndentAddonImpl };
+}
+var IndentAddonImpl = {
+  id: "x/indent",
+  init(ctx) {
+    const bump = (c, delta) => {
+      const view = c._prosemirror;
+      if (!view) return false;
+      const { from, to } = view.state.selection;
+      let current = 0;
+      view.state.doc.nodeAt(from)?.attrs;
+      const node = view.state.doc.nodeAt(Math.max(0, from - 1));
+      if (node && typeof node.attrs?.["indent"] === "number")
+        current = node.attrs["indent"];
+      const next = Math.max(0, Math.min(10, current + delta));
+      return c.setBlockAttrs({ indent: next });
+    };
+    ctx.commands.register({
+      id: "indent",
+      label: "Indent",
+      icon: "indent",
+      shortcut: "Tab",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => bump(c, 1)
+    });
+    ctx.commands.register({
+      id: "outdent",
+      label: "Outdent",
+      icon: "outdent",
+      shortcut: "Shift-Tab",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => bump(c, -1)
+    });
+    return {};
+  }
+};
+
+// src/blocks/index.ts
+function HeadingsAddon() {
+  return {
+    id: "x/headings",
+    dependencies: ["x/schema"],
+    impl: HeadingsAddonImpl
+  };
+}
+var HeadingsAddonImpl = {
+  id: "x/headings",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "heading",
+      group: "block",
+      content: "inline*",
+      attrs: {
+        level: { default: 1 },
+        align: { default: null },
+        indent: { default: 0 },
+        lineHeight: { default: null }
+      },
+      parseDOM: [1, 2, 3, 4, 5, 6].map((level) => ({
+        tag: `h${level}`,
+        getAttrs: () => ({ level })
+      })),
+      toDOM: (node) => {
+        const style = [];
+        if (node.attrs.align) style.push(`text-align:${node.attrs.align}`);
+        if (node.attrs.lineHeight)
+          style.push(`line-height:${node.attrs.lineHeight}`);
+        const attrs = {};
+        if (style.length > 0) attrs["style"] = style.join(";");
+        if (node.attrs.indent > 0)
+          attrs["data-indent"] = String(node.attrs.indent);
+        return [`h${node.attrs.level}`, attrs, 0];
+      }
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    for (let level = 1; level <= 6; level++) {
+      ctx.commands.register({
+        id: `heading${level}`,
+        label: `Heading ${level}`,
+        icon: `h${level}`,
+        shortcut: `Mod-Alt-${level}`,
+        isEnabled: () => true,
+        isActive: () => false,
+        execute: () => ctxImpl.setBlockType("heading", { level })
+      });
+    }
+    ctx.commands.register({
+      id: "paragraph",
+      label: "Paragraph",
+      shortcut: "Mod-Alt-0",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.setBlockType("paragraph")
+    });
+    return {};
+  }
+};
+function BlockquoteAddon() {
+  return {
+    id: "x/blockquote",
+    dependencies: ["x/schema"],
+    impl: BlockquoteAddonImpl
+  };
+}
+var BlockquoteAddonImpl = {
+  id: "x/blockquote",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "blockquote",
+      group: "block",
+      content: "block+",
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM: () => ["blockquote", 0]
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "blockquote",
+      label: "Blockquote",
+      icon: "blockquote",
+      shortcut: "Mod-Shift-.",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.wrapInBlock("blockquote") || ctxImpl.liftBlock()
+    });
+    return {};
+  }
+};
+function DividerAddon() {
+  return {
+    id: "x/divider",
+    dependencies: ["x/schema"],
+    impl: DividerAddonImpl
+  };
+}
+var DividerAddonImpl = {
+  id: "x/divider",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "horizontalRule",
+      group: "block",
+      parseDOM: [{ tag: "hr" }],
+      toDOM: () => ["hr"]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertDivider",
+      label: "Divider",
+      icon: "divider",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("horizontalRule");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function PageBreakAddon() {
+  return {
+    id: "x/page-break",
+    dependencies: ["x/schema"],
+    impl: PageBreakAddonImpl
+  };
+}
+var PageBreakAddonImpl = {
+  id: "x/page-break",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "pageBreak",
+      group: "block",
+      parseDOM: [{ tag: "div[data-page-break]" }],
+      toDOM: () => [
+        "div",
+        { "data-page-break": "true", style: "page-break-after:always" }
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertPageBreak",
+      label: "Page Break",
+      icon: "page-break",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("pageBreak");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function CalloutAddon(config) {
+  return {
+    id: "x/callout",
+    config,
+    dependencies: ["x/schema"],
+    impl: CalloutAddonImpl
+  };
+}
+var CalloutAddonImpl = {
+  id: "x/callout",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "callout",
+      group: "block",
+      content: "block+",
+      attrs: { type: { default: "info" } },
+      parseDOM: [
+        {
+          tag: "div[data-callout]",
+          getAttrs: (el) => ({
+            type: el.getAttribute("data-callout")
+          })
+        }
+      ],
+      toDOM: (node) => [
+        "div",
+        {
+          "data-callout": node.attrs.type,
+          class: `xe-callout xe-callout--${node.attrs.type}`
+        },
+        0
+      ]
+    });
+  },
+  init(ctx, config = {}) {
+    const types = config.types ?? [
+      "info",
+      "success",
+      "warning",
+      "error",
+      "tip",
+      "note"
+    ];
+    const defaultType = types[0] ?? "info";
+    ctx.commands.register({
+      id: "insertCallout",
+      label: "Callout",
+      icon: "callout",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const type = args?.type ?? defaultType;
+        c.insertNode("callout", { type }, { type: "paragraph" });
+        return true;
+      }
+    });
+    for (const type of types) {
+      ctx.commands.register({
+        id: `insertCallout_${type}`,
+        label: `Callout: ${type}`,
+        icon: `callout-${type}`,
+        isEnabled: () => true,
+        isActive: () => false,
+        execute: (c) => {
+          c.insertNode("callout", { type }, { type: "paragraph" });
+          return true;
+        }
+      });
+    }
+    return {};
+  }
+};
+function DetailsAddon() {
+  return {
+    id: "x/details",
+    dependencies: ["x/schema"],
+    impl: DetailsAddonImpl
+  };
+}
+var DetailsAddonImpl = {
+  id: "x/details",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "details",
+      group: "block",
+      content: "summary block+",
+      parseDOM: [{ tag: "details" }],
+      toDOM: () => ["details", 0]
+    });
+    ctx.addNode({
+      name: "summary",
+      content: "inline*",
+      parseDOM: [{ tag: "summary" }],
+      toDOM: () => ["summary", 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertDetails",
+      label: "Details / Toggle",
+      icon: "details",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("details", void 0, [
+          { type: "summary" },
+          { type: "paragraph" }
+        ]);
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function ColumnsAddon(config) {
+  return {
+    id: "x/columns",
+    config,
+    dependencies: ["x/schema"],
+    impl: ColumnsAddonImpl
+  };
+}
+var ColumnsAddonImpl = {
+  id: "x/columns",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "columns",
+      group: "block",
+      content: "column+",
+      attrs: { ratio: { default: "1:1" } },
+      parseDOM: [{ tag: "div[data-columns]" }],
+      toDOM: () => ["div", { "data-columns": "true", class: "xe-columns" }, 0]
+    });
+    ctx.addNode({
+      name: "column",
+      content: "block+",
+      parseDOM: [{ tag: "div[data-column]" }],
+      toDOM: () => ["div", { "data-column": "true", class: "xe-column" }, 0]
+    });
+  },
+  init(ctx, config = {}) {
+    ctx.commands.register({
+      id: "insertColumns",
+      label: "Columns",
+      icon: "columns",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("columns", void 0, [
+          { type: "column", content: [{ type: "paragraph" }] },
+          { type: "column", content: [{ type: "paragraph" }] }
+        ]);
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "addColumn",
+      label: "Add Column",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "removeColumn",
+      label: "Remove Column",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "setColumnRatio",
+      label: "Set Column Ratio",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function CodeBlockAddon(config) {
+  return {
+    id: "x/code-block",
+    config,
+    dependencies: ["x/schema"],
+    impl: CodeBlockAddonImpl
+  };
+}
+var CodeBlockAddonImpl = {
+  id: "x/code-block",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "codeBlock",
+      group: "block",
+      content: "text*",
+      attrs: { language: { default: "" } },
+      parseDOM: [{ tag: "pre", preserveWhitespace: "full" }],
+      toDOM: () => ["pre", ["code", 0]]
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "insertCodeBlock",
+      label: "Code Block",
+      icon: "code-block",
+      shortcut: "Mod-Alt-c",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.setBlockType("codeBlock")
+    });
+    ctx.commands.register({
+      id: "copyCodeBlock",
+      label: "Copy Code",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        const text = c.getContent("text");
+        if (typeof navigator !== "undefined" && navigator.clipboard) {
+          navigator.clipboard.writeText(text).catch(() => {
+          });
+        }
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/lists/index.ts
+function BulletListAddon() {
+  return {
+    id: "x/bullet-list",
+    dependencies: ["x/schema"],
+    impl: BulletListAddonImpl
+  };
+}
+var BulletListAddonImpl = {
+  id: "x/bullet-list",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "bulletList",
+      group: "block",
+      content: "listItem+",
+      parseDOM: [{ tag: "ul" }],
+      toDOM: () => ["ul", 0]
+    });
+    ctx.addNode({
+      name: "listItem",
+      content: "paragraph block*",
+      parseDOM: [{ tag: "li" }],
+      toDOM: () => ["li", 0]
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "bulletList",
+      label: "Bullet List",
+      icon: "bullet-list",
+      shortcut: "Mod-Shift-8",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.wrapInBlock("bulletList") || ctxImpl.liftBlock()
+    });
+    return {};
+  }
+};
+function OrderedListAddon() {
+  return {
+    id: "x/ordered-list",
+    dependencies: ["x/schema"],
+    impl: OrderedListAddonImpl
+  };
+}
+var OrderedListAddonImpl = {
+  id: "x/ordered-list",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "orderedList",
+      group: "block",
+      content: "listItem+",
+      attrs: { order: { default: 1 } },
+      parseDOM: [
+        {
+          tag: "ol",
+          getAttrs: (el) => ({
+            order: parseInt(el.getAttribute("start") ?? "1", 10)
+          })
+        }
+      ],
+      toDOM: (node) => node.attrs.order === 1 ? ["ol", 0] : ["ol", { start: node.attrs.order }, 0]
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "orderedList",
+      label: "Ordered List",
+      icon: "ordered-list",
+      shortcut: "Mod-Shift-7",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.wrapInBlock("orderedList") || ctxImpl.liftBlock()
+    });
+    return {};
+  }
+};
+function TaskListAddon() {
+  return {
+    id: "x/task-list",
+    dependencies: ["x/schema"],
+    impl: TaskListAddonImpl
+  };
+}
+var TaskListAddonImpl = {
+  id: "x/task-list",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "taskList",
+      group: "block",
+      content: "taskItem+",
+      parseDOM: [{ tag: "ul[data-task-list]" }],
+      toDOM: () => ["ul", { "data-task-list": "true" }, 0]
+    });
+    ctx.addNode({
+      name: "taskItem",
+      content: "paragraph block*",
+      attrs: { checked: { default: false } },
+      parseDOM: [{ tag: "li[data-task-item]" }],
+      toDOM: (node) => [
+        "li",
+        { "data-task-item": "true", "data-checked": node.attrs.checked },
+        0
+      ]
+    });
+  },
+  init(ctx) {
+    const ctxImpl = ctx;
+    ctx.commands.register({
+      id: "taskList",
+      label: "Task List",
+      icon: "task-list",
+      shortcut: "Mod-Shift-9",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => ctxImpl.wrapInBlock("taskList") || ctxImpl.liftBlock()
+    });
+    return {};
+  }
+};
+function ToggleListAddon() {
+  return {
+    id: "x/toggle-list",
+    dependencies: ["x/schema"],
+    impl: ToggleListAddonImpl
+  };
+}
+var ToggleListAddonImpl = {
+  id: "x/toggle-list",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "toggleList",
+      group: "block",
+      content: "toggleItem+",
+      parseDOM: [{ tag: "ul[data-toggle-list]" }],
+      toDOM: () => ["ul", { "data-toggle-list": "true" }, 0]
+    });
+    ctx.addNode({
+      name: "toggleItem",
+      content: "paragraph block*",
+      attrs: { open: { default: true } },
+      parseDOM: [{ tag: "li[data-toggle-item]" }],
+      toDOM: () => ["li", { "data-toggle-item": "true" }, 0]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "toggleList",
+      label: "Toggle List",
+      icon: "toggle-list",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("toggleList", void 0, [
+          { type: "toggleItem", content: [{ type: "paragraph" }] }
+        ]);
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function ListsAddon() {
+  return [
+    BulletListAddon(),
+    OrderedListAddon(),
+    TaskListAddon(),
+    ToggleListAddon()
+  ];
+}
+
+// src/tables/index.ts
+function TableAddon(config) {
+  return {
+    id: "x/table",
+    config,
+    dependencies: ["x/schema"],
+    impl: TableAddonImpl
+  };
+}
+var _tablesCache = null;
+var _tablesPromise = null;
+async function loadTables() {
+  if (_tablesCache) return _tablesCache;
+  if (!_tablesPromise) {
+    _tablesPromise = import("prosemirror-tables").then((mod) => {
+      _tablesCache = mod;
+      return _tablesCache;
+    });
+  }
+  return _tablesPromise;
+}
+function getView(ctx) {
+  return ctx._prosemirror ?? null;
+}
+var TableAddonImpl = {
+  id: "x/table",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "table",
+      group: "block",
+      content: "tableRow+",
+      tableRole: "table",
+      isolating: true,
+      parseDOM: [{ tag: "table" }],
+      toDOM: () => ["table", ["tbody", 0]]
+    });
+    ctx.addNode({
+      name: "tableRow",
+      content: "(tableHeader | tableCell)+",
+      tableRole: "row",
+      parseDOM: [{ tag: "tr" }],
+      toDOM: () => ["tr", 0]
+    });
+    ctx.addNode({
+      name: "tableHeader",
+      content: "block+",
+      tableRole: "header_cell",
+      isolating: true,
+      attrs: {
+        colspan: { default: 1 },
+        rowspan: { default: 1 },
+        colwidth: { default: null },
+        align: { default: null },
+        background: { default: null }
+      },
+      parseDOM: [
+        {
+          tag: "th",
+          getAttrs: (el) => readCellAttrs(el)
+        }
+      ],
+      toDOM: (node) => [
+        "th",
+        cellDomAttrs(node.attrs),
+        0
+      ]
+    });
+    ctx.addNode({
+      name: "tableCell",
+      content: "block+",
+      tableRole: "cell",
+      isolating: true,
+      attrs: {
+        colspan: { default: 1 },
+        rowspan: { default: 1 },
+        colwidth: { default: null },
+        align: { default: null },
+        background: { default: null }
+      },
+      parseDOM: [
+        {
+          tag: "td",
+          getAttrs: (el) => readCellAttrs(el)
+        }
+      ],
+      toDOM: (node) => [
+        "td",
+        cellDomAttrs(node.attrs),
+        0
+      ]
+    });
+  },
+  init(ctx, config) {
+    void loadTables();
+    ctx.commands.register({
+      id: "insertTable",
+      label: "Insert Table",
+      icon: "table",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        const maxCols = config?.maxCols ?? 20;
+        const maxRows = config?.maxRows ?? 100;
+        const rows = clamp(a.rows ?? 3, 1, maxRows);
+        const cols = clamp(a.cols ?? 3, 1, maxCols);
+        const header = a.withHeader ?? true;
+        const headerRow = header ? [
+          {
+            type: "tableRow",
+            content: Array.from({ length: cols }, () => ({
+              type: "tableHeader",
+              content: [{ type: "paragraph" }]
+            }))
+          }
+        ] : [];
+        const bodyRows = Array.from(
+          { length: header ? Math.max(0, rows - 1) : rows },
+          () => ({
+            type: "tableRow",
+            content: Array.from({ length: cols }, () => ({
+              type: "tableCell",
+              content: [{ type: "paragraph" }]
+            }))
+          })
+        );
+        c.insertNode("table", void 0, [
+          ...headerRow,
+          ...bodyRows
+        ]);
+        return true;
+      }
+    });
+    registerTableCommand(
+      ctx,
+      "addRowBefore",
+      "Add Row Before",
+      (t) => t.addRowBefore
+    );
+    registerTableCommand(
+      ctx,
+      "addRowAfter",
+      "Add Row After",
+      (t) => t.addRowAfter
+    );
+    registerTableCommand(ctx, "deleteRow", "Delete Row", (t) => t.deleteRow);
+    registerTableCommand(
+      ctx,
+      "addColumnBefore",
+      "Add Column Before",
+      (t) => t.addColumnBefore
+    );
+    registerTableCommand(
+      ctx,
+      "addColumnAfter",
+      "Add Column After",
+      (t) => t.addColumnAfter
+    );
+    registerTableCommand(
+      ctx,
+      "deleteColumn",
+      "Delete Column",
+      (t) => t.deleteColumn
+    );
+    registerTableCommand(
+      ctx,
+      "addColBefore",
+      "Add Column Before",
+      (t) => t.addColumnBefore
+    );
+    registerTableCommand(
+      ctx,
+      "addColAfter",
+      "Add Column After",
+      (t) => t.addColumnAfter
+    );
+    registerTableCommand(
+      ctx,
+      "deleteCol",
+      "Delete Column",
+      (t) => t.deleteColumn
+    );
+    registerTableCommand(ctx, "mergeCells", "Merge Cells", (t) => t.mergeCells);
+    registerTableCommand(ctx, "splitCell", "Split Cell", (t) => t.splitCell);
+    registerTableCommand(
+      ctx,
+      "toggleHeaderRow",
+      "Toggle Header Row",
+      (t) => t.toggleHeaderRow
+    );
+    registerTableCommand(
+      ctx,
+      "toggleHeaderCol",
+      "Toggle Header Column",
+      (t) => t.toggleHeaderColumn
+    );
+    registerTableCommand(
+      ctx,
+      "toggleHeaderColumn",
+      "Toggle Header Column",
+      (t) => t.toggleHeaderColumn
+    );
+    registerTableCommand(
+      ctx,
+      "goToNextCell",
+      "Next Cell",
+      (t) => t.goToNextCell(1)
+    );
+    registerTableCommand(
+      ctx,
+      "goToPrevCell",
+      "Previous Cell",
+      (t) => t.goToNextCell(-1)
+    );
+    ctx.commands.register({
+      id: "setCellAlignment",
+      label: "Set Cell Alignment",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const align = args?.align ?? null;
+        return setCellAttr(c, "align", align);
+      }
+    });
+    ctx.commands.register({
+      id: "setCellBackground",
+      label: "Set Cell Background",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const bg = args?.background ?? args?.color ?? null;
+        return setCellAttr(c, "background", bg);
+      }
+    });
+    ctx.commands.register({
+      id: "deleteTable",
+      label: "Delete Table",
+      icon: "table-delete",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        const view = getView(c);
+        if (!view) return false;
+        if (_tablesCache) {
+          const ok = _tablesCache.deleteTable(view.state, view.dispatch);
+          if (ok) return true;
+        }
+        const found = findTableNode(view);
+        if (!found) return false;
+        const tr = view.state.tr.delete(found.from, found.from + found.size);
+        view.dispatch(tr);
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function clamp(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function readCellAttrs(el) {
+  const colspan = parseInt(el.getAttribute("colspan") ?? "1", 10);
+  const rowspan = parseInt(el.getAttribute("rowspan") ?? "1", 10);
+  const widthAttr = el.getAttribute("data-colwidth");
+  let colwidth = null;
+  if (widthAttr) {
+    const widths = widthAttr.split(",").map((s) => parseInt(s, 10));
+    if (widths.every((w) => !isNaN(w)) && widths.length === colspan) {
+      colwidth = widths;
+    }
+  }
+  const align = el.style.textAlign || el.getAttribute("data-align") || null;
+  const background = el.style.backgroundColor || el.getAttribute("data-background") || null;
+  return { colspan, rowspan, colwidth, align, background };
+}
+function cellDomAttrs(attrs) {
+  const out = {};
+  const colspan = attrs["colspan"] ?? 1;
+  const rowspan = attrs["rowspan"] ?? 1;
+  if (colspan !== 1) out["colspan"] = String(colspan);
+  if (rowspan !== 1) out["rowspan"] = String(rowspan);
+  const colwidth = attrs["colwidth"];
+  if (colwidth) out["data-colwidth"] = colwidth.join(",");
+  const align = attrs["align"];
+  const background = attrs["background"];
+  const styles = [];
+  if (align) styles.push(`text-align:${align}`);
+  if (background) styles.push(`background-color:${background}`);
+  if (styles.length > 0) out["style"] = styles.join(";");
+  if (align) out["data-align"] = align;
+  if (background) out["data-background"] = background;
+  return out;
+}
+function registerTableCommand(ctx, id, label, pick) {
+  ctx.commands.register({
+    id,
+    label,
+    isEnabled: () => true,
+    isActive: () => false,
+    execute: (c) => {
+      const view = getView(c);
+      if (!view) return false;
+      if (_tablesCache) {
+        const cmd = pick(_tablesCache);
+        if (!cmd) return false;
+        return cmd(view.state, view.dispatch);
+      }
+      void loadTables();
+      return false;
+    }
+  });
+}
+function setCellAttr(ctx, name, value) {
+  const view = getView(ctx);
+  if (!view) return false;
+  if (!_tablesCache) {
+    void loadTables();
+    return false;
+  }
+  return _tablesCache.setCellAttr(name, value)(view.state, view.dispatch);
+}
+function findTableNode(view) {
+  let result = null;
+  view.state.doc.descendants((node, pos) => {
+    if (!result && node.type.name === "table") {
+      result = { from: pos, size: node.nodeSize };
+    }
+  });
+  return result;
+}
+
+// src/media/index.ts
+function ImageAddon(config) {
+  return {
+    id: "x/image",
+    config,
+    dependencies: ["x/schema"],
+    impl: ImageAddonImpl
+  };
+}
+var ImageAddonImpl = {
+  id: "x/image",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "image",
+      group: "block",
+      atom: true,
+      draggable: true,
+      attrs: {
+        src: {},
+        alt: { default: "" },
+        title: { default: null },
+        width: { default: null },
+        align: { default: "center" }
+      },
+      parseDOM: [
+        {
+          tag: "img[src]",
+          getAttrs: (el) => ({
+            src: el.getAttribute("src"),
+            alt: el.getAttribute("alt"),
+            title: el.getAttribute("title")
+          })
+        }
+      ],
+      toDOM: (node) => ["img", node.attrs]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertImage",
+      label: "Image",
+      icon: "image",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.src) return false;
+        c.insertNode("image", {
+          src: a.src,
+          alt: a.alt ?? "",
+          title: a.title ?? null,
+          width: a.width ?? null,
+          align: a.align ?? "center"
+        });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "setImageAlt",
+      label: "Set Image Alt",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "setImageSize",
+      label: "Set Image Size",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "alignImageLeft",
+      label: "Align Image Left",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "alignImageCenter",
+      label: "Align Image Center",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "alignImageRight",
+      label: "Align Image Right",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "alignImageFull",
+      label: "Align Image Full",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function VideoAddon(config) {
+  return {
+    id: "x/video",
+    config,
+    dependencies: ["x/schema"],
+    impl: VideoAddonImpl
+  };
+}
+var VideoAddonImpl = {
+  id: "x/video",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "video",
+      group: "block",
+      atom: true,
+      attrs: {
+        src: {},
+        provider: { default: "upload" },
+        poster: { default: null },
+        width: { default: null }
+      },
+      parseDOM: [
+        {
+          tag: "video[src]",
+          getAttrs: (el) => ({ src: el.getAttribute("src") })
+        }
+      ],
+      toDOM: (node) => [
+        "video",
+        { src: node.attrs["src"], controls: "true" }
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertVideo",
+      label: "Video",
+      icon: "video",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.src) return false;
+        c.insertNode("video", {
+          src: a.src,
+          provider: a.provider ?? "upload",
+          poster: a.poster ?? null,
+          width: a.width ?? null
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function AudioAddon(config) {
+  return {
+    id: "x/audio",
+    config,
+    dependencies: ["x/schema"],
+    impl: AudioAddonImpl
+  };
+}
+var AudioAddonImpl = {
+  id: "x/audio",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "audio",
+      group: "block",
+      atom: true,
+      attrs: { src: {}, title: { default: "" } },
+      parseDOM: [
+        {
+          tag: "audio[src]",
+          getAttrs: (el) => ({ src: el.getAttribute("src") })
+        }
+      ],
+      toDOM: (node) => [
+        "audio",
+        { src: node.attrs["src"], controls: "true" }
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertAudio",
+      label: "Audio",
+      icon: "audio",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.src) return false;
+        c.insertNode("audio", { src: a.src, title: a.title ?? "" });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function FileAddon(config) {
+  return {
+    id: "x/file",
+    config,
+    dependencies: ["x/schema"],
+    impl: FileAddonImpl
+  };
+}
+var FileAddonImpl = {
+  id: "x/file",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "file",
+      group: "block",
+      atom: true,
+      attrs: {
+        src: {},
+        name: {},
+        size: { default: 0 },
+        mimeType: { default: "" }
+      },
+      parseDOM: [{ tag: "a[data-file]" }],
+      toDOM: (node) => [
+        "a",
+        {
+          href: node.attrs["src"],
+          download: node.attrs["name"],
+          "data-file": "true"
+        },
+        String(node.attrs["name"])
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertFile",
+      label: "File",
+      icon: "file",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        const src = a.src ?? a.url;
+        if (!src) return false;
+        c.insertNode("file", {
+          src,
+          name: a.name ?? "file",
+          size: a.size ?? 0,
+          mimeType: a.mimeType ?? ""
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function EmbedAddon(config) {
+  return {
+    id: "x/embed",
+    config,
+    dependencies: ["x/schema"],
+    impl: EmbedAddonImpl
+  };
+}
+var EmbedAddonImpl = {
+  id: "x/embed",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "embed",
+      group: "block",
+      atom: true,
+      attrs: {
+        url: {},
+        provider: { default: "" },
+        width: { default: null },
+        height: { default: null }
+      },
+      parseDOM: [{ tag: "iframe[data-embed]" }],
+      toDOM: (node) => [
+        "iframe",
+        { src: node.attrs["url"], "data-embed": "true", class: "xe-embed" }
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertEmbed",
+      label: "Embed",
+      icon: "embed",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.url) return false;
+        c.insertNode("embed", {
+          url: a.url,
+          provider: a.provider ?? "",
+          width: a.width ?? null,
+          height: a.height ?? null
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function BookmarkAddon(config) {
+  return {
+    id: "x/bookmark",
+    config,
+    dependencies: ["x/schema"],
+    impl: BookmarkAddonImpl
+  };
+}
+var BookmarkAddonImpl = {
+  id: "x/bookmark",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "bookmark",
+      group: "block",
+      atom: true,
+      attrs: {
+        url: {},
+        title: { default: "" },
+        description: { default: "" },
+        image: { default: null },
+        favicon: { default: null }
+      },
+      parseDOM: [{ tag: "div[data-bookmark]" }],
+      toDOM: () => ["div", { "data-bookmark": "true", class: "xe-bookmark" }]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertBookmark",
+      label: "Bookmark",
+      icon: "bookmark",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.url) return false;
+        c.insertNode("bookmark", {
+          url: a.url,
+          title: a.title ?? "",
+          description: a.description ?? "",
+          image: a.image ?? null,
+          favicon: a.favicon ?? null
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/inline/index.ts
+function LinkAddon(config) {
+  return {
+    id: "x/link",
+    config,
+    dependencies: ["x/schema"],
+    impl: LinkAddonImpl
+  };
+}
+var LinkAddonImpl = {
+  id: "x/link",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "link",
+      attrs: {
+        href: {},
+        title: { default: null },
+        target: { default: "_blank" }
+      },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "a[href]",
+          getAttrs: (el) => ({
+            href: el.getAttribute("href"),
+            title: el.getAttribute("title"),
+            target: el.getAttribute("target")
+          })
+        }
+      ],
+      toDOM: (mark) => ["a", mark.attrs, 0]
+    });
+  },
+  init(ctx, config = {}) {
+    ctx.commands.register({
+      id: "insertLink",
+      label: "Insert Link",
+      icon: "link",
+      shortcut: "Mod-k",
+      isEnabled: () => true,
+      isActive: (c) => c.selection.hasMark("link"),
+      execute: (c, args) => {
+        const a = args ?? {};
+        let url = a.href;
+        if (!url) {
+          if (typeof window === "undefined") return false;
+          const prompted = window.prompt("Enter URL", "https://");
+          if (!prompted) return false;
+          url = prompted;
+        }
+        if (config.validate && !config.validate(url)) return false;
+        c.addMark("link", {
+          href: url,
+          title: a.title ?? null,
+          target: a.target ?? config.defaultTarget ?? "_blank"
+        });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "editLink",
+      label: "Edit Link",
+      isEnabled: (c) => c.selection.hasMark("link"),
+      isActive: () => false,
+      execute: (c) => {
+        if (typeof window === "undefined") return false;
+        const url = window.prompt("Edit URL", "https://");
+        if (!url) return false;
+        c.addMark("link", {
+          href: url,
+          target: config.defaultTarget ?? "_blank"
+        });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "removeLink",
+      label: "Remove Link",
+      isEnabled: (c) => c.selection.hasMark("link"),
+      isActive: () => false,
+      execute: (c) => {
+        c.removeMark("link");
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "openLink",
+      label: "Open Link",
+      isEnabled: (c) => c.selection.hasMark("link"),
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function MentionAddon(config) {
+  return {
+    id: "x/mention",
+    config,
+    dependencies: ["x/schema"],
+    impl: MentionAddonImpl
+  };
+}
+var MentionAddonImpl = {
+  id: "x/mention",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "mention",
+      group: "inline",
+      inline: true,
+      atom: true,
+      attrs: { id: {}, label: {}, type: { default: "user" } },
+      parseDOM: [{ tag: "span[data-mention]" }],
+      toDOM: (node) => [
+        "span",
+        {
+          "data-mention": node.attrs["type"],
+          "data-id": node.attrs["id"],
+          class: "xe-mention"
+        },
+        `@${node.attrs["label"]}`
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertMention",
+      label: "Mention",
+      icon: "mention",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        if (!a.id || !a.label) return false;
+        c.insertNode("mention", {
+          id: a.id,
+          label: a.label,
+          type: a.type ?? "user"
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function EmojiAddon(config) {
+  return {
+    id: "x/emoji",
+    config,
+    dependencies: ["x/schema"],
+    impl: EmojiAddonImpl
+  };
+}
+var EmojiAddonImpl = {
+  id: "x/emoji",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "emoji",
+      group: "inline",
+      inline: true,
+      atom: true,
+      attrs: { id: {}, native: {} },
+      parseDOM: [{ tag: "span[data-emoji]" }],
+      toDOM: (node) => [
+        "span",
+        { "data-emoji": node.attrs["id"], class: "xe-emoji" },
+        node.attrs["native"]
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertEmoji",
+      label: "Emoji",
+      icon: "emoji",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        const id = a.id ?? a.shortcode ?? "smile";
+        const native = a.native ?? "\u{1F642}";
+        c.insertNode("emoji", { id, native });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function EquationAddon(config) {
+  return {
+    id: "x/equation",
+    config,
+    dependencies: ["x/schema"],
+    impl: EquationAddonImpl
+  };
+}
+var EquationAddonImpl = {
+  id: "x/equation",
+  initSchema(ctx) {
+    ctx.addMark({
+      name: "equation",
+      parseDOM: [{ tag: "span[data-equation]" }],
+      toDOM: () => [
+        "span",
+        { "data-equation": "true", class: "xe-equation-inline" },
+        0
+      ]
+    });
+    ctx.addNode({
+      name: "equationBlock",
+      group: "block",
+      atom: true,
+      attrs: { src: {} },
+      parseDOM: [{ tag: "div[data-equation-block]" }],
+      toDOM: () => [
+        "div",
+        { "data-equation-block": "true", class: "xe-equation-block" }
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertEquationBlock",
+      label: "Equation Block",
+      icon: "equation-block",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const src = args?.latex ?? args?.src ?? "";
+        c.insertNode("equationBlock", { src });
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "insertEquation",
+      label: "Equation",
+      icon: "equation",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => c.execCommand("insertEquationBlock", args)
+    });
+    ctx.commands.register({
+      id: "insertInlineEquation",
+      label: "Inline Equation",
+      icon: "equation",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.addMark("equation");
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "editEquation",
+      label: "Edit Equation",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function FootnoteAddon() {
+  return {
+    id: "x/footnote",
+    dependencies: ["x/schema"],
+    impl: FootnoteAddonImpl
+  };
+}
+var FootnoteAddonImpl = {
+  id: "x/footnote",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "footnoteRef",
+      group: "inline",
+      inline: true,
+      atom: true,
+      attrs: { id: {}, index: { default: 1 } },
+      parseDOM: [{ tag: "sup[data-footnote-ref]" }],
+      toDOM: (node) => [
+        "sup",
+        { "data-footnote-ref": node.attrs["id"], class: "xe-footnote-ref" },
+        `[${node.attrs["index"]}]`
+      ]
+    });
+    ctx.addNode({
+      name: "footnote",
+      group: "block",
+      content: "block+",
+      attrs: { id: {} },
+      parseDOM: [{ tag: "div[data-footnote]" }],
+      toDOM: () => [
+        "div",
+        { "data-footnote": "true", class: "xe-footnote" },
+        0
+      ]
+    });
+  },
+  init(ctx) {
+    let _footnoteCounter = 0;
+    ctx.commands.register({
+      id: "insertFootnote",
+      label: "Footnote",
+      icon: "footnote",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        const id = a.id ?? `fn-${++_footnoteCounter}`;
+        c.insertNode("footnote", { id }, [
+          {
+            type: "paragraph",
+            content: a.text ? [{ type: "text", text: a.text }] : []
+          }
+        ]);
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "editFootnote",
+      label: "Edit Footnote",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function SmartChipAddon(config) {
+  return {
+    id: "x/smart-chip",
+    config,
+    dependencies: ["x/mention"],
+    impl: SmartChipAddonImpl
+  };
+}
+var SmartChipAddonImpl = {
+  id: "x/smart-chip",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "smartChip",
+      group: "inline",
+      inline: true,
+      atom: true,
+      attrs: {
+        kind: { default: "generic" },
+        value: { default: "" },
+        label: { default: null }
+      },
+      parseDOM: [{ tag: "span[data-smart-chip]" }],
+      toDOM: (node) => [
+        "span",
+        {
+          "data-smart-chip": node.attrs["kind"],
+          "data-value": node.attrs["value"],
+          class: "xe-smart-chip"
+        },
+        String(node.attrs["label"] ?? node.attrs["value"])
+      ]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertSmartChip",
+      label: "Smart Chip",
+      icon: "smart-chip",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c, args) => {
+        const a = args ?? {};
+        c.insertNode("smartChip", {
+          kind: a.kind ?? "generic",
+          value: a.value ?? "",
+          label: a.label ?? null
+        });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/ui-shell/command-group.ts
+function createCommandGroup(ctx, opts) {
+  const mode = opts.mode ?? "inline";
+  const density = opts.density ?? (mode === "popover" ? "compact" : "comfortable");
+  const orientation = opts.orientation ?? "horizontal";
+  const showLabels = opts.showLabels ?? false;
+  const showTooltips = opts.showTooltips ?? true;
+  let loading = opts.loading ?? /* @__PURE__ */ new Set();
+  const el = document.createElement("div");
+  el.className = `xe-cgroup xe-cgroup--${mode} xe-cgroup--${density} xe-cgroup--${orientation}`;
+  el.setAttribute("role", "group");
+  el.setAttribute("aria-orientation", orientation);
+  if (opts.label) el.setAttribute("aria-label", opts.label);
+  const entries = [];
+  for (const cmdId of opts.commands) {
+    const cmd = ctx.commands.get(cmdId);
+    if (!cmd) continue;
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "xe-cgroup__btn";
+    btn.dataset["cmdId"] = cmdId;
+    btn.setAttribute("aria-label", cmd.label);
+    btn.tabIndex = -1;
+    if (cmd.icon) {
+      const svg = ctx.icons.get(cmd.icon);
+      const iconWrap = document.createElement("span");
+      iconWrap.className = "xe-cgroup__icon";
+      iconWrap.innerHTML = svg ?? cmd.icon;
+      btn.appendChild(iconWrap);
+    }
+    if (showLabels) {
+      const label = document.createElement("span");
+      label.className = "xe-cgroup__label";
+      label.textContent = cmd.label;
+      btn.appendChild(label);
+    }
+    btn.addEventListener("click", (ev) => {
+      ev.preventDefault();
+      if (btn.disabled) return;
+      if (loading.has(cmdId)) return;
+      if (opts.onActivate) opts.onActivate(cmdId);
+      else ctx.execCommand(cmdId);
+    });
+    btn.addEventListener("mousedown", (ev) => {
+      ev.preventDefault();
+    });
+    el.appendChild(btn);
+    entries.push({ cmdId, cmd, btn });
+  }
+  let activeIndex = entries.findIndex(
+    (e) => !(e.cmd.isEnabled?.(ctx) === false)
+  );
+  if (activeIndex < 0 && entries.length > 0) activeIndex = 0;
+  if (activeIndex >= 0) entries[activeIndex].btn.tabIndex = 0;
+  const setActive = (next, focus) => {
+    if (next < 0 || next >= entries.length) return;
+    if (entries[next].btn.disabled) return;
+    if (activeIndex >= 0 && activeIndex < entries.length) {
+      entries[activeIndex].btn.tabIndex = -1;
+    }
+    activeIndex = next;
+    entries[activeIndex].btn.tabIndex = 0;
+    if (focus) entries[activeIndex].btn.focus();
+  };
+  const findNext = (from, dir) => {
+    if (entries.length === 0) return -1;
+    for (let i = 1; i <= entries.length; i++) {
+      const idx = (from + dir * i + entries.length * i) % entries.length;
+      if (!entries[idx].btn.disabled) return idx;
+    }
+    return -1;
+  };
+  const onKeyDown = (ev) => {
+    const nextKey = orientation === "horizontal" ? "ArrowRight" : "ArrowDown";
+    const prevKey = orientation === "horizontal" ? "ArrowLeft" : "ArrowUp";
+    if (ev.key === nextKey) {
+      ev.preventDefault();
+      const n = findNext(activeIndex, 1);
+      if (n >= 0) setActive(n, true);
+    } else if (ev.key === prevKey) {
+      ev.preventDefault();
+      const n = findNext(activeIndex, -1);
+      if (n >= 0) setActive(n, true);
+    } else if (ev.key === "Home") {
+      ev.preventDefault();
+      for (let i = 0; i < entries.length; i++) {
+        if (!entries[i].btn.disabled) {
+          setActive(i, true);
+          break;
+        }
+      }
+    } else if (ev.key === "End") {
+      ev.preventDefault();
+      for (let i = entries.length - 1; i >= 0; i--) {
+        if (!entries[i].btn.disabled) {
+          setActive(i, true);
+          break;
+        }
+      }
+    }
+  };
+  el.addEventListener("keydown", onKeyDown);
+  const onFocusIn = (ev) => {
+    const target = ev.target;
+    if (!target) return;
+    const idx = entries.findIndex((e) => e.btn === target);
+    if (idx >= 0 && idx !== activeIndex) setActive(idx, false);
+  };
+  el.addEventListener("focusin", onFocusIn);
+  const update = () => {
+    for (const entry of entries) {
+      const { cmd, btn, cmdId } = entry;
+      const enabled = cmd.isEnabled?.(ctx) ?? true;
+      const active = cmd.isActive?.(ctx) ?? false;
+      const isLoading = loading.has(cmdId);
+      btn.disabled = !enabled || isLoading;
+      btn.setAttribute("aria-disabled", String(!enabled));
+      btn.setAttribute("aria-pressed", String(active));
+      if (isLoading) btn.setAttribute("aria-busy", "true");
+      else btn.removeAttribute("aria-busy");
+      btn.classList.toggle("xe-cgroup__btn--active", active);
+      btn.classList.toggle("xe-cgroup__btn--disabled", !enabled);
+      btn.classList.toggle("xe-cgroup__btn--loading", isLoading);
+      const tooltipText = showTooltips && cmd.label ? cmd.shortcut ? `${cmd.label} (${cmd.shortcut})` : cmd.label : "";
+      if (tooltipText) btn.title = tooltipText;
+      else btn.removeAttribute("title");
+      const hasSpinner = btn.querySelector(".xe-cgroup__spinner");
+      if (isLoading && !hasSpinner) {
+        const spinner = document.createElement("span");
+        spinner.className = "xe-cgroup__spinner";
+        spinner.setAttribute("aria-hidden", "true");
+        btn.appendChild(spinner);
+      } else if (!isLoading && hasSpinner) {
+        hasSpinner.remove();
+      }
+    }
+    if (activeIndex >= 0 && activeIndex < entries.length && entries[activeIndex].btn.disabled) {
+      const n = findNext(activeIndex, 1);
+      if (n >= 0) setActive(n, false);
+    }
+  };
+  update();
+  const focusFirst = () => {
+    const n = findNext(-1, 1);
+    if (n >= 0) setActive(n, true);
+  };
+  const focusLast = () => {
+    const n = findNext(entries.length, -1);
+    if (n >= 0) setActive(n, true);
+  };
+  const setLoading = (next) => {
+    loading = next;
+    update();
+  };
+  const destroy = () => {
+    el.removeEventListener("keydown", onKeyDown);
+    el.removeEventListener("focusin", onFocusIn);
+    el.remove();
+  };
+  return { el, update, focusFirst, focusLast, setLoading, destroy };
+}
+
+// src/ui-shell/index.ts
+function ToolbarAddon(config) {
+  return {
+    id: "x/toolbar",
+    config,
+    dependencies: ["x/commands"],
+    impl: ToolbarAddonImpl
+  };
+}
+var ToolbarAddonImpl = {
+  id: "x/toolbar",
+  init(ctx, config = {}) {
+    const container = ctx.getSlot("toolbar");
+    if (!container) return {};
+    const toolbar = document.createElement("div");
+    toolbar.className = "xe-toolbar";
+    toolbar.setAttribute("role", "toolbar");
+    container.appendChild(toolbar);
+    let groupHandles = [];
+    let lastGroupsKey = "";
+    const render = () => {
+      const groups = config.groups ?? [
+        { commands: ctx.commands.getAll().map((c) => c.id) }
+      ];
+      const groupsKey = JSON.stringify(
+        groups.map((g) => [g.label ?? "", g.commands])
+      );
+      if (groupsKey === lastGroupsKey) {
+        for (const h of groupHandles) h.update();
+        return;
+      }
+      lastGroupsKey = groupsKey;
+      for (const h of groupHandles) h.destroy();
+      groupHandles = [];
+      toolbar.innerHTML = "";
+      for (const group of groups) {
+        const handle = createCommandGroup(ctx, {
+          commands: group.commands,
+          label: group.label,
+          mode: "inline",
+          density: "comfortable",
+          showLabels: config.showLabels,
+          showTooltips: config.showTooltips
+        });
+        toolbar.appendChild(handle.el);
+        groupHandles.push(handle);
+      }
+    };
+    render();
+    const unsub = ctx.on("selection:change", () => {
+      for (const h of groupHandles) h.update();
+    });
+    const unsub2 = ctx.on("doc:change", render);
+    return {
+      destroy() {
+        unsub();
+        unsub2();
+        for (const h of groupHandles) h.destroy();
+        groupHandles = [];
+        toolbar.remove();
+      }
+    };
+  }
+};
+function BubbleMenuAddon(config) {
+  return {
+    id: "x/bubble-menu",
+    config,
+    dependencies: ["x/commands"],
+    impl: BubbleMenuAddonImpl
+  };
+}
+var DEFAULT_BUBBLE_COMMANDS = [
+  "bold",
+  "italic",
+  "underline",
+  "strikethrough",
+  "inlineCode",
+  "insertLink"
+];
+var BubbleMenuAddonImpl = {
+  id: "x/bubble-menu",
+  init(ctx, config = {}) {
+    const menu = document.createElement("div");
+    menu.className = "xe-bubble-menu";
+    menu.style.display = "none";
+    menu.style.position = "absolute";
+    ctx.getSlot("overlay")?.appendChild(menu);
+    const commands = (config.commands ?? DEFAULT_BUBBLE_COMMANDS).filter(
+      (id) => !!ctx.commands.get(id)
+    );
+    const group = createCommandGroup(ctx, {
+      commands,
+      mode: "popover",
+      density: "compact",
+      showTooltips: true,
+      label: "Selection actions"
+    });
+    menu.appendChild(group.el);
+    const unsub = ctx.on("selection:change", () => {
+      if (ctx.selection.empty) {
+        menu.style.display = "none";
+      } else {
+        menu.style.display = "flex";
+        group.update();
+      }
+    });
+    const unsub2 = ctx.on("doc:change", () => group.update());
+    return {
+      destroy() {
+        unsub();
+        unsub2();
+        group.destroy();
+        menu.remove();
+      }
+    };
+  }
+};
+function SlashMenuAddon(config) {
+  return {
+    id: "x/slash-menu",
+    config,
+    dependencies: ["x/commands"],
+    impl: SlashMenuAddonImpl
+  };
+}
+var SlashMenuAddonImpl = {
+  id: "x/slash-menu",
+  init(ctx, config = {}) {
+    const content = ctx.getSlot("content");
+    let menu = null;
+    let groupHandles = [];
+    const close = () => {
+      for (const h of groupHandles) h.destroy();
+      groupHandles = [];
+      if (menu) {
+        menu.remove();
+        menu = null;
+      }
+    };
+    const buildGroups = () => {
+      if (config.groups && config.groups.length > 0) return config.groups;
+      const all = ctx.commands.getAll().slice(0, config.maxVisible ?? 30).map((c) => c.id);
+      return [{ label: "Commands", commands: all }];
+    };
+    const open = () => {
+      close();
+      menu = document.createElement("div");
+      menu.className = "xe-slash-menu";
+      menu.setAttribute("data-xe-slash", "true");
+      const groups = buildGroups();
+      for (const grp of groups) {
+        if (grp.label) {
+          const header = document.createElement("div");
+          header.className = "xe-slash-menu__label";
+          header.textContent = grp.label;
+          menu.appendChild(header);
+        }
+        const handle = createCommandGroup(ctx, {
+          commands: grp.commands,
+          label: grp.label,
+          mode: "popover",
+          density: "compact",
+          orientation: "vertical",
+          showLabels: true,
+          showTooltips: false,
+          onActivate: (cmdId) => {
+            ctx.execCommand(cmdId);
+            close();
+          }
+        });
+        menu.appendChild(handle.el);
+        groupHandles.push(handle);
+      }
+      const host = ctx.getSlot("overlay") ?? content ?? document.body;
+      host.appendChild(menu);
+      menu.addEventListener("keydown", (ev) => {
+        if (ev.key === "Escape") {
+          ev.preventDefault();
+          close();
+        }
+      });
+      groupHandles[0]?.focusFirst();
+    };
+    const onKeydown = (e) => {
+      if (e.key === "/") {
+        setTimeout(open, 0);
+      } else if (e.key === "Escape" && menu) {
+        e.preventDefault();
+        close();
+      }
+    };
+    const target = content ?? document;
+    target.addEventListener("keydown", onKeydown);
+    document.addEventListener(
+      "click",
+      (ev) => {
+        if (menu && !menu.contains(ev.target)) close();
+      },
+      true
+    );
+    return {
+      destroy() {
+        close();
+        target.removeEventListener("keydown", onKeydown);
+      }
+    };
+  }
+};
+function CommandPaletteAddon(config) {
+  return {
+    id: "x/command-palette",
+    config,
+    dependencies: ["x/commands"],
+    impl: CommandPaletteAddonImpl
+  };
+}
+var CommandPaletteAddonImpl = {
+  id: "x/command-palette",
+  init(ctx, _config = {}) {
+    let palette = null;
+    const close = () => {
+      if (palette) {
+        palette.remove();
+        palette = null;
+      }
+    };
+    const open = () => {
+      close();
+      palette = document.createElement("div");
+      palette.className = "xe-command-palette";
+      palette.setAttribute("data-xe-palette", "true");
+      palette.style.cssText = "position:fixed; top:20%; left:50%; transform:translateX(-50%); background:var(--xe-bg,#fff); border:1px solid var(--xe-border,#ddd); border-radius:8px; padding:10px; width:420px; max-height:60vh; overflow:auto; box-shadow:0 12px 48px rgba(0,0,0,0.2); z-index:1000;";
+      const input = document.createElement("input");
+      input.type = "text";
+      input.placeholder = "Search commands\u2026";
+      input.style.cssText = "width:100%; padding:8px; border:1px solid var(--xe-border,#ddd); border-radius:4px; box-sizing:border-box;";
+      const list = document.createElement("div");
+      list.className = "xe-command-palette-list";
+      list.style.cssText = "margin-top:8px; max-height:50vh; overflow:auto;";
+      const renderList = (q = "") => {
+        list.innerHTML = "";
+        const ql = q.toLowerCase();
+        for (const cmd of ctx.commands.getAll()) {
+          if (ql && !cmd.label.toLowerCase().includes(ql) && !cmd.id.toLowerCase().includes(ql))
+            continue;
+          const row = document.createElement("button");
+          row.type = "button";
+          row.textContent = cmd.label;
+          row.style.cssText = "display:block; width:100%; text-align:left; padding:6px 8px; border:0; background:transparent; cursor:pointer;";
+          row.addEventListener("mousedown", (ev) => {
+            ev.preventDefault();
+            ctx.execCommand(cmd.id);
+            close();
+          });
+          list.appendChild(row);
+        }
+      };
+      input.addEventListener("input", () => renderList(input.value));
+      input.addEventListener("keydown", (ev) => {
+        if (ev.key === "Escape") close();
+      });
+      palette.appendChild(input);
+      palette.appendChild(list);
+      renderList();
+      document.body.appendChild(palette);
+      input.focus();
+    };
+    const handleKeydown = (e) => {
+      const mod = e.metaKey || e.ctrlKey;
+      if (mod && (e.key === "k" || e.key === "K")) {
+        e.preventDefault();
+        ctx.emit("command-palette:open");
+        open();
+      }
+    };
+    document.addEventListener("keydown", handleKeydown);
+    return {
+      destroy() {
+        close();
+        document.removeEventListener("keydown", handleKeydown);
+      }
+    };
+  }
+};
+function BlockHandlesAddon(config) {
+  return { id: "x/block-handles", config, impl: BlockHandlesAddonImpl };
+}
+var BlockHandlesAddonImpl = {
+  id: "x/block-handles",
+  init(_ctx) {
+    return {};
+  }
+};
+function ContextMenuAddon() {
+  return {
+    id: "x/context-menu",
+    dependencies: ["x/commands"],
+    impl: ContextMenuAddonImpl
+  };
+}
+var ContextMenuAddonImpl = {
+  id: "x/context-menu",
+  init(ctx) {
+    const content = ctx.getSlot("content");
+    const handleContextMenu = (e) => {
+      e.preventDefault();
+      ctx.emit("context-menu:open", { x: e.clientX, y: e.clientY });
+    };
+    content?.addEventListener("contextmenu", handleContextMenu);
+    return {
+      destroy() {
+        content?.removeEventListener("contextmenu", handleContextMenu);
+      }
+    };
+  }
+};
+function StatusBarAddon(config) {
+  return { id: "x/status-bar", config, impl: StatusBarAddonImpl };
+}
+var StatusBarAddonImpl = {
+  id: "x/status-bar",
+  init(ctx, config = {}) {
+    const container = ctx.getSlot("statusbar");
+    if (!container) return {};
+    const slots = config.slots ?? ["wordCount", "charCount"];
+    const bar = document.createElement("div");
+    bar.className = "xe-status-bar";
+    bar.style.display = "flex";
+    bar.style.gap = "12px";
+    bar.style.padding = "4px 8px";
+    container.appendChild(bar);
+    const slotEls = /* @__PURE__ */ new Map();
+    for (const slot of slots) {
+      const el = document.createElement("span");
+      el.dataset["slot"] = slot;
+      el.className = `xe-status-${slot}`;
+      bar.appendChild(el);
+      slotEls.set(slot, el);
+    }
+    let words = 0, chars = 0, peerCount = 0, readingMinutes = 0;
+    const render = () => {
+      for (const [slot, el] of slotEls) {
+        switch (slot) {
+          case "wordCount":
+            el.textContent = `Words: ${words}`;
+            break;
+          case "charCount":
+            el.textContent = `Chars: ${chars}`;
+            break;
+          case "readingTime":
+            el.textContent = `${readingMinutes}m read`;
+            break;
+          case "peers":
+            el.textContent = peerCount > 0 ? `${peerCount} peer${peerCount === 1 ? "" : "s"}` : "Solo";
+            break;
+          case "cursorPos":
+            el.textContent = `Pos: ${ctx.selection.from}`;
+            break;
+          case "saveStatus":
+            el.textContent = "Saved";
+            break;
+        }
+      }
+    };
+    render();
+    const unsubs = [
+      ctx.on("count:update", ((payload) => {
+        const p = payload ?? {};
+        if (typeof p.words === "number") words = p.words;
+        if (typeof p.chars === "number") chars = p.chars;
+        render();
+      })),
+      ctx.on("readingTime:update", ((payload) => {
+        const p = payload ?? {};
+        if (typeof p.minutes === "number") readingMinutes = p.minutes;
+        render();
+      })),
+      ctx.on("collab:awareness", ((payload) => {
+        const p = payload ?? {};
+        if (typeof p.count === "number") peerCount = p.count;
+        render();
+      })),
+      ctx.on("collab:sync", ((payload) => {
+        const p = payload ?? {};
+        if (p.state === "disconnected") {
+          peerCount = 0;
+          render();
+        }
+      })),
+      ctx.on("selection:change", render),
+      ctx.on("auto-save:saved", () => {
+        const el = slotEls.get("saveStatus");
+        if (el) {
+          el.textContent = "Saved \u2713";
+          setTimeout(() => {
+            el.textContent = "Saved";
+          }, 1500);
+        }
+      })
+    ];
+    return {
+      destroy() {
+        for (const u of unsubs) u();
+        bar.remove();
+      }
+    };
+  }
+};
+
+// src/structure/index.ts
+function TableOfContentsAddon(config) {
+  return {
+    id: "x/toc",
+    config,
+    dependencies: ["x/headings"],
+    impl: TableOfContentsAddonImpl
+  };
+}
+var TableOfContentsAddonImpl = {
+  id: "x/toc",
+  initSchema(ctx) {
+    ctx.addNode({
+      name: "tableOfContents",
+      group: "block",
+      atom: true,
+      parseDOM: [{ tag: "nav[data-toc]" }],
+      toDOM: () => ["nav", { "data-toc": "true", class: "xe-toc" }]
+    });
+  },
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertTableOfContents",
+      label: "Table of Contents",
+      icon: "toc",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        c.insertNode("tableOfContents");
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "toggleOutlinePanel",
+      label: "Toggle Outline Panel",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function OutlineAddon() {
+  return {
+    id: "x/outline",
+    dependencies: ["x/headings"],
+    impl: OutlineAddonImpl
+  };
+}
+var OutlineAddonImpl = {
+  id: "x/outline",
+  init(_ctx) {
+    return {};
+  }
+};
+function CoverAddon(config) {
+  return { id: "x/cover", config, impl: CoverAddonImpl };
+}
+var CoverAddonImpl = {
+  id: "x/cover",
+  init(ctx) {
+    ctx.commands.register({
+      id: "setCover",
+      label: "Set Cover",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "removeCover",
+      label: "Remove Cover",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "repositionCover",
+      label: "Reposition Cover",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function BreadcrumbAddon(config) {
+  return { id: "x/breadcrumb", config, impl: BreadcrumbAddonImpl };
+}
+var BreadcrumbAddonImpl = {
+  id: "x/breadcrumb",
+  init(_ctx) {
+    return {};
+  }
+};
+function TemplatesAddon() {
+  return {
+    id: "x/templates",
+    dependencies: ["x/content"],
+    impl: TemplatesAddonImpl
+  };
+}
+var TemplatesAddonImpl = {
+  id: "x/templates",
+  init(ctx) {
+    ctx.commands.register({
+      id: "insertTemplate",
+      label: "Insert Template",
+      icon: "template",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function PageSetupAddon(config) {
+  return { id: "x/page-setup", config, impl: PageSetupAddonImpl };
+}
+var PageSetupAddonImpl = {
+  id: "x/page-setup",
+  init(ctx) {
+    ctx.commands.register({
+      id: "pageSetup",
+      label: "Page Setup",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+
+// src/export/index.ts
+function ContentAddon() {
+  return { id: "x/content", impl: ContentAddonImpl };
+}
+function downloadString(filename, content, mimeType) {
+  if (typeof document === "undefined" || typeof URL === "undefined") return;
+  const blob = new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.style.display = "none";
+  document.body.appendChild(a);
+  a.click();
+  setTimeout(() => {
+    a.remove();
+    URL.revokeObjectURL(url);
+  }, 0);
+}
+var ContentAddonImpl = {
+  id: "x/content",
+  init(ctx) {
+    ctx.commands.register({
+      id: "exportJson",
+      label: "Export as JSON",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        downloadString(
+          "document.json",
+          c.getContent("json"),
+          "application/json"
+        );
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "exportHtml",
+      label: "Export as HTML",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        downloadString("document.html", c.getContent("html"), "text/html");
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "exportMarkdown",
+      label: "Export as Markdown",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        downloadString(
+          "document.md",
+          c.getContent("markdown"),
+          "text/markdown"
+        );
+        return true;
+      }
+    });
+    ctx.commands.register({
+      id: "exportText",
+      label: "Export as Text",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: (c) => {
+        downloadString("document.txt", c.getContent("text"), "text/plain");
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function DocxAddon() {
+  return { id: "x/docx", dependencies: ["x/content"], impl: DocxAddonImpl };
+}
+var DocxAddonImpl = {
+  id: "x/docx",
+  init(ctx) {
+    ctx.commands.register({
+      id: "exportDocx",
+      label: "Export as DOCX",
+      icon: "docx",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "importDocx",
+      label: "Import DOCX",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function PdfAddon() {
+  return { id: "x/pdf", dependencies: ["x/content"], impl: PdfAddonImpl };
+}
+var PdfAddonImpl = {
+  id: "x/pdf",
+  init(ctx) {
+    ctx.commands.register({
+      id: "exportPdf",
+      label: "Export as PDF",
+      icon: "pdf",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function PrintAddon() {
+  return { id: "x/print", impl: PrintAddonImpl };
+}
+var PrintAddonImpl = {
+  id: "x/print",
+  init(ctx) {
+    ctx.commands.register({
+      id: "print",
+      label: "Print",
+      icon: "print",
+      shortcut: "Mod-p",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => {
+        window.print();
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/tools/index.ts
+function SearchAddon() {
+  return { id: "x/search", impl: SearchAddonImpl };
+}
+var SearchAddonImpl = {
+  id: "x/search",
+  init(ctx) {
+    ctx.commands.register({
+      id: "findReplace",
+      label: "Find & Replace",
+      icon: "search",
+      shortcut: "Mod-f",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "findNext",
+      label: "Find Next",
+      shortcut: "F3",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "findPrevious",
+      label: "Find Previous",
+      shortcut: "Shift-F3",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function SpellCheckAddon() {
+  return { id: "x/spell-check", impl: SpellCheckAddonImpl };
+}
+var SpellCheckAddonImpl = {
+  id: "x/spell-check",
+  init(_ctx) {
+    return {};
+  }
+};
+function GrammarAddon() {
+  return {
+    id: "x/grammar",
+    dependencies: ["x/spell-check"],
+    impl: GrammarAddonImpl
+  };
+}
+var GrammarAddonImpl = {
+  id: "x/grammar",
+  init(_ctx) {
+    return {};
+  }
+};
+function AutoSaveAddon(config) {
+  return {
+    id: "x/auto-save",
+    config,
+    dependencies: ["x/content"],
+    impl: AutoSaveAddonImpl
+  };
+}
+var AutoSaveAddonImpl = {
+  id: "x/auto-save",
+  init(ctx, config) {
+    const interval = config.interval ?? 5e3;
+    let timer = null;
+    let dirty = false;
+    const schedSave = () => {
+      dirty = true;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(async () => {
+        if (!dirty) return;
+        dirty = false;
+        const content = ctx.getContent(config.format ?? "json");
+        await config.save(content, config.format ?? "json").catch(() => {
+        });
+        ctx.emit("auto-save:saved");
+      }, interval);
+    };
+    const unsub = ctx.on("doc:change", schedSave);
+    return {
+      destroy() {
+        unsub();
+        if (timer) clearTimeout(timer);
+      }
+    };
+  }
+};
+function ReadOnlyAddon(config) {
+  return { id: "x/read-only", config, impl: ReadOnlyAddonImpl };
+}
+var ReadOnlyAddonImpl = {
+  id: "x/read-only",
+  init(ctx, config = {}) {
+    let readOnly = config.readOnly ?? false;
+    const ctxImpl = ctx;
+    if (readOnly) ctxImpl.setEditable(false);
+    ctx.commands.register({
+      id: "toggleReadOnly",
+      label: "Toggle Read Only",
+      isEnabled: () => true,
+      isActive: () => readOnly,
+      execute: () => {
+        readOnly = !readOnly;
+        ctxImpl.setEditable(!readOnly);
+        ctx.emit("read-only:change", { readOnly });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+
+// src/collab/index.ts
+function CollabAddon(config) {
+  return { id: "x/collab", config, impl: CollabAddonImpl };
+}
+var CollabAddonImpl = {
+  id: "x/collab",
+  init(ctx, _config) {
+    const binder = ctx._collabBinder;
+    if (!binder?.awareness) return {};
+    const aw = binder.awareness;
+    const emitPeerCount = () => {
+      const states = aw.getStates();
+      const others = Math.max(0, states.size - 1);
+      ctx.emit("collab:awareness", { count: others });
+    };
+    const handler = () => emitPeerCount();
+    aw.on("update", handler);
+    emitPeerCount();
+    return {
+      destroy() {
+        aw.off("update", handler);
+      }
+    };
+  }
+};
+function AwarenessAddon(config) {
+  return {
+    id: "x/awareness",
+    config,
+    dependencies: ["x/collab"],
+    impl: AwarenessAddonImpl
+  };
+}
+var AwarenessAddonImpl = {
+  id: "x/awareness",
+  init(ctx, config = {}) {
+    const binder = ctx._collabBinder;
+    const aw = binder?.awareness;
+    if (!aw) return {};
+    const palette = [
+      "#e74c3c",
+      "#3498db",
+      "#2ecc71",
+      "#f39c12",
+      "#9b59b6",
+      "#1abc9c"
+    ];
+    const identity = config.identity ?? {
+      id: typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `user-${Math.random().toString(36).slice(2, 10)}`,
+      name: "Anonymous",
+      color: palette[Math.floor(Math.random() * palette.length)]
+    };
+    aw.setLocalStateField("user", identity);
+    if (config.schemaVersion) {
+      aw.setLocalStateField("schemaVersion", config.schemaVersion);
+    }
+    return {
+      destroy() {
+        try {
+          aw.setLocalState(null);
+        } catch {
+        }
+      }
+    };
+  }
+};
+function PresenceAddon() {
+  return {
+    id: "x/presence",
+    dependencies: ["x/collab", "x/awareness"],
+    impl: PresenceAddonImpl
+  };
+}
+var PresenceAddonImpl = {
+  id: "x/presence",
+  init(_ctx) {
+    return {};
+  }
+};
+function CommentsAddon(config) {
+  return { id: "x/comments", config, impl: CommentsAddonImpl };
+}
+var CommentsAddonImpl = {
+  id: "x/comments",
+  init(ctx) {
+    ctx.commands.register({
+      id: "addComment",
+      label: "Add Comment",
+      icon: "comment",
+      shortcut: "Mod-Alt-m",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "resolveComment",
+      label: "Resolve Comment",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "toggleComments",
+      label: "Toggle Comments Panel",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function SuggestionsAddon() {
+  return {
+    id: "x/suggestions",
+    dependencies: ["x/schema", "x/commands"],
+    impl: SuggestionsAddonImpl
+  };
+}
+var SuggestionsAddonImpl = {
+  id: "x/suggestions",
+  init(ctx) {
+    ctx.commands.register({
+      id: "toggleSuggestions",
+      label: "Toggle Tracked Changes",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "acceptSuggestion",
+      label: "Accept Change",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "rejectSuggestion",
+      label: "Reject Change",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "acceptAllSuggestions",
+      label: "Accept All Changes",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "rejectAllSuggestions",
+      label: "Reject All Changes",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function VersionAddon() {
+  return {
+    id: "x/version",
+    dependencies: ["x/content"],
+    impl: VersionAddonImpl
+  };
+}
+var VersionAddonImpl = {
+  id: "x/version",
+  init(ctx) {
+    ctx.commands.register({
+      id: "createSnapshot",
+      label: "Create Snapshot",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "restoreSnapshot",
+      label: "Restore Snapshot",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "viewHistory",
+      label: "View History",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+
+// src/code/index.ts
+function CodeAddon(config) {
+  return { id: "x/code", config, impl: CodeAddonImpl };
+}
+var CodeAddonImpl = {
+  id: "x/code",
+  init(_ctx) {
+    return {};
+  }
+};
+function LineNumbersAddon() {
+  return {
+    id: "x/line-numbers",
+    dependencies: ["x/code"],
+    impl: LineNumbersAddonImpl
+  };
+}
+var LineNumbersAddonImpl = {
+  id: "x/line-numbers",
+  init(_ctx) {
+    return {};
+  }
+};
+function CodeFoldingAddon() {
+  return {
+    id: "x/code-folding",
+    dependencies: ["x/code"],
+    impl: CodeFoldingAddonImpl
+  };
+}
+var CodeFoldingAddonImpl = {
+  id: "x/code-folding",
+  init(ctx) {
+    ctx.commands.register({
+      id: "foldCode",
+      label: "Fold Code",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "unfoldCode",
+      label: "Unfold Code",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "foldAll",
+      label: "Fold All",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "unfoldAll",
+      label: "Unfold All",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function BracketMatchingAddon() {
+  return {
+    id: "x/bracket-matching",
+    dependencies: ["x/code"],
+    impl: BracketMatchingAddonImpl
+  };
+}
+var BracketMatchingAddonImpl = {
+  id: "x/bracket-matching",
+  init(_ctx) {
+    return {};
+  }
+};
+function CodeAutoCompleteAddon(config) {
+  return {
+    id: "x/code-autocomplete",
+    config,
+    dependencies: ["x/code"],
+    impl: CodeAutoCompleteAddonImpl
+  };
+}
+var CodeAutoCompleteAddonImpl = {
+  id: "x/code-autocomplete",
+  init(_ctx) {
+    return {};
+  }
+};
+function CodeLintAddon(config) {
+  return {
+    id: "x/code-lint",
+    config,
+    dependencies: ["x/code"],
+    impl: CodeLintAddonImpl
+  };
+}
+var CodeLintAddonImpl = {
+  id: "x/code-lint",
+  init(_ctx) {
+    return {};
+  }
+};
+function DiffAddon(config) {
+  return {
+    id: "x/diff",
+    config,
+    dependencies: ["x/code"],
+    impl: DiffAddonImpl
+  };
+}
+var DiffAddonImpl = {
+  id: "x/diff",
+  init(ctx) {
+    ctx.commands.register({
+      id: "toggleDiff",
+      label: "Toggle Diff",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+function MiniMapAddon() {
+  return { id: "x/minimap", dependencies: ["x/code"], impl: MiniMapAddonImpl };
+}
+var MiniMapAddonImpl = {
+  id: "x/minimap",
+  init(_ctx) {
+    return {};
+  }
+};
+
+// src/utility/index.ts
+function PlaceholderAddon(config) {
+  return { id: "x/placeholder", config, impl: PlaceholderAddonImpl };
+}
+var PlaceholderAddonImpl = {
+  id: "x/placeholder",
+  init(ctx, config) {
+    const container = ctx.getSlot("content");
+    if (!container) return {};
+    const el = document.createElement("div");
+    el.className = "xe-placeholder";
+    el.textContent = config.text;
+    el.style.pointerEvents = "none";
+    el.style.position = "absolute";
+    el.style.color = "var(--xe-fg)";
+    el.style.opacity = "0.4";
+    container.style.position = "relative";
+    container.appendChild(el);
+    const update = () => {
+      const isEmpty = ctx.getContent("text").trim() === "";
+      el.style.display = isEmpty ? "block" : "none";
+    };
+    update();
+    const unsub = ctx.on("doc:change", update);
+    return {
+      destroy() {
+        unsub();
+        el.remove();
+      }
+    };
+  }
+};
+function CountAddon(config) {
+  return { id: "x/count", config, impl: CountAddonImpl };
+}
+var CountAddonImpl = {
+  id: "x/count",
+  init(ctx, config = {}) {
+    const update = () => {
+      const text = ctx.getContent("text");
+      const words = text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+      const chars = text.length;
+      ctx.emit("count:update", { words, chars });
+    };
+    update();
+    const unsub = ctx.on("doc:change", update);
+    return { destroy: unsub };
+  }
+};
+function ReadingTimeAddon() {
+  return { id: "x/reading-time", impl: ReadingTimeAddonImpl };
+}
+var ReadingTimeAddonImpl = {
+  id: "x/reading-time",
+  init(ctx) {
+    const update = () => {
+      const text = ctx.getContent("text");
+      const words = text.trim() === "" ? 0 : text.trim().split(/\s+/).length;
+      const minutes = Math.ceil(words / 200);
+      ctx.emit("readingTime:update", { minutes, words });
+    };
+    const unsub = ctx.on("doc:change", update);
+    return { destroy: unsub };
+  }
+};
+function FocusModeAddon(config) {
+  return { id: "x/focus-mode", config, impl: FocusModeAddonImpl };
+}
+var FocusModeAddonImpl = {
+  id: "x/focus-mode",
+  init(ctx) {
+    let active = false;
+    ctx.commands.register({
+      id: "toggleFocusMode",
+      label: "Toggle Focus Mode",
+      icon: "focus",
+      isEnabled: () => true,
+      isActive: () => active,
+      execute: () => {
+        active = !active;
+        ctx.emit("focus-mode:change", { active });
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function FullScreenAddon() {
+  return { id: "x/fullscreen", impl: FullScreenAddonImpl };
+}
+var FullScreenAddonImpl = {
+  id: "x/fullscreen",
+  init(ctx) {
+    ctx.commands.register({
+      id: "toggleFullScreen",
+      label: "Toggle Full Screen",
+      icon: "fullscreen",
+      shortcut: "F11",
+      isEnabled: () => true,
+      isActive: () => !!document.fullscreenElement,
+      execute: () => {
+        if (document.fullscreenElement) {
+          document.exitFullscreen?.();
+        } else {
+          ctx.shadowRoot?.host?.requestFullscreen?.();
+        }
+        return true;
+      }
+    });
+    return {};
+  }
+};
+function AccessibilityAddon() {
+  return { id: "x/accessibility", impl: AccessibilityAddonImpl };
+}
+var AccessibilityAddonImpl = {
+  id: "x/accessibility",
+  init(ctx) {
+    const content = ctx.getSlot("content");
+    if (content) {
+      content.setAttribute("role", "textbox");
+      content.setAttribute("aria-multiline", "true");
+    }
+    const toolbar = ctx.getSlot("toolbar");
+    if (toolbar) {
+      toolbar.setAttribute("role", "toolbar");
+    }
+    return {};
+  }
+};
+function MarkdownAddon(config) {
+  return {
+    id: "x/markdown",
+    config,
+    dependencies: ["x/schema"],
+    impl: MarkdownAddonImpl
+  };
+}
+var MarkdownAddonImpl = {
+  id: "x/markdown",
+  init(ctx) {
+    ctx.commands.register({
+      id: "toggleMarkdownMode",
+      label: "Toggle Markdown Mode",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    ctx.commands.register({
+      id: "toggleMarkdownPreview",
+      label: "Toggle Markdown Preview",
+      isEnabled: () => true,
+      isActive: () => false,
+      execute: () => true
+    });
+    return {};
+  }
+};
+
+// src/index.ts
+var ADDON_IMPLEMENTATIONS = /* @__PURE__ */ new Map([
+  [SchemaAddonImpl.id, SchemaAddonImpl],
+  [CommandsAddonImpl.id, CommandsAddonImpl],
+  [KeymapAddonImpl.id, KeymapAddonImpl],
+  [HistoryAddonImpl.id, HistoryAddonImpl],
+  [InputRulesAddonImpl.id, InputRulesAddonImpl],
+  [BoldAddonImpl.id, BoldAddonImpl],
+  [ItalicAddonImpl.id, ItalicAddonImpl],
+  [UnderlineAddonImpl.id, UnderlineAddonImpl],
+  [StrikethroughAddonImpl.id, StrikethroughAddonImpl],
+  [InlineCodeAddonImpl.id, InlineCodeAddonImpl],
+  [SubscriptAddonImpl.id, SubscriptAddonImpl],
+  [SuperscriptAddonImpl.id, SuperscriptAddonImpl],
+  [HighlightAddonImpl.id, HighlightAddonImpl],
+  [TextColorAddonImpl.id, TextColorAddonImpl],
+  [FontFamilyAddonImpl.id, FontFamilyAddonImpl],
+  [FontSizeAddonImpl.id, FontSizeAddonImpl],
+  [ClearFormattingAddonImpl.id, ClearFormattingAddonImpl],
+  [AlignmentAddonImpl.id, AlignmentAddonImpl],
+  [LineHeightAddonImpl.id, LineHeightAddonImpl],
+  [ParagraphSpacingAddonImpl.id, ParagraphSpacingAddonImpl],
+  [IndentAddonImpl.id, IndentAddonImpl],
+  [HeadingsAddonImpl.id, HeadingsAddonImpl],
+  [BlockquoteAddonImpl.id, BlockquoteAddonImpl],
+  [DividerAddonImpl.id, DividerAddonImpl],
+  [PageBreakAddonImpl.id, PageBreakAddonImpl],
+  [CalloutAddonImpl.id, CalloutAddonImpl],
+  [DetailsAddonImpl.id, DetailsAddonImpl],
+  [ColumnsAddonImpl.id, ColumnsAddonImpl],
+  [CodeBlockAddonImpl.id, CodeBlockAddonImpl],
+  [BulletListAddonImpl.id, BulletListAddonImpl],
+  [OrderedListAddonImpl.id, OrderedListAddonImpl],
+  [TaskListAddonImpl.id, TaskListAddonImpl],
+  [ToggleListAddonImpl.id, ToggleListAddonImpl],
+  [TableAddonImpl.id, TableAddonImpl],
+  [ImageAddonImpl.id, ImageAddonImpl],
+  [VideoAddonImpl.id, VideoAddonImpl],
+  [AudioAddonImpl.id, AudioAddonImpl],
+  [FileAddonImpl.id, FileAddonImpl],
+  [EmbedAddonImpl.id, EmbedAddonImpl],
+  [BookmarkAddonImpl.id, BookmarkAddonImpl],
+  [LinkAddonImpl.id, LinkAddonImpl],
+  [MentionAddonImpl.id, MentionAddonImpl],
+  [EmojiAddonImpl.id, EmojiAddonImpl],
+  [EquationAddonImpl.id, EquationAddonImpl],
+  [FootnoteAddonImpl.id, FootnoteAddonImpl],
+  [SmartChipAddonImpl.id, SmartChipAddonImpl],
+  [ToolbarAddonImpl.id, ToolbarAddonImpl],
+  [BubbleMenuAddonImpl.id, BubbleMenuAddonImpl],
+  [SlashMenuAddonImpl.id, SlashMenuAddonImpl],
+  [CommandPaletteAddonImpl.id, CommandPaletteAddonImpl],
+  [BlockHandlesAddonImpl.id, BlockHandlesAddonImpl],
+  [ContextMenuAddonImpl.id, ContextMenuAddonImpl],
+  [StatusBarAddonImpl.id, StatusBarAddonImpl],
+  [TableOfContentsAddonImpl.id, TableOfContentsAddonImpl],
+  [OutlineAddonImpl.id, OutlineAddonImpl],
+  [CoverAddonImpl.id, CoverAddonImpl],
+  [BreadcrumbAddonImpl.id, BreadcrumbAddonImpl],
+  [TemplatesAddonImpl.id, TemplatesAddonImpl],
+  [PageSetupAddonImpl.id, PageSetupAddonImpl],
+  [ContentAddonImpl.id, ContentAddonImpl],
+  [DocxAddonImpl.id, DocxAddonImpl],
+  [PdfAddonImpl.id, PdfAddonImpl],
+  [PrintAddonImpl.id, PrintAddonImpl],
+  [SearchAddonImpl.id, SearchAddonImpl],
+  [SpellCheckAddonImpl.id, SpellCheckAddonImpl],
+  [GrammarAddonImpl.id, GrammarAddonImpl],
+  [AutoSaveAddonImpl.id, AutoSaveAddonImpl],
+  [ReadOnlyAddonImpl.id, ReadOnlyAddonImpl],
+  [CollabAddonImpl.id, CollabAddonImpl],
+  [AwarenessAddonImpl.id, AwarenessAddonImpl],
+  [PresenceAddonImpl.id, PresenceAddonImpl],
+  [CommentsAddonImpl.id, CommentsAddonImpl],
+  [SuggestionsAddonImpl.id, SuggestionsAddonImpl],
+  [VersionAddonImpl.id, VersionAddonImpl],
+  [CodeAddonImpl.id, CodeAddonImpl],
+  [LineNumbersAddonImpl.id, LineNumbersAddonImpl],
+  [CodeFoldingAddonImpl.id, CodeFoldingAddonImpl],
+  [BracketMatchingAddonImpl.id, BracketMatchingAddonImpl],
+  [CodeAutoCompleteAddonImpl.id, CodeAutoCompleteAddonImpl],
+  [CodeLintAddonImpl.id, CodeLintAddonImpl],
+  [DiffAddonImpl.id, DiffAddonImpl],
+  [MiniMapAddonImpl.id, MiniMapAddonImpl],
+  [PlaceholderAddonImpl.id, PlaceholderAddonImpl],
+  [CountAddonImpl.id, CountAddonImpl],
+  [ReadingTimeAddonImpl.id, ReadingTimeAddonImpl],
+  [FocusModeAddonImpl.id, FocusModeAddonImpl],
+  [FullScreenAddonImpl.id, FullScreenAddonImpl],
+  [AccessibilityAddonImpl.id, AccessibilityAddonImpl],
+  [MarkdownAddonImpl.id, MarkdownAddonImpl]
+]);
+export {
+  ADDON_IMPLEMENTATIONS,
+  AccessibilityAddon,
+  AccessibilityAddonImpl,
+  AlignmentAddon,
+  AlignmentAddonImpl,
+  AudioAddon,
+  AudioAddonImpl,
+  AutoSaveAddon,
+  AutoSaveAddonImpl,
+  AwarenessAddon,
+  AwarenessAddonImpl,
+  BlockHandlesAddon,
+  BlockHandlesAddonImpl,
+  BlockquoteAddon,
+  BlockquoteAddonImpl,
+  BoldAddon,
+  BoldAddonImpl,
+  BookmarkAddon,
+  BookmarkAddonImpl,
+  BracketMatchingAddon,
+  BracketMatchingAddonImpl,
+  BreadcrumbAddon,
+  BreadcrumbAddonImpl,
+  BubbleMenuAddon,
+  BubbleMenuAddonImpl,
+  BulletListAddon,
+  BulletListAddonImpl,
+  CalloutAddon,
+  CalloutAddonImpl,
+  ClearFormattingAddon,
+  ClearFormattingAddonImpl,
+  CodeAddon,
+  CodeAddonImpl,
+  CodeAutoCompleteAddon,
+  CodeAutoCompleteAddonImpl,
+  CodeBlockAddon,
+  CodeBlockAddonImpl,
+  CodeFoldingAddon,
+  CodeFoldingAddonImpl,
+  CodeLintAddon,
+  CodeLintAddonImpl,
+  CollabAddon,
+  CollabAddonImpl,
+  ColumnsAddon,
+  ColumnsAddonImpl,
+  CommandPaletteAddon,
+  CommandPaletteAddonImpl,
+  CommandsAddon,
+  CommandsAddonImpl,
+  CommentsAddon,
+  CommentsAddonImpl,
+  ContentAddon,
+  ContentAddonImpl,
+  ContextMenuAddon,
+  ContextMenuAddonImpl,
+  CountAddon,
+  CountAddonImpl,
+  CoverAddon,
+  CoverAddonImpl,
+  DetailsAddon,
+  DetailsAddonImpl,
+  DiffAddon,
+  DiffAddonImpl,
+  DividerAddon,
+  DividerAddonImpl,
+  DocxAddon,
+  DocxAddonImpl,
+  EmbedAddon,
+  EmbedAddonImpl,
+  EmojiAddon,
+  EmojiAddonImpl,
+  EquationAddon,
+  EquationAddonImpl,
+  FileAddon,
+  FileAddonImpl,
+  FocusModeAddon,
+  FocusModeAddonImpl,
+  FontFamilyAddon,
+  FontFamilyAddonImpl,
+  FontSizeAddon,
+  FontSizeAddonImpl,
+  FootnoteAddon,
+  FootnoteAddonImpl,
+  FullScreenAddon,
+  FullScreenAddonImpl,
+  GrammarAddon,
+  GrammarAddonImpl,
+  HeadingsAddon,
+  HeadingsAddonImpl,
+  HighlightAddon,
+  HighlightAddonImpl,
+  HistoryAddon,
+  HistoryAddonImpl,
+  ImageAddon,
+  ImageAddonImpl,
+  IndentAddon,
+  IndentAddonImpl,
+  InlineCodeAddon,
+  InlineCodeAddonImpl,
+  InputRulesAddon,
+  InputRulesAddonImpl,
+  ItalicAddon,
+  ItalicAddonImpl,
+  KeymapAddon,
+  KeymapAddonImpl,
+  LineHeightAddon,
+  LineHeightAddonImpl,
+  LineNumbersAddon,
+  LineNumbersAddonImpl,
+  LinkAddon,
+  LinkAddonImpl,
+  ListsAddon,
+  MarkdownAddon,
+  MarkdownAddonImpl,
+  MentionAddon,
+  MentionAddonImpl,
+  MiniMapAddon,
+  MiniMapAddonImpl,
+  OrderedListAddon,
+  OrderedListAddonImpl,
+  OutlineAddon,
+  OutlineAddonImpl,
+  PageBreakAddon,
+  PageBreakAddonImpl,
+  PageSetupAddon,
+  PageSetupAddonImpl,
+  ParagraphSpacingAddon,
+  ParagraphSpacingAddonImpl,
+  PdfAddon,
+  PdfAddonImpl,
+  PlaceholderAddon,
+  PlaceholderAddonImpl,
+  PresenceAddon,
+  PresenceAddonImpl,
+  PrintAddon,
+  PrintAddonImpl,
+  ReadOnlyAddon,
+  ReadOnlyAddonImpl,
+  ReadingTimeAddon,
+  ReadingTimeAddonImpl,
+  SchemaAddon,
+  SchemaAddonImpl,
+  SearchAddon,
+  SearchAddonImpl,
+  SlashMenuAddon,
+  SlashMenuAddonImpl,
+  SmartChipAddon,
+  SmartChipAddonImpl,
+  SpellCheckAddon,
+  SpellCheckAddonImpl,
+  StatusBarAddon,
+  StatusBarAddonImpl,
+  StrikethroughAddon,
+  StrikethroughAddonImpl,
+  SubscriptAddon,
+  SubscriptAddonImpl,
+  SuggestionsAddon,
+  SuggestionsAddonImpl,
+  SuperscriptAddon,
+  SuperscriptAddonImpl,
+  TableAddon,
+  TableAddonImpl,
+  TableOfContentsAddon,
+  TableOfContentsAddonImpl,
+  TaskListAddon,
+  TaskListAddonImpl,
+  TemplatesAddon,
+  TemplatesAddonImpl,
+  TextColorAddon,
+  TextColorAddonImpl,
+  ToggleListAddon,
+  ToggleListAddonImpl,
+  ToolbarAddon,
+  ToolbarAddonImpl,
+  UnderlineAddon,
+  UnderlineAddonImpl,
+  VersionAddon,
+  VersionAddonImpl,
+  VideoAddon,
+  VideoAddonImpl,
+  createCommandGroup
+};
+//# sourceMappingURL=index.mjs.map