@threadlabs/looma 0.1.0 → 0.1.2

package/editor/chunk-YGJLGDQC.js

@@ -0,0 +1,4010 @@
+// ../../node_modules/.pnpm/@tiptap+extension-document@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-document/dist/index.js
+import { Node } from "@tiptap/core";
+var Document = Node.create({
+  name: "doc",
+  topNode: true,
+  content: "block+"
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-paragraph@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-paragraph/dist/index.js
+import { Node as Node2, mergeAttributes } from "@tiptap/core";
+var Paragraph = Node2.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [
+      { tag: "p" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["p", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands }) => {
+        return commands.setNode(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-text@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-text/dist/index.js
+import { Node as Node3 } from "@tiptap/core";
+var Text = Node3.create({
+  name: "text",
+  group: "inline"
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-bold@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-bold/dist/index.js
+import { Mark, mergeAttributes as mergeAttributes2, markInputRule, markPasteRule } from "@tiptap/core";
+var starInputRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
+var starPasteRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
+var underscoreInputRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
+var underscorePasteRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
+var Bold = Mark.create({
+  name: "bold",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "strong"
+      },
+      {
+        tag: "b",
+        getAttrs: (node) => node.style.fontWeight !== "normal" && null
+      },
+      {
+        style: "font-weight=400",
+        clearMark: (mark) => mark.type.name === this.name
+      },
+      {
+        style: "font-weight",
+        getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["strong", mergeAttributes2(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setBold: () => ({ commands }) => {
+        return commands.setMark(this.name);
+      },
+      toggleBold: () => ({ commands }) => {
+        return commands.toggleMark(this.name);
+      },
+      unsetBold: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-b": () => this.editor.commands.toggleBold(),
+      "Mod-B": () => this.editor.commands.toggleBold()
+    };
+  },
+  addInputRules() {
+    return [
+      markInputRule({
+        find: starInputRegex,
+        type: this.type
+      }),
+      markInputRule({
+        find: underscoreInputRegex,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      markPasteRule({
+        find: starPasteRegex,
+        type: this.type
+      }),
+      markPasteRule({
+        find: underscorePasteRegex,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-italic@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-italic/dist/index.js
+import { Mark as Mark2, mergeAttributes as mergeAttributes3, markInputRule as markInputRule2, markPasteRule as markPasteRule2 } from "@tiptap/core";
+var starInputRegex2 = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/;
+var starPasteRegex2 = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g;
+var underscoreInputRegex2 = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/;
+var underscorePasteRegex2 = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g;
+var Italic = Mark2.create({
+  name: "italic",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "em"
+      },
+      {
+        tag: "i",
+        getAttrs: (node) => node.style.fontStyle !== "normal" && null
+      },
+      {
+        style: "font-style=normal",
+        clearMark: (mark) => mark.type.name === this.name
+      },
+      {
+        style: "font-style=italic"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["em", mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setItalic: () => ({ commands }) => {
+        return commands.setMark(this.name);
+      },
+      toggleItalic: () => ({ commands }) => {
+        return commands.toggleMark(this.name);
+      },
+      unsetItalic: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
+    };
+  },
+  addInputRules() {
+    return [
+      markInputRule2({
+        find: starInputRegex2,
+        type: this.type
+      }),
+      markInputRule2({
+        find: underscoreInputRegex2,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      markPasteRule2({
+        find: starPasteRegex2,
+        type: this.type
+      }),
+      markPasteRule2({
+        find: underscorePasteRegex2,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-strike@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-strike/dist/index.js
+import { Mark as Mark3, mergeAttributes as mergeAttributes4, markInputRule as markInputRule3, markPasteRule as markPasteRule3 } from "@tiptap/core";
+var inputRegex = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/;
+var pasteRegex = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g;
+var Strike = Mark3.create({
+  name: "strike",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "s"
+      },
+      {
+        tag: "del"
+      },
+      {
+        tag: "strike"
+      },
+      {
+        style: "text-decoration",
+        consuming: false,
+        getAttrs: (style) => style.includes("line-through") ? {} : false
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["s", mergeAttributes4(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setStrike: () => ({ commands }) => {
+        return commands.setMark(this.name);
+      },
+      toggleStrike: () => ({ commands }) => {
+        return commands.toggleMark(this.name);
+      },
+      unsetStrike: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
+    };
+  },
+  addInputRules() {
+    return [
+      markInputRule3({
+        find: inputRegex,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      markPasteRule3({
+        find: pasteRegex,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-underline@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-underline/dist/index.js
+import { Mark as Mark4, mergeAttributes as mergeAttributes5 } from "@tiptap/core";
+var Underline = Mark4.create({
+  name: "underline",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "u"
+      },
+      {
+        style: "text-decoration",
+        consuming: false,
+        getAttrs: (style) => style.includes("underline") ? {} : false
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["u", mergeAttributes5(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setUnderline: () => ({ commands }) => {
+        return commands.setMark(this.name);
+      },
+      toggleUnderline: () => ({ commands }) => {
+        return commands.toggleMark(this.name);
+      },
+      unsetUnderline: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-u": () => this.editor.commands.toggleUnderline(),
+      "Mod-U": () => this.editor.commands.toggleUnderline()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-heading@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-heading/dist/index.js
+import { Node as Node4, mergeAttributes as mergeAttributes6, textblockTypeInputRule } from "@tiptap/core";
+var Heading = Node4.create({
+  name: "heading",
+  addOptions() {
+    return {
+      levels: [1, 2, 3, 4, 5, 6],
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  group: "block",
+  defining: true,
+  addAttributes() {
+    return {
+      level: {
+        default: 1,
+        rendered: false
+      }
+    };
+  },
+  parseHTML() {
+    return this.options.levels.map((level) => ({
+      tag: `h${level}`,
+      attrs: { level }
+    }));
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const hasLevel = this.options.levels.includes(node.attrs.level);
+    const level = hasLevel ? node.attrs.level : this.options.levels[0];
+    return [`h${level}`, mergeAttributes6(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setHeading: (attributes) => ({ commands }) => {
+        if (!this.options.levels.includes(attributes.level)) {
+          return false;
+        }
+        return commands.setNode(this.name, attributes);
+      },
+      toggleHeading: (attributes) => ({ commands }) => {
+        if (!this.options.levels.includes(attributes.level)) {
+          return false;
+        }
+        return commands.toggleNode(this.name, "paragraph", attributes);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce((items, level) => ({
+      ...items,
+      ...{
+        [`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
+      }
+    }), {});
+  },
+  addInputRules() {
+    return this.options.levels.map((level) => {
+      return textblockTypeInputRule({
+        find: new RegExp(`^(#{${Math.min(...this.options.levels)},${level}})\\s$`),
+        type: this.type,
+        getAttributes: {
+          level
+        }
+      });
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-bullet-list@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-bullet-list/dist/index.js
+import { Node as Node5, mergeAttributes as mergeAttributes7, wrappingInputRule } from "@tiptap/core";
+var ListItemName = "listItem";
+var TextStyleName = "textStyle";
+var inputRegex2 = /^\s*([-+*])\s$/;
+var BulletList = Node5.create({
+  name: "bulletList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: false,
+      keepAttributes: false
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [
+      { tag: "ul" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["ul", mergeAttributes7(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      toggleBulletList: () => ({ commands, chain }) => {
+        if (this.options.keepAttributes) {
+          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
+        }
+        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      find: inputRegex2,
+      type: this.type
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule({
+        find: inputRegex2,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: () => {
+          return this.editor.getAttributes(TextStyleName);
+        },
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-ordered-list@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-ordered-list/dist/index.js
+import { Node as Node6, mergeAttributes as mergeAttributes8, wrappingInputRule as wrappingInputRule2 } from "@tiptap/core";
+var ListItemName2 = "listItem";
+var TextStyleName2 = "textStyle";
+var inputRegex3 = /^(\d+)\.\s$/;
+var OrderedList = Node6.create({
+  name: "orderedList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: false,
+      keepAttributes: false
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  addAttributes() {
+    return {
+      start: {
+        default: 1,
+        parseHTML: (element) => {
+          return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
+        }
+      },
+      type: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("type")
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const { start, ...attributesWithoutStart } = HTMLAttributes;
+    return start === 1 ? ["ol", mergeAttributes8(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes8(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      toggleOrderedList: () => ({ commands, chain }) => {
+        if (this.options.keepAttributes) {
+          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName2, this.editor.getAttributes(TextStyleName2)).run();
+        }
+        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
+    };
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule2({
+      find: inputRegex3,
+      type: this.type,
+      getAttributes: (match) => ({ start: +match[1] }),
+      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule2({
+        find: inputRegex3,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName2) }),
+        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-list-item@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-list-item/dist/index.js
+import { Node as Node7, mergeAttributes as mergeAttributes9 } from "@tiptap/core";
+var ListItem = Node7.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: true,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["li", mergeAttributes9(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      Tab: () => this.editor.commands.sinkListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-task-list@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-task-list/dist/index.js
+import { Node as Node8, mergeAttributes as mergeAttributes10 } from "@tiptap/core";
+var TaskList = Node8.create({
+  name: "taskList",
+  addOptions() {
+    return {
+      itemTypeName: "taskItem",
+      HTMLAttributes: {}
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `ul[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["ul", mergeAttributes10(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }), 0];
+  },
+  addCommands() {
+    return {
+      toggleTaskList: () => ({ commands }) => {
+        return commands.toggleList(this.name, this.options.itemTypeName);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-9": () => this.editor.commands.toggleTaskList()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-task-item@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-task-item/dist/index.js
+import { Node as Node9, mergeAttributes as mergeAttributes11, wrappingInputRule as wrappingInputRule3 } from "@tiptap/core";
+var inputRegex4 = /^\s*(\[([( |x])?\])\s$/;
+var TaskItem = Node9.create({
+  name: "taskItem",
+  addOptions() {
+    return {
+      nested: false,
+      HTMLAttributes: {},
+      taskListTypeName: "taskList",
+      a11y: void 0
+    };
+  },
+  content() {
+    return this.options.nested ? "paragraph block*" : "paragraph+";
+  },
+  defining: true,
+  addAttributes() {
+    return {
+      checked: {
+        default: false,
+        keepOnSplit: false,
+        parseHTML: (element) => {
+          const dataChecked = element.getAttribute("data-checked");
+          return dataChecked === "" || dataChecked === "true";
+        },
+        renderHTML: (attributes) => ({
+          "data-checked": attributes.checked
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `li[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "li",
+      mergeAttributes11(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": this.name
+      }),
+      [
+        "label",
+        [
+          "input",
+          {
+            type: "checkbox",
+            checked: node.attrs.checked ? "checked" : null
+          }
+        ],
+        ["span"]
+      ],
+      ["div", 0]
+    ];
+  },
+  addKeyboardShortcuts() {
+    const shortcuts = {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+    if (!this.options.nested) {
+      return shortcuts;
+    }
+    return {
+      ...shortcuts,
+      Tab: () => this.editor.commands.sinkListItem(this.name)
+    };
+  },
+  addNodeView() {
+    return ({ node, HTMLAttributes, getPos, editor }) => {
+      const listItem = document.createElement("li");
+      const checkboxWrapper = document.createElement("label");
+      const checkboxStyler = document.createElement("span");
+      const checkbox = document.createElement("input");
+      const content = document.createElement("div");
+      const updateA11Y = () => {
+        var _a, _b;
+        checkbox.ariaLabel = ((_b = (_a = this.options.a11y) === null || _a === void 0 ? void 0 : _a.checkboxLabel) === null || _b === void 0 ? void 0 : _b.call(_a, node, checkbox.checked)) || `Task item checkbox for ${node.textContent || "empty task item"}`;
+      };
+      updateA11Y();
+      checkboxWrapper.contentEditable = "false";
+      checkbox.type = "checkbox";
+      checkbox.addEventListener("mousedown", (event) => event.preventDefault());
+      checkbox.addEventListener("change", (event) => {
+        if (!editor.isEditable && !this.options.onReadOnlyChecked) {
+          checkbox.checked = !checkbox.checked;
+          return;
+        }
+        const { checked } = event.target;
+        if (editor.isEditable && typeof getPos === "function") {
+          editor.chain().focus(void 0, { scrollIntoView: false }).command(({ tr: tr2 }) => {
+            const position = getPos();
+            if (typeof position !== "number") {
+              return false;
+            }
+            const currentNode = tr2.doc.nodeAt(position);
+            tr2.setNodeMarkup(position, void 0, {
+              ...currentNode === null || currentNode === void 0 ? void 0 : currentNode.attrs,
+              checked
+            });
+            return true;
+          }).run();
+        }
+        if (!editor.isEditable && this.options.onReadOnlyChecked) {
+          if (!this.options.onReadOnlyChecked(node, checked)) {
+            checkbox.checked = !checkbox.checked;
+          }
+        }
+      });
+      Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {
+        listItem.setAttribute(key, value);
+      });
+      listItem.dataset.checked = node.attrs.checked;
+      checkbox.checked = node.attrs.checked;
+      checkboxWrapper.append(checkbox, checkboxStyler);
+      listItem.append(checkboxWrapper, content);
+      Object.entries(HTMLAttributes).forEach(([key, value]) => {
+        listItem.setAttribute(key, value);
+      });
+      return {
+        dom: listItem,
+        contentDOM: content,
+        update: (updatedNode) => {
+          if (updatedNode.type !== this.type) {
+            return false;
+          }
+          listItem.dataset.checked = updatedNode.attrs.checked;
+          checkbox.checked = updatedNode.attrs.checked;
+          updateA11Y();
+          return true;
+        }
+      };
+    };
+  },
+  addInputRules() {
+    return [
+      wrappingInputRule3({
+        find: inputRegex4,
+        type: this.type,
+        getAttributes: (match) => ({
+          checked: match[match.length - 1] === "x"
+        })
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-blockquote@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-blockquote/dist/index.js
+import { Node as Node10, mergeAttributes as mergeAttributes12, wrappingInputRule as wrappingInputRule4 } from "@tiptap/core";
+var inputRegex5 = /^\s*>\s$/;
+var Blockquote = Node10.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: true,
+  parseHTML() {
+    return [
+      { tag: "blockquote" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["blockquote", mergeAttributes12(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setBlockquote: () => ({ commands }) => {
+        return commands.wrapIn(this.name);
+      },
+      toggleBlockquote: () => ({ commands }) => {
+        return commands.toggleWrap(this.name);
+      },
+      unsetBlockquote: () => ({ commands }) => {
+        return commands.lift(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+    };
+  },
+  addInputRules() {
+    return [
+      wrappingInputRule4({
+        find: inputRegex5,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-horizontal-rule@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-horizontal-rule/dist/index.js
+import { Node as Node11, mergeAttributes as mergeAttributes13, canInsertNode, isNodeSelection, nodeInputRule } from "@tiptap/core";
+import { TextSelection, NodeSelection } from "@tiptap/pm/state";
+var HorizontalRule = Node11.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["hr", mergeAttributes13(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain, state }) => {
+        if (!canInsertNode(state, state.schema.nodes[this.name])) {
+          return false;
+        }
+        const { selection } = state;
+        const { $from: $originFrom, $to: $originTo } = selection;
+        const currentChain = chain();
+        if ($originFrom.parentOffset === 0) {
+          currentChain.insertContentAt({
+            from: Math.max($originFrom.pos - 1, 0),
+            to: $originTo.pos
+          }, {
+            type: this.name
+          });
+        } else if (isNodeSelection(selection)) {
+          currentChain.insertContentAt($originTo.pos, {
+            type: this.name
+          });
+        } else {
+          currentChain.insertContent({ type: this.name });
+        }
+        return currentChain.command(({ tr: tr2, dispatch }) => {
+          var _a;
+          if (dispatch) {
+            const { $to } = tr2.selection;
+            const posAfter = $to.end();
+            if ($to.nodeAfter) {
+              if ($to.nodeAfter.isTextblock) {
+                tr2.setSelection(TextSelection.create(tr2.doc, $to.pos + 1));
+              } else if ($to.nodeAfter.isBlock) {
+                tr2.setSelection(NodeSelection.create(tr2.doc, $to.pos));
+              } else {
+                tr2.setSelection(TextSelection.create(tr2.doc, $to.pos));
+              }
+            } else {
+              const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();
+              if (node) {
+                tr2.insert(posAfter, node);
+                tr2.setSelection(TextSelection.create(tr2.doc, posAfter + 1));
+              }
+            }
+            tr2.scrollIntoView();
+          }
+          return true;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      nodeInputRule({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-hard-break@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-hard-break/dist/index.js
+import { Node as Node12, mergeAttributes as mergeAttributes14 } from "@tiptap/core";
+var HardBreak = Node12.create({
+  name: "hardBreak",
+  addOptions() {
+    return {
+      keepMarks: true,
+      HTMLAttributes: {}
+    };
+  },
+  inline: true,
+  group: "inline",
+  selectable: false,
+  linebreakReplacement: true,
+  parseHTML() {
+    return [
+      { tag: "br" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["br", mergeAttributes14(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  renderText() {
+    return "\n";
+  },
+  addCommands() {
+    return {
+      setHardBreak: () => ({ commands, chain, state, editor }) => {
+        return commands.first([
+          () => commands.exitCode(),
+          () => commands.command(() => {
+            const { selection, storedMarks } = state;
+            if (selection.$from.parent.type.spec.isolating) {
+              return false;
+            }
+            const { keepMarks } = this.options;
+            const { splittableMarks } = editor.extensionManager;
+            const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+            return chain().insertContent({ type: this.name }).command(({ tr: tr2, dispatch }) => {
+              if (dispatch && marks && keepMarks) {
+                const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+                tr2.ensureMarks(filteredMarks);
+              }
+              return true;
+            }).run();
+          })
+        ]);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-history@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-history/dist/index.js
+import { Extension } from "@tiptap/core";
+import { undo, redo, history } from "@tiptap/pm/history";
+var History = Extension.create({
+  name: "history",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state, dispatch }) => {
+        return undo(state, dispatch);
+      },
+      redo: () => ({ state, dispatch }) => {
+        return redo(state, dispatch);
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      history(this.options)
+    ];
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-z": () => this.editor.commands.undo(),
+      "Shift-Mod-z": () => this.editor.commands.redo(),
+      "Mod-y": () => this.editor.commands.redo(),
+      // Russian keyboard layouts
+      "Mod-\u044F": () => this.editor.commands.undo(),
+      "Shift-Mod-\u044F": () => this.editor.commands.redo()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-dropcursor@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-dropcursor/dist/index.js
+import { Extension as Extension2 } from "@tiptap/core";
+import { dropCursor } from "@tiptap/pm/dropcursor";
+var Dropcursor = Extension2.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      dropCursor(this.options)
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-gapcursor@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-gapcursor/dist/index.js
+import { Extension as Extension3, callOrReturn, getExtensionField } from "@tiptap/core";
+import { gapCursor } from "@tiptap/pm/gapcursor";
+var Gapcursor = Extension3.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [
+      gapCursor()
+    ];
+  },
+  extendNodeSchema(extension) {
+    var _a;
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage
+    };
+    return {
+      allowGapCursor: (_a = callOrReturn(getExtensionField(extension, "allowGapCursor", context))) !== null && _a !== void 0 ? _a : null
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-link@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-link/dist/index.js
+import { combineTransactionSteps, getChangedRanges, findChildrenInRange, getMarksBetween, getAttributes, Mark as Mark5, mergeAttributes as mergeAttributes15, markPasteRule as markPasteRule4 } from "@tiptap/core";
+
+// ../../node_modules/.pnpm/linkifyjs@4.3.2/node_modules/linkifyjs/dist/linkify.mjs
+var encodedTlds = "aaa1rp3bb0ott3vie4c1le2ogado5udhabi7c0ademy5centure6ountant0s9o1tor4d0s1ult4e0g1ro2tna4f0l1rica5g0akhan5ency5i0g1rbus3force5tel5kdn3l0ibaba4pay4lfinanz6state5y2sace3tom5m0azon4ericanexpress7family11x2fam3ica3sterdam8nalytics7droid5quan4z2o0l2partments8p0le4q0uarelle8r0ab1mco4chi3my2pa2t0e3s0da2ia2sociates9t0hleta5torney7u0ction5di0ble3o3spost5thor3o0s4w0s2x0a2z0ure5ba0by2idu3namex4d1k2r0celona5laycard4s5efoot5gains6seball5ketball8uhaus5yern5b0c1t1va3cg1n2d1e0ats2uty4er2rlin4st0buy5t2f1g1h0arti5i0ble3d1ke2ng0o3o1z2j1lack0friday9ockbuster8g1omberg7ue3m0s1w2n0pparibas9o0ats3ehringer8fa2m1nd2o0k0ing5sch2tik2on4t1utique6x2r0adesco6idgestone9oadway5ker3ther5ussels7s1t1uild0ers6siness6y1zz3v1w1y1z0h3ca0b1fe2l0l1vinklein9m0era3p2non3petown5ital0one8r0avan4ds2e0er0s4s2sa1e1h1ino4t0ering5holic7ba1n1re3c1d1enter4o1rn3f0a1d2g1h0anel2nel4rity4se2t2eap3intai5ristmas6ome4urch5i0priani6rcle4sco3tadel4i0c2y3k1l0aims4eaning6ick2nic1que6othing5ud3ub0med6m1n1o0ach3des3ffee4llege4ogne5m0mbank4unity6pany2re3uter5sec4ndos3struction8ulting7tact3ractors9oking4l1p2rsica5untry4pon0s4rses6pa2r0edit0card4union9icket5own3s1uise0s6u0isinella9v1w1x1y0mru3ou3z2dad1nce3ta1e1ing3sun4y2clk3ds2e0al0er2s3gree4livery5l1oitte5ta3mocrat6ntal2ist5si0gn4v2hl2iamonds6et2gital5rect0ory7scount3ver5h2y2j1k1m1np2o0cs1tor4g1mains5t1wnload7rive4tv2ubai3nlop4pont4rban5vag2r2z2earth3t2c0o2deka3u0cation8e1g1mail3erck5nergy4gineer0ing9terprises10pson4quipment8r0icsson6ni3s0q1tate5t1u0rovision8s2vents5xchange6pert3osed4ress5traspace10fage2il1rwinds6th3mily4n0s2rm0ers5shion4t3edex3edback6rrari3ero6i0delity5o2lm2nal1nce1ial7re0stone6mdale6sh0ing5t0ness6j1k1lickr3ghts4r2orist4wers5y2m1o0o0d1tball6rd1ex2sale4um3undation8x2r0ee1senius7l1ogans4ntier7tr2ujitsu5n0d2rniture7tbol5yi3ga0l0lery3o1up4me0s3p1rden4y2b0iz3d0n2e0a1nt0ing5orge5f1g0ee3h1i0ft0s3ves2ing5l0ass3e1obal2o4m0ail3bh2o1x2n1odaddy5ld0point6f2o0dyear5g0le4p1t1v2p1q1r0ainger5phics5tis4een3ipe3ocery4up4s1t1u0cci3ge2ide2tars5ru3w1y2hair2mburg5ngout5us3bo2dfc0bank7ealth0care8lp1sinki6re1mes5iphop4samitsu7tachi5v2k0t2m1n1ockey4ldings5iday5medepot5goods5s0ense7nda3rse3spital5t0ing5t0els3mail5use3w2r1sbc3t1u0ghes5yatt3undai7ibm2cbc2e1u2d1e0ee3fm2kano4l1m0amat4db2mo0bilien9n0c1dustries8finiti5o2g1k1stitute6urance4e4t0ernational10uit4vestments10o1piranga7q1r0ish4s0maili5t0anbul7t0au2v3jaguar4va3cb2e0ep2tzt3welry6io2ll2m0p2nj2o0bs1urg4t1y2p0morgan6rs3uegos4niper7kaufen5ddi3e0rryhotels6properties14fh2g1h1i0a1ds2m1ndle4tchen5wi3m1n1oeln3matsu5sher5p0mg2n2r0d1ed3uokgroup8w1y0oto4z2la0caixa5mborghini8er3nd0rover6xess5salle5t0ino3robe5w0yer5b1c1ds2ease3clerc5frak4gal2o2xus4gbt3i0dl2fe0insurance9style7ghting6ke2lly3mited4o2ncoln4k2ve1ing5k1lc1p2oan0s3cker3us3l1ndon4tte1o3ve3pl0financial11r1s1t0d0a3u0ndbeck6xe1ury5v1y2ma0drid4if1son4keup4n0agement7go3p1rket0ing3s4riott5shalls7ttel5ba2c0kinsey7d1e0d0ia3et2lbourne7me1orial6n0u2rckmsd7g1h1iami3crosoft7l1ni1t2t0subishi9k1l0b1s2m0a2n1o0bi0le4da2e1i1m1nash3ey2ster5rmon3tgage6scow4to0rcycles9v0ie4p1q1r1s0d2t0n1r2u0seum3ic4v1w1x1y1z2na0b1goya4me2vy3ba2c1e0c1t0bank4flix4work5ustar5w0s2xt0direct7us4f0l2g0o2hk2i0co2ke1on3nja3ssan1y5l1o0kia3rton4w0ruz3tv4p1r0a1w2tt2u1yc2z2obi1server7ffice5kinawa6layan0group9lo3m0ega4ne1g1l0ine5oo2pen3racle3nge4g0anic5igins6saka4tsuka4t2vh3pa0ge2nasonic7ris2s1tners4s1y3y2ccw3e0t2f0izer5g1h0armacy6d1ilips5one2to0graphy6s4ysio5ics1tet2ures6d1n0g1k2oneer5zza4k1l0ace2y0station9umbing5s3m1n0c2ohl2ker3litie5rn2st3r0axi3ess3ime3o0d0uctions8f1gressive8mo2perties3y5tection8u0dential9s1t1ub2w0c2y2qa1pon3uebec3st5racing4dio4e0ad1lestate6tor2y4cipes5d0stone5umbrella9hab3ise0n3t2liance6n0t0als5pair3ort3ublican8st0aurant8view0s5xroth6ich0ardli6oh3l1o1p2o0cks3deo3gers4om3s0vp3u0gby3hr2n2w0e2yukyu6sa0arland6fe0ty4kura4le1on3msclub4ung5ndvik0coromant12ofi4p1rl2s1ve2xo3b0i1s2c0b1haeffler7midt4olarships8ol3ule3warz5ience5ot3d1e0arch3t2cure1ity6ek2lect4ner3rvices6ven3w1x0y3fr2g1h0angrila6rp3ell3ia1ksha5oes2p0ping5uji3w3i0lk2na1gles5te3j1k0i0n2y0pe4l0ing4m0art3ile4n0cf3o0ccer3ial4ftbank4ware6hu2lar2utions7ng1y2y2pa0ce3ort2t3r0l2s1t0ada2ples4r1tebank4farm7c0group6ockholm6rage3e3ream4udio2y3yle4u0cks3pplies3y2ort5rf1gery5zuki5v1watch4iss4x1y0dney4stems6z2tab1ipei4lk2obao4rget4tamotors6r2too4x0i3c0i2d0k2eam2ch0nology8l1masek5nnis4va3f1g1h0d1eater2re6iaa2ckets5enda4ps2res2ol4j0maxx4x2k0maxx5l1m0all4n1o0day3kyo3ols3p1ray3shiba5tal3urs3wn2yota3s3r0ade1ing4ining5vel0ers0insurance16ust3v2t1ube2i1nes3shu4v0s2w1z2ua1bank3s2g1k1nicom3versity8o2ol2ps2s1y1z2va0cations7na1guard7c1e0gas3ntures6risign5m\xF6gensberater2ung14sicherung10t2g1i0ajes4deo3g1king4llas4n1p1rgin4sa1ion4va1o3laanderen9n1odka3lvo3te1ing3o2yage5u2wales2mart4ter4ng0gou5tch0es6eather0channel12bcam3er2site5d0ding5ibo2r3f1hoswho6ien2ki2lliamhill9n0dows4e1ners6me2olterskluwer11odside6rk0s2ld3w2s1tc1f3xbox3erox4ihuan4n2xx2yz3yachts4hoo3maxun5ndex5e1odobashi7ga2kohama6u0tube6t1un3za0ppos4ra3ero3ip2m1one3uerich6w2";
+var encodedUtlds = "\u03B5\u03BB1\u03C52\u0431\u04331\u0435\u043B3\u0434\u0435\u0442\u04384\u0435\u044E2\u043A\u0430\u0442\u043E\u043B\u0438\u043A6\u043E\u043C3\u043C\u043A\u04342\u043E\u043D1\u0441\u043A\u0432\u04306\u043E\u043D\u043B\u0430\u0439\u043D5\u0440\u04333\u0440\u0443\u04412\u04442\u0441\u0430\u0439\u04423\u0440\u04313\u0443\u043A\u04403\u049B\u0430\u04373\u0570\u0561\u05753\u05D9\u05E9\u05E8\u05D0\u05DC5\u05E7\u05D5\u05DD3\u0627\u0628\u0648\u0638\u0628\u064A5\u0631\u0627\u0645\u0643\u06485\u0644\u0627\u0631\u062F\u06464\u0628\u062D\u0631\u064A\u06465\u062C\u0632\u0627\u0626\u06315\u0633\u0639\u0648\u062F\u064A\u06296\u0639\u0644\u064A\u0627\u06465\u0645\u063A\u0631\u06285\u0645\u0627\u0631\u0627\u062A5\u06CC\u0631\u0627\u06465\u0628\u0627\u0631\u062A2\u0632\u0627\u06314\u064A\u062A\u06433\u06BE\u0627\u0631\u062A5\u062A\u0648\u0646\u06334\u0633\u0648\u062F\u0627\u06463\u0631\u064A\u06295\u0634\u0628\u0643\u06294\u0639\u0631\u0627\u06422\u06282\u0645\u0627\u06464\u0641\u0644\u0633\u0637\u064A\u06466\u0642\u0637\u06313\u0643\u0627\u062B\u0648\u0644\u064A\u06436\u0648\u06453\u0645\u0635\u06312\u0644\u064A\u0633\u064A\u06275\u0648\u0631\u064A\u062A\u0627\u0646\u064A\u06277\u0642\u06394\u0647\u0645\u0631\u0627\u06475\u067E\u0627\u06A9\u0633\u062A\u0627\u06467\u0680\u0627\u0631\u062A4\u0915\u0949\u092E3\u0928\u0947\u091F3\u092D\u093E\u0930\u09240\u092E\u094D3\u094B\u09245\u0938\u0902\u0917\u0920\u09285\u09AC\u09BE\u0982\u09B2\u09BE5\u09AD\u09BE\u09B0\u09A42\u09F0\u09A44\u0A2D\u0A3E\u0A30\u0A244\u0AAD\u0ABE\u0AB0\u0AA44\u0B2D\u0B3E\u0B30\u0B244\u0B87\u0BA8\u0BCD\u0BA4\u0BBF\u0BAF\u0BBE6\u0BB2\u0B99\u0BCD\u0B95\u0BC86\u0B9A\u0BBF\u0B99\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0BC2\u0BB0\u0BCD11\u0C2D\u0C3E\u0C30\u0C24\u0C4D5\u0CAD\u0CBE\u0CB0\u0CA44\u0D2D\u0D3E\u0D30\u0D24\u0D025\u0DBD\u0D82\u0D9A\u0DCF4\u0E04\u0E2D\u0E213\u0E44\u0E17\u0E223\u0EA5\u0EB2\u0EA73\u10D2\u10D42\u307F\u3093\u306A3\u30A2\u30DE\u30BE\u30F34\u30AF\u30E9\u30A6\u30C94\u30B0\u30FC\u30B0\u30EB4\u30B3\u30E02\u30B9\u30C8\u30A23\u30BB\u30FC\u30EB3\u30D5\u30A1\u30C3\u30B7\u30E7\u30F36\u30DD\u30A4\u30F3\u30C84\u4E16\u754C2\u4E2D\u4FE11\u56FD1\u570B1\u6587\u7F513\u4E9A\u9A6C\u900A3\u4F01\u4E1A2\u4F5B\u5C712\u4FE1\u606F2\u5065\u5EB72\u516B\u53662\u516C\u53F81\u76CA2\u53F0\u6E7E1\u70632\u5546\u57CE1\u5E971\u68072\u5609\u91CC0\u5927\u9152\u5E975\u5728\u7EBF2\u5927\u62FF2\u5929\u4E3B\u65593\u5A31\u4E502\u5BB6\u96FB2\u5E7F\u4E1C2\u5FAE\u535A2\u6148\u55842\u6211\u7231\u4F603\u624B\u673A2\u62DB\u80582\u653F\u52A11\u5E9C2\u65B0\u52A0\u57612\u95FB2\u65F6\u5C1A2\u66F8\u7C4D2\u673A\u67842\u6DE1\u9A6C\u95213\u6E38\u620F2\u6FB3\u95802\u70B9\u770B2\u79FB\u52A82\u7EC4\u7EC7\u673A\u67844\u7F51\u57401\u5E971\u7AD91\u7EDC2\u8054\u901A2\u8C37\u6B4C2\u8D2D\u72692\u901A\u8CA92\u96C6\u56E22\u96FB\u8A0A\u76C8\u79D14\u98DE\u5229\u6D663\u98DF\u54C12\u9910\u53852\u9999\u683C\u91CC\u62C93\u6E2F2\uB2F7\uB1371\uCEF42\uC0BC\uC1312\uD55C\uAD6D2";
+var numeric = "numeric";
+var ascii = "ascii";
+var alpha = "alpha";
+var asciinumeric = "asciinumeric";
+var alphanumeric = "alphanumeric";
+var domain = "domain";
+var emoji = "emoji";
+var scheme = "scheme";
+var slashscheme = "slashscheme";
+var whitespace = "whitespace";
+function registerGroup(name, groups) {
+  if (!(name in groups)) {
+    groups[name] = [];
+  }
+  return groups[name];
+}
+function addToGroups(t, flags, groups) {
+  if (flags[numeric]) {
+    flags[asciinumeric] = true;
+    flags[alphanumeric] = true;
+  }
+  if (flags[ascii]) {
+    flags[asciinumeric] = true;
+    flags[alpha] = true;
+  }
+  if (flags[asciinumeric]) {
+    flags[alphanumeric] = true;
+  }
+  if (flags[alpha]) {
+    flags[alphanumeric] = true;
+  }
+  if (flags[alphanumeric]) {
+    flags[domain] = true;
+  }
+  if (flags[emoji]) {
+    flags[domain] = true;
+  }
+  for (const k in flags) {
+    const group = registerGroup(k, groups);
+    if (group.indexOf(t) < 0) {
+      group.push(t);
+    }
+  }
+}
+function flagsForToken(t, groups) {
+  const result = {};
+  for (const c in groups) {
+    if (groups[c].indexOf(t) >= 0) {
+      result[c] = true;
+    }
+  }
+  return result;
+}
+function State(token = null) {
+  this.j = {};
+  this.jr = [];
+  this.jd = null;
+  this.t = token;
+}
+State.groups = {};
+State.prototype = {
+  accepts() {
+    return !!this.t;
+  },
+  /**
+   * Follow an existing transition from the given input to the next state.
+   * Does not mutate.
+   * @param {string} input character or token type to transition on
+   * @returns {?State<T>} the next state, if any
+   */
+  go(input) {
+    const state = this;
+    const nextState = state.j[input];
+    if (nextState) {
+      return nextState;
+    }
+    for (let i = 0; i < state.jr.length; i++) {
+      const regex = state.jr[i][0];
+      const nextState2 = state.jr[i][1];
+      if (nextState2 && regex.test(input)) {
+        return nextState2;
+      }
+    }
+    return state.jd;
+  },
+  /**
+   * Whether the state has a transition for the given input. Set the second
+   * argument to true to only look for an exact match (and not a default or
+   * regular-expression-based transition)
+   * @param {string} input
+   * @param {boolean} exactOnly
+   */
+  has(input, exactOnly = false) {
+    return exactOnly ? input in this.j : !!this.go(input);
+  },
+  /**
+   * Short for "transition all"; create a transition from the array of items
+   * in the given list to the same final resulting state.
+   * @param {string | string[]} inputs Group of inputs to transition on
+   * @param {Transition<T> | State<T>} [next] Transition options
+   * @param {Flags} [flags] Collections flags to add token to
+   * @param {Collections<T>} [groups] Master list of token groups
+   */
+  ta(inputs, next, flags, groups) {
+    for (let i = 0; i < inputs.length; i++) {
+      this.tt(inputs[i], next, flags, groups);
+    }
+  },
+  /**
+   * Short for "take regexp transition"; defines a transition for this state
+   * when it encounters a token which matches the given regular expression
+   * @param {RegExp} regexp Regular expression transition (populate first)
+   * @param {T | State<T>} [next] Transition options
+   * @param {Flags} [flags] Collections flags to add token to
+   * @param {Collections<T>} [groups] Master list of token groups
+   * @returns {State<T>} taken after the given input
+   */
+  tr(regexp, next, flags, groups) {
+    groups = groups || State.groups;
+    let nextState;
+    if (next && next.j) {
+      nextState = next;
+    } else {
+      nextState = new State(next);
+      if (flags && groups) {
+        addToGroups(next, flags, groups);
+      }
+    }
+    this.jr.push([regexp, nextState]);
+    return nextState;
+  },
+  /**
+   * Short for "take transitions", will take as many sequential transitions as
+   * the length of the given input and returns the
+   * resulting final state.
+   * @param {string | string[]} input
+   * @param {T | State<T>} [next] Transition options
+   * @param {Flags} [flags] Collections flags to add token to
+   * @param {Collections<T>} [groups] Master list of token groups
+   * @returns {State<T>} taken after the given input
+   */
+  ts(input, next, flags, groups) {
+    let state = this;
+    const len = input.length;
+    if (!len) {
+      return state;
+    }
+    for (let i = 0; i < len - 1; i++) {
+      state = state.tt(input[i]);
+    }
+    return state.tt(input[len - 1], next, flags, groups);
+  },
+  /**
+   * Short for "take transition", this is a method for building/working with
+   * state machines.
+   *
+   * If a state already exists for the given input, returns it.
+   *
+   * If a token is specified, that state will emit that token when reached by
+   * the linkify engine.
+   *
+   * If no state exists, it will be initialized with some default transitions
+   * that resemble existing default transitions.
+   *
+   * If a state is given for the second argument, that state will be
+   * transitioned to on the given input regardless of what that input
+   * previously did.
+   *
+   * Specify a token group flags to define groups that this token belongs to.
+   * The token will be added to corresponding entires in the given groups
+   * object.
+   *
+   * @param {string} input character, token type to transition on
+   * @param {T | State<T>} [next] Transition options
+   * @param {Flags} [flags] Collections flags to add token to
+   * @param {Collections<T>} [groups] Master list of groups
+   * @returns {State<T>} taken after the given input
+   */
+  tt(input, next, flags, groups) {
+    groups = groups || State.groups;
+    const state = this;
+    if (next && next.j) {
+      state.j[input] = next;
+      return next;
+    }
+    const t = next;
+    let nextState, templateState = state.go(input);
+    if (templateState) {
+      nextState = new State();
+      Object.assign(nextState.j, templateState.j);
+      nextState.jr.push.apply(nextState.jr, templateState.jr);
+      nextState.jd = templateState.jd;
+      nextState.t = templateState.t;
+    } else {
+      nextState = new State();
+    }
+    if (t) {
+      if (groups) {
+        if (nextState.t && typeof nextState.t === "string") {
+          const allFlags = Object.assign(flagsForToken(nextState.t, groups), flags);
+          addToGroups(t, allFlags, groups);
+        } else if (flags) {
+          addToGroups(t, flags, groups);
+        }
+      }
+      nextState.t = t;
+    }
+    state.j[input] = nextState;
+    return nextState;
+  }
+};
+var ta = (state, input, next, flags, groups) => state.ta(input, next, flags, groups);
+var tr = (state, regexp, next, flags, groups) => state.tr(regexp, next, flags, groups);
+var ts = (state, input, next, flags, groups) => state.ts(input, next, flags, groups);
+var tt = (state, input, next, flags, groups) => state.tt(input, next, flags, groups);
+var WORD = "WORD";
+var UWORD = "UWORD";
+var ASCIINUMERICAL = "ASCIINUMERICAL";
+var ALPHANUMERICAL = "ALPHANUMERICAL";
+var LOCALHOST = "LOCALHOST";
+var TLD = "TLD";
+var UTLD = "UTLD";
+var SCHEME = "SCHEME";
+var SLASH_SCHEME = "SLASH_SCHEME";
+var NUM = "NUM";
+var WS = "WS";
+var NL = "NL";
+var OPENBRACE = "OPENBRACE";
+var CLOSEBRACE = "CLOSEBRACE";
+var OPENBRACKET = "OPENBRACKET";
+var CLOSEBRACKET = "CLOSEBRACKET";
+var OPENPAREN = "OPENPAREN";
+var CLOSEPAREN = "CLOSEPAREN";
+var OPENANGLEBRACKET = "OPENANGLEBRACKET";
+var CLOSEANGLEBRACKET = "CLOSEANGLEBRACKET";
+var FULLWIDTHLEFTPAREN = "FULLWIDTHLEFTPAREN";
+var FULLWIDTHRIGHTPAREN = "FULLWIDTHRIGHTPAREN";
+var LEFTCORNERBRACKET = "LEFTCORNERBRACKET";
+var RIGHTCORNERBRACKET = "RIGHTCORNERBRACKET";
+var LEFTWHITECORNERBRACKET = "LEFTWHITECORNERBRACKET";
+var RIGHTWHITECORNERBRACKET = "RIGHTWHITECORNERBRACKET";
+var FULLWIDTHLESSTHAN = "FULLWIDTHLESSTHAN";
+var FULLWIDTHGREATERTHAN = "FULLWIDTHGREATERTHAN";
+var AMPERSAND = "AMPERSAND";
+var APOSTROPHE = "APOSTROPHE";
+var ASTERISK = "ASTERISK";
+var AT = "AT";
+var BACKSLASH = "BACKSLASH";
+var BACKTICK = "BACKTICK";
+var CARET = "CARET";
+var COLON = "COLON";
+var COMMA = "COMMA";
+var DOLLAR = "DOLLAR";
+var DOT = "DOT";
+var EQUALS = "EQUALS";
+var EXCLAMATION = "EXCLAMATION";
+var HYPHEN = "HYPHEN";
+var PERCENT = "PERCENT";
+var PIPE = "PIPE";
+var PLUS = "PLUS";
+var POUND = "POUND";
+var QUERY = "QUERY";
+var QUOTE = "QUOTE";
+var FULLWIDTHMIDDLEDOT = "FULLWIDTHMIDDLEDOT";
+var SEMI = "SEMI";
+var SLASH = "SLASH";
+var TILDE = "TILDE";
+var UNDERSCORE = "UNDERSCORE";
+var EMOJI$1 = "EMOJI";
+var SYM = "SYM";
+var tk = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  ALPHANUMERICAL,
+  AMPERSAND,
+  APOSTROPHE,
+  ASCIINUMERICAL,
+  ASTERISK,
+  AT,
+  BACKSLASH,
+  BACKTICK,
+  CARET,
+  CLOSEANGLEBRACKET,
+  CLOSEBRACE,
+  CLOSEBRACKET,
+  CLOSEPAREN,
+  COLON,
+  COMMA,
+  DOLLAR,
+  DOT,
+  EMOJI: EMOJI$1,
+  EQUALS,
+  EXCLAMATION,
+  FULLWIDTHGREATERTHAN,
+  FULLWIDTHLEFTPAREN,
+  FULLWIDTHLESSTHAN,
+  FULLWIDTHMIDDLEDOT,
+  FULLWIDTHRIGHTPAREN,
+  HYPHEN,
+  LEFTCORNERBRACKET,
+  LEFTWHITECORNERBRACKET,
+  LOCALHOST,
+  NL,
+  NUM,
+  OPENANGLEBRACKET,
+  OPENBRACE,
+  OPENBRACKET,
+  OPENPAREN,
+  PERCENT,
+  PIPE,
+  PLUS,
+  POUND,
+  QUERY,
+  QUOTE,
+  RIGHTCORNERBRACKET,
+  RIGHTWHITECORNERBRACKET,
+  SCHEME,
+  SEMI,
+  SLASH,
+  SLASH_SCHEME,
+  SYM,
+  TILDE,
+  TLD,
+  UNDERSCORE,
+  UTLD,
+  UWORD,
+  WORD,
+  WS
+});
+var ASCII_LETTER = /[a-z]/;
+var LETTER = /\p{L}/u;
+var EMOJI = /\p{Emoji}/u;
+var DIGIT = /\d/;
+var SPACE = /\s/;
+var CR = "\r";
+var LF = "\n";
+var EMOJI_VARIATION = "\uFE0F";
+var EMOJI_JOINER = "\u200D";
+var OBJECT_REPLACEMENT = "\uFFFC";
+var tlds = null;
+var utlds = null;
+function init$2(customSchemes = []) {
+  const groups = {};
+  State.groups = groups;
+  const Start = new State();
+  if (tlds == null) {
+    tlds = decodeTlds(encodedTlds);
+  }
+  if (utlds == null) {
+    utlds = decodeTlds(encodedUtlds);
+  }
+  tt(Start, "'", APOSTROPHE);
+  tt(Start, "{", OPENBRACE);
+  tt(Start, "}", CLOSEBRACE);
+  tt(Start, "[", OPENBRACKET);
+  tt(Start, "]", CLOSEBRACKET);
+  tt(Start, "(", OPENPAREN);
+  tt(Start, ")", CLOSEPAREN);
+  tt(Start, "<", OPENANGLEBRACKET);
+  tt(Start, ">", CLOSEANGLEBRACKET);
+  tt(Start, "\uFF08", FULLWIDTHLEFTPAREN);
+  tt(Start, "\uFF09", FULLWIDTHRIGHTPAREN);
+  tt(Start, "\u300C", LEFTCORNERBRACKET);
+  tt(Start, "\u300D", RIGHTCORNERBRACKET);
+  tt(Start, "\u300E", LEFTWHITECORNERBRACKET);
+  tt(Start, "\u300F", RIGHTWHITECORNERBRACKET);
+  tt(Start, "\uFF1C", FULLWIDTHLESSTHAN);
+  tt(Start, "\uFF1E", FULLWIDTHGREATERTHAN);
+  tt(Start, "&", AMPERSAND);
+  tt(Start, "*", ASTERISK);
+  tt(Start, "@", AT);
+  tt(Start, "`", BACKTICK);
+  tt(Start, "^", CARET);
+  tt(Start, ":", COLON);
+  tt(Start, ",", COMMA);
+  tt(Start, "$", DOLLAR);
+  tt(Start, ".", DOT);
+  tt(Start, "=", EQUALS);
+  tt(Start, "!", EXCLAMATION);
+  tt(Start, "-", HYPHEN);
+  tt(Start, "%", PERCENT);
+  tt(Start, "|", PIPE);
+  tt(Start, "+", PLUS);
+  tt(Start, "#", POUND);
+  tt(Start, "?", QUERY);
+  tt(Start, '"', QUOTE);
+  tt(Start, "/", SLASH);
+  tt(Start, ";", SEMI);
+  tt(Start, "~", TILDE);
+  tt(Start, "_", UNDERSCORE);
+  tt(Start, "\\", BACKSLASH);
+  tt(Start, "\u30FB", FULLWIDTHMIDDLEDOT);
+  const Num = tr(Start, DIGIT, NUM, {
+    [numeric]: true
+  });
+  tr(Num, DIGIT, Num);
+  const Asciinumeric = tr(Num, ASCII_LETTER, ASCIINUMERICAL, {
+    [asciinumeric]: true
+  });
+  const Alphanumeric = tr(Num, LETTER, ALPHANUMERICAL, {
+    [alphanumeric]: true
+  });
+  const Word = tr(Start, ASCII_LETTER, WORD, {
+    [ascii]: true
+  });
+  tr(Word, DIGIT, Asciinumeric);
+  tr(Word, ASCII_LETTER, Word);
+  tr(Asciinumeric, DIGIT, Asciinumeric);
+  tr(Asciinumeric, ASCII_LETTER, Asciinumeric);
+  const UWord = tr(Start, LETTER, UWORD, {
+    [alpha]: true
+  });
+  tr(UWord, ASCII_LETTER);
+  tr(UWord, DIGIT, Alphanumeric);
+  tr(UWord, LETTER, UWord);
+  tr(Alphanumeric, DIGIT, Alphanumeric);
+  tr(Alphanumeric, ASCII_LETTER);
+  tr(Alphanumeric, LETTER, Alphanumeric);
+  const Nl2 = tt(Start, LF, NL, {
+    [whitespace]: true
+  });
+  const Cr = tt(Start, CR, WS, {
+    [whitespace]: true
+  });
+  const Ws = tr(Start, SPACE, WS, {
+    [whitespace]: true
+  });
+  tt(Start, OBJECT_REPLACEMENT, Ws);
+  tt(Cr, LF, Nl2);
+  tt(Cr, OBJECT_REPLACEMENT, Ws);
+  tr(Cr, SPACE, Ws);
+  tt(Ws, CR);
+  tt(Ws, LF);
+  tr(Ws, SPACE, Ws);
+  tt(Ws, OBJECT_REPLACEMENT, Ws);
+  const Emoji = tr(Start, EMOJI, EMOJI$1, {
+    [emoji]: true
+  });
+  tt(Emoji, "#");
+  tr(Emoji, EMOJI, Emoji);
+  tt(Emoji, EMOJI_VARIATION, Emoji);
+  const EmojiJoiner = tt(Emoji, EMOJI_JOINER);
+  tt(EmojiJoiner, "#");
+  tr(EmojiJoiner, EMOJI, Emoji);
+  const wordjr = [[ASCII_LETTER, Word], [DIGIT, Asciinumeric]];
+  const uwordjr = [[ASCII_LETTER, null], [LETTER, UWord], [DIGIT, Alphanumeric]];
+  for (let i = 0; i < tlds.length; i++) {
+    fastts(Start, tlds[i], TLD, WORD, wordjr);
+  }
+  for (let i = 0; i < utlds.length; i++) {
+    fastts(Start, utlds[i], UTLD, UWORD, uwordjr);
+  }
+  addToGroups(TLD, {
+    tld: true,
+    ascii: true
+  }, groups);
+  addToGroups(UTLD, {
+    utld: true,
+    alpha: true
+  }, groups);
+  fastts(Start, "file", SCHEME, WORD, wordjr);
+  fastts(Start, "mailto", SCHEME, WORD, wordjr);
+  fastts(Start, "http", SLASH_SCHEME, WORD, wordjr);
+  fastts(Start, "https", SLASH_SCHEME, WORD, wordjr);
+  fastts(Start, "ftp", SLASH_SCHEME, WORD, wordjr);
+  fastts(Start, "ftps", SLASH_SCHEME, WORD, wordjr);
+  addToGroups(SCHEME, {
+    scheme: true,
+    ascii: true
+  }, groups);
+  addToGroups(SLASH_SCHEME, {
+    slashscheme: true,
+    ascii: true
+  }, groups);
+  customSchemes = customSchemes.sort((a, b) => a[0] > b[0] ? 1 : -1);
+  for (let i = 0; i < customSchemes.length; i++) {
+    const sch = customSchemes[i][0];
+    const optionalSlashSlash = customSchemes[i][1];
+    const flags = optionalSlashSlash ? {
+      [scheme]: true
+    } : {
+      [slashscheme]: true
+    };
+    if (sch.indexOf("-") >= 0) {
+      flags[domain] = true;
+    } else if (!ASCII_LETTER.test(sch)) {
+      flags[numeric] = true;
+    } else if (DIGIT.test(sch)) {
+      flags[asciinumeric] = true;
+    } else {
+      flags[ascii] = true;
+    }
+    ts(Start, sch, sch, flags);
+  }
+  ts(Start, "localhost", LOCALHOST, {
+    ascii: true
+  });
+  Start.jd = new State(SYM);
+  return {
+    start: Start,
+    tokens: Object.assign({
+      groups
+    }, tk)
+  };
+}
+function run$1(start, str) {
+  const iterable = stringToArray(str.replace(/[A-Z]/g, (c) => c.toLowerCase()));
+  const charCount = iterable.length;
+  const tokens = [];
+  let cursor = 0;
+  let charCursor = 0;
+  while (charCursor < charCount) {
+    let state = start;
+    let nextState = null;
+    let tokenLength = 0;
+    let latestAccepting = null;
+    let sinceAccepts = -1;
+    let charsSinceAccepts = -1;
+    while (charCursor < charCount && (nextState = state.go(iterable[charCursor]))) {
+      state = nextState;
+      if (state.accepts()) {
+        sinceAccepts = 0;
+        charsSinceAccepts = 0;
+        latestAccepting = state;
+      } else if (sinceAccepts >= 0) {
+        sinceAccepts += iterable[charCursor].length;
+        charsSinceAccepts++;
+      }
+      tokenLength += iterable[charCursor].length;
+      cursor += iterable[charCursor].length;
+      charCursor++;
+    }
+    cursor -= sinceAccepts;
+    charCursor -= charsSinceAccepts;
+    tokenLength -= sinceAccepts;
+    tokens.push({
+      t: latestAccepting.t,
+      // token type/name
+      v: str.slice(cursor - tokenLength, cursor),
+      // string value
+      s: cursor - tokenLength,
+      // start index
+      e: cursor
+      // end index (excluding)
+    });
+  }
+  return tokens;
+}
+function stringToArray(str) {
+  const result = [];
+  const len = str.length;
+  let index = 0;
+  while (index < len) {
+    let first = str.charCodeAt(index);
+    let second;
+    let char = first < 55296 || first > 56319 || index + 1 === len || (second = str.charCodeAt(index + 1)) < 56320 || second > 57343 ? str[index] : str.slice(index, index + 2);
+    result.push(char);
+    index += char.length;
+  }
+  return result;
+}
+function fastts(state, input, t, defaultt, jr) {
+  let next;
+  const len = input.length;
+  for (let i = 0; i < len - 1; i++) {
+    const char = input[i];
+    if (state.j[char]) {
+      next = state.j[char];
+    } else {
+      next = new State(defaultt);
+      next.jr = jr.slice();
+      state.j[char] = next;
+    }
+    state = next;
+  }
+  next = new State(t);
+  next.jr = jr.slice();
+  state.j[input[len - 1]] = next;
+  return next;
+}
+function decodeTlds(encoded) {
+  const words = [];
+  const stack = [];
+  let i = 0;
+  let digits = "0123456789";
+  while (i < encoded.length) {
+    let popDigitCount = 0;
+    while (digits.indexOf(encoded[i + popDigitCount]) >= 0) {
+      popDigitCount++;
+    }
+    if (popDigitCount > 0) {
+      words.push(stack.join(""));
+      for (let popCount = parseInt(encoded.substring(i, i + popDigitCount), 10); popCount > 0; popCount--) {
+        stack.pop();
+      }
+      i += popDigitCount;
+    } else {
+      stack.push(encoded[i]);
+      i++;
+    }
+  }
+  return words;
+}
+var defaults = {
+  defaultProtocol: "http",
+  events: null,
+  format: noop,
+  formatHref: noop,
+  nl2br: false,
+  tagName: "a",
+  target: null,
+  rel: null,
+  validate: true,
+  truncate: Infinity,
+  className: null,
+  attributes: null,
+  ignoreTags: [],
+  render: null
+};
+function Options(opts, defaultRender = null) {
+  let o = Object.assign({}, defaults);
+  if (opts) {
+    o = Object.assign(o, opts instanceof Options ? opts.o : opts);
+  }
+  const ignoredTags = o.ignoreTags;
+  const uppercaseIgnoredTags = [];
+  for (let i = 0; i < ignoredTags.length; i++) {
+    uppercaseIgnoredTags.push(ignoredTags[i].toUpperCase());
+  }
+  this.o = o;
+  if (defaultRender) {
+    this.defaultRender = defaultRender;
+  }
+  this.ignoreTags = uppercaseIgnoredTags;
+}
+Options.prototype = {
+  o: defaults,
+  /**
+   * @type string[]
+   */
+  ignoreTags: [],
+  /**
+   * @param {IntermediateRepresentation} ir
+   * @returns {any}
+   */
+  defaultRender(ir) {
+    return ir;
+  },
+  /**
+   * Returns true or false based on whether a token should be displayed as a
+   * link based on the user options.
+   * @param {MultiToken} token
+   * @returns {boolean}
+   */
+  check(token) {
+    return this.get("validate", token.toString(), token);
+  },
+  // Private methods
+  /**
+   * Resolve an option's value based on the value of the option and the given
+   * params. If operator and token are specified and the target option is
+   * callable, automatically calls the function with the given argument.
+   * @template {keyof Opts} K
+   * @param {K} key Name of option to use
+   * @param {string} [operator] will be passed to the target option if it's a
+   * function. If not specified, RAW function value gets returned
+   * @param {MultiToken} [token] The token from linkify.tokenize
+   * @returns {Opts[K] | any}
+   */
+  get(key, operator, token) {
+    const isCallable = operator != null;
+    let option = this.o[key];
+    if (!option) {
+      return option;
+    }
+    if (typeof option === "object") {
+      option = token.t in option ? option[token.t] : defaults[key];
+      if (typeof option === "function" && isCallable) {
+        option = option(operator, token);
+      }
+    } else if (typeof option === "function" && isCallable) {
+      option = option(operator, token.t, token);
+    }
+    return option;
+  },
+  /**
+   * @template {keyof Opts} L
+   * @param {L} key Name of options object to use
+   * @param {string} [operator]
+   * @param {MultiToken} [token]
+   * @returns {Opts[L] | any}
+   */
+  getObj(key, operator, token) {
+    let obj = this.o[key];
+    if (typeof obj === "function" && operator != null) {
+      obj = obj(operator, token.t, token);
+    }
+    return obj;
+  },
+  /**
+   * Convert the given token to a rendered element that may be added to the
+   * calling-interface's DOM
+   * @param {MultiToken} token Token to render to an HTML element
+   * @returns {any} Render result; e.g., HTML string, DOM element, React
+   *   Component, etc.
+   */
+  render(token) {
+    const ir = token.render(this);
+    const renderFn = this.get("render", null, token) || this.defaultRender;
+    return renderFn(ir, token.t, token);
+  }
+};
+function noop(val) {
+  return val;
+}
+function MultiToken(value, tokens) {
+  this.t = "token";
+  this.v = value;
+  this.tk = tokens;
+}
+MultiToken.prototype = {
+  isLink: false,
+  /**
+   * Return the string this token represents.
+   * @return {string}
+   */
+  toString() {
+    return this.v;
+  },
+  /**
+   * What should the value for this token be in the `href` HTML attribute?
+   * Returns the `.toString` value by default.
+   * @param {string} [scheme]
+   * @return {string}
+   */
+  toHref(scheme2) {
+    return this.toString();
+  },
+  /**
+   * @param {Options} options Formatting options
+   * @returns {string}
+   */
+  toFormattedString(options) {
+    const val = this.toString();
+    const truncate = options.get("truncate", val, this);
+    const formatted = options.get("format", val, this);
+    return truncate && formatted.length > truncate ? formatted.substring(0, truncate) + "\u2026" : formatted;
+  },
+  /**
+   *
+   * @param {Options} options
+   * @returns {string}
+   */
+  toFormattedHref(options) {
+    return options.get("formatHref", this.toHref(options.get("defaultProtocol")), this);
+  },
+  /**
+   * The start index of this token in the original input string
+   * @returns {number}
+   */
+  startIndex() {
+    return this.tk[0].s;
+  },
+  /**
+   * The end index of this token in the original input string (up to this
+   * index but not including it)
+   * @returns {number}
+   */
+  endIndex() {
+    return this.tk[this.tk.length - 1].e;
+  },
+  /**
+  	Returns an object  of relevant values for this token, which includes keys
+  	* type - Kind of token ('url', 'email', etc.)
+  	* value - Original text
+  	* href - The value that should be added to the anchor tag's href
+  		attribute
+  		@method toObject
+  	@param {string} [protocol] `'http'` by default
+  */
+  toObject(protocol = defaults.defaultProtocol) {
+    return {
+      type: this.t,
+      value: this.toString(),
+      isLink: this.isLink,
+      href: this.toHref(protocol),
+      start: this.startIndex(),
+      end: this.endIndex()
+    };
+  },
+  /**
+   *
+   * @param {Options} options Formatting option
+   */
+  toFormattedObject(options) {
+    return {
+      type: this.t,
+      value: this.toFormattedString(options),
+      isLink: this.isLink,
+      href: this.toFormattedHref(options),
+      start: this.startIndex(),
+      end: this.endIndex()
+    };
+  },
+  /**
+   * Whether this token should be rendered as a link according to the given options
+   * @param {Options} options
+   * @returns {boolean}
+   */
+  validate(options) {
+    return options.get("validate", this.toString(), this);
+  },
+  /**
+   * Return an object that represents how this link should be rendered.
+   * @param {Options} options Formattinng options
+   */
+  render(options) {
+    const token = this;
+    const href = this.toHref(options.get("defaultProtocol"));
+    const formattedHref = options.get("formatHref", href, this);
+    const tagName = options.get("tagName", href, token);
+    const content = this.toFormattedString(options);
+    const attributes = {};
+    const className = options.get("className", href, token);
+    const target = options.get("target", href, token);
+    const rel = options.get("rel", href, token);
+    const attrs = options.getObj("attributes", href, token);
+    const eventListeners = options.getObj("events", href, token);
+    attributes.href = formattedHref;
+    if (className) {
+      attributes.class = className;
+    }
+    if (target) {
+      attributes.target = target;
+    }
+    if (rel) {
+      attributes.rel = rel;
+    }
+    if (attrs) {
+      Object.assign(attributes, attrs);
+    }
+    return {
+      tagName,
+      attributes,
+      content,
+      eventListeners
+    };
+  }
+};
+function createTokenClass(type, props) {
+  class Token extends MultiToken {
+    constructor(value, tokens) {
+      super(value, tokens);
+      this.t = type;
+    }
+  }
+  for (const p in props) {
+    Token.prototype[p] = props[p];
+  }
+  Token.t = type;
+  return Token;
+}
+var Email = createTokenClass("email", {
+  isLink: true,
+  toHref() {
+    return "mailto:" + this.toString();
+  }
+});
+var Text2 = createTokenClass("text");
+var Nl = createTokenClass("nl");
+var Url = createTokenClass("url", {
+  isLink: true,
+  /**
+  	Lowercases relevant parts of the domain and adds the protocol if
+  	required. Note that this will not escape unsafe HTML characters in the
+  	URL.
+  		@param {string} [scheme] default scheme (e.g., 'https')
+  	@return {string} the full href
+  */
+  toHref(scheme2 = defaults.defaultProtocol) {
+    return this.hasProtocol() ? this.v : `${scheme2}://${this.v}`;
+  },
+  /**
+   * Check whether this URL token has a protocol
+   * @return {boolean}
+   */
+  hasProtocol() {
+    const tokens = this.tk;
+    return tokens.length >= 2 && tokens[0].t !== LOCALHOST && tokens[1].t === COLON;
+  }
+});
+var makeState = (arg) => new State(arg);
+function init$1({
+  groups
+}) {
+  const qsAccepting = groups.domain.concat([AMPERSAND, ASTERISK, AT, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, NUM, PERCENT, PIPE, PLUS, POUND, SLASH, SYM, TILDE, UNDERSCORE]);
+  const qsNonAccepting = [APOSTROPHE, COLON, COMMA, DOT, EXCLAMATION, PERCENT, QUERY, QUOTE, SEMI, OPENANGLEBRACKET, CLOSEANGLEBRACKET, OPENBRACE, CLOSEBRACE, CLOSEBRACKET, OPENBRACKET, OPENPAREN, CLOSEPAREN, FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN, LEFTCORNERBRACKET, RIGHTCORNERBRACKET, LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET, FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN];
+  const localpartAccepting = [AMPERSAND, APOSTROPHE, ASTERISK, BACKSLASH, BACKTICK, CARET, DOLLAR, EQUALS, HYPHEN, OPENBRACE, CLOSEBRACE, PERCENT, PIPE, PLUS, POUND, QUERY, SLASH, SYM, TILDE, UNDERSCORE];
+  const Start = makeState();
+  const Localpart = tt(Start, TILDE);
+  ta(Localpart, localpartAccepting, Localpart);
+  ta(Localpart, groups.domain, Localpart);
+  const Domain = makeState(), Scheme = makeState(), SlashScheme = makeState();
+  ta(Start, groups.domain, Domain);
+  ta(Start, groups.scheme, Scheme);
+  ta(Start, groups.slashscheme, SlashScheme);
+  ta(Domain, localpartAccepting, Localpart);
+  ta(Domain, groups.domain, Domain);
+  const LocalpartAt = tt(Domain, AT);
+  tt(Localpart, AT, LocalpartAt);
+  tt(Scheme, AT, LocalpartAt);
+  tt(SlashScheme, AT, LocalpartAt);
+  const LocalpartDot = tt(Localpart, DOT);
+  ta(LocalpartDot, localpartAccepting, Localpart);
+  ta(LocalpartDot, groups.domain, Localpart);
+  const EmailDomain = makeState();
+  ta(LocalpartAt, groups.domain, EmailDomain);
+  ta(EmailDomain, groups.domain, EmailDomain);
+  const EmailDomainDot = tt(EmailDomain, DOT);
+  ta(EmailDomainDot, groups.domain, EmailDomain);
+  const Email$1 = makeState(Email);
+  ta(EmailDomainDot, groups.tld, Email$1);
+  ta(EmailDomainDot, groups.utld, Email$1);
+  tt(LocalpartAt, LOCALHOST, Email$1);
+  const EmailDomainHyphen = tt(EmailDomain, HYPHEN);
+  tt(EmailDomainHyphen, HYPHEN, EmailDomainHyphen);
+  ta(EmailDomainHyphen, groups.domain, EmailDomain);
+  ta(Email$1, groups.domain, EmailDomain);
+  tt(Email$1, DOT, EmailDomainDot);
+  tt(Email$1, HYPHEN, EmailDomainHyphen);
+  const EmailColon = tt(Email$1, COLON);
+  ta(EmailColon, groups.numeric, Email);
+  const DomainHyphen = tt(Domain, HYPHEN);
+  const DomainDot = tt(Domain, DOT);
+  tt(DomainHyphen, HYPHEN, DomainHyphen);
+  ta(DomainHyphen, groups.domain, Domain);
+  ta(DomainDot, localpartAccepting, Localpart);
+  ta(DomainDot, groups.domain, Domain);
+  const DomainDotTld = makeState(Url);
+  ta(DomainDot, groups.tld, DomainDotTld);
+  ta(DomainDot, groups.utld, DomainDotTld);
+  ta(DomainDotTld, groups.domain, Domain);
+  ta(DomainDotTld, localpartAccepting, Localpart);
+  tt(DomainDotTld, DOT, DomainDot);
+  tt(DomainDotTld, HYPHEN, DomainHyphen);
+  tt(DomainDotTld, AT, LocalpartAt);
+  const DomainDotTldColon = tt(DomainDotTld, COLON);
+  const DomainDotTldColonPort = makeState(Url);
+  ta(DomainDotTldColon, groups.numeric, DomainDotTldColonPort);
+  const Url$1 = makeState(Url);
+  const UrlNonaccept = makeState();
+  ta(Url$1, qsAccepting, Url$1);
+  ta(Url$1, qsNonAccepting, UrlNonaccept);
+  ta(UrlNonaccept, qsAccepting, Url$1);
+  ta(UrlNonaccept, qsNonAccepting, UrlNonaccept);
+  tt(DomainDotTld, SLASH, Url$1);
+  tt(DomainDotTldColonPort, SLASH, Url$1);
+  const SchemeColon = tt(Scheme, COLON);
+  const SlashSchemeColon = tt(SlashScheme, COLON);
+  const SlashSchemeColonSlash = tt(SlashSchemeColon, SLASH);
+  const UriPrefix = tt(SlashSchemeColonSlash, SLASH);
+  ta(Scheme, groups.domain, Domain);
+  tt(Scheme, DOT, DomainDot);
+  tt(Scheme, HYPHEN, DomainHyphen);
+  ta(SlashScheme, groups.domain, Domain);
+  tt(SlashScheme, DOT, DomainDot);
+  tt(SlashScheme, HYPHEN, DomainHyphen);
+  ta(SchemeColon, groups.domain, Url$1);
+  tt(SchemeColon, SLASH, Url$1);
+  tt(SchemeColon, QUERY, Url$1);
+  ta(UriPrefix, groups.domain, Url$1);
+  ta(UriPrefix, qsAccepting, Url$1);
+  tt(UriPrefix, SLASH, Url$1);
+  const bracketPairs = [
+    [OPENBRACE, CLOSEBRACE],
+    // {}
+    [OPENBRACKET, CLOSEBRACKET],
+    // []
+    [OPENPAREN, CLOSEPAREN],
+    // ()
+    [OPENANGLEBRACKET, CLOSEANGLEBRACKET],
+    // <>
+    [FULLWIDTHLEFTPAREN, FULLWIDTHRIGHTPAREN],
+    // （）
+    [LEFTCORNERBRACKET, RIGHTCORNERBRACKET],
+    // 「」
+    [LEFTWHITECORNERBRACKET, RIGHTWHITECORNERBRACKET],
+    // 『』
+    [FULLWIDTHLESSTHAN, FULLWIDTHGREATERTHAN]
+    // ＜＞
+  ];
+  for (let i = 0; i < bracketPairs.length; i++) {
+    const [OPEN, CLOSE] = bracketPairs[i];
+    const UrlOpen = tt(Url$1, OPEN);
+    tt(UrlNonaccept, OPEN, UrlOpen);
+    tt(UrlOpen, CLOSE, Url$1);
+    const UrlOpenQ = makeState(Url);
+    ta(UrlOpen, qsAccepting, UrlOpenQ);
+    const UrlOpenSyms = makeState();
+    ta(UrlOpen, qsNonAccepting);
+    ta(UrlOpenQ, qsAccepting, UrlOpenQ);
+    ta(UrlOpenQ, qsNonAccepting, UrlOpenSyms);
+    ta(UrlOpenSyms, qsAccepting, UrlOpenQ);
+    ta(UrlOpenSyms, qsNonAccepting, UrlOpenSyms);
+    tt(UrlOpenQ, CLOSE, Url$1);
+    tt(UrlOpenSyms, CLOSE, Url$1);
+  }
+  tt(Start, LOCALHOST, DomainDotTld);
+  tt(Start, NL, Nl);
+  return {
+    start: Start,
+    tokens: tk
+  };
+}
+function run(start, input, tokens) {
+  let len = tokens.length;
+  let cursor = 0;
+  let multis = [];
+  let textTokens = [];
+  while (cursor < len) {
+    let state = start;
+    let secondState = null;
+    let nextState = null;
+    let multiLength = 0;
+    let latestAccepting = null;
+    let sinceAccepts = -1;
+    while (cursor < len && !(secondState = state.go(tokens[cursor].t))) {
+      textTokens.push(tokens[cursor++]);
+    }
+    while (cursor < len && (nextState = secondState || state.go(tokens[cursor].t))) {
+      secondState = null;
+      state = nextState;
+      if (state.accepts()) {
+        sinceAccepts = 0;
+        latestAccepting = state;
+      } else if (sinceAccepts >= 0) {
+        sinceAccepts++;
+      }
+      cursor++;
+      multiLength++;
+    }
+    if (sinceAccepts < 0) {
+      cursor -= multiLength;
+      if (cursor < len) {
+        textTokens.push(tokens[cursor]);
+        cursor++;
+      }
+    } else {
+      if (textTokens.length > 0) {
+        multis.push(initMultiToken(Text2, input, textTokens));
+        textTokens = [];
+      }
+      cursor -= sinceAccepts;
+      multiLength -= sinceAccepts;
+      const Multi = latestAccepting.t;
+      const subtokens = tokens.slice(cursor - multiLength, cursor);
+      multis.push(initMultiToken(Multi, input, subtokens));
+    }
+  }
+  if (textTokens.length > 0) {
+    multis.push(initMultiToken(Text2, input, textTokens));
+  }
+  return multis;
+}
+function initMultiToken(Multi, input, tokens) {
+  const startIdx = tokens[0].s;
+  const endIdx = tokens[tokens.length - 1].e;
+  const value = input.slice(startIdx, endIdx);
+  return new Multi(value, tokens);
+}
+var warn = typeof console !== "undefined" && console && console.warn || (() => {
+});
+var warnAdvice = "until manual call of linkify.init(). Register all schemes and plugins before invoking linkify the first time.";
+var INIT = {
+  scanner: null,
+  parser: null,
+  tokenQueue: [],
+  pluginQueue: [],
+  customSchemes: [],
+  initialized: false
+};
+function reset() {
+  State.groups = {};
+  INIT.scanner = null;
+  INIT.parser = null;
+  INIT.tokenQueue = [];
+  INIT.pluginQueue = [];
+  INIT.customSchemes = [];
+  INIT.initialized = false;
+  return INIT;
+}
+function registerCustomProtocol(scheme2, optionalSlashSlash = false) {
+  if (INIT.initialized) {
+    warn(`linkifyjs: already initialized - will not register custom scheme "${scheme2}" ${warnAdvice}`);
+  }
+  if (!/^[0-9a-z]+(-[0-9a-z]+)*$/.test(scheme2)) {
+    throw new Error(`linkifyjs: incorrect scheme format.
+1. Must only contain digits, lowercase ASCII letters or "-"
+2. Cannot start or end with "-"
+3. "-" cannot repeat`);
+  }
+  INIT.customSchemes.push([scheme2, optionalSlashSlash]);
+}
+function init() {
+  INIT.scanner = init$2(INIT.customSchemes);
+  for (let i = 0; i < INIT.tokenQueue.length; i++) {
+    INIT.tokenQueue[i][1]({
+      scanner: INIT.scanner
+    });
+  }
+  INIT.parser = init$1(INIT.scanner.tokens);
+  for (let i = 0; i < INIT.pluginQueue.length; i++) {
+    INIT.pluginQueue[i][1]({
+      scanner: INIT.scanner,
+      parser: INIT.parser
+    });
+  }
+  INIT.initialized = true;
+  return INIT;
+}
+function tokenize(str) {
+  if (!INIT.initialized) {
+    init();
+  }
+  return run(INIT.parser.start, str, run$1(INIT.scanner.start, str));
+}
+tokenize.scan = run$1;
+function find(str, type = null, opts = null) {
+  if (type && typeof type === "object") {
+    if (opts) {
+      throw Error(`linkifyjs: Invalid link type ${type}; must be a string`);
+    }
+    opts = type;
+    type = null;
+  }
+  const options = new Options(opts);
+  const tokens = tokenize(str);
+  const filtered = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.isLink && (!type || token.t === type) && options.check(token)) {
+      filtered.push(token.toFormattedObject(options));
+    }
+  }
+  return filtered;
+}
+
+// ../../node_modules/.pnpm/@tiptap+extension-link@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-link/dist/index.js
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+var UNICODE_WHITESPACE_PATTERN = "[\0- \xA0\u1680\u180E\u2000-\u2029\u205F\u3000]";
+var UNICODE_WHITESPACE_REGEX = new RegExp(UNICODE_WHITESPACE_PATTERN);
+var UNICODE_WHITESPACE_REGEX_END = new RegExp(`${UNICODE_WHITESPACE_PATTERN}$`);
+var UNICODE_WHITESPACE_REGEX_GLOBAL = new RegExp(UNICODE_WHITESPACE_PATTERN, "g");
+function isValidLinkStructure(tokens) {
+  if (tokens.length === 1) {
+    return tokens[0].isLink;
+  }
+  if (tokens.length === 3 && tokens[1].isLink) {
+    return ["()", "[]"].includes(tokens[0].value + tokens[2].value);
+  }
+  return false;
+}
+function autolink(options) {
+  return new Plugin({
+    key: new PluginKey("autolink"),
+    appendTransaction: (transactions, oldState, newState) => {
+      const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
+      const preventAutolink = transactions.some((transaction) => transaction.getMeta("preventAutolink"));
+      if (!docChanges || preventAutolink) {
+        return;
+      }
+      const { tr: tr2 } = newState;
+      const transform = combineTransactionSteps(oldState.doc, [...transactions]);
+      const changes = getChangedRanges(transform);
+      changes.forEach(({ newRange }) => {
+        const nodesInChangedRanges = findChildrenInRange(newState.doc, newRange, (node) => node.isTextblock);
+        let textBlock;
+        let textBeforeWhitespace;
+        if (nodesInChangedRanges.length > 1) {
+          textBlock = nodesInChangedRanges[0];
+          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, textBlock.pos + textBlock.node.nodeSize, void 0, " ");
+        } else if (nodesInChangedRanges.length) {
+          const endText = newState.doc.textBetween(newRange.from, newRange.to, " ", " ");
+          if (!UNICODE_WHITESPACE_REGEX_END.test(endText)) {
+            return;
+          }
+          textBlock = nodesInChangedRanges[0];
+          textBeforeWhitespace = newState.doc.textBetween(textBlock.pos, newRange.to, void 0, " ");
+        }
+        if (textBlock && textBeforeWhitespace) {
+          const wordsBeforeWhitespace = textBeforeWhitespace.split(UNICODE_WHITESPACE_REGEX).filter(Boolean);
+          if (wordsBeforeWhitespace.length <= 0) {
+            return false;
+          }
+          const lastWordBeforeSpace = wordsBeforeWhitespace[wordsBeforeWhitespace.length - 1];
+          const lastWordAndBlockOffset = textBlock.pos + textBeforeWhitespace.lastIndexOf(lastWordBeforeSpace);
+          if (!lastWordBeforeSpace) {
+            return false;
+          }
+          const linksBeforeSpace = tokenize(lastWordBeforeSpace).map((t) => t.toObject(options.defaultProtocol));
+          if (!isValidLinkStructure(linksBeforeSpace)) {
+            return false;
+          }
+          linksBeforeSpace.filter((link) => link.isLink).map((link) => ({
+            ...link,
+            from: lastWordAndBlockOffset + link.start + 1,
+            to: lastWordAndBlockOffset + link.end + 1
+          })).filter((link) => {
+            if (!newState.schema.marks.code) {
+              return true;
+            }
+            return !newState.doc.rangeHasMark(link.from, link.to, newState.schema.marks.code);
+          }).filter((link) => options.validate(link.value)).filter((link) => options.shouldAutoLink(link.value)).forEach((link) => {
+            if (getMarksBetween(link.from, link.to, newState.doc).some((item) => item.mark.type === options.type)) {
+              return;
+            }
+            tr2.addMark(link.from, link.to, options.type.create({
+              href: link.href
+            }));
+          });
+        }
+      });
+      if (!tr2.steps.length) {
+        return;
+      }
+      return tr2;
+    }
+  });
+}
+function clickHandler(options) {
+  return new Plugin({
+    key: new PluginKey("handleClickLink"),
+    props: {
+      handleClick: (view, pos, event) => {
+        var _a, _b;
+        if (event.button !== 0) {
+          return false;
+        }
+        if (!view.editable) {
+          return false;
+        }
+        let a = event.target;
+        const els = [];
+        while (a.nodeName !== "DIV") {
+          els.push(a);
+          a = a.parentNode;
+        }
+        if (!els.find((value) => value.nodeName === "A")) {
+          return false;
+        }
+        const attrs = getAttributes(view.state, options.type.name);
+        const link = event.target;
+        const href = (_a = link === null || link === void 0 ? void 0 : link.href) !== null && _a !== void 0 ? _a : attrs.href;
+        const target = (_b = link === null || link === void 0 ? void 0 : link.target) !== null && _b !== void 0 ? _b : attrs.target;
+        if (link && href) {
+          window.open(href, target);
+          return true;
+        }
+        return false;
+      }
+    }
+  });
+}
+function pasteHandler(options) {
+  return new Plugin({
+    key: new PluginKey("handlePasteLink"),
+    props: {
+      handlePaste: (view, event, slice) => {
+        const { state } = view;
+        const { selection } = state;
+        const { empty } = selection;
+        if (empty) {
+          return false;
+        }
+        let textContent = "";
+        slice.content.forEach((node) => {
+          textContent += node.textContent;
+        });
+        const link = find(textContent, { defaultProtocol: options.defaultProtocol }).find((item) => item.isLink && item.value === textContent);
+        if (!textContent || !link) {
+          return false;
+        }
+        return options.editor.commands.setMark(options.type, {
+          href: link.href
+        });
+      }
+    }
+  });
+}
+function isAllowedUri(uri, protocols) {
+  const allowedProtocols = [
+    "http",
+    "https",
+    "ftp",
+    "ftps",
+    "mailto",
+    "tel",
+    "callto",
+    "sms",
+    "cid",
+    "xmpp"
+  ];
+  if (protocols) {
+    protocols.forEach((protocol) => {
+      const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
+      if (nextProtocol) {
+        allowedProtocols.push(nextProtocol);
+      }
+    });
+  }
+  return !uri || uri.replace(UNICODE_WHITESPACE_REGEX_GLOBAL, "").match(new RegExp(
+    // eslint-disable-next-line no-useless-escape
+    `^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+    "i"
+  ));
+}
+var Link = Mark5.create({
+  name: "link",
+  priority: 1e3,
+  keepOnSplit: false,
+  exitable: true,
+  onCreate() {
+    if (this.options.validate && !this.options.shouldAutoLink) {
+      this.options.shouldAutoLink = this.options.validate;
+      console.warn("The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.");
+    }
+    this.options.protocols.forEach((protocol) => {
+      if (typeof protocol === "string") {
+        registerCustomProtocol(protocol);
+        return;
+      }
+      registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
+    });
+  },
+  onDestroy() {
+    reset();
+  },
+  inclusive() {
+    return this.options.autolink;
+  },
+  addOptions() {
+    return {
+      openOnClick: true,
+      linkOnPaste: true,
+      autolink: true,
+      protocols: [],
+      defaultProtocol: "http",
+      HTMLAttributes: {
+        target: "_blank",
+        rel: "noopener noreferrer nofollow",
+        class: null
+      },
+      isAllowedUri: (url, ctx) => !!isAllowedUri(url, ctx.protocols),
+      validate: (url) => !!url,
+      shouldAutoLink: (url) => !!url
+    };
+  },
+  addAttributes() {
+    return {
+      href: {
+        default: null,
+        parseHTML(element) {
+          return element.getAttribute("href");
+        }
+      },
+      target: {
+        default: this.options.HTMLAttributes.target
+      },
+      rel: {
+        default: this.options.HTMLAttributes.rel
+      },
+      class: {
+        default: this.options.HTMLAttributes.class
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "a[href]",
+        getAttrs: (dom) => {
+          const href = dom.getAttribute("href");
+          if (!href || !this.options.isAllowedUri(href, {
+            defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
+            protocols: this.options.protocols,
+            defaultProtocol: this.options.defaultProtocol
+          })) {
+            return false;
+          }
+          return null;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    if (!this.options.isAllowedUri(HTMLAttributes.href, {
+      defaultValidate: (href) => !!isAllowedUri(href, this.options.protocols),
+      protocols: this.options.protocols,
+      defaultProtocol: this.options.defaultProtocol
+    })) {
+      return [
+        "a",
+        mergeAttributes15(this.options.HTMLAttributes, { ...HTMLAttributes, href: "" }),
+        0
+      ];
+    }
+    return ["a", mergeAttributes15(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setLink: (attributes) => ({ chain }) => {
+        const { href } = attributes;
+        if (!this.options.isAllowedUri(href, {
+          defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        })) {
+          return false;
+        }
+        return chain().setMark(this.name, attributes).setMeta("preventAutolink", true).run();
+      },
+      toggleLink: (attributes) => ({ chain }) => {
+        const { href } = attributes;
+        if (!this.options.isAllowedUri(href, {
+          defaultValidate: (url) => !!isAllowedUri(url, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        })) {
+          return false;
+        }
+        return chain().toggleMark(this.name, attributes, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
+      },
+      unsetLink: () => ({ chain }) => {
+        return chain().unsetMark(this.name, { extendEmptyMarkRange: true }).setMeta("preventAutolink", true).run();
+      }
+    };
+  },
+  addPasteRules() {
+    return [
+      markPasteRule4({
+        find: (text) => {
+          const foundLinks = [];
+          if (text) {
+            const { protocols, defaultProtocol } = this.options;
+            const links = find(text).filter((item) => item.isLink && this.options.isAllowedUri(item.value, {
+              defaultValidate: (href) => !!isAllowedUri(href, protocols),
+              protocols,
+              defaultProtocol
+            }));
+            if (links.length) {
+              links.forEach((link) => foundLinks.push({
+                text: link.value,
+                data: {
+                  href: link.href
+                },
+                index: link.start
+              }));
+            }
+          }
+          return foundLinks;
+        },
+        type: this.type,
+        getAttributes: (match) => {
+          var _a;
+          return {
+            href: (_a = match.data) === null || _a === void 0 ? void 0 : _a.href
+          };
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    const plugins = [];
+    const { protocols, defaultProtocol } = this.options;
+    if (this.options.autolink) {
+      plugins.push(autolink({
+        type: this.type,
+        defaultProtocol: this.options.defaultProtocol,
+        validate: (url) => this.options.isAllowedUri(url, {
+          defaultValidate: (href) => !!isAllowedUri(href, protocols),
+          protocols,
+          defaultProtocol
+        }),
+        shouldAutoLink: this.options.shouldAutoLink
+      }));
+    }
+    if (this.options.openOnClick === true) {
+      plugins.push(clickHandler({
+        type: this.type
+      }));
+    }
+    if (this.options.linkOnPaste) {
+      plugins.push(pasteHandler({
+        editor: this.editor,
+        defaultProtocol: this.options.defaultProtocol,
+        type: this.type
+      }));
+    }
+    return plugins;
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-image@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-image/dist/index.js
+import { Node as Node13, mergeAttributes as mergeAttributes16, nodeInputRule as nodeInputRule2 } from "@tiptap/core";
+var inputRegex6 = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/;
+var Image = Node13.create({
+  name: "image",
+  addOptions() {
+    return {
+      inline: false,
+      allowBase64: false,
+      HTMLAttributes: {}
+    };
+  },
+  inline() {
+    return this.options.inline;
+  },
+  group() {
+    return this.options.inline ? "inline" : "block";
+  },
+  draggable: true,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      },
+      alt: {
+        default: null
+      },
+      title: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["img", mergeAttributes16(this.options.HTMLAttributes, HTMLAttributes)];
+  },
+  addCommands() {
+    return {
+      setImage: (options) => ({ commands }) => {
+        return commands.insertContent({
+          type: this.name,
+          attrs: options
+        });
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      nodeInputRule2({
+        find: inputRegex6,
+        type: this.type,
+        getAttributes: (match) => {
+          const [, , alt, src, title] = match;
+          return { src, alt, title };
+        }
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-highlight@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-highlight/dist/index.js
+import { Mark as Mark6, mergeAttributes as mergeAttributes17, markInputRule as markInputRule4, markPasteRule as markPasteRule5 } from "@tiptap/core";
+var inputRegex7 = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))$/;
+var pasteRegex2 = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))/g;
+var Highlight = Mark6.create({
+  name: "highlight",
+  addOptions() {
+    return {
+      multicolor: false,
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    if (!this.options.multicolor) {
+      return {};
+    }
+    return {
+      color: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-color") || element.style.backgroundColor,
+        renderHTML: (attributes) => {
+          if (!attributes.color) {
+            return {};
+          }
+          return {
+            "data-color": attributes.color,
+            style: `background-color: ${attributes.color}; color: inherit`
+          };
+        }
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "mark"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["mark", mergeAttributes17(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setHighlight: (attributes) => ({ commands }) => {
+        return commands.setMark(this.name, attributes);
+      },
+      toggleHighlight: (attributes) => ({ commands }) => {
+        return commands.toggleMark(this.name, attributes);
+      },
+      unsetHighlight: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-h": () => this.editor.commands.toggleHighlight()
+    };
+  },
+  addInputRules() {
+    return [
+      markInputRule4({
+        find: inputRegex7,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      markPasteRule5({
+        find: pasteRegex2,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-typography@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-typography/dist/index.js
+import { Extension as Extension4, textInputRule } from "@tiptap/core";
+var emDash = (override) => textInputRule({
+  find: /--$/,
+  replace: override !== null && override !== void 0 ? override : "\u2014"
+});
+var ellipsis = (override) => textInputRule({
+  find: /\.\.\.$/,
+  replace: override !== null && override !== void 0 ? override : "\u2026"
+});
+var openDoubleQuote = (override) => textInputRule({
+  find: /(?:^|[\s{[(<'"\u2018\u201C])(")$/,
+  replace: override !== null && override !== void 0 ? override : "\u201C"
+});
+var closeDoubleQuote = (override) => textInputRule({
+  find: /"$/,
+  replace: override !== null && override !== void 0 ? override : "\u201D"
+});
+var openSingleQuote = (override) => textInputRule({
+  find: /(?:^|[\s{[(<'"\u2018\u201C])(')$/,
+  replace: override !== null && override !== void 0 ? override : "\u2018"
+});
+var closeSingleQuote = (override) => textInputRule({
+  find: /'$/,
+  replace: override !== null && override !== void 0 ? override : "\u2019"
+});
+var leftArrow = (override) => textInputRule({
+  find: /<-$/,
+  replace: override !== null && override !== void 0 ? override : "\u2190"
+});
+var rightArrow = (override) => textInputRule({
+  find: /->$/,
+  replace: override !== null && override !== void 0 ? override : "\u2192"
+});
+var copyright = (override) => textInputRule({
+  find: /\(c\)$/,
+  replace: override !== null && override !== void 0 ? override : "\xA9"
+});
+var trademark = (override) => textInputRule({
+  find: /\(tm\)$/,
+  replace: override !== null && override !== void 0 ? override : "\u2122"
+});
+var servicemark = (override) => textInputRule({
+  find: /\(sm\)$/,
+  replace: override !== null && override !== void 0 ? override : "\u2120"
+});
+var registeredTrademark = (override) => textInputRule({
+  find: /\(r\)$/,
+  replace: override !== null && override !== void 0 ? override : "\xAE"
+});
+var oneHalf = (override) => textInputRule({
+  find: /(?:^|\s)(1\/2)\s$/,
+  replace: override !== null && override !== void 0 ? override : "\xBD"
+});
+var plusMinus = (override) => textInputRule({
+  find: /\+\/-$/,
+  replace: override !== null && override !== void 0 ? override : "\xB1"
+});
+var notEqual = (override) => textInputRule({
+  find: /!=$/,
+  replace: override !== null && override !== void 0 ? override : "\u2260"
+});
+var laquo = (override) => textInputRule({
+  find: /<<$/,
+  replace: override !== null && override !== void 0 ? override : "\xAB"
+});
+var raquo = (override) => textInputRule({
+  find: />>$/,
+  replace: override !== null && override !== void 0 ? override : "\xBB"
+});
+var multiplication = (override) => textInputRule({
+  find: /\d+\s?([*x])\s?\d+$/,
+  replace: override !== null && override !== void 0 ? override : "\xD7"
+});
+var superscriptTwo = (override) => textInputRule({
+  find: /\^2$/,
+  replace: override !== null && override !== void 0 ? override : "\xB2"
+});
+var superscriptThree = (override) => textInputRule({
+  find: /\^3$/,
+  replace: override !== null && override !== void 0 ? override : "\xB3"
+});
+var oneQuarter = (override) => textInputRule({
+  find: /(?:^|\s)(1\/4)\s$/,
+  replace: override !== null && override !== void 0 ? override : "\xBC"
+});
+var threeQuarters = (override) => textInputRule({
+  find: /(?:^|\s)(3\/4)\s$/,
+  replace: override !== null && override !== void 0 ? override : "\xBE"
+});
+var Typography = Extension4.create({
+  name: "typography",
+  addOptions() {
+    return {
+      closeDoubleQuote: "\u201D",
+      closeSingleQuote: "\u2019",
+      copyright: "\xA9",
+      ellipsis: "\u2026",
+      emDash: "\u2014",
+      laquo: "\xAB",
+      leftArrow: "\u2190",
+      multiplication: "\xD7",
+      notEqual: "\u2260",
+      oneHalf: "\xBD",
+      oneQuarter: "\xBC",
+      openDoubleQuote: "\u201C",
+      openSingleQuote: "\u2018",
+      plusMinus: "\xB1",
+      raquo: "\xBB",
+      registeredTrademark: "\xAE",
+      rightArrow: "\u2192",
+      servicemark: "\u2120",
+      superscriptThree: "\xB3",
+      superscriptTwo: "\xB2",
+      threeQuarters: "\xBE",
+      trademark: "\u2122"
+    };
+  },
+  addInputRules() {
+    const rules = [];
+    if (this.options.emDash !== false) {
+      rules.push(emDash(this.options.emDash));
+    }
+    if (this.options.ellipsis !== false) {
+      rules.push(ellipsis(this.options.ellipsis));
+    }
+    if (this.options.openDoubleQuote !== false) {
+      rules.push(openDoubleQuote(this.options.openDoubleQuote));
+    }
+    if (this.options.closeDoubleQuote !== false) {
+      rules.push(closeDoubleQuote(this.options.closeDoubleQuote));
+    }
+    if (this.options.openSingleQuote !== false) {
+      rules.push(openSingleQuote(this.options.openSingleQuote));
+    }
+    if (this.options.closeSingleQuote !== false) {
+      rules.push(closeSingleQuote(this.options.closeSingleQuote));
+    }
+    if (this.options.leftArrow !== false) {
+      rules.push(leftArrow(this.options.leftArrow));
+    }
+    if (this.options.rightArrow !== false) {
+      rules.push(rightArrow(this.options.rightArrow));
+    }
+    if (this.options.copyright !== false) {
+      rules.push(copyright(this.options.copyright));
+    }
+    if (this.options.trademark !== false) {
+      rules.push(trademark(this.options.trademark));
+    }
+    if (this.options.servicemark !== false) {
+      rules.push(servicemark(this.options.servicemark));
+    }
+    if (this.options.registeredTrademark !== false) {
+      rules.push(registeredTrademark(this.options.registeredTrademark));
+    }
+    if (this.options.oneHalf !== false) {
+      rules.push(oneHalf(this.options.oneHalf));
+    }
+    if (this.options.plusMinus !== false) {
+      rules.push(plusMinus(this.options.plusMinus));
+    }
+    if (this.options.notEqual !== false) {
+      rules.push(notEqual(this.options.notEqual));
+    }
+    if (this.options.laquo !== false) {
+      rules.push(laquo(this.options.laquo));
+    }
+    if (this.options.raquo !== false) {
+      rules.push(raquo(this.options.raquo));
+    }
+    if (this.options.multiplication !== false) {
+      rules.push(multiplication(this.options.multiplication));
+    }
+    if (this.options.superscriptTwo !== false) {
+      rules.push(superscriptTwo(this.options.superscriptTwo));
+    }
+    if (this.options.superscriptThree !== false) {
+      rules.push(superscriptThree(this.options.superscriptThree));
+    }
+    if (this.options.oneQuarter !== false) {
+      rules.push(oneQuarter(this.options.oneQuarter));
+    }
+    if (this.options.threeQuarters !== false) {
+      rules.push(threeQuarters(this.options.threeQuarters));
+    }
+    return rules;
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-placeholder@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-placeholder/dist/index.js
+import { Extension as Extension5, isNodeEmpty } from "@tiptap/core";
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var Placeholder = Extension5.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      placeholder: "Write something \u2026",
+      showOnlyWhenEditable: true,
+      showOnlyCurrent: true,
+      includeChildren: false
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin2({
+        key: new PluginKey2("placeholder"),
+        props: {
+          decorations: ({ doc, selection }) => {
+            const active = this.editor.isEditable || !this.options.showOnlyWhenEditable;
+            const { anchor } = selection;
+            const decorations = [];
+            if (!active) {
+              return null;
+            }
+            const isEmptyDoc = this.editor.isEmpty;
+            doc.descendants((node, pos) => {
+              const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
+              const isEmpty = !node.isLeaf && isNodeEmpty(node);
+              if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
+                const classes = [this.options.emptyNodeClass];
+                if (isEmptyDoc) {
+                  classes.push(this.options.emptyEditorClass);
+                }
+                const decoration = Decoration.node(pos, pos + node.nodeSize, {
+                  class: classes.join(" "),
+                  "data-placeholder": typeof this.options.placeholder === "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node,
+                    pos,
+                    hasAnchor
+                  }) : this.options.placeholder
+                });
+                decorations.push(decoration);
+              }
+              return this.options.includeChildren;
+            });
+            return DecorationSet.create(doc, decorations);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-code@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-code/dist/index.js
+import { Mark as Mark7, mergeAttributes as mergeAttributes18, markInputRule as markInputRule5, markPasteRule as markPasteRule6 } from "@tiptap/core";
+var inputRegex8 = /(^|[^`])`([^`]+)`(?!`)/;
+var pasteRegex3 = /(^|[^`])`([^`]+)`(?!`)/g;
+var Code = Mark7.create({
+  name: "code",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  excludes: "_",
+  code: true,
+  exitable: true,
+  parseHTML() {
+    return [
+      { tag: "code" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["code", mergeAttributes18(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setCode: () => ({ commands }) => {
+        return commands.setMark(this.name);
+      },
+      toggleCode: () => ({ commands }) => {
+        return commands.toggleMark(this.name);
+      },
+      unsetCode: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-e": () => this.editor.commands.toggleCode()
+    };
+  },
+  addInputRules() {
+    return [
+      markInputRule5({
+        find: inputRegex8,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      markPasteRule6({
+        find: pasteRegex3,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-code-block@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-code-block/dist/index.js
+import { Node as Node14, mergeAttributes as mergeAttributes19, textblockTypeInputRule as textblockTypeInputRule2 } from "@tiptap/core";
+import { Selection, Plugin as Plugin3, PluginKey as PluginKey3, TextSelection as TextSelection2 } from "@tiptap/pm/state";
+var backtickInputRegex = /^```([a-z]+)?[\s\n]$/;
+var tildeInputRegex = /^~~~([a-z]+)?[\s\n]$/;
+var CodeBlock = Node14.create({
+  name: "codeBlock",
+  addOptions() {
+    return {
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: true,
+      exitOnArrowDown: true,
+      defaultLanguage: null,
+      HTMLAttributes: {}
+    };
+  },
+  content: "text*",
+  marks: "",
+  group: "block",
+  code: true,
+  defining: true,
+  addAttributes() {
+    return {
+      language: {
+        default: this.options.defaultLanguage,
+        parseHTML: (element) => {
+          var _a;
+          const { languageClassPrefix } = this.options;
+          const classNames = [...((_a = element.firstElementChild) === null || _a === void 0 ? void 0 : _a.classList) || []];
+          const languages = classNames.filter((className) => className.startsWith(languageClassPrefix)).map((className) => className.replace(languageClassPrefix, ""));
+          const language = languages[0];
+          if (!language) {
+            return null;
+          }
+          return language;
+        },
+        rendered: false
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full"
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "pre",
+      mergeAttributes19(this.options.HTMLAttributes, HTMLAttributes),
+      [
+        "code",
+        {
+          class: node.attrs.language ? this.options.languageClassPrefix + node.attrs.language : null
+        },
+        0
+      ]
+    ];
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (attributes) => ({ commands }) => {
+        return commands.setNode(this.name, attributes);
+      },
+      toggleCodeBlock: (attributes) => ({ commands }) => {
+        return commands.toggleNode(this.name, "paragraph", attributes);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
+      // remove code block when at start of document or code block is empty
+      Backspace: () => {
+        const { empty, $anchor } = this.editor.state.selection;
+        const isAtStart = $anchor.pos === 1;
+        if (!empty || $anchor.parent.type.name !== this.name) {
+          return false;
+        }
+        if (isAtStart || !$anchor.parent.textContent.length) {
+          return this.editor.commands.clearNodes();
+        }
+        return false;
+      },
+      // exit node on triple enter
+      Enter: ({ editor }) => {
+        if (!this.options.exitOnTripleEnter) {
+          return false;
+        }
+        const { state } = editor;
+        const { selection } = state;
+        const { $from, empty } = selection;
+        if (!empty || $from.parent.type !== this.type) {
+          return false;
+        }
+        const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
+        const endsWithDoubleNewline = $from.parent.textContent.endsWith("\n\n");
+        if (!isAtEnd || !endsWithDoubleNewline) {
+          return false;
+        }
+        return editor.chain().command(({ tr: tr2 }) => {
+          tr2.delete($from.pos - 2, $from.pos);
+          return true;
+        }).exitCode().run();
+      },
+      // exit node on arrow down
+      ArrowDown: ({ editor }) => {
+        if (!this.options.exitOnArrowDown) {
+          return false;
+        }
+        const { state } = editor;
+        const { selection, doc } = state;
+        const { $from, empty } = selection;
+        if (!empty || $from.parent.type !== this.type) {
+          return false;
+        }
+        const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
+        if (!isAtEnd) {
+          return false;
+        }
+        const after = $from.after();
+        if (after === void 0) {
+          return false;
+        }
+        const nodeAfter = doc.nodeAt(after);
+        if (nodeAfter) {
+          return editor.commands.command(({ tr: tr2 }) => {
+            tr2.setSelection(Selection.near(doc.resolve(after)));
+            return true;
+          });
+        }
+        return editor.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      textblockTypeInputRule2({
+        find: backtickInputRegex,
+        type: this.type,
+        getAttributes: (match) => ({
+          language: match[1]
+        })
+      }),
+      textblockTypeInputRule2({
+        find: tildeInputRegex,
+        type: this.type,
+        getAttributes: (match) => ({
+          language: match[1]
+        })
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      // this plugin creates a code block for pasted content from VS Code
+      // we can also detect the copied code language
+      new Plugin3({
+        key: new PluginKey3("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (view, event) => {
+            if (!event.clipboardData) {
+              return false;
+            }
+            if (this.editor.isActive(this.type.name)) {
+              return false;
+            }
+            const text = event.clipboardData.getData("text/plain");
+            const vscode = event.clipboardData.getData("vscode-editor-data");
+            const vscodeData = vscode ? JSON.parse(vscode) : void 0;
+            const language = vscodeData === null || vscodeData === void 0 ? void 0 : vscodeData.mode;
+            if (!text || !language) {
+              return false;
+            }
+            const { tr: tr2, schema } = view.state;
+            const textNode = schema.text(text.replace(/\r\n?/g, "\n"));
+            tr2.replaceSelectionWith(this.type.create({ language }, textNode));
+            if (tr2.selection.$from.parent.type !== this.type) {
+              tr2.setSelection(TextSelection2.near(tr2.doc.resolve(Math.max(0, tr2.selection.from - 2))));
+            }
+            tr2.setMeta("paste", true);
+            view.dispatch(tr2);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-table-row@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-table-row/dist/index.js
+import { Node as Node15, mergeAttributes as mergeAttributes20 } from "@tiptap/core";
+var TableRow = Node15.create({
+  name: "tableRow",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "(tableCell | tableHeader)*",
+  tableRole: "row",
+  parseHTML() {
+    return [
+      { tag: "tr" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["tr", mergeAttributes20(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
+
+// src/extensions/list-behavior.ts
+import { Extension as Extension6 } from "@tiptap/core";
+function isEmptyParagraphAtStart(editor) {
+  const { selection } = editor.state;
+  return selection.empty && selection.$from.parent.isTextblock && selection.$from.parent.content.size === 0 && selection.$from.parentOffset === 0;
+}
+var LoomaListBehavior = Extension6.create({
+  name: "loomaListBehavior",
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        if (this.editor.isActive("taskItem")) {
+          return this.editor.commands.splitListItem("taskItem");
+        }
+        if (this.editor.isActive("listItem")) {
+          return this.editor.commands.splitListItem("listItem");
+        }
+        return false;
+      },
+      Backspace: () => {
+        if (!isEmptyParagraphAtStart(this.editor)) {
+          return false;
+        }
+        if (this.editor.isActive("taskItem")) {
+          return this.editor.commands.liftListItem("taskItem");
+        }
+        if (this.editor.isActive("listItem")) {
+          return this.editor.commands.liftListItem("listItem");
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-table@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-table/dist/index.js
+import { findParentNodeClosestToPos, Node as Node16, mergeAttributes as mergeAttributes21, callOrReturn as callOrReturn2, getExtensionField as getExtensionField2 } from "@tiptap/core";
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+import { CellSelection, addColumnBefore, addColumnAfter, deleteColumn, addRowBefore, addRowAfter, deleteRow, deleteTable, mergeCells, splitCell, toggleHeader, toggleHeaderCell, setCellAttr, goToNextCell, fixTables, columnResizing, tableEditing } from "@tiptap/pm/tables";
+function getColStyleDeclaration(minWidth, width) {
+  if (width) {
+    return ["width", `${Math.max(width, minWidth)}px`];
+  }
+  return ["min-width", `${minWidth}px`];
+}
+function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
+  var _a;
+  let totalWidth = 0;
+  let fixedWidth = true;
+  let nextDOM = colgroup.firstChild;
+  const row = node.firstChild;
+  if (row !== null) {
+    for (let i = 0, col = 0; i < row.childCount; i += 1) {
+      const { colspan, colwidth } = row.child(i).attrs;
+      for (let j = 0; j < colspan; j += 1, col += 1) {
+        const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];
+        const cssWidth = hasWidth ? `${hasWidth}px` : "";
+        totalWidth += hasWidth || cellMinWidth;
+        if (!hasWidth) {
+          fixedWidth = false;
+        }
+        if (!nextDOM) {
+          const colElement = document.createElement("col");
+          const [propertyKey, propertyValue] = getColStyleDeclaration(cellMinWidth, hasWidth);
+          colElement.style.setProperty(propertyKey, propertyValue);
+          colgroup.appendChild(colElement);
+        } else {
+          if (nextDOM.style.width !== cssWidth) {
+            const [propertyKey, propertyValue] = getColStyleDeclaration(cellMinWidth, hasWidth);
+            nextDOM.style.setProperty(propertyKey, propertyValue);
+          }
+          nextDOM = nextDOM.nextSibling;
+        }
+      }
+    }
+  }
+  while (nextDOM) {
+    const after = nextDOM.nextSibling;
+    (_a = nextDOM.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(nextDOM);
+    nextDOM = after;
+  }
+  if (fixedWidth) {
+    table.style.width = `${totalWidth}px`;
+    table.style.minWidth = "";
+  } else {
+    table.style.width = "";
+    table.style.minWidth = `${totalWidth}px`;
+  }
+}
+var TableView = class {
+  constructor(node, cellMinWidth) {
+    this.node = node;
+    this.cellMinWidth = cellMinWidth;
+    this.dom = document.createElement("div");
+    this.dom.className = "tableWrapper";
+    this.table = this.dom.appendChild(document.createElement("table"));
+    this.colgroup = this.table.appendChild(document.createElement("colgroup"));
+    updateColumns(node, this.colgroup, this.table, cellMinWidth);
+    this.contentDOM = this.table.appendChild(document.createElement("tbody"));
+  }
+  update(node) {
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.node = node;
+    updateColumns(node, this.colgroup, this.table, this.cellMinWidth);
+    return true;
+  }
+  ignoreMutation(mutation) {
+    return mutation.type === "attributes" && (mutation.target === this.table || this.colgroup.contains(mutation.target));
+  }
+};
+function createColGroup(node, cellMinWidth, overrideCol, overrideValue) {
+  let totalWidth = 0;
+  let fixedWidth = true;
+  const cols = [];
+  const row = node.firstChild;
+  if (!row) {
+    return {};
+  }
+  for (let i = 0, col = 0; i < row.childCount; i += 1) {
+    const { colspan, colwidth } = row.child(i).attrs;
+    for (let j = 0; j < colspan; j += 1, col += 1) {
+      const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];
+      totalWidth += hasWidth || cellMinWidth;
+      if (!hasWidth) {
+        fixedWidth = false;
+      }
+      const [property, value] = getColStyleDeclaration(cellMinWidth, hasWidth);
+      cols.push([
+        "col",
+        { style: `${property}: ${value}` }
+      ]);
+    }
+  }
+  const tableWidth = fixedWidth ? `${totalWidth}px` : "";
+  const tableMinWidth = fixedWidth ? "" : `${totalWidth}px`;
+  const colgroup = ["colgroup", {}, ...cols];
+  return { colgroup, tableWidth, tableMinWidth };
+}
+function createCell(cellType, cellContent) {
+  if (cellContent) {
+    return cellType.createChecked(null, cellContent);
+  }
+  return cellType.createAndFill();
+}
+function getTableNodeTypes(schema) {
+  if (schema.cached.tableNodeTypes) {
+    return schema.cached.tableNodeTypes;
+  }
+  const roles = {};
+  Object.keys(schema.nodes).forEach((type) => {
+    const nodeType = schema.nodes[type];
+    if (nodeType.spec.tableRole) {
+      roles[nodeType.spec.tableRole] = nodeType;
+    }
+  });
+  schema.cached.tableNodeTypes = roles;
+  return roles;
+}
+function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
+  const types = getTableNodeTypes(schema);
+  const headerCells = [];
+  const cells = [];
+  for (let index = 0; index < colsCount; index += 1) {
+    const cell = createCell(types.cell, cellContent);
+    if (cell) {
+      cells.push(cell);
+    }
+    if (withHeaderRow) {
+      const headerCell = createCell(types.header_cell, cellContent);
+      if (headerCell) {
+        headerCells.push(headerCell);
+      }
+    }
+  }
+  const rows = [];
+  for (let index = 0; index < rowsCount; index += 1) {
+    rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+  }
+  return types.table.createChecked(null, rows);
+}
+function isCellSelection(value) {
+  return value instanceof CellSelection;
+}
+var deleteTableWhenAllCellsSelected = ({ editor }) => {
+  const { selection } = editor.state;
+  if (!isCellSelection(selection)) {
+    return false;
+  }
+  let cellCount = 0;
+  const table = findParentNodeClosestToPos(selection.ranges[0].$from, (node) => {
+    return node.type.name === "table";
+  });
+  table === null || table === void 0 ? void 0 : table.node.descendants((node) => {
+    if (node.type.name === "table") {
+      return false;
+    }
+    if (["tableCell", "tableHeader"].includes(node.type.name)) {
+      cellCount += 1;
+    }
+  });
+  const allCellsSelected = cellCount === selection.ranges.length;
+  if (!allCellsSelected) {
+    return false;
+  }
+  editor.commands.deleteTable();
+  return true;
+};
+var Table = Node16.create({
+  name: "table",
+  // @ts-ignore
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      resizable: false,
+      renderWrapper: false,
+      handleWidth: 5,
+      cellMinWidth: 25,
+      // TODO: fix
+      View: TableView,
+      lastColumnResizable: true,
+      allowTableNodeSelection: false
+    };
+  },
+  content: "tableRow+",
+  tableRole: "table",
+  isolating: true,
+  group: "block",
+  parseHTML() {
+    return [{ tag: "table" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const { colgroup, tableWidth, tableMinWidth } = createColGroup(node, this.options.cellMinWidth);
+    const table = [
+      "table",
+      mergeAttributes21(this.options.HTMLAttributes, HTMLAttributes, {
+        style: tableWidth ? `width: ${tableWidth}` : `min-width: ${tableMinWidth}`
+      }),
+      colgroup,
+      ["tbody", 0]
+    ];
+    return this.options.renderWrapper ? ["div", { class: "tableWrapper" }, table] : table;
+  },
+  addCommands() {
+    return {
+      insertTable: ({ rows = 3, cols = 3, withHeaderRow = true } = {}) => ({ tr: tr2, dispatch, editor }) => {
+        const node = createTable(editor.schema, rows, cols, withHeaderRow);
+        if (dispatch) {
+          const offset = tr2.selection.from + 1;
+          tr2.replaceSelectionWith(node).scrollIntoView().setSelection(TextSelection3.near(tr2.doc.resolve(offset)));
+        }
+        return true;
+      },
+      addColumnBefore: () => ({ state, dispatch }) => {
+        return addColumnBefore(state, dispatch);
+      },
+      addColumnAfter: () => ({ state, dispatch }) => {
+        return addColumnAfter(state, dispatch);
+      },
+      deleteColumn: () => ({ state, dispatch }) => {
+        return deleteColumn(state, dispatch);
+      },
+      addRowBefore: () => ({ state, dispatch }) => {
+        return addRowBefore(state, dispatch);
+      },
+      addRowAfter: () => ({ state, dispatch }) => {
+        return addRowAfter(state, dispatch);
+      },
+      deleteRow: () => ({ state, dispatch }) => {
+        return deleteRow(state, dispatch);
+      },
+      deleteTable: () => ({ state, dispatch }) => {
+        return deleteTable(state, dispatch);
+      },
+      mergeCells: () => ({ state, dispatch }) => {
+        return mergeCells(state, dispatch);
+      },
+      splitCell: () => ({ state, dispatch }) => {
+        return splitCell(state, dispatch);
+      },
+      toggleHeaderColumn: () => ({ state, dispatch }) => {
+        return toggleHeader("column")(state, dispatch);
+      },
+      toggleHeaderRow: () => ({ state, dispatch }) => {
+        return toggleHeader("row")(state, dispatch);
+      },
+      toggleHeaderCell: () => ({ state, dispatch }) => {
+        return toggleHeaderCell(state, dispatch);
+      },
+      mergeOrSplit: () => ({ state, dispatch }) => {
+        if (mergeCells(state, dispatch)) {
+          return true;
+        }
+        return splitCell(state, dispatch);
+      },
+      setCellAttribute: (name, value) => ({ state, dispatch }) => {
+        return setCellAttr(name, value)(state, dispatch);
+      },
+      goToNextCell: () => ({ state, dispatch }) => {
+        return goToNextCell(1)(state, dispatch);
+      },
+      goToPreviousCell: () => ({ state, dispatch }) => {
+        return goToNextCell(-1)(state, dispatch);
+      },
+      fixTables: () => ({ state, dispatch }) => {
+        if (dispatch) {
+          fixTables(state);
+        }
+        return true;
+      },
+      setCellSelection: (position) => ({ tr: tr2, dispatch }) => {
+        if (dispatch) {
+          const selection = CellSelection.create(tr2.doc, position.anchorCell, position.headCell);
+          tr2.setSelection(selection);
+        }
+        return true;
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Tab: () => {
+        if (this.editor.commands.goToNextCell()) {
+          return true;
+        }
+        if (!this.editor.can().addRowAfter()) {
+          return false;
+        }
+        return this.editor.chain().addRowAfter().goToNextCell().run();
+      },
+      "Shift-Tab": () => this.editor.commands.goToPreviousCell(),
+      Backspace: deleteTableWhenAllCellsSelected,
+      "Mod-Backspace": deleteTableWhenAllCellsSelected,
+      Delete: deleteTableWhenAllCellsSelected,
+      "Mod-Delete": deleteTableWhenAllCellsSelected
+    };
+  },
+  addProseMirrorPlugins() {
+    const isResizable = this.options.resizable && this.editor.isEditable;
+    return [
+      ...isResizable ? [
+        columnResizing({
+          handleWidth: this.options.handleWidth,
+          cellMinWidth: this.options.cellMinWidth,
+          defaultCellMinWidth: this.options.cellMinWidth,
+          View: this.options.View,
+          lastColumnResizable: this.options.lastColumnResizable
+        })
+      ] : [],
+      tableEditing({
+        allowTableNodeSelection: this.options.allowTableNodeSelection
+      })
+    ];
+  },
+  extendNodeSchema(extension) {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage
+    };
+    return {
+      tableRole: callOrReturn2(getExtensionField2(extension, "tableRole", context))
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-table-cell@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-table-cell/dist/index.js
+import { Node as Node17, mergeAttributes as mergeAttributes22 } from "@tiptap/core";
+var TableCell = Node17.create({
+  name: "tableCell",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? colwidth.split(",").map((width) => parseInt(width, 10)) : null;
+          return value;
+        }
+      }
+    };
+  },
+  tableRole: "cell",
+  isolating: true,
+  parseHTML() {
+    return [
+      { tag: "td" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["td", mergeAttributes22(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
+
+// ../../node_modules/.pnpm/@tiptap+extension-table-header@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-table-header/dist/index.js
+import { Node as Node18, mergeAttributes as mergeAttributes23 } from "@tiptap/core";
+var TableHeader = Node18.create({
+  name: "tableHeader",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? colwidth.split(",").map((width) => parseInt(width, 10)) : null;
+          return value;
+        }
+      }
+    };
+  },
+  tableRole: "header_cell",
+  isolating: true,
+  parseHTML() {
+    return [
+      { tag: "th" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["th", mergeAttributes23(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
+
+// src/extensions/table-formatting.ts
+var TABLE_CELL_BACKGROUND_PRESETS = {
+  none: null,
+  gray: "#f3f4f6",
+  yellow: "#fef3c7",
+  blue: "#dbeafe",
+  green: "#dcfce7",
+  red: "#fee2e2"
+};
+var LoomaTable = Table.configure({
+  resizable: true,
+  lastColumnResizable: false
+});
+function normalizeTableCellAlignment(value) {
+  if (value === "left" || value === "center" || value === "right") {
+    return value;
+  }
+  return null;
+}
+function normalizeTableCellBackground(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function renderTableCellStyle(attributes) {
+  const styleFragments = [];
+  const textAlign = normalizeTableCellAlignment(attributes.textAlign);
+  const backgroundColor = normalizeTableCellBackground(attributes.backgroundColor);
+  if (textAlign && textAlign !== "left") {
+    styleFragments.push(`text-align: ${textAlign}`);
+  }
+  if (backgroundColor) {
+    styleFragments.push(`background-color: ${backgroundColor}`);
+  }
+  return styleFragments.length > 0 ? `${styleFragments.join("; ")};` : null;
+}
+var tableAlignmentAttributes = {
+  textAlign: {
+    default: null,
+    parseHTML: (element) => normalizeTableCellAlignment(element.style.textAlign),
+    renderHTML: (attributes) => {
+      const style = renderTableCellStyle(attributes);
+      return style ? { style } : {};
+    }
+  },
+  backgroundColor: {
+    default: null,
+    parseHTML: (element) => normalizeTableCellBackground(element.style.backgroundColor),
+    renderHTML: (attributes) => {
+      const style = renderTableCellStyle(attributes);
+      return style ? { style } : {};
+    }
+  }
+};
+var LoomaTableHeader = TableHeader.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      ...tableAlignmentAttributes
+    };
+  }
+});
+var LoomaTableCell = TableCell.extend({
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      ...tableAlignmentAttributes
+    };
+  }
+});
+function getActiveTableCellAlignment(editor) {
+  const { $from } = editor.state.selection;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const node = $from.node(depth);
+    if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+      return normalizeTableCellAlignment(node.attrs.textAlign) ?? "left";
+    }
+  }
+  return "left";
+}
+function getActiveTableCellBackground(editor) {
+  const { $from } = editor.state.selection;
+  for (let depth = $from.depth; depth > 0; depth -= 1) {
+    const node = $from.node(depth);
+    if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+      return normalizeTableCellBackground(node.attrs.backgroundColor);
+    }
+  }
+  return null;
+}
+function setActiveTableCellAlignment(editor, alignment) {
+  const textAlign = alignment === "left" ? null : alignment;
+  if (editor.isActive("tableHeader")) {
+    return editor.chain().focus().updateAttributes("tableHeader", { textAlign }).run();
+  }
+  if (editor.isActive("tableCell")) {
+    return editor.chain().focus().updateAttributes("tableCell", { textAlign }).run();
+  }
+  return false;
+}
+function setActiveTableCellBackground(editor, backgroundColor) {
+  const normalizedBackgroundColor = normalizeTableCellBackground(backgroundColor);
+  if (editor.isActive("tableHeader")) {
+    return editor.chain().focus().updateAttributes("tableHeader", {
+      backgroundColor: normalizedBackgroundColor
+    }).run();
+  }
+  if (editor.isActive("tableCell")) {
+    return editor.chain().focus().updateAttributes("tableCell", {
+      backgroundColor: normalizedBackgroundColor
+    }).run();
+  }
+  return false;
+}
+
+// src/extensions/preset.ts
+function getDefaultEditorExtensions(options = {}) {
+  const {
+    placeholder = "Type \u201C/\u201D for commands, or start writing\u2026",
+    linkOpenOnClick = false,
+    imageInline = false
+  } = options;
+  return [
+    Document,
+    Paragraph,
+    Text,
+    Bold,
+    Italic,
+    Strike,
+    Underline,
+    Heading.configure({ levels: [1, 2, 3] }),
+    BulletList,
+    OrderedList,
+    ListItem,
+    TaskList,
+    TaskItem.configure({ nested: false }),
+    Blockquote,
+    HorizontalRule,
+    HardBreak,
+    History,
+    Dropcursor,
+    Gapcursor,
+    Link.configure({
+      openOnClick: linkOpenOnClick,
+      HTMLAttributes: { rel: "noopener noreferrer", target: "_blank" }
+    }),
+    Image.configure({ inline: imageInline }),
+    Highlight.configure({ multicolor: false }),
+    Code,
+    CodeBlock,
+    Typography,
+    Placeholder.configure({
+      placeholder: ({ node }) => node.type.name === "paragraph" ? placeholder : "",
+      emptyNodeClass: "is-editor-empty"
+    }),
+    LoomaTable,
+    TableRow,
+    LoomaTableHeader,
+    LoomaTableCell,
+    LoomaListBehavior
+  ];
+}
+
+// src/extensions/table-commands.ts
+import { TableMap } from "@tiptap/pm/tables";
+function arrayEquals(left, right) {
+  if (!left || left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}
+function readRenderedColumnWidths(tableElement) {
+  const colElements = Array.from(tableElement.querySelectorAll("colgroup col"));
+  if (colElements.length > 0) {
+    return colElements.map((column) => Math.max(1, Math.round(column.getBoundingClientRect().width)));
+  }
+  const firstRow = tableElement.rows.item(0);
+  if (!firstRow) {
+    return [];
+  }
+  return Array.from(firstRow.cells).map((cell) => Math.max(1, Math.round(cell.getBoundingClientRect().width)));
+}
+function distributeWidthDelta(widths, availableWidth, minWidth) {
+  const normalized = [...widths];
+  let delta = availableWidth - normalized.reduce((sum, width) => sum + width, 0);
+  while (delta !== 0) {
+    const adjustableIndices = normalized.map((width, index) => ({ width, index })).filter(({ width }) => delta > 0 || width > minWidth).sort((left, right) => {
+      if (delta > 0) {
+        return left.width - right.width;
+      }
+      return right.width - left.width;
+    });
+    if (adjustableIndices.length === 0) {
+      break;
+    }
+    for (const { index } of adjustableIndices) {
+      if (delta === 0) {
+        break;
+      }
+      const currentWidth = normalized[index];
+      if (currentWidth === void 0) {
+        continue;
+      }
+      if (delta > 0) {
+        normalized[index] = currentWidth + 1;
+        delta -= 1;
+        continue;
+      }
+      if (currentWidth <= minWidth) {
+        continue;
+      }
+      normalized[index] = currentWidth - 1;
+      delta += 1;
+    }
+  }
+  return normalized;
+}
+function normalizeColumnWidths(widths, availableWidth, minWidth) {
+  if (widths.length === 0 || availableWidth <= 0) {
+    return widths;
+  }
+  const totalWidth = widths.reduce((sum, width) => sum + width, 0);
+  if (totalWidth <= 0) {
+    return widths;
+  }
+  const scaled = widths.map(
+    (width) => Math.max(minWidth, Math.round(width / totalWidth * availableWidth))
+  );
+  return distributeWidthDelta(scaled, availableWidth, minWidth);
+}
+function getTextPositionInCell(tablePos, table, rowIndex, colIndex) {
+  let pos = tablePos + 1;
+  for (let r = 0; r < rowIndex; r++) {
+    pos += table.child(r).nodeSize;
+  }
+  const row = table.child(rowIndex);
+  for (let c = 0; c < colIndex; c++) {
+    pos += row.child(c).nodeSize;
+  }
+  return pos + 3;
+}
+function findTable(editor) {
+  const { $from } = editor.state.selection;
+  for (let d = $from.depth; d > 0; d--) {
+    const node = $from.node(d);
+    if (node.type.name === "table") {
+      return { pos: $from.before(d), node };
+    }
+  }
+  return null;
+}
+function insertTableAtRange(editor, range, options = {}) {
+  const rows = Math.min(10, Math.max(1, options.rows ?? 3));
+  const cols = Math.min(10, Math.max(1, options.cols ?? 3));
+  const withHeaderRow = options.withHeaderRow ?? true;
+  return editor.chain().focus().deleteRange(range).insertTable({ rows, cols, withHeaderRow }).run();
+}
+function normalizeActiveTableColumnWidths(editor, tableElement, minWidth = 25) {
+  const tableInfo = findTable(editor);
+  if (!tableInfo) {
+    return false;
+  }
+  const renderedColumnWidths = readRenderedColumnWidths(tableElement);
+  if (renderedColumnWidths.length === 0) {
+    return false;
+  }
+  const availableWidth = Math.max(1, Math.round(tableElement.getBoundingClientRect().width));
+  const normalizedColumnWidths = normalizeColumnWidths(
+    renderedColumnWidths,
+    availableWidth,
+    minWidth
+  );
+  const { pos: tablePos, node: table } = tableInfo;
+  const map = TableMap.get(table);
+  const tableStart = tablePos + 1;
+  let tr2 = editor.state.tr;
+  let changed = false;
+  for (let row = 0; row < map.height; row += 1) {
+    for (let col = 0; col < map.width; col += 1) {
+      const mapIndex = row * map.width + col;
+      const cellPos = map.map[mapIndex];
+      if (cellPos === void 0) {
+        continue;
+      }
+      if (col > 0 && map.map[mapIndex - 1] === cellPos || row > 0 && map.map[mapIndex - map.width] === cellPos) {
+        continue;
+      }
+      const cellNode = table.nodeAt(cellPos);
+      if (!cellNode) {
+        continue;
+      }
+      const startCol = map.colCount(cellPos);
+      const cellWidths = normalizedColumnWidths.slice(startCol, startCol + cellNode.attrs.colspan);
+      if (cellWidths.length !== cellNode.attrs.colspan || arrayEquals(cellNode.attrs.colwidth, cellWidths)) {
+        continue;
+      }
+      tr2 = tr2.setNodeMarkup(tableStart + cellPos, null, {
+        ...cellNode.attrs,
+        colwidth: cellWidths
+      });
+      changed = true;
+    }
+  }
+  if (changed) {
+    editor.view.dispatch(tr2);
+  }
+  return changed;
+}
+function handleTableOverlayAction(editor, detail) {
+  const tableInfo = findTable(editor);
+  if (!tableInfo) return false;
+  const { action, boundaryIndex } = detail;
+  const { pos: tablePos, node: table } = tableInfo;
+  const rows = table.childCount;
+  const cols = rows > 0 ? table.child(0).childCount : 0;
+  let cellPos;
+  let command;
+  switch (action) {
+    case "add-row-before": {
+      const rowIndex = Math.min(boundaryIndex, rows - 1);
+      if (rowIndex < 0) return false;
+      cellPos = getTextPositionInCell(tablePos, table, rowIndex, 0);
+      command = () => editor.chain().focus().setTextSelection(cellPos).addRowBefore().run();
+      break;
+    }
+    case "add-row-after": {
+      const rowIndex = Math.min(boundaryIndex, rows - 1);
+      if (rowIndex < 0) return false;
+      cellPos = getTextPositionInCell(tablePos, table, rowIndex, 0);
+      command = () => editor.chain().focus().setTextSelection(cellPos).addRowAfter().run();
+      break;
+    }
+    case "add-column-before": {
+      const colIndex = Math.min(boundaryIndex, cols - 1);
+      if (colIndex < 0) return false;
+      cellPos = getTextPositionInCell(tablePos, table, 0, colIndex);
+      command = () => editor.chain().focus().setTextSelection(cellPos).addColumnBefore().run();
+      break;
+    }
+    case "add-column-after": {
+      const colIndex = Math.min(boundaryIndex, cols - 1);
+      if (colIndex < 0) return false;
+      cellPos = getTextPositionInCell(tablePos, table, 0, colIndex);
+      command = () => editor.chain().focus().setTextSelection(cellPos).addColumnAfter().run();
+      break;
+    }
+    default:
+      return false;
+  }
+  return command();
+}
+
+export {
+  TABLE_CELL_BACKGROUND_PRESETS,
+  LoomaTable,
+  LoomaTableHeader,
+  LoomaTableCell,
+  getActiveTableCellAlignment,
+  getActiveTableCellBackground,
+  setActiveTableCellAlignment,
+  setActiveTableCellBackground,
+  getDefaultEditorExtensions,
+  insertTableAtRange,
+  normalizeActiveTableColumnWidths,
+  handleTableOverlayAction
+};