@bendyline/squisq-editor-react 0.1.1 → 1.0.1

package/dist/index.js

@@ -1,3825 +1,35 @@
-// src/EditorShell.tsx
-import { useEffect as useEffect6 } from "react";
-
-// src/EditorContext.tsx
-import {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
-  useMemo,
-  useRef,
-  useEffect
-} from "react";
-import { parseMarkdown, stringifyMarkdown } from "@bendyline/squisq/markdown";
-import { markdownToDoc } from "@bendyline/squisq/doc";
-import { jsx } from "react/jsx-runtime";
-var EditorContext = createContext(null);
-function useEditorContext() {
-  const ctx = useContext(EditorContext);
-  if (!ctx) {
-    throw new Error("useEditorContext must be used within an <EditorProvider>");
-  }
-  return ctx;
-}
-function EditorProvider({
-  initialMarkdown = "",
-  initialView = "raw",
-  articleId = "untitled",
-  theme: initialTheme = "light",
-  children
-}) {
-  const [markdownSource, setMarkdownSourceRaw] = useState(initialMarkdown);
-  const [markdownDoc, setMarkdownDocState] = useState(null);
-  const [doc, setDoc] = useState(null);
-  const [activeView, setActiveView] = useState(initialView);
-  const [parseError, setParseError] = useState(null);
-  const [isParsing, setIsParsing] = useState(false);
-  const [theme, setTheme] = useState(initialTheme);
-  const [tiptapEditor, setTiptapEditor] = useState(null);
-  const [monacoEditor, setMonacoEditor] = useState(null);
-  const articleIdRef = useRef(articleId);
-  articleIdRef.current = articleId;
-  useEffect(() => {
-    setTheme(initialTheme);
-  }, [initialTheme]);
-  const parseTimeoutRef = useRef(null);
-  const doParse = useCallback((source) => {
-    setIsParsing(true);
-    try {
-      const parsed = parseMarkdown(source);
-      setMarkdownDocState(parsed);
-      setParseError(null);
-      try {
-        const generatedDoc = markdownToDoc(parsed, {
-          articleId: articleIdRef.current
-        });
-        setDoc(generatedDoc);
-      } catch (docErr) {
-        setDoc(null);
-        console.warn("Doc generation failed:", docErr instanceof Error ? docErr.message : docErr);
-      }
-    } catch (err) {
-      setParseError(err instanceof Error ? err.message : "Parse error");
-      setMarkdownDocState(null);
-      setDoc(null);
-    } finally {
-      setIsParsing(false);
-    }
-  }, []);
-  useEffect(() => {
-    if (parseTimeoutRef.current) {
-      clearTimeout(parseTimeoutRef.current);
-    }
-    parseTimeoutRef.current = setTimeout(() => {
-      doParse(markdownSource);
-    }, 150);
-    return () => {
-      if (parseTimeoutRef.current) {
-        clearTimeout(parseTimeoutRef.current);
-      }
-    };
-  }, [markdownSource, doParse]);
-  useEffect(() => {
-    if (initialMarkdown) {
-      doParse(initialMarkdown);
-    }
-  }, []);
-  const setMarkdownSource = useCallback((source) => {
-    setMarkdownSourceRaw(source);
-  }, []);
-  const setMarkdownDoc = useCallback((newDoc) => {
-    setMarkdownDocState(newDoc);
-    try {
-      const newSource = stringifyMarkdown(newDoc);
-      setMarkdownSourceRaw(newSource);
-      setParseError(null);
-      try {
-        const generatedDoc = markdownToDoc(newDoc, {
-          articleId: articleIdRef.current
-        });
-        setDoc(generatedDoc);
-      } catch (docErr) {
-        setDoc(null);
-        console.warn("Doc generation failed:", docErr instanceof Error ? docErr.message : docErr);
-      }
-    } catch (err) {
-      setParseError(err instanceof Error ? err.message : "Stringify error");
-    }
-  }, []);
-  const value = useMemo(
-    () => ({
-      markdownSource,
-      markdownDoc,
-      doc,
-      activeView,
-      parseError,
-      isParsing,
-      theme,
-      tiptapEditor,
-      monacoEditor,
-      setMarkdownSource,
-      setMarkdownDoc,
-      setActiveView,
-      setTiptapEditor,
-      setMonacoEditor,
-      setTheme
-    }),
-    [
-      markdownSource,
-      markdownDoc,
-      doc,
-      activeView,
-      parseError,
-      isParsing,
-      theme,
-      tiptapEditor,
-      monacoEditor,
-      setMarkdownSource,
-      setMarkdownDoc,
-      setActiveView,
-      setTiptapEditor,
-      setMonacoEditor,
-      setTheme
-    ]
-  );
-  return /* @__PURE__ */ jsx(EditorContext.Provider, { value, children });
-}
-
-// src/Toolbar.tsx
-import { useCallback as useCallback2, useEffect as useEffect2, useReducer } from "react";
-import { getAvailableTemplates } from "@bendyline/squisq/doc";
-import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
-var VIEWS = [
-  { id: "wysiwyg", label: "Editor", shortcut: "\u23181" },
-  { id: "raw", label: "Raw", shortcut: "\u23182" },
-  { id: "preview", label: "Preview", shortcut: "\u23183" }
-];
-var BUTTONS = [
-  // Format group
-  {
-    id: "bold",
-    label: "B",
-    icon: "B",
-    title: "Bold (Ctrl+B)",
-    group: "format",
-    iconStyle: { fontWeight: 700 }
-  },
-  {
-    id: "italic",
-    label: "I",
-    icon: "I",
-    title: "Italic (Ctrl+I)",
-    group: "format",
-    iconStyle: { fontStyle: "italic" }
-  },
-  {
-    id: "strikethrough",
-    label: "S",
-    icon: "S",
-    title: "Strikethrough",
-    group: "format",
-    iconStyle: { textDecoration: "line-through" }
-  },
-  { id: "code", label: "<>", icon: "`", title: "Inline code", group: "format" },
-  // Structure group
-  { id: "h1", label: "H1", icon: "H1", title: "Heading 1", group: "structure" },
-  { id: "h2", label: "H2", icon: "H2", title: "Heading 2", group: "structure" },
-  { id: "h3", label: "H3", icon: "H3", title: "Heading 3", group: "structure" },
-  { id: "quote", label: "\u275D", icon: "\u275D", title: "Blockquote", group: "structure" },
-  // Insert group
-  { id: "ul", label: "\u2022", icon: "\u2022", title: "Bullet list", group: "insert" },
-  { id: "ol", label: "1.", icon: "1.", title: "Numbered list", group: "insert" },
-  { id: "codeblock", label: "{ }", icon: "{ }", title: "Code block", group: "insert" },
-  { id: "hr", label: "\u2014", icon: "\u2014", title: "Horizontal rule", group: "insert" },
-  { id: "link", label: "\u{1F517}", icon: "\u{1F517}", title: "Insert link", group: "insert" }
-];
-function isTiptapActive(editor, id) {
-  if (!editor) return false;
-  switch (id) {
-    case "bold":
-      return editor.isActive("bold");
-    case "italic":
-      return editor.isActive("italic");
-    case "strikethrough":
-      return editor.isActive("strike");
-    case "code":
-      return editor.isActive("code");
-    case "h1":
-      return editor.isActive("heading", { level: 1 });
-    case "h2":
-      return editor.isActive("heading", { level: 2 });
-    case "h3":
-      return editor.isActive("heading", { level: 3 });
-    case "quote":
-      return editor.isActive("blockquote");
-    case "ul":
-      return editor.isActive("bulletList");
-    case "ol":
-      return editor.isActive("orderedList");
-    case "codeblock":
-      return editor.isActive("codeBlock");
-    default:
-      return false;
-  }
-}
-function Toolbar({ className }) {
-  const {
-    activeView,
-    setActiveView,
-    markdownSource,
-    setMarkdownSource,
-    tiptapEditor,
-    monacoEditor
-  } = useEditorContext();
-  const [, forceUpdate] = useReducer((c) => c + 1, 0);
-  useEffect2(() => {
-    if (!tiptapEditor) return;
-    tiptapEditor.on("transaction", forceUpdate);
-    return () => {
-      tiptapEditor.off("transaction", forceUpdate);
-    };
-  }, [tiptapEditor]);
-  const handleTiptap = useCallback2(
-    (id) => {
-      if (!tiptapEditor) return;
-      const chain = tiptapEditor.chain().focus();
-      switch (id) {
-        case "bold":
-          chain.toggleBold().run();
-          break;
-        case "italic":
-          chain.toggleItalic().run();
-          break;
-        case "strikethrough":
-          chain.toggleStrike().run();
-          break;
-        case "code":
-          chain.toggleCode().run();
-          break;
-        case "h1":
-          chain.toggleHeading({ level: 1 }).run();
-          break;
-        case "h2":
-          chain.toggleHeading({ level: 2 }).run();
-          break;
-        case "h3":
-          chain.toggleHeading({ level: 3 }).run();
-          break;
-        case "quote":
-          chain.toggleBlockquote().run();
-          break;
-        case "ul":
-          chain.toggleBulletList().run();
-          break;
-        case "ol":
-          chain.toggleOrderedList().run();
-          break;
-        case "codeblock":
-          chain.toggleCodeBlock().run();
-          break;
-        case "hr":
-          chain.setHorizontalRule().run();
-          break;
-        case "link": {
-          const url = window.prompt("URL:");
-          if (url) {
-            chain.setLink?.({ href: url }).run();
-          }
-          break;
-        }
-      }
-    },
-    [tiptapEditor]
-  );
-  const handleRaw = useCallback2(
-    (id) => {
-      if (monacoEditor) {
-        const selection = monacoEditor.getSelection();
-        const model = monacoEditor.getModel();
-        if (!selection || !model) return;
-        const selectedText = model.getValueInRange(selection);
-        const hasSelection = selectedText.length > 0;
-        let replacement = "";
-        let newCursorOffset = 0;
-        const wrapInline = (before, after, placeholder) => {
-          if (hasSelection) {
-            replacement = before + selectedText + after;
-          } else {
-            replacement = before + placeholder + after;
-            newCursorOffset = before.length;
-          }
-        };
-        const prefixLines = (prefix, placeholder) => {
-          if (hasSelection) {
-            replacement = selectedText.split("\n").map((line) => prefix + line).join("\n");
-          } else {
-            replacement = prefix + placeholder;
-            newCursorOffset = prefix.length;
-          }
-        };
-        switch (id) {
-          case "bold":
-            wrapInline("**", "**", "bold text");
-            break;
-          case "italic":
-            wrapInline("*", "*", "italic text");
-            break;
-          case "strikethrough":
-            wrapInline("~~", "~~", "strikethrough");
-            break;
-          case "code":
-            wrapInline("`", "`", "code");
-            break;
-          case "h1":
-            prefixLines("# ", "Heading 1");
-            break;
-          case "h2":
-            prefixLines("## ", "Heading 2");
-            break;
-          case "h3":
-            prefixLines("### ", "Heading 3");
-            break;
-          case "quote":
-            prefixLines("> ", "Quote");
-            break;
-          case "ul":
-            prefixLines("- ", "Item");
-            break;
-          case "ol":
-            prefixLines("1. ", "Item");
-            break;
-          case "codeblock": {
-            const inner = hasSelection ? selectedText : "code";
-            replacement = "```\n" + inner + "\n```";
-            if (!hasSelection) newCursorOffset = 4;
-            break;
-          }
-          case "hr": {
-            replacement = "\n---\n";
-            break;
-          }
-          case "link": {
-            if (hasSelection) {
-              replacement = "[" + selectedText + "](url)";
-            } else {
-              replacement = "[link text](url)";
-              newCursorOffset = 1;
-            }
-            break;
-          }
-        }
-        const range = selection;
-        monacoEditor.executeEdits("toolbar", [{ range, text: replacement }]);
-        if (!hasSelection && newCursorOffset > 0) {
-          const startPos = model.getPositionAt(
-            model.getOffsetAt(range.getStartPosition()) + newCursorOffset
-          );
-          const _placeholderLen = replacement.length - newCursorOffset - (replacement.length - replacement.lastIndexOf(replacement.charAt(replacement.length - 1)));
-          monacoEditor.setPosition(startPos);
-        }
-        monacoEditor.focus();
-      } else {
-        let insertion = "";
-        switch (id) {
-          case "bold":
-            insertion = "**bold text**";
-            break;
-          case "italic":
-            insertion = "*italic text*";
-            break;
-          case "strikethrough":
-            insertion = "~~strikethrough~~";
-            break;
-          case "code":
-            insertion = "`code`";
-            break;
-          case "h1":
-            insertion = "\n# Heading 1\n";
-            break;
-          case "h2":
-            insertion = "\n## Heading 2\n";
-            break;
-          case "h3":
-            insertion = "\n### Heading 3\n";
-            break;
-          case "quote":
-            insertion = "\n> Quote\n";
-            break;
-          case "ul":
-            insertion = "\n- Item\n";
-            break;
-          case "ol":
-            insertion = "\n1. Item\n";
-            break;
-          case "codeblock":
-            insertion = "\n```\ncode\n```\n";
-            break;
-          case "hr":
-            insertion = "\n---\n";
-            break;
-          case "link":
-            insertion = "[link text](url)";
-            break;
-        }
-        if (insertion) {
-          setMarkdownSource(markdownSource + insertion);
-        }
-      }
-    },
-    [monacoEditor, markdownSource, setMarkdownSource]
-  );
-  const handleAction = useCallback2(
-    (id) => {
-      if (activeView === "wysiwyg" && tiptapEditor) {
-        handleTiptap(id);
-      } else {
-        handleRaw(id);
-      }
-    },
-    [activeView, tiptapEditor, handleTiptap, handleRaw]
-  );
-  const groups = ["format", "structure", "insert"];
-  const isWysiwyg = activeView === "wysiwyg" && tiptapEditor;
-  const isPreview = activeView === "preview";
-  const currentTemplate = isWysiwyg ? tiptapEditor.isActive("heading") ? tiptapEditor.getAttributes("heading")?.dataTemplate ?? "" : null : null;
-  const handleTemplatePick = (value) => {
-    if (!tiptapEditor) return;
-    if (value === "") {
-      tiptapEditor.chain().focus().updateAttributes("heading", { dataTemplate: null, dataTemplateParams: null }).run();
-    } else {
-      tiptapEditor.chain().focus().updateAttributes("heading", { dataTemplate: value }).run();
-    }
-  };
-  const templateNames = getAvailableTemplates();
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: `squisq-toolbar ${className || ""}`,
-      role: "toolbar",
-      "aria-label": "Formatting toolbar",
-      children: [
-        /* @__PURE__ */ jsx2("div", { className: "squisq-toolbar-view-tabs", role: "tablist", "aria-label": "Editor view", children: VIEWS.map((view) => /* @__PURE__ */ jsx2(
-          "button",
-          {
-            role: "tab",
-            "data-view": view.id,
-            "aria-selected": activeView === view.id,
-            className: `squisq-toolbar-view-tab${activeView === view.id ? " squisq-toolbar-view-tab--active" : ""}`,
-            onClick: () => setActiveView(view.id),
-            title: `${view.label} (${view.shortcut})`,
-            children: view.label
-          },
-          view.id
-        )) }),
-        !isPreview && /* @__PURE__ */ jsx2("div", { className: "squisq-toolbar-separator" }),
-        !isPreview && groups.map((group, gi) => /* @__PURE__ */ jsxs("div", { className: "squisq-toolbar-group", children: [
-          gi > 0 && /* @__PURE__ */ jsx2("div", { className: "squisq-toolbar-separator" }),
-          BUTTONS.filter((b) => b.group === group).map((btn) => {
-            const active = isWysiwyg ? isTiptapActive(tiptapEditor, btn.id) : false;
-            return /* @__PURE__ */ jsx2(
-              "button",
-              {
-                className: `squisq-toolbar-button${active ? " squisq-toolbar-button--active" : ""}`,
-                title: btn.title,
-                onClick: () => handleAction(btn.id),
-                "aria-label": btn.title,
-                "aria-pressed": active,
-                style: btn.iconStyle,
-                children: btn.icon
-              },
-              btn.id
-            );
-          })
-        ] }, group)),
-        !isPreview && currentTemplate !== null && /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx2("div", { className: "squisq-toolbar-separator" }),
-          /* @__PURE__ */ jsx2("div", { className: "squisq-toolbar-group squisq-template-picker", children: /* @__PURE__ */ jsxs("label", { className: "squisq-template-picker-label", title: "Block template for this heading", children: [
-            "Template:",
-            /* @__PURE__ */ jsxs(
-              "select",
-              {
-                className: "squisq-template-picker-select",
-                value: currentTemplate,
-                onChange: (e) => handleTemplatePick(e.target.value),
-                children: [
-                  /* @__PURE__ */ jsx2("option", { value: "", children: "\u2014 none \u2014" }),
-                  templateNames.map((name) => /* @__PURE__ */ jsx2("option", { value: name, children: name }, name))
-                ]
-              }
-            )
-          ] }) })
-        ] })
-      ]
-    }
-  );
-}
-
-// src/StatusBar.tsx
-import { useMemo as useMemo2 } from "react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function StatusBar({ className }) {
-  const { markdownSource, doc, parseError, isParsing } = useEditorContext();
-  const stats = useMemo2(() => {
-    const chars = markdownSource.length;
-    const words = markdownSource.trim() ? markdownSource.trim().split(/\s+/).length : 0;
-    const lines = markdownSource.split("\n").length;
-    const blocks = doc?.blocks.length ?? 0;
-    return { chars, words, lines, blocks };
-  }, [markdownSource, doc]);
-  return /* @__PURE__ */ jsxs2("div", { className: `squisq-status-bar ${className || ""}`, children: [
-    /* @__PURE__ */ jsxs2("span", { className: "squisq-status-item", children: [
-      stats.words,
-      " words"
-    ] }),
-    /* @__PURE__ */ jsxs2("span", { className: "squisq-status-item", children: [
-      stats.chars,
-      " chars"
-    ] }),
-    /* @__PURE__ */ jsxs2("span", { className: "squisq-status-item", children: [
-      stats.lines,
-      " lines"
-    ] }),
-    /* @__PURE__ */ jsxs2("span", { className: "squisq-status-item", children: [
-      stats.blocks,
-      " blocks"
-    ] }),
-    /* @__PURE__ */ jsx3("span", { className: "squisq-status-spacer" }),
-    isParsing && /* @__PURE__ */ jsx3("span", { className: "squisq-status-item squisq-status-parsing", children: "Parsing\u2026" }),
-    parseError && /* @__PURE__ */ jsx3("span", { className: "squisq-status-item squisq-status-error", title: parseError, children: "\u26A0 Error" }),
-    !isParsing && !parseError && /* @__PURE__ */ jsx3("span", { className: "squisq-status-item squisq-status-ok", children: "\u2713 OK" })
-  ] });
-}
-
-// src/RawEditor.tsx
-import { useRef as useRef2, useCallback as useCallback3, useEffect as useEffect3 } from "react";
-import Editor, { loader } from "@monaco-editor/react";
-import * as monaco from "monaco-editor";
-import { getAvailableTemplates as getAvailableTemplates2 } from "@bendyline/squisq/doc";
-import { jsx as jsx4 } from "react/jsx-runtime";
-loader.config({ monaco });
-function RawEditor({
-  theme = "vs",
-  minimap = false,
-  fontSize = 14,
-  wordWrap = "on",
-  className
-}) {
-  const { markdownSource, setMarkdownSource, setMonacoEditor } = useEditorContext();
-  const editorRef = useRef2(null);
-  const isExternalUpdate = useRef2(false);
-  const completionDisposable = useRef2(null);
-  const handleMount = useCallback3(
-    (editor, monaco2) => {
-      editorRef.current = editor;
-      setMonacoEditor(editor);
-      editor.focus();
-      completionDisposable.current?.dispose();
-      const templates = getAvailableTemplates2();
-      completionDisposable.current = monaco2.languages.registerCompletionItemProvider("markdown", {
-        triggerCharacters: ["["],
-        provideCompletionItems(model, position) {
-          const lineContent = model.getLineContent(position.lineNumber);
-          if (!/^#{1,6}\s/.test(lineContent)) return { suggestions: [] };
-          const textBeforeCursor = lineContent.substring(0, position.column - 1);
-          const bracketIdx = textBeforeCursor.lastIndexOf("{[");
-          if (bracketIdx === -1) return { suggestions: [] };
-          const startCol = bracketIdx + 3;
-          const range = new monaco2.Range(
-            position.lineNumber,
-            startCol,
-            position.lineNumber,
-            position.column
-          );
-          const suggestions = templates.map((name) => ({
-            label: name,
-            kind: monaco2.languages.CompletionItemKind.Value,
-            insertText: name + "]}",
-            range,
-            detail: "Block template",
-            sortText: name
-          }));
-          return { suggestions };
-        }
-      });
-    },
-    [setMonacoEditor]
-  );
-  useEffect3(() => {
-    return () => {
-      setMonacoEditor(null);
-      completionDisposable.current?.dispose();
-      completionDisposable.current = null;
-    };
-  }, [setMonacoEditor]);
-  const handleChange = useCallback3(
-    (value) => {
-      if (isExternalUpdate.current) return;
-      if (value !== void 0) {
-        setMarkdownSource(value);
-      }
-    },
-    [setMarkdownSource]
-  );
-  useEffect3(() => {
-    const editor = editorRef.current;
-    if (editor) {
-      const currentValue = editor.getValue();
-      if (currentValue !== markdownSource) {
-        isExternalUpdate.current = true;
-        editor.setValue(markdownSource);
-        isExternalUpdate.current = false;
-      }
-    }
-  }, [markdownSource]);
-  return /* @__PURE__ */ jsx4("div", { className, style: { width: "100%", height: "100%" }, "data-testid": "raw-editor", children: /* @__PURE__ */ jsx4(
-    Editor,
-    {
-      defaultLanguage: "markdown",
-      value: markdownSource,
-      theme,
-      onMount: handleMount,
-      onChange: handleChange,
-      options: {
-        fontSize,
-        wordWrap,
-        minimap: { enabled: minimap },
-        lineNumbers: "on",
-        scrollBeyondLastLine: false,
-        automaticLayout: true,
-        tabSize: 2,
-        renderWhitespace: "selection",
-        bracketPairColorization: { enabled: true },
-        guides: { indentation: true },
-        padding: { top: 12, bottom: 12 }
-      }
-    }
-  ) });
-}
-
-// src/WysiwygEditor.tsx
-import { useEffect as useEffect4, useRef as useRef3 } from "react";
-import { useEditor, EditorContent } from "@tiptap/react";
-import StarterKit from "@tiptap/starter-kit";
-import Table from "@tiptap/extension-table";
-import TableRow from "@tiptap/extension-table-row";
-import TableCell from "@tiptap/extension-table-cell";
-import TableHeader from "@tiptap/extension-table-header";
-import TaskList from "@tiptap/extension-task-list";
-import TaskItem from "@tiptap/extension-task-item";
-import Placeholder from "@tiptap/extension-placeholder";
-
-// ../../node_modules/@tiptap/core/dist/index.js
-import { Plugin, PluginKey, TextSelection, Selection, AllSelection, NodeSelection, EditorState } from "@tiptap/pm/state";
-import { EditorView } from "@tiptap/pm/view";
-import { keymap } from "@tiptap/pm/keymap";
-import { Schema, DOMSerializer, Fragment as Fragment2, Node as Node$1, DOMParser, Slice } from "@tiptap/pm/model";
-import { liftTarget, ReplaceStep, ReplaceAroundStep, joinPoint, Transform, canSplit, canJoin, findWrapping } from "@tiptap/pm/transform";
-import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinUp as joinUp$1, joinDown as joinDown$1, joinBackward as joinBackward$1, joinForward as joinForward$1, joinTextblockBackward as joinTextblockBackward$1, joinTextblockForward as joinTextblockForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from "@tiptap/pm/commands";
-import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from "@tiptap/pm/schema-list";
-function createChainableState(config) {
-  const { state, transaction } = config;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-var CommandManager = class {
-  constructor(props) {
-    this.editor = props.editor;
-    this.rawCommands = this.editor.extensionManager.commands;
-    this.customState = props.state;
-  }
-  get hasCustomState() {
-    return !!this.customState;
-  }
-  get state() {
-    return this.customState || this.editor.state;
-  }
-  get commands() {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const { tr } = state;
-    const props = this.buildProps(tr);
-    return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      const method = (...args) => {
-        const callback = command2(...args)(props);
-        if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
-          view.dispatch(tr);
-        }
-        return callback;
-      };
-      return [name, method];
-    }));
-  }
-  get chain() {
-    return () => this.createChain();
-  }
-  get can() {
-    return () => this.createCan();
-  }
-  createChain(startTr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const callbacks = [];
-    const hasStartTransaction = !!startTr;
-    const tr = startTr || state.tr;
-    const run = () => {
-      if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
-        view.dispatch(tr);
-      }
-      return callbacks.every((callback) => callback === true);
-    };
-    const chain = {
-      ...Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-        const chainedCommand = (...args) => {
-          const props = this.buildProps(tr, shouldDispatch);
-          const callback = command2(...args)(props);
-          callbacks.push(callback);
-          return chain;
-        };
-        return [name, chainedCommand];
-      })),
-      run
-    };
-    return chain;
-  }
-  createCan(startTr) {
-    const { rawCommands, state } = this;
-    const dispatch = false;
-    const tr = startTr || state.tr;
-    const props = this.buildProps(tr, dispatch);
-    const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-    }));
-    return {
-      ...formattedCommands,
-      chain: () => this.createChain(tr, dispatch)
-    };
-  }
-  buildProps(tr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const props = {
-      tr,
-      editor,
-      view,
-      state: createChainableState({
-        state,
-        transaction: tr
-      }),
-      dispatch: shouldDispatch ? () => void 0 : void 0,
-      chain: () => this.createChain(tr, shouldDispatch),
-      can: () => this.createCan(tr),
-      get commands() {
-        return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)(props)];
-        }));
-      }
-    };
-    return props;
-  }
-};
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
-  }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
-      ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
-    });
-    return value;
-  }
-  return extension.config[field];
-}
-function splitExtensions(extensions) {
-  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
-  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
-  const markExtensions = extensions.filter((extension) => extension.type === "mark");
-  return {
-    baseExtensions,
-    nodeExtensions,
-    markExtensions
-  };
-}
-function getNodeType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.nodes[nameOrType]) {
-      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.nodes[nameOrType];
-  }
-  return nameOrType;
-}
-function mergeAttributes(...objects) {
-  return objects.filter((item) => !!item).reduce((items, item) => {
-    const mergedAttributes = { ...items };
-    Object.entries(item).forEach(([key, value]) => {
-      const exists = mergedAttributes[key];
-      if (!exists) {
-        mergedAttributes[key] = value;
-        return;
-      }
-      if (key === "class") {
-        const valueClasses = value ? String(value).split(" ") : [];
-        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
-        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
-        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
-      } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
-      } else {
-        mergedAttributes[key] = value;
-      }
-    });
-    return mergedAttributes;
-  }, {});
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function callOrReturn(value, context = void 0, ...props) {
-  if (isFunction(value)) {
-    if (context) {
-      return value.bind(context)(...props);
-    }
-    return value(...props);
-  }
-  return value;
-}
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-var InputRule = class {
-  constructor(config) {
-    this.find = config.find;
-    this.handler = config.handler;
-  }
-};
-function getType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-  if (getType(value) !== "Object") {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  if (isPlainObject(target) && isPlainObject(source)) {
-    Object.keys(source).forEach((key) => {
-      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
-        output[key] = mergeDeep(target[key], source[key]);
-      } else {
-        output[key] = source[key];
-      }
-    });
-  }
-  return output;
-}
-var Extension = class _Extension {
-  constructor(config = {}) {
-    this.type = "extension";
-    this.name = "extension";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config
-    };
-    this.name = this.config.name;
-    if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config = {}) {
-    return new _Extension(config);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new _Extension({ ...this.config, ...extendedConfig });
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-};
-function getTextBetween(startNode, range, options) {
-  const { from, to } = range;
-  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-  let text = "";
-  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
-    var _a;
-    if (node.isBlock && pos > from) {
-      text += blockSeparator;
-    }
-    const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
-    if (textSerializer) {
-      if (parent) {
-        text += textSerializer({
-          node,
-          pos,
-          parent,
-          index,
-          range
-        });
-      }
-      return false;
-    }
-    if (node.isText) {
-      text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-    }
-  });
-  return text;
-}
-function getTextSerializersFromSchema(schema) {
-  return Object.fromEntries(Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText]));
-}
-var ClipboardTextSerializer = Extension.create({
-  name: "clipboardTextSerializer",
-  addOptions() {
-    return {
-      blockSeparator: void 0
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("clipboardTextSerializer"),
-        props: {
-          clipboardTextSerializer: () => {
-            const { editor } = this;
-            const { state, schema } = editor;
-            const { doc, selection } = state;
-            const { ranges } = selection;
-            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-            const textSerializers = getTextSerializersFromSchema(schema);
-            const range = { from, to };
-            return getTextBetween(doc, range, {
-              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-              textSerializers
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var blur = () => ({ editor, view }) => {
-  requestAnimationFrame(() => {
-    var _a;
-    if (!editor.isDestroyed) {
-      view.dom.blur();
-      (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-    }
-  });
-  return true;
-};
-var clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-  return commands2.setContent("", emitUpdate);
-};
-var clearNodes = () => ({ state, tr, dispatch }) => {
-  const { selection } = tr;
-  const { ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  ranges.forEach(({ $from, $to }) => {
-    state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-      if (node.type.isText) {
-        return;
-      }
-      const { doc, mapping } = tr;
-      const $mappedFrom = doc.resolve(mapping.map(pos));
-      const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
-      const nodeRange = $mappedFrom.blockRange($mappedTo);
-      if (!nodeRange) {
-        return;
-      }
-      const targetLiftDepth = liftTarget(nodeRange);
-      if (node.type.isTextblock) {
-        const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
-        tr.setNodeMarkup(nodeRange.start, defaultType);
-      }
-      if (targetLiftDepth || targetLiftDepth === 0) {
-        tr.lift(nodeRange, targetLiftDepth);
-      }
-    });
-  });
-  return true;
-};
-var command = (fn) => (props) => {
-  return fn(props);
-};
-var createParagraphNear = () => ({ state, dispatch }) => {
-  return createParagraphNear$1(state, dispatch);
-};
-var cut = (originRange, targetPos) => ({ editor, tr }) => {
-  const { state } = editor;
-  const contentSlice = state.doc.slice(originRange.from, originRange.to);
-  tr.deleteRange(originRange.from, originRange.to);
-  const newPos = tr.mapping.map(targetPos);
-  tr.insert(newPos, contentSlice.content);
-  tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
-  return true;
-};
-var deleteCurrentNode = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const currentNode = selection.$anchor.node();
-  if (currentNode.content.size > 0) {
-    return false;
-  }
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth);
-    if (node.type === currentNode.type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth);
-    if (node.type === type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var deleteRange = (range) => ({ tr, dispatch }) => {
-  const { from, to } = range;
-  if (dispatch) {
-    tr.delete(from, to);
-  }
-  return true;
-};
-var deleteSelection = () => ({ state, dispatch }) => {
-  return deleteSelection$1(state, dispatch);
-};
-var enter = () => ({ commands: commands2 }) => {
-  return commands2.keyboardShortcut("Enter");
-};
-var exitCode = () => ({ state, dispatch }) => {
-  return exitCode$1(state, dispatch);
-};
-function objectIncludes(object1, object2, options = { strict: true }) {
-  const keys = Object.keys(object2);
-  if (!keys.length) {
-    return true;
-  }
-  return keys.every((key) => {
-    if (options.strict) {
-      return object2[key] === object1[key];
-    }
-    if (isRegExp(object2[key])) {
-      return object2[key].test(object1[key]);
-    }
-    return object2[key] === object1[key];
-  });
-}
-function findMarkInSet(marks, type, attributes = {}) {
-  return marks.find((item) => {
-    return item.type === type && objectIncludes(
-      // Only check equality for the attributes that are provided
-      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
-      attributes
-    );
-  });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-  return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes) {
-  var _a;
-  if (!$pos || !type) {
-    return;
-  }
-  let start = $pos.parent.childAfter($pos.parentOffset);
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    start = $pos.parent.childBefore($pos.parentOffset);
-  }
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    return;
-  }
-  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
-  const mark = findMarkInSet([...start.node.marks], type, attributes);
-  if (!mark) {
-    return;
-  }
-  let startIndex = start.index;
-  let startPos = $pos.start() + start.offset;
-  let endIndex = startIndex + 1;
-  let endPos = startPos + start.node.nodeSize;
-  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
-    startIndex -= 1;
-    startPos -= $pos.parent.child(startIndex).nodeSize;
-  }
-  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
-    endPos += $pos.parent.child(endIndex).nodeSize;
-    endIndex += 1;
-  }
-  return {
-    from: startPos,
-    to: endPos
-  };
-}
-function getMarkType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.marks[nameOrType]) {
-      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.marks[nameOrType];
-  }
-  return nameOrType;
-}
-var extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const type = getMarkType(typeOrName, state.schema);
-  const { doc, selection } = tr;
-  const { $from, from, to } = selection;
-  if (dispatch) {
-    const range = getMarkRange($from, type, attributes);
-    if (range && range.from <= from && range.to >= to) {
-      const newSelection = TextSelection.create(doc, range.from, range.to);
-      tr.setSelection(newSelection);
-    }
-  }
-  return true;
-};
-var first = (commands2) => (props) => {
-  const items = typeof commands2 === "function" ? commands2(props) : commands2;
-  for (let i = 0; i < items.length; i += 1) {
-    if (items[i](props)) {
-      return true;
-    }
-  }
-  return false;
-};
-function isTextSelection(value) {
-  return value instanceof TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = Selection.atStart(doc);
-  const selectionAtEnd = Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-function isSafari() {
-  return typeof navigator !== "undefined" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
-}
-var focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-  options = {
-    scrollIntoView: true,
-    ...options
-  };
-  const delayedFocus = () => {
-    if (isiOS() || isAndroid()) {
-      view.dom.focus();
-    }
-    requestAnimationFrame(() => {
-      if (!editor.isDestroyed) {
-        view.focus();
-        if (isSafari() && !isiOS() && !isAndroid()) {
-          view.dom.focus({ preventScroll: true });
-        }
-      }
-    });
-  };
-  if (view.hasFocus() && position === null || position === false) {
-    return true;
-  }
-  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-    delayedFocus();
-    return true;
-  }
-  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
-  const isSameSelection = editor.state.selection.eq(selection);
-  if (dispatch) {
-    if (!isSameSelection) {
-      tr.setSelection(selection);
-    }
-    if (isSameSelection && tr.storedMarks) {
-      tr.setStoredMarks(tr.storedMarks);
-    }
-    delayedFocus();
-  }
-  return true;
-};
-var forEach = (items, fn) => (props) => {
-  return items.every((item, index) => fn(item, { ...props, index }));
-};
-var insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-  return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-var removeWhitespaces = (node) => {
-  const children = node.childNodes;
-  for (let i = children.length - 1; i >= 0; i -= 1) {
-    const child = children[i];
-    if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-      node.removeChild(child);
-    } else if (child.nodeType === 1) {
-      removeWhitespaces(child);
-    }
-  }
-  return node;
-};
-function elementFromString(value) {
-  const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
-  return removeWhitespaces(html);
-}
-function createNodeFromContent(content, schema, options) {
-  if (content instanceof Node$1 || content instanceof Fragment2) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return Fragment2.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node.check();
-      }
-      return node;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e === "string" ? e : e.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
-      }
-      if (options.errorOnInvalidContent && hasInvalidContent) {
-        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${invalidContent}`) });
-      }
-    }
-    const parser = DOMParser.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-var isFragment = (nodeOrFragment) => {
-  return !("type" in nodeOrFragment);
-};
-var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-  var _a;
-  if (dispatch) {
-    options = {
-      parseOptions: editor.options.parseOptions,
-      updateSelection: true,
-      applyInputRules: false,
-      applyPasteRules: false,
-      ...options
-    };
-    let content;
-    const emitContentError = (error) => {
-      editor.emit("contentError", {
-        editor,
-        error,
-        disableCollaboration: () => {
-          if (editor.storage.collaboration) {
-            editor.storage.collaboration.isDisabled = true;
-          }
-        }
-      });
-    };
-    const parseOptions = {
-      preserveWhitespace: "full",
-      ...options.parseOptions
-    };
-    if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
-      try {
-        createNodeFromContent(value, editor.schema, {
-          parseOptions,
-          errorOnInvalidContent: true
-        });
-      } catch (e) {
-        emitContentError(e);
-      }
-    }
-    try {
-      content = createNodeFromContent(value, editor.schema, {
-        parseOptions,
-        errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-      });
-    } catch (e) {
-      emitContentError(e);
-      return false;
-    }
-    let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
-    let isOnlyTextContent = true;
-    let isOnlyBlockContent = true;
-    const nodes = isFragment(content) ? content : [content];
-    nodes.forEach((node) => {
-      node.check();
-      isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false;
-      isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false;
-    });
-    if (from === to && isOnlyBlockContent) {
-      const { parent } = tr.doc.resolve(from);
-      const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
-      if (isEmptyTextBlock) {
-        from -= 1;
-        to += 1;
-      }
-    }
-    let newContent;
-    if (isOnlyTextContent) {
-      if (Array.isArray(value)) {
-        newContent = value.map((v) => v.text || "").join("");
-      } else if (value instanceof Fragment2) {
-        let text = "";
-        value.forEach((node) => {
-          if (node.text) {
-            text += node.text;
-          }
-        });
-        newContent = text;
-      } else if (typeof value === "object" && !!value && !!value.text) {
-        newContent = value.text;
-      } else {
-        newContent = value;
-      }
-      tr.insertText(newContent, from, to);
-    } else {
-      newContent = content;
-      tr.replaceWith(from, to, newContent);
-    }
-    if (options.updateSelection) {
-      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    if (options.applyInputRules) {
-      tr.setMeta("applyInputRules", { from, text: newContent });
-    }
-    if (options.applyPasteRules) {
-      tr.setMeta("applyPasteRules", { from, text: newContent });
-    }
-  }
-  return true;
-};
-var joinUp = () => ({ state, dispatch }) => {
-  return joinUp$1(state, dispatch);
-};
-var joinDown = () => ({ state, dispatch }) => {
-  return joinDown$1(state, dispatch);
-};
-var joinBackward = () => ({ state, dispatch }) => {
-  return joinBackward$1(state, dispatch);
-};
-var joinForward = () => ({ state, dispatch }) => {
-  return joinForward$1(state, dispatch);
-};
-var joinItemBackward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, -1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-var joinItemForward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, 1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-var joinTextblockBackward = () => ({ state, dispatch }) => {
-  return joinTextblockBackward$1(state, dispatch);
-};
-var joinTextblockForward = () => ({ state, dispatch }) => {
-  return joinTextblockForward$1(state, dispatch);
-};
-function isMacOS() {
-  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-}
-function normalizeKeyName(name) {
-  const parts = name.split(/-(?!$)/);
-  let result = parts[parts.length - 1];
-  if (result === "Space") {
-    result = " ";
-  }
-  let alt;
-  let ctrl;
-  let shift;
-  let meta;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const mod = parts[i];
-    if (/^(cmd|meta|m)$/i.test(mod)) {
-      meta = true;
-    } else if (/^a(lt)?$/i.test(mod)) {
-      alt = true;
-    } else if (/^(c|ctrl|control)$/i.test(mod)) {
-      ctrl = true;
-    } else if (/^s(hift)?$/i.test(mod)) {
-      shift = true;
-    } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS()) {
-        meta = true;
-      } else {
-        ctrl = true;
-      }
-    } else {
-      throw new Error(`Unrecognized modifier name: ${mod}`);
-    }
-  }
-  if (alt) {
-    result = `Alt-${result}`;
-  }
-  if (ctrl) {
-    result = `Ctrl-${result}`;
-  }
-  if (meta) {
-    result = `Meta-${result}`;
-  }
-  if (shift) {
-    result = `Shift-${result}`;
-  }
-  return result;
-}
-var keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
-  const keys = normalizeKeyName(name).split(/-(?!$)/);
-  const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
-  const event = new KeyboardEvent("keydown", {
-    key: key === "Space" ? " " : key,
-    altKey: keys.includes("Alt"),
-    ctrlKey: keys.includes("Ctrl"),
-    metaKey: keys.includes("Meta"),
-    shiftKey: keys.includes("Shift"),
-    bubbles: true,
-    cancelable: true
-  });
-  const capturedTransaction = editor.captureTransaction(() => {
-    view.someProp("handleKeyDown", (f) => f(view, event));
-  });
-  capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach((step) => {
-    const newStep = step.map(tr.mapping);
-    if (newStep && dispatch) {
-      tr.maybeStep(newStep);
-    }
-  });
-  return true;
-};
-function isNodeActive(state, typeOrName, attributes = {}) {
-  const { from, to, empty } = state.selection;
-  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
-  const nodeRanges = [];
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isText) {
-      return;
-    }
-    const relativeFrom = Math.max(from, pos);
-    const relativeTo = Math.min(to, pos + node.nodeSize);
-    nodeRanges.push({
-      node,
-      from: relativeFrom,
-      to: relativeTo
-    });
-  });
-  const selectionRange = to - from;
-  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === nodeRange.node.type.name;
-  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
-  if (empty) {
-    return !!matchedNodeRanges.length;
-  }
-  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
-  return range >= selectionRange;
-}
-var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (!isActive) {
-    return false;
-  }
-  return lift$1(state, dispatch);
-};
-var liftEmptyBlock = () => ({ state, dispatch }) => {
-  return liftEmptyBlock$1(state, dispatch);
-};
-var liftListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return liftListItem$1(type)(state, dispatch);
-};
-var newlineInCode = () => ({ state, dispatch }) => {
-  return newlineInCode$1(state, dispatch);
-};
-function getSchemaTypeNameByName(name, schema) {
-  if (schema.nodes[name]) {
-    return "node";
-  }
-  if (schema.marks[name]) {
-    return "mark";
-  }
-  return null;
-}
-function deleteProps(obj, propOrProps) {
-  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
-  return Object.keys(obj).reduce((newObj, prop) => {
-    if (!props.includes(prop)) {
-      newObj[prop] = obj[prop];
-    }
-    return newObj;
-  }, {});
-}
-var resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-        if (nodeType && nodeType === node.type) {
-          tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
-        }
-        if (markType && node.marks.length) {
-          node.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-            }
-          });
-        }
-      });
-    });
-  }
-  return true;
-};
-var scrollIntoView = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    tr.scrollIntoView();
-  }
-  return true;
-};
-var selectAll = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const selection = new AllSelection(tr.doc);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var selectNodeBackward = () => ({ state, dispatch }) => {
-  return selectNodeBackward$1(state, dispatch);
-};
-var selectNodeForward = () => ({ state, dispatch }) => {
-  return selectNodeForward$1(state, dispatch);
-};
-var selectParentNode = () => ({ state, dispatch }) => {
-  return selectParentNode$1(state, dispatch);
-};
-var selectTextblockEnd = () => ({ state, dispatch }) => {
-  return selectTextblockEnd$1(state, dispatch);
-};
-var selectTextblockStart = () => ({ state, dispatch }) => {
-  return selectTextblockStart$1(state, dispatch);
-};
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-var setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands: commands2 }) => {
-  var _a, _b;
-  const { doc } = tr;
-  if (parseOptions.preserveWhitespace !== "full") {
-    const document2 = createDocument(content, editor.schema, parseOptions, {
-      errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-    });
-    if (dispatch) {
-      tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
-    }
-    return true;
-  }
-  if (dispatch) {
-    tr.setMeta("preventUpdate", !emitUpdate);
-  }
-  return commands2.insertContentAt({ from: 0, to: doc.content.size }, content, {
-    parseOptions,
-    errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck
-  });
-};
-function getMarkAttributes(state, typeOrName) {
-  const type = getMarkType(typeOrName, state.schema);
-  const { from, to, empty } = state.selection;
-  const marks = [];
-  if (empty) {
-    if (state.storedMarks) {
-      marks.push(...state.storedMarks);
-    }
-    marks.push(...state.selection.$head.marks());
-  } else {
-    state.doc.nodesBetween(from, to, (node) => {
-      marks.push(...node.marks);
-    });
-  }
-  const mark = marks.find((markItem) => markItem.type.name === type.name);
-  if (!mark) {
-    return {};
-  }
-  return { ...mark.attrs };
-}
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i += 1) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type;
-    }
-  }
-  return null;
-}
-function findParentNodeClosestToPos($pos, predicate) {
-  for (let i = $pos.depth; i > 0; i -= 1) {
-    const node = $pos.node(i);
-    if (predicate(node)) {
-      return {
-        pos: i > 0 ? $pos.before(i) : 0,
-        start: $pos.start(i),
-        depth: i,
-        node
-      };
-    }
-  }
-}
-function findParentNode(predicate) {
-  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-  return Object.fromEntries(Object.entries(attributes).filter(([name]) => {
-    const extensionAttribute = extensionAttributes.find((item) => {
-      return item.type === typeName && item.name === name;
-    });
-    if (!extensionAttribute) {
-      return false;
-    }
-    return extensionAttribute.attribute.keepOnSplit;
-  }));
-}
-function isMarkActive(state, typeOrName, attributes = {}) {
-  const { empty, ranges } = state.selection;
-  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
-  if (empty) {
-    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
-      if (!type) {
-        return true;
-      }
-      return type.name === mark.type.name;
-    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
-  }
-  let selectionRange = 0;
-  const markRanges = [];
-  ranges.forEach(({ $from, $to }) => {
-    const from = $from.pos;
-    const to = $to.pos;
-    state.doc.nodesBetween(from, to, (node, pos) => {
-      if (!node.isText && !node.marks.length) {
-        return;
-      }
-      const relativeFrom = Math.max(from, pos);
-      const relativeTo = Math.min(to, pos + node.nodeSize);
-      const range2 = relativeTo - relativeFrom;
-      selectionRange += range2;
-      markRanges.push(...node.marks.map((mark) => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo
-      })));
-    });
-  });
-  if (selectionRange === 0) {
-    return false;
-  }
-  const matchedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === markRange.mark.type.name;
-  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const excludedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
-  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
-  return range >= selectionRange;
-}
-function isList(name, extensions) {
-  const { nodeExtensions } = splitExtensions(extensions);
-  const extension = nodeExtensions.find((item) => item.name === name);
-  if (!extension) {
-    return false;
-  }
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage
-  };
-  const group = callOrReturn(getExtensionField(extension, "group", context));
-  if (typeof group !== "string") {
-    return false;
-  }
-  return group.split(" ").includes("list");
-}
-function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false } = {}) {
-  var _a;
-  if (ignoreWhitespace) {
-    if (node.type.name === "hardBreak") {
-      return true;
-    }
-    if (node.isText) {
-      return /^\s*$/m.test((_a = node.text) !== null && _a !== void 0 ? _a : "");
-    }
-  }
-  if (node.isText) {
-    return !node.text;
-  }
-  if (node.isAtom || node.isLeaf) {
-    return false;
-  }
-  if (node.content.childCount === 0) {
-    return true;
-  }
-  if (checkChildren) {
-    let isContentEmpty = true;
-    node.content.forEach((childNode) => {
-      if (isContentEmpty === false) {
-        return;
-      }
-      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
-        isContentEmpty = false;
-      }
-    });
-    return isContentEmpty;
-  }
-  return false;
-}
-function canSetMark(state, tr, newMarkType) {
-  var _a;
-  const { selection } = tr;
-  let cursor = null;
-  if (isTextSelection(selection)) {
-    cursor = selection.$cursor;
-  }
-  if (cursor) {
-    const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
-    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType));
-  }
-  const { ranges } = selection;
-  return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
-    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
-      if (someNodeSupportsMark) {
-        return false;
-      }
-      if (node.isInline) {
-        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
-        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
-      }
-      return !someNodeSupportsMark;
-    });
-    return someNodeSupportsMark;
-  });
-}
-var setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  const type = getMarkType(typeOrName, state.schema);
-  if (dispatch) {
-    if (empty) {
-      const oldAttributes = getMarkAttributes(state, type);
-      tr.addStoredMark(type.create({
-        ...oldAttributes,
-        ...attributes
-      }));
-    } else {
-      ranges.forEach((range) => {
-        const from = range.$from.pos;
-        const to = range.$to.pos;
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          const trimmedFrom = Math.max(pos, from);
-          const trimmedTo = Math.min(pos + node.nodeSize, to);
-          const someHasMark = node.marks.find((mark) => mark.type === type);
-          if (someHasMark) {
-            node.marks.forEach((mark) => {
-              if (type === mark.type) {
-                tr.addMark(trimmedFrom, trimmedTo, type.create({
-                  ...mark.attrs,
-                  ...attributes
-                }));
-              }
-            });
-          } else {
-            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
-          }
-        });
-      });
-    }
-  }
-  return canSetMark(state, tr, type);
-};
-var setMeta = (key, value) => ({ tr }) => {
-  tr.setMeta(key, value);
-  return true;
-};
-var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (!type.isTextblock) {
-    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-    return false;
-  }
-  return chain().command(({ commands: commands2 }) => {
-    const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
-    if (canSetBlock) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).command(({ state: updatedState }) => {
-    return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-  }).run();
-};
-var setNodeSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const from = minMax(position, 0, doc.content.size);
-    const selection = NodeSelection.create(doc, from);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var setTextSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-    const minPos = TextSelection.atStart(doc).from;
-    const maxPos = TextSelection.atEnd(doc).to;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return sinkListItem$1(type)(state, dispatch);
-};
-function ensureMarks(state, splittableMarks) {
-  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
-  if (marks) {
-    const filteredMarks = marks.filter((mark) => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-    state.tr.ensureMarks(filteredMarks);
-  }
-}
-var splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
-  const { selection, doc } = tr;
-  const { $from, $to } = selection;
-  const extensionAttributes = editor.extensionManager.attributes;
-  const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-  if (selection instanceof NodeSelection && selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
-      return false;
-    }
-    if (dispatch) {
-      if (keepMarks) {
-        ensureMarks(state, editor.extensionManager.splittableMarks);
-      }
-      tr.split($from.pos).scrollIntoView();
-    }
-    return true;
-  }
-  if (!$from.parent.isBlock) {
-    return false;
-  }
-  const atEnd = $to.parentOffset === $to.parent.content.size;
-  const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-  let types = atEnd && deflt ? [
-    {
-      type: deflt,
-      attrs: newAttributes
-    }
-  ] : void 0;
-  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-  if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-    can = true;
-    types = deflt ? [
-      {
-        type: deflt,
-        attrs: newAttributes
-      }
-    ] : void 0;
-  }
-  if (dispatch) {
-    if (can) {
-      if (selection instanceof TextSelection) {
-        tr.deleteSelection();
-      }
-      tr.split(tr.mapping.map($from.pos), 1, types);
-      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-        const first2 = tr.mapping.map($from.before());
-        const $first = tr.doc.resolve(first2);
-        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-        }
-      }
-    }
-    if (keepMarks) {
-      ensureMarks(state, editor.extensionManager.splittableMarks);
-    }
-    tr.scrollIntoView();
-  }
-  return can;
-};
-var splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-  var _a;
-  const type = getNodeType(typeOrName, state.schema);
-  const { $from, $to } = state.selection;
-  const node = state.selection.node;
-  if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-    return false;
-  }
-  const grandParent = $from.node(-1);
-  if (grandParent.type !== type) {
-    return false;
-  }
-  const extensionAttributes = editor.extensionManager.attributes;
-  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-    if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-      return false;
-    }
-    if (dispatch) {
-      let wrap = Fragment2.empty;
-      const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-        wrap = Fragment2.from($from.node(d).copy(wrap));
-      }
-      const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-      const newNextTypeAttributes2 = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-      wrap = wrap.append(Fragment2.from(type.createAndFill(null, nextType2) || void 0));
-      const start = $from.before($from.depth - (depthBefore - 1));
-      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
-      let sel = -1;
-      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-        if (sel > -1) {
-          return false;
-        }
-        if (n.isTextblock && n.content.size === 0) {
-          sel = pos + 1;
-        }
-      });
-      if (sel > -1) {
-        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
-      }
-      tr.scrollIntoView();
-    }
-    return true;
-  }
-  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-  const newTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-    ...overrideAttrs
-  };
-  const newNextTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-    ...overrideAttrs
-  };
-  tr.delete($from.pos, $to.pos);
-  const types = nextType ? [
-    { type, attrs: newTypeAttributes },
-    { type: nextType, attrs: newNextTypeAttributes }
-  ] : [{ type, attrs: newTypeAttributes }];
-  if (!canSplit(tr.doc, $from.pos, 2)) {
-    return false;
-  }
-  if (dispatch) {
-    const { selection, storedMarks } = state;
-    const { splittableMarks } = editor.extensionManager;
-    const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-    tr.split($from.pos, 2, types).scrollIntoView();
-    if (!marks || !dispatch) {
-      return true;
-    }
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-  }
-  return true;
-};
-var joinListBackwards = (tr, listType) => {
-  const list = findParentNode((node) => node.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-  if (before === void 0) {
-    return true;
-  }
-  const nodeBefore = tr.doc.nodeAt(before);
-  const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
-  if (!canJoinBackwards) {
-    return true;
-  }
-  tr.join(list.pos);
-  return true;
-};
-var joinListForwards = (tr, listType) => {
-  const list = findParentNode((node) => node.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const after = tr.doc.resolve(list.start).after(list.depth);
-  if (after === void 0) {
-    return true;
-  }
-  const nodeAfter = tr.doc.nodeAt(after);
-  const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
-  if (!canJoinForwards) {
-    return true;
-  }
-  tr.join(after);
-  return true;
-};
-var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands: commands2, can }) => {
-  const { extensions, splittableMarks } = editor.extensionManager;
-  const listType = getNodeType(listTypeOrName, state.schema);
-  const itemType = getNodeType(itemTypeOrName, state.schema);
-  const { selection, storedMarks } = state;
-  const { $from, $to } = selection;
-  const range = $from.blockRange($to);
-  const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-  if (!range) {
-    return false;
-  }
-  const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
-  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-    if (parentList.node.type === listType) {
-      return commands2.liftListItem(itemType);
-    }
-    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
-      return chain().command(() => {
-        tr.setNodeMarkup(parentList.pos, listType);
-        return true;
-      }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-    }
-  }
-  if (!keepMarks || !marks || !dispatch) {
-    return chain().command(() => {
-      const canWrapInList = can().wrapInList(listType, attributes);
-      if (canWrapInList) {
-        return true;
-      }
-      return commands2.clearNodes();
-    }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-  }
-  return chain().command(() => {
-    const canWrapInList = can().wrapInList(listType, attributes);
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-    if (canWrapInList) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-};
-var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-  const { extendEmptyMarkRange = false } = options;
-  const type = getMarkType(typeOrName, state.schema);
-  const isActive = isMarkActive(state, type, attributes);
-  if (isActive) {
-    return commands2.unsetMark(type, { extendEmptyMarkRange });
-  }
-  return commands2.setMark(type, attributes);
-};
-var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const toggleType = getNodeType(toggleTypeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (isActive) {
-    return commands2.setNode(toggleType, attributesToCopy);
-  }
-  return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-};
-var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (isActive) {
-    return commands2.lift(type);
-  }
-  return commands2.wrapIn(type, attributes);
-};
-var undoInputRule = () => ({ state, dispatch }) => {
-  const plugins = state.plugins;
-  for (let i = 0; i < plugins.length; i += 1) {
-    const plugin = plugins[i];
-    let undoable;
-    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-      if (dispatch) {
-        const tr = state.tr;
-        const toUndo = undoable.transform;
-        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
-        }
-        if (undoable.text) {
-          const marks = tr.doc.resolve(undoable.from).marks();
-          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
-        } else {
-          tr.delete(undoable.from, undoable.to);
-        }
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var unsetAllMarks = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  if (empty) {
-    return true;
-  }
-  if (dispatch) {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos);
-    });
-  }
-  return true;
-};
-var unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-  var _a;
-  const { extendEmptyMarkRange = false } = options;
-  const { selection } = tr;
-  const type = getMarkType(typeOrName, state.schema);
-  const { $from, empty, ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  if (empty && extendEmptyMarkRange) {
-    let { from, to } = selection;
-    const attrs = (_a = $from.marks().find((mark) => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-    const range = getMarkRange($from, type, attrs);
-    if (range) {
-      from = range.from;
-      to = range.to;
-    }
-    tr.removeMark(from, to, type);
-  } else {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos, type);
-    });
-  }
-  tr.removeStoredMark(type);
-  return true;
-};
-var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      const from = range.$from.pos;
-      const to = range.$to.pos;
-      let lastPos;
-      let lastNode;
-      let trimmedFrom;
-      let trimmedTo;
-      if (tr.selection.empty) {
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          if (nodeType && nodeType === node.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node.nodeSize, to);
-            lastPos = pos;
-            lastNode = node;
-          }
-        });
-      } else {
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          if (pos < from && nodeType && nodeType === node.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node.nodeSize, to);
-            lastPos = pos;
-            lastNode = node;
-          }
-          if (pos >= from && pos <= to) {
-            if (nodeType && nodeType === node.type) {
-              tr.setNodeMarkup(pos, void 0, {
-                ...node.attrs,
-                ...attributes
-              });
-            }
-            if (markType && node.marks.length) {
-              node.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  const trimmedFrom2 = Math.max(pos, from);
-                  const trimmedTo2 = Math.min(pos + node.nodeSize, to);
-                  tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  }));
-                }
-              });
-            }
-          }
-        });
-      }
-      if (lastNode) {
-        if (lastPos !== void 0) {
-          tr.setNodeMarkup(lastPos, void 0, {
-            ...lastNode.attrs,
-            ...attributes
-          });
-        }
-        if (markType && lastNode.marks.length) {
-          lastNode.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                ...mark.attrs,
-                ...attributes
-              }));
-            }
-          });
-        }
-      }
-    });
-  }
-  return true;
-};
-var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapIn$1(type, attributes)(state, dispatch);
-};
-var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapInList$1(type, attributes)(state, dispatch);
-};
-var commands = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  blur,
-  clearContent,
-  clearNodes,
-  command,
-  createParagraphNear,
-  cut,
-  deleteCurrentNode,
-  deleteNode,
-  deleteRange,
-  deleteSelection,
-  enter,
-  exitCode,
-  extendMarkRange,
-  first,
-  focus,
-  forEach,
-  insertContent,
-  insertContentAt,
-  joinBackward,
-  joinDown,
-  joinForward,
-  joinItemBackward,
-  joinItemForward,
-  joinTextblockBackward,
-  joinTextblockForward,
-  joinUp,
-  keyboardShortcut,
-  lift,
-  liftEmptyBlock,
-  liftListItem,
-  newlineInCode,
-  resetAttributes,
-  scrollIntoView,
-  selectAll,
-  selectNodeBackward,
-  selectNodeForward,
-  selectParentNode,
-  selectTextblockEnd,
-  selectTextblockStart,
-  setContent,
-  setMark,
-  setMeta,
-  setNode,
-  setNodeSelection,
-  setTextSelection,
-  sinkListItem,
-  splitBlock,
-  splitListItem,
-  toggleList,
-  toggleMark,
-  toggleNode,
-  toggleWrap,
-  undoInputRule,
-  unsetAllMarks,
-  unsetMark,
-  updateAttributes,
-  wrapIn,
-  wrapInList
-});
-var Commands = Extension.create({
-  name: "commands",
-  addCommands() {
-    return {
-      ...commands
-    };
-  }
-});
-var Drop = Extension.create({
-  name: "drop",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapDrop"),
-        props: {
-          handleDrop: (_, e, slice, moved) => {
-            this.editor.emit("drop", {
-              editor: this.editor,
-              event: e,
-              slice,
-              moved
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Editable = Extension.create({
-  name: "editable",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("editable"),
-        props: {
-          editable: () => this.editor.options.editable
-        }
-      })
-    ];
-  }
-});
-var focusEventsPluginKey = new PluginKey("focusEvents");
-var FocusEvents = Extension.create({
-  name: "focusEvents",
-  addProseMirrorPlugins() {
-    const { editor } = this;
-    return [
-      new Plugin({
-        key: focusEventsPluginKey,
-        props: {
-          handleDOMEvents: {
-            focus: (view, event) => {
-              editor.isFocused = true;
-              const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            },
-            blur: (view, event) => {
-              editor.isFocused = false;
-              const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            }
-          }
-        }
-      })
-    ];
-  }
-});
-var Keymap = Extension.create({
-  name: "keymap",
-  addKeyboardShortcuts() {
-    const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.undoInputRule(),
-      // maybe convert first text block node to default node
-      () => commands2.command(({ tr }) => {
-        const { selection, doc } = tr;
-        const { empty, $anchor } = selection;
-        const { pos, parent } = $anchor;
-        const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-        const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-        const parentPos = $anchor.pos - $anchor.parentOffset;
-        const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : Selection.atStart(doc).from === pos;
-        if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-          return false;
-        }
-        return commands2.clearNodes();
-      }),
-      () => commands2.deleteSelection(),
-      () => commands2.joinBackward(),
-      () => commands2.selectNodeBackward()
-    ]);
-    const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.deleteSelection(),
-      () => commands2.deleteCurrentNode(),
-      () => commands2.joinForward(),
-      () => commands2.selectNodeForward()
-    ]);
-    const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.newlineInCode(),
-      () => commands2.createParagraphNear(),
-      () => commands2.liftEmptyBlock(),
-      () => commands2.splitBlock()
-    ]);
-    const baseKeymap = {
-      Enter: handleEnter,
-      "Mod-Enter": () => this.editor.commands.exitCode(),
-      Backspace: handleBackspace,
-      "Mod-Backspace": handleBackspace,
-      "Shift-Backspace": handleBackspace,
-      Delete: handleDelete,
-      "Mod-Delete": handleDelete,
-      "Mod-a": () => this.editor.commands.selectAll()
-    };
-    const pcKeymap = {
-      ...baseKeymap
-    };
-    const macKeymap = {
-      ...baseKeymap,
-      "Ctrl-h": handleBackspace,
-      "Alt-Backspace": handleBackspace,
-      "Ctrl-d": handleDelete,
-      "Ctrl-Alt-Backspace": handleDelete,
-      "Alt-Delete": handleDelete,
-      "Alt-d": handleDelete,
-      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-    };
-    if (isiOS() || isMacOS()) {
-      return macKeymap;
-    }
-    return pcKeymap;
-  },
-  addProseMirrorPlugins() {
-    return [
-      // With this plugin we check if the whole document was selected and deleted.
-      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-      // to a paragraph if necessary.
-      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-      // with many other commands.
-      new Plugin({
-        key: new PluginKey("clearDocument"),
-        appendTransaction: (transactions, oldState, newState) => {
-          if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-            return;
-          }
-          const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-          const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-          if (!docChanges || ignoreTr) {
-            return;
-          }
-          const { empty, from, to } = oldState.selection;
-          const allFrom = Selection.atStart(oldState.doc).from;
-          const allEnd = Selection.atEnd(oldState.doc).to;
-          const allWasSelected = from === allFrom && to === allEnd;
-          if (empty || !allWasSelected) {
-            return;
-          }
-          const isEmpty = isNodeEmpty(newState.doc);
-          if (!isEmpty) {
-            return;
-          }
-          const tr = newState.tr;
-          const state = createChainableState({
-            state: newState,
-            transaction: tr
-          });
-          const { commands: commands2 } = new CommandManager({
-            editor: this.editor,
-            state
-          });
-          commands2.clearNodes();
-          if (!tr.steps.length) {
-            return;
-          }
-          return tr;
-        }
-      })
-    ];
-  }
-});
-var Paste = Extension.create({
-  name: "paste",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapPaste"),
-        props: {
-          handlePaste: (_view, e, slice) => {
-            this.editor.emit("paste", {
-              editor: this.editor,
-              event: e,
-              slice
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Tabindex = Extension.create({
-  name: "tabindex",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tabindex"),
-        props: {
-          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-        }
-      })
-    ];
-  }
-});
-function textblockTypeInputRule(config) {
-  return new InputRule({
-    find: config.find,
-    handler: ({ state, range, match }) => {
-      const $start = state.doc.resolve(range.from);
-      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
-        return null;
-      }
-      state.tr.delete(range.from, range.to).setBlockType(range.from, range.from, config.type, attributes);
-    }
-  });
-}
-var Node = class _Node {
-  constructor(config = {}) {
-    this.type = "node";
-    this.name = "node";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config
-    };
-    this.name = this.config.name;
-    if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config = {}) {
-    return new _Node(config);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new _Node(extendedConfig);
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-};
-
-// ../../node_modules/@tiptap/extension-heading/dist/index.js
-var Heading = Node.create({
-  name: "heading",
-  addOptions() {
-    return {
-      levels: [1, 2, 3, 4, 5, 6],
-      HTMLAttributes: {}
-    };
-  },
-  content: "inline*",
-  group: "block",
-  defining: true,
-  addAttributes() {
-    return {
-      level: {
-        default: 1,
-        rendered: false
-      }
-    };
-  },
-  parseHTML() {
-    return this.options.levels.map((level) => ({
-      tag: `h${level}`,
-      attrs: { level }
-    }));
-  },
-  renderHTML({ node, HTMLAttributes }) {
-    const hasLevel = this.options.levels.includes(node.attrs.level);
-    const level = hasLevel ? node.attrs.level : this.options.levels[0];
-    return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-  },
-  addCommands() {
-    return {
-      setHeading: (attributes) => ({ commands: commands2 }) => {
-        if (!this.options.levels.includes(attributes.level)) {
-          return false;
-        }
-        return commands2.setNode(this.name, attributes);
-      },
-      toggleHeading: (attributes) => ({ commands: commands2 }) => {
-        if (!this.options.levels.includes(attributes.level)) {
-          return false;
-        }
-        return commands2.toggleNode(this.name, "paragraph", attributes);
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return this.options.levels.reduce((items, level) => ({
-      ...items,
-      ...{
-        [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
-      }
-    }), {});
-  },
-  addInputRules() {
-    return this.options.levels.map((level) => {
-      return textblockTypeInputRule({
-        find: new RegExp(`^(#{${Math.min(...this.options.levels)},${level}})\\s$`),
-        type: this.type,
-        getAttributes: {
-          level
-        }
-      });
-    });
-  }
-});
-
-// src/TemplateAnnotation.ts
-var HeadingWithTemplate = Heading.extend({
-  addAttributes() {
-    return {
-      ...this.parent?.(),
-      dataTemplate: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("data-template") || null,
-        renderHTML: (attributes) => {
-          if (!attributes.dataTemplate) return {};
-          return { "data-template": attributes.dataTemplate };
-        }
-      },
-      dataTemplateParams: {
-        default: null,
-        parseHTML: (element) => element.getAttribute("data-template-params") || null,
-        renderHTML: (attributes) => {
-          if (!attributes.dataTemplateParams) return {};
-          return { "data-template-params": attributes.dataTemplateParams };
-        }
-      }
-    };
-  },
-  renderHTML({ node, HTMLAttributes }) {
-    const level = node.attrs.level;
-    const tag = `h${level}`;
-    const templateName = HTMLAttributes["data-template"];
-    if (templateName) {
-      return [
-        tag,
-        HTMLAttributes,
-        ["span", { class: "squisq-heading-content" }, 0],
-        [
-          "span",
-          {
-            class: "squisq-template-badge",
-            contenteditable: "false",
-            "data-template": templateName
-          },
-          templateName
-        ]
-      ];
-    }
-    return [tag, HTMLAttributes, 0];
-  }
-});
-
-// src/tiptapBridge.ts
-var RE_BOLD_STAR = /\*\*(.+?)\*\*/g;
-var RE_BOLD_UNDER = /__(.+?)__/g;
-var RE_ITALIC_STAR = /\*(.+?)\*/g;
-var RE_ITALIC_UNDER = /_(.+?)_/g;
-var RE_STRIKETHROUGH = /~~(.+?)~~/g;
-var RE_INLINE_CODE = /`(.+?)`/g;
-var RE_LINK = /\[(.+?)\]\((.+?)\)/g;
-var RE_IMAGE = /!\[(.+?)\]\((.+?)\)/g;
-var RE_STRONG_TAG = /<strong>(.*?)<\/strong>/g;
-var RE_B_TAG = /<b>(.*?)<\/b>/g;
-var RE_EM_TAG = /<em>(.*?)<\/em>/g;
-var RE_I_TAG = /<i>(.*?)<\/i>/g;
-var RE_S_TAG = /<s>(.*?)<\/s>/g;
-var RE_DEL_TAG = /<del>(.*?)<\/del>/g;
-var RE_CODE_TAG = /<code>(.*?)<\/code>/g;
-var RE_A_TAG = /<a[^>]+href="([^"]*)"[^>]*>(.*?)<\/a>/g;
-var RE_IMG_TAG = /<img[^>]+alt="([^"]*)"[^>]+src="([^"]*)"[^>]*>/g;
-var RE_STRIP_TAGS = /<[^>]+>/g;
-function markdownToTiptap(markdown) {
-  if (!markdown.trim()) return "<p></p>";
-  const html = markdown;
-  const lines = html.split("\n");
-  const outputBlocks = [];
-  let inCodeBlock = false;
-  let codeBlockLang = "";
-  let codeBlockLines = [];
-  let inList = false;
-  let listItems = [];
-  let listType = "ul";
-  const flushList = () => {
-    if (inList && listItems.length > 0) {
-      const tag = listType === "ol" ? "ol" : "ul";
-      const attr = listType === "task" ? ' data-type="taskList"' : "";
-      outputBlocks.push(`<${tag}${attr}>${listItems.join("")}</${tag}>`);
-      listItems = [];
-      inList = false;
-    }
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("```")) {
-      if (!inCodeBlock) {
-        flushList();
-        inCodeBlock = true;
-        codeBlockLang = line.slice(3).trim();
-        codeBlockLines = [];
-        continue;
-      } else {
-        const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
-        outputBlocks.push(
-          `<pre><code${langAttr}>${escapeHtml(codeBlockLines.join("\n"))}</code></pre>`
-        );
-        inCodeBlock = false;
-        codeBlockLang = "";
-        codeBlockLines = [];
-        continue;
-      }
-    }
-    if (inCodeBlock) {
-      codeBlockLines.push(line);
-      continue;
-    }
-    if (line.trim() === "") {
-      flushList();
-      continue;
-    }
-    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      flushList();
-      const level = headingMatch[1].length;
-      let text = headingMatch[2];
-      let attrs = "";
-      const annotMatch = text.match(/\s*\{\[([^\]]+)\]\}\s*$/);
-      if (annotMatch) {
-        text = text.slice(0, annotMatch.index).trimEnd();
-        const tokens = annotMatch[1].trim().split(/\s+/);
-        attrs = ` data-template="${escapeHtml(tokens[0])}"`;
-        const params = tokens.slice(1).filter((t) => t.includes("="));
-        if (params.length > 0) {
-          attrs += ` data-template-params="${escapeHtml(params.join(" "))}"`;
-        }
-      }
-      outputBlocks.push(`<h${level}${attrs}>${inlineToHtml(text)}</h${level}>`);
-      continue;
-    }
-    if (/^(---|\*\*\*|___)(\s*)$/.test(line.trim())) {
-      flushList();
-      outputBlocks.push("<hr>");
-      continue;
-    }
-    if (line.startsWith("> ")) {
-      flushList();
-      outputBlocks.push(`<blockquote><p>${inlineToHtml(line.slice(2))}</p></blockquote>`);
-      continue;
-    }
-    const taskMatch = line.match(/^[-*+]\s+\[([xX ])\]\s+(.+)$/);
-    if (taskMatch) {
-      if (!inList || listType !== "task") {
-        flushList();
-        inList = true;
-        listType = "task";
-      }
-      const checked = taskMatch[1].toLowerCase() === "x" ? ' data-checked="true"' : "";
-      listItems.push(
-        `<li data-type="taskItem"${checked}><label><input type="checkbox"${checked ? " checked" : ""}>${inlineToHtml(taskMatch[2])}</label></li>`
-      );
-      continue;
-    }
-    const ulMatch = line.match(/^[-*+]\s+(.+)$/);
-    if (ulMatch) {
-      if (!inList || listType !== "ul") {
-        flushList();
-        inList = true;
-        listType = "ul";
-      }
-      listItems.push(`<li><p>${inlineToHtml(ulMatch[1])}</p></li>`);
-      continue;
-    }
-    const olMatch = line.match(/^\d+\.\s+(.+)$/);
-    if (olMatch) {
-      if (!inList || listType !== "ol") {
-        flushList();
-        inList = true;
-        listType = "ol";
-      }
-      listItems.push(`<li><p>${inlineToHtml(olMatch[1])}</p></li>`);
-      continue;
-    }
-    flushList();
-    outputBlocks.push(`<p>${inlineToHtml(line)}</p>`);
-  }
-  if (inCodeBlock) {
-    const langAttr = codeBlockLang ? ` class="language-${escapeHtml(codeBlockLang)}"` : "";
-    outputBlocks.push(
-      `<pre><code${langAttr}>${escapeHtml(codeBlockLines.join("\n"))}</code></pre>`
-    );
-  }
-  flushList();
-  return outputBlocks.join("") || "<p></p>";
-}
-function tiptapToMarkdown(html) {
-  if (!html || html === "<p></p>") return "";
-  const lines = [];
-  let remaining = html;
-  while (remaining.length > 0) {
-    const headingMatch = remaining.match(/^<h([1-6])([^>]*)>(.*?)<\/h\1>/s);
-    if (headingMatch) {
-      const level = parseInt(headingMatch[1], 10);
-      const attrs = headingMatch[2];
-      let text = htmlToInline(headingMatch[3]);
-      const tmplMatch = attrs.match(/data-template="([^"]+)"/);
-      if (tmplMatch) {
-        let annotation = tmplMatch[1];
-        const paramsMatch = attrs.match(/data-template-params="([^"]+)"/);
-        if (paramsMatch) {
-          annotation += " " + unescapeHtml(paramsMatch[1]);
-        }
-        text += ` {[${annotation}]}`;
-      }
-      lines.push("#".repeat(level) + " " + text);
-      lines.push("");
-      remaining = remaining.slice(headingMatch[0].length);
-      continue;
-    }
-    const codeMatch = remaining.match(
-      /^<pre><code(?:\s+class="language-([^"]*)")?>(.*?)<\/code><\/pre>/s
-    );
-    if (codeMatch) {
-      const lang = codeMatch[1] || "";
-      const code = unescapeHtml(codeMatch[2]);
-      lines.push("```" + lang);
-      lines.push(code);
-      lines.push("```");
-      lines.push("");
-      remaining = remaining.slice(codeMatch[0].length);
-      continue;
-    }
-    const bqMatch = remaining.match(/^<blockquote>(.*?)<\/blockquote>/s);
-    if (bqMatch) {
-      const inner = htmlToInline(bqMatch[1].replace(/<\/?p>/g, ""));
-      lines.push("> " + inner);
-      lines.push("");
-      remaining = remaining.slice(bqMatch[0].length);
-      continue;
-    }
-    if (remaining.startsWith("<hr>") || remaining.startsWith("<hr/>") || remaining.startsWith("<hr />")) {
-      const hrMatch = remaining.match(/^<hr\s*\/?>/);
-      lines.push("---");
-      lines.push("");
-      remaining = remaining.slice(hrMatch[0].length);
-      continue;
-    }
-    const taskListMatch = remaining.match(/^<ul[^>]*data-type="taskList"[^>]*>(.*?)<\/ul>/s);
-    if (taskListMatch) {
-      const items = taskListMatch[1].matchAll(
-        /<li[^>]*data-type="taskItem"[^>]*(data-checked="true")?[^>]*>.*?<\/li>/gs
-      );
-      for (const item of items) {
-        const checked = item[0].includes('data-checked="true"') || item[0].includes("checked");
-        const textMatch2 = item[0].match(/<label>.*?<\/label>|<p>(.*?)<\/p>/s);
-        const text = textMatch2 ? htmlToInline(textMatch2[0].replace(/<[^>]+>/g, "")) : "";
-        lines.push(`- [${checked ? "x" : " "}] ${text}`);
-      }
-      lines.push("");
-      remaining = remaining.slice(taskListMatch[0].length);
-      continue;
-    }
-    const ulMatch = remaining.match(/^<ul>(.*?)<\/ul>/s);
-    if (ulMatch) {
-      const items = ulMatch[1].matchAll(/<li>(.*?)<\/li>/gs);
-      for (const item of items) {
-        lines.push("- " + htmlToInline(item[1].replace(/<\/?p>/g, "")));
-      }
-      lines.push("");
-      remaining = remaining.slice(ulMatch[0].length);
-      continue;
-    }
-    const olMatch = remaining.match(/^<ol[^>]*>(.*?)<\/ol>/s);
-    if (olMatch) {
-      const items = [...olMatch[1].matchAll(/<li>(.*?)<\/li>/gs)];
-      items.forEach((item, idx) => {
-        lines.push(`${idx + 1}. ` + htmlToInline(item[1].replace(/<\/?p>/g, "")));
-      });
-      lines.push("");
-      remaining = remaining.slice(olMatch[0].length);
-      continue;
-    }
-    const pMatch = remaining.match(/^<p>(.*?)<\/p>/s);
-    if (pMatch) {
-      const text = htmlToInline(pMatch[1]);
-      if (text.trim()) {
-        lines.push(text);
-        lines.push("");
-      }
-      remaining = remaining.slice(pMatch[0].length);
-      continue;
-    }
-    const skipMatch = remaining.match(/^(<[^>]+>|\s+)/);
-    if (skipMatch) {
-      remaining = remaining.slice(skipMatch[0].length);
-      continue;
-    }
-    const textMatch = remaining.match(/^([^<]+)/);
-    if (textMatch) {
-      lines.push(unescapeHtml(textMatch[1]));
-      remaining = remaining.slice(textMatch[0].length);
-      continue;
-    }
-    remaining = remaining.slice(1);
-  }
-  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
-}
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function unescapeHtml(text) {
-  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
-}
-function inlineToHtml(text) {
-  let result = escapeHtml(text);
-  result = result.replace(RE_BOLD_STAR, "<strong>$1</strong>");
-  result = result.replace(RE_BOLD_UNDER, "<strong>$1</strong>");
-  result = result.replace(RE_ITALIC_STAR, "<em>$1</em>");
-  result = result.replace(RE_ITALIC_UNDER, "<em>$1</em>");
-  result = result.replace(RE_STRIKETHROUGH, "<s>$1</s>");
-  result = result.replace(RE_INLINE_CODE, "<code>$1</code>");
-  result = result.replace(RE_LINK, '<a href="$2">$1</a>');
-  result = result.replace(RE_IMAGE, '<img alt="$1" src="$2">');
-  return result;
-}
-function htmlToInline(html) {
-  let result = html;
-  result = result.replace(RE_STRONG_TAG, "**$1**");
-  result = result.replace(RE_B_TAG, "**$1**");
-  result = result.replace(RE_EM_TAG, "*$1*");
-  result = result.replace(RE_I_TAG, "*$1*");
-  result = result.replace(RE_S_TAG, "~~$1~~");
-  result = result.replace(RE_DEL_TAG, "~~$1~~");
-  result = result.replace(RE_CODE_TAG, "`$1`");
-  result = result.replace(RE_A_TAG, "[$2]($1)");
-  result = result.replace(RE_IMG_TAG, "![$1]($2)");
-  result = result.replace(RE_STRIP_TAGS, "");
-  return unescapeHtml(result);
-}
-
-// src/WysiwygEditor.tsx
-import { useEditor as useEditor2 } from "@tiptap/react";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-function stripFrontmatter(md) {
-  const m = md.match(FRONTMATTER_RE);
-  if (!m) return { body: md, frontmatter: "" };
-  return { body: md.slice(m[0].length), frontmatter: m[0] };
-}
-function WysiwygEditor({
-  placeholder = "Start typing your markdown\u2026",
-  className
-}) {
-  const { markdownSource, setMarkdownSource, setTiptapEditor } = useEditorContext();
-  const isExternalUpdate = useRef3(false);
-  const lastSourceRef = useRef3(markdownSource);
-  const frontmatterRef = useRef3(stripFrontmatter(markdownSource).frontmatter);
-  const editor = useEditor({
-    extensions: [
-      StarterKit.configure({
-        // Disable built-in heading; we use HeadingWithTemplate instead
-        heading: false,
-        codeBlock: {
-          HTMLAttributes: { class: "squisq-code-block" }
-        }
-      }),
-      HeadingWithTemplate.configure({ levels: [1, 2, 3, 4, 5, 6] }),
-      Table.configure({ resizable: true }),
-      TableRow,
-      TableCell,
-      TableHeader,
-      TaskList,
-      TaskItem.configure({ nested: true }),
-      Placeholder.configure({ placeholder })
-    ],
-    content: markdownToTiptap(stripFrontmatter(markdownSource).body),
-    onUpdate: ({ editor: ed }) => {
-      if (isExternalUpdate.current) return;
-      const html = ed.getHTML();
-      const bodyMd = tiptapToMarkdown(html);
-      const newSource = frontmatterRef.current + bodyMd;
-      lastSourceRef.current = newSource;
-      setMarkdownSource(newSource);
-    },
-    editorProps: {
-      attributes: {
-        class: "squisq-wysiwyg-editor",
-        "data-testid": "wysiwyg-editor"
-      }
-    }
-  });
-  useEffect4(() => {
-    if (editor) {
-      setTiptapEditor(editor);
-    }
-    return () => setTiptapEditor(null);
-  }, [editor, setTiptapEditor]);
-  useEffect4(() => {
-    if (!editor) return;
-    if (markdownSource !== lastSourceRef.current) {
-      isExternalUpdate.current = true;
-      const { body, frontmatter } = stripFrontmatter(markdownSource);
-      frontmatterRef.current = frontmatter;
-      const content = markdownToTiptap(body);
-      editor.commands.setContent(content);
-      lastSourceRef.current = markdownSource;
-      isExternalUpdate.current = false;
-    }
-  }, [markdownSource, editor]);
-  return /* @__PURE__ */ jsx5(
-    "div",
-    {
-      className,
-      style: { width: "100%", height: "100%", overflow: "auto" },
-      "data-testid": "wysiwyg-container",
-      children: /* @__PURE__ */ jsx5(EditorContent, { editor, style: { height: "100%" } })
-    }
-  );
-}
-
-// src/PreviewPanel.tsx
-import { useMemo as useMemo3, useState as useState2, useEffect as useEffect5 } from "react";
-import { DocPlayer, LinearDocView } from "@bendyline/squisq-react";
-import { flattenBlocks } from "@bendyline/squisq/doc";
-import { hasTemplate } from "@bendyline/squisq/doc";
-import { extractPlainText } from "@bendyline/squisq/markdown";
-import { VIEWPORT_PRESETS } from "@bendyline/squisq/schemas";
-import { getThemeSummaries, resolveTheme } from "@bendyline/squisq/schemas";
-import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
-function extractBodyText(contents) {
-  if (!contents || contents.length === 0) return "";
-  const parts = [];
-  for (const node of contents) {
-    parts.push(extractPlainText(node));
-  }
-  return parts.join("\n").trim();
-}
-function extractListItems(contents) {
-  if (!contents) return [];
-  const items = [];
-  for (const node of contents) {
-    if (node.type === "list") {
-      for (const item of node.children) {
-        const text = extractPlainText(item).trim();
-        if (text) items.push(text);
-      }
-    }
-  }
-  return items;
-}
-function getTemplateDefaults(templateName, headingText, block) {
-  const body = extractBodyText(block.contents);
-  switch (templateName) {
-    case "statHighlight":
-      return {
-        stat: headingText,
-        description: body || headingText
-      };
-    case "quoteBlock":
-    case "fullBleedQuote":
-    case "pullQuote":
-      return {
-        quote: body || headingText
-      };
-    case "factCard":
-      return {
-        fact: headingText,
-        explanation: body || headingText
-      };
-    case "comparisonBar":
-      return {
-        leftLabel: "A",
-        leftValue: 60,
-        rightLabel: "B",
-        rightValue: 40
-      };
-    case "listBlock":
-      return {
-        items: extractListItems(block.contents) || ["Item 1", "Item 2", "Item 3"]
-      };
-    case "definitionCard":
-      return {
-        term: headingText,
-        definition: body || headingText
-      };
-    case "dateEvent":
-      return {
-        date: headingText,
-        description: body || headingText
-      };
-    default:
-      return {};
-  }
-}
-function blockToSlide(block, index) {
-  const headingText = block.sourceHeading ? extractPlainText(block.sourceHeading) : block.id || `Slide ${index + 1}`;
-  const requestedTemplate = block.template || "sectionHeader";
-  const template = hasTemplate(requestedTemplate) ? requestedTemplate : "sectionHeader";
-  const defaults = getTemplateDefaults(template, headingText, block);
-  return {
-    id: block.id,
-    template,
-    duration: block.duration,
-    audioSegment: 0,
-    transition: index > 0 ? { type: "fade", duration: 0.5 } : void 0,
-    // Provide heading text as title — consumed by sectionHeader, titleBlock, etc.
-    title: headingText,
-    // Template-specific defaults (safe fallbacks for required fields)
-    ...defaults,
-    // Spread annotation overrides last so explicit values win
-    ...block.templateOverrides
-  };
-}
-function buildPreviewDoc(doc) {
-  const flat = flattenBlocks(doc.blocks);
-  const slides = flat.map(blockToSlide);
-  let t = 0;
-  for (const slide of slides) {
-    slide.startTime = t;
-    t += slide.duration;
-  }
-  return {
-    articleId: doc.articleId,
-    duration: t,
-    blocks: slides,
-    audio: {
-      // Synthetic segment — audio will fail to load and DocPlayer will use
-      // its fallback timer to advance currentTime via requestAnimationFrame.
-      segments: t > 0 ? [{ src: "", name: "preview", duration: t, startTime: 0 }] : []
-    }
-  };
-}
-var VIEWPORT_OPTIONS = [
-  { key: "landscape", label: "16:9 Landscape" },
-  { key: "portrait", label: "9:16 Portrait" },
-  { key: "square", label: "1:1 Square" },
-  { key: "standard", label: "4:3 Standard" }
-];
-function resolveRenderAs(value) {
-  if (typeof value !== "string") return null;
-  const v = value.trim().toLowerCase();
-  const mapping = {
-    landscape: "landscape",
-    "16:9": "landscape",
-    widescreen: "landscape",
-    portrait: "portrait",
-    "9:16": "portrait",
-    vertical: "portrait",
-    stories: "portrait",
-    square: "square",
-    "1:1": "square",
-    standard: "standard",
-    "4:3": "standard"
-  };
-  return mapping[v] ?? null;
-}
-var DISPLAY_MODE_OPTIONS = [
-  { key: "video", label: "Video" },
-  { key: "slideshow", label: "Slideshow" },
-  { key: "linear", label: "Document" }
-];
-var THEME_OPTIONS = getThemeSummaries().map((s) => ({ key: s.id, label: s.name }));
-var VALID_THEME_IDS = new Set(THEME_OPTIONS.map((o) => o.key));
-function resolveFrontmatterTheme(value) {
-  if (typeof value !== "string") return null;
-  const v = value.trim().toLowerCase();
-  if (VALID_THEME_IDS.has(v)) return v;
-  const normalized = v.replace(/\s+/g, "-");
-  if (VALID_THEME_IDS.has(normalized)) return normalized;
-  return null;
-}
-function resolveDisplayMode(value) {
-  if (typeof value !== "string") return null;
-  const v = value.trim().toLowerCase();
-  if (v === "video" || v === "slideshow" || v === "linear") return v;
-  if (v === "slides" || v === "presentation" || v === "deck") return "slideshow";
-  if (v === "document" || v === "scroll" || v === "page") return "linear";
-  return null;
-}
-function PreviewPanel({ basePath = "/", className }) {
-  const { doc, parseError, isParsing } = useEditorContext();
-  const frontmatterPreset = useMemo3(() => {
-    if (!doc?.frontmatter) return null;
-    return resolveRenderAs(doc.frontmatter["document-render-as"]);
-  }, [doc?.frontmatter]);
-  const [selectedPreset, setSelectedPreset] = useState2(null);
-  useEffect5(() => {
-    setSelectedPreset(null);
-  }, [frontmatterPreset]);
-  const activePreset = selectedPreset ?? frontmatterPreset ?? "landscape";
-  const activeViewport = VIEWPORT_PRESETS[activePreset];
-  const frontmatterDisplayMode = useMemo3(() => {
-    if (!doc?.frontmatter) return null;
-    return resolveDisplayMode(doc.frontmatter["display-mode"]);
-  }, [doc?.frontmatter]);
-  const [selectedDisplayMode, setSelectedDisplayMode] = useState2(null);
-  useEffect5(() => {
-    setSelectedDisplayMode(null);
-  }, [frontmatterDisplayMode]);
-  const activeDisplayMode = selectedDisplayMode ?? frontmatterDisplayMode ?? "video";
-  const frontmatterThemeId = useMemo3(() => {
-    if (!doc?.frontmatter) return null;
-    return resolveFrontmatterTheme(doc.frontmatter["theme"]);
-  }, [doc?.frontmatter]);
-  const [selectedThemeId, setSelectedThemeId] = useState2(null);
-  useEffect5(() => {
-    setSelectedThemeId(null);
-  }, [frontmatterThemeId]);
-  const activeThemeId = selectedThemeId ?? frontmatterThemeId ?? "documentary";
-  const activeTheme = useMemo3(() => resolveTheme(activeThemeId), [activeThemeId]);
-  const previewDoc = useMemo3(() => {
-    if (!doc || !doc.blocks.length) return null;
-    return buildPreviewDoc(doc);
-  }, [doc]);
-  if (isParsing) {
-    return /* @__PURE__ */ jsx6("div", { className: `squisq-preview-status ${className || ""}`, "data-testid": "preview-panel", children: /* @__PURE__ */ jsx6("p", { children: "Parsing\u2026" }) });
-  }
-  if (parseError) {
-    return /* @__PURE__ */ jsxs3("div", { className: `squisq-preview-status ${className || ""}`, "data-testid": "preview-panel", children: [
-      /* @__PURE__ */ jsx6("h3", { children: "Parse Error" }),
-      /* @__PURE__ */ jsx6("pre", { children: parseError })
-    ] });
-  }
-  if (!previewDoc) {
-    return /* @__PURE__ */ jsx6("div", { className: `squisq-preview-status ${className || ""}`, "data-testid": "preview-panel", children: /* @__PURE__ */ jsx6("p", { children: "No content to preview. Start typing in the editor." }) });
-  }
-  return /* @__PURE__ */ jsxs3(
-    "div",
-    {
-      className: `squisq-preview-container ${className || ""}`,
-      "data-testid": "preview-panel",
-      style: {
-        width: "100%",
-        height: "100%",
-        display: "flex",
-        flexDirection: "column",
-        overflow: "hidden",
-        background: "var(--squisq-bg, #f5f5f5)"
-      },
-      children: [
-        /* @__PURE__ */ jsxs3(
-          "div",
-          {
-            className: "squisq-preview-toolbar",
-            style: {
-              display: "flex",
-              alignItems: "center",
-              gap: "8px",
-              padding: "6px 12px",
-              borderBottom: "1px solid var(--squisq-border, #e0e0e0)",
-              flexShrink: 0,
-              fontSize: "13px"
-            },
-            children: [
-              /* @__PURE__ */ jsx6("label", { htmlFor: "viewport-preset", style: { color: "var(--squisq-text-muted, #6b7280)" }, children: "Format:" }),
-              /* @__PURE__ */ jsx6(
-                "select",
-                {
-                  id: "viewport-preset",
-                  value: activePreset,
-                  onChange: (e) => setSelectedPreset(e.target.value),
-                  style: {
-                    padding: "3px 8px",
-                    borderRadius: "4px",
-                    border: "1px solid var(--squisq-border, #d1d5db)",
-                    background: "var(--squisq-input-bg, #fff)",
-                    color: "var(--squisq-text, #1f2937)",
-                    fontSize: "13px",
-                    cursor: "pointer"
-                  },
-                  children: VIEWPORT_OPTIONS.map((opt) => /* @__PURE__ */ jsx6("option", { value: opt.key, children: opt.label }, opt.key))
-                }
-              ),
-              frontmatterPreset && selectedPreset === null && /* @__PURE__ */ jsx6(
-                "span",
-                {
-                  style: {
-                    fontSize: "11px",
-                    color: "var(--squisq-text-muted, #9ca3af)",
-                    fontStyle: "italic"
-                  },
-                  children: "(from frontmatter)"
-                }
-              ),
-              /* @__PURE__ */ jsx6(
-                "span",
-                {
-                  style: {
-                    width: "1px",
-                    height: "18px",
-                    background: "var(--squisq-border, #d1d5db)",
-                    margin: "0 4px"
-                  }
-                }
-              ),
-              /* @__PURE__ */ jsx6("label", { htmlFor: "display-mode", style: { color: "var(--squisq-text-muted, #6b7280)" }, children: "Mode:" }),
-              /* @__PURE__ */ jsx6(
-                "select",
-                {
-                  id: "display-mode",
-                  value: activeDisplayMode,
-                  onChange: (e) => setSelectedDisplayMode(e.target.value),
-                  style: {
-                    padding: "3px 8px",
-                    borderRadius: "4px",
-                    border: "1px solid var(--squisq-border, #d1d5db)",
-                    background: "var(--squisq-input-bg, #fff)",
-                    color: "var(--squisq-text, #1f2937)",
-                    fontSize: "13px",
-                    cursor: "pointer"
-                  },
-                  children: DISPLAY_MODE_OPTIONS.map((opt) => /* @__PURE__ */ jsx6("option", { value: opt.key, children: opt.label }, opt.key))
-                }
-              ),
-              frontmatterDisplayMode && selectedDisplayMode === null && /* @__PURE__ */ jsx6(
-                "span",
-                {
-                  style: {
-                    fontSize: "11px",
-                    color: "var(--squisq-text-muted, #9ca3af)",
-                    fontStyle: "italic"
-                  },
-                  children: "(from frontmatter)"
-                }
-              ),
-              /* @__PURE__ */ jsx6(
-                "span",
-                {
-                  style: {
-                    width: "1px",
-                    height: "18px",
-                    background: "var(--squisq-border, #d1d5db)",
-                    margin: "0 4px"
-                  }
-                }
-              ),
-              /* @__PURE__ */ jsx6("label", { htmlFor: "theme-select", style: { color: "var(--squisq-text-muted, #6b7280)" }, children: "Theme:" }),
-              /* @__PURE__ */ jsx6(
-                "select",
-                {
-                  id: "theme-select",
-                  value: activeThemeId,
-                  onChange: (e) => setSelectedThemeId(e.target.value),
-                  style: {
-                    padding: "3px 8px",
-                    borderRadius: "4px",
-                    border: "1px solid var(--squisq-border, #d1d5db)",
-                    background: "var(--squisq-input-bg, #fff)",
-                    color: "var(--squisq-text, #1f2937)",
-                    fontSize: "13px",
-                    cursor: "pointer"
-                  },
-                  children: THEME_OPTIONS.map((opt) => /* @__PURE__ */ jsx6("option", { value: opt.key, children: opt.label }, opt.key))
-                }
-              ),
-              frontmatterThemeId && selectedThemeId === null && /* @__PURE__ */ jsx6(
-                "span",
-                {
-                  style: {
-                    fontSize: "11px",
-                    color: "var(--squisq-text-muted, #9ca3af)",
-                    fontStyle: "italic"
-                  },
-                  children: "(from frontmatter)"
-                }
-              )
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx6(
-          "div",
-          {
-            className: "squisq-preview-player",
-            style: {
-              flex: 1,
-              display: "flex",
-              alignItems: activeDisplayMode === "linear" ? "stretch" : "center",
-              justifyContent: "center",
-              overflow: "hidden",
-              minHeight: 0
-            },
-            children: activeDisplayMode === "linear" ? /* @__PURE__ */ jsx6(
-              LinearDocView,
-              {
-                doc,
-                basePath,
-                viewport: activeViewport,
-                theme: activeTheme
-              }
-            ) : /* @__PURE__ */ jsx6(
-              DocPlayer,
-              {
-                script: previewDoc,
-                basePath,
-                showControls: true,
-                muted: true,
-                forceViewport: activeViewport,
-                displayMode: activeDisplayMode,
-                theme: activeTheme
-              }
-            )
-          }
-        )
-      ]
-    }
-  );
-}
-
-// src/EditorShell.tsx
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
-function EditorShell({
-  initialMarkdown = "",
-  initialView = "wysiwyg",
-  articleId = "untitled",
-  basePath = "/",
-  onChange,
-  theme = "light",
-  className,
-  height = "100vh"
-}) {
-  return /* @__PURE__ */ jsx7(
-    EditorProvider,
-    {
-      initialMarkdown,
-      initialView,
-      articleId,
-      theme,
-      children: /* @__PURE__ */ jsx7(
-        EditorShellInner,
-        {
-          basePath,
-          onChange,
-          className,
-          height
-        }
-      )
-    }
-  );
-}
-function EditorShellInner({ basePath, onChange, className, height }) {
-  const { activeView, markdownSource, theme } = useEditorContext();
-  useEffect6(() => {
-    onChange?.(markdownSource);
-  }, [markdownSource, onChange]);
-  useEffect6(() => {
-    const handler = (e) => {
-      if (e.ctrlKey || e.metaKey) {
-        switch (e.key) {
-          case "1":
-            e.preventDefault();
-            document.querySelector('[data-view="wysiwyg"]')?.click();
-            break;
-          case "2":
-            e.preventDefault();
-            document.querySelector('[data-view="raw"]')?.click();
-            break;
-          case "3":
-            e.preventDefault();
-            document.querySelector('[data-view="preview"]')?.click();
-            break;
-        }
-      }
-    };
-    window.addEventListener("keydown", handler);
-    return () => window.removeEventListener("keydown", handler);
-  }, []);
-  return /* @__PURE__ */ jsxs4(
-    "div",
-    {
-      className: `squisq-editor-shell ${className || ""}`,
-      "data-theme": theme,
-      style: {
-        display: "flex",
-        flexDirection: "column",
-        height,
-        overflow: "hidden"
-      },
-      children: [
-        /* @__PURE__ */ jsx7("div", { className: "squisq-editor-header", children: /* @__PURE__ */ jsx7(Toolbar, {}) }),
-        /* @__PURE__ */ jsxs4(
-          "div",
-          {
-            className: "squisq-editor-content",
-            style: { flex: 1, overflow: "hidden", position: "relative" },
-            children: [
-              activeView === "raw" && /* @__PURE__ */ jsx7(RawEditor, { theme: theme === "dark" ? "vs-dark" : "vs" }),
-              activeView === "wysiwyg" && /* @__PURE__ */ jsx7(WysiwygEditor, {}),
-              activeView === "preview" && /* @__PURE__ */ jsx7(PreviewPanel, { basePath })
-            ]
-          }
-        ),
-        /* @__PURE__ */ jsx7(StatusBar, {})
-      ]
-    }
-  );
-}
-
-// src/ViewSwitcher.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
-var VIEWS2 = [
-  { id: "raw", label: "Raw", shortcut: "\u23181" },
-  { id: "wysiwyg", label: "Editor", shortcut: "\u23182" },
-  { id: "preview", label: "Preview", shortcut: "\u23183" }
-];
-function ViewSwitcher({ className }) {
-  const { activeView, setActiveView } = useEditorContext();
-  return /* @__PURE__ */ jsx8(
-    "div",
-    {
-      className: `squisq-view-switcher ${className || ""}`,
-      role: "tablist",
-      "aria-label": "Editor view",
-      children: VIEWS2.map((view) => /* @__PURE__ */ jsx8(
-        "button",
-        {
-          role: "tab",
-          "aria-selected": activeView === view.id,
-          className: `squisq-view-tab ${activeView === view.id ? "squisq-view-tab--active" : ""}`,
-          onClick: () => setActiveView(view.id),
-          title: `${view.label} (${view.shortcut})`,
-          children: view.label
-        },
-        view.id
-      ))
-    }
-  );
-}
-export {
-  EditorProvider,
-  EditorShell,
-  HeadingWithTemplate,
-  PreviewPanel,
-  RawEditor,
-  StatusBar,
-  Toolbar,
-  ViewSwitcher,
-  WysiwygEditor,
-  markdownToTiptap,
-  tiptapToMarkdown,
-  useEditorContext
-};
+/**
+ * @bendyline/squisq-editor-react
+ *
+ * React component library for editing markdown content with three views:
+ * - Raw (Monaco) — Full markdown source editing
+ * - WYSIWYG (Tiptap) — Rich text editing
+ * - Preview — Rendered block preview
+ *
+ * @example
+ * ```tsx
+ * import { EditorShell } from '@bendyline/squisq-editor-react';
+ * import '@bendyline/squisq-editor-react/styles';
+ *
+ * function App() {
+ *   return <EditorShell initialMarkdown="# Hello World" />;
+ * }
+ * ```
+ */
+// Shell (top-level component)
+export { EditorShell } from './EditorShell.js';
+// Context
+export { EditorProvider, useEditorContext } from './EditorContext.js';
+// Individual editors (for custom layouts)
+export { RawEditor } from './RawEditor.js';
+export { WysiwygEditor } from './WysiwygEditor.js';
+export { PreviewPanel } from './PreviewPanel.js';
+// Chrome (for custom layouts)
+export { ViewSwitcher } from './ViewSwitcher.js';
+export { Toolbar } from './Toolbar.js';
+export { StatusBar } from './StatusBar.js';
+// Bridge utilities
+export { markdownToTiptap, tiptapToMarkdown } from './tiptapBridge.js';
+// Tiptap extension: Heading with template annotation support
+export { HeadingWithTemplate } from './TemplateAnnotation.js';
 //# sourceMappingURL=index.js.map