@templatical/editor 0.15.1 → 0.16.1

package/dist/dist-i_Z7t67A.js

@@ -0,0 +1,2594 @@
+import { Cn as e, Ct as t, Dn as n, En as r, Mt as i, Nt as a, On as o, Pt as s, Sn as c, Tn as l, Ut as u, Wt as d, Xt as f, Y as p, Z as m, _n as h, at as g, bn as _, c as v, en as ee, gn as y, i as b, in as te, mn as ne, ot as re, qt as x, rt as ie, u as S, v as ae, vn as C, wn as w, wt as oe, xn as T, y as se, yn as E } from "./dist-D9g4CSnm.js";
+import { Link as ce } from "./dist-CHLoeloJ.js";
+import { Underline as le } from "./dist-DGEaAAIb.js";
+//#region ../../node_modules/.pnpm/@tiptap+core@3.28.0_@tiptap+pm@3.28.0/node_modules/@tiptap/core/dist/jsx-runtime/jsx-runtime.js
+var D = (e, t) => {
+	if (e === "slot") return 0;
+	if (e instanceof Function) return e(t);
+	let { children: n, ...r } = t ?? {};
+	if (e === "svg") throw Error("SVG elements are not supported in the JSX syntax, use the array syntax instead");
+	return [
+		e,
+		r,
+		n
+	];
+}, ue = (e, t) => {
+	let { state: n, view: r } = e, { selection: i } = n;
+	if (!i.empty) return !1;
+	let { $from: a } = i;
+	if (a.parentOffset !== 0) return !1;
+	let o = a.depth - 1;
+	if (o < 0) return !1;
+	let s = a.node(o), c = a.index(o);
+	if (c === 0) return !1;
+	if (s.type === t) return e.commands.lift(t.name);
+	let l = s.child(c - 1);
+	if (l.type !== t || !l.lastChild?.isTextblock) return !1;
+	let u = a.before(), d = u - 1 - 1, { tr: f } = n;
+	return f.delete(u, a.after()).insert(d, a.parent.content), f.setSelection(w.create(f.doc, d)), r.dispatch(f.scrollIntoView()), !0;
+}, de = /^\s*>\s$/, fe = S.create({
+	name: "blockquote",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	content: "block+",
+	group: "block",
+	defining: !0,
+	parseHTML() {
+		return [{ tag: "blockquote" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return /* @__PURE__ */ D("blockquote", {
+			...x(this.options.HTMLAttributes, e),
+			children: /* @__PURE__ */ D("slot", {})
+		});
+	},
+	parseMarkdown: (e, t) => {
+		let n = t.parseBlockChildren ?? t.parseChildren;
+		return t.createNode("blockquote", void 0, n(e.tokens || []));
+	},
+	renderMarkdown: (e, t) => {
+		if (!e.content) return "";
+		let n = [];
+		return e.content.forEach((e, r) => {
+			let i = (t.renderChild?.call(t, e, r) ?? t.renderChildren([e])).split("\n").map((e) => e.trim() === "" ? ">" : `> ${e}`);
+			n.push(i.join("\n"));
+		}), n.join("\n>\n");
+	},
+	addCommands() {
+		return {
+			setBlockquote: () => ({ commands: e }) => e.wrapIn(this.name),
+			toggleBlockquote: () => ({ commands: e }) => e.toggleWrap(this.name),
+			unsetBlockquote: () => ({ commands: e }) => e.lift(this.name)
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-Shift-b": () => this.editor.commands.toggleBlockquote(),
+			Backspace: () => ue(this.editor, this.type)
+		};
+	},
+	addInputRules() {
+		return [y({
+			find: de,
+			type: this.type
+		})];
+	}
+}), pe = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, me = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, he = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, ge = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, _e = v.create({
+	name: "bold",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [
+			{ tag: "strong" },
+			{
+				tag: "b",
+				getAttrs: (e) => e.style.fontWeight !== "normal" && null
+			},
+			{
+				style: "font-weight=400",
+				clearMark: (e) => e.type.name === this.name
+			},
+			{
+				style: "font-weight",
+				getAttrs: (e) => /^(bold(er)?|[5-9]\d{2,})$/.test(e) && null
+			}
+		];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return /* @__PURE__ */ D("strong", {
+			...x(this.options.HTMLAttributes, e),
+			children: /* @__PURE__ */ D("slot", {})
+		});
+	},
+	markdownTokenName: "strong",
+	parseMarkdown: (e, t) => t.applyMark("bold", t.parseInline(e.tokens || [])),
+	markdownOptions: { htmlReopen: {
+		open: "<strong>",
+		close: "</strong>"
+	} },
+	renderMarkdown: (e, t) => `**${t.renderChildren(e)}**`,
+	addCommands() {
+		return {
+			setBold: () => ({ commands: e }) => e.setMark(this.name),
+			toggleBold: () => ({ commands: e }) => e.toggleMark(this.name),
+			unsetBold: () => ({ commands: e }) => e.unsetMark(this.name)
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-b": () => this.editor.commands.toggleBold(),
+			"Mod-B": () => this.editor.commands.toggleBold()
+		};
+	},
+	addInputRules() {
+		return [u({
+			find: pe,
+			type: this.type
+		}), u({
+			find: he,
+			type: this.type
+		})];
+	},
+	addPasteRules() {
+		return [d({
+			find: me,
+			type: this.type
+		}), d({
+			find: ge,
+			type: this.type
+		})];
+	}
+}), ve = (e) => {
+	let t = /`([^`]+)`(?!`)$/.exec(e);
+	return !t || t.index > 0 && e[t.index - 1] === "`" ? null : {
+		index: t.index,
+		text: t[0],
+		replaceWith: t[1]
+	};
+}, ye = (e) => {
+	let t = /`([^`]+)`(?!`)/g, n = [], r;
+	for (; (r = t.exec(e)) !== null;) r.index > 0 && e[r.index - 1] === "`" || n.push({
+		index: r.index,
+		text: r[0],
+		replaceWith: r[1]
+	});
+	return n;
+}, be = v.create({
+	name: "code",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	excludes: "_",
+	code: !0,
+	exitable: !0,
+	parseHTML() {
+		return [{ tag: "code" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"code",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	markdownTokenName: "codespan",
+	parseMarkdown: (e, t) => t.applyMark("code", [{
+		type: "text",
+		text: e.text || ""
+	}]),
+	renderMarkdown: (e, t) => e.content ? `\`${t.renderChildren(e.content)}\`` : "",
+	addCommands() {
+		return {
+			setCode: () => ({ commands: e }) => e.setMark(this.name),
+			toggleCode: () => ({ commands: e }) => e.toggleMark(this.name),
+			unsetCode: () => ({ commands: e }) => e.unsetMark(this.name)
+		};
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-e": () => this.editor.commands.toggleCode() };
+	},
+	addInputRules() {
+		return [u({
+			find: ve,
+			type: this.type
+		})];
+	},
+	addPasteRules() {
+		return [d({
+			find: ye,
+			type: this.type
+		})];
+	}
+}), O = 4, xe = /^```([a-z]+)?[\s\n]$/, Se = /^~~~([a-z]+)?[\s\n]$/, Ce = S.create({
+	name: "codeBlock",
+	addOptions() {
+		return {
+			languageClassPrefix: "language-",
+			exitOnTripleEnter: !0,
+			exitOnArrowDown: !0,
+			defaultLanguage: null,
+			enableTabIndentation: !1,
+			tabSize: O,
+			HTMLAttributes: {}
+		};
+	},
+	content: "text*",
+	marks: "",
+	group: "block",
+	code: !0,
+	defining: !0,
+	addAttributes() {
+		return { language: {
+			default: this.options.defaultLanguage,
+			parseHTML: (e) => {
+				let { languageClassPrefix: t } = this.options;
+				return t && [...e.firstElementChild?.classList || []].filter((e) => e.startsWith(t)).map((e) => e.replace(t, ""))[0] || null;
+			},
+			rendered: !1
+		} };
+	},
+	parseHTML() {
+		return [{
+			tag: "pre",
+			preserveWhitespace: "full"
+		}];
+	},
+	renderHTML({ node: e, HTMLAttributes: t }) {
+		return [
+			"pre",
+			x(this.options.HTMLAttributes, t),
+			[
+				"code",
+				{ class: e.attrs.language ? this.options.languageClassPrefix + e.attrs.language : null },
+				0
+			]
+		];
+	},
+	markdownTokenName: "code",
+	parseMarkdown: (e, t) => e.raw?.startsWith("```") === !1 && e.raw?.startsWith("~~~") === !1 && e.codeBlockStyle !== "indented" ? [] : t.createNode("codeBlock", { language: e.lang || null }, e.text ? [t.createTextNode(e.text)] : []),
+	renderMarkdown: (e, t) => {
+		let n = "", r = e.attrs?.language || "";
+		return n = e.content ? [
+			`\`\`\`${r}`,
+			t.renderChildren(e.content),
+			"```"
+		].join("\n") : `\`\`\`${r}
+
+\`\`\``, n;
+	},
+	addCommands() {
+		return {
+			setCodeBlock: (e) => ({ commands: t }) => t.setNode(this.name, e),
+			toggleCodeBlock: (e) => ({ commands: t }) => t.toggleNode(this.name, "paragraph", e)
+		};
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
+			Backspace: () => {
+				let { empty: e, $anchor: t } = this.editor.state.selection, n = t.pos === 1;
+				return !e || t.parent.type.name !== this.name ? !1 : n || !t.parent.textContent.length ? this.editor.commands.clearNodes() : !1;
+			},
+			Tab: ({ editor: e }) => {
+				if (!this.options.enableTabIndentation) return !1;
+				let t = this.options.tabSize ?? O, { state: n } = e, { selection: r } = n, { $from: i, empty: a } = r;
+				if (i.parent.type !== this.type) return !1;
+				let o = " ".repeat(t);
+				return a ? e.commands.insertContent(o) : e.commands.command(({ tr: e }) => {
+					let { from: t, to: i } = r, a = n.doc.textBetween(t, i, "\n", "\n").split("\n").map((e) => o + e).join("\n");
+					return e.replaceWith(t, i, n.schema.text(a)), !0;
+				});
+			},
+			"Shift-Tab": ({ editor: e }) => {
+				if (!this.options.enableTabIndentation) return !1;
+				let t = this.options.tabSize ?? O, { state: n } = e, { selection: r } = n, { $from: i, empty: a } = r;
+				return i.parent.type === this.type ? a ? e.commands.command(({ tr: e }) => {
+					let { pos: r } = i, a = i.start(), o = i.end(), s = n.doc.textBetween(a, o, "\n", "\n").split("\n"), c = 0, l = 0, u = r - a;
+					for (let e = 0; e < s.length; e += 1) {
+						if (l + s[e].length >= u) {
+							c = e;
+							break;
+						}
+						l += s[e].length + 1;
+					}
+					let d = s[c].match(/^ */)?.[0] || "", f = Math.min(d.length, t);
+					if (f === 0) return !0;
+					let p = a;
+					for (let e = 0; e < c; e += 1) p += s[e].length + 1;
+					return e.delete(p, p + f), r - p <= f && e.setSelection(w.create(e.doc, p)), !0;
+				}) : e.commands.command(({ tr: e }) => {
+					let { from: i, to: a } = r, o = n.doc.textBetween(i, a, "\n", "\n").split("\n").map((e) => {
+						let n = e.match(/^ */)?.[0] || "", r = Math.min(n.length, t);
+						return e.slice(r);
+					}).join("\n");
+					return e.replaceWith(i, a, n.schema.text(o)), !0;
+				}) : !1;
+			},
+			Enter: ({ editor: e }) => {
+				if (!this.options.exitOnTripleEnter) return !1;
+				let { state: t } = e, { selection: n } = t, { $from: r, empty: i } = n;
+				if (!i || r.parent.type !== this.type) return !1;
+				let a = r.parentOffset === r.parent.nodeSize - 2, o = r.parent.textContent.endsWith("\n\n");
+				return !a || !o ? !1 : e.chain().command(({ tr: e }) => (e.delete(r.pos - 2, r.pos), !0)).exitCode().run();
+			},
+			ArrowDown: ({ editor: t }) => {
+				if (!this.options.exitOnArrowDown) return !1;
+				let { state: n } = t, { selection: r, doc: i } = n, { $from: a, empty: o } = r;
+				if (!o || a.parent.type !== this.type || a.parentOffset !== a.parent.nodeSize - 2) return !1;
+				let s = a.after();
+				return s === void 0 ? !1 : i.nodeAt(s) ? t.commands.command(({ tr: t }) => (t.setSelection(e.near(i.resolve(s))), !0)) : t.commands.exitCode();
+			}
+		};
+	},
+	addInputRules() {
+		return [ne({
+			find: xe,
+			type: this.type,
+			getAttributes: (e) => ({ language: e[1] })
+		}), ne({
+			find: Se,
+			type: this.type,
+			getAttributes: (e) => ({ language: e[1] })
+		})];
+	},
+	addProseMirrorPlugins() {
+		return [new T({
+			key: new c("codeBlockVSCodeHandler"),
+			props: { handlePaste: (e, t) => {
+				if (!t.clipboardData || this.editor.isActive(this.type.name)) return !1;
+				let n = t.clipboardData.getData("text/plain"), r = t.clipboardData.getData("vscode-editor-data"), i = (r ? JSON.parse(r) : void 0)?.mode;
+				if (!n || !i) return !1;
+				let { tr: a, schema: o } = e.state, s = o.text(n.replace(/\r\n?/g, "\n"));
+				return a.replaceSelectionWith(this.type.create({ language: i }, s)), a.selection.$from.parent.type !== this.type && a.setSelection(w.near(a.doc.resolve(Math.max(0, a.selection.from - 2)))), a.setMeta("paste", !0), e.dispatch(a), !0;
+			} }
+		})];
+	}
+}), we = S.create({
+	name: "doc",
+	topNode: !0,
+	content: "block+",
+	renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, "\n\n") : ""
+}), Te = S.create({
+	name: "hardBreak",
+	markdownTokenName: "br",
+	addOptions() {
+		return {
+			keepMarks: !0,
+			HTMLAttributes: {}
+		};
+	},
+	inline: !0,
+	group: "inline",
+	selectable: !1,
+	linebreakReplacement: !0,
+	parseHTML() {
+		return [{ tag: "br" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return ["br", x(this.options.HTMLAttributes, e)];
+	},
+	renderText() {
+		return "\n";
+	},
+	renderMarkdown: () => "  \n",
+	parseMarkdown: () => ({ type: "hardBreak" }),
+	addCommands() {
+		return { setHardBreak: () => ({ commands: e, chain: t, state: n, editor: r }) => e.first([() => e.exitCode(), () => e.command(() => {
+			let { selection: e, storedMarks: i } = n;
+			if (e.$from.parent.type.spec.isolating) return !1;
+			let { keepMarks: a } = this.options, { splittableMarks: o } = r.extensionManager, s = i || e.$to.parentOffset && e.$from.marks();
+			return t().insertContent({ type: this.name }).command(({ tr: e, dispatch: t }) => {
+				if (t && s && a) {
+					let t = s.filter((e) => o.includes(e.type.name));
+					e.ensureMarks(t);
+				}
+				return !0;
+			}).run();
+		})]) };
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-Enter": () => this.editor.commands.setHardBreak(),
+			"Shift-Enter": () => this.editor.commands.setHardBreak()
+		};
+	}
+}), Ee = S.create({
+	name: "heading",
+	addOptions() {
+		return {
+			levels: [
+				1,
+				2,
+				3,
+				4,
+				5,
+				6
+			],
+			HTMLAttributes: {}
+		};
+	},
+	content: "inline*",
+	group: "block",
+	defining: !0,
+	addAttributes() {
+		return { level: {
+			default: 1,
+			rendered: !1
+		} };
+	},
+	parseHTML() {
+		return this.options.levels.map((e) => ({
+			tag: `h${e}`,
+			attrs: { level: e }
+		}));
+	},
+	renderHTML({ node: e, HTMLAttributes: t }) {
+		return [
+			`h${this.options.levels.includes(e.attrs.level) ? e.attrs.level : this.options.levels[0]}`,
+			x(this.options.HTMLAttributes, t),
+			0
+		];
+	},
+	parseMarkdown: (e, t) => t.createNode("heading", { level: e.depth || 1 }, t.parseInline(e.tokens || [])),
+	renderMarkdown: (e, t) => {
+		let n = e.attrs?.level ? parseInt(e.attrs.level, 10) : 1, r = "#".repeat(n);
+		return e.content ? `${r} ${t.renderChildren(e.content)}` : "";
+	},
+	addCommands() {
+		return {
+			setHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.setNode(this.name, e) : !1,
+			toggleHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.toggleNode(this.name, "paragraph", e) : !1
+		};
+	},
+	addKeyboardShortcuts() {
+		return this.options.levels.reduce((e, t) => ({
+			...e,
+			[`Mod-Alt-${t}`]: () => this.editor.commands.toggleHeading({ level: t })
+		}), {});
+	},
+	addInputRules() {
+		return this.options.levels.map((e) => ne({
+			find: RegExp(`^(#{${Math.min(...this.options.levels)},${e}})\\s$`),
+			type: this.type,
+			getAttributes: { level: e }
+		}));
+	}
+}), De = S.create({
+	name: "horizontalRule",
+	addOptions() {
+		return {
+			HTMLAttributes: {},
+			nextNodeType: "paragraph"
+		};
+	},
+	group: "block",
+	parseHTML() {
+		return [{ tag: "hr" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return ["hr", x(this.options.HTMLAttributes, e)];
+	},
+	markdownTokenName: "hr",
+	parseMarkdown: (e, t) => t.createNode("horizontalRule"),
+	renderMarkdown: () => "---",
+	addCommands() {
+		return { setHorizontalRule: () => ({ chain: e, state: t }) => {
+			if (!se(t, t.schema.nodes[this.name])) return !1;
+			let { selection: n } = t, { $to: r } = n, i = e();
+			return s(n) ? i.insertContentAt(r.pos, { type: this.name }) : i.insertContent({ type: this.name }), i.command(({ state: e, tr: t, dispatch: n }) => {
+				if (n) {
+					let { $to: n } = t.selection, r = n.end();
+					if (n.nodeAfter) n.nodeAfter.isTextblock ? t.setSelection(w.create(t.doc, n.pos + 1)) : n.nodeAfter.isBlock ? t.setSelection(_.create(t.doc, n.pos)) : t.setSelection(w.create(t.doc, n.pos));
+					else {
+						let i = (e.schema.nodes[this.options.nextNodeType] || n.parent.type.contentMatch.defaultType)?.create();
+						i && (t.insert(r, i), t.setSelection(w.create(t.doc, r + 1)));
+					}
+					t.scrollIntoView();
+				}
+				return !0;
+			}).run();
+		} };
+	},
+	addInputRules() {
+		return [f({
+			find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+			type: this.type
+		})];
+	}
+}), Oe = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, ke = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, Ae = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, je = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, Me = v.create({
+	name: "italic",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [
+			{ tag: "em" },
+			{
+				tag: "i",
+				getAttrs: (e) => e.style.fontStyle !== "normal" && null
+			},
+			{
+				style: "font-style=normal",
+				clearMark: (e) => e.type.name === this.name
+			},
+			{ style: "font-style=italic" }
+		];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"em",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	addCommands() {
+		return {
+			setItalic: () => ({ commands: e }) => e.setMark(this.name),
+			toggleItalic: () => ({ commands: e }) => e.toggleMark(this.name),
+			unsetItalic: () => ({ commands: e }) => e.unsetMark(this.name)
+		};
+	},
+	markdownTokenName: "em",
+	parseMarkdown: (e, t) => t.applyMark("italic", t.parseInline(e.tokens || [])),
+	markdownOptions: { htmlReopen: {
+		open: "<em>",
+		close: "</em>"
+	} },
+	renderMarkdown: (e, t) => `*${t.renderChildren(e)}*`,
+	addKeyboardShortcuts() {
+		return {
+			"Mod-i": () => this.editor.commands.toggleItalic(),
+			"Mod-I": () => this.editor.commands.toggleItalic()
+		};
+	},
+	addInputRules() {
+		return [u({
+			find: Oe,
+			type: this.type
+		}), u({
+			find: Ae,
+			type: this.type
+		})];
+	},
+	addPasteRules() {
+		return [d({
+			find: ke,
+			type: this.type
+		}), d({
+			find: je,
+			type: this.type
+		})];
+	}
+}), Ne = Object.defineProperty, Pe = (e, t) => {
+	for (var n in t) Ne(e, n, {
+		get: t[n],
+		enumerable: !0
+	});
+}, Fe = "listItem", Ie = "textStyle", Le = /^\s*([-+*])\s$/, Re = S.create({
+	name: "bulletList",
+	addOptions() {
+		return {
+			itemTypeName: "listItem",
+			HTMLAttributes: {},
+			keepMarks: !1,
+			keepAttributes: !1
+		};
+	},
+	group: "block list",
+	content() {
+		return `${this.options.itemTypeName}+`;
+	},
+	parseHTML() {
+		return [{ tag: "ul" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"ul",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	markdownTokenName: "list",
+	parseMarkdown: (e, t) => e.type !== "list" || e.ordered ? [] : {
+		type: "bulletList",
+		content: e.items ? t.parseChildren(e.items) : []
+	},
+	renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, "\n") : "",
+	markdownOptions: { indentsContent: !0 },
+	addCommands() {
+		return { toggleBulletList: () => ({ commands: e, chain: t }) => this.options.keepAttributes ? t().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(Fe, this.editor.getAttributes(Ie)).run() : e.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks) };
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Shift-8": () => this.editor.commands.toggleBulletList() };
+	},
+	addInputRules() {
+		let e = y({
+			find: Le,
+			type: this.type
+		});
+		return (this.options.keepMarks || this.options.keepAttributes) && (e = y({
+			find: Le,
+			type: this.type,
+			keepMarks: this.options.keepMarks,
+			keepAttributes: this.options.keepAttributes,
+			getAttributes: () => this.editor.getAttributes(Ie),
+			editor: this.editor
+		})), [e];
+	}
+}), ze = (e, t, n) => {
+	let { selection: r } = e;
+	if (!r.empty) return null;
+	let { $from: i } = r;
+	if (!i.parent.isTextblock || i.parentOffset !== i.parent.content.size) return null;
+	let a = -1;
+	for (let e = i.depth; e > 0; --e) if (i.node(e).type.name === t) {
+		a = e;
+		break;
+	}
+	if (a < 0) return null;
+	let o = i.node(a), s = i.index(a);
+	if (s + 1 >= o.childCount) return null;
+	let c = o.child(s + 1);
+	if (!n.includes(c.type.name)) return null;
+	let l = e.schema.nodes[t], u = !1;
+	if (c.forEach((e) => {
+		e.type === l && e.childCount > 1 && (u = !0);
+	}), !u) return null;
+	let d = e.doc.resolve(i.after()).nodeAfter;
+	if (!d || !n.includes(d.type.name)) return null;
+	let f = [];
+	return d.forEach((e) => {
+		f.push(e);
+	}), f.length === 0 ? null : {
+		listItemDepth: a,
+		nestedList: d,
+		nestedListPos: i.after(),
+		insertPos: i.after(a),
+		items: f
+	};
+}, Be = (e, t, r, i) => {
+	let a = ze(e, r, i);
+	if (!a) return !1;
+	let { selection: o } = e, { nestedList: s, nestedListPos: c, insertPos: l, items: u } = a, d = e.tr;
+	d.delete(c, c + s.nodeSize);
+	let f = d.mapping.map(l);
+	return d.insert(f, n.from(u)), d.setSelection(o.map(d.doc, d.mapping)), t && t(d), !0;
+}, Ve = (e, t, n) => Be(e.state, e.view.dispatch, t, n), He = (e, t) => b.create({
+	name: `${e}BranchingDeleteKeymap`,
+	priority: 101,
+	addKeyboardShortcuts() {
+		let n = () => Ve(this.editor, e, t);
+		return {
+			Delete: n,
+			"Mod-Delete": n
+		};
+	}
+}), Ue = [
+	[1e3, "m"],
+	[900, "cm"],
+	[500, "d"],
+	[400, "cd"],
+	[100, "c"],
+	[90, "xc"],
+	[50, "l"],
+	[40, "xl"],
+	[10, "x"],
+	[9, "ix"],
+	[5, "v"],
+	[4, "iv"],
+	[1, "i"]
+], k = "abcdefghijklmnopqrstuvwxyz", We = String.raw`\d+|[ivxlcdmIVXLCDM]+|${"[a-zA-Z]{1,2}"}`;
+function A(e) {
+	let t = e, n = "";
+	for (let [e, r] of Ue) for (; t >= e;) n += r, t -= e;
+	return n;
+}
+function j(e) {
+	return A(e).toUpperCase();
+}
+function Ge(e) {
+	let t = e.toLowerCase(), n = 0, r = 0;
+	for (; n < t.length;) {
+		let e = !1;
+		for (let [i, a] of Ue) if (t.startsWith(a, n)) {
+			r += i, n += a.length, e = !0;
+			break;
+		}
+		if (!e) return 0;
+	}
+	return r;
+}
+function Ke(e) {
+	if (!/^[ivxlcdmIVXLCDM]+$/.test(e)) return !1;
+	let t = Ge(e);
+	return t <= 0 ? !1 : (e === e.toLowerCase() ? A(t) : j(t)) === e;
+}
+function qe(e) {
+	let t = e.toLowerCase();
+	if (t.length === 1) return t.charCodeAt(0) - 97 + 1;
+	if (t.length === 2) {
+		let e = t.charCodeAt(0) - 97, n = t.charCodeAt(1) - 97;
+		return (e + 1) * 26 + n + 1;
+	}
+	return 0;
+}
+function M(e) {
+	if (e <= 26) return k[e - 1];
+	let t = Math.floor((e - 1) / 26) - 1, n = (e - 1) % 26;
+	return t < 0 ? k[n] : k[t] + k[n];
+}
+function N(e) {
+	if (!(!e || /^\d+$/.test(e))) {
+		if (Ke(e)) return e === e.toLowerCase() ? "i" : "I";
+		if (/^[a-z]{1,2}$/.test(e)) return "a";
+		if (/^[A-Z]{1,2}$/.test(e)) return "A";
+	}
+}
+function P(e) {
+	if (/^\d+$/.test(e)) return parseInt(e, 10);
+	let t = N(e);
+	if (t === "i" || t === "I") return Ge(e);
+	if (t === "a" || t === "A") {
+		let t = qe(e);
+		return t > 0 ? t : 1;
+	}
+	let n = parseInt(e, 10);
+	return Number.isNaN(n) ? 1 : n;
+}
+function Je(e, t) {
+	if (e === "numeric") return String(t);
+	switch (e) {
+		case "a": return M(t);
+		case "A": return M(t).toUpperCase();
+		case "i": return A(t);
+		case "I": return j(t);
+		default: return String(t);
+	}
+}
+function Ye(e) {
+	if (e.length === 0) return !1;
+	let t = N(e[0]) ?? "numeric", n = P(e[0]);
+	if (n < 1) return !1;
+	for (let r = 0; r < e.length; r++) {
+		let i = Je(t, n + r);
+		if (e[r] !== i) return !1;
+	}
+	return !0;
+}
+function Xe(e) {
+	return {
+		type: N(e),
+		start: P(e)
+	};
+}
+function Ze(e) {
+	let { type: t, start: n } = Xe(e), r = {};
+	return t && (r.type = t), n !== 1 && (r.start = n), r;
+}
+function Qe(e, t, n = ". ") {
+	let r = t + 1;
+	if (!e || e === "1") return `${r}${n}`;
+	switch (e) {
+		case "a": return `${M(r)}${n}`;
+		case "A": return `${M(r).toUpperCase()}${n}`;
+		case "i": return `${A(r)}${n}`;
+		case "I": return `${j(r)}${n}`;
+		default: return `${r}${n}`;
+	}
+}
+function $e(e) {
+	let t = e.tokens?.[0];
+	return !!(e.text && e.tokens?.length === 1 && t?.type === "list" && t.ordered && t.raw === e.text);
+}
+function et(e, t) {
+	return t.tokenizeInline ? t.parseInline(t.tokenizeInline(e)) : t.parseInline([{
+		type: "text",
+		raw: e,
+		text: e
+	}]);
+}
+var tt = S.create({
+	name: "listItem",
+	addOptions() {
+		return {
+			HTMLAttributes: {},
+			bulletListTypeName: "bulletList",
+			orderedListTypeName: "orderedList"
+		};
+	},
+	content: "paragraph block*",
+	defining: !0,
+	parseHTML() {
+		return [{ tag: "li" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"li",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	markdownTokenName: "list_item",
+	parseMarkdown: (e, t) => {
+		if (e.type !== "list_item") return [];
+		let n = t.parseBlockChildren ?? t.parseChildren, r = [];
+		if (e.tokens && e.tokens.length > 0) {
+			if ($e(e)) return {
+				type: "listItem",
+				content: [{
+					type: "paragraph",
+					content: et(e.text || "", t)
+				}]
+			};
+			if (e.tokens.some((e) => e.type === "paragraph")) r = n(e.tokens);
+			else {
+				let i = e.tokens[0];
+				if (i && i.type === "text" && i.tokens && i.tokens.length > 0) {
+					if (r = [{
+						type: "paragraph",
+						content: t.parseInline(i.tokens)
+					}], e.tokens.length > 1) {
+						let t = n(e.tokens.slice(1));
+						r.push(...t);
+					}
+				} else r = n(e.tokens);
+			}
+		}
+		return r.length === 0 && (r = [{
+			type: "paragraph",
+			content: []
+		}]), {
+			type: "listItem",
+			content: r
+		};
+	},
+	renderMarkdown: (e, t, n) => te(e, t, (e) => {
+		if (e.parentType === "bulletList") return "- ";
+		if (e.parentType === "orderedList") {
+			let t = e.meta?.parentAttrs?.start || 1;
+			return Qe(e.meta?.parentAttrs?.type, t - 1 + (e.index || 0), ". ");
+		}
+		return "- ";
+	}, n),
+	addExtensions() {
+		return [He(this.name, [this.options.bulletListTypeName, this.options.orderedListTypeName])];
+	},
+	addKeyboardShortcuts() {
+		return {
+			Enter: () => this.editor.commands.splitListItem(this.name),
+			Tab: () => this.editor.commands.sinkListItem(this.name),
+			"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+		};
+	}
+});
+Pe({}, {
+	findListItemPos: () => F,
+	getNextListDepth: () => I,
+	handleBackspace: () => rt,
+	handleDelete: () => ot,
+	hasListBefore: () => nt,
+	hasListItemAfter: () => st,
+	hasListItemBefore: () => ct,
+	listItemHasSubList: () => lt,
+	nextListIsDeeper: () => it,
+	nextListIsHigher: () => at
+});
+var F = (e, t) => {
+	let { $from: n } = t.selection, r = g(e, t.schema), i = null, a = n.depth, o = n.pos, s = null;
+	for (; a > 0 && s === null;) i = n.node(a), i.type === r ? s = a : (--a, --o);
+	return s === null ? null : {
+		$pos: t.doc.resolve(o),
+		depth: s
+	};
+}, I = (e, t) => {
+	let n = F(e, t);
+	if (!n) return !1;
+	let [, r] = ie(t, e, n.$pos.pos + 4);
+	return r;
+}, nt = (e, t, n) => {
+	let { $anchor: r } = e.selection, i = Math.max(0, r.pos - 2), a = e.doc.resolve(i).node();
+	return !(!a || !n.includes(a.type.name));
+}, rt = (e, t, n) => {
+	if (e.commands.undoInputRule()) return !0;
+	if (e.state.selection.from !== e.state.selection.to) return !1;
+	if (!i(e.state, t) && nt(e.state, t, n)) {
+		let { $anchor: n } = e.state.selection, r = e.state.doc.resolve(n.before() - 1), i = [];
+		r.node().descendants((e, n) => {
+			e.type.name === t && i.push({
+				node: e,
+				pos: n
+			});
+		});
+		let a = i.at(-1);
+		if (!a) return !1;
+		let o = e.state.doc.resolve(r.start() + a.pos + 1);
+		return e.chain().cut({
+			from: n.start() - 1,
+			to: n.end() + 1
+		}, o.end()).joinForward().run();
+	}
+	return !i(e.state, t) || !oe(e.state) ? !1 : e.chain().liftListItem(t).run();
+}, it = (e, t) => {
+	let n = I(e, t), r = F(e, t);
+	return !r || !n ? !1 : n > r.depth;
+}, at = (e, t) => {
+	let n = I(e, t), r = F(e, t);
+	return !r || !n ? !1 : n < r.depth;
+}, ot = (e, n) => {
+	if (!i(e.state, n) || !t(e.state, n)) return !1;
+	let { selection: r } = e.state, { $from: a, $to: o } = r;
+	return !r.empty && a.sameParent(o) ? !1 : it(n, e.state) ? e.chain().focus(e.state.selection.from + 4).lift(n).joinBackward().run() : at(n, e.state) ? e.chain().joinForward().joinBackward().run() : e.commands.joinItemForward();
+}, st = (e, t) => {
+	let { $anchor: n } = t.selection, r = t.doc.resolve(n.pos - n.parentOffset - 2);
+	return !(r.index() === r.parent.childCount - 1 || r.nodeAfter?.type.name !== e);
+}, ct = (e, t) => {
+	let { $anchor: n } = t.selection, r = t.doc.resolve(n.pos - 2);
+	return !(r.index() === 0 || r.nodeBefore?.type.name !== e);
+}, lt = (e, t, n) => {
+	if (!n) return !1;
+	let r = g(e, t.schema), i = !1;
+	return n.descendants((e) => {
+		e.type === r && (i = !0);
+	}), i;
+}, ut = b.create({
+	name: "listKeymap",
+	addOptions() {
+		return { listTypes: [{
+			itemName: "listItem",
+			wrapperNames: ["bulletList", "orderedList"]
+		}, {
+			itemName: "taskItem",
+			wrapperNames: ["taskList"]
+		}] };
+	},
+	addKeyboardShortcuts() {
+		return {
+			Delete: ({ editor: e }) => {
+				let t = !1;
+				return this.options.listTypes.forEach(({ itemName: n }) => {
+					e.state.schema.nodes[n] !== void 0 && ot(e, n) && (t = !0);
+				}), t;
+			},
+			"Mod-Delete": ({ editor: e }) => {
+				let t = !1;
+				return this.options.listTypes.forEach(({ itemName: n }) => {
+					e.state.schema.nodes[n] !== void 0 && ot(e, n) && (t = !0);
+				}), t;
+			},
+			Backspace: ({ editor: e }) => {
+				let t = !1;
+				return this.options.listTypes.forEach(({ itemName: n, wrapperNames: r }) => {
+					e.state.schema.nodes[n] !== void 0 && rt(e, n, r) && (t = !0);
+				}), t;
+			},
+			"Mod-Backspace": ({ editor: e }) => {
+				let t = !1;
+				return this.options.listTypes.forEach(({ itemName: n, wrapperNames: r }) => {
+					e.state.schema.nodes[n] !== void 0 && rt(e, n, r) && (t = !0);
+				}), t;
+			}
+		};
+	}
+}), L = RegExp(`^(\\s*)(${We})([.)])\\s+(.*)$`), dt = /^\s/, R = {
+	heading: /^#{1,6}(?:\s|$)/,
+	bulletItem: /^[-+*]\s+/,
+	codeFence: /^(?:```|~~~)/,
+	thematicBreak: /^(?:(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})$/
+};
+function ft(e) {
+	return L.test(e.trimStart());
+}
+function pt(e) {
+	let t = e.trimStart();
+	return R.bulletItem.test(t) || ft(t) || R.heading.test(t) || R.thematicBreak.test(t) && !t.startsWith("-") || /^>\s?/.test(t) || R.codeFence.test(t);
+}
+function mt(e) {
+	return Object.values(R).some((t) => t.test(e));
+}
+function ht(e) {
+	let t = [], n = [], r = !1;
+	return e.forEach((e) => {
+		if (r) {
+			n.push(e);
+			return;
+		}
+		if (e.trim() === "") {
+			r = !0, n.push(e);
+			return;
+		}
+		if (t.length > 0 && pt(e)) {
+			r = !0, n.push(e);
+			return;
+		}
+		t.push(e);
+	}), {
+		paragraphLines: t,
+		blockLines: n
+	};
+}
+function gt(e) {
+	let t = [], n = 0, r = 0;
+	for (; n < e.length;) {
+		let i = e[n], a = i.match(L);
+		if (!a) break;
+		let [, o, s, c, l] = a, u = o.length, d = parseInt(s, 10), f = isNaN(d) ? N(s) : void 0, p = isNaN(d) ? P(s) : d, m = [l], h = n + 1, g = [i], _ = !1;
+		for (; h < e.length;) {
+			let t = e[h];
+			if (t.match(L)) break;
+			if (t.trim() === "") g.push(t), m.push(""), _ = !0, h += 1;
+			else if (t.match(dt)) {
+				let e = t.length - t.trimStart().length, n = u + s.length + 1;
+				g.push(t), m.push(t.slice(Math.min(e, n))), h += 1;
+			} else {
+				if (_ || mt(t)) break;
+				g.push(t), m.push(t), h += 1;
+			}
+		}
+		t.push({
+			indent: u,
+			number: p,
+			type: f,
+			content: m.join("\n").trim(),
+			contentLines: m,
+			raw: g.join("\n")
+		}), r = h, n = h;
+	}
+	return [t, r];
+}
+var _t = RegExp(`^(${We})([.)])\\s+(.+)$`);
+function vt(e) {
+	let t = e.split("\n").filter((e) => e.trim().length > 0);
+	if (t.length === 0) return null;
+	let n = [];
+	for (let e of t) {
+		let t = e.trim().match(_t);
+		if (!t) return null;
+		n.push({
+			marker: t[1],
+			content: t[3]
+		});
+	}
+	return Ye(n.map((e) => e.marker)) ? {
+		type: "orderedList",
+		attrs: Ze(n[0].marker),
+		content: n.map((e) => ({
+			type: "listItem",
+			content: [{
+				type: "paragraph",
+				content: [{
+					type: "text",
+					text: e.content
+				}]
+			}]
+		}))
+	} : null;
+}
+function yt(e, t, n) {
+	let r = [], i = 0;
+	for (; i < e.length;) {
+		let a = e[i];
+		if (a.indent === t) {
+			let { paragraphLines: o, blockLines: s } = ht(a.contentLines), c = o.join("\n").trim(), l = [];
+			c && l.push({
+				type: "paragraph",
+				raw: c,
+				tokens: n.inlineTokens(c)
+			});
+			let u = s.join("\n").trim();
+			if (u) {
+				let e = n.blockTokens(u);
+				l.push(...e);
+			}
+			let d = i + 1, f = [];
+			for (; d < e.length && e[d].indent > t;) f.push(e[d]), d += 1;
+			if (f.length > 0) {
+				let e = yt(f, Math.min(...f.map((e) => e.indent)), n);
+				l.push({
+					type: "list",
+					ordered: !0,
+					start: f[0].number,
+					typeMarker: f[0].type,
+					items: e,
+					raw: f.map((e) => e.raw).join("\n")
+				});
+			}
+			r.push({
+				type: "list_item",
+				raw: a.raw,
+				tokens: l
+			}), i = d;
+		} else i += 1;
+	}
+	return r;
+}
+function bt(e, t) {
+	return e.map((e) => {
+		if (e.type !== "list_item") return t.parseChildren([e])[0];
+		let n = [];
+		return e.tokens && e.tokens.length > 0 && e.tokens.forEach((e) => {
+			if (e.type === "paragraph" || e.type === "list" || e.type === "blockquote" || e.type === "code") n.push(...t.parseChildren([e]));
+			else if (e.type === "text" && e.tokens) {
+				let r = t.parseChildren([e]);
+				n.push({
+					type: "paragraph",
+					content: r
+				});
+			} else {
+				let r = t.parseChildren([e]);
+				r.length > 0 && n.push(...r);
+			}
+		}), {
+			type: "listItem",
+			content: n
+		};
+	});
+}
+var xt = "listItem", St = "textStyle", Ct = /^(\d+)\.\s$/;
+function wt(e) {
+	let t = e.match(/list-style-type\s*:\s*([^;]+)/i);
+	if (!t) return null;
+	switch (t[1].trim().toLowerCase()) {
+		case "upper-roman": return "I";
+		case "lower-roman": return "i";
+		case "upper-alpha":
+		case "upper-latin": return "A";
+		case "lower-alpha":
+		case "lower-latin": return "a";
+		default: return null;
+	}
+}
+var Tt = S.create({
+	name: "orderedList",
+	addOptions() {
+		return {
+			itemTypeName: "listItem",
+			HTMLAttributes: {},
+			keepMarks: !1,
+			keepAttributes: !1
+		};
+	},
+	group: "block list",
+	content() {
+		return `${this.options.itemTypeName}+`;
+	},
+	addAttributes() {
+		return {
+			start: {
+				default: 1,
+				parseHTML: (e) => e.hasAttribute("start") ? parseInt(e.getAttribute("start") || "", 10) : 1
+			},
+			type: {
+				default: null,
+				parseHTML: (e) => {
+					let t = e.getAttribute("type");
+					if (t) return t;
+					let n = e.getAttribute("style");
+					if (n) {
+						let e = wt(n);
+						if (e) return e;
+					}
+					let r = e.querySelector("li");
+					if (r) {
+						let e = r.getAttribute("style");
+						if (e) {
+							let t = wt(e);
+							if (t) return t;
+						}
+					}
+					return null;
+				}
+			}
+		};
+	},
+	parseHTML() {
+		return [{ tag: "ol" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		let { start: t, type: n, ...r } = e, i = x(this.options.HTMLAttributes, r);
+		return t !== 1 && (i.start = t), n && n !== "1" && (i.type = n), [
+			"ol",
+			i,
+			0
+		];
+	},
+	markdownTokenName: "list",
+	parseMarkdown: (e, t) => {
+		if (e.type !== "list" || !e.ordered) return [];
+		let n = e.start || 1, r = e.typeMarker, i = e.items ? bt(e.items, t) : [], a = {};
+		return n !== 1 && (a.start = n), r && (a.type = r), Object.keys(a).length > 0 ? {
+			type: "orderedList",
+			attrs: a,
+			content: i
+		} : {
+			type: "orderedList",
+			content: i
+		};
+	},
+	renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, "\n") : "",
+	markdownTokenizer: {
+		name: "orderedList",
+		level: "block",
+		start: () => -1,
+		tokenize: (e, t, n) => {
+			let r = e.split("\n"), [i, a] = gt(r);
+			if (i.length === 0) return;
+			let o = yt(i, i[0].indent, n);
+			if (o.length !== 0) return {
+				type: "list",
+				ordered: !0,
+				start: i[0]?.number || 1,
+				typeMarker: i[0]?.type,
+				items: o,
+				raw: r.slice(0, a).join("\n")
+			};
+		}
+	},
+	markdownOptions: { indentsContent: !0 },
+	addCommands() {
+		return { toggleOrderedList: () => ({ commands: e, chain: t }) => this.options.keepAttributes ? t().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(xt, this.editor.getAttributes(St)).run() : e.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks) };
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Shift-7": () => this.editor.commands.toggleOrderedList() };
+	},
+	addProseMirrorPlugins() {
+		return [new T({ props: { handlePaste: (e, t) => {
+			if ((t.clipboardData?.getData("text/html"))?.trim()) return !1;
+			let n = t.clipboardData?.getData("text/plain");
+			if (!n) return !1;
+			let r = vt(n);
+			if (!r) return !1;
+			try {
+				let t = e.state.schema.nodeFromJSON(r), n = e.state.tr.replaceSelectionWith(t);
+				return e.dispatch(n), !0;
+			} catch {
+				return !1;
+			}
+		} } })];
+	},
+	addInputRules() {
+		let e = (e, t) => (!t.attrs.type || t.attrs.type === "1") && t.childCount + t.attrs.start === +e[1], t = y({
+			find: Ct,
+			type: this.type,
+			getAttributes: (e) => ({ start: +e[1] }),
+			joinPredicate: e
+		});
+		return (this.options.keepMarks || this.options.keepAttributes) && (t = y({
+			find: Ct,
+			type: this.type,
+			keepMarks: this.options.keepMarks,
+			keepAttributes: this.options.keepAttributes,
+			getAttributes: (e) => ({
+				start: +e[1],
+				...this.editor.getAttributes(St)
+			}),
+			joinPredicate: e,
+			editor: this.editor
+		})), [t];
+	}
+}), Et = /^\s*(\[([( |x])?\])\s$/, Dt = S.create({
+	name: "taskItem",
+	addOptions() {
+		return {
+			nested: !1,
+			HTMLAttributes: {},
+			taskListTypeName: "taskList",
+			a11y: void 0
+		};
+	},
+	content() {
+		return this.options.nested ? "paragraph block*" : "paragraph+";
+	},
+	defining: !0,
+	addAttributes() {
+		return { checked: {
+			default: !1,
+			keepOnSplit: !1,
+			parseHTML: (e) => {
+				let t = e.getAttribute("data-checked");
+				return t === "" || t === "true";
+			},
+			renderHTML: (e) => ({ "data-checked": e.checked })
+		} };
+	},
+	parseHTML() {
+		return [{
+			tag: `li[data-type="${this.name}"]`,
+			priority: 51
+		}];
+	},
+	renderHTML({ node: e, HTMLAttributes: t }) {
+		return [
+			"li",
+			x(this.options.HTMLAttributes, t, { "data-type": this.name }),
+			[
+				"label",
+				["input", {
+					type: "checkbox",
+					checked: e.attrs.checked ? "checked" : null
+				}],
+				["span"]
+			],
+			["div", 0]
+		];
+	},
+	parseMarkdown: (e, t) => {
+		let n = [];
+		if (e.tokens && e.tokens.length > 0 ? n.push(t.createNode("paragraph", {}, t.parseInline(e.tokens))) : e.text ? n.push(t.createNode("paragraph", {}, [t.createNode("text", { text: e.text })])) : n.push(t.createNode("paragraph", {}, [])), e.nestedTokens && e.nestedTokens.length > 0) {
+			let r = t.parseChildren(e.nestedTokens);
+			n.push(...r);
+		}
+		return t.createNode("taskItem", { checked: e.checked || !1 }, n);
+	},
+	renderMarkdown: (e, t) => te(e, t, `- [${e.attrs?.checked ? "x" : " "}] `),
+	addExtensions() {
+		return this.options.nested ? [He(this.name, [this.options.taskListTypeName])] : [];
+	},
+	addKeyboardShortcuts() {
+		let e = {
+			Enter: () => this.editor.commands.splitListItem(this.name),
+			"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+		};
+		return this.options.nested ? {
+			...e,
+			Tab: () => this.editor.commands.sinkListItem(this.name)
+		} : e;
+	},
+	addNodeView() {
+		return ({ node: e, HTMLAttributes: t, getPos: n, editor: r }) => {
+			let i = document.createElement("li"), a = document.createElement("label"), o = document.createElement("span"), s = document.createElement("input"), c = document.createElement("div"), l = (e) => {
+				var t;
+				s.ariaLabel = ((t = this.options.a11y)?.checkboxLabel)?.call(t, e, s.checked) || `Task item checkbox for ${e.textContent || "empty task item"}`;
+			};
+			l(e), a.contentEditable = "false", s.type = "checkbox", s.addEventListener("mousedown", (e) => e.preventDefault()), s.addEventListener("change", (t) => {
+				if (!r.isEditable && !this.options.onReadOnlyChecked) {
+					s.checked = !s.checked;
+					return;
+				}
+				let { checked: i } = t.target;
+				r.isEditable && typeof n == "function" && r.chain().focus(void 0, { scrollIntoView: !1 }).command(({ tr: e }) => {
+					let t = n();
+					if (typeof t != "number") return !1;
+					let r = e.doc.nodeAt(t);
+					return e.setNodeMarkup(t, void 0, {
+						...r?.attrs,
+						checked: i
+					}), !0;
+				}).run(), !r.isEditable && this.options.onReadOnlyChecked && (this.options.onReadOnlyChecked(e, i) || (s.checked = !s.checked));
+			}), Object.entries(this.options.HTMLAttributes).forEach(([e, t]) => {
+				i.setAttribute(e, t);
+			}), i.dataset.checked = e.attrs.checked, s.checked = e.attrs.checked, a.append(s, o), i.append(a, c), Object.entries(t).forEach(([e, t]) => {
+				i.setAttribute(e, t);
+			});
+			let u = new Set(Object.keys(t));
+			return {
+				dom: i,
+				contentDOM: c,
+				update: (e) => {
+					if (e.type !== this.type) return !1;
+					i.dataset.checked = e.attrs.checked, s.checked = e.attrs.checked, l(e);
+					let t = r.extensionManager.attributes, n = re(e, t), a = new Set(Object.keys(n)), o = this.options.HTMLAttributes;
+					return u.forEach((e) => {
+						a.has(e) || (e in o ? i.setAttribute(e, o[e]) : i.removeAttribute(e));
+					}), Object.entries(n).forEach(([e, t]) => {
+						t == null ? e in o ? i.setAttribute(e, o[e]) : i.removeAttribute(e) : i.setAttribute(e, t);
+					}), u = a, !0;
+				}
+			};
+		};
+	},
+	addInputRules() {
+		return [y({
+			find: Et,
+			type: this.type,
+			getAttributes: (e) => ({ checked: e[e.length - 1] === "x" })
+		})];
+	}
+}), Ot = S.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: e }) {
+		return [
+			"ul",
+			x(this.options.HTMLAttributes, e, { "data-type": this.name }),
+			0
+		];
+	},
+	parseMarkdown: (e, t) => t.createNode("taskList", {}, t.parseChildren(e.items || [])),
+	renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, "\n") : "",
+	markdownTokenizer: {
+		name: "taskList",
+		level: "block",
+		start(e) {
+			let t = e.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)?.index;
+			return t === void 0 ? -1 : t;
+		},
+		tokenize(e, t, n) {
+			let r = (e) => {
+				let t = ee(e, {
+					itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+					extractItemData: (e) => ({
+						indentLevel: e[1].length,
+						mainContent: e[4],
+						checked: e[3].toLowerCase() === "x"
+					}),
+					createToken: (e, t) => ({
+						type: "taskItem",
+						raw: "",
+						mainContent: e.mainContent,
+						indentLevel: e.indentLevel,
+						checked: e.checked,
+						text: e.mainContent,
+						tokens: n.inlineTokens(e.mainContent),
+						nestedTokens: t
+					}),
+					customNestedParser: r
+				}, n);
+				if (t) {
+					let r = {
+						type: "taskList",
+						raw: t.raw,
+						items: t.items
+					}, i = e.slice(t.raw.length);
+					return i.trim() ? [r, ...n.blockTokens(i)] : [r];
+				}
+				return n.blockTokens(e);
+			}, i = ee(e, {
+				itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+				extractItemData: (e) => ({
+					indentLevel: e[1].length,
+					mainContent: e[4],
+					checked: e[3].toLowerCase() === "x"
+				}),
+				createToken: (e, t) => ({
+					type: "taskItem",
+					raw: "",
+					mainContent: e.mainContent,
+					indentLevel: e.indentLevel,
+					checked: e.checked,
+					text: e.mainContent,
+					tokens: n.inlineTokens(e.mainContent),
+					nestedTokens: t
+				}),
+				customNestedParser: r
+			}, n);
+			if (i) return {
+				type: "taskList",
+				raw: i.raw,
+				items: i.items
+			};
+		}
+	},
+	markdownOptions: { indentsContent: !0 },
+	addCommands() {
+		return { toggleTaskList: () => ({ commands: e }) => e.toggleList(this.name, this.options.itemTypeName) };
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Shift-9": () => this.editor.commands.toggleTaskList() };
+	}
+});
+b.create({
+	name: "listKit",
+	addExtensions() {
+		let e = [];
+		return this.options.bulletList !== !1 && e.push(Re.configure(this.options.bulletList)), this.options.listItem !== !1 && e.push(tt.configure(this.options.listItem)), this.options.listKeymap !== !1 && e.push(ut.configure(this.options.listKeymap)), this.options.orderedList !== !1 && e.push(Tt.configure(this.options.orderedList)), this.options.taskItem !== !1 && e.push(Dt.configure(this.options.taskItem)), this.options.taskList !== !1 && e.push(Ot.configure(this.options.taskList)), e;
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tiptap+extension-paragraph@3.28.0_@tiptap+core@3.28.0_@tiptap+pm@3.28.0_/node_modules/@tiptap/extension-paragraph/dist/index.js
+var z = "&nbsp;", B = "\xA0", kt = S.create({
+	name: "paragraph",
+	priority: 1e3,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	group: "block",
+	content: "inline*",
+	parseHTML() {
+		return [{ tag: "p" }];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"p",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	parseMarkdown: (e, t) => {
+		let n = e.tokens || [];
+		if (n.length === 1 && n[0].type === "image") return t.parseChildren([n[0]]);
+		let r = t.parseInline(n);
+		return n.length === 1 && n[0].type === "text" && (n[0].raw === z || n[0].text === z || n[0].raw === B || n[0].text === B) && r.length === 1 && r[0].type === "text" && (r[0].text === z || r[0].text === B) ? t.createNode("paragraph", void 0, []) : t.createNode("paragraph", void 0, r);
+	},
+	renderMarkdown: (e, t, n) => {
+		if (!e) return "";
+		let r = Array.isArray(e.content) ? e.content : [];
+		if (r.length === 0) {
+			let e = Array.isArray(n?.previousNode?.content) ? n.previousNode.content : [];
+			return n?.previousNode?.type === "paragraph" && e.length === 0 ? z : "";
+		}
+		return t.renderChildren(r);
+	},
+	addCommands() {
+		return { setParagraph: () => ({ commands: e }) => e.setNode(this.name) };
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Alt-0": () => this.editor.commands.setParagraph() };
+	}
+}), At = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, jt = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, Mt = v.create({
+	name: "strike",
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	parseHTML() {
+		return [
+			{ tag: "s" },
+			{ tag: "del" },
+			{ tag: "strike" },
+			{
+				style: "text-decoration",
+				consuming: !1,
+				getAttrs: (e) => e.includes("line-through") ? {} : !1
+			}
+		];
+	},
+	renderHTML({ HTMLAttributes: e }) {
+		return [
+			"s",
+			x(this.options.HTMLAttributes, e),
+			0
+		];
+	},
+	markdownTokenName: "del",
+	parseMarkdown: (e, t) => t.applyMark("strike", t.parseInline(e.tokens || [])),
+	renderMarkdown: (e, t) => `~~${t.renderChildren(e)}~~`,
+	addCommands() {
+		return {
+			setStrike: () => ({ commands: e }) => e.setMark(this.name),
+			toggleStrike: () => ({ commands: e }) => e.toggleMark(this.name),
+			unsetStrike: () => ({ commands: e }) => e.unsetMark(this.name)
+		};
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Shift-s": () => this.editor.commands.toggleStrike() };
+	},
+	addInputRules() {
+		return [u({
+			find: At,
+			type: this.type
+		})];
+	},
+	addPasteRules() {
+		return [d({
+			find: jt,
+			type: this.type
+		})];
+	}
+}), Nt = S.create({
+	name: "text",
+	group: "inline",
+	parseMarkdown: (e) => ({
+		type: "text",
+		text: e.text || ""
+	}),
+	renderMarkdown: (e) => e.text || ""
+});
+//#endregion
+//#region ../../node_modules/.pnpm/prosemirror-dropcursor@1.8.2/node_modules/prosemirror-dropcursor/dist/index.js
+function Pt(e = {}) {
+	return new T({ view(t) {
+		return new Ft(t, e);
+	} });
+}
+var Ft = class {
+	constructor(e, t) {
+		this.editorView = e, this.cursorPos = null, this.element = null, this.timeout = -1, this.width = t.width ?? 1, this.color = t.color === !1 ? void 0 : t.color || "black", this.class = t.class, this.handlers = [
+			"dragover",
+			"dragend",
+			"drop",
+			"dragleave"
+		].map((t) => {
+			let n = (e) => {
+				this[t](e);
+			};
+			return e.dom.addEventListener(t, n), {
+				name: t,
+				handler: n
+			};
+		});
+	}
+	destroy() {
+		this.handlers.forEach(({ name: e, handler: t }) => this.editorView.dom.removeEventListener(e, t));
+	}
+	update(e, t) {
+		this.cursorPos != null && t.doc != e.state.doc && (this.cursorPos > e.state.doc.content.size ? this.setCursor(null) : this.updateOverlay());
+	}
+	setCursor(e) {
+		e != this.cursorPos && (this.cursorPos = e, e == null ? (this.element.parentNode.removeChild(this.element), this.element = null) : this.updateOverlay());
+	}
+	updateOverlay() {
+		let e = this.editorView.state.doc.resolve(this.cursorPos), t = !e.parent.inlineContent, n, r = this.editorView.dom, i = r.getBoundingClientRect(), a = i.width / r.offsetWidth, o = i.height / r.offsetHeight;
+		if (t) {
+			let t = e.nodeBefore, r = e.nodeAfter;
+			if (t || r) {
+				let e = this.editorView.nodeDOM(this.cursorPos - (t ? t.nodeSize : 0));
+				if (e) {
+					let i = e.getBoundingClientRect(), a = t ? i.bottom : i.top;
+					t && r && (a = (a + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2);
+					let s = this.width / 2 * o;
+					n = {
+						left: i.left,
+						right: i.right,
+						top: a - s,
+						bottom: a + s
+					};
+				}
+			}
+		}
+		if (!n) {
+			let e = this.editorView.coordsAtPos(this.cursorPos), t = this.width / 2 * a;
+			n = {
+				left: e.left - t,
+				right: e.left + t,
+				top: e.top,
+				bottom: e.bottom
+			};
+		}
+		let s = this.editorView.dom.offsetParent;
+		this.element || (this.element = s.appendChild(document.createElement("div")), this.class && (this.element.className = this.class), this.element.style.cssText = "position: absolute; z-index: 50; pointer-events: none;", this.color && (this.element.style.backgroundColor = this.color)), this.element.classList.toggle("prosemirror-dropcursor-block", t), this.element.classList.toggle("prosemirror-dropcursor-inline", !t);
+		let c, l;
+		if (!s || s == document.body && getComputedStyle(s).position == "static") c = -pageXOffset, l = -pageYOffset;
+		else {
+			let e = s.getBoundingClientRect(), t = e.width / s.offsetWidth, n = e.height / s.offsetHeight;
+			c = e.left - s.scrollLeft * t, l = e.top - s.scrollTop * n;
+		}
+		this.element.style.left = (n.left - c) / a + "px", this.element.style.top = (n.top - l) / o + "px", this.element.style.width = (n.right - n.left) / a + "px", this.element.style.height = (n.bottom - n.top) / o + "px";
+	}
+	scheduleRemoval(e) {
+		clearTimeout(this.timeout), this.timeout = setTimeout(() => this.setCursor(null), e);
+	}
+	dragover(e) {
+		if (!this.editorView.editable) return;
+		let t = this.editorView.posAtCoords({
+			left: e.clientX,
+			top: e.clientY
+		}), n = t && t.inside >= 0 && this.editorView.state.doc.nodeAt(t.inside), i = n && n.type.spec.disableDropCursor, a = typeof i == "function" ? i(this.editorView, t, e) : i;
+		if (t && !a) {
+			let e = t.pos;
+			if (this.editorView.dragging && this.editorView.dragging.slice) {
+				let t = r(this.editorView.state.doc, e, this.editorView.dragging.slice);
+				t != null && (e = t);
+			}
+			this.setCursor(e), this.scheduleRemoval(5e3);
+		}
+	}
+	dragend() {
+		this.scheduleRemoval(20);
+	}
+	drop() {
+		this.scheduleRemoval(20);
+	}
+	dragleave(e) {
+		this.editorView.dom.contains(e.relatedTarget) || this.setCursor(null);
+	}
+}, V = class t extends e {
+	constructor(e) {
+		super(e, e);
+	}
+	map(n, r) {
+		let i = n.resolve(r.map(this.head));
+		return t.valid(i) ? new t(i) : e.near(i);
+	}
+	content() {
+		return o.empty;
+	}
+	eq(e) {
+		return e instanceof t && e.head == this.head;
+	}
+	toJSON() {
+		return {
+			type: "gapcursor",
+			pos: this.head
+		};
+	}
+	static fromJSON(e, n) {
+		if (typeof n.pos != "number") throw RangeError("Invalid input for GapCursor.fromJSON");
+		return new t(e.resolve(n.pos));
+	}
+	getBookmark() {
+		return new It(this.anchor);
+	}
+	static valid(e) {
+		let t = e.parent;
+		if (t.inlineContent || !Rt(e) || !zt(e)) return !1;
+		let n = t.type.spec.allowGapCursor;
+		if (n != null) return n;
+		let r = t.contentMatchAt(e.index()).defaultType;
+		return r && r.isTextblock;
+	}
+	static findGapCursorFrom(e, n, r = !1) {
+		search: for (;;) {
+			if (!r && t.valid(e)) return e;
+			let i = e.pos, a = null;
+			for (let r = e.depth;; r--) {
+				let o = e.node(r);
+				if (n > 0 ? e.indexAfter(r) < o.childCount : e.index(r) > 0) {
+					a = o.child(n > 0 ? e.indexAfter(r) : e.index(r) - 1);
+					break;
+				} else if (r == 0) return null;
+				i += n;
+				let s = e.doc.resolve(i);
+				if (t.valid(s)) return s;
+			}
+			for (;;) {
+				let o = n > 0 ? a.firstChild : a.lastChild;
+				if (!o) {
+					if (a.isAtom && !a.isText && !_.isSelectable(a)) {
+						e = e.doc.resolve(i + a.nodeSize * n), r = !1;
+						continue search;
+					}
+					break;
+				}
+				a = o, i += n;
+				let s = e.doc.resolve(i);
+				if (t.valid(s)) return s;
+			}
+			return null;
+		}
+	}
+};
+V.prototype.visible = !1, V.findFrom = V.findGapCursorFrom, e.jsonID("gapcursor", V);
+var It = class t {
+	constructor(e) {
+		this.pos = e;
+	}
+	map(e) {
+		return new t(e.map(this.pos));
+	}
+	resolve(t) {
+		let n = t.resolve(this.pos);
+		return V.valid(n) ? new V(n) : e.near(n);
+	}
+};
+function Lt(e) {
+	return e.isAtom || e.spec.isolating || e.spec.createGapCursor;
+}
+function Rt(e) {
+	for (let t = e.depth; t >= 0; t--) {
+		let n = e.index(t), r = e.node(t);
+		if (n == 0) {
+			if (r.type.spec.isolating) return !0;
+			continue;
+		}
+		for (let e = r.child(n - 1);; e = e.lastChild) {
+			if (e.childCount == 0 && !e.inlineContent || Lt(e.type)) return !0;
+			if (e.inlineContent) return !1;
+		}
+	}
+	return !0;
+}
+function zt(e) {
+	for (let t = e.depth; t >= 0; t--) {
+		let n = e.indexAfter(t), r = e.node(t);
+		if (n == r.childCount) {
+			if (r.type.spec.isolating) return !0;
+			continue;
+		}
+		for (let e = r.child(n);; e = e.firstChild) {
+			if (e.childCount == 0 && !e.inlineContent || Lt(e.type)) return !0;
+			if (e.inlineContent) return !1;
+		}
+	}
+	return !0;
+}
+function Bt() {
+	return new T({ props: {
+		decorations: Wt,
+		createSelectionBetween(e, t, n) {
+			return t.pos == n.pos && V.valid(n) ? new V(n) : null;
+		},
+		handleClick: Ht,
+		handleKeyDown: Vt,
+		handleDOMEvents: { beforeinput: Ut }
+	} });
+}
+var Vt = h({
+	ArrowLeft: H("horiz", -1),
+	ArrowRight: H("horiz", 1),
+	ArrowUp: H("vert", -1),
+	ArrowDown: H("vert", 1)
+});
+function H(e, t) {
+	let n = e == "vert" ? t > 0 ? "down" : "up" : t > 0 ? "right" : "left";
+	return function(e, r, i) {
+		let a = e.selection, o = t > 0 ? a.$to : a.$from, s = a.empty;
+		if (a instanceof w) {
+			if (!i.endOfTextblock(n) || o.depth == 0) return !1;
+			s = !1, o = e.doc.resolve(t > 0 ? o.after() : o.before());
+		}
+		let c = V.findGapCursorFrom(o, t, s);
+		return c ? (r && r(e.tr.setSelection(new V(c))), !0) : !1;
+	};
+}
+function Ht(e, t, n) {
+	if (!e || !e.editable) return !1;
+	let r = e.state.doc.resolve(t);
+	if (!V.valid(r)) return !1;
+	let i = e.posAtCoords({
+		left: n.clientX,
+		top: n.clientY
+	});
+	return i && i.inside > -1 && _.isSelectable(e.state.doc.nodeAt(i.inside)) ? !1 : (e.dispatch(e.state.tr.setSelection(new V(r))), !0);
+}
+function Ut(e, t) {
+	if (t.inputType != "insertCompositionText" || !(e.state.selection instanceof V)) return !1;
+	let { $from: r } = e.state.selection, i = r.parent.contentMatchAt(r.index()).findWrapping(e.state.schema.nodes.text);
+	if (!i) return !1;
+	let a = n.empty;
+	for (let e = i.length - 1; e >= 0; e--) a = n.from(i[e].createAndFill(null, a));
+	let s = e.state.tr.replace(r.pos, r.pos, new o(a, 0, 0));
+	return s.setSelection(w.near(s.doc.resolve(r.pos + 1))), e.dispatch(s), !1;
+}
+function Wt(e) {
+	if (!(e.selection instanceof V)) return null;
+	let t = document.createElement("div");
+	return t.className = "ProseMirror-gapcursor", E.create(e.doc, [C.widget(e.selection.head, t, { key: "gapcursor" })]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rope-sequence@1.3.4/node_modules/rope-sequence/dist/index.js
+var U = 200, W = function() {};
+W.prototype.append = function(e) {
+	return e.length ? (e = W.from(e), !this.length && e || e.length < U && this.leafAppend(e) || this.length < U && e.leafPrepend(this) || this.appendInner(e)) : this;
+}, W.prototype.prepend = function(e) {
+	return e.length ? W.from(e).append(this) : this;
+}, W.prototype.appendInner = function(e) {
+	return new Kt(this, e);
+}, W.prototype.slice = function(e, t) {
+	return e === void 0 && (e = 0), t === void 0 && (t = this.length), e >= t ? W.empty : this.sliceInner(Math.max(0, e), Math.min(this.length, t));
+}, W.prototype.get = function(e) {
+	if (!(e < 0 || e >= this.length)) return this.getInner(e);
+}, W.prototype.forEach = function(e, t, n) {
+	t === void 0 && (t = 0), n === void 0 && (n = this.length), t <= n ? this.forEachInner(e, t, n, 0) : this.forEachInvertedInner(e, t, n, 0);
+}, W.prototype.map = function(e, t, n) {
+	t === void 0 && (t = 0), n === void 0 && (n = this.length);
+	var r = [];
+	return this.forEach(function(t, n) {
+		return r.push(e(t, n));
+	}, t, n), r;
+}, W.from = function(e) {
+	return e instanceof W ? e : e && e.length ? new Gt(e) : W.empty;
+};
+var Gt = /* @__PURE__ */ function(e) {
+	function t(t) {
+		e.call(this), this.values = t;
+	}
+	e && (t.__proto__ = e), t.prototype = Object.create(e && e.prototype), t.prototype.constructor = t;
+	var n = {
+		length: { configurable: !0 },
+		depth: { configurable: !0 }
+	};
+	return t.prototype.flatten = function() {
+		return this.values;
+	}, t.prototype.sliceInner = function(e, n) {
+		return e == 0 && n == this.length ? this : new t(this.values.slice(e, n));
+	}, t.prototype.getInner = function(e) {
+		return this.values[e];
+	}, t.prototype.forEachInner = function(e, t, n, r) {
+		for (var i = t; i < n; i++) if (e(this.values[i], r + i) === !1) return !1;
+	}, t.prototype.forEachInvertedInner = function(e, t, n, r) {
+		for (var i = t - 1; i >= n; i--) if (e(this.values[i], r + i) === !1) return !1;
+	}, t.prototype.leafAppend = function(e) {
+		if (this.length + e.length <= U) return new t(this.values.concat(e.flatten()));
+	}, t.prototype.leafPrepend = function(e) {
+		if (this.length + e.length <= U) return new t(e.flatten().concat(this.values));
+	}, n.length.get = function() {
+		return this.values.length;
+	}, n.depth.get = function() {
+		return 0;
+	}, Object.defineProperties(t.prototype, n), t;
+}(W);
+W.empty = new Gt([]);
+var Kt = /* @__PURE__ */ function(e) {
+	function t(t, n) {
+		e.call(this), this.left = t, this.right = n, this.length = t.length + n.length, this.depth = Math.max(t.depth, n.depth) + 1;
+	}
+	return e && (t.__proto__ = e), t.prototype = Object.create(e && e.prototype), t.prototype.constructor = t, t.prototype.flatten = function() {
+		return this.left.flatten().concat(this.right.flatten());
+	}, t.prototype.getInner = function(e) {
+		return e < this.left.length ? this.left.get(e) : this.right.get(e - this.left.length);
+	}, t.prototype.forEachInner = function(e, t, n, r) {
+		var i = this.left.length;
+		if (t < i && this.left.forEachInner(e, t, Math.min(n, i), r) === !1 || n > i && this.right.forEachInner(e, Math.max(t - i, 0), Math.min(this.length, n) - i, r + i) === !1) return !1;
+	}, t.prototype.forEachInvertedInner = function(e, t, n, r) {
+		var i = this.left.length;
+		if (t > i && this.right.forEachInvertedInner(e, t - i, Math.max(n, i) - i, r + i) === !1 || n < i && this.left.forEachInvertedInner(e, Math.min(t, i), n, r) === !1) return !1;
+	}, t.prototype.sliceInner = function(e, t) {
+		if (e == 0 && t == this.length) return this;
+		var n = this.left.length;
+		return t <= n ? this.left.slice(e, t) : e >= n ? this.right.slice(e - n, t - n) : this.left.slice(e, n).append(this.right.slice(0, t - n));
+	}, t.prototype.leafAppend = function(e) {
+		var n = this.right.leafAppend(e);
+		if (n) return new t(this.left, n);
+	}, t.prototype.leafPrepend = function(e) {
+		var n = this.left.leafPrepend(e);
+		if (n) return new t(n, this.right);
+	}, t.prototype.appendInner = function(e) {
+		return this.left.depth >= Math.max(this.right.depth, e.depth) + 1 ? new t(this.left, new t(this.right, e)) : new t(this, e);
+	}, t;
+}(W), qt = 500, G = class e {
+	constructor(e, t) {
+		this.items = e, this.eventCount = t;
+	}
+	popEvent(t, n) {
+		if (this.eventCount == 0) return null;
+		let r = this.items.length;
+		for (;; r--) if (this.items.get(r - 1).selection) {
+			--r;
+			break;
+		}
+		let i, a;
+		n && (i = this.remapping(r, this.items.length), a = i.maps.length);
+		let o = t.tr, s, c, l = [], u = [];
+		return this.items.forEach((t, n) => {
+			if (!t.step) {
+				i || (i = this.remapping(r, n + 1), a = i.maps.length), a--, u.push(t);
+				return;
+			}
+			if (i) {
+				u.push(new K(t.map));
+				let e = t.step.map(i.slice(a)), n;
+				e && o.maybeStep(e).doc && (n = o.mapping.maps[o.mapping.maps.length - 1], l.push(new K(n, void 0, void 0, l.length + u.length))), a--, n && i.appendMap(n, a);
+			} else o.maybeStep(t.step);
+			if (t.selection) return s = i ? t.selection.map(i.slice(a)) : t.selection, c = new e(this.items.slice(0, r).append(u.reverse().concat(l)), this.eventCount - 1), !1;
+		}, this.items.length, 0), {
+			remaining: c,
+			transform: o,
+			selection: s
+		};
+	}
+	addTransform(t, n, r, i) {
+		let a = [], o = this.eventCount, s = this.items, c = !i && s.length ? s.get(s.length - 1) : null;
+		for (let e = 0; e < t.steps.length; e++) {
+			let r = t.steps[e].invert(t.docs[e]), l = new K(t.mapping.maps[e], r, n), u;
+			(u = c && c.merge(l)) && (l = u, e ? a.pop() : s = s.slice(0, s.length - 1)), a.push(l), n &&= (o++, void 0), i || (c = l);
+		}
+		let l = o - r.depth;
+		return l > Yt && (s = Jt(s, l), o -= l), new e(s.append(a), o);
+	}
+	remapping(e, t) {
+		let n = new l();
+		return this.items.forEach((t, r) => {
+			let i = t.mirrorOffset != null && r - t.mirrorOffset >= e ? n.maps.length - t.mirrorOffset : void 0;
+			n.appendMap(t.map, i);
+		}, e, t), n;
+	}
+	addMaps(t) {
+		return this.eventCount == 0 ? this : new e(this.items.append(t.map((e) => new K(e))), this.eventCount);
+	}
+	rebased(t, n) {
+		if (!this.eventCount) return this;
+		let r = [], i = Math.max(0, this.items.length - n), a = t.mapping, o = t.steps.length, s = this.eventCount;
+		this.items.forEach((e) => {
+			e.selection && s--;
+		}, i);
+		let c = n;
+		this.items.forEach((e) => {
+			let n = a.getMirror(--c);
+			if (n == null) return;
+			o = Math.min(o, n);
+			let i = a.maps[n];
+			if (e.step) {
+				let o = t.steps[n].invert(t.docs[n]), l = e.selection && e.selection.map(a.slice(c + 1, n));
+				l && s++, r.push(new K(i, o, l));
+			} else r.push(new K(i));
+		}, i);
+		let l = [];
+		for (let e = n; e < o; e++) l.push(new K(a.maps[e]));
+		let u = this.items.slice(0, i).append(l).append(r), d = new e(u, s);
+		return d.emptyItemCount() > qt && (d = d.compress(this.items.length - r.length)), d;
+	}
+	emptyItemCount() {
+		let e = 0;
+		return this.items.forEach((t) => {
+			t.step || e++;
+		}), e;
+	}
+	compress(t = this.items.length) {
+		let n = this.remapping(0, t), r = n.maps.length, i = [], a = 0;
+		return this.items.forEach((e, o) => {
+			if (o >= t) i.push(e), e.selection && a++;
+			else if (e.step) {
+				let t = e.step.map(n.slice(r)), o = t && t.getMap();
+				if (r--, o && n.appendMap(o, r), t) {
+					let s = e.selection && e.selection.map(n.slice(r));
+					s && a++;
+					let c = new K(o.invert(), t, s), l, u = i.length - 1;
+					(l = i.length && i[u].merge(c)) ? i[u] = l : i.push(c);
+				}
+			} else e.map && r--;
+		}, this.items.length, 0), new e(W.from(i.reverse()), a);
+	}
+};
+G.empty = new G(W.empty, 0);
+function Jt(e, t) {
+	let n;
+	return e.forEach((e, r) => {
+		if (e.selection && t-- == 0) return n = r, !1;
+	}), e.slice(n);
+}
+var K = class e {
+	constructor(e, t, n, r) {
+		this.map = e, this.step = t, this.selection = n, this.mirrorOffset = r;
+	}
+	merge(t) {
+		if (this.step && t.step && !t.selection) {
+			let n = t.step.merge(this.step);
+			if (n) return new e(n.getMap().invert(), n, this.selection);
+		}
+	}
+}, q = class {
+	constructor(e, t, n, r, i) {
+		this.done = e, this.undone = t, this.prevRanges = n, this.prevTime = r, this.prevComposition = i;
+	}
+}, Yt = 20;
+function Xt(e, t, n, r) {
+	let i = n.getMeta(Z), a;
+	if (i) return i.historyState;
+	n.getMeta(tn) && (e = new q(e.done, e.undone, null, 0, -1));
+	let o = n.getMeta("appendedTransaction");
+	if (n.steps.length == 0) return e;
+	if (o && o.getMeta(Z)) return o.getMeta(Z).redo ? new q(e.done.addTransform(n, void 0, r, X(t)), e.undone, Qt(n.mapping.maps), e.prevTime, e.prevComposition) : new q(e.done, e.undone.addTransform(n, void 0, r, X(t)), null, e.prevTime, e.prevComposition);
+	if (n.getMeta("addToHistory") !== !1 && !(o && o.getMeta("addToHistory") === !1)) {
+		let i = n.getMeta("composition"), a = e.prevTime == 0 || !o && e.prevComposition != i && (e.prevTime < (n.time || 0) - r.newGroupDelay || !Zt(n, e.prevRanges)), s = o ? J(e.prevRanges, n.mapping) : Qt(n.mapping.maps);
+		return new q(e.done.addTransform(n, a ? t.selection.getBookmark() : void 0, r, X(t)), G.empty, s, n.time, i ?? e.prevComposition);
+	} else if (a = n.getMeta("rebased")) return new q(e.done.rebased(n, a), e.undone.rebased(n, a), J(e.prevRanges, n.mapping), e.prevTime, e.prevComposition);
+	else return new q(e.done.addMaps(n.mapping.maps), e.undone.addMaps(n.mapping.maps), J(e.prevRanges, n.mapping), e.prevTime, e.prevComposition);
+}
+function Zt(e, t) {
+	if (!t) return !1;
+	if (!e.docChanged) return !0;
+	let n = !1;
+	return e.mapping.maps[0].forEach((e, r) => {
+		for (let i = 0; i < t.length; i += 2) e <= t[i + 1] && r >= t[i] && (n = !0);
+	}), n;
+}
+function Qt(e) {
+	let t = [];
+	for (let n = e.length - 1; n >= 0 && t.length == 0; n--) e[n].forEach((e, n, r, i) => t.push(r, i));
+	return t;
+}
+function J(e, t) {
+	if (!e) return null;
+	let n = [];
+	for (let r = 0; r < e.length; r += 2) {
+		let i = t.map(e[r], 1), a = t.map(e[r + 1], -1);
+		i <= a && n.push(i, a);
+	}
+	return n;
+}
+function $t(e, t, n) {
+	let r = X(t), i = Z.get(t).spec.config, a = (n ? e.undone : e.done).popEvent(t, r);
+	if (!a) return null;
+	let o = a.selection.resolve(a.transform.doc), s = (n ? e.done : e.undone).addTransform(a.transform, t.selection.getBookmark(), i, r), c = new q(n ? s : a.remaining, n ? a.remaining : s, null, 0, -1);
+	return a.transform.setSelection(o).setMeta(Z, {
+		redo: n,
+		historyState: c
+	});
+}
+var Y = !1, en = null;
+function X(e) {
+	let t = e.plugins;
+	if (en != t) {
+		Y = !1, en = t;
+		for (let e = 0; e < t.length; e++) if (t[e].spec.historyPreserveItems) {
+			Y = !0;
+			break;
+		}
+	}
+	return Y;
+}
+var Z = new c("history"), tn = new c("closeHistory");
+function nn(e = {}) {
+	return e = {
+		depth: e.depth || 100,
+		newGroupDelay: e.newGroupDelay || 500
+	}, new T({
+		key: Z,
+		state: {
+			init() {
+				return new q(G.empty, G.empty, null, 0, -1);
+			},
+			apply(t, n, r) {
+				return Xt(n, r, t, e);
+			}
+		},
+		config: e,
+		props: { handleDOMEvents: { beforeinput(e, t) {
+			let n = t.inputType, r = n == "historyUndo" ? an : n == "historyRedo" ? on : null;
+			return !r || !e.editable ? !1 : (t.preventDefault(), r(e.state, e.dispatch));
+		} } }
+	});
+}
+function rn(e, t) {
+	return (n, r) => {
+		let i = Z.getState(n);
+		if (!i || (e ? i.undone : i.done).eventCount == 0) return !1;
+		if (r) {
+			let a = $t(i, n, e);
+			a && r(t ? a.scrollIntoView() : a);
+		}
+		return !0;
+	};
+}
+var an = rn(!1, !0), on = rn(!0, !0);
+b.create({
+	name: "characterCount",
+	addOptions() {
+		return {
+			limit: null,
+			autoTrim: !0,
+			mode: "textSize",
+			textCounter: (e) => e.length,
+			wordCounter: (e) => e.split(" ").filter((e) => e !== "").length
+		};
+	},
+	addStorage() {
+		return {
+			characters: () => 0,
+			words: () => 0
+		};
+	},
+	onBeforeCreate() {
+		this.storage.characters = (e) => {
+			let t = e?.node || this.editor.state.doc;
+			if ((e?.mode || this.options.mode) === "textSize") {
+				let e = t.textBetween(0, t.content.size, void 0, " ");
+				return this.options.textCounter(e);
+			}
+			return t.nodeSize;
+		}, this.storage.words = (e) => {
+			let t = e?.node || this.editor.state.doc, n = t.textBetween(0, t.content.size, " ", " ");
+			return this.options.wordCounter(n);
+		};
+	},
+	addProseMirrorPlugins() {
+		let e = !1;
+		return [new T({
+			key: new c("characterCount"),
+			appendTransaction: (t, n, r) => {
+				if (e) return;
+				let i = this.options.limit, a = this.options.autoTrim;
+				if (i == null || i === 0 || a === !1) {
+					e = !0;
+					return;
+				}
+				let o = this.storage.characters({ node: r.doc });
+				if (o > i) {
+					let t = o - i;
+					console.warn(`[CharacterCount] Initial content exceeded limit of ${i} characters. Content was automatically trimmed.`);
+					let n = r.tr.deleteRange(0, t);
+					return e = !0, n;
+				}
+				e = !0;
+			},
+			filterTransaction: (e, t) => {
+				let n = this.options.limit;
+				if (!e.docChanged || n === 0 || n == null) return !0;
+				let r = this.storage.characters({ node: t.doc }), i = this.storage.characters({ node: e.doc });
+				if (i <= n || r > n && i > n && i <= r) return !0;
+				if (r > n && i > n && i > r || !e.getMeta("paste")) return !1;
+				let a = e.selection.$head.pos, o = a - (i - n), s = a;
+				return e.deleteRange(o, s), !(this.storage.characters({ node: e.doc }) > n);
+			}
+		})];
+	}
+});
+var sn = b.create({
+	name: "dropCursor",
+	addOptions() {
+		return {
+			color: "currentColor",
+			width: 1,
+			class: void 0
+		};
+	},
+	addProseMirrorPlugins() {
+		return [Pt(this.options)];
+	}
+});
+b.create({
+	name: "focus",
+	addOptions() {
+		return {
+			className: "has-focus",
+			mode: "all"
+		};
+	},
+	addProseMirrorPlugins() {
+		return [new T({
+			key: new c("focus"),
+			props: { decorations: ({ doc: e, selection: t }) => {
+				let { isEditable: n, isFocused: r } = this.editor, { anchor: i } = t, a = [];
+				if (!n || !r) return E.create(e, []);
+				let o = 0;
+				this.options.mode === "deepest" && e.descendants((e, t) => {
+					if (!e.isText) {
+						if (!(i >= t && i <= t + e.nodeSize - 1)) return !1;
+						o += 1;
+					}
+				});
+				let s = 0;
+				return e.descendants((e, t) => {
+					if (e.isText || !(i >= t && i <= t + e.nodeSize - 1)) return !1;
+					if (s += 1, this.options.mode === "deepest" && o - s > 0 || this.options.mode === "shallowest" && s > 1) return this.options.mode === "deepest";
+					a.push(C.node(t, t + e.nodeSize, { class: this.options.className }));
+				}), E.create(e, a);
+			} }
+		})];
+	}
+});
+var cn = b.create({
+	name: "gapCursor",
+	addProseMirrorPlugins() {
+		return [Bt()];
+	},
+	extendNodeSchema(e) {
+		return { allowGapCursor: ae(m(e, "allowGapCursor", {
+			name: e.name,
+			options: e.options,
+			storage: e.storage
+		})) ?? null };
+	}
+}), ln = "placeholder", un = new c("tiptap__placeholder");
+function dn(e) {
+	let { editor: t, placeholder: n, dataAttribute: r, pos: i, node: a, isEmptyDoc: o, hasAnchor: s, classes: { emptyNode: c, emptyEditor: l } } = e, u = [c];
+	return o && u.push(l), C.node(i, i + a.nodeSize, {
+		class: u.join(" "),
+		[r]: typeof n == "function" ? n({
+			editor: t,
+			node: a,
+			pos: i,
+			hasAnchor: s
+		}) : n
+	});
+}
+function fn(e, t) {
+	return typeof e == "function" ? e(t) : e;
+}
+function pn({ editor: e, options: t, dataAttribute: n, doc: r, selection: i, from: o, to: s }) {
+	let { anchor: c } = i, l = [], u = e.isEmpty;
+	return r.nodesBetween(o, s, (r, i) => {
+		let o = c >= i && c <= i + r.nodeSize, s = !r.isLeaf && a(r);
+		return r.type.isTextblock && (o || !t.showOnlyCurrent) && s && l.push(dn({
+			editor: e,
+			isEmptyDoc: u,
+			dataAttribute: n,
+			hasAnchor: o,
+			placeholder: t.placeholder,
+			classes: {
+				emptyEditor: t.emptyEditorClass,
+				emptyNode: fn(t.emptyNodeClass, {
+					editor: e,
+					node: r,
+					pos: i,
+					hasAnchor: o
+				})
+			},
+			node: r,
+			pos: i
+		})), t.includeChildren;
+	}), l;
+}
+function mn({ editor: e, options: t, dataAttribute: n, doc: r, selection: i }) {
+	if (!(e.isEditable || !t.showOnlyWhenEditable)) return null;
+	let { anchor: o } = i, s = [], c = e.isEmpty;
+	if (t.showOnlyCurrent && !t.includeChildren) {
+		let i = r.resolve(o), l = i.depth > 0 ? i.node(1) : i.nodeAfter, u = i.depth > 0 ? i.before(1) : o;
+		if (l && l.type.isTextblock && a(l)) {
+			let r = o >= u && o <= u + l.nodeSize;
+			s.push(dn({
+				editor: e,
+				isEmptyDoc: c,
+				dataAttribute: n,
+				hasAnchor: r,
+				placeholder: t.placeholder,
+				classes: {
+					emptyEditor: t.emptyEditorClass,
+					emptyNode: fn(t.emptyNodeClass, {
+						editor: e,
+						node: l,
+						pos: u,
+						hasAnchor: r
+					})
+				},
+				node: l,
+				pos: u
+			}));
+		}
+	} else s.push(...pn({
+		editor: e,
+		options: t,
+		dataAttribute: n,
+		doc: r,
+		selection: i,
+		from: 0,
+		to: r.content.size
+	}));
+	return E.create(r, s);
+}
+function Q(e, t) {
+	let n = e.resolve(t);
+	if (n.depth === 0) {
+		let e = n.nodeAfter ?? n.nodeBefore;
+		if (!e) return {
+			from: t,
+			to: t
+		};
+		let r = n.nodeAfter ? t : t - e.nodeSize;
+		return {
+			from: r,
+			to: r + e.nodeSize
+		};
+	}
+	let r = n.before(1);
+	return {
+		from: r,
+		to: r + n.node(1).nodeSize
+	};
+}
+function $(e, t) {
+	return {
+		from: Math.max(0, t.from - 1),
+		to: Math.min(e.content.size, t.to - 1)
+	};
+}
+function hn(e, t, n) {
+	let r = [];
+	return e.forEach((e, i) => {
+		let a = i, o = a + e.nodeSize, s = a + 1, c = o + 1;
+		s < n && c > t && r.push({
+			from: a,
+			to: o
+		});
+	}), r;
+}
+function gn(e) {
+	if (e.length === 0) return [];
+	let t = [...e].sort((e, t) => e.from - t.from), n = [{ ...t[0] }];
+	for (let e = 1; e < t.length; e += 1) {
+		let r = n[n.length - 1], i = t[e];
+		i.from <= r.to ? r.to = Math.max(r.to, i.to) : n.push({ ...i });
+	}
+	return n;
+}
+function _n(e, t) {
+	let n = hn(e, t.from, t.to);
+	return n.push($(e, Q(e, t.from))), t.to > t.from ? n.push($(e, Q(e, Math.min(t.to, e.content.size + 1) - 1))) : t.from < e.content.size + 1 && n.push($(e, Q(e, Math.min(t.from + 1, e.content.size)))), n;
+}
+function vn(e, t, n) {
+	let r = [];
+	if (e.docChanged) {
+		let t = p(e);
+		for (let e of t) r.push(..._n(n.doc, e.newRange));
+	}
+	return e.selectionSet && (r.push($(n.doc, Q(n.doc, e.mapping.map(t.selection.anchor)))), r.push($(n.doc, Q(n.doc, n.selection.anchor)))), gn(r);
+}
+function yn(e, t, n) {
+	let r = Math.max(0, Math.min(e, n.content.size));
+	return {
+		from: r,
+		to: Math.max(r, Math.min(t, n.content.size))
+	};
+}
+function bn({ decorations: e, ranges: t, editor: n, options: r, dataAttribute: i, doc: a, selection: o }) {
+	let s = e;
+	for (let e of t) {
+		let { from: t, to: c } = yn(e.from, e.to, a), l = s.find(t, c).filter((e) => e.from >= t && e.to <= c);
+		l.length && (s = s.remove(l));
+		let u = pn({
+			editor: n,
+			options: r,
+			dataAttribute: i,
+			doc: a,
+			selection: o,
+			from: t,
+			to: c
+		});
+		u.length && (s = s.add(a, u));
+	}
+	return s;
+}
+function xn({ editor: e, options: t, dataAttribute: n }) {
+	return {
+		init(r, i) {
+			return mn({
+				editor: e,
+				options: t,
+				dataAttribute: n,
+				doc: i.doc,
+				selection: i.selection
+			}) ?? E.empty;
+		},
+		apply(r, i, a, o) {
+			return !r.docChanged && !r.selectionSet ? i : bn({
+				decorations: i.map(r.mapping, r.doc),
+				ranges: vn(r, a, o),
+				editor: e,
+				options: t,
+				dataAttribute: n,
+				doc: o.doc,
+				selection: o.selection
+			});
+		}
+	};
+}
+function Sn(e) {
+	return e.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/^[0-9-]+/, "").replace(/^-+/, "").toLowerCase();
+}
+function Cn({ editor: e, options: t }) {
+	let n = t.dataAttribute ? `data-${Sn(t.dataAttribute)}` : `data-${ln}`, r = t.showOnlyCurrent && !t.includeChildren;
+	return new T({
+		key: un,
+		...r ? {} : { state: xn({
+			editor: e,
+			options: t,
+			dataAttribute: n
+		}) },
+		props: { decorations: r ? ({ doc: r, selection: i }) => mn({
+			editor: e,
+			options: t,
+			dataAttribute: n,
+			doc: r,
+			selection: i
+		}) : (n) => t.showOnlyWhenEditable && !e.isEditable ? E.empty : un.getState(n) ?? E.empty }
+	});
+}
+b.create({
+	name: "placeholder",
+	addOptions() {
+		return {
+			emptyEditorClass: "is-editor-empty",
+			emptyNodeClass: "is-empty",
+			dataAttribute: ln,
+			placeholder: "Write something …",
+			showOnlyWhenEditable: !0,
+			showOnlyCurrent: !0,
+			includeChildren: !1
+		};
+	},
+	addProseMirrorPlugins() {
+		return [Cn({
+			editor: this.editor,
+			options: this.options
+		})];
+	}
+});
+function wn(e, t) {
+	return !e.selection.empty && !s(e.selection) && t.isEditable;
+}
+function Tn(e, t) {
+	return wn(e, t) && !t.isFocused && !t.view.dragging;
+}
+function En() {
+	var e;
+	(e = window.getSelection()) == null || e.removeAllRanges();
+}
+function Dn(e) {
+	e.focus();
+}
+b.create({
+	name: "selection",
+	addOptions() {
+		return { className: "selection" };
+	},
+	addProseMirrorPlugins() {
+		let { editor: e, options: t } = this;
+		return [new T({
+			key: new c("selection"),
+			props: {
+				decorations(n) {
+					return Tn(n, e) ? E.create(n.doc, [C.inline(n.selection.from, n.selection.to, { class: t.className })]) : null;
+				},
+				handleDOMEvents: {
+					blur(t) {
+						return wn(t.state, e) && En(), !1;
+					},
+					focus(t) {
+						return wn(t.state, e) && requestAnimationFrame(() => {
+							!e.isDestroyed && t.hasFocus() && Dn(t);
+						}), !1;
+					}
+				}
+			}
+		})];
+	}
+});
+function On({ types: e, node: t }) {
+	return t && Array.isArray(e) && e.includes(t.type) || t?.type === e;
+}
+var kn = b.create({
+	name: "trailingNode",
+	addOptions() {
+		return {
+			node: void 0,
+			notAfter: []
+		};
+	},
+	addProseMirrorPlugins() {
+		let e = new c(this.name), t = this.options.node || this.editor.schema.topNodeType.contentMatch.defaultType?.name || "paragraph", n = Object.entries(this.editor.schema.nodes).map(([, e]) => e).filter((e) => (this.options.notAfter || []).concat(t).includes(e.name));
+		return [new T({
+			key: e,
+			appendTransaction: (n, r, i) => {
+				let { doc: a, tr: o, schema: s } = i, c = e.getState(i), l = a.content.size, u = s.nodes[t];
+				if (!n.some((e) => e.getMeta("skipTrailingNode")) && c) return o.insert(l, u.create());
+			},
+			state: {
+				init: (e, t) => {
+					let r = t.tr.doc.lastChild;
+					return !On({
+						node: r,
+						types: n
+					});
+				},
+				apply: (e, t) => {
+					if (!e.docChanged || e.getMeta("__uniqueIDTransaction")) return t;
+					let r = e.doc.lastChild;
+					return !On({
+						node: r,
+						types: n
+					});
+				}
+			}
+		})];
+	}
+}), An = b.create({
+	name: "undoRedo",
+	addOptions() {
+		return {
+			depth: 100,
+			newGroupDelay: 500
+		};
+	},
+	addCommands() {
+		return {
+			undo: () => ({ state: e, dispatch: t }) => an(e, t),
+			redo: () => ({ state: e, dispatch: t }) => on(e, t)
+		};
+	},
+	addProseMirrorPlugins() {
+		return [nn(this.options)];
+	},
+	addKeyboardShortcuts() {
+		return {
+			"Mod-z": () => this.editor.commands.undo(),
+			"Shift-Mod-z": () => this.editor.commands.redo(),
+			"Mod-y": () => this.editor.commands.redo(),
+			"Mod-я": () => this.editor.commands.undo(),
+			"Shift-Mod-я": () => this.editor.commands.redo()
+		};
+	}
+}), jn = b.create({
+	name: "starterKit",
+	addExtensions() {
+		let e = [];
+		return this.options.bold !== !1 && e.push(_e.configure(this.options.bold)), this.options.blockquote !== !1 && e.push(fe.configure(this.options.blockquote)), this.options.bulletList !== !1 && e.push(Re.configure(this.options.bulletList)), this.options.code !== !1 && e.push(be.configure(this.options.code)), this.options.codeBlock !== !1 && e.push(Ce.configure(this.options.codeBlock)), this.options.document !== !1 && e.push(we.configure(this.options.document)), this.options.dropcursor !== !1 && e.push(sn.configure(this.options.dropcursor)), this.options.gapcursor !== !1 && e.push(cn.configure(this.options.gapcursor)), this.options.hardBreak !== !1 && e.push(Te.configure(this.options.hardBreak)), this.options.heading !== !1 && e.push(Ee.configure(this.options.heading)), this.options.undoRedo !== !1 && e.push(An.configure(this.options.undoRedo)), this.options.horizontalRule !== !1 && e.push(De.configure(this.options.horizontalRule)), this.options.italic !== !1 && e.push(Me.configure(this.options.italic)), this.options.listItem !== !1 && e.push(tt.configure(this.options.listItem)), this.options.listKeymap !== !1 && e.push(ut.configure(this.options?.listKeymap)), this.options.link !== !1 && e.push(ce.configure(this.options?.link)), this.options.orderedList !== !1 && e.push(Tt.configure(this.options.orderedList)), this.options.paragraph !== !1 && e.push(kt.configure(this.options.paragraph)), this.options.strike !== !1 && e.push(Mt.configure(this.options.strike)), this.options.text !== !1 && e.push(Nt.configure(this.options.text)), this.options.underline !== !1 && e.push(le.configure(this.options?.underline)), this.options.trailingNode !== !1 && e.push(kn.configure(this.options?.trailingNode)), e;
+	}
+}), Mn = jn;
+//#endregion
+export { jn as StarterKit, Mn as default };