@pixerate/editor 0.19.0 → 0.20.0

package/dist/chunk-CYFJCKC4.js

@@ -0,0 +1,4480 @@
+import {
+  INSTRUCTION_REGEX,
+  TEMPLATE_REGEX,
+  VARIABLE_REGEX,
+  matchConditionalTags,
+  parseVariableBody
+} from "./chunk-B2ZRLN4S.js";
+import {
+  PIXERATE_DOCUMENT_MIME,
+  getClipboardData,
+  plainTextToParagraphHtml,
+  readRichClipboard,
+  rtfToPlainText,
+  sanitizeImportedHtml,
+  serializeRichClipboardPayload
+} from "./chunk-KYRZDWM4.js";
+import {
+  CommentStore,
+  TrackChanges,
+  createReviewId,
+  htmlToPlainText,
+  markdownToTipTapHtml,
+  plainTextToSlice
+} from "./chunk-3TYMNULT.js";
+
+// src/extensions/gradient-text.ts
+import { Mark } from "@tiptap/core";
+import { Plugin } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var createGradientDecorations = (doc, options) => {
+  const decorations = [];
+  const speed = options.speed ?? 1;
+  const jsonVarSet = options.jsonVariables ? options.jsonVariables instanceof Set ? options.jsonVariables : new Set(options.jsonVariables) : null;
+  const conditionalTags = [];
+  doc.descendants((node, pos) => {
+    if (node.isText) {
+      const text = node.text || "";
+      let match;
+      const tmplRegex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+      while ((match = tmplRegex.exec(text)) !== null) {
+        const templateName = match[1].trim();
+        const colors = options.templateColorMap?.get(templateName);
+        if (colors) {
+          const start2 = pos + match.index;
+          const end = start2 + match[0].length;
+          const { from: colorFrom, to: colorTo } = colors;
+          const style = `--bg-size: ${speed * 300}%; --color-from: ${colorFrom}; --color-to: ${colorTo}; caret-color: #111 !important; background-image: linear-gradient(to right, ${colorFrom}, ${colorTo}, ${colorFrom}); -webkit-background-clip: text; background-clip: text; -webkit-text-fill-color: transparent; color: transparent;`;
+          decorations.push(
+            Decoration.inline(start2, end, {
+              class: "inline animate-gradient bg-gradient-to-r from-[var(--color-from)] via-[var(--color-to)] to-[var(--color-from)] bg-[length:var(--bg-size)_100%] bg-clip-text text-transparent border border-(--color-to)/20 px-1 py-0.5 rounded-sm cursor-pointer",
+              style,
+              "data-template": templateName
+            })
+          );
+        }
+      }
+      const instRegex = new RegExp(
+        INSTRUCTION_REGEX.source,
+        INSTRUCTION_REGEX.flags
+      );
+      while ((match = instRegex.exec(text)) !== null) {
+        const content = match[1].trim();
+        const colors = options.templateColorMap?.get(content) || {
+          from: "#ffaa40",
+          to: "#9c40ff"
+        };
+        const start2 = pos + match.index;
+        const end = start2 + match[0].length;
+        const { from: colorFrom, to: colorTo } = colors;
+        const style = `--bg-size: ${speed * 300}%; --color-from: ${colorFrom}; --color-to: ${colorTo}; caret-color: #111 !important; background-image: linear-gradient(to right, #fb7185, #8b5cf6, #fb7185); -webkit-background-clip: text; background-clip: text; -webkit-text-fill-color: transparent; color: transparent;`;
+        decorations.push(
+          Decoration.inline(start2, end, {
+            class: "italic animate-gradient bg-gradient-to-r from-rose-400 from-50% to-violet-500 to-50% bg-size-[200%_100%] bg-clip-text text-transparent inline-flex items-baseline gap-0.5",
+            style
+          })
+        );
+      }
+      const varRegex = new RegExp(
+        VARIABLE_REGEX.source,
+        VARIABLE_REGEX.flags
+      );
+      while ((match = varRegex.exec(text)) !== null) {
+        const parsed = parseVariableBody(match[1]);
+        const start2 = pos + match.index;
+        const end = start2 + match[0].length;
+        if (parsed.kind === "conditional") {
+          conditionalTags.push({
+            conditional: parsed.conditional,
+            name: parsed.name,
+            start: start2,
+            end
+          });
+          continue;
+        }
+        const variableName = parsed.name;
+        const isJsonVar = jsonVarSet?.has(variableName);
+        const attrs = {
+          class: isJsonVar ? "bg-violet-400/40 border-b-4 border-rose-300 dark:border-rose-800 inline-flex items-baseline px-1 py-0 text-foreground/80 gap-0.5 rounded-xs" : "bg-rose-400/40 border-b-4 border-violet-300 dark:border-violet-800 inline-flex items-baseline px-1 py-0 text-foreground/80 gap-0.5 rounded-xs",
+          "data-variable": variableName
+        };
+        if (parsed.defaultValue !== void 0) {
+          attrs.class += " border-dashed";
+          attrs["data-default"] = parsed.defaultValue;
+        }
+        if (parsed.description !== void 0) {
+          attrs["data-description"] = parsed.description;
+        }
+        const title = [
+          parsed.description,
+          parsed.defaultValue !== void 0 ? `Default: ${parsed.defaultValue || "(empty)"}` : void 0
+        ].filter(Boolean).join(" \xB7 ");
+        if (title) attrs.title = title;
+        decorations.push(Decoration.inline(start2, end, attrs));
+      }
+    }
+  });
+  matchConditionalTags(conditionalTags).forEach((result, i) => {
+    const tag = conditionalTags[i];
+    decorations.push(
+      Decoration.inline(
+        tag.start,
+        tag.end,
+        result.error ? {
+          class: "underline decoration-wavy decoration-red-500 text-red-600 dark:text-red-400",
+          "data-conditional-error": result.error,
+          title: result.error === "unclosed-section" ? `Section "${tag.name}" is never closed with {/${tag.name}}` : `{/${tag.name}} does not close any open section`
+        } : {
+          class: "bg-amber-400/30 text-amber-700 dark:text-amber-300 font-medium px-0.5 rounded-xs",
+          "data-conditional": tag.conditional,
+          "data-variable-condition": tag.name
+        }
+      )
+    );
+  });
+  return decorations;
+};
+var GradientText = Mark.create({
+  name: "gradientText",
+  addOptions() {
+    return {
+      templateColorMap: /* @__PURE__ */ new Map(),
+      speed: 1,
+      jsonVariables: void 0,
+      onTemplateClick: void 0
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    const defaultColors = {
+      from: "#ffaa40",
+      to: "#9c40ff"
+    };
+    const speed = this.options.speed ?? 1;
+    const style = `--bg-size: ${speed * 300}%; --color-from: ${defaultColors.from}; --color-to: ${defaultColors.to}; caret-color: #111 !important;`;
+    return [
+      "span",
+      {
+        class: "inline animate-gradient bg-gradient-to-r from-[var(--color-from)] via-[var(--color-to)] to-[var(--color-from)] bg-[length:var(--bg-size)_100%] bg-clip-text text-transparent",
+        style,
+        ...HTMLAttributes
+      },
+      0
+    ];
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        getAttrs: (node) => node.classList.contains("animate-gradient") && node.classList.contains("bg-clip-text") && null
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    const markOptions = this.options;
+    return [
+      new Plugin({
+        state: {
+          init(_, { doc }) {
+            return DecorationSet.create(
+              doc,
+              createGradientDecorations(doc, markOptions)
+            );
+          },
+          apply(tr, value) {
+            const newDoc = tr.doc;
+            if (tr.docChanged) {
+              return DecorationSet.create(
+                newDoc,
+                createGradientDecorations(newDoc, markOptions)
+              );
+            }
+            return value.map(tr.mapping, newDoc);
+          }
+        },
+        props: {
+          decorations(state) {
+            return this.getState(state);
+          },
+          handleClickOn(view, pos, _node, _nodePos, event) {
+            const decorationSet = this.getState(
+              view.state
+            );
+            const decorations = decorationSet.find(pos, pos + 1);
+            for (const decoration of decorations) {
+              const decorationWithAttrs = decoration;
+              const templateName = decorationWithAttrs.type?.attrs?.["data-template"];
+              if (templateName) {
+                if (markOptions.onTemplateClick) {
+                  markOptions.onTemplateClick(templateName, event);
+                }
+                if (typeof window !== "undefined") {
+                  window.dispatchEvent(
+                    new CustomEvent("show-gradient-popover", {
+                      detail: {
+                        templateName,
+                        target: event.target
+                      }
+                    })
+                  );
+                }
+                return true;
+              }
+            }
+            return false;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/slash-commands.ts
+import { Extension } from "@tiptap/core";
+import { Plugin as Plugin2 } from "@tiptap/pm/state";
+var SlashCommands = Extension.create({
+  name: "slashCommands",
+  addOptions() {
+    return {
+      trigger: "/",
+      onMatch: void 0,
+      onClear: void 0,
+      containerId: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const opts = this.options;
+    return [
+      new Plugin2({
+        view() {
+          return {
+            update(view) {
+              const { state } = view;
+              const { selection } = state;
+              const { $from } = selection;
+              if (!$from.parent.isTextblock) {
+                opts.onClear?.();
+                return;
+              }
+              const textBeforeCursor = $from.parent.textBetween(
+                0,
+                $from.parentOffset
+              );
+              const slashMatch = textBeforeCursor.match(
+                /(?:^|\s)\/([a-zA-Z0-9_-]*)$/
+              );
+              if (slashMatch) {
+                const matchIndex = slashMatch.index ?? 0;
+                const offsetInParent = matchIndex + (slashMatch[0].startsWith(" ") ? 1 : 0);
+                const matchFrom = $from.start() + offsetInParent;
+                const matchTo = $from.pos;
+                const coords = view.coordsAtPos($from.pos);
+                let relativeCoords = {
+                  top: coords.top,
+                  left: coords.left,
+                  bottom: coords.bottom,
+                  right: coords.right
+                };
+                if (opts.containerId && typeof document !== "undefined") {
+                  const container = document.getElementById(opts.containerId);
+                  if (container) {
+                    const rect = container.getBoundingClientRect();
+                    relativeCoords = {
+                      top: coords.bottom - rect.top + 5,
+                      left: coords.left - rect.left,
+                      bottom: coords.bottom - rect.top,
+                      right: coords.right - rect.left
+                    };
+                  }
+                }
+                opts.onMatch?.({
+                  match: slashMatch,
+                  query: slashMatch[1] || "",
+                  from: matchFrom,
+                  to: matchTo,
+                  coords: relativeCoords
+                });
+              } else {
+                opts.onClear?.();
+              }
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/template-suggestions.ts
+import { Extension as Extension2 } from "@tiptap/core";
+import Suggestion from "@tiptap/suggestion";
+var TemplateSuggestions = Extension2.create({
+  name: "templateSuggestions",
+  addOptions() {
+    return {
+      templates: [],
+      char: "{{",
+      onSuggestion: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const opts = this.options;
+    const suggestionConfig = {
+      char: opts.char || "{{",
+      items: ({ query }) => {
+        const lower = query.toLowerCase();
+        return (opts.templates || []).filter(
+          (t) => t.name.toLowerCase().includes(lower)
+        );
+      },
+      command: ({ editor, range, props }) => {
+        editor.chain().focus().deleteRange(range).insertContent(`{{${props.name}}}`).run();
+      },
+      render: () => {
+        return {
+          onStart: (props) => {
+            opts.onSuggestion?.(props);
+          },
+          onUpdate: (props) => {
+            opts.onSuggestion?.(props);
+          },
+          onExit: () => {
+            opts.onSuggestion?.({
+              query: "",
+              range: { from: 0, to: 0 },
+              items: [],
+              command: () => {
+              }
+            });
+          }
+        };
+      }
+    };
+    const SuggestionFn = typeof Suggestion === "function" ? Suggestion : Suggestion?.default || Suggestion?.Suggestion;
+    return [
+      SuggestionFn({
+        editor: this.editor,
+        ...suggestionConfig
+      })
+    ];
+  }
+});
+
+// src/extensions/loading-node.ts
+import { Node as Node2, mergeAttributes } from "@tiptap/core";
+var LoadingNode = Node2.create({
+  name: "loadingNode",
+  group: "inline",
+  inline: true,
+  selectable: true,
+  atom: true,
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-id"),
+        renderHTML: (attributes) => {
+          if (!attributes.id) return {};
+          return { "data-id": attributes.id };
+        }
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-type="loading"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-type": "loading",
+        class: "inline-flex items-center px-1.5 py-0.5 text-xs text-muted-foreground animate-pulse"
+      }),
+      "\u23F3"
+    ];
+  }
+});
+
+// src/extensions/SmilieReplacer.ts
+import { Extension as Extension3, textInputRule } from "@tiptap/core";
+var SMILIE_REPLACEMENTS = [
+  [/-___- $/, "\u{1F611} "],
+  [/:'-\) $/, "\u{1F602} "],
+  [/':-\) $/, "\u{1F605} "],
+  [/':-D $/, "\u{1F605} "],
+  [/>:-\) $/, "\u{1F606} "],
+  [/-__- $/, "\u{1F611} "],
+  [/':-\( $/, "\u{1F613} "],
+  [/:'-\( $/, "\u{1F622} "],
+  [/>:-\( $/, "\u{1F620} "],
+  [/O:-\) $/, "\u{1F607} "],
+  [/:'\) $/, "\u{1F602} "],
+  [/:-D $/, "\u{1F603} "],
+  [/':\) $/, "\u{1F605} "],
+  [/;-\) $/, "\u{1F609} "],
+  [/B-\) $/, "\u{1F60E} "],
+  [/:-\* $/, "\u{1F618} "],
+  [/:-\) $/, "\u{1F642} "],
+  [/-_- $/, "\u{1F611} "],
+  [/:-O $/, "\u{1F62E} "],
+  [/:-P $/, "\u{1F61B} "],
+  [/:-p $/, "\u{1F61B} "],
+  [/:-\/ $/, "\u{1F615} "],
+  [/:-\( $/, "\u{1F61E} "],
+  [/:'\( $/, "\u{1F622} "],
+  [/:D $/, "\u{1F603} "],
+  [/=D $/, "\u{1F603} "],
+  [/;\) $/, "\u{1F609} "],
+  [/B\) $/, "\u{1F60E} "],
+  [/:\) $/, "\u{1F642} "],
+  [/=\) $/, "\u{1F642} "],
+  [/:O $/, "\u{1F62E} "],
+  [/:P $/, "\u{1F61B} "],
+  [/:p $/, "\u{1F61B} "],
+  [/:\/ $/, "\u{1F615} "],
+  [/:\( $/, "\u{1F61E} "],
+  [/<3 $/, "\u2764\uFE0F "],
+  [/<\/3 $/, "\u{1F494} "],
+  [/\/shrug $/, "\xAF\\_(\u30C4)_/\xAF "]
+];
+var smilieAutocorrectRules = SMILIE_REPLACEMENTS.map(
+  ([find, replace], index) => ({
+    id: `smilie:${index}`,
+    find: new RegExp(find.source.replace(/'/g, "['\u2018\u2019]"), find.flags),
+    replace
+  })
+);
+var SmilieReplacer = Extension3.create({
+  name: "smilieReplacer",
+  addInputRules() {
+    return SMILIE_REPLACEMENTS.map(
+      ([find, replace]) => textInputRule({ find, replace })
+    );
+  }
+});
+
+// src/extensions/ColorHighlighter.ts
+import { Extension as Extension4 } from "@tiptap/core";
+import { Plugin as Plugin3 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+function findHexColors(doc) {
+  const hexColorRegex = /(#[0-9a-fA-F]{3,8})\b/g;
+  const decorations = [];
+  doc.descendants((node, position) => {
+    if (!node.text) return;
+    let match;
+    while ((match = hexColorRegex.exec(node.text)) !== null) {
+      const color = match[0];
+      const from = position + match.index;
+      const to = from + color.length;
+      decorations.push(
+        Decoration2.inline(from, to, {
+          class: "color-highlight px-1 py-0.5 rounded text-xs font-mono border",
+          style: `--color: ${color}; background-color: ${color}20; border-color: ${color}; color: ${color};`
+        })
+      );
+    }
+  });
+  return DecorationSet2.create(doc, decorations);
+}
+var ColorHighlighter = Extension4.create({
+  name: "colorHighlighter",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin3({
+        state: {
+          init(_, { doc }) {
+            return findHexColors(doc);
+          },
+          apply(transaction, oldState) {
+            return transaction.docChanged ? findHexColors(transaction.doc) : oldState;
+          }
+        },
+        props: {
+          decorations(state) {
+            return this.getState(state);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/FontSize.ts
+import { Extension as Extension5 } from "@tiptap/core";
+import "@tiptap/extension-text-style";
+var FontSize = Extension5.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (element) => element.style.fontSize.replace(/['"]+/g, ""),
+            renderHTML: (attributes) => {
+              if (!attributes.fontSize) {
+                return {};
+              }
+              return {
+                style: `font-size: ${attributes.fontSize}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (fontSize) => ({ chain }) => chain().setMark("textStyle", { fontSize }).run(),
+      unsetFontSize: () => ({ chain }) => chain().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run()
+    };
+  }
+});
+
+// src/extensions/rich-text-preset.ts
+import {
+  wrappingInputRule,
+  markInputRule
+} from "@tiptap/core";
+import * as _StarterKit from "@tiptap/starter-kit";
+import * as _Color from "@tiptap/extension-color";
+import * as _Highlight from "@tiptap/extension-highlight";
+import * as _Link from "@tiptap/extension-link";
+import * as _TaskList from "@tiptap/extension-task-list";
+import * as _TaskItem from "@tiptap/extension-task-item";
+import * as _TextAlign from "@tiptap/extension-text-align";
+import * as _TextStyle from "@tiptap/extension-text-style";
+import * as _Typography from "@tiptap/extension-typography";
+import * as _Underline from "@tiptap/extension-underline";
+import * as _Placeholder from "@tiptap/extension-placeholder";
+import * as _CharacterCount from "@tiptap/extension-character-count";
+
+// src/extensions/mention.ts
+import {
+  Mention as TipTapMention
+} from "@tiptap/extension-mention";
+var BaseMention = TipTapMention || TipTapMention?.default?.default || TipTapMention?.default || TipTapMention;
+var Mention = BaseMention.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      type: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-type-name") || element.getAttribute("data-entity-type"),
+        renderHTML: (attributes) => {
+          if (!attributes.type) return {};
+          return { "data-type-name": attributes.type };
+        }
+      },
+      avatarUrl: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-avatar-url"),
+        renderHTML: (attributes) => {
+          if (!attributes.avatarUrl) return {};
+          return { "data-avatar-url": attributes.avatarUrl };
+        }
+      },
+      color: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-color"),
+        renderHTML: (attributes) => {
+          if (!attributes.color) return {};
+          return { "data-color": attributes.color };
+        }
+      }
+    };
+  }
+});
+function createMentionExtension(options = {}) {
+  const { HTMLAttributes = {}, ...rest } = options;
+  return Mention.configure({
+    HTMLAttributes: {
+      class: "pixerate-mention-node",
+      ...HTMLAttributes
+    },
+    ...rest
+  });
+}
+
+// ../../node_modules/.pnpm/tiptap-markdown@0.8.10_@tiptap+core@2.27.3_@tiptap+pm@2.27.3_/node_modules/tiptap-markdown/dist/tiptap-markdown.es.js
+import { Extension as Extension6, Mark as Mark2, getHTMLFromFragment, Node as Node$1, extensions } from "@tiptap/core";
+import { MarkdownSerializerState as MarkdownSerializerState$1, defaultMarkdownSerializer } from "prosemirror-markdown";
+import markdownit from "markdown-it";
+import { Fragment, DOMParser } from "@tiptap/pm/model";
+import taskListPlugin from "markdown-it-task-lists";
+import { Plugin as Plugin4, PluginKey } from "@tiptap/pm/state";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var MarkdownTightLists = Extension6.create({
+  name: "markdownTightLists",
+  addOptions: () => ({
+    tight: true,
+    tightClass: "tight",
+    listTypes: ["bulletList", "orderedList"]
+  }),
+  addGlobalAttributes() {
+    return [{
+      types: this.options.listTypes,
+      attributes: {
+        tight: {
+          default: this.options.tight,
+          parseHTML: (element) => element.getAttribute("data-tight") === "true" || !element.querySelector("p"),
+          renderHTML: (attributes) => ({
+            class: attributes.tight ? this.options.tightClass : null,
+            "data-tight": attributes.tight ? "true" : null
+          })
+        }
+      }
+    }];
+  },
+  addCommands() {
+    var _this = this;
+    return {
+      toggleTight: function() {
+        let tight = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+        return (_ref) => {
+          let {
+            editor,
+            commands
+          } = _ref;
+          function toggleTight(name) {
+            if (!editor.isActive(name)) {
+              return false;
+            }
+            const attrs = editor.getAttributes(name);
+            return commands.updateAttributes(name, {
+              tight: tight !== null && tight !== void 0 ? tight : !(attrs !== null && attrs !== void 0 && attrs.tight)
+            });
+          }
+          return _this.options.listTypes.some((name) => toggleTight(name));
+        };
+      }
+    };
+  }
+});
+var md = markdownit();
+function scanDelims(text, pos) {
+  md.inline.State.prototype.scanDelims.call({
+    src: text,
+    posMax: text.length
+  });
+  const state = new md.inline.State(text, null, null, []);
+  return state.scanDelims(pos, true);
+}
+function shiftDelim(text, delim, start2, offset) {
+  let res = text.substring(0, start2) + text.substring(start2 + delim.length);
+  res = res.substring(0, start2 + offset) + delim + res.substring(start2 + offset);
+  return res;
+}
+function trimStart(text, delim, from, to) {
+  let pos = from, res = text;
+  while (pos < to) {
+    if (scanDelims(res, pos).can_open) {
+      break;
+    }
+    res = shiftDelim(res, delim, pos, 1);
+    pos++;
+  }
+  return {
+    text: res,
+    from: pos,
+    to
+  };
+}
+function trimEnd(text, delim, from, to) {
+  let pos = to, res = text;
+  while (pos > from) {
+    if (scanDelims(res, pos).can_close) {
+      break;
+    }
+    res = shiftDelim(res, delim, pos, -1);
+    pos--;
+  }
+  return {
+    text: res,
+    from,
+    to: pos
+  };
+}
+function trimInline(text, delim, from, to) {
+  let state = {
+    text,
+    from,
+    to
+  };
+  state = trimStart(state.text, delim, state.from, state.to);
+  state = trimEnd(state.text, delim, state.from, state.to);
+  if (state.to - state.from < delim.length + 1) {
+    state.text = state.text.substring(0, state.from) + state.text.substring(state.to + delim.length);
+  }
+  return state.text;
+}
+var MarkdownSerializerState = class extends MarkdownSerializerState$1 {
+  constructor(nodes, marks, options) {
+    super(nodes, marks, options !== null && options !== void 0 ? options : {});
+    __publicField(this, "inTable", false);
+    this.inlines = [];
+  }
+  render(node, parent, index) {
+    super.render(node, parent, index);
+    const top = this.inlines[this.inlines.length - 1];
+    if (top !== null && top !== void 0 && top.start && top !== null && top !== void 0 && top.end) {
+      const {
+        delimiter,
+        start: start2,
+        end
+      } = this.normalizeInline(top);
+      this.out = trimInline(this.out, delimiter, start2, end);
+      this.inlines.pop();
+    }
+  }
+  markString(mark, open, parent, index) {
+    const info = this.marks[mark.type.name];
+    if (info.expelEnclosingWhitespace) {
+      if (open) {
+        this.inlines.push({
+          start: this.out.length,
+          delimiter: info.open
+        });
+      } else {
+        const top = this.inlines.pop();
+        this.inlines.push({
+          ...top,
+          end: this.out.length
+        });
+      }
+    }
+    return super.markString(mark, open, parent, index);
+  }
+  normalizeInline(inline) {
+    let {
+      start: start2,
+      end
+    } = inline;
+    while (this.out.charAt(start2).match(/\s/)) {
+      start2++;
+    }
+    return {
+      ...inline,
+      start: start2
+    };
+  }
+};
+var HTMLMark = Mark2.create({
+  name: "markdownHTMLMark",
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open(state, mark) {
+            var _getMarkTags$, _getMarkTags;
+            if (!this.editor.storage.markdown.options.html) {
+              console.warn(`Tiptap Markdown: "${mark.type.name}" mark is only available in html mode`);
+              return "";
+            }
+            return (_getMarkTags$ = (_getMarkTags = getMarkTags(mark)) === null || _getMarkTags === void 0 ? void 0 : _getMarkTags[0]) !== null && _getMarkTags$ !== void 0 ? _getMarkTags$ : "";
+          },
+          close(state, mark) {
+            var _getMarkTags$2, _getMarkTags2;
+            if (!this.editor.storage.markdown.options.html) {
+              return "";
+            }
+            return (_getMarkTags$2 = (_getMarkTags2 = getMarkTags(mark)) === null || _getMarkTags2 === void 0 ? void 0 : _getMarkTags2[1]) !== null && _getMarkTags$2 !== void 0 ? _getMarkTags$2 : "";
+          }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function getMarkTags(mark) {
+  const schema = mark.type.schema;
+  const node = schema.text(" ", [mark]);
+  const html = getHTMLFromFragment(Fragment.from(node), schema);
+  const match = html.match(/^(<.*?>) (<\/.*?>)$/);
+  return match ? [match[1], match[2]] : null;
+}
+function elementFromString(value) {
+  const wrappedValue = `<body>${value}</body>`;
+  return new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
+}
+function escapeHTML(value) {
+  return value === null || value === void 0 ? void 0 : value.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function extractElement(node) {
+  const parent = node.parentElement;
+  const prepend = parent.cloneNode();
+  while (parent.firstChild && parent.firstChild !== node) {
+    prepend.appendChild(parent.firstChild);
+  }
+  if (prepend.childNodes.length > 0) {
+    parent.parentElement.insertBefore(prepend, parent);
+  }
+  parent.parentElement.insertBefore(node, parent);
+  if (parent.childNodes.length === 0) {
+    parent.remove();
+  }
+}
+function unwrapElement(node) {
+  const parent = node.parentNode;
+  while (node.firstChild)
+    parent.insertBefore(node.firstChild, node);
+  parent.removeChild(node);
+}
+var HTMLNode = Node$1.create({
+  name: "markdownHTMLNode",
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent) {
+          if (this.editor.storage.markdown.options.html) {
+            state.write(serializeHTML(node, parent));
+          } else {
+            console.warn(`Tiptap Markdown: "${node.type.name}" node is only available in html mode`);
+            state.write(`[${node.type.name}]`);
+          }
+          if (node.isBlock) {
+            state.closeBlock(node);
+          }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function serializeHTML(node, parent) {
+  const schema = node.type.schema;
+  const html = getHTMLFromFragment(Fragment.from(node), schema);
+  if (node.isBlock && (parent instanceof Fragment || parent.type.name === schema.topNodeType.name)) {
+    return formatBlock(html);
+  }
+  return html;
+}
+function formatBlock(html) {
+  const dom = elementFromString(html);
+  const element = dom.firstElementChild;
+  element.innerHTML = element.innerHTML.trim() ? `
+${element.innerHTML}
+` : `
+`;
+  return element.outerHTML;
+}
+var Blockquote = Node$1.create({
+  name: "blockquote"
+});
+var Blockquote$1 = Blockquote.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.blockquote,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var BulletList = Node$1.create({
+  name: "bulletList"
+});
+var BulletList$1 = BulletList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          return state.renderList(node, "  ", () => (this.editor.storage.markdown.options.bulletListMarker || "-") + " ");
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var CodeBlock = Node$1.create({
+  name: "codeBlock"
+});
+var CodeBlock$1 = CodeBlock.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.write("```" + (node.attrs.language || "") + "\n");
+          state.text(node.textContent, false);
+          state.ensureNewLine();
+          state.write("```");
+          state.closeBlock(node);
+        },
+        parse: {
+          setup(markdownit2) {
+            var _this$options$languag;
+            markdownit2.set({
+              langPrefix: (_this$options$languag = this.options.languageClassPrefix) !== null && _this$options$languag !== void 0 ? _this$options$languag : "language-"
+            });
+          },
+          updateDOM(element) {
+            element.innerHTML = element.innerHTML.replace(/\n<\/code><\/pre>/g, "</code></pre>");
+          }
+        }
+      }
+    };
+  }
+});
+var HardBreak = Node$1.create({
+  name: "hardBreak"
+});
+var HardBreak$1 = HardBreak.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent, index) {
+          for (let i = index + 1; i < parent.childCount; i++)
+            if (parent.child(i).type != node.type) {
+              state.write(state.inTable ? HTMLNode.storage.markdown.serialize.call(this, state, node, parent) : "\\\n");
+              return;
+            }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Heading = Node$1.create({
+  name: "heading"
+});
+var Heading$1 = Heading.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.heading,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var HorizontalRule = Node$1.create({
+  name: "horizontalRule"
+});
+var HorizontalRule$1 = HorizontalRule.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.horizontal_rule,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Image = Node$1.create({
+  name: "image"
+});
+var Image$1 = Image.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.image,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var ListItem = Node$1.create({
+  name: "listItem"
+});
+var ListItem$1 = ListItem.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.list_item,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var OrderedList = Node$1.create({
+  name: "orderedList"
+});
+function findIndexOfAdjacentNode(node, parent, index) {
+  let i = 0;
+  for (; index - i > 0; i++) {
+    if (parent.child(index - i - 1).type.name !== node.type.name) {
+      break;
+    }
+  }
+  return i;
+}
+var OrderedList$1 = OrderedList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent, index) {
+          const start2 = node.attrs.start || 1;
+          const maxW = String(start2 + node.childCount - 1).length;
+          const space = state.repeat(" ", maxW + 2);
+          const adjacentIndex = findIndexOfAdjacentNode(node, parent, index);
+          const separator = adjacentIndex % 2 ? ") " : ". ";
+          state.renderList(node, space, (i) => {
+            const nStr = String(start2 + i);
+            return state.repeat(" ", maxW - nStr.length) + nStr + separator;
+          });
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Paragraph = Node$1.create({
+  name: "paragraph"
+});
+var Paragraph$1 = Paragraph.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.nodes.paragraph,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function childNodes(node) {
+  var _node$content$content, _node$content;
+  return (_node$content$content = node === null || node === void 0 || (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.content) !== null && _node$content$content !== void 0 ? _node$content$content : [];
+}
+var Table = Node$1.create({
+  name: "table"
+});
+var Table$1 = Table.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent) {
+          if (!isMarkdownSerializable(node)) {
+            HTMLNode.storage.markdown.serialize.call(this, state, node, parent);
+            return;
+          }
+          state.inTable = true;
+          node.forEach((row, p, i) => {
+            state.write("| ");
+            row.forEach((col, p2, j) => {
+              if (j) {
+                state.write(" | ");
+              }
+              const cellContent = col.firstChild;
+              if (cellContent.textContent.trim()) {
+                state.renderInline(cellContent);
+              }
+            });
+            state.write(" |");
+            state.ensureNewLine();
+            if (!i) {
+              const delimiterRow = Array.from({
+                length: row.childCount
+              }).map(() => "---").join(" | ");
+              state.write(`| ${delimiterRow} |`);
+              state.ensureNewLine();
+            }
+          });
+          state.closeBlock(node);
+          state.inTable = false;
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function hasSpan(node) {
+  return node.attrs.colspan > 1 || node.attrs.rowspan > 1;
+}
+function isMarkdownSerializable(node) {
+  const rows = childNodes(node);
+  const firstRow = rows[0];
+  const bodyRows = rows.slice(1);
+  if (childNodes(firstRow).some((cell) => cell.type.name !== "tableHeader" || hasSpan(cell) || cell.childCount > 1)) {
+    return false;
+  }
+  if (bodyRows.some((row) => childNodes(row).some((cell) => cell.type.name === "tableHeader" || hasSpan(cell) || cell.childCount > 1))) {
+    return false;
+  }
+  return true;
+}
+var TaskItem = Node$1.create({
+  name: "taskItem"
+});
+var TaskItem$1 = TaskItem.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          const check = node.attrs.checked ? "[x]" : "[ ]";
+          state.write(`${check} `);
+          state.renderContent(node);
+        },
+        parse: {
+          updateDOM(element) {
+            [...element.querySelectorAll(".task-list-item")].forEach((item) => {
+              const input = item.querySelector("input");
+              item.setAttribute("data-type", "taskItem");
+              if (input) {
+                item.setAttribute("data-checked", input.checked);
+                input.remove();
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var TaskList = Node$1.create({
+  name: "taskList"
+});
+var TaskList$1 = TaskList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: BulletList$1.storage.markdown.serialize,
+        parse: {
+          setup(markdownit2) {
+            markdownit2.use(taskListPlugin);
+          },
+          updateDOM(element) {
+            [...element.querySelectorAll(".contains-task-list")].forEach((list) => {
+              list.setAttribute("data-type", "taskList");
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var Text = Node$1.create({
+  name: "text"
+});
+var Text$1 = Text.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.text(escapeHTML(node.text));
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Bold = Mark2.create({
+  name: "bold"
+});
+var Bold$1 = Bold.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.marks.strong,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Code = Mark2.create({
+  name: "code"
+});
+var Code$1 = Code.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.marks.code,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Italic = Mark2.create({
+  name: "italic"
+});
+var Italic$1 = Italic.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.marks.em,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Link = Mark2.create({
+  name: "link"
+});
+var Link$1 = Link.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: defaultMarkdownSerializer.marks.link,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Strike = Mark2.create({
+  name: "strike"
+});
+var Strike$1 = Strike.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open: "~~",
+          close: "~~",
+          expelEnclosingWhitespace: true
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var markdownExtensions = [Blockquote$1, BulletList$1, CodeBlock$1, HardBreak$1, Heading$1, HorizontalRule$1, HTMLNode, Image$1, ListItem$1, OrderedList$1, Paragraph$1, Table$1, TaskItem$1, TaskList$1, Text$1, Bold$1, Code$1, HTMLMark, Italic$1, Link$1, Strike$1];
+function getMarkdownSpec(extension) {
+  var _extension$storage, _markdownExtensions$f;
+  const markdownSpec = (_extension$storage = extension.storage) === null || _extension$storage === void 0 ? void 0 : _extension$storage.markdown;
+  const defaultMarkdownSpec = (_markdownExtensions$f = markdownExtensions.find((e) => e.name === extension.name)) === null || _markdownExtensions$f === void 0 ? void 0 : _markdownExtensions$f.storage.markdown;
+  if (markdownSpec || defaultMarkdownSpec) {
+    return {
+      ...defaultMarkdownSpec,
+      ...markdownSpec
+    };
+  }
+  return null;
+}
+var MarkdownSerializer = class {
+  constructor(editor) {
+    __publicField(this, "editor", null);
+    this.editor = editor;
+  }
+  serialize(content) {
+    const state = new MarkdownSerializerState(this.nodes, this.marks, {
+      hardBreakNodeName: HardBreak$1.name
+    });
+    state.renderContent(content);
+    return state.out;
+  }
+  get nodes() {
+    var _this$editor$extensio;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.nodes).map((name) => [name, this.serializeNode(HTMLNode)])),
+      ...Object.fromEntries((_this$editor$extensio = this.editor.extensionManager.extensions.filter((extension) => extension.type === "node" && this.serializeNode(extension)).map((extension) => [extension.name, this.serializeNode(extension)])) !== null && _this$editor$extensio !== void 0 ? _this$editor$extensio : [])
+    };
+  }
+  get marks() {
+    var _this$editor$extensio2;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.marks).map((name) => [name, this.serializeMark(HTMLMark)])),
+      ...Object.fromEntries((_this$editor$extensio2 = this.editor.extensionManager.extensions.filter((extension) => extension.type === "mark" && this.serializeMark(extension)).map((extension) => [extension.name, this.serializeMark(extension)])) !== null && _this$editor$extensio2 !== void 0 ? _this$editor$extensio2 : [])
+    };
+  }
+  serializeNode(node) {
+    var _getMarkdownSpec;
+    return (_getMarkdownSpec = getMarkdownSpec(node)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.serialize) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.bind({
+      editor: this.editor,
+      options: node.options
+    });
+  }
+  serializeMark(mark) {
+    var _getMarkdownSpec2;
+    const serialize = (_getMarkdownSpec2 = getMarkdownSpec(mark)) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.serialize;
+    return serialize ? {
+      ...serialize,
+      open: typeof serialize.open === "function" ? serialize.open.bind({
+        editor: this.editor,
+        options: mark.options
+      }) : serialize.open,
+      close: typeof serialize.close === "function" ? serialize.close.bind({
+        editor: this.editor,
+        options: mark.options
+      }) : serialize.close
+    } : null;
+  }
+};
+var MarkdownParser = class {
+  constructor(editor, _ref) {
+    __publicField(this, "editor", null);
+    __publicField(this, "md", null);
+    let {
+      html,
+      linkify,
+      breaks
+    } = _ref;
+    this.editor = editor;
+    this.md = this.withPatchedRenderer(markdownit({
+      html,
+      linkify,
+      breaks
+    }));
+  }
+  parse(content) {
+    let {
+      inline
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (typeof content === "string") {
+      this.editor.extensionManager.extensions.forEach((extension) => {
+        var _getMarkdownSpec;
+        return (_getMarkdownSpec = getMarkdownSpec(extension)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.parse) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.setup) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.call({
+          editor: this.editor,
+          options: extension.options
+        }, this.md);
+      });
+      const renderedHTML = this.md.render(content);
+      const element = elementFromString(renderedHTML);
+      this.editor.extensionManager.extensions.forEach((extension) => {
+        var _getMarkdownSpec2;
+        return (_getMarkdownSpec2 = getMarkdownSpec(extension)) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.parse) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.updateDOM) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.call({
+          editor: this.editor,
+          options: extension.options
+        }, element);
+      });
+      this.normalizeDOM(element, {
+        inline,
+        content
+      });
+      return element.innerHTML;
+    }
+    return content;
+  }
+  normalizeDOM(node, _ref2) {
+    let {
+      inline,
+      content
+    } = _ref2;
+    this.normalizeBlocks(node);
+    node.querySelectorAll("*").forEach((el) => {
+      var _el$nextSibling;
+      if (((_el$nextSibling = el.nextSibling) === null || _el$nextSibling === void 0 ? void 0 : _el$nextSibling.nodeType) === Node.TEXT_NODE && !el.closest("pre")) {
+        el.nextSibling.textContent = el.nextSibling.textContent.replace(/^\n/, "");
+      }
+    });
+    if (inline) {
+      this.normalizeInline(node, content);
+    }
+    return node;
+  }
+  normalizeBlocks(node) {
+    const blocks = Object.values(this.editor.schema.nodes).filter((node2) => node2.isBlock);
+    const selector = blocks.map((block) => {
+      var _block$spec$parseDOM;
+      return (_block$spec$parseDOM = block.spec.parseDOM) === null || _block$spec$parseDOM === void 0 ? void 0 : _block$spec$parseDOM.map((spec) => spec.tag);
+    }).flat().filter(Boolean).join(",");
+    if (!selector) {
+      return;
+    }
+    [...node.querySelectorAll(selector)].forEach((el) => {
+      if (el.parentElement.matches("p")) {
+        extractElement(el);
+      }
+    });
+  }
+  normalizeInline(node, content) {
+    var _node$firstElementChi;
+    if ((_node$firstElementChi = node.firstElementChild) !== null && _node$firstElementChi !== void 0 && _node$firstElementChi.matches("p")) {
+      var _content$match$, _content$match, _content$match$2, _content$match2;
+      const firstParagraph = node.firstElementChild;
+      const {
+        nextElementSibling
+      } = firstParagraph;
+      const startSpaces = (_content$match$ = (_content$match = content.match(/^\s+/)) === null || _content$match === void 0 ? void 0 : _content$match[0]) !== null && _content$match$ !== void 0 ? _content$match$ : "";
+      const endSpaces = !nextElementSibling ? (_content$match$2 = (_content$match2 = content.match(/\s+$/)) === null || _content$match2 === void 0 ? void 0 : _content$match2[0]) !== null && _content$match$2 !== void 0 ? _content$match$2 : "" : "";
+      if (content.match(/^\n\n/)) {
+        firstParagraph.innerHTML = `${firstParagraph.innerHTML}${endSpaces}`;
+        return;
+      }
+      unwrapElement(firstParagraph);
+      node.innerHTML = `${startSpaces}${node.innerHTML}${endSpaces}`;
+    }
+  }
+  /**
+   * @param {markdownit} md
+   */
+  withPatchedRenderer(md2) {
+    const withoutNewLine = (renderer) => function() {
+      const rendered = renderer(...arguments);
+      if (rendered === "\n") {
+        return rendered;
+      }
+      if (rendered[rendered.length - 1] === "\n") {
+        return rendered.slice(0, -1);
+      }
+      return rendered;
+    };
+    md2.renderer.rules.hardbreak = withoutNewLine(md2.renderer.rules.hardbreak);
+    md2.renderer.rules.softbreak = withoutNewLine(md2.renderer.rules.softbreak);
+    md2.renderer.rules.fence = withoutNewLine(md2.renderer.rules.fence);
+    md2.renderer.rules.code_block = withoutNewLine(md2.renderer.rules.code_block);
+    md2.renderer.renderToken = withoutNewLine(md2.renderer.renderToken.bind(md2.renderer));
+    return md2;
+  }
+};
+var MarkdownClipboard = Extension6.create({
+  name: "markdownClipboard",
+  addOptions() {
+    return {
+      transformPastedText: false,
+      transformCopiedText: false
+    };
+  },
+  addProseMirrorPlugins() {
+    return [new Plugin4({
+      key: new PluginKey("markdownClipboard"),
+      props: {
+        clipboardTextParser: (text, context, plainText) => {
+          if (plainText || !this.options.transformPastedText) {
+            return null;
+          }
+          const parsed = this.editor.storage.markdown.parser.parse(text, {
+            inline: true
+          });
+          return DOMParser.fromSchema(this.editor.schema).parseSlice(elementFromString(parsed), {
+            preserveWhitespace: true,
+            context
+          });
+        },
+        /**
+         * @param {import('prosemirror-model').Slice} slice
+         */
+        clipboardTextSerializer: (slice) => {
+          if (!this.options.transformCopiedText) {
+            return null;
+          }
+          return this.editor.storage.markdown.serializer.serialize(slice.content);
+        }
+      }
+    })];
+  }
+});
+var Markdown = Extension6.create({
+  name: "markdown",
+  priority: 50,
+  addOptions() {
+    return {
+      html: true,
+      tightLists: true,
+      tightListClass: "tight",
+      bulletListMarker: "-",
+      linkify: false,
+      breaks: false,
+      transformPastedText: false,
+      transformCopiedText: false
+    };
+  },
+  addCommands() {
+    const commands = extensions.Commands.config.addCommands();
+    return {
+      setContent: (content, emitUpdate, parseOptions) => (props) => {
+        return commands.setContent(props.editor.storage.markdown.parser.parse(content), emitUpdate, parseOptions)(props);
+      },
+      insertContentAt: (range, content, options) => (props) => {
+        return commands.insertContentAt(range, props.editor.storage.markdown.parser.parse(content, {
+          inline: true
+        }), options)(props);
+      }
+    };
+  },
+  onBeforeCreate() {
+    this.editor.storage.markdown = {
+      options: {
+        ...this.options
+      },
+      parser: new MarkdownParser(this.editor, this.options),
+      serializer: new MarkdownSerializer(this.editor),
+      getMarkdown: () => {
+        return this.editor.storage.markdown.serializer.serialize(this.editor.state.doc);
+      }
+    };
+    this.editor.options.initialContent = this.editor.options.content;
+    this.editor.options.content = this.editor.storage.markdown.parser.parse(this.editor.options.content);
+  },
+  onCreate() {
+    this.editor.options.content = this.editor.options.initialContent;
+    delete this.editor.options.initialContent;
+  },
+  addStorage() {
+    return {
+      /// storage will be defined in onBeforeCreate() to prevent initial object overriding
+    };
+  },
+  addExtensions() {
+    return [MarkdownTightLists.configure({
+      tight: this.options.tightLists,
+      tightClass: this.options.tightListClass
+    }), MarkdownClipboard.configure({
+      transformPastedText: this.options.transformPastedText,
+      transformCopiedText: this.options.transformCopiedText
+    })];
+  }
+});
+
+// src/extensions/markdown.ts
+var resolveExt = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
+var Markdown2 = resolveExt(Markdown, "Markdown");
+
+// src/extensions/image.ts
+import * as _Image from "@tiptap/extension-image";
+import { Plugin as Plugin5, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+var resolveExt2 = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
+var BaseImage = resolveExt2(_Image, "Image");
+var imagePastePluginKey = new PluginKey2("imagePasteHandler");
+function insertImageNode(view, src, alt) {
+  const { schema } = view.state;
+  const imageType = schema.nodes.image;
+  if (!imageType) return;
+  const node = imageType.create({ src, alt: alt || "" });
+  const tr = view.state.tr.replaceSelectionWith(node);
+  view.dispatch(tr);
+}
+function updateImageSrc(view, oldSrc, newSrc) {
+  const { doc } = view.state;
+  let foundPos = null;
+  let foundAttrs = null;
+  doc.descendants((node, pos) => {
+    if (node.type.name === "image" && node.attrs.src === oldSrc) {
+      foundPos = pos;
+      foundAttrs = node.attrs;
+      return false;
+    }
+  });
+  if (foundPos !== null && foundAttrs) {
+    const tr = view.state.tr.setNodeMarkup(foundPos, void 0, {
+      ...foundAttrs,
+      src: newSrc
+    });
+    view.dispatch(tr);
+  }
+}
+function removeImageNode(view, src) {
+  const { doc } = view.state;
+  let foundPos = null;
+  let nodeSize = 0;
+  doc.descendants((node, pos) => {
+    if (node.type.name === "image" && node.attrs.src === src) {
+      foundPos = pos;
+      nodeSize = node.nodeSize;
+      return false;
+    }
+  });
+  if (foundPos !== null) {
+    const tr = view.state.tr.delete(foundPos, foundPos + nodeSize);
+    view.dispatch(tr);
+  }
+}
+function handleImageInsertion(view, file, options) {
+  if (typeof options.upload === "function") {
+    const hasObjectUrl = typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
+    const tempUrl = hasObjectUrl ? URL.createObjectURL(file) : null;
+    if (tempUrl) {
+      insertImageNode(view, tempUrl, file.name);
+    }
+    Promise.resolve(options.upload(file)).then((uploadedUrl) => {
+      if (!uploadedUrl) {
+        throw new Error("Upload handler returned empty URL");
+      }
+      if (tempUrl) {
+        updateImageSrc(view, tempUrl, uploadedUrl);
+        if (typeof URL.revokeObjectURL === "function") {
+          URL.revokeObjectURL(tempUrl);
+        }
+      } else {
+        insertImageNode(view, uploadedUrl, file.name);
+      }
+    }).catch((err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("Failed to upload pasted image:", error);
+      if (tempUrl) {
+        removeImageNode(view, tempUrl);
+        if (typeof URL.revokeObjectURL === "function") {
+          URL.revokeObjectURL(tempUrl);
+        }
+      }
+      if (typeof options.onUploadError === "function") {
+        options.onUploadError(error, file);
+      }
+    });
+  } else if (options.allowBase64 !== false) {
+    const maxBase64Size = options.maxBase64Size ?? 65536;
+    if (file.size > maxBase64Size) {
+      const err = new Error(
+        `Image size (${Math.round(file.size / 1024)}KB) exceeds maxBase64Size (${Math.round(
+          maxBase64Size / 1024
+        )}KB). Provide an upload handler to support large images.`
+      );
+      console.warn(`[Editor] ${err.message}`);
+      if (typeof options.onUploadError === "function") {
+        options.onUploadError(err, file);
+      }
+      return;
+    }
+    if (typeof FileReader !== "undefined") {
+      const reader = new FileReader();
+      reader.onload = () => {
+        const src = reader.result;
+        if (src) {
+          insertImageNode(view, src, file.name);
+        }
+      };
+      reader.readAsDataURL(file);
+    }
+  }
+}
+var Image2 = BaseImage.extend({
+  addOptions() {
+    return {
+      ...this.parent?.(),
+      allowBase64: true,
+      maxBase64Size: 65536,
+      enablePaste: true,
+      enableDrop: true,
+      upload: void 0,
+      onUploadError: void 0,
+      HTMLAttributes: {
+        class: "rounded-md max-w-full h-auto my-2"
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const parentPlugins = this.parent?.() || [];
+    const options = this.options;
+    if (!options.enablePaste && !options.enableDrop) {
+      return parentPlugins;
+    }
+    const pastePlugin = new Plugin5({
+      key: imagePastePluginKey,
+      props: {
+        handlePaste(view, event) {
+          if (!options.enablePaste) return false;
+          const items = Array.from(event.clipboardData?.items || []);
+          const imageItems = items.filter(
+            (item) => item.kind === "file" && item.type.startsWith("image/")
+          );
+          if (imageItems.length === 0) return false;
+          event.preventDefault();
+          for (const item of imageItems) {
+            const file = item.getAsFile();
+            if (!file) continue;
+            handleImageInsertion(view, file, options);
+          }
+          return true;
+        },
+        handleDrop(view, event) {
+          if (!options.enableDrop) return false;
+          const files = Array.from(event.dataTransfer?.files || []);
+          const imageFiles = files.filter((f) => f.type.startsWith("image/"));
+          if (imageFiles.length === 0) return false;
+          event.preventDefault();
+          for (const file of imageFiles) {
+            handleImageInsertion(view, file, options);
+          }
+          return true;
+        }
+      }
+    });
+    return [...parentPlugins, pastePlugin];
+  }
+});
+
+// src/extensions/comments.ts
+import { Mark as Mark3, mergeAttributes as mergeAttributes2 } from "@tiptap/core";
+import { Plugin as Plugin6, PluginKey as PluginKey3, TextSelection } from "@tiptap/pm/state";
+import { Decoration as Decoration3, DecorationSet as DecorationSet3 } from "@tiptap/pm/view";
+var commentsPluginKey = new PluginKey3("comments");
+var COMMENT_MARK_NAME = "comment";
+function findCommentRanges(doc) {
+  const result = /* @__PURE__ */ new Map();
+  doc.descendants((node, pos) => {
+    if (!node.isInline) return;
+    node.marks.forEach((mark) => {
+      if (mark.type.name !== COMMENT_MARK_NAME) return;
+      const id = mark.attrs.commentId;
+      if (!id) return;
+      const ranges = result.get(id) ?? [];
+      const last = ranges[ranges.length - 1];
+      const end = pos + node.nodeSize;
+      if (last && last.to === pos) {
+        last.to = end;
+      } else {
+        ranges.push({ from: pos, to: end });
+      }
+      result.set(id, ranges);
+    });
+  });
+  return result;
+}
+function getCommentAnchors(doc) {
+  const anchors = /* @__PURE__ */ new Map();
+  findCommentRanges(doc).forEach((ranges, id) => {
+    const from = ranges[0].from;
+    const to = ranges[ranges.length - 1].to;
+    anchors.set(id, {
+      from,
+      to,
+      quote: ranges.map((r) => doc.textBetween(r.from, r.to, " ", " ")).join(" ")
+    });
+  });
+  return anchors;
+}
+function getCommentIdsAt(state, pos = state.selection.from) {
+  const $pos = state.doc.resolve(pos);
+  const marks = [
+    ...$pos.nodeAfter?.marks ?? [],
+    ...$pos.nodeBefore?.marks ?? []
+  ];
+  const ids = [];
+  marks.forEach((m) => {
+    if (m.type.name === COMMENT_MARK_NAME && m.attrs.commentId && !ids.includes(m.attrs.commentId)) {
+      ids.push(m.attrs.commentId);
+    }
+  });
+  return ids;
+}
+function getCommentStore(editor) {
+  return editor?.storage?.[COMMENT_MARK_NAME]?.store ?? null;
+}
+function resolveAuthor(author) {
+  return typeof author === "function" ? author() : author;
+}
+var Comments = Mark3.create({
+  name: COMMENT_MARK_NAME,
+  // Typing at the edge of a comment does not extend it.
+  inclusive: false,
+  // Allow several comment marks (different threads) on the same text.
+  excludes: "",
+  addOptions() {
+    return {
+      store: null,
+      author: { id: "anonymous", name: "Anonymous" },
+      HTMLAttributes: {},
+      commentClass: "pixerate-comment bg-amber-100 border-b-2 border-amber-400 dark:bg-amber-500/20 cursor-pointer",
+      activeClass: "pixerate-comment-active bg-amber-200 dark:bg-amber-500/40",
+      resolvedClass: "",
+      activateOnSelection: true
+    };
+  },
+  addStorage() {
+    return {
+      store: this.options.store ?? new CommentStore(),
+      // tiptap-markdown: comments are not part of the exported markdown.
+      markdown: { serialize: { open: "", close: "" }, parse: {} }
+    };
+  },
+  addAttributes() {
+    return {
+      commentId: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-comment-id"),
+        renderHTML: (attrs) => attrs.commentId ? { "data-comment-id": attrs.commentId } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-comment-id]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes2(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    const store = () => this.storage.store;
+    return {
+      addComment: (options = {}) => ({ state, tr, dispatch }) => {
+        const { from, to, empty } = state.selection;
+        if (empty) return false;
+        if (dispatch) {
+          const id = options.id ?? createReviewId("comment");
+          tr.addMark(from, to, this.type.create({ commentId: id }));
+          tr.setMeta(commentsPluginKey, "refresh");
+          store().createThread({
+            id,
+            body: options.body ?? "",
+            author: options.author ?? resolveAuthor(this.options.author),
+            anchor: { from, to, quote: state.doc.textBetween(from, to, " ", " ") }
+          });
+          store().setActiveThread(id);
+        }
+        return true;
+      },
+      resolveComment: (id, resolved = true) => ({ tr, dispatch }) => {
+        if (!store().getThread(id)) return false;
+        if (dispatch) {
+          store().resolveThread(id, resolved, resolveAuthor(this.options.author));
+          tr.setMeta(commentsPluginKey, "refresh");
+        }
+        return true;
+      },
+      deleteComment: (id) => ({ state, tr, dispatch }) => {
+        const ranges = findCommentRanges(state.doc).get(id) ?? [];
+        if (ranges.length === 0 && !store().getThread(id)) return false;
+        if (dispatch) {
+          ranges.forEach(({ from, to }) => {
+            state.doc.nodesBetween(from, to, (node, pos) => {
+              const mark = node.marks.find(
+                (m) => m.type === this.type && m.attrs.commentId === id
+              );
+              if (mark) {
+                tr.removeMark(Math.max(pos, from), Math.min(pos + node.nodeSize, to), mark);
+              }
+            });
+          });
+          tr.setMeta(commentsPluginKey, "refresh");
+          store().deleteThread(id);
+        }
+        return true;
+      },
+      setActiveComment: (id) => ({ tr, dispatch }) => {
+        if (id !== null && !store().getThread(id)) return false;
+        if (dispatch) {
+          store().setActiveThread(id);
+          tr.setMeta(commentsPluginKey, "refresh");
+        }
+        return true;
+      },
+      focusComment: (id) => ({ state, tr, dispatch }) => {
+        const ranges = findCommentRanges(state.doc).get(id);
+        if (!ranges || ranges.length === 0) return false;
+        if (dispatch) {
+          const from = ranges[0].from;
+          const to = ranges[ranges.length - 1].to;
+          tr.setSelection(TextSelection.create(tr.doc, from, to)).scrollIntoView();
+          store().setActiveThread(id);
+          tr.setMeta(commentsPluginKey, "refresh");
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const store = this.storage.store;
+    const options = this.options;
+    let cache = null;
+    const buildDecorations = (doc) => {
+      const snapshot = store.getSnapshot();
+      if (cache && cache.doc === doc && cache.snapshot === snapshot) return cache.set;
+      const decorations = [];
+      findCommentRanges(doc).forEach((ranges, id) => {
+        const thread = store.getThread(id);
+        const resolved = thread?.resolved ?? false;
+        const active = snapshot.activeThreadId === id;
+        const cls = [
+          resolved ? options.resolvedClass : options.commentClass,
+          active ? options.activeClass : ""
+        ].filter(Boolean).join(" ");
+        if (!cls) return;
+        ranges.forEach(({ from, to }) => {
+          decorations.push(Decoration3.inline(from, to, { class: cls }));
+        });
+      });
+      const set = DecorationSet3.create(doc, decorations);
+      cache = { doc, snapshot, set };
+      return set;
+    };
+    return [
+      new Plugin6({
+        key: commentsPluginKey,
+        props: {
+          decorations: (state) => buildDecorations(state.doc)
+        },
+        view: (view) => {
+          let destroyed = false;
+          let scheduled = false;
+          const sync = () => store.syncAnchors(getCommentAnchors(view.state.doc));
+          sync();
+          const unsubscribe = store.subscribe(() => {
+            if (scheduled) return;
+            scheduled = true;
+            queueMicrotask(() => {
+              scheduled = false;
+              if (destroyed) return;
+              sync();
+              if (cache?.snapshot !== store.getSnapshot()) {
+                view.dispatch(
+                  view.state.tr.setMeta(commentsPluginKey, "refresh").setMeta("addToHistory", false)
+                );
+              }
+            });
+          });
+          return {
+            update(view2, prevState) {
+              if (!prevState.doc.eq(view2.state.doc)) sync();
+              if (options.activateOnSelection && !prevState.selection.eq(view2.state.selection)) {
+                const ids = getCommentIdsAt(view2.state);
+                const active = store.getSnapshot().activeThreadId;
+                if (!active || !ids.includes(active)) {
+                  store.setActiveThread(ids[0] ?? null);
+                }
+              }
+            },
+            destroy() {
+              destroyed = true;
+              unsubscribe();
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+function getCommentAuthor(editor) {
+  const ext = editor?.extensionManager?.extensions.find((e) => e.name === COMMENT_MARK_NAME);
+  return ext ? resolveAuthor(ext.options.author) : null;
+}
+
+// src/extensions/file-import.ts
+import { Extension as Extension7 } from "@tiptap/core";
+import { Plugin as Plugin7, PluginKey as PluginKey4 } from "@tiptap/pm/state";
+
+// src/import/registry.ts
+var ImportError = class extends Error {
+  code;
+  fileName;
+  constructor(code, message, details = {}) {
+    super(message, details.cause !== void 0 ? { cause: details.cause } : void 0);
+    this.name = "ImportError";
+    this.code = code;
+    this.fileName = details.fileName;
+  }
+};
+var normalizeExtension = (ext) => {
+  const lower = ext.trim().toLowerCase();
+  return lower.startsWith(".") ? lower : `.${lower}`;
+};
+var normalizeMimeType = (mime) => (mime ?? "").split(";")[0].trim().toLowerCase();
+function isFileLike(input) {
+  return typeof input === "object" && input !== null && !(input instanceof ArrayBuffer) && !ArrayBuffer.isView(input);
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function createImportContext(input, details) {
+  const readArrayBuffer = async () => {
+    if (typeof input === "string") {
+      return new TextEncoder().encode(input).buffer;
+    }
+    if (input instanceof ArrayBuffer) return input;
+    if (ArrayBuffer.isView(input)) {
+      return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
+    }
+    if (typeof input.arrayBuffer === "function") return input.arrayBuffer();
+    if (typeof input.text === "function") {
+      return new TextEncoder().encode(await input.text()).buffer;
+    }
+    throw new TypeError("Import input cannot be read as binary data.");
+  };
+  const readText = async () => {
+    if (typeof input === "string") return stripBom(input);
+    if (isFileLike(input) && typeof input.text === "function") {
+      return stripBom(await input.text());
+    }
+    return stripBom(new TextDecoder("utf-8").decode(await readArrayBuffer()));
+  };
+  return { ...details, readText, readArrayBuffer };
+}
+var ImportAdapterRegistry = class {
+  adapters = [];
+  /** Registers an adapter and returns a function that unregisters it. */
+  register(adapter, options = {}) {
+    const existing = this.adapters.findIndex((a) => a.id === adapter.id);
+    if (existing !== -1) {
+      if (!options.replace) {
+        throw new Error(`Import adapter "${adapter.id}" is already registered.`);
+      }
+      this.adapters.splice(existing, 1);
+    }
+    this.adapters.push(adapter);
+    return () => {
+      this.unregister(adapter);
+    };
+  }
+  /** Removes an adapter by id or instance. Returns whether it was registered. */
+  unregister(adapterOrId) {
+    const index = this.adapters.findIndex(
+      (a) => typeof adapterOrId === "string" ? a.id === adapterOrId : a === adapterOrId
+    );
+    if (index === -1) return false;
+    this.adapters.splice(index, 1);
+    return true;
+  }
+  get(id) {
+    return this.adapters.find((a) => a.id === id);
+  }
+  /** Registered adapters in registration order, optionally for one target. */
+  list(target) {
+    return this.adapters.filter((a) => target === void 0 || a.target === target);
+  }
+  /**
+   * Finds the best adapter for a file. Extensions win over MIME types (browsers
+   * often report `""` or `text/plain` for markdown), the longest matching
+   * extension wins (`.md.txt` beats `.txt`), exact MIME types beat `type/*`
+   * wildcards, then higher `priority`, then the most recently registered.
+   */
+  find(query) {
+    const fileName = query.fileName?.toLowerCase() ?? "";
+    const mime = normalizeMimeType(query.mimeType);
+    let best;
+    let bestScore = 0;
+    let bestPriority = -Infinity;
+    this.adapters.forEach((adapter) => {
+      if (query.target !== void 0 && adapter.target !== query.target) return;
+      let score = 0;
+      if (fileName) {
+        for (const raw of adapter.extensions) {
+          const ext = normalizeExtension(raw);
+          if (fileName.endsWith(ext) && fileName.length > ext.length) {
+            score = Math.max(score, 1e3 + ext.length);
+          }
+        }
+      }
+      if (score === 0 && mime) {
+        for (const raw of adapter.mimeTypes) {
+          const accepted = normalizeMimeType(raw);
+          if (accepted === mime) score = Math.max(score, 2);
+          else if (accepted.endsWith("/*") && mime.startsWith(accepted.slice(0, -1))) {
+            score = Math.max(score, 1);
+          }
+        }
+      }
+      if (score === 0) return;
+      const priority = adapter.priority ?? 0;
+      if (score > bestScore || score === bestScore && priority >= bestPriority) {
+        best = adapter;
+        bestScore = score;
+        bestPriority = priority;
+      }
+    });
+    return best;
+  }
+  /**
+   * Returns a value for `<input type="file" accept="…">` covering every
+   * registered extension and MIME type (optionally for one target).
+   */
+  accept(target) {
+    const values = /* @__PURE__ */ new Set();
+    for (const adapter of this.list(target)) {
+      adapter.extensions.forEach((ext) => values.add(normalizeExtension(ext)));
+      adapter.mimeTypes.forEach((mime) => values.add(normalizeMimeType(mime)));
+    }
+    return Array.from(values).join(",");
+  }
+  /** Whether some adapter (optionally for `target`) accepts this file. */
+  canImport(file, target) {
+    return !!this.find({ fileName: file.name, mimeType: file.type, target });
+  }
+  /**
+   * Imports a file (or string / binary input) with the matching adapter.
+   * Rejects with an {@link ImportError} when no adapter matches or the
+   * adapter fails.
+   */
+  async importFile(input, options = {}) {
+    const fileName = options.fileName ?? (isFileLike(input) ? input.name : void 0);
+    const mimeType = options.mimeType ?? (isFileLike(input) ? input.type : void 0);
+    let adapter;
+    if (options.adapterId) {
+      adapter = this.get(options.adapterId);
+      if (!adapter) {
+        throw new ImportError("unknown_adapter", `No import adapter with id "${options.adapterId}".`, { fileName });
+      }
+    } else {
+      adapter = this.find({ fileName, mimeType, target: options.target });
+    }
+    if (!adapter) {
+      const what = fileName || mimeType || "input";
+      throw new ImportError(
+        "unsupported_type",
+        `No import adapter accepts ${what}${options.target ? ` for target "${options.target}"` : ""}.`,
+        { fileName }
+      );
+    }
+    const context = createImportContext(input, { fileName, mimeType, target: adapter.target });
+    try {
+      const result = await adapter.import(input, context);
+      return { adapterId: adapter.id, target: adapter.target, fileName, mimeType, result };
+    } catch (error) {
+      throw new ImportError(
+        "adapter_failed",
+        `Import adapter "${adapter.id}" failed: ${error instanceof Error ? error.message : String(error)}`,
+        { fileName, cause: error }
+      );
+    }
+  }
+};
+
+// src/import/adapters.ts
+var markdownImportAdapter = {
+  id: "markdown",
+  label: "Markdown",
+  mimeTypes: ["text/markdown", "text/x-markdown"],
+  extensions: [".md", ".mdown", ".markdown", ".mkdn", ".mkd", ".rmd", ".md.txt"],
+  target: "document",
+  async import(_input, context) {
+    const text = await context.readText();
+    return { html: markdownToTipTapHtml(text), text };
+  }
+};
+var htmlImportAdapter = {
+  id: "html",
+  label: "HTML",
+  mimeTypes: ["text/html", "application/xhtml+xml"],
+  extensions: [".html", ".htm", ".xhtml"],
+  target: "document",
+  async import(_input, context) {
+    const html = sanitizeImportedHtml(await context.readText());
+    return { html, text: htmlToPlainText(html) };
+  }
+};
+var plainTextImportAdapter = {
+  id: "text",
+  label: "Plain text",
+  mimeTypes: ["text/plain"],
+  extensions: [".txt", ".text"],
+  target: "document",
+  async import(_input, context) {
+    const text = (await context.readText()).replace(/\r\n?/g, "\n");
+    return { html: plainTextToParagraphHtml(text), text };
+  }
+};
+var rtfImportAdapter = {
+  id: "rtf",
+  label: "Rich Text Format",
+  mimeTypes: ["application/rtf", "text/rtf"],
+  extensions: [".rtf"],
+  target: "document",
+  async import(_input, context) {
+    const text = rtfToPlainText(await context.readText());
+    return { html: plainTextToParagraphHtml(text), text };
+  }
+};
+var BUILT_IN_IMPORT_ADAPTERS = [
+  markdownImportAdapter,
+  htmlImportAdapter,
+  plainTextImportAdapter,
+  rtfImportAdapter
+];
+function createImportAdapterRegistry(options = {}) {
+  const registry = new ImportAdapterRegistry();
+  if (options.builtIns !== false) {
+    BUILT_IN_IMPORT_ADAPTERS.forEach((adapter) => registry.register(adapter));
+  }
+  return registry;
+}
+var defaultImportRegistry = createImportAdapterRegistry();
+function registerImportAdapter(adapter, options) {
+  return defaultImportRegistry.register(adapter, options);
+}
+function unregisterImportAdapter(adapterOrId) {
+  return defaultImportRegistry.unregister(adapterOrId);
+}
+function findImportAdapter(query) {
+  return defaultImportRegistry.find(query);
+}
+function importFile(input, options) {
+  return defaultImportRegistry.importFile(input, options);
+}
+function getImportAccept(target) {
+  return defaultImportRegistry.accept(target);
+}
+
+// src/import/editor.ts
+import { DOMParser as PMDOMParser, Slice } from "@tiptap/pm/model";
+import { Selection } from "@tiptap/pm/state";
+var toView = (target) => "state" in target && "dispatch" in target ? target : target.view;
+function htmlToSlice(html, schema) {
+  const Parser = globalThis.DOMParser ?? globalThis.window?.DOMParser;
+  if (!Parser) return null;
+  const body = new Parser().parseFromString(`<body>${html}</body>`, "text/html").body;
+  return new Slice(PMDOMParser.fromSchema(schema).parse(body).content, 0, 0);
+}
+function insertImportedDocument(target, content, options = {}) {
+  const view = toView(target);
+  const { state } = view;
+  const htmlSlice = options.asPlainText ? null : htmlToSlice(content.html, state.schema);
+  const size = state.doc.content.size;
+  let from = options.at !== void 0 ? Math.max(0, Math.min(options.at, size)) : state.selection.from;
+  let to = options.at !== void 0 ? from : state.selection.to;
+  if (!htmlSlice && from === to && !state.doc.resolve(from).parent.inlineContent) {
+    from = to = Selection.near(state.doc.resolve(from)).from;
+  }
+  const tr = htmlSlice ? state.tr.replaceRange(from, to, htmlSlice) : state.tr.replace(from, to, plainTextToSlice(content.text, state.schema));
+  const end = tr.mapping.map(to, 1);
+  view.dispatch(tr.scrollIntoView().setMeta("uiEvent", "drop"));
+  return end;
+}
+async function importFilesIntoEditor(target, files, options = {}) {
+  const registry = options.registry ?? defaultImportRegistry;
+  const outcomes = [];
+  let at = options.at;
+  for (const file of Array.from(files)) {
+    try {
+      const outcome = await registry.importFile(file, { target: "document" });
+      const view = toView(target);
+      if (view.isDestroyed) break;
+      at = insertImportedDocument(view, outcome.result, { at, asPlainText: options.asPlainText });
+      outcomes.push(outcome);
+      options.onImport?.(outcome, file);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (options.onError) options.onError(err, file);
+      else console.error("[Editor] File import failed:", err);
+    }
+  }
+  return outcomes;
+}
+
+// src/extensions/file-import.ts
+var fileImportPluginKey = new PluginKey4("fileImport");
+function getImportableFiles(files, registry) {
+  const list = Array.from(files ?? []);
+  if (list.length === 0) return null;
+  return list.every((file) => registry.canImport(file, "document")) ? list : null;
+}
+function dropPosition(view, event) {
+  try {
+    return view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos;
+  } catch {
+    return void 0;
+  }
+}
+var FileImport = Extension7.create({
+  name: "fileImport",
+  addOptions() {
+    return {
+      registry: void 0,
+      asPlainText: false,
+      enableDrop: true,
+      enablePaste: true,
+      onImport: void 0,
+      onImportError: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    const registry = () => options.registry ?? defaultImportRegistry;
+    const run = (view, files, at) => {
+      void importFilesIntoEditor(view, files, {
+        registry: registry(),
+        at,
+        asPlainText: options.asPlainText,
+        onImport: options.onImport,
+        onError: options.onImportError
+      });
+    };
+    return [
+      new Plugin7({
+        key: fileImportPluginKey,
+        props: {
+          handleDrop(view, event, _slice, moved) {
+            if (!options.enableDrop || moved) return false;
+            const files = getImportableFiles(event.dataTransfer?.files, registry());
+            if (!files) return false;
+            event.preventDefault();
+            run(view, files, dropPosition(view, event));
+            return true;
+          },
+          handlePaste(view, event) {
+            if (!options.enablePaste) return false;
+            const files = getImportableFiles(event.clipboardData?.files, registry());
+            if (!files) return false;
+            event.preventDefault();
+            run(view, files);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/rich-clipboard.ts
+import { Extension as Extension8 } from "@tiptap/core";
+import { Plugin as Plugin8, PluginKey as PluginKey5 } from "@tiptap/pm/state";
+var richClipboardPluginKey = new PluginKey5("richClipboard");
+function writeRichClipboard(view, event, options = {}) {
+  const { state } = view;
+  if (state.selection.empty) return false;
+  const data = getClipboardData(event);
+  if (!data || typeof data.setData !== "function") return false;
+  const slice = state.selection.content();
+  const { dom, text } = view.serializeForClipboard(slice);
+  event.preventDefault();
+  data.clearData?.();
+  data.setData("text/html", dom.innerHTML);
+  data.setData("text/plain", text);
+  data.setData(options.mimeType ?? PIXERATE_DOCUMENT_MIME, serializeRichClipboardPayload(slice, state.schema));
+  if (options.cut && view.editable) {
+    view.dispatch(state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
+  }
+  return true;
+}
+var RichClipboard = Extension8.create({
+  name: "richClipboard",
+  addOptions() {
+    return {
+      mimeType: PIXERATE_DOCUMENT_MIME,
+      plainTextMode: false
+    };
+  },
+  addStorage() {
+    return { plainTextMode: !!this.options.plainTextMode };
+  },
+  addProseMirrorPlugins() {
+    const mimeType = this.options.mimeType ?? PIXERATE_DOCUMENT_MIME;
+    const storage = this.storage;
+    return [
+      new Plugin8({
+        key: richClipboardPluginKey,
+        props: {
+          handleDOMEvents: {
+            copy: (view, event) => writeRichClipboard(view, event, { mimeType }),
+            cut: (view, event) => writeRichClipboard(view, event, { cut: true, mimeType })
+          },
+          handlePaste(view, event) {
+            if (storage.plainTextMode) return false;
+            const slice = readRichClipboard(event, view.state.schema, mimeType);
+            if (!slice) return false;
+            event.preventDefault();
+            view.dispatch(
+              view.state.tr.replaceSelection(slice).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste")
+            );
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/autocorrect.ts
+import { Extension as Extension9 } from "@tiptap/core";
+import { closeHistory } from "@tiptap/pm/history";
+import { Plugin as Plugin9, PluginKey as PluginKey6 } from "@tiptap/pm/state";
+var quoteOpener = /[\s ([{<—–‘“-]/;
+var smartQuoteRules = [
+  {
+    id: "smart-quotes:double",
+    find: /(^|.)"$/su,
+    replace: (m) => m[1] + (!m[1] || quoteOpener.test(m[1]) ? "\u201C" : "\u201D")
+  },
+  {
+    id: "smart-quotes:single",
+    find: /(^|.)'$/su,
+    replace: (m) => m[1] + (!m[1] || quoteOpener.test(m[1]) ? "\u2018" : "\u2019")
+  }
+];
+var symbolRules = [
+  { id: "symbols:em-dash", find: "--", replace: "\u2014" },
+  { id: "symbols:ellipsis", find: "...", replace: "\u2026" },
+  { id: "symbols:right-arrow", find: "->", replace: "\u2192" },
+  { id: "symbols:left-arrow", find: "<-", replace: "\u2190" },
+  { id: "symbols:copyright", find: /\([cC]\)$/, replace: "\xA9" },
+  { id: "symbols:registered", find: /\([rR]\)$/, replace: "\xAE" },
+  { id: "symbols:trademark", find: /\((?:tm|TM)\)$/, replace: "\u2122" }
+];
+var FRACTIONS = { "1/2": "\xBD", "1/4": "\xBC", "3/4": "\xBE" };
+var fractionRules = [
+  {
+    id: "fractions",
+    find: /(^|[^\d/.,])([13]\/[24])([\s.,;:!?)])$/u,
+    replace: (m) => FRACTIONS[m[2]] ? m[1] + FRACTIONS[m[2]] + m[3] : null
+  }
+];
+var capitalizeSentenceRules = [
+  {
+    id: "capitalize-sentence",
+    find: /(?:^|(\S+)(\s+))(\p{Ll}[^\s]*)(\s)$/u,
+    replace: (m, ctx) => {
+      const [, previous, space = "", word, trailing] = m;
+      if (/[./@:\\]/.test(word.slice(0, -1))) return null;
+      if (previous !== void 0) {
+        if (!/[.!?]["'”’)]*$/.test(previous)) return null;
+        const token = previous.replace(/["'”’)]+$/, "");
+        if (ctx.isException(token)) return null;
+        if (/^\p{L}\.$/u.test(token)) return null;
+        if (/\.\./.test(token) || token.endsWith("\u2026")) return null;
+      }
+      return (previous ?? "") + space + word.charAt(0).toUpperCase() + word.slice(1) + trailing;
+    }
+  }
+];
+var twoInitialCapitalsRules = [
+  {
+    id: "two-initial-capitals",
+    find: /(^|[^\p{L}\p{N}'’])(\p{Lu})(\p{Lu})(\p{Ll}{1,})([\s.,;:!?])$/u,
+    replace: (m, ctx) => {
+      const word = m[2] + m[3] + m[4];
+      if (ctx.isException(word)) return null;
+      return m[1] + m[2] + m[3].toLowerCase() + m[4] + m[5];
+    }
+  }
+];
+var defaultAutocorrectRules = [
+  ...smartQuoteRules,
+  ...symbolRules,
+  ...fractionRules,
+  ...capitalizeSentenceRules,
+  ...twoInitialCapitalsRules
+];
+var DEFAULT_AUTOCORRECT_EXCEPTIONS = [
+  "a.m.",
+  "abbr.",
+  "approx.",
+  "apt.",
+  "assn.",
+  "ave.",
+  "ca.",
+  "cf.",
+  "co.",
+  "corp.",
+  "dept.",
+  "dr.",
+  "e.g.",
+  "est.",
+  "etc.",
+  "fig.",
+  "i.e.",
+  "inc.",
+  "jr.",
+  "ltd.",
+  "mr.",
+  "mrs.",
+  "ms.",
+  "mt.",
+  "no.",
+  "p.",
+  "p.m.",
+  "pp.",
+  "prof.",
+  "sr.",
+  "st.",
+  "vol.",
+  "vs.",
+  "CDs",
+  "IDs",
+  "PCs",
+  "GHz",
+  "MHz",
+  "KHz"
+];
+var autocorrectPluginKey = new PluginKey6("autocorrect");
+var WHOLE_WORD_DELIMITER = /[\s.,;:!?]/;
+function findAutocorrection(textBefore, rules, context) {
+  const ctx = { ...context, textBefore };
+  for (const rule of rules) {
+    let match = null;
+    if (typeof rule.find === "string") {
+      const find = rule.find;
+      if (rule.wholeWord) {
+        const delimiter = textBefore.slice(-1);
+        if (!WHOLE_WORD_DELIMITER.test(delimiter)) continue;
+        const body = textBefore.slice(0, -1);
+        if (!body.endsWith(find)) continue;
+        const before = body.charAt(body.length - find.length - 1);
+        if (before && /[\p{L}\p{N}_]/u.test(before)) continue;
+        match = Object.assign([find + delimiter], {
+          index: textBefore.length - find.length - 1,
+          input: textBefore
+        });
+      } else {
+        if (!textBefore.endsWith(find)) continue;
+        match = Object.assign([find], {
+          index: textBefore.length - find.length,
+          input: textBefore
+        });
+      }
+    } else {
+      const regex = new RegExp(rule.find.source, rule.find.flags.replace("g", ""));
+      match = textBefore.match(regex);
+      if (!match || match.index + match[0].length !== textBefore.length) continue;
+    }
+    const original = match[0];
+    if (ctx.isException(original.trim())) continue;
+    let replacement;
+    if (typeof rule.replace === "function") {
+      replacement = rule.replace(match, ctx);
+    } else {
+      replacement = rule.wholeWord && typeof rule.find === "string" ? rule.replace + original.slice(-1) : rule.replace;
+    }
+    if (replacement == null || replacement === original) continue;
+    return { ruleId: rule.id, start: match.index, original, replacement };
+  }
+  return null;
+}
+function isInsidePromptToken(textBefore) {
+  if (textBefore.lastIndexOf("{") > textBefore.lastIndexOf("}")) return true;
+  const underscores = textBefore.match(/__/g);
+  return !!underscores && underscores.length % 2 === 1;
+}
+var Autocorrect = Extension9.create({
+  name: "autocorrect",
+  addOptions() {
+    return {
+      rules: defaultAutocorrectRules,
+      exceptions: DEFAULT_AUTOCORRECT_EXCEPTIONS,
+      ignoreNodes: ["codeBlock"],
+      ignoreMarks: ["code"],
+      ignorePromptTokens: true,
+      onCorrection: void 0
+    };
+  },
+  addStorage() {
+    return {
+      enabled: true,
+      exceptions: new Set(this.options.exceptions.map((e) => e.toLowerCase()))
+    };
+  },
+  addCommands() {
+    return {
+      undoAutocorrect: () => ({ state, tr, dispatch }) => {
+        const last = autocorrectPluginKey.getState(state)?.last;
+        if (!last) return false;
+        if (state.doc.textBetween(last.from, last.to) !== last.replacement) return false;
+        if (dispatch) {
+          tr.insertText(last.original, last.from, last.to);
+          tr.setMeta(autocorrectPluginKey, { undo: true });
+        }
+        return true;
+      },
+      setAutocorrectEnabled: (enabled) => () => {
+        this.storage.enabled = enabled;
+        return true;
+      },
+      addAutocorrectException: (text) => () => {
+        this.storage.exceptions.add(text.toLowerCase());
+        return true;
+      },
+      removeAutocorrectException: (text) => () => this.storage.exceptions.delete(text.toLowerCase())
+    };
+  },
+  addProseMirrorPlugins() {
+    const extension = this;
+    const isIgnored = (state, from, to) => {
+      const { ignoreNodes, ignoreMarks } = extension.options;
+      const $from = state.doc.resolve(from);
+      for (let d = $from.depth; d > 0; d--) {
+        const node = $from.node(d);
+        if (node.type.spec.code || ignoreNodes.includes(node.type.name)) return true;
+      }
+      const isIgnoredMark = (mark) => mark.type.spec.code || ignoreMarks.includes(mark.type.name);
+      const marks = state.storedMarks ?? $from.marks();
+      if (marks.some(isIgnoredMark)) return true;
+      let ignored = false;
+      if (to > from) {
+        state.doc.nodesBetween(from, to, (node) => {
+          if (node.marks.some(isIgnoredMark)) ignored = true;
+        });
+      }
+      return ignored;
+    };
+    const handleTextInput = (view, from, to, text) => {
+      if (!extension.storage.enabled || view.composing) return false;
+      const { state } = view;
+      const pluginState = autocorrectPluginKey.getState(state);
+      const $from = state.doc.resolve(from);
+      if (!$from.parent.isTextblock || !$from.sameParent(state.doc.resolve(to))) {
+        return false;
+      }
+      const insertTyped = () => {
+        const tr2 = state.tr.insertText(text, from, to);
+        if (pluginState?.closePending) closeHistory(tr2);
+        view.dispatch(tr2);
+      };
+      if (isIgnored(state, from, to)) return false;
+      const textBefore = $from.parent.textBetween(0, $from.parentOffset, void 0, "\uFFFC") + text;
+      if (extension.options.ignorePromptTokens && isInsidePromptToken(textBefore)) {
+        return false;
+      }
+      const currentWord = /\S*$/.exec(textBefore)?.[0] ?? "";
+      if (/:\/\/|^www\./i.test(currentWord)) return false;
+      const exceptions = extension.storage.exceptions;
+      const found = findAutocorrection(textBefore, extension.options.rules, {
+        state,
+        isException: (value) => exceptions.has(value.toLowerCase())
+      });
+      if (!found) {
+        if (!pluginState?.closePending) return false;
+        insertTyped();
+        return true;
+      }
+      let { original, replacement } = found;
+      let start2 = found.start;
+      let prefix = 0;
+      while (prefix < original.length && prefix < replacement.length && original[prefix] === replacement[prefix]) {
+        prefix++;
+      }
+      let suffix = 0;
+      while (suffix < original.length - prefix && suffix < replacement.length - prefix && original[original.length - 1 - suffix] === replacement[replacement.length - 1 - suffix]) {
+        suffix++;
+      }
+      start2 += prefix;
+      original = original.slice(prefix, original.length - suffix);
+      replacement = replacement.slice(prefix, replacement.length - suffix);
+      const textEnd = textBefore.length - suffix;
+      insertTyped();
+      const next = view.state;
+      const blockStart = next.doc.resolve(from + text.length).start();
+      const correctionFrom = blockStart + start2;
+      const correctionTo = blockStart + textEnd;
+      if (next.doc.textBetween(correctionFrom, correctionTo, void 0, "\uFFFC") !== original || isIgnored(next, correctionFrom, correctionTo)) {
+        return true;
+      }
+      const correction = {
+        ruleId: found.ruleId,
+        from: correctionFrom,
+        to: correctionFrom + replacement.length,
+        original,
+        replacement
+      };
+      const tr = next.tr.insertText(replacement, correctionFrom, correctionTo);
+      closeHistory(tr);
+      tr.setMeta(autocorrectPluginKey, { correction });
+      view.dispatch(tr);
+      extension.options.onCorrection?.(correction);
+      return true;
+    };
+    return [
+      new Plugin9({
+        key: autocorrectPluginKey,
+        state: {
+          init: () => ({ last: null, closePending: false }),
+          apply: (tr, prev) => {
+            const meta = tr.getMeta(autocorrectPluginKey);
+            if (meta?.correction) return { last: meta.correction, closePending: true };
+            if (meta?.undo) return { last: null, closePending: true };
+            if (!tr.docChanged) return prev;
+            if (!prev.last && !prev.closePending) return prev;
+            return { last: null, closePending: false };
+          }
+        },
+        props: { handleTextInput }
+      })
+    ];
+  }
+});
+
+// src/extensions/document-structure/outline.ts
+import { Extension as Extension10 } from "@tiptap/core";
+import {
+  Plugin as Plugin10,
+  PluginKey as PluginKey7,
+  TextSelection as TextSelection2
+} from "@tiptap/pm/state";
+
+// src/extensions/document-structure/utils.ts
+import { createDocument } from "@tiptap/core";
+import { EditorState } from "@tiptap/pm/state";
+import { ReplaceAroundStep, ReplaceStep } from "@tiptap/pm/transform";
+var idCounter = 0;
+function generateStructureId(prefix) {
+  idCounter = (idCounter + 1) % 1296;
+  const random = Math.random().toString(36).slice(2, 8).padEnd(6, "0");
+  return `${prefix}-${random}${idCounter.toString(36).padStart(2, "0")}`;
+}
+function transactionsInsert(transactions, typeNames) {
+  for (const tr of transactions) {
+    for (const step of tr.steps) {
+      if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
+        const mark = step.mark;
+        if (mark && typeNames.includes(mark.type.name)) return true;
+        continue;
+      }
+      let found = false;
+      step.slice.content.descendants((node) => {
+        if (found) return false;
+        if (typeNames.includes(node.type.name) || node.marks.some((m) => typeNames.includes(m.type.name))) {
+          found = true;
+        }
+        return !found;
+      });
+      if (found) return true;
+    }
+  }
+  return false;
+}
+function docContains(doc, typeNames) {
+  let found = false;
+  doc.descendants((node) => {
+    if (found) return false;
+    if (typeNames.includes(node.type.name) || node.marks.some((m) => typeNames.includes(m.type.name))) {
+      found = true;
+    }
+    return !found;
+  });
+  return found;
+}
+function presenceStateSpec(typeNames) {
+  return {
+    init: (_config, state) => docContains(state.doc, typeNames),
+    apply: (tr, present, _oldState, newState) => {
+      if (!tr.docChanged) return present;
+      if (!present && !transactionsInsert([tr], typeNames)) return false;
+      return docContains(newState.doc, typeNames);
+    }
+  };
+}
+function arraysEqual(a, b, eq) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!eq(a[i], b[i])) return false;
+  }
+  return true;
+}
+function scrollDomAtPos(view, pos, behavior = "smooth") {
+  try {
+    const dom = view?.nodeDOM?.(pos);
+    if (dom && typeof dom.scrollIntoView === "function") {
+      dom.scrollIntoView({ block: "start", behavior });
+    }
+  } catch {
+  }
+}
+function syncInitialContent(editor, sync) {
+  const { content } = editor.options;
+  if (content == null || content === "") return;
+  try {
+    const doc = createDocument(content, editor.schema, editor.options.parseOptions, {
+      errorOnInvalidContent: false
+    });
+    const tr = sync(EditorState.create({ doc }));
+    if (tr?.docChanged) editor.options.content = tr.doc;
+  } catch {
+  }
+}
+var STRUCTURE_PRIORITY = 45;
+
+// src/extensions/document-structure/outline.ts
+var outlinePluginKey = new PluginKey7("outline");
+var outlineIdPluginKey = new PluginKey7("outlineIds");
+var sameHeading = (a, b) => a.id === b.id && a.level === b.level && a.text === b.text && a.pos === b.pos && a.depth === b.depth;
+function computeOutline(doc, types = ["heading"]) {
+  const headings = [];
+  const stack = [];
+  doc.descendants((node, pos) => {
+    if (types.includes(node.type.name)) {
+      const level = Number(node.attrs.level) || 1;
+      while (stack.length && stack[stack.length - 1] >= level) stack.pop();
+      headings.push({
+        id: node.attrs.id ?? `outline-${headings.length}`,
+        level,
+        text: node.textContent,
+        pos,
+        index: headings.length,
+        depth: stack.length
+      });
+      stack.push(level);
+      return false;
+    }
+    return !node.isTextblock;
+  });
+  return headings;
+}
+function buildOutlineTree(headings) {
+  const root = [];
+  const stack = [];
+  for (const heading of headings) {
+    const item = { ...heading, children: [] };
+    while (stack.length && stack[stack.length - 1].level >= item.level) {
+      stack.pop();
+    }
+    if (stack.length) stack[stack.length - 1].children.push(item);
+    else root.push(item);
+    stack.push(item);
+  }
+  return root;
+}
+function getOutline(editorOrState) {
+  const state = "state" in editorOrState ? editorOrState.state : editorOrState;
+  return outlinePluginKey.getState(state) ?? computeOutline(state.doc);
+}
+function getActiveHeading(editorOrState, headings = getOutline(editorOrState)) {
+  const state = "state" in editorOrState ? editorOrState.state : editorOrState;
+  const head = state.selection.from;
+  let lo = 0;
+  let hi = headings.length - 1;
+  let found = null;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (headings[mid].pos <= head) {
+      found = headings[mid];
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return found;
+}
+function findHeading(state, id) {
+  return getOutline(state).find((h) => h.id === id) ?? null;
+}
+var EMPTY_SNAPSHOT = Object.freeze({
+  headings: [],
+  tree: [],
+  activeId: null
+});
+function createOutlineStore(editor) {
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = EMPTY_SNAPSHOT;
+  const compute = () => {
+    if (!editor || editor.isDestroyed) return EMPTY_SNAPSHOT;
+    const headings = getOutline(editor);
+    const activeId = getActiveHeading(editor, headings)?.id ?? null;
+    const sameStructure = arraysEqual(snapshot.headings, headings, sameHeading);
+    if (sameStructure && snapshot.activeId === activeId) return snapshot;
+    return {
+      headings: sameStructure ? snapshot.headings : headings,
+      tree: sameStructure ? snapshot.tree : buildOutlineTree(headings),
+      activeId
+    };
+  };
+  snapshot = compute();
+  const onTransaction = () => {
+    const next = compute();
+    if (next !== snapshot) {
+      snapshot = next;
+      listeners.forEach((l) => l());
+    }
+  };
+  return {
+    getSnapshot: () => {
+      if (!listeners.size) snapshot = compute();
+      return snapshot;
+    },
+    subscribe(listener) {
+      if (!listeners.size) {
+        snapshot = compute();
+        editor?.on("transaction", onTransaction);
+      }
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (!listeners.size) editor?.off("transaction", onTransaction);
+      };
+    },
+    destroy() {
+      editor?.off("transaction", onTransaction);
+      listeners.clear();
+    }
+  };
+}
+function navigateToHeading(editor, heading, options = {}) {
+  if (!editor || editor.isDestroyed) return false;
+  const current = findHeading(editor.state, heading.id) ?? getOutline(editor).find((h) => h.pos === heading.pos);
+  if (!current) return false;
+  const { focus = true, behavior = "smooth" } = options;
+  if (focus) {
+    const tr = editor.state.tr.setSelection(TextSelection2.create(editor.state.doc, current.pos + 1)).scrollIntoView();
+    editor.view.dispatch(tr);
+    editor.view.focus();
+  }
+  scrollDomAtPos(editor.view, current.pos, behavior);
+  return true;
+}
+function assignHeadingIds(state, types, generateId) {
+  const seen = /* @__PURE__ */ new Set();
+  let tr = null;
+  state.doc.descendants((node, pos) => {
+    if (types.includes(node.type.name)) {
+      let id = node.attrs.id;
+      if (!id || seen.has(id)) {
+        do {
+          id = generateId();
+        } while (seen.has(id));
+        tr = tr ?? state.tr;
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, id });
+      }
+      seen.add(id);
+      return false;
+    }
+    return !node.isTextblock;
+  });
+  return tr;
+}
+var Outline = Extension10.create({
+  name: "outline",
+  priority: STRUCTURE_PRIORITY,
+  addOptions() {
+    return {
+      types: ["heading"],
+      generateId: () => generateStructureId("h"),
+      onUpdate: void 0
+    };
+  },
+  addStorage() {
+    return { headings: [] };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          id: {
+            default: null,
+            keepOnSplit: false,
+            parseHTML: (element) => element.getAttribute("id") || element.getAttribute("data-id"),
+            renderHTML: (attributes) => attributes.id ? { id: attributes.id } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      focusHeading: (id, options = {}) => ({ state, tr, dispatch, view }) => {
+        const heading = findHeading(state, id);
+        if (!heading) return false;
+        if (dispatch) {
+          if (options.focus !== false) {
+            tr.setSelection(TextSelection2.create(tr.doc, heading.pos + 1));
+            tr.scrollIntoView();
+            view?.focus?.();
+          }
+          scrollDomAtPos(view, heading.pos, options.behavior);
+        }
+        return true;
+      },
+      scrollToHeading: (id, options = {}) => ({ state, dispatch, view }) => {
+        const heading = findHeading(state, id);
+        if (!heading) return false;
+        if (dispatch) scrollDomAtPos(view, heading.pos, options.behavior);
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const { types, generateId } = this.options;
+    const storage = this.storage;
+    const onUpdate = () => this.options.onUpdate;
+    return [
+      new Plugin10({
+        key: outlinePluginKey,
+        state: {
+          init: (_config, state) => {
+            const headings = computeOutline(state.doc, types);
+            storage.headings = headings;
+            return headings;
+          },
+          apply: (tr, prev, _oldState, newState) => {
+            if (!tr.docChanged) return prev;
+            const next = computeOutline(newState.doc, types);
+            if (arraysEqual(prev, next, sameHeading)) return prev;
+            storage.headings = next;
+            onUpdate()?.(next);
+            return next;
+          }
+        }
+      }),
+      new Plugin10({
+        key: outlineIdPluginKey,
+        appendTransaction: (transactions, _oldState, newState) => {
+          if (!transactions.some((tr) => tr.docChanged)) return null;
+          return assignHeadingIds(newState, types, generateId);
+        }
+      })
+    ];
+  },
+  onBeforeCreate() {
+    const { types, generateId } = this.options;
+    syncInitialContent(this.editor, (state) => assignHeadingIds(state, types, generateId));
+  }
+});
+
+// src/extensions/document-structure/table-of-contents.ts
+import { Node as Node3, mergeAttributes as mergeAttributes3 } from "@tiptap/core";
+import {
+  Plugin as Plugin11,
+  PluginKey as PluginKey8,
+  TextSelection as TextSelection3
+} from "@tiptap/pm/state";
+
+// src/extensions/document-structure/markdown-it.ts
+var installed = /* @__PURE__ */ new WeakMap();
+function once(md2, name) {
+  let names = installed.get(md2);
+  if (!names) {
+    names = /* @__PURE__ */ new Set();
+    installed.set(md2, names);
+  }
+  if (names.has(name)) return false;
+  names.add(name);
+  return true;
+}
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var TOC_LINE = /^(?:\[\[toc\]\]|\[toc\])\s*$/i;
+function tableOfContentsMarkdownIt(md2) {
+  if (!once(md2, "toc")) return;
+  md2.block.ruler.before(
+    "reference",
+    "pixerate_toc",
+    (state, startLine, _endLine, silent) => {
+      if (state.sCount[startLine] - state.blkIndent >= 4) return false;
+      const start2 = state.bMarks[startLine] + state.tShift[startLine];
+      const line = state.src.slice(start2, state.eMarks[startLine]);
+      if (!TOC_LINE.test(line)) return false;
+      if (silent) return true;
+      const token = state.push("pixerate_toc", "nav", 0);
+      token.block = true;
+      token.map = [startLine, startLine + 1];
+      state.line = startLine + 1;
+      return true;
+    },
+    { alt: ["paragraph", "reference"] }
+  );
+  md2.renderer.rules.pixerate_toc = () => '<nav data-type="table-of-contents"></nav>\n';
+}
+var FOOTNOTE_DEF = /^\[\^([^\]\s]+)\]:[ \t]?(.*)$/;
+function footnotesMarkdownIt(md2) {
+  if (!once(md2, "footnotes")) return;
+  md2.block.ruler.before(
+    "reference",
+    "pixerate_footnote_def",
+    (state, startLine, endLine, silent) => {
+      if (state.sCount[startLine] - state.blkIndent >= 4) return false;
+      const start2 = state.bMarks[startLine] + state.tShift[startLine];
+      const match = FOOTNOTE_DEF.exec(
+        state.src.slice(start2, state.eMarks[startLine])
+      );
+      if (!match) return false;
+      if (silent) return true;
+      const paragraphs = [[match[2]]];
+      let lastContentLine = startLine;
+      let pendingBlank = false;
+      for (let line = startLine + 1; line < endLine; line++) {
+        const lineStart = state.bMarks[line] + state.tShift[line];
+        const lineEnd = state.eMarks[line];
+        if (lineStart >= lineEnd) {
+          pendingBlank = true;
+          continue;
+        }
+        if (state.sCount[line] - state.blkIndent < 4) break;
+        const text = state.src.slice(lineStart, lineEnd);
+        if (pendingBlank) paragraphs.push([text]);
+        else paragraphs[paragraphs.length - 1].push(text);
+        pendingBlank = false;
+        lastContentLine = line;
+      }
+      const open = state.push("pixerate_footnote_open", "li", 1);
+      open.meta = { label: match[1] };
+      open.block = true;
+      open.map = [startLine, lastContentLine + 1];
+      for (const paragraph of paragraphs) {
+        state.push("paragraph_open", "p", 1).block = true;
+        const inline = state.push("inline", "", 0);
+        inline.content = paragraph.join("\n").trim();
+        inline.map = [startLine, lastContentLine + 1];
+        inline.children = [];
+        state.push("paragraph_close", "p", -1).block = true;
+      }
+      state.push("pixerate_footnote_close", "li", -1).block = true;
+      state.line = lastContentLine + 1;
+      return true;
+    },
+    { alt: ["paragraph", "reference"] }
+  );
+  md2.inline.ruler.before("link", "pixerate_footnote_ref", (state, silent) => {
+    const { src, pos, posMax } = state;
+    if (src.charCodeAt(pos) !== 91 || src.charCodeAt(pos + 1) !== 94) {
+      return false;
+    }
+    let end = pos + 2;
+    while (end < posMax && src.charCodeAt(end) !== 93) {
+      if (/\s/.test(src[end])) return false;
+      end++;
+    }
+    if (end >= posMax || end === pos + 2) return false;
+    if (!silent) {
+      const token = state.push("pixerate_footnote_ref", "sup", 0);
+      token.meta = { label: src.slice(pos + 2, end) };
+    }
+    state.pos = end + 1;
+    return true;
+  });
+  md2.renderer.rules.pixerate_footnote_ref = (tokens, idx) => {
+    const label = escapeAttr(tokens[idx].meta.label);
+    return `<sup data-type="footnote-reference" data-id="${label}">${label}</sup>`;
+  };
+  md2.renderer.rules.pixerate_footnote_open = (tokens, idx) => {
+    const label = escapeAttr(tokens[idx].meta.label);
+    return `<section data-type="footnotes"><ol><li data-type="footnote" data-id="${label}">`;
+  };
+  md2.renderer.rules.pixerate_footnote_close = () => "</li></ol></section>\n";
+}
+function mergeFootnoteSections(element) {
+  const sections = Array.from(
+    element.querySelectorAll('section[data-type="footnotes"]')
+  );
+  if (!sections.length) return;
+  const [first, ...rest] = sections;
+  const list = first.querySelector("ol");
+  if (!list) return;
+  for (const section of rest) {
+    section.querySelectorAll('li[data-type="footnote"]').forEach((li) => list.appendChild(li));
+    section.remove();
+  }
+  element.appendChild(first);
+}
+
+// src/extensions/document-structure/table-of-contents.ts
+var tableOfContentsPluginKey = new PluginKey8("tableOfContents");
+var sameEntry = (a, b) => a.id === b.id && a.level === b.level && a.text === b.text && a.depth === b.depth;
+function getTableOfContentsEntries(headings, minLevel = 1, maxLevel = 6) {
+  const entries = [];
+  const stack = [];
+  for (const heading of headings) {
+    if (heading.level < minLevel || heading.level > maxLevel) continue;
+    while (stack.length && stack[stack.length - 1] >= heading.level) stack.pop();
+    entries.push({
+      // Fallback ids (`outline-n`) are not stored on the heading, so they
+      // cannot be linked to.
+      id: heading.id.startsWith("outline-") ? null : heading.id,
+      level: heading.level,
+      text: heading.text,
+      depth: stack.length
+    });
+    stack.push(heading.level);
+  }
+  return entries;
+}
+function syncTableOfContents(state, headingTypes) {
+  const headings = outlinePluginKey.getState(state) ?? computeOutline(state.doc, headingTypes);
+  let tr = null;
+  state.doc.descendants((node, pos) => {
+    if (node.type.name === "tableOfContents") {
+      const entries = getTableOfContentsEntries(
+        headings,
+        node.attrs.minLevel,
+        node.attrs.maxLevel
+      );
+      if (!arraysEqual(node.attrs.entries ?? [], entries, sameEntry)) {
+        tr = tr ?? state.tr;
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, entries });
+      }
+      return false;
+    }
+    return !node.isTextblock;
+  });
+  return tr;
+}
+var TableOfContents = Node3.create({
+  name: "tableOfContents",
+  priority: STRUCTURE_PRIORITY - 5,
+  group: "block",
+  atom: true,
+  selectable: true,
+  draggable: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      headingTypes: ["heading"],
+      defaultTitle: "Contents",
+      emptyText: "Add headings to build the table of contents."
+    };
+  },
+  addAttributes() {
+    return {
+      title: {
+        default: this.options.defaultTitle,
+        parseHTML: (element) => element.getAttribute("data-title") ?? this.options.defaultTitle,
+        renderHTML: (attributes) => ({
+          "data-title": attributes.title
+        })
+      },
+      minLevel: {
+        default: 1,
+        parseHTML: (element) => Number(element.getAttribute("data-min-level")) || 1,
+        renderHTML: (attributes) => ({
+          "data-min-level": attributes.minLevel
+        })
+      },
+      maxLevel: {
+        default: 3,
+        parseHTML: (element) => Number(element.getAttribute("data-max-level")) || 3,
+        renderHTML: (attributes) => ({
+          "data-max-level": attributes.maxLevel
+        })
+      },
+      entries: {
+        default: [],
+        rendered: false,
+        // Entries are derived from the headings and recomputed after parsing.
+        parseHTML: () => []
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'nav[data-type="table-of-contents"]', priority: 60 }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const entries = node.attrs.entries ?? [];
+    const list = entries.length ? [
+      "ol",
+      { class: "toc-list" },
+      ...entries.map((entry) => [
+        "li",
+        {
+          class: "toc-entry",
+          "data-level": entry.level,
+          "data-depth": entry.depth,
+          style: `margin-left: ${entry.depth * 1.25}em`
+        },
+        entry.id ? ["a", { href: `#${entry.id}`, "data-heading-id": entry.id }, entry.text] : ["span", {}, entry.text]
+      ])
+    ] : ["p", { class: "toc-empty" }, this.options.emptyText];
+    return [
+      "nav",
+      mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": "table-of-contents",
+        "aria-label": node.attrs.title || "Table of contents",
+        class: "pixerate-toc"
+      }),
+      ["p", { class: "toc-title" }, node.attrs.title ?? ""],
+      list
+    ];
+  },
+  renderText({ node }) {
+    const entries = node.attrs.entries ?? [];
+    return [node.attrs.title, ...entries.map((e) => `${"  ".repeat(e.depth)}${e.text}`)].filter(Boolean).join("\n");
+  },
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.write("[[toc]]");
+          state.closeBlock(node);
+        },
+        parse: {
+          setup(markdownit2) {
+            tableOfContentsMarkdownIt(markdownit2);
+          }
+        }
+      }
+    };
+  },
+  addCommands() {
+    return {
+      insertTableOfContents: (options = {}) => ({ commands }) => commands.insertContent({
+        type: this.name,
+        attrs: {
+          title: options.title ?? this.options.defaultTitle,
+          minLevel: options.minLevel ?? 1,
+          maxLevel: options.maxLevel ?? 3
+        }
+      })
+    };
+  },
+  addProseMirrorPlugins() {
+    const { headingTypes } = this.options;
+    const editor = this.editor;
+    return [
+      new Plugin11({
+        key: tableOfContentsPluginKey,
+        state: presenceStateSpec([this.name]),
+        appendTransaction: (transactions, _oldState, newState) => {
+          if (!transactions.some((tr) => tr.docChanged)) return null;
+          if (!tableOfContentsPluginKey.getState(newState)) return null;
+          return syncTableOfContents(newState, headingTypes);
+        },
+        props: {
+          handleDOMEvents: {
+            click: (view, event) => {
+              const target = event.target;
+              const link = target?.closest?.(
+                'nav[data-type="table-of-contents"] a[data-heading-id]'
+              );
+              if (!link) return false;
+              event.preventDefault();
+              const id = link.getAttribute("data-heading-id");
+              const heading = (outlinePluginKey.getState(view.state) ?? computeOutline(view.state.doc, headingTypes)).find((h) => h.id === id);
+              if (!heading) return true;
+              if (editor.isEditable) {
+                view.dispatch(
+                  view.state.tr.setSelection(TextSelection3.create(view.state.doc, heading.pos + 1)).scrollIntoView()
+                );
+                view.focus();
+              }
+              scrollDomAtPos(view, heading.pos);
+              return true;
+            }
+          }
+        }
+      })
+    ];
+  },
+  onBeforeCreate() {
+    const { headingTypes } = this.options;
+    syncInitialContent(this.editor, (state) => syncTableOfContents(state, headingTypes));
+  }
+});
+
+// src/extensions/document-structure/footnotes.ts
+import { Node as Node4, mergeAttributes as mergeAttributes4 } from "@tiptap/core";
+import {
+  NodeSelection,
+  Plugin as Plugin12,
+  PluginKey as PluginKey9,
+  TextSelection as TextSelection4
+} from "@tiptap/pm/state";
+var footnotesPluginKey = new PluginKey9("footnotes");
+var REFERENCE = "footnoteReference";
+var LIST = "footnotes";
+var ITEM = "footnote";
+function paragraphsFromText(schema, text) {
+  const parts = text.split(/\n\s*\n/);
+  return parts.map(
+    (part) => schema.nodes.paragraph.create(null, part ? schema.text(part) : void 0)
+  );
+}
+function footnoteText(node) {
+  const parts = [];
+  node.forEach((child) => parts.push(child.textContent));
+  return parts.join("\n\n");
+}
+function getFootnotes(doc) {
+  const footnotes = /* @__PURE__ */ new Map();
+  const refs = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name === LIST) {
+      node.forEach((child, offset) => {
+        if (child.type.name === ITEM && !footnotes.has(child.attrs.id)) {
+          footnotes.set(child.attrs.id, { node: child, pos: pos + 1 + offset });
+        }
+      });
+      return false;
+    }
+    if (node.type.name === REFERENCE) refs.push({ id: node.attrs.id, pos });
+    return true;
+  });
+  return refs.map((ref, index) => {
+    const footnote = footnotes.get(ref.id);
+    return {
+      id: ref.id,
+      number: index + 1,
+      text: footnote ? footnoteText(footnote.node) : "",
+      referencePos: ref.pos,
+      footnotePos: footnote?.pos ?? null
+    };
+  });
+}
+function syncFootnotes(tr, options = {}) {
+  const schema = tr.doc.type.schema;
+  const listType = schema.nodes[LIST];
+  const itemType = schema.nodes[ITEM];
+  if (!listType || !itemType) return false;
+  const generateId = options.generateId ?? (() => generateStructureId("fn"));
+  const refs = [];
+  const lists = [];
+  const existing = /* @__PURE__ */ new Map();
+  tr.doc.descendants((node, pos) => {
+    if (node.type === listType) {
+      lists.push({ node, pos });
+      node.forEach((child) => {
+        if (child.type === itemType && !existing.has(child.attrs.id)) {
+          existing.set(child.attrs.id, child);
+        }
+      });
+      return false;
+    }
+    if (node.type.name === REFERENCE) refs.push({ node, pos });
+    return true;
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const desiredRefs = [];
+  refs.forEach((ref, index) => {
+    let id = ref.node.attrs.id;
+    let copyOf;
+    if (!id || seen.has(id)) {
+      copyOf = id || void 0;
+      do {
+        id = generateId();
+      } while (seen.has(id) || existing.has(id));
+    }
+    seen.add(id);
+    desiredRefs.push({ pos: ref.pos, id, number: index + 1, copyOf });
+  });
+  const desiredItems = desiredRefs.map(({ id, number, copyOf }) => {
+    const source = existing.get(id) ?? (copyOf ? existing.get(copyOf) : void 0);
+    const content = source?.content ?? paragraphsFromText(schema, options.contents?.[id] ?? "");
+    if (source && source.attrs.id === id && source.attrs.number === number) {
+      return source;
+    }
+    return itemType.create({ id, number }, content);
+  });
+  const refsInSync = desiredRefs.every(
+    (d, i) => refs[i].node.attrs.id === d.id && refs[i].node.attrs.number === d.number
+  );
+  const lastChild = tr.doc.lastChild;
+  const listInSync = desiredItems.length ? lists.length === 1 && lastChild === lists[0].node && lists[0].node.childCount === desiredItems.length && desiredItems.every((item, i) => lists[0].node.child(i) === item) : lists.length === 0;
+  if (refsInSync && listInSync) return false;
+  desiredRefs.forEach((d, i) => {
+    const node = refs[i].node;
+    if (node.attrs.id !== d.id || node.attrs.number !== d.number) {
+      tr.setNodeMarkup(d.pos, void 0, { ...node.attrs, id: d.id, number: d.number });
+    }
+  });
+  if (!listInSync) {
+    for (let i = lists.length - 1; i >= 0; i--) {
+      tr.delete(lists[i].pos, lists[i].pos + lists[i].node.nodeSize);
+    }
+    if (desiredItems.length) {
+      tr.insert(tr.doc.content.size, listType.create(null, desiredItems));
+    }
+  }
+  return true;
+}
+function findFootnote(doc, id) {
+  let found = null;
+  doc.descendants((node, pos) => {
+    if (found) return false;
+    if (node.type.name === ITEM && node.attrs.id === id) {
+      found = { node, pos };
+      return false;
+    }
+    return true;
+  });
+  return found;
+}
+function findReferences(doc, id) {
+  const refs = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name === LIST) return false;
+    if (node.type.name === REFERENCE && node.attrs.id === id) refs.push({ node, pos });
+    return true;
+  });
+  return refs;
+}
+var FootnoteReference = Node4.create({
+  name: REFERENCE,
+  priority: STRUCTURE_PRIORITY - 5,
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      generateId: () => generateStructureId("fn")
+    };
+  },
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-id"),
+        renderHTML: (attributes) => attributes.id ? { "data-id": attributes.id } : {}
+      },
+      number: {
+        default: null,
+        parseHTML: (element) => Number(element.getAttribute("data-number")) || null,
+        renderHTML: (attributes) => attributes.number ? { "data-number": attributes.number } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'sup[data-type="footnote-reference"]', priority: 60 }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const id = node.attrs.id;
+    return [
+      "sup",
+      mergeAttributes4(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": "footnote-reference",
+        class: "pixerate-footnote-ref",
+        ...id ? { id: `fnref-${id}` } : {}
+      }),
+      ["a", id ? { href: `#fn-${id}` } : {}, String(node.attrs.number ?? "")]
+    ];
+  },
+  renderText({ node }) {
+    return `[${node.attrs.number ?? ""}]`;
+  },
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.write(`[^${node.attrs.number ?? node.attrs.id}]`);
+        },
+        parse: {
+          setup(markdownit2) {
+            footnotesMarkdownIt(markdownit2);
+          },
+          updateDOM(element) {
+            mergeFootnoteSections(element);
+          }
+        }
+      }
+    };
+  },
+  addCommands() {
+    return {
+      insertFootnote: (options = {}) => ({ state, tr, dispatch }) => {
+        const type = state.schema.nodes[REFERENCE];
+        if (!type || !state.schema.nodes[ITEM]) return false;
+        const { $from } = state.selection;
+        for (let d = $from.depth; d > 0; d--) {
+          if ($from.node(d).type.name === LIST) return false;
+        }
+        if (!$from.parent.inlineContent) return false;
+        if (!dispatch) return true;
+        const id = options.id ?? this.options.generateId();
+        tr.replaceSelectionWith(type.create({ id }), false);
+        syncFootnotes(tr, {
+          generateId: this.options.generateId,
+          contents: options.content ? { [id]: options.content } : void 0
+        });
+        const focusContent = options.focusContent ?? !options.content;
+        if (focusContent) {
+          const footnote = findFootnote(tr.doc, id);
+          if (footnote) {
+            tr.setSelection(TextSelection4.create(tr.doc, footnote.pos + 2));
+          }
+        }
+        tr.scrollIntoView();
+        return true;
+      },
+      updateFootnote: (id, content) => ({ state, tr, dispatch }) => {
+        const footnote = findFootnote(state.doc, id);
+        if (!footnote) return false;
+        if (dispatch) {
+          tr.replaceWith(
+            footnote.pos + 1,
+            footnote.pos + footnote.node.nodeSize - 1,
+            paragraphsFromText(state.schema, content)
+          );
+        }
+        return true;
+      },
+      deleteFootnote: (id) => ({ state, tr, dispatch }) => {
+        const refs = findReferences(state.doc, id);
+        const footnote = findFootnote(state.doc, id);
+        if (!refs.length && !footnote) return false;
+        if (dispatch) {
+          for (let i = refs.length - 1; i >= 0; i--) {
+            tr.delete(refs[i].pos, refs[i].pos + refs[i].node.nodeSize);
+          }
+          syncFootnotes(tr, { generateId: this.options.generateId });
+        }
+        return true;
+      },
+      goToFootnote: (id) => ({ state, tr, dispatch, view }) => {
+        const footnote = findFootnote(state.doc, id);
+        if (!footnote) return false;
+        if (dispatch) {
+          tr.setSelection(
+            TextSelection4.create(tr.doc, footnote.pos + footnote.node.nodeSize - 2)
+          );
+          tr.scrollIntoView();
+          scrollDomAtPos(view, footnote.pos);
+        }
+        return true;
+      },
+      goToFootnoteReference: (id) => ({ state, tr, dispatch, view }) => {
+        const [ref] = findReferences(state.doc, id);
+        if (!ref) return false;
+        if (dispatch) {
+          tr.setSelection(NodeSelection.create(tr.doc, ref.pos));
+          tr.scrollIntoView();
+          scrollDomAtPos(view, ref.pos);
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const generateId = this.options.generateId;
+    const editor = this.editor;
+    return [
+      new Plugin12({
+        key: footnotesPluginKey,
+        state: presenceStateSpec([REFERENCE, LIST]),
+        appendTransaction: (transactions, _oldState, newState) => {
+          if (!transactions.some((tr2) => tr2.docChanged)) return null;
+          if (!footnotesPluginKey.getState(newState)) return null;
+          const tr = newState.tr;
+          return syncFootnotes(tr, { generateId }) ? tr : null;
+        },
+        props: {
+          handleClickOn: (_view, _pos, node, _nodePos, event) => {
+            if (node.type.name !== REFERENCE || !node.attrs.id) return false;
+            const target = event.target;
+            if (!target?.closest?.("a")) return false;
+            event.preventDefault();
+            return editor.commands.goToFootnote(node.attrs.id);
+          }
+        }
+      })
+    ];
+  },
+  onBeforeCreate() {
+    const { generateId } = this.options;
+    syncInitialContent(this.editor, (state) => {
+      const tr = state.tr;
+      return syncFootnotes(tr, { generateId }) ? tr : null;
+    });
+  }
+});
+var Footnotes = Node4.create({
+  name: LIST,
+  group: "block",
+  content: `${ITEM}+`,
+  isolating: true,
+  selectable: false,
+  draggable: false,
+  parseHTML() {
+    return [{ tag: 'section[data-type="footnotes"]', contentElement: "ol", priority: 60 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "section",
+      mergeAttributes4(HTMLAttributes, {
+        "data-type": "footnotes",
+        class: "pixerate-footnotes",
+        role: "doc-endnotes"
+      }),
+      ["ol", 0]
+    ];
+  },
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          node.forEach((footnote) => {
+            const label = footnote.attrs.number ?? footnote.attrs.id;
+            state.wrapBlock(
+              "    ",
+              `[^${label}]: `,
+              footnote,
+              () => state.renderContent(footnote)
+            );
+          });
+        },
+        parse: {}
+      }
+    };
+  }
+});
+var Footnote = Node4.create({
+  name: ITEM,
+  content: "paragraph+",
+  isolating: true,
+  defining: true,
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-id"),
+        renderHTML: (attributes) => attributes.id ? { "data-id": attributes.id, id: `fn-${attributes.id}` } : {}
+      },
+      number: {
+        default: null,
+        parseHTML: (element) => Number(element.getAttribute("data-number")) || null,
+        renderHTML: (attributes) => attributes.number ? { "data-number": attributes.number } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'li[data-type="footnote"]', priority: 60 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "li",
+      mergeAttributes4(HTMLAttributes, {
+        "data-type": "footnote",
+        class: "pixerate-footnote"
+      }),
+      0
+    ];
+  },
+  addKeyboardShortcuts() {
+    const atFootnoteStart = () => {
+      const { selection } = this.editor.state;
+      if (!selection.empty) return false;
+      const { $from } = selection;
+      if ($from.parentOffset !== 0 || $from.depth < 2) return false;
+      const footnote = $from.node($from.depth - 1);
+      return footnote.type.name === ITEM && $from.index($from.depth - 1) === 0;
+    };
+    return {
+      Backspace: () => atFootnoteStart()
+    };
+  }
+});
+
+// src/extensions/document-structure/bookmarks.ts
+import { Mark as Mark4, mergeAttributes as mergeAttributes5 } from "@tiptap/core";
+import { TextSelection as TextSelection5 } from "@tiptap/pm/state";
+var BOOKMARK = "bookmark";
+function getBookmarks(doc) {
+  const byId = /* @__PURE__ */ new Map();
+  doc.descendants((node, pos) => {
+    if (!node.isText) return true;
+    for (const mark of node.marks) {
+      if (mark.type.name !== BOOKMARK || !mark.attrs.id) continue;
+      const end = pos + node.nodeSize;
+      const existing = byId.get(mark.attrs.id);
+      if (existing) {
+        existing.text += (existing.to === pos ? "" : " ") + node.text;
+        existing.to = end;
+      } else {
+        byId.set(mark.attrs.id, {
+          id: mark.attrs.id,
+          name: mark.attrs.name ?? mark.attrs.id,
+          text: node.text ?? "",
+          from: pos,
+          to: end
+        });
+      }
+    }
+    return false;
+  });
+  return Array.from(byId.values());
+}
+function forEachBookmarkRange(doc, id, fn) {
+  doc.descendants((node, pos) => {
+    if (!node.isText) return true;
+    const mark = node.marks.find(
+      (m) => m.type.name === BOOKMARK && m.attrs.id === id
+    );
+    if (mark) fn(pos, pos + node.nodeSize, mark);
+    return false;
+  });
+}
+var Bookmark = Mark4.create({
+  name: BOOKMARK,
+  inclusive: false,
+  excludes: "",
+  spanning: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      generateId: () => generateStructureId("bm")
+    };
+  },
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-bookmark-id"),
+        renderHTML: (attributes) => attributes.id ? { "data-bookmark-id": attributes.id } : {}
+      },
+      name: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-bookmark-name"),
+        renderHTML: (attributes) => attributes.name ? { "data-bookmark-name": attributes.name } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-bookmark-id]", priority: 60 }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes5(this.options.HTMLAttributes, HTMLAttributes, {
+        class: "pixerate-bookmark"
+      }),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      setBookmark: ({ name, id }) => ({ state, tr, dispatch }) => {
+        const type = state.schema.marks[BOOKMARK];
+        if (!type || !name) return false;
+        let { from, to } = state.selection;
+        if (from === to) {
+          const { $from } = state.selection;
+          const text = $from.parent.textBetween(0, $from.parent.content.size, void 0, "\uFFFC");
+          let start2 = $from.parentOffset;
+          let end = $from.parentOffset;
+          while (start2 > 0 && /[\p{L}\p{N}_'-]/u.test(text[start2 - 1])) start2--;
+          while (end < text.length && /[\p{L}\p{N}_'-]/u.test(text[end])) end++;
+          if (start2 === end) return false;
+          from = $from.start() + start2;
+          to = $from.start() + end;
+        }
+        if (!dispatch) return true;
+        const sameName = getBookmarks(state.doc).find((b) => b.name === name);
+        const bookmarkId = id ?? sameName?.id ?? this.options.generateId();
+        if (sameName) {
+          forEachBookmarkRange(
+            tr.doc,
+            sameName.id,
+            (f, t, mark) => tr.removeMark(f, t, mark)
+          );
+        }
+        tr.addMark(from, to, type.create({ id: bookmarkId, name }));
+        return true;
+      },
+      removeBookmark: (id) => ({ state, tr, dispatch }) => {
+        let found = false;
+        forEachBookmarkRange(state.doc, id, (from, to, mark) => {
+          found = true;
+          if (dispatch) tr.removeMark(from, to, mark);
+        });
+        return found;
+      },
+      renameBookmark: (id, name) => ({ state, tr, dispatch }) => {
+        let found = false;
+        forEachBookmarkRange(state.doc, id, (from, to, mark) => {
+          found = true;
+          if (dispatch) {
+            tr.removeMark(from, to, mark);
+            tr.addMark(from, to, mark.type.create({ ...mark.attrs, name }));
+          }
+        });
+        return found;
+      },
+      goToBookmark: (id) => ({ state, tr, dispatch, view }) => {
+        const bookmark = getBookmarks(state.doc).find((b) => b.id === id);
+        if (!bookmark) return false;
+        if (dispatch) {
+          tr.setSelection(TextSelection5.create(tr.doc, bookmark.from, bookmark.to));
+          tr.scrollIntoView();
+          const domPos = state.doc.resolve(bookmark.from);
+          scrollDomAtPos(view, domPos.before(domPos.depth));
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// src/extensions/document-structure/cross-reference.ts
+import { Node as Node5, mergeAttributes as mergeAttributes6 } from "@tiptap/core";
+import {
+  Plugin as Plugin13,
+  PluginKey as PluginKey10,
+  TextSelection as TextSelection6
+} from "@tiptap/pm/state";
+var crossReferencePluginKey = new PluginKey10("crossReference");
+var NAME = "crossReference";
+function getCrossReferenceTargets(doc, headingTypes = ["heading"]) {
+  const headings = computeOutline(doc, headingTypes).filter((h) => !h.id.startsWith("outline-")).map((h) => ({ type: "heading", id: h.id, text: h.text, name: h.text, level: h.level }));
+  const bookmarks = getBookmarks(doc).map((b) => ({
+    type: "bookmark",
+    id: b.id,
+    text: b.text,
+    name: b.name
+  }));
+  return [...headings, ...bookmarks];
+}
+function syncCrossReferences(state, headingTypes) {
+  let lookup = null;
+  const resolve = () => {
+    if (!lookup) {
+      const next = { targets: /* @__PURE__ */ new Map(), headingsByText: /* @__PURE__ */ new Map() };
+      for (const t of getCrossReferenceTargets(state.doc, headingTypes)) {
+        next.targets.set(`${t.type}:${t.id}`, t);
+        if (t.type === "heading" && !next.headingsByText.has(t.text)) {
+          next.headingsByText.set(t.text, t);
+        }
+      }
+      lookup = next;
+    }
+    return lookup;
+  };
+  let tr = null;
+  state.doc.descendants((node, pos) => {
+    if (node.type.name !== NAME) return true;
+    const { targets, headingsByText } = resolve();
+    const { targetType } = node.attrs;
+    let { targetId } = node.attrs;
+    let target = targets.get(`${targetType}:${targetId}`);
+    if (!target && targetType === "heading" && node.attrs.label) {
+      target = headingsByText.get(node.attrs.label);
+      if (target) targetId = target.id;
+    }
+    const label = target ? target.text : node.attrs.label;
+    const broken = !target;
+    if (label !== node.attrs.label || broken !== node.attrs.broken || targetId !== node.attrs.targetId) {
+      tr = tr ?? state.tr;
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, targetId, label, broken });
+    }
+    return false;
+  });
+  return tr;
+}
+var CrossReference = Node5.create({
+  name: NAME,
+  priority: STRUCTURE_PRIORITY - 5,
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      headingTypes: ["heading"],
+      brokenText: "Error! Reference source not found."
+    };
+  },
+  addAttributes() {
+    return {
+      targetType: {
+        default: "heading",
+        parseHTML: (element) => element.getAttribute("data-target-type") ?? "heading",
+        renderHTML: (attributes) => ({
+          "data-target-type": attributes.targetType
+        })
+      },
+      targetId: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-target-id"),
+        renderHTML: (attributes) => attributes.targetId ? { "data-target-id": attributes.targetId } : {}
+      },
+      label: {
+        default: "",
+        parseHTML: (element) => element.getAttribute("data-label") ?? element.textContent ?? "",
+        renderHTML: (attributes) => ({
+          "data-label": attributes.label
+        })
+      },
+      broken: {
+        default: false,
+        parseHTML: (element) => element.hasAttribute("data-broken"),
+        renderHTML: (attributes) => attributes.broken ? { "data-broken": "true" } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'a[data-type="cross-reference"]', priority: 60 }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const { targetType, targetId, broken, label } = node.attrs;
+    const href = !broken && targetType === "heading" && targetId ? { href: `#${targetId}` } : {};
+    return [
+      "a",
+      mergeAttributes6(this.options.HTMLAttributes, HTMLAttributes, href, {
+        "data-type": "cross-reference",
+        class: broken ? "pixerate-cross-reference is-broken" : "pixerate-cross-reference"
+      }),
+      broken ? this.options.brokenText : label
+    ];
+  },
+  renderText({ node }) {
+    return node.attrs.broken ? this.options.brokenText : node.attrs.label;
+  },
+  addCommands() {
+    return {
+      insertCrossReference: ({ targetType, targetId }) => ({ state, tr, dispatch }) => {
+        const type = state.schema.nodes[NAME];
+        if (!type || !state.selection.$from.parent.inlineContent) return false;
+        const target = getCrossReferenceTargets(state.doc, this.options.headingTypes).find(
+          (t) => t.type === targetType && t.id === targetId
+        );
+        if (!target) return false;
+        if (dispatch) {
+          tr.replaceSelectionWith(
+            type.create({ targetType, targetId, label: target.text, broken: false }),
+            false
+          );
+        }
+        return true;
+      },
+      followCrossReference: (pos) => ({ state, tr, dispatch, view }) => {
+        const node = pos != null ? state.doc.nodeAt(pos) : state.selection.node ?? null;
+        if (!node || node.type.name !== NAME || node.attrs.broken) return false;
+        const { targetType, targetId } = node.attrs;
+        let range = null;
+        if (targetType === "bookmark") {
+          const bookmark = getBookmarks(state.doc).find((b) => b.id === targetId);
+          if (bookmark) {
+            const $from = state.doc.resolve(bookmark.from);
+            range = {
+              from: bookmark.from,
+              to: bookmark.to,
+              blockPos: $from.before($from.depth)
+            };
+          }
+        } else {
+          const heading = computeOutline(state.doc, this.options.headingTypes).find(
+            (h) => h.id === targetId
+          );
+          if (heading) {
+            range = { from: heading.pos + 1, to: heading.pos + 1, blockPos: heading.pos };
+          }
+        }
+        if (!range) return false;
+        if (dispatch) {
+          tr.setSelection(TextSelection6.create(tr.doc, range.from, range.to));
+          tr.scrollIntoView();
+          scrollDomAtPos(view, range.blockPos);
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const { headingTypes } = this.options;
+    const editor = this.editor;
+    return [
+      new Plugin13({
+        key: crossReferencePluginKey,
+        state: presenceStateSpec([NAME]),
+        appendTransaction: (transactions, _oldState, newState) => {
+          if (!transactions.some((tr) => tr.docChanged)) return null;
+          if (!crossReferencePluginKey.getState(newState)) return null;
+          return syncCrossReferences(newState, headingTypes);
+        },
+        props: {
+          handleClickOn: (_view, _pos, node, nodePos, event) => {
+            if (node.type.name !== NAME) return false;
+            if (editor.isEditable && !(event.metaKey || event.ctrlKey)) return false;
+            event.preventDefault();
+            return editor.commands.followCrossReference(nodePos);
+          }
+        }
+      })
+    ];
+  },
+  onBeforeCreate() {
+    const { headingTypes } = this.options;
+    syncInitialContent(this.editor, (state) => syncCrossReferences(state, headingTypes));
+  }
+});
+
+// src/extensions/document-structure/command-items.ts
+var start = (editor, args) => {
+  const chain = editor.chain().focus();
+  return args?.range ? chain.deleteRange(args.range) : chain;
+};
+var documentStructureCommandItems = [
+  {
+    id: "table-of-contents",
+    title: "Table of contents",
+    description: "Insert a linked list of the document's headings",
+    keywords: ["toc", "contents", "outline", "index"],
+    extension: "tableOfContents",
+    run: (editor, args) => start(editor, args).insertTableOfContents().run()
+  },
+  {
+    id: "footnote",
+    title: "Footnote",
+    description: "Insert a numbered footnote",
+    keywords: ["footnote", "note", "fn", "citation"],
+    extension: "footnoteReference",
+    run: (editor, args) => start(editor, args).insertFootnote({ content: args?.content }).run()
+  },
+  {
+    id: "bookmark",
+    title: "Bookmark",
+    description: "Name the selected text or word so it can be referenced",
+    keywords: ["bookmark", "anchor", "name"],
+    extension: "bookmark",
+    requires: "name",
+    run: (editor, args) => !!args?.name && start(editor, args).setBookmark({ name: args.name }).run()
+  },
+  {
+    id: "cross-reference",
+    title: "Cross-reference",
+    description: "Insert a live reference to a heading or bookmark",
+    keywords: ["cross", "reference", "xref", "link", "ref"],
+    extension: "crossReference",
+    requires: "target",
+    run: (editor, args) => !!args?.targetType && !!args.targetId && start(editor, args).insertCrossReference({ targetType: args.targetType, targetId: args.targetId }).run()
+  }
+];
+function getDocumentStructureCommandItems(editor, query = "") {
+  if (!editor) return [];
+  const installed2 = new Set(
+    editor.extensionManager.extensions.map((extension) => extension.name)
+  );
+  const q = query.trim().toLowerCase();
+  return documentStructureCommandItems.filter(
+    (item) => installed2.has(item.extension) && (!q || item.title.toLowerCase().includes(q) || item.keywords.some((k) => k.startsWith(q)))
+  );
+}
+
+// src/extensions/rich-text-preset.ts
+var resolveExt3 = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
+var StarterKit = resolveExt3(_StarterKit, "StarterKit");
+var Color = resolveExt3(_Color, "Color");
+var Highlight = resolveExt3(_Highlight, "Highlight");
+var Link2 = resolveExt3(_Link, "Link");
+var TaskList2 = resolveExt3(_TaskList, "TaskList");
+var TaskItem2 = resolveExt3(_TaskItem, "TaskItem");
+var TextAlign = resolveExt3(_TextAlign, "TextAlign");
+var TextStyle = resolveExt3(_TextStyle, "TextStyle");
+var Typography = resolveExt3(_Typography, "Typography");
+var Underline = resolveExt3(_Underline, "Underline");
+var Placeholder = resolveExt3(_Placeholder, "Placeholder");
+var CharacterCount = resolveExt3(_CharacterCount, "CharacterCount");
+var optionObject = (value) => typeof value === "object" && value !== null ? value : {};
+function createRichTextPreset(options = {}) {
+  const {
+    placeholder = "Start typing...",
+    characterLimit,
+    openLinksOnClick = false,
+    enableSmilies = true,
+    enableColorHighlighter = true,
+    headingLevels = [1, 2, 3, 4]
+  } = options;
+  const extensions2 = [
+    StarterKit.configure({
+      orderedList: {
+        HTMLAttributes: {
+          class: "list-decimal pl-4"
+        }
+      },
+      bulletList: {
+        HTMLAttributes: {
+          class: "list-disc pl-4"
+        }
+      },
+      heading: {
+        levels: headingLevels,
+        HTMLAttributes: {
+          class: "font-bold tracking-tight"
+        }
+      }
+    }),
+    TextStyle,
+    Color,
+    Highlight.configure({ multicolor: true }),
+    Underline,
+    ...options.autocorrect ? [] : [Typography],
+    TextAlign.configure({
+      types: ["heading", "paragraph"]
+    }),
+    Link2.extend({
+      addInputRules() {
+        return [
+          markInputRule({
+            find: /(?:^|\s)\[([^\]]+)\]\(([^)]+)\)$/,
+            type: this.type,
+            getAttributes: (match) => ({
+              href: match[2]
+            })
+          })
+        ];
+      }
+    }).configure({
+      openOnClick: openLinksOnClick,
+      autolink: true,
+      defaultProtocol: "https",
+      protocols: ["file", "vscode", "cursor"],
+      HTMLAttributes: {
+        target: "_blank",
+        rel: "noopener noreferrer",
+        class: "text-blue-500 underline underline-offset-2"
+      }
+    }),
+    TaskList2,
+    TaskItem2.extend({
+      addInputRules() {
+        return [
+          wrappingInputRule({
+            find: /^\s*(\[([ |x])?\])\s$/i,
+            type: this.type,
+            getAttributes: (match) => ({
+              checked: match[2]?.toLowerCase() === "x"
+            })
+          })
+        ];
+      }
+    }).configure({
+      nested: true
+    }),
+    FontSize,
+    Placeholder.configure({
+      emptyEditorClass: "is-empty",
+      placeholder: typeof placeholder === "function" ? placeholder : () => placeholder
+    })
+  ];
+  if (characterLimit) {
+    extensions2.push(
+      CharacterCount.configure({
+        limit: characterLimit
+      })
+    );
+  }
+  if (enableSmilies) {
+    extensions2.push(SmilieReplacer);
+  }
+  if (enableColorHighlighter) {
+    extensions2.push(ColorHighlighter);
+  }
+  if (options.mention) {
+    const mentionConfig = typeof options.mention === "object" ? options.mention : {};
+    extensions2.push(
+      Mention.configure({
+        HTMLAttributes: {
+          class: "pixerate-mention-node",
+          ...mentionConfig.HTMLAttributes || {}
+        },
+        ...mentionConfig
+      })
+    );
+  }
+  if (options.markdown) {
+    const markdownConfig = typeof options.markdown === "object" ? options.markdown : {};
+    extensions2.push(
+      Markdown2.configure({
+        html: true,
+        tightLists: true,
+        tightListClass: "tight",
+        bulletListMarker: "-",
+        linkify: true,
+        breaks: true,
+        transformPastedText: true,
+        transformCopiedText: true,
+        ...markdownConfig
+      })
+    );
+  }
+  if (options.image !== false) {
+    const imageConfig = typeof options.image === "object" ? options.image : {};
+    extensions2.push(
+      Image2.configure({
+        HTMLAttributes: {
+          class: "rounded-md max-w-full h-auto my-2",
+          ...imageConfig.HTMLAttributes || {}
+        },
+        ...imageConfig
+      })
+    );
+  }
+  if (options.comments) {
+    extensions2.push(
+      typeof options.comments === "object" ? Comments.configure(options.comments) : Comments
+    );
+  }
+  if (options.trackChanges) {
+    extensions2.push(
+      typeof options.trackChanges === "object" ? TrackChanges.configure(options.trackChanges) : TrackChanges
+    );
+  }
+  if (options.fileImport) {
+    extensions2.push(
+      FileImport.configure(
+        typeof options.fileImport === "object" ? options.fileImport : {}
+      )
+    );
+  }
+  if (options.richClipboard) {
+    extensions2.push(
+      RichClipboard.configure(
+        typeof options.richClipboard === "object" ? options.richClipboard : {}
+      )
+    );
+  }
+  if (options.autocorrect) {
+    extensions2.push(Autocorrect.configure(optionObject(options.autocorrect)));
+  }
+  if (options.outline || options.tableOfContents || options.crossReferences) {
+    extensions2.push(Outline.configure(optionObject(options.outline)));
+  }
+  if (options.tableOfContents) {
+    extensions2.push(TableOfContents.configure(optionObject(options.tableOfContents)));
+  }
+  if (options.footnotes) {
+    extensions2.push(
+      FootnoteReference.configure(optionObject(options.footnotes)),
+      Footnotes,
+      Footnote
+    );
+  }
+  if (options.bookmarks) {
+    extensions2.push(Bookmark.configure(optionObject(options.bookmarks)));
+  }
+  if (options.crossReferences) {
+    extensions2.push(CrossReference.configure(optionObject(options.crossReferences)));
+  }
+  return extensions2;
+}
+
+export {
+  GradientText,
+  SlashCommands,
+  TemplateSuggestions,
+  LoadingNode,
+  SMILIE_REPLACEMENTS,
+  smilieAutocorrectRules,
+  SmilieReplacer,
+  findHexColors,
+  ColorHighlighter,
+  FontSize,
+  Mention,
+  createMentionExtension,
+  Markdown2 as Markdown,
+  imagePastePluginKey,
+  insertImageNode,
+  updateImageSrc,
+  removeImageNode,
+  handleImageInsertion,
+  Image2 as Image,
+  commentsPluginKey,
+  COMMENT_MARK_NAME,
+  findCommentRanges,
+  getCommentAnchors,
+  getCommentIdsAt,
+  getCommentStore,
+  Comments,
+  getCommentAuthor,
+  ImportError,
+  createImportContext,
+  ImportAdapterRegistry,
+  markdownImportAdapter,
+  htmlImportAdapter,
+  plainTextImportAdapter,
+  rtfImportAdapter,
+  BUILT_IN_IMPORT_ADAPTERS,
+  createImportAdapterRegistry,
+  defaultImportRegistry,
+  registerImportAdapter,
+  unregisterImportAdapter,
+  findImportAdapter,
+  importFile,
+  getImportAccept,
+  htmlToSlice,
+  insertImportedDocument,
+  importFilesIntoEditor,
+  fileImportPluginKey,
+  FileImport,
+  richClipboardPluginKey,
+  writeRichClipboard,
+  RichClipboard,
+  smartQuoteRules,
+  symbolRules,
+  fractionRules,
+  capitalizeSentenceRules,
+  twoInitialCapitalsRules,
+  defaultAutocorrectRules,
+  DEFAULT_AUTOCORRECT_EXCEPTIONS,
+  autocorrectPluginKey,
+  findAutocorrection,
+  isInsidePromptToken,
+  Autocorrect,
+  outlinePluginKey,
+  computeOutline,
+  buildOutlineTree,
+  getOutline,
+  getActiveHeading,
+  createOutlineStore,
+  navigateToHeading,
+  Outline,
+  tableOfContentsMarkdownIt,
+  footnotesMarkdownIt,
+  tableOfContentsPluginKey,
+  getTableOfContentsEntries,
+  TableOfContents,
+  footnotesPluginKey,
+  getFootnotes,
+  syncFootnotes,
+  FootnoteReference,
+  Footnotes,
+  Footnote,
+  getBookmarks,
+  Bookmark,
+  crossReferencePluginKey,
+  getCrossReferenceTargets,
+  CrossReference,
+  documentStructureCommandItems,
+  getDocumentStructureCommandItems,
+  createRichTextPreset
+};
+//# sourceMappingURL=chunk-CYFJCKC4.js.map