miyuan-editor 0.0.3

package/dist/extensions/index.cjs.js

@@ -0,0 +1,3462 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../prompt-CGLw2O21.cjs");
+const require_dist = require("../dist-CRSJDo2G.cjs");
+const require_dist$1 = require("../dist-CMM6n8DO.cjs");
+const require_dist$2 = require("../dist-rItBfhNb.cjs");
+const require_toc_extension = require("../toc-extension-SRvSuskn.cjs");
+//#region src/extensions/doc-extension.ts
+/**
+* DocExtension: the root document node.
+*/
+function DocExtension() {
+	return {
+		name: "doc",
+		type: "extension",
+		addNodes() {
+			return { doc: { content: "block+" } };
+		}
+	};
+}
+//#endregion
+//#region src/extensions/text-paragraph-extension.ts
+var MAX_INDENT = 7;
+var INDENT_STEP = 2;
+/**
+* TextExtension: the inline text leaf node.
+*/
+function TextExtension() {
+	return {
+		name: "text",
+		type: "extension",
+		addNodes() {
+			return { text: { group: "inline" } };
+		}
+	};
+}
+/** Helper: compute inline style from attrs (textAlign + indent + lineHeight) */
+function blockStyle(attrs) {
+	const parts = [];
+	const align = attrs.textAlign;
+	if (align && align !== "left") parts.push(`text-align: ${align}`);
+	const indent = attrs.indent || 0;
+	if (indent > 0) parts.push(`margin-left: ${indent * INDENT_STEP}em`);
+	const lineHeight = attrs.lineHeight;
+	if (lineHeight) parts.push(`line-height: ${lineHeight}`);
+	return parts.length ? parts.join("; ") : void 0;
+}
+/** Helper: parse text-align from DOM element */
+function parseAlign(dom) {
+	const match = (dom.getAttribute("style") || "").match(/text-align:\s*(left|center|right)/);
+	if (match) return match[1];
+	return null;
+}
+/** Helper: parse indent level from DOM element */
+function parseIndent(dom) {
+	const match = (dom.getAttribute("style") || "").match(/margin-left:\s*([\d.]+)em/);
+	if (!match) return 0;
+	const em = parseFloat(match[1]);
+	return Math.round(em / INDENT_STEP);
+}
+/** Helper: parse line-height from DOM element */
+function parseLineHeight(dom) {
+	const match = (dom.getAttribute("style") || "").match(/line-height:\s*([\d.]+)/);
+	if (!match) return null;
+	return parseFloat(match[1]);
+}
+/**
+* ParagraphExtension: the basic block node for text content.
+* Supports textAlign attribute.
+*/
+function ParagraphExtension() {
+	return {
+		name: "paragraph",
+		type: "node",
+		addNodes() {
+			return { paragraph: {
+				group: "block",
+				content: "inline*",
+				attrs: {
+					textAlign: { default: null },
+					indent: { default: 0 },
+					lineHeight: { default: null }
+				},
+				toDOM(node) {
+					const style = blockStyle(node.attrs);
+					return style ? [
+						"p",
+						{ style },
+						0
+					] : ["p", 0];
+				},
+				parseDOM: [{
+					tag: "p",
+					getAttrs(dom) {
+						const el = dom;
+						return {
+							textAlign: parseAlign(el),
+							indent: parseIndent(el),
+							lineHeight: parseLineHeight(el)
+						};
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return {
+				setTextAlign: (...args) => {
+					const align = args[0];
+					return setTextAlignCommand(align, ["paragraph", "heading"]);
+				},
+				indent: () => indentCommand(1, ["paragraph", "heading"]),
+				outdent: () => indentCommand(-1, ["paragraph", "heading"])
+			};
+		},
+		addKeyboardShortcuts() {
+			return {
+				Tab: indentCommand(1, ["paragraph", "heading"]),
+				"Shift-Tab": indentCommand(-1, ["paragraph", "heading"])
+			};
+		}
+	};
+}
+/**
+* Create a command that sets textAlign on the given block types.
+*/
+function setTextAlignCommand(align, nodeNames) {
+	return (state, dispatch) => {
+		const { from, to } = state.selection;
+		let applicable = false;
+		state.doc.nodesBetween(from, to, (node, pos) => {
+			if (!nodeNames.includes(node.type.name)) return;
+			applicable = true;
+			if (dispatch) {
+				const tr = state.tr;
+				const newAlign = node.attrs.textAlign === align ? null : align;
+				tr.setNodeMarkup(pos, null, {
+					...node.attrs,
+					textAlign: newAlign
+				});
+				dispatch(tr);
+			}
+		});
+		return applicable;
+	};
+}
+/**
+* Create a command that changes indent level by delta (+1 or -1).
+*/
+function indentCommand(delta, nodeNames) {
+	return (state, dispatch) => {
+		const { from, to } = state.selection;
+		let applicable = false;
+		state.doc.nodesBetween(from, to, (node, pos) => {
+			if (!nodeNames.includes(node.type.name)) return;
+			const current = node.attrs.indent || 0;
+			const next = Math.max(0, Math.min(MAX_INDENT, current + delta));
+			if (next === current) return;
+			applicable = true;
+			if (dispatch) {
+				const tr = state.tr;
+				tr.setNodeMarkup(pos, null, {
+					...node.attrs,
+					indent: next
+				});
+				dispatch(tr);
+			}
+		});
+		return applicable;
+	};
+}
+//#endregion
+//#region src/extensions/mark-extensions.ts
+function BoldExtension() {
+	return {
+		name: "bold",
+		type: "mark",
+		addMarks() {
+			return { bold: {
+				toDOM() {
+					return ["strong", 0];
+				},
+				parseDOM: [{ tag: "strong" }, {
+					tag: "b",
+					getAttrs: (node) => node.style.fontWeight !== "normal" && null
+				}]
+			} };
+		},
+		addCommands() {
+			return { bold: () => (state, dispatch) => {
+				const mt = state.schema.marks["bold"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-b": (state, dispatch) => {
+				const mt = state.schema.marks["bold"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		}
+	};
+}
+function ItalicExtension() {
+	return {
+		name: "italic",
+		type: "mark",
+		addMarks() {
+			return { italic: {
+				toDOM() {
+					return ["em", 0];
+				},
+				parseDOM: [{ tag: "em" }, { tag: "i" }]
+			} };
+		},
+		addCommands() {
+			return { italic: () => (state, dispatch) => {
+				const mt = state.schema.marks["italic"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-i": (state, dispatch) => {
+				const mt = state.schema.marks["italic"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		}
+	};
+}
+function CodeExtension() {
+	return {
+		name: "code",
+		type: "mark",
+		addMarks() {
+			return { code: {
+				excludes: "_",
+				toDOM() {
+					return ["code", 0];
+				},
+				parseDOM: [{ tag: "code" }]
+			} };
+		},
+		addCommands() {
+			return { code: () => (state, dispatch) => {
+				const mt = state.schema.marks["code"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-e": (state, dispatch) => {
+				const mt = state.schema.marks["code"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		}
+	};
+}
+function StrikeExtension() {
+	return {
+		name: "strike",
+		type: "mark",
+		addMarks() {
+			return { strike: {
+				toDOM() {
+					return ["s", 0];
+				},
+				parseDOM: [
+					{ tag: "s" },
+					{ tag: "del" },
+					{ tag: "strike" }
+				]
+			} };
+		},
+		addCommands() {
+			return { strike: () => (state, dispatch) => {
+				const mt = state.schema.marks["strike"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		}
+	};
+}
+function UnderlineExtension() {
+	return {
+		name: "underline",
+		type: "mark",
+		addMarks() {
+			return { underline: {
+				toDOM() {
+					return ["u", 0];
+				},
+				parseDOM: [{ tag: "u" }]
+			} };
+		},
+		addCommands() {
+			return { underline: () => (state, dispatch) => {
+				const mt = state.schema.marks["underline"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-u": (state, dispatch) => {
+				const mt = state.schema.marks["underline"];
+				if (!mt) return false;
+				return require_dist.toggleMark(mt)(state, dispatch);
+			} };
+		}
+	};
+}
+function LinkExtension() {
+	return {
+		name: "link",
+		type: "mark",
+		addMarks() {
+			return { link: {
+				attrs: {
+					href: {},
+					target: { default: "_blank" }
+				},
+				inclusive: false,
+				toDOM(mark) {
+					const { href, target } = mark.attrs;
+					return [
+						"a",
+						{
+							href,
+							target
+						},
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "a[href]",
+					getAttrs(dom) {
+						const el = dom;
+						return {
+							href: el.getAttribute("href"),
+							target: el.getAttribute("target")
+						};
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { setLink: (...args) => {
+				const attrs = args[0] ?? {};
+				return (state, dispatch) => {
+					const mt = state.schema.marks["link"];
+					if (!mt) return false;
+					return require_dist.toggleMark(mt, attrs)(state, dispatch);
+				};
+			} };
+		}
+	};
+}
+var DEFAULT_COLORS = [
+	"#000000",
+	"#434343",
+	"#666666",
+	"#999999",
+	"#b7b7b7",
+	"#cccccc",
+	"#d9d9d9",
+	"#ffffff",
+	"#980000",
+	"#ff0000",
+	"#ff9900",
+	"#ffff00",
+	"#00ff00",
+	"#00ffff",
+	"#4a86e8",
+	"#0000ff",
+	"#9900ff",
+	"#ff00ff",
+	"#f4cccc",
+	"#fce5cd",
+	"#fff2cc",
+	"#d9ead3",
+	"#d0e0e3",
+	"#c9daf8",
+	"#e4d7f5",
+	"#ea9999",
+	"#f9cb9c",
+	"#ffe599",
+	"#b6d7a8",
+	"#a2c4c9",
+	"#a4c2f4",
+	"#d5a6bd"
+];
+function TextColorExtension(config) {
+	return {
+		name: "textColor",
+		type: "mark",
+		options: { colors: config?.colors ?? DEFAULT_COLORS },
+		addMarks() {
+			return { textColor: {
+				attrs: { color: {} },
+				toDOM(mark) {
+					return [
+						"span",
+						{ style: `color: ${mark.attrs.color}` },
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "span[style*=\"color\"]",
+					getAttrs(dom) {
+						const color = dom.style.color;
+						return color ? { color } : false;
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { setTextColor: (...args) => {
+				const color = args[0];
+				return (state, dispatch) => {
+					const mt = state.schema.marks["textColor"];
+					if (!mt) return false;
+					const { from, to } = state.selection;
+					if (from === to) return false;
+					if (dispatch) {
+						let tr = state.tr;
+						tr = tr.removeMark(from, to, mt);
+						if (color) tr = tr.addMark(from, to, mt.create({ color }));
+						dispatch(tr);
+					}
+					return true;
+				};
+			} };
+		}
+	};
+}
+function BackgroundColorExtension(config) {
+	return {
+		name: "backgroundColor",
+		type: "mark",
+		options: { colors: config?.colors ?? DEFAULT_COLORS },
+		addMarks() {
+			return { backgroundColor: {
+				attrs: { color: {} },
+				toDOM(mark) {
+					return [
+						"span",
+						{ style: `background-color: ${mark.attrs.color}` },
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "span[style*=\"background-color\"]",
+					getAttrs(dom) {
+						const color = dom.style.backgroundColor;
+						return color ? { color } : false;
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { setBackgroundColor: (...args) => {
+				const color = args[0];
+				return (state, dispatch) => {
+					const mt = state.schema.marks["backgroundColor"];
+					if (!mt) return false;
+					const { from, to } = state.selection;
+					if (from === to) return false;
+					if (dispatch) {
+						let tr = state.tr;
+						tr = tr.removeMark(from, to, mt);
+						if (color) tr = tr.addMark(from, to, mt.create({ color }));
+						dispatch(tr);
+					}
+					return true;
+				};
+			} };
+		}
+	};
+}
+var DEFAULT_FONT_SIZES = [
+	{
+		label: "12",
+		value: "12px"
+	},
+	{
+		label: "14",
+		value: "14px"
+	},
+	{
+		label: "16",
+		value: "16px"
+	},
+	{
+		label: "18",
+		value: "18px"
+	},
+	{
+		label: "20",
+		value: "20px"
+	},
+	{
+		label: "24",
+		value: "24px"
+	},
+	{
+		label: "28",
+		value: "28px"
+	},
+	{
+		label: "32",
+		value: "32px"
+	},
+	{
+		label: "36",
+		value: "36px"
+	},
+	{
+		label: "48",
+		value: "48px"
+	}
+];
+function normalizeFontSize(value) {
+	const num = typeof value === "string" ? parseFloat(value) : value;
+	if (isNaN(num) || num <= 0) return "";
+	return `${Math.round(num)}px`;
+}
+function FontSizeExtension(config) {
+	return {
+		name: "fontSize",
+		type: "mark",
+		options: { sizes: config?.sizes ?? DEFAULT_FONT_SIZES },
+		addMarks() {
+			return { fontSize: {
+				attrs: { size: {} },
+				toDOM(mark) {
+					return [
+						"span",
+						{ style: `font-size: ${normalizeFontSize(mark.attrs.size)}` },
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "span[style*=\"font-size\"]",
+					getAttrs(dom) {
+						const raw = dom.style.fontSize;
+						const size = normalizeFontSize(raw);
+						return size ? { size } : false;
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { setFontSize: (...args) => {
+				const size = normalizeFontSize(args[0]);
+				return (state, dispatch) => {
+					const mt = state.schema.marks["fontSize"];
+					if (!mt) return false;
+					const { from, to } = state.selection;
+					if (from === to) return false;
+					if (dispatch) {
+						let tr = state.tr;
+						tr = tr.removeMark(from, to, mt);
+						if (size) tr = tr.addMark(from, to, mt.create({ size }));
+						dispatch(tr);
+					}
+					return true;
+				};
+			} };
+		}
+	};
+}
+var DEFAULT_FONT_FAMILIES = [
+	{
+		label: "默认",
+		value: ""
+	},
+	{
+		label: "宋体",
+		value: "SimSun, serif"
+	},
+	{
+		label: "黑体",
+		value: "SimHei, sans-serif"
+	},
+	{
+		label: "微软雅黑",
+		value: "Microsoft YaHei, sans-serif"
+	},
+	{
+		label: "楷体",
+		value: "KaiTi, serif"
+	},
+	{
+		label: "Arial",
+		value: "Arial, sans-serif"
+	},
+	{
+		label: "Times New Roman",
+		value: "Times New Roman, serif"
+	},
+	{
+		label: "Courier New",
+		value: "Courier New, monospace"
+	},
+	{
+		label: "Georgia",
+		value: "Georgia, serif"
+	},
+	{
+		label: "Verdana",
+		value: "Verdana, sans-serif"
+	}
+];
+function FontFamilyExtension(config) {
+	return {
+		name: "fontFamily",
+		type: "mark",
+		options: { families: config?.families ?? DEFAULT_FONT_FAMILIES },
+		addMarks() {
+			return { fontFamily: {
+				attrs: { family: {} },
+				toDOM(mark) {
+					return [
+						"span",
+						{ style: `font-family: ${mark.attrs.family}` },
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "span[style*=\"font-family\"]",
+					getAttrs(dom) {
+						const family = dom.style.fontFamily;
+						return family ? { family } : false;
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { setFontFamily: (...args) => {
+				const family = args[0];
+				return (state, dispatch) => {
+					const mt = state.schema.marks["fontFamily"];
+					if (!mt) return false;
+					const { from, to } = state.selection;
+					if (from === to) return false;
+					if (dispatch) {
+						let tr = state.tr;
+						tr = tr.removeMark(from, to, mt);
+						if (family) tr = tr.addMark(from, to, mt.create({ family }));
+						dispatch(tr);
+					}
+					return true;
+				};
+			} };
+		},
+		addKeyboardShortcuts() {
+			return {};
+		},
+		addPlugins() {
+			return [];
+		}
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/prosemirror-inputrules@1.5.1/node_modules/prosemirror-inputrules/dist/index.js
+/**
+Input rules are regular expressions describing a piece of text
+that, when typed, causes something to happen. This might be
+changing two dashes into an emdash, wrapping a paragraph starting
+with `"> "` into a blockquote, or something entirely different.
+*/
+var InputRule = class {
+	/**
+	Create an input rule. The rule applies when the user typed
+	something and the text directly in front of the cursor matches
+	`match`, which should end with `$`.
+	
+	The `handler` can be a string, in which case the matched text, or
+	the first matched group in the regexp, is replaced by that
+	string.
+	
+	Or a it can be a function, which will be called with the match
+	array produced by
+	[`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+	as well as the start and end of the matched range, and which can
+	return a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) that describes the
+	rule's effect, or null to indicate the input was not handled.
+	*/
+	constructor(match, handler, options = {}) {
+		this.match = match;
+		this.match = match;
+		this.handler = typeof handler == "string" ? stringHandler(handler) : handler;
+		this.undoable = options.undoable !== false;
+		this.inCode = options.inCode || false;
+		this.inCodeMark = options.inCodeMark !== false;
+	}
+};
+function stringHandler(string) {
+	return function(state, match, start, end) {
+		let insert = string;
+		if (match[1]) {
+			let offset = match[0].lastIndexOf(match[1]);
+			insert += match[0].slice(offset + match[1].length);
+			start += offset;
+			let cutOff = start - end;
+			if (cutOff > 0) {
+				insert = match[0].slice(offset - cutOff, offset) + insert;
+				start = end;
+			}
+		}
+		return state.tr.insertText(insert, start, end);
+	};
+}
+var MAX_MATCH = 500;
+/**
+Create an input rules plugin. When enabled, it will cause text
+input that matches any of the given rules to trigger the rule's
+action.
+*/
+function inputRules({ rules }) {
+	let plugin = new require_dist.Plugin({
+		state: {
+			init() {
+				return null;
+			},
+			apply(tr, prev) {
+				let stored = tr.getMeta(this);
+				if (stored) return stored;
+				return tr.selectionSet || tr.docChanged ? null : prev;
+			}
+		},
+		props: {
+			handleTextInput(view, from, to, text) {
+				return run(view, from, to, text, rules, plugin);
+			},
+			handleDOMEvents: { compositionend: (view) => {
+				setTimeout(() => {
+					let { $cursor } = view.state.selection;
+					if ($cursor) run(view, $cursor.pos, $cursor.pos, "", rules, plugin);
+				});
+			} }
+		},
+		isInputRules: true
+	});
+	return plugin;
+}
+function run(view, from, to, text, rules, plugin) {
+	if (view.composing) return false;
+	let state = view.state, $from = state.doc.resolve(from);
+	let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, "") + text;
+	for (let i = 0; i < rules.length; i++) {
+		let rule = rules[i];
+		if (!rule.inCodeMark && $from.marks().some((m) => m.type.spec.code)) continue;
+		if ($from.parent.type.spec.code) {
+			if (!rule.inCode) continue;
+		} else if (rule.inCode === "only") continue;
+		let match = rule.match.exec(textBefore);
+		if (!match || match[0].length < text.length) continue;
+		let startPos = from - (match[0].length - text.length);
+		if (!rule.inCodeMark) {
+			let hasMark = false;
+			state.doc.nodesBetween(startPos, $from.pos, (node) => {
+				if (node.isInline && node.marks.some((m) => m.type.spec.code)) hasMark = true;
+			});
+			if (hasMark) continue;
+		}
+		let tr = rule.handler(state, match, startPos, to);
+		if (!tr) continue;
+		if (rule.undoable) tr.setMeta(plugin, {
+			transform: tr,
+			from,
+			to,
+			text
+		});
+		view.dispatch(tr);
+		return true;
+	}
+	return false;
+}
+new InputRule(/--$/, "—", { inCodeMark: false });
+new InputRule(/\.\.\.$/, "…", { inCodeMark: false });
+new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, "“", { inCodeMark: false });
+new InputRule(/"$/, "”", { inCodeMark: false });
+new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, "‘", { inCodeMark: false });
+new InputRule(/'$/, "’", { inCodeMark: false });
+//#endregion
+//#region src/extensions/node-extensions.ts
+/** Parse text-align from DOM element style attribute */
+function parseAlignFromDOM(dom) {
+	const match = (dom.getAttribute("style") || "").match(/text-align:\s*(left|center|right)/);
+	return match ? match[1] : null;
+}
+/** Parse indent level from DOM element (margin-left in em) */
+function parseIndentFromDOM(dom) {
+	const match = (dom.getAttribute("style") || "").match(/margin-left:\s*([\d.]+)em/);
+	if (!match) return 0;
+	return Math.round(parseFloat(match[1]) / 2);
+}
+/** Build inline style string from align + indent + lineHeight attrs */
+function buildBlockStyle(attrs) {
+	const parts = [];
+	const align = attrs.textAlign;
+	if (align && align !== "left") parts.push(`text-align: ${align}`);
+	const indent = attrs.indent || 0;
+	if (indent > 0) parts.push(`margin-left: ${indent * 2}em`);
+	const lineHeight = attrs.lineHeight;
+	if (lineHeight) parts.push(`line-height: ${lineHeight}`);
+	return parts.length ? parts.join("; ") : void 0;
+}
+/** Helper: parse line-height from DOM element */
+function parseLineHeightFromDOM(dom) {
+	const match = (dom.getAttribute("style") || "").match(/line-height:\s*([\d.]+)/);
+	if (!match) return null;
+	return parseFloat(match[1]);
+}
+function HeadingExtension() {
+	return {
+		name: "heading",
+		type: "node",
+		addNodes() {
+			return { heading: {
+				group: "block",
+				content: "inline*",
+				attrs: {
+					level: { default: 1 },
+					textAlign: { default: null },
+					indent: { default: 0 },
+					lineHeight: { default: null }
+				},
+				defining: true,
+				toDOM(node) {
+					const style = buildBlockStyle(node.attrs);
+					const tag = `h${node.attrs.level}`;
+					return style ? [
+						tag,
+						{ style },
+						0
+					] : [tag, 0];
+				},
+				parseDOM: [
+					{
+						tag: "h1",
+						getAttrs: (dom) => ({
+							level: 1,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					},
+					{
+						tag: "h2",
+						getAttrs: (dom) => ({
+							level: 2,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					},
+					{
+						tag: "h3",
+						getAttrs: (dom) => ({
+							level: 3,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					},
+					{
+						tag: "h4",
+						getAttrs: (dom) => ({
+							level: 4,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					},
+					{
+						tag: "h5",
+						getAttrs: (dom) => ({
+							level: 5,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					},
+					{
+						tag: "h6",
+						getAttrs: (dom) => ({
+							level: 6,
+							textAlign: parseAlignFromDOM(dom),
+							indent: parseIndentFromDOM(dom),
+							lineHeight: parseLineHeightFromDOM(dom)
+						})
+					}
+				]
+			} };
+		},
+		addCommands() {
+			return { heading: (...args) => {
+				const level = args[0] ?? 1;
+				return (state, dispatch) => {
+					const headingType = state.schema.nodes["heading"];
+					const paraType = state.schema.nodes["paragraph"];
+					if (!headingType || !paraType) return false;
+					const { $from } = state.selection;
+					const parent = $from.parent;
+					if (parent.type === headingType && parent.attrs.level === level) return require_dist.setBlockType(paraType)(state, dispatch);
+					return require_dist.setBlockType(headingType, { level })(state, dispatch);
+				};
+			} };
+		},
+		addKeyboardShortcuts() {
+			const shortcuts = {};
+			for (let i = 1; i <= 6; i++) {
+				const level = i;
+				shortcuts[`Mod-Alt-${i}`] = (state, dispatch) => {
+					const headingType = state.schema.nodes["heading"];
+					const paraType = state.schema.nodes["paragraph"];
+					if (!headingType || !paraType) return false;
+					const { $from } = state.selection;
+					const parent = $from.parent;
+					if (parent.type === headingType && parent.attrs.level === level) return require_dist.setBlockType(paraType)(state, dispatch);
+					return require_dist.setBlockType(headingType, { level })(state, dispatch);
+				};
+			}
+			return shortcuts;
+		},
+		addPlugins() {
+			return [inputRules({ rules: [new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
+				const level = match[1].length;
+				const nt = state.schema.nodes["heading"];
+				if (!nt) return null;
+				const tr = state.tr;
+				tr.delete(start, end);
+				const range = tr.doc.resolve(start).blockRange();
+				if (!range) return null;
+				tr.setBlockType(range.start, range.end, nt, { level });
+				return tr;
+			})] })];
+		}
+	};
+}
+function BlockquoteExtension() {
+	return {
+		name: "blockquote",
+		type: "node",
+		addNodes() {
+			return { blockquote: {
+				group: "block",
+				content: "block+",
+				defining: true,
+				toDOM() {
+					return ["blockquote", 0];
+				},
+				parseDOM: [{ tag: "blockquote" }]
+			} };
+		},
+		addCommands() {
+			return { blockquote: () => (state, dispatch) => {
+				const nt = state.schema.nodes["blockquote"];
+				if (!nt) return false;
+				return require_dist.wrapIn(nt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-Shift-b": (state, dispatch) => {
+				const nt = state.schema.nodes["blockquote"];
+				if (!nt) return false;
+				return require_dist.wrapIn(nt)(state, dispatch);
+			} };
+		}
+	};
+}
+function BulletListExtension() {
+	return {
+		name: "bullet_list",
+		type: "node",
+		addNodes() {
+			return {
+				bullet_list: {
+					group: "block",
+					content: "list_item+",
+					toDOM() {
+						return ["ul", 0];
+					},
+					parseDOM: [{ tag: "ul" }]
+				},
+				list_item: {
+					content: "paragraph block*",
+					toDOM() {
+						return ["li", 0];
+					},
+					parseDOM: [{ tag: "li" }]
+				}
+			};
+		},
+		addCommands() {
+			return { bulletList: () => (state, dispatch) => {
+				const nt = state.schema.nodes["bullet_list"];
+				if (!nt) return false;
+				return require_dist.wrapIn(nt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { Enter: (state, dispatch) => {
+				const nt = state.schema.nodes["list_item"];
+				if (!nt) return false;
+				return require_dist$2.splitListItem(nt)(state, dispatch);
+			} };
+		}
+	};
+}
+function OrderedListExtension() {
+	return {
+		name: "ordered_list",
+		type: "node",
+		addNodes() {
+			return { ordered_list: {
+				group: "block",
+				content: "list_item+",
+				attrs: { order: { default: 1 } },
+				toDOM(node) {
+					return node.attrs.order === 1 ? ["ol", 0] : [
+						"ol",
+						{ start: node.attrs.order },
+						0
+					];
+				},
+				parseDOM: [{
+					tag: "ol",
+					getAttrs(dom) {
+						return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { orderedList: () => (state, dispatch) => {
+				const nt = state.schema.nodes["ordered_list"];
+				if (!nt) return false;
+				return require_dist.wrapIn(nt)(state, dispatch);
+			} };
+		},
+		addKeyboardShortcuts() {
+			return { Enter: (state, dispatch) => {
+				const nt = state.schema.nodes["list_item"];
+				if (!nt) return false;
+				return require_dist$2.splitListItem(nt)(state, dispatch);
+			} };
+		}
+	};
+}
+function TaskListExtension() {
+	return {
+		name: "task_list",
+		type: "node",
+		addNodes() {
+			return {
+				task_list: {
+					group: "block",
+					content: "task_item+",
+					toDOM() {
+						return [
+							"ul",
+							{ class: "mi-task-list" },
+							0
+						];
+					},
+					parseDOM: [{ tag: "ul.mi-task-list" }, { tag: "ul[data-task-list]" }]
+				},
+				task_item: {
+					content: "paragraph block*",
+					attrs: { checked: { default: false } },
+					toDOM(node) {
+						return [
+							"li",
+							{
+								"data-task-item": "",
+								class: "mi-task-item"
+							},
+							["input", {
+								type: "checkbox",
+								checked: node.attrs.checked ? "checked" : null,
+								"data-checked": String(node.attrs.checked)
+							}],
+							[
+								"div",
+								{ class: "mi-task-content" },
+								0
+							]
+						];
+					},
+					parseDOM: [{
+						tag: "li[data-task-item]",
+						getAttrs(dom) {
+							return { checked: dom.querySelector("input[type=\"checkbox\"]")?.checked ?? false };
+						}
+					}]
+				}
+			};
+		},
+		addCommands() {
+			return {
+				taskList: () => (state, dispatch) => {
+					const nt = state.schema.nodes["task_list"];
+					if (!nt) return false;
+					return require_dist.wrapIn(nt)(state, dispatch);
+				},
+				toggleTaskItem: () => (state, dispatch) => {
+					const { $from } = state.selection;
+					let taskItemPos = -1;
+					let taskItemNode = null;
+					state.doc.nodesBetween($from.pos, $from.pos, (node, pos) => {
+						if (node.type.name === "task_item") {
+							taskItemPos = pos;
+							taskItemNode = node;
+							return false;
+						}
+					});
+					for (let d = $from.depth; d > 0; d--) {
+						const node = $from.node(d);
+						if (node.type.name === "task_item") {
+							taskItemPos = $from.before(d);
+							taskItemNode = node;
+							break;
+						}
+					}
+					if (taskItemPos < 0 || !taskItemNode) return false;
+					if (dispatch) {
+						const tr = state.tr;
+						tr.setNodeMarkup(taskItemPos, null, {
+							...taskItemNode.attrs,
+							checked: !taskItemNode.attrs.checked
+						});
+						dispatch(tr);
+					}
+					return true;
+				}
+			};
+		},
+		addKeyboardShortcuts() {
+			return { Enter: (state, dispatch) => {
+				const nt = state.schema.nodes["task_item"];
+				if (!nt) return false;
+				return require_dist$2.splitListItem(nt)(state, dispatch);
+			} };
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({ props: { handleDOMEvents: { click(view, event) {
+				const target = event.target;
+				if (target.tagName === "INPUT" && target.type === "checkbox" && target.closest(".mi-task-item")) {
+					event.preventDefault();
+					const li = target.closest(".mi-task-item");
+					if (!li) return false;
+					const pos = view.posAtDOM(li, 0);
+					const node = view.state.doc.nodeAt(pos);
+					if (!node || node.type.name !== "task_item") return false;
+					const tr = view.state.tr;
+					tr.setNodeMarkup(pos, null, {
+						...node.attrs,
+						checked: !node.attrs.checked
+					});
+					view.dispatch(tr);
+					return true;
+				}
+				return false;
+			} } } })];
+		}
+	};
+}
+function CodeBlockExtension() {
+	return {
+		name: "code_block",
+		type: "node",
+		addNodes() {
+			return { code_block: {
+				group: "block",
+				content: "text*",
+				marks: "",
+				code: true,
+				defining: true,
+				toDOM() {
+					return ["pre", ["code", 0]];
+				},
+				parseDOM: [{
+					tag: "pre",
+					preserveWhitespace: "full"
+				}]
+			} };
+		},
+		addCommands() {
+			return { codeBlock: () => (state, dispatch) => {
+				const nt = state.schema.nodes["code_block"];
+				if (!nt) return false;
+				return require_dist.setBlockType(nt)(state, dispatch);
+			} };
+		},
+		addPlugins() {
+			return [inputRules({ rules: [new InputRule(/^```$/, (state, _match, start, end) => {
+				const nt = state.schema.nodes["code_block"];
+				if (!nt) return null;
+				const tr = state.tr;
+				tr.delete(start, end);
+				const range = tr.doc.resolve(start).blockRange();
+				if (!range) return null;
+				tr.setBlockType(range.start, range.end, nt);
+				return tr;
+			})] })];
+		}
+	};
+}
+function HorizontalRuleExtension() {
+	return {
+		name: "horizontal_rule",
+		type: "node",
+		addNodes() {
+			return { horizontal_rule: {
+				group: "block",
+				toDOM() {
+					return ["hr"];
+				},
+				parseDOM: [{ tag: "hr" }]
+			} };
+		},
+		addCommands() {
+			return { horizontalRule: () => (state, dispatch) => {
+				const nt = state.schema.nodes["horizontal_rule"];
+				if (!nt) return false;
+				const tr = state.tr;
+				tr.replaceSelectionWith(nt.create());
+				if (dispatch) dispatch(tr);
+				return true;
+			} };
+		}
+	};
+}
+function HardBreakExtension() {
+	return {
+		name: "hard_break",
+		type: "node",
+		addNodes() {
+			return { hard_break: {
+				group: "inline",
+				inline: true,
+				selectable: false,
+				toDOM() {
+					return ["br"];
+				},
+				parseDOM: [{ tag: "br" }]
+			} };
+		},
+		addKeyboardShortcuts() {
+			const insertHardBreak = (state, dispatch) => {
+				const nt = state.schema.nodes["hard_break"];
+				if (!nt) return false;
+				const tr = state.tr.replaceSelectionWith(nt.create());
+				if (dispatch) dispatch(tr.scrollIntoView());
+				return true;
+			};
+			return {
+				"Mod-Enter": insertHardBreak,
+				"Shift-Enter": insertHardBreak
+			};
+		}
+	};
+}
+var MIN_IMG_SIZE = 30;
+var IMG_PRESET_SIZES = [
+	25,
+	50,
+	75,
+	100
+];
+var ImageNodeView = class {
+	constructor(node, view, getPos) {
+		this.selected = false;
+		this._onDocMouseDown = null;
+		this.node = node;
+		this.view = view;
+		this.getPos = getPos;
+		const { src, alt, title, width, height, align } = node.attrs;
+		this.wrapper = document.createElement("span");
+		this.wrapper.className = `mi-img-wrap mi-img-align-${align || "center"}`;
+		this.wrapper.style.display = "inline-block";
+		this.wrapper.style.position = "relative";
+		this.wrapper.style.lineHeight = "0";
+		this.wrapper.style.verticalAlign = "middle";
+		if (width) this.wrapper.style.width = typeof width === "number" ? `${width}px` : String(width);
+		this.img = document.createElement("img");
+		this.img.src = src || "";
+		if (alt) this.img.alt = alt;
+		if (title) this.img.title = title;
+		if (width) this.img.style.width = typeof width === "number" ? `${width}px` : String(width);
+		if (height) this.img.style.height = typeof height === "number" ? `${height}px` : String(height);
+		this.img.style.display = "block";
+		this.img.style.maxWidth = "100%";
+		this.img.style.height = height ? typeof height === "number" ? `${height}px` : String(height) : "auto";
+		this.img.style.borderRadius = "6px";
+		this.img.style.cursor = "pointer";
+		this.img.draggable = false;
+		this.handles = document.createElement("div");
+		this.handles.style.cssText = "display:none;position:absolute;top:0;left:0;right:0;bottom:0;pointer-events:none;";
+		[
+			"nw",
+			"ne",
+			"sw",
+			"se"
+		].forEach((dir) => {
+			const h = document.createElement("div");
+			const isTop = dir.includes("n");
+			const isLeft = dir.includes("w");
+			h.style.cssText = `
+        position:absolute;width:10px;height:10px;background:#fff;border:2px solid #1a73e8;
+        border-radius:2px;pointer-events:all;cursor:${dir}-resize;z-index:10;
+        top:${isTop ? "-5px" : "auto"};bottom:${!isTop ? "-5px" : "auto"};
+        left:${isLeft ? "-5px" : "auto"};right:${!isLeft ? "-5px" : "auto"};
+      `;
+			h.addEventListener("mousedown", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				this.startResize(e, dir);
+			});
+			this.handles.appendChild(h);
+		});
+		this.toolbar = document.createElement("div");
+		this.toolbar.style.cssText = "display:none;position:absolute;bottom:calc(100% + 6px);left:50%;transform:translateX(-50%);background:#fff;border:1px solid #e0e0e0;border-radius:8px;padding:3px 6px;box-shadow:0 2px 10px rgba(0,0,0,0.12);z-index:20;white-space:nowrap;line-height:1;";
+		this.buildToolbar();
+		this.wrapper.appendChild(this.img);
+		this.wrapper.appendChild(this.handles);
+		this.wrapper.appendChild(this.toolbar);
+		this.dom = this.wrapper;
+		this.wrapper.addEventListener("mousedown", (e) => {
+			if (e.target === this.img || e.target === this.wrapper) e.preventDefault();
+		});
+		this.wrapper.addEventListener("click", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+			this.select();
+		});
+		const onDocMouseDown = (e) => {
+			if (!this.wrapper.contains(e.target)) this.deselect();
+		};
+		document.addEventListener("mousedown", onDocMouseDown);
+		this._onDocMouseDown = onDocMouseDown;
+	}
+	buildToolbar() {
+		this.toolbar.innerHTML = "";
+		const sizeGroup = document.createElement("span");
+		sizeGroup.style.cssText = "display:inline-flex;gap:2px;align-items:center;";
+		IMG_PRESET_SIZES.forEach((pct) => {
+			const btn = document.createElement("button");
+			btn.textContent = `${pct}%`;
+			btn.style.cssText = "padding:2px 6px;border:none;border-radius:3px;background:transparent;color:#555;cursor:pointer;font-size:11px;";
+			btn.addEventListener("mousedown", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+			});
+			btn.addEventListener("click", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				this.applyPreset(pct);
+			});
+			btn.addEventListener("mouseenter", () => {
+				btn.style.background = "#f0f0f0";
+			});
+			btn.addEventListener("mouseleave", () => {
+				btn.style.background = "transparent";
+			});
+			sizeGroup.appendChild(btn);
+		});
+		const divider = document.createElement("span");
+		divider.style.cssText = "display:inline-block;width:1px;height:16px;background:#e0e0e0;margin:0 4px;vertical-align:middle;";
+		const alignGroup = document.createElement("span");
+		alignGroup.style.cssText = "display:inline-flex;gap:2px;align-items:center;";
+		const currentAlign = this.node.attrs.align || "center";
+		[
+			["left", "◀"],
+			["center", "◆"],
+			["right", "▶"]
+		].forEach(([val, icon]) => {
+			const btn = document.createElement("button");
+			btn.textContent = icon;
+			btn.style.cssText = `padding:2px 5px;border:none;border-radius:3px;background:${currentAlign === val ? "#e8f0fe" : "transparent"};color:${currentAlign === val ? "#1a73e8" : "#555"};cursor:pointer;font-size:11px;`;
+			btn.addEventListener("mousedown", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+			});
+			btn.addEventListener("click", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				this.setAlign(val);
+			});
+			alignGroup.appendChild(btn);
+		});
+		this.toolbar.appendChild(sizeGroup);
+		this.toolbar.appendChild(divider);
+		this.toolbar.appendChild(alignGroup);
+	}
+	select() {
+		if (this.selected) return;
+		this.selected = true;
+		this.handles.style.display = "";
+		this.toolbar.style.display = "";
+		this.img.style.outline = "2px solid rgba(26,115,232,0.5)";
+		this.img.style.outlineOffset = "1px";
+		const pos = this.getPos();
+		if (pos === void 0) return;
+		try {
+			const tr = this.view.state.tr.setSelection(require_dist.NodeSelection.create(this.view.state.doc, pos));
+			this.view.dispatch(tr);
+		} catch {}
+	}
+	deselect() {
+		if (!this.selected) return;
+		this.selected = false;
+		this.handles.style.display = "none";
+		this.toolbar.style.display = "none";
+		this.img.style.outline = "";
+		this.img.style.outlineOffset = "";
+	}
+	startResize(e, dir) {
+		const startX = e.clientX;
+		const startY = e.clientY;
+		const startW = this.img.offsetWidth;
+		const startH = this.img.offsetHeight;
+		const aspect = startW / startH;
+		const onMove = (ev) => {
+			let dx = ev.clientX - startX;
+			let dy = ev.clientY - startY;
+			if (dir.includes("w")) dx = -dx;
+			if (dir.includes("n")) dy = -dy;
+			const scale = Math.max(dx / startW, dy / startH);
+			let newW = Math.max(MIN_IMG_SIZE, Math.round(startW * (1 + scale)));
+			let newH = Math.round(newW / aspect);
+			if (newH < MIN_IMG_SIZE) {
+				newH = MIN_IMG_SIZE;
+				newW = Math.round(newH * aspect);
+			}
+			this.img.style.width = `${newW}px`;
+			this.img.style.height = `${newH}px`;
+			this.wrapper.style.width = `${newW}px`;
+		};
+		const onUp = () => {
+			document.removeEventListener("mousemove", onMove);
+			document.removeEventListener("mouseup", onUp);
+			const pos = this.getPos();
+			if (pos === void 0) return;
+			const cur = this.view.state.doc.nodeAt(pos);
+			if (!cur || cur.type.name !== "image") return;
+			const tr = this.view.state.tr.setNodeMarkup(pos, null, {
+				...cur.attrs,
+				width: this.img.offsetWidth,
+				height: this.img.offsetHeight
+			});
+			this.view.dispatch(tr);
+		};
+		document.addEventListener("mousemove", onMove);
+		document.addEventListener("mouseup", onUp);
+	}
+	applyPreset(pct) {
+		const pos = this.getPos();
+		if (pos === void 0) return;
+		const cur = this.view.state.doc.nodeAt(pos);
+		if (!cur || cur.type.name !== "image") return;
+		const baseW = this.img.naturalWidth || this.img.offsetWidth;
+		const baseH = this.img.naturalHeight || this.img.offsetHeight;
+		const newW = Math.max(MIN_IMG_SIZE, Math.round(baseW * pct / 100));
+		const newH = Math.round(newW / (baseW / baseH));
+		this.img.style.width = `${newW}px`;
+		this.img.style.height = `${newH}px`;
+		this.wrapper.style.width = `${newW}px`;
+		const tr = this.view.state.tr.setNodeMarkup(pos, null, {
+			...cur.attrs,
+			width: newW,
+			height: newH
+		});
+		this.view.dispatch(tr);
+	}
+	setAlign(align) {
+		const pos = this.getPos();
+		if (pos === void 0) return;
+		const cur = this.view.state.doc.nodeAt(pos);
+		if (!cur || cur.type.name !== "image") return;
+		this.wrapper.className = `mi-img-wrap mi-img-align-${align}`;
+		this.buildToolbar();
+		const tr = this.view.state.tr.setNodeMarkup(pos, null, {
+			...cur.attrs,
+			align
+		});
+		this.view.dispatch(tr);
+	}
+	update(node) {
+		if (node.type.name !== "image") return false;
+		this.node = node;
+		const { src, alt, title, width, height, align } = node.attrs;
+		this.wrapper.className = `mi-img-wrap mi-img-align-${align || "center"}`;
+		if (this.img.src !== src) this.img.src = src || "";
+		if (alt) this.img.alt = alt;
+		if (title) this.img.title = title;
+		if (width) {
+			const w = typeof width === "number" ? `${width}px` : String(width);
+			this.img.style.width = w;
+			this.wrapper.style.width = w;
+		} else {
+			this.img.style.width = "";
+			this.wrapper.style.width = "";
+		}
+		if (height) this.img.style.height = typeof height === "number" ? `${height}px` : String(height);
+		else this.img.style.height = "";
+		this.buildToolbar();
+		return true;
+	}
+	stopEvent() {
+		return true;
+	}
+	ignoreMutation() {
+		return true;
+	}
+	destroy() {
+		if (this._onDocMouseDown) {
+			document.removeEventListener("mousedown", this._onDocMouseDown);
+			this._onDocMouseDown = null;
+		}
+		this.deselect();
+	}
+};
+function ImageExtension() {
+	return {
+		name: "image",
+		type: "node",
+		addNodes() {
+			return { image: {
+				group: "inline",
+				inline: true,
+				attrs: {
+					src: {},
+					alt: { default: null },
+					title: { default: null },
+					width: { default: null },
+					height: { default: null },
+					align: { default: "center" }
+				},
+				selectable: true,
+				draggable: true,
+				toDOM(node) {
+					const { src, alt, title, width, height } = node.attrs;
+					const attrs = {
+						src: src || "",
+						draggable: "false"
+					};
+					if (alt) attrs.alt = alt;
+					if (title) attrs.title = title;
+					if (width) attrs.style = `width: ${typeof width === "number" ? `${width}px` : String(width)}; height: ${height ? typeof height === "number" ? `${height}px` : String(height) : "auto"};`;
+					return ["img", attrs];
+				},
+				parseDOM: [{
+					tag: "img[src]",
+					getAttrs(dom) {
+						const el = dom;
+						const style = el.getAttribute("style") || "";
+						const wMatch = style.match(/width:\s*(\d+)px/);
+						const hMatch = style.match(/height:\s*(\d+)px/);
+						return {
+							src: el.getAttribute("src"),
+							alt: el.getAttribute("alt"),
+							title: el.getAttribute("title"),
+							width: wMatch ? parseInt(wMatch[1]) : el.getAttribute("width") ? parseInt(el.getAttribute("width")) : null,
+							height: hMatch ? parseInt(hMatch[1]) : el.getAttribute("height") ? parseInt(el.getAttribute("height")) : null,
+							align: "center"
+						};
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return {
+				setImageSize: (...args) => {
+					const width = args[0];
+					const height = args[1];
+					return (state, dispatch) => {
+						const { $from } = state.selection;
+						let imagePos = -1;
+						for (let d = $from.depth; d > 0; d--) if ($from.node(d).type.name === "image") {
+							imagePos = $from.before(d);
+							break;
+						}
+						if (imagePos < 0) return false;
+						const node = state.doc.nodeAt(imagePos);
+						if (!node || node.type.name !== "image") return false;
+						const aspect = node.attrs.width && node.attrs.height ? node.attrs.width / node.attrs.height : 1;
+						const finalH = height ?? Math.round(width / aspect);
+						if (dispatch) dispatch(state.tr.setNodeMarkup(imagePos, null, {
+							...node.attrs,
+							width,
+							height: finalH
+						}));
+						return true;
+					};
+				},
+				setImageAlign: (...args) => {
+					const align = args[0];
+					return (state, dispatch) => {
+						const { $from } = state.selection;
+						let imagePos = -1;
+						for (let d = $from.depth; d > 0; d--) if ($from.node(d).type.name === "image") {
+							imagePos = $from.before(d);
+							break;
+						}
+						if (imagePos < 0) return false;
+						const node = state.doc.nodeAt(imagePos);
+						if (!node || node.type.name !== "image") return false;
+						if (dispatch) dispatch(state.tr.setNodeMarkup(imagePos, null, {
+							...node.attrs,
+							align
+						}));
+						return true;
+					};
+				}
+			};
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({
+				key: new require_dist.PluginKey("imageNodeView"),
+				props: { nodeViews: { image(node, view, getPos) {
+					return new ImageNodeView(node, view, getPos);
+				} } }
+			})];
+		}
+	};
+}
+function CardExtension() {
+	return {
+		name: "card",
+		type: "node",
+		addNodes() {
+			return { card: {
+				group: "block",
+				content: "block+",
+				defining: true,
+				attrs: { title: { default: "" } },
+				toDOM(node) {
+					return [
+						"div",
+						{
+							class: "mi-card",
+							"data-card-title": node.attrs.title || ""
+						},
+						[
+							"div",
+							{ class: "mi-card-header" },
+							[
+								"div",
+								{
+									class: "mi-card-title",
+									contenteditable: "false",
+									"data-card-title": ""
+								},
+								node.attrs.title || "卡片标题"
+							]
+						],
+						[
+							"div",
+							{ class: "mi-card-body" },
+							0
+						]
+					];
+				},
+				parseDOM: [{
+					tag: "div.mi-card",
+					getAttrs(dom) {
+						const el = dom;
+						return { title: el.querySelector(".mi-card-title")?.textContent || el.getAttribute("data-card-title") || "" };
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { card: (...args) => {
+				const title = args[0] ?? "";
+				return (state, dispatch) => {
+					const nt = state.schema.nodes["card"];
+					const paraType = state.schema.nodes["paragraph"];
+					if (!nt || !paraType) return false;
+					const { from, to } = state.selection;
+					const para = paraType.createAndFill();
+					const card = nt.create({ title }, para);
+					if (dispatch) dispatch(state.tr.replaceWith(from, to, card).scrollIntoView());
+					return true;
+				};
+			} };
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({ props: { handleDOMEvents: { click(view, event) {
+				const titleEl = event.target.closest(".mi-card-title");
+				if (!titleEl) return false;
+				const card = titleEl.closest(".mi-card");
+				if (!card) return false;
+				event.preventDefault();
+				const pos = view.posAtDOM(card, 0);
+				const tr = view.state.tr;
+				const resolved = tr.doc.resolve(pos);
+				let nodePos = -1;
+				for (let d = resolved.depth; d >= 0; d--) if (resolved.node(d).type.name === "card") {
+					nodePos = resolved.before(d);
+					break;
+				}
+				if (nodePos < 0) return false;
+				const node = tr.doc.nodeAt(nodePos);
+				if (!node || node.type.name !== "card") return false;
+				const currentTitle = node.attrs.title;
+				const newTitle = prompt("编辑卡片标题:", currentTitle);
+				if (newTitle !== null && newTitle !== currentTitle) {
+					tr.setNodeMarkup(nodePos, null, {
+						...node.attrs,
+						title: newTitle
+					});
+					view.dispatch(tr);
+				}
+				return true;
+			} } } })];
+		}
+	};
+}
+function ProductCardExtension() {
+	return {
+		name: "product_card",
+		type: "node",
+		addNodes() {
+			return { product_card: {
+				group: "block",
+				atom: true,
+				attrs: {
+					productName: { default: "" },
+					productImage: { default: "" },
+					productPrice: { default: "" },
+					productOriginalPrice: { default: "" },
+					productDescription: { default: "" },
+					productLink: { default: "" },
+					productTags: { default: "" }
+				},
+				toDOM(node) {
+					const a = node.attrs;
+					const tags = a.productTags ? a.productTags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+					const imgWrap = a.productImage ? [
+						"div",
+						{ class: "mi-product-card-img-wrap" },
+						["img", {
+							src: a.productImage,
+							alt: a.productName,
+							class: "mi-product-card-img",
+							draggable: "false"
+						}]
+					] : [
+						"div",
+						{ class: "mi-product-card-img-wrap mi-product-card-img-empty" },
+						[
+							"span",
+							{ class: "mi-product-card-img-placeholder" },
+							"📦"
+						]
+					];
+					const contentChildren = [[
+						"div",
+						{ class: "mi-product-card-title" },
+						a.productName || "商品名称"
+					]];
+					if (a.productDescription) contentChildren.push([
+						"div",
+						{ class: "mi-product-card-desc" },
+						a.productDescription
+					]);
+					if (tags.length > 0) {
+						const tagElements = tags.map((tag) => [
+							"span",
+							{ class: "mi-product-card-tag" },
+							tag
+						]);
+						contentChildren.push([
+							"div",
+							{ class: "mi-product-card-tags" },
+							...tagElements
+						]);
+					}
+					if (a.productPrice || a.productOriginalPrice) {
+						const priceElements = [];
+						if (a.productPrice) priceElements.push([
+							"span",
+							{ class: "mi-product-card-price" },
+							`¥${a.productPrice}`
+						]);
+						if (a.productOriginalPrice) priceElements.push([
+							"span",
+							{ class: "mi-product-card-original-price" },
+							`¥${a.productOriginalPrice}`
+						]);
+						contentChildren.push([
+							"div",
+							{ class: "mi-product-card-price-row" },
+							...priceElements
+						]);
+					}
+					if (a.productLink) contentChildren.push([
+						"a",
+						{
+							class: "mi-product-card-link",
+							href: a.productLink,
+							target: "_blank",
+							rel: "noopener noreferrer"
+						},
+						"查看详情 →"
+					]);
+					return [
+						"div",
+						{
+							class: "mi-product-card",
+							contenteditable: "false"
+						},
+						[
+							"div",
+							{ class: "mi-product-card-inner" },
+							imgWrap,
+							[
+								"div",
+								{ class: "mi-product-card-content" },
+								...contentChildren
+							]
+						],
+						[
+							"button",
+							{
+								class: "mi-product-card-delete",
+								title: "删除卡片"
+							},
+							"×"
+						]
+					];
+				},
+				parseDOM: [{
+					tag: "div.mi-product-card",
+					getAttrs(dom) {
+						const el = dom;
+						const get = (sel) => el.querySelector(sel)?.textContent?.trim() || "";
+						const img = el.querySelector(".mi-product-card-img");
+						const link = el.querySelector(".mi-product-card-link");
+						const tags = Array.from(el.querySelectorAll(".mi-product-card-tag")).map((t) => t.textContent?.trim() || "").filter(Boolean).join(",");
+						return {
+							productName: get(".mi-product-card-title"),
+							productImage: img?.getAttribute("src") || "",
+							productPrice: get(".mi-product-card-price")?.replace(/^¥/, "") || "",
+							productOriginalPrice: get(".mi-product-card-original-price")?.replace(/^¥/, "") || "",
+							productDescription: get(".mi-product-card-desc"),
+							productLink: link?.getAttribute("href") || "",
+							productTags: tags
+						};
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { insertProductCard: (...args) => {
+				const attrs = args[0];
+				return (state, dispatch) => {
+					const nt = state.schema.nodes["product_card"];
+					if (!nt) return false;
+					const { from, to } = state.selection;
+					const node = nt.create({
+						productName: attrs?.productName ?? "",
+						productImage: attrs?.productImage ?? "",
+						productPrice: attrs?.productPrice ?? "",
+						productOriginalPrice: attrs?.productOriginalPrice ?? "",
+						productDescription: attrs?.productDescription ?? "",
+						productLink: attrs?.productLink ?? "",
+						productTags: attrs?.productTags ?? ""
+					});
+					if (dispatch) dispatch(state.tr.replaceWith(from, to, node).scrollIntoView());
+					return true;
+				};
+			} };
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({ props: { handleDOMEvents: {
+				click(view, event) {
+					const target = event.target;
+					if (target.classList.contains("mi-product-card-delete")) {
+						event.preventDefault();
+						event.stopPropagation();
+						const card = target.closest(".mi-product-card");
+						if (!card || !view.dom.contains(card)) return false;
+						const pos = view.posAtDOM(card, 0);
+						const node = view.state.doc.nodeAt(pos);
+						if (!node || node.type.name !== "product_card") return false;
+						const tr = view.state.tr.delete(pos, pos + node.nodeSize);
+						view.dispatch(tr);
+						return true;
+					}
+					return false;
+				},
+				dblclick(view, event) {
+					const target = event.target;
+					if (target.classList.contains("mi-product-card-delete")) return false;
+					const card = target.closest(".mi-product-card");
+					if (!card || !view.dom.contains(card)) return false;
+					event.preventDefault();
+					const pos = view.posAtDOM(card, 0);
+					const node = view.state.doc.nodeAt(pos);
+					if (!node || node.type.name !== "product_card") return false;
+					const a = node.attrs;
+					const name = prompt("商品名称:", a.productName);
+					if (name === null) return true;
+					const price = prompt("商品价格:", a.productPrice);
+					if (price === null) return true;
+					const desc = prompt("商品描述:", a.productDescription);
+					if (desc === null) return true;
+					const tr = view.state.tr;
+					tr.setNodeMarkup(pos, null, {
+						...node.attrs,
+						productName: name,
+						productPrice: price,
+						productDescription: desc
+					});
+					view.dispatch(tr);
+					return true;
+				}
+			} } })];
+		}
+	};
+}
+//#endregion
+//#region src/extensions/table-extension.ts
+function cellAttrs(attrs) {
+	return {
+		colspan: attrs.colspan || 1,
+		rowspan: attrs.rowspan || 1,
+		colwidth: attrs.colwidth || null,
+		style: attrs.style || null
+	};
+}
+function cellAttrsToDOM(attrs) {
+	const result = {};
+	if (attrs.colspan && attrs.colspan > 1) result.colspan = String(attrs.colspan);
+	if (attrs.rowspan && attrs.rowspan > 1) result.rowspan = String(attrs.rowspan);
+	if (attrs.colwidth && attrs.colwidth.length > 0) result.style = `width: ${attrs.colwidth[0]}px`;
+	if (attrs.style) result.style = result.style ? `${result.style}; ${attrs.style}` : attrs.style;
+	return result;
+}
+function parseCellAttrs(dom) {
+	return {
+		colspan: parseInt(dom.getAttribute("colspan") || "1", 10),
+		rowspan: parseInt(dom.getAttribute("rowspan") || "1", 10),
+		colwidth: dom.getAttribute("colwidth") ? dom.getAttribute("colwidth").split(",").map(Number) : null,
+		style: dom.getAttribute("style") || null
+	};
+}
+function tableNodes() {
+	return {
+		table: {
+			group: "block",
+			content: "table_row+",
+			tableRole: "table",
+			isolating: true,
+			attrs: {
+				class: { default: null },
+				tableStyle: { default: "default" }
+			},
+			parseDOM: [{
+				tag: "table",
+				getAttrs: (dom) => ({
+					class: dom.getAttribute("class"),
+					tableStyle: dom.getAttribute("data-table-style") || "default"
+				})
+			}],
+			toDOM(node) {
+				const style = node.attrs.tableStyle || "default";
+				const attrs = {
+					class: `miyuan-table miyuan-table-${style}`,
+					"data-table-style": style
+				};
+				if (node.attrs.class) attrs.class += ` ${node.attrs.class}`;
+				return [
+					"div",
+					{ class: "miyuan-table-wrapper" },
+					[
+						"table",
+						attrs,
+						["tbody", 0]
+					]
+				];
+			}
+		},
+		table_row: {
+			content: "(table_cell | table_header)+",
+			tableRole: "row",
+			parseDOM: [{ tag: "tr" }],
+			toDOM() {
+				return ["tr", 0];
+			}
+		},
+		table_cell: {
+			content: "block+",
+			tableRole: "cell",
+			isolating: true,
+			attrs: {
+				colspan: { default: 1 },
+				rowspan: { default: 1 },
+				colwidth: { default: null },
+				style: { default: null }
+			},
+			parseDOM: [{
+				tag: "td",
+				getAttrs: (dom) => parseCellAttrs(dom)
+			}],
+			toDOM(node) {
+				return [
+					"td",
+					cellAttrsToDOM(cellAttrs(node.attrs)),
+					0
+				];
+			}
+		},
+		table_header: {
+			content: "block+",
+			tableRole: "header_cell",
+			isolating: true,
+			attrs: {
+				colspan: { default: 1 },
+				rowspan: { default: 1 },
+				colwidth: { default: null },
+				style: { default: null }
+			},
+			parseDOM: [{
+				tag: "th",
+				getAttrs: (dom) => parseCellAttrs(dom)
+			}],
+			toDOM(node) {
+				return [
+					"th",
+					cellAttrsToDOM(cellAttrs(node.attrs)),
+					0
+				];
+			}
+		}
+	};
+}
+function findTable(state) {
+	const { $from } = state.selection;
+	for (let d = $from.depth; d > 0; d--) if ($from.node(d).type.name === "table") return {
+		pos: $from.before(d),
+		node: $from.node(d),
+		depth: d
+	};
+	return null;
+}
+function findCellPosition(state) {
+	const { $from } = state.selection;
+	for (let d = $from.depth; d > 0; d--) {
+		const node = $from.node(d);
+		if (node.type.name === "table_cell" || node.type.name === "table_header") return {
+			cellPos: $from.before(d),
+			cellNode: node,
+			rowPos: $from.before(d - 1),
+			rowNode: $from.node(d - 1),
+			tablePos: $from.before(d - 2),
+			tableNode: $from.node(d - 2)
+		};
+	}
+	return null;
+}
+function insertTable(rows = 3, cols = 3) {
+	return (state, dispatch) => {
+		const { schema } = state;
+		const tableNodeType = schema.nodes.table;
+		const rowType = schema.nodes.table_row;
+		const cellType = schema.nodes.table_cell;
+		const headerType = schema.nodes.table_header;
+		const paraType = schema.nodes.paragraph;
+		if (!tableNodeType || !rowType || !cellType || !headerType || !paraType) return false;
+		const tableRows = [];
+		const headerCells = [];
+		for (let c = 0; c < cols; c++) headerCells.push(headerType.createAndFill({}, paraType.createAndFill()));
+		tableRows.push(rowType.create(null, headerCells));
+		for (let r = 1; r < rows; r++) {
+			const cells = [];
+			for (let c = 0; c < cols; c++) cells.push(cellType.createAndFill({}, paraType.createAndFill()));
+			tableRows.push(rowType.create(null, cells));
+		}
+		const table = tableNodeType.create(null, tableRows);
+		if (dispatch) {
+			const { from, to } = state.selection;
+			const tr = state.tr.replaceWith(from, to, table);
+			const newSelection = require_dist.TextSelection.near(tr.doc.resolve(from + 2));
+			tr.setSelection(newSelection);
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+function addRowBefore() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (dispatch) {
+			const { schema } = state;
+			const rowType = schema.nodes.table_row;
+			const cellType = schema.nodes.table_cell;
+			const paraType = schema.nodes.paragraph;
+			const colCount = cellPos.rowNode.childCount;
+			const cells = [];
+			for (let i = 0; i < colCount; i++) cells.push(cellType.createAndFill({}, paraType.createAndFill()));
+			const newRow = rowType.create(null, cells);
+			dispatch(state.tr.insert(cellPos.rowPos, newRow).scrollIntoView());
+		}
+		return true;
+	};
+}
+function addRowAfter() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (dispatch) {
+			const { schema } = state;
+			const rowType = schema.nodes.table_row;
+			const cellType = schema.nodes.table_cell;
+			const paraType = schema.nodes.paragraph;
+			const colCount = cellPos.rowNode.childCount;
+			const cells = [];
+			for (let i = 0; i < colCount; i++) cells.push(cellType.createAndFill({}, paraType.createAndFill()));
+			const newRow = rowType.create(null, cells);
+			dispatch(state.tr.insert(cellPos.rowPos + cellPos.rowNode.nodeSize, newRow).scrollIntoView());
+		}
+		return true;
+	};
+}
+function addColumnBefore() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (dispatch) {
+			const { schema } = state;
+			const table = cellPos.tableNode;
+			const colIndex = getCellColumnIndex(cellPos.rowNode, cellPos.cellPos - cellPos.rowPos - 1);
+			let tr = state.tr;
+			for (let i = table.childCount - 1; i >= 0; i--) {
+				const row = table.child(i);
+				const cellType = i === 0 ? schema.nodes.table_header : schema.nodes.table_cell;
+				const paraType = schema.nodes.paragraph;
+				const newCell = cellType.createAndFill({}, paraType.createAndFill());
+				let insertPos = cellPos.tablePos + 1;
+				for (let r = 0; r < i; r++) insertPos += table.child(r).nodeSize;
+				insertPos += 1;
+				for (let j = 0; j < colIndex && j < row.childCount; j++) insertPos += row.child(j).nodeSize;
+				tr = tr.insert(insertPos, newCell);
+			}
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+function addColumnAfter() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (dispatch) {
+			const { schema } = state;
+			const table = cellPos.tableNode;
+			const colIndex = getCellColumnIndex(cellPos.rowNode, cellPos.cellPos - cellPos.rowPos - 1);
+			let tr = state.tr;
+			for (let i = table.childCount - 1; i >= 0; i--) {
+				const row = table.child(i);
+				const cellType = i === 0 ? schema.nodes.table_header : schema.nodes.table_cell;
+				const paraType = schema.nodes.paragraph;
+				const newCell = cellType.createAndFill({}, paraType.createAndFill());
+				let insertPos = cellPos.tablePos + 1;
+				for (let r = 0; r < i; r++) insertPos += table.child(r).nodeSize;
+				insertPos += 1;
+				for (let j = 0; j <= colIndex && j < row.childCount; j++) insertPos += row.child(j).nodeSize;
+				tr = tr.insert(insertPos, newCell);
+			}
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+function deleteRow() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (cellPos.tableNode.childCount === 1) return deleteTable()(state, dispatch);
+		if (dispatch) dispatch(state.tr.delete(cellPos.rowPos, cellPos.rowPos + cellPos.rowNode.nodeSize).scrollIntoView());
+		return true;
+	};
+}
+function deleteColumn() {
+	return (state, dispatch) => {
+		const cellPos = findCellPosition(state);
+		if (!cellPos) return false;
+		if (cellPos.rowNode.childCount === 1) return deleteTable()(state, dispatch);
+		if (dispatch) {
+			const { schema } = state;
+			const table = cellPos.tableNode;
+			const colIndex = getCellColumnIndex(cellPos.rowNode, cellPos.cellPos - cellPos.rowPos - 1);
+			let tr = state.tr;
+			let offset = 0;
+			for (let i = 0; i < table.childCount; i++) {
+				const row = table.child(i);
+				let cellDeletePos = cellPos.tablePos + offset + 1 + 1;
+				for (let j = 0; j < colIndex && j < row.childCount; j++) cellDeletePos += row.child(j).nodeSize;
+				const cellToDelete = row.child(Math.min(colIndex, row.childCount - 1));
+				tr = tr.delete(cellDeletePos, cellDeletePos + cellToDelete.nodeSize);
+				offset -= cellToDelete.nodeSize;
+			}
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+function deleteTable() {
+	return (state, dispatch) => {
+		const table = findTable(state);
+		if (!table) return false;
+		if (dispatch) dispatch(state.tr.delete(table.pos, table.pos + table.node.nodeSize).scrollIntoView());
+		return true;
+	};
+}
+function toggleHeaderRow() {
+	return (state, dispatch) => {
+		const table = findTable(state);
+		if (!table) return false;
+		if (dispatch) {
+			const { schema } = state;
+			const firstRow = table.node.child(0);
+			const tr = state.tr;
+			const allHeaders = Array.from({ length: firstRow.childCount }, (_, i) => firstRow.child(i).type.name).every((type) => type === "table_header");
+			let offset = 0;
+			for (let i = 0; i < firstRow.childCount; i++) {
+				const cell = firstRow.child(i);
+				const cellPos = table.pos + 1 + offset;
+				const newType = allHeaders ? schema.nodes.table_cell : schema.nodes.table_header;
+				tr.setNodeMarkup(cellPos, newType, cell.attrs);
+				offset += cell.nodeSize;
+			}
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+function setTableStyle(style) {
+	return (state, dispatch) => {
+		const table = findTable(state);
+		if (!table) return false;
+		if (dispatch) dispatch(state.tr.setNodeMarkup(table.pos, null, {
+			...table.node.attrs,
+			tableStyle: style
+		}));
+		return true;
+	};
+}
+function getCellColumnIndex(row, cellOffset) {
+	let offset = 0;
+	for (let i = 0; i < row.childCount; i++) {
+		if (offset === cellOffset) return i;
+		offset += row.child(i).nodeSize;
+	}
+	return row.childCount - 1;
+}
+var tablePluginKey = new require_dist.PluginKey("table");
+function tablePlugin() {
+	return new require_dist.Plugin({
+		key: tablePluginKey,
+		props: { handleKeyDown(view, event) {
+			const state = view.state;
+			const cellPos = findCellPosition(state);
+			if (event.key === "Tab") {
+				if (!cellPos) return false;
+				event.preventDefault();
+				const { schema } = state;
+				const table = cellPos.tableNode;
+				const row = cellPos.rowNode;
+				const colIndex = getCellColumnIndex(row, cellPos.cellPos - cellPos.rowPos - 1);
+				const rowIndex = getRowIndex(table, cellPos.rowPos - cellPos.tablePos - 1);
+				let targetRow;
+				let targetCol;
+				if (event.shiftKey) if (colIndex > 0) {
+					targetRow = rowIndex;
+					targetCol = colIndex - 1;
+				} else if (rowIndex > 0) {
+					targetRow = rowIndex - 1;
+					targetCol = table.child(rowIndex - 1).childCount - 1;
+				} else return true;
+				else if (colIndex < row.childCount - 1) {
+					targetRow = rowIndex;
+					targetCol = colIndex + 1;
+				} else if (rowIndex < table.childCount - 1) {
+					targetRow = rowIndex + 1;
+					targetCol = 0;
+				} else return addRowAfter()(state, view.dispatch);
+				const targetCellPos = getCellPos(table, targetRow, targetCol, cellPos.tablePos);
+				if (targetCellPos !== null) {
+					const $pos = state.doc.resolve(targetCellPos + 1);
+					const tr = state.tr.setSelection(require_dist.TextSelection.near($pos, 1));
+					view.dispatch(tr.scrollIntoView());
+				}
+				return true;
+			}
+			if (event.key === "Enter" && !event.shiftKey && !event.ctrlKey && !event.metaKey) {
+				if (!cellPos) return false;
+				return false;
+			}
+			if (event.key === "Backspace") {
+				if (!cellPos) return false;
+				const { from, empty } = state.selection;
+				if (!empty) return false;
+				if (from === cellPos.cellPos + 2) {
+					event.preventDefault();
+					const table = cellPos.tableNode;
+					table.child(0);
+					const firstCellPos = cellPos.tablePos + 2;
+					if (cellPos.cellPos === firstCellPos - 1) return deleteTable()(state, view.dispatch);
+					const row = cellPos.rowNode;
+					const colIndex = getCellColumnIndex(row, cellPos.cellPos - cellPos.rowPos - 1);
+					const rowIndex = getRowIndex(table, cellPos.rowPos - cellPos.tablePos - 1);
+					let prevRow;
+					let prevCol;
+					if (colIndex > 0) {
+						prevRow = rowIndex;
+						prevCol = colIndex - 1;
+					} else if (rowIndex > 0) {
+						prevRow = rowIndex - 1;
+						prevCol = table.child(rowIndex - 1).childCount - 1;
+					} else return true;
+					const prevCellPos = getCellPos(table, prevRow, prevCol, cellPos.tablePos);
+					if (prevCellPos !== null) {
+						const $pos = state.doc.resolve(prevCellPos + 1);
+						const tr = state.tr.setSelection(require_dist.TextSelection.near($pos, 1));
+						view.dispatch(tr.scrollIntoView());
+					}
+					return true;
+				}
+			}
+			return false;
+		} }
+	});
+}
+function getRowIndex(table, rowOffset) {
+	let offset = 0;
+	for (let i = 0; i < table.childCount; i++) {
+		if (offset === rowOffset) return i;
+		offset += table.child(i).nodeSize;
+	}
+	return table.childCount - 1;
+}
+function getCellPos(table, rowIndex, colIndex, tablePos) {
+	if (rowIndex < 0 || rowIndex >= table.childCount) return null;
+	const row = table.child(rowIndex);
+	if (colIndex < 0 || colIndex >= row.childCount) return null;
+	let offset = 1;
+	for (let r = 0; r < rowIndex; r++) offset += table.child(r).nodeSize;
+	let cellOffset = 1;
+	for (let c = 0; c < colIndex; c++) cellOffset += row.child(c).nodeSize;
+	return tablePos + offset + cellOffset;
+}
+function TableExtension() {
+	return {
+		name: "table",
+		type: "node",
+		addNodes() {
+			return tableNodes();
+		},
+		addCommands() {
+			return {
+				insertTable: (...args) => (state, dispatch) => {
+					return insertTable(args[0] || 3, args[1] || 3)(state, dispatch);
+				},
+				addRowBefore: () => addRowBefore(),
+				addRowAfter: () => addRowAfter(),
+				addColumnBefore: () => addColumnBefore(),
+				addColumnAfter: () => addColumnAfter(),
+				deleteRow: () => deleteRow(),
+				deleteColumn: () => deleteColumn(),
+				deleteTable: () => deleteTable(),
+				toggleHeaderRow: () => toggleHeaderRow(),
+				setTableStyle: (...args) => setTableStyle(args[0] || "default")
+			};
+		},
+		addKeyboardShortcuts() {
+			return { "Mod-Alt-t": insertTable(3, 3) };
+		},
+		addPlugins() {
+			return [tablePlugin()];
+		}
+	};
+}
+//#endregion
+//#region src/extensions/behavior-extensions.ts
+function HistoryExtension() {
+	return {
+		name: "history",
+		type: "extension",
+		addPlugins() {
+			return [require_dist$2.history()];
+		},
+		addCommands() {
+			return {
+				undo: () => require_dist$2.undo,
+				redo: () => require_dist$2.redo
+			};
+		},
+		addKeyboardShortcuts() {
+			return {
+				"Mod-z": require_dist$2.undo,
+				"Mod-y": require_dist$2.redo,
+				"Mod-Shift-z": require_dist$2.redo
+			};
+		}
+	};
+}
+var placeholderKey = new require_dist.PluginKey("placeholder");
+function PlaceholderExtension(config) {
+	const text = config?.placeholder ?? "开始输入...";
+	return {
+		name: "placeholder",
+		type: "extension",
+		addPlugins() {
+			return [new require_dist.Plugin({
+				key: placeholderKey,
+				state: {
+					init(_, state) {
+						return buildDecorations(state, text);
+					},
+					apply(tr, oldDecorations, _oldState, newState) {
+						if (tr.docChanged) return buildDecorations(newState, text);
+						return oldDecorations;
+					}
+				},
+				props: { decorations(state) {
+					return this.getState(state);
+				} }
+			})];
+		}
+	};
+}
+function buildDecorations(state, text) {
+	const doc = state.doc;
+	if (doc.childCount !== 1) return require_dist$1.DecorationSet.empty;
+	const first = doc.firstChild;
+	if (!first || first.type.name !== "paragraph" || first.content.size > 0) return require_dist$1.DecorationSet.empty;
+	const deco = require_dist$1.Decoration.node(0, first.nodeSize, {
+		class: "mi-placeholder",
+		"data-placeholder": text
+	});
+	return require_dist$1.DecorationSet.create(doc, [deco]);
+}
+var imageUploadKey = new require_dist.PluginKey("imageUpload");
+/** Default: convert file to base64 data URL */
+function fileToDataURL(file) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => resolve(reader.result);
+		reader.onerror = reject;
+		reader.readAsDataURL(file);
+	});
+}
+function ImageUploadExtension(config) {
+	const upload = config?.upload ?? fileToDataURL;
+	const maxSize = config?.maxSize ?? 5 * 1024 * 1024;
+	function insertImage(view, src) {
+		const imageType = view.state.schema.nodes["image"];
+		if (!imageType) return;
+		const tr = view.state.tr.replaceSelectionWith(imageType.create({ src }));
+		view.dispatch(tr.scrollIntoView());
+	}
+	async function handleFile(file, view) {
+		if (!file.type.startsWith("image/")) return;
+		if (file.size > maxSize) {
+			console.warn(`Image too large: ${(file.size / 1024 / 1024).toFixed(1)}MB > ${(maxSize / 1024 / 1024).toFixed(1)}MB`);
+			return;
+		}
+		try {
+			insertImage(view, await upload(file));
+		} catch (e) {
+			console.error("Image upload failed:", e);
+		}
+	}
+	return {
+		name: "imageUpload",
+		type: "extension",
+		addCommands() {
+			return { insertImage: (...args) => {
+				const src = args[0];
+				return (state, dispatch) => {
+					const imageType = state.schema.nodes["image"];
+					if (!imageType) return false;
+					const tr = state.tr.replaceSelectionWith(imageType.create({ src }));
+					if (dispatch) dispatch(tr.scrollIntoView());
+					return true;
+				};
+			} };
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({
+				key: imageUploadKey,
+				props: {
+					handlePaste(view, event) {
+						const files = event.clipboardData?.files;
+						if (!files || files.length === 0) return false;
+						const imageFile = Array.from(files).find((f) => f.type.startsWith("image/"));
+						if (!imageFile) return false;
+						event.preventDefault();
+						handleFile(imageFile, view);
+						return true;
+					},
+					handleDrop(view, event) {
+						const files = event.dataTransfer?.files;
+						if (!files || files.length === 0) return false;
+						const imageFile = Array.from(files).find((f) => f.type.startsWith("image/"));
+						if (!imageFile) return false;
+						event.preventDefault();
+						handleFile(imageFile, view);
+						return true;
+					}
+				}
+			})];
+		}
+	};
+}
+//#endregion
+//#region src/extensions/line-height-extension.ts
+var DEFAULT_LINE_HEIGHTS = [
+	{
+		label: "单倍行距",
+		value: 1
+	},
+	{
+		label: "1.15 倍行距",
+		value: 1.15
+	},
+	{
+		label: "1.5 倍行距",
+		value: 1.5
+	},
+	{
+		label: "双倍行距",
+		value: 2
+	},
+	{
+		label: "2.5 倍行距",
+		value: 2.5
+	},
+	{
+		label: "3 倍行距",
+		value: 3
+	}
+];
+function LineHeightExtension(config) {
+	return {
+		name: "lineHeight",
+		type: "extension",
+		options: { lineHeights: config?.lineHeights ?? DEFAULT_LINE_HEIGHTS },
+		addCommands() {
+			return { setLineHeight: (...args) => {
+				const value = args[0];
+				return setLineHeightCommand(value);
+			} };
+		}
+	};
+}
+function setLineHeightCommand(value) {
+	return (state, dispatch) => {
+		const { from, to } = state.selection;
+		let applicable = false;
+		state.doc.nodesBetween(from, to, (node, pos) => {
+			if (node.type.name !== "paragraph" && node.type.name !== "heading") return;
+			applicable = true;
+			if (dispatch) {
+				const tr = state.tr;
+				tr.setNodeMarkup(pos, null, {
+					...node.attrs,
+					lineHeight: value
+				});
+				dispatch(tr);
+			}
+		});
+		return applicable;
+	};
+}
+//#endregion
+//#region src/extensions/version-history-extension.ts
+var versionHistoryKey = new require_dist.PluginKey("versionHistory");
+function generateId() {
+	return `v_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function createInitialState(versions) {
+	return { versions };
+}
+function getVersions(state) {
+	return versionHistoryKey.getState(state)?.versions ?? [];
+}
+function saveVersion(name) {
+	return (state, dispatch) => {
+		if (dispatch) dispatch(state.tr.setMeta(versionHistoryKey, {
+			type: "save",
+			name: name ?? `版本 ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}`
+		}));
+		return true;
+	};
+}
+function restoreVersion(versionId) {
+	return (state, dispatch) => {
+		const pluginState = versionHistoryKey.getState(state);
+		if (!pluginState) return false;
+		const version = pluginState.versions.find((v) => v.id === versionId);
+		if (!version) return false;
+		if (dispatch) {
+			const doc = require_dist.Node.fromJSON(state.schema, version.docJSON);
+			const tr = state.tr.replaceWith(0, state.doc.content.size, doc.content);
+			tr.setMeta(versionHistoryKey, { type: "restore" });
+			dispatch(tr);
+		}
+		return true;
+	};
+}
+function deleteVersion(versionId) {
+	return (state, dispatch) => {
+		if (dispatch) dispatch(state.tr.setMeta(versionHistoryKey, {
+			type: "delete",
+			versionId
+		}));
+		return true;
+	};
+}
+function renameVersion(versionId, newName) {
+	return (state, dispatch) => {
+		if (dispatch) dispatch(state.tr.setMeta(versionHistoryKey, {
+			type: "rename",
+			versionId,
+			name: newName
+		}));
+		return true;
+	};
+}
+function VersionHistoryExtension(config) {
+	const maxVersions = config?.maxVersions ?? 50;
+	const autoSaveInterval = config?.autoSaveInterval ?? 0;
+	const onVersionsChange = config?.onVersionsChange;
+	const storage = config?.storage;
+	let autoSaveTimer = null;
+	let currentEditorState = null;
+	let currentDispatch = null;
+	return {
+		name: "versionHistory",
+		type: "extension",
+		addCommands() {
+			return {
+				saveVersion: (...args) => {
+					const name = args[0];
+					return saveVersion(name);
+				},
+				restoreVersion: (...args) => {
+					const versionId = args[0];
+					return restoreVersion(versionId);
+				},
+				deleteVersion: (...args) => {
+					const versionId = args[0];
+					return deleteVersion(versionId);
+				},
+				renameVersion: (...args) => {
+					const versionId = args[0];
+					const newName = args[1];
+					return renameVersion(versionId, newName);
+				},
+				listVersions: () => {
+					return (state, dispatch) => {
+						const versions = getVersions(state);
+						if (dispatch && onVersionsChange) onVersionsChange(versions);
+						return true;
+					};
+				}
+			};
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({
+				key: versionHistoryKey,
+				state: {
+					init() {
+						const loaded = storage?.load();
+						if (loaded && !(typeof loaded.then === "function")) return createInitialState(loaded);
+						return createInitialState([]);
+					},
+					apply(tr, value, _oldState, newState) {
+						const meta = tr.getMeta(versionHistoryKey);
+						if (!meta) return value;
+						let newVersions;
+						switch (meta.type) {
+							case "save":
+								newVersions = [{
+									id: generateId(),
+									name: meta.name ?? `版本 ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}`,
+									timestamp: Date.now(),
+									docJSON: newState.doc.toJSON()
+								}, ...value.versions];
+								if (newVersions.length > maxVersions) newVersions = newVersions.slice(0, maxVersions);
+								break;
+							case "delete":
+								newVersions = value.versions.filter((v) => v.id !== meta.versionId);
+								break;
+							case "rename":
+								newVersions = value.versions.map((v) => v.id === meta.versionId ? {
+									...v,
+									name: meta.name ?? v.name
+								} : v);
+								break;
+							case "restore": return value;
+							case "init": {
+								const versions = meta.versions;
+								return createInitialState(versions);
+							}
+							default: return value;
+						}
+						if (onVersionsChange) onVersionsChange(newVersions);
+						if (storage) {
+							const result = storage.save(newVersions);
+							if (result && typeof result.then === "function") result.catch((err) => {
+								console.error("[VersionHistory] Failed to save versions to storage:", err);
+							});
+						}
+						return createInitialState(newVersions);
+					}
+				},
+				view(editorView) {
+					currentEditorState = editorView.state;
+					currentDispatch = editorView.dispatch.bind(editorView);
+					if (storage) {
+						const loadResult = storage.load();
+						if (loadResult && typeof loadResult.then === "function") loadResult.then((loaded) => {
+							if (loaded && currentDispatch && currentEditorState) {
+								const tr = currentEditorState.tr.setMeta(versionHistoryKey, {
+									type: "init",
+									versions: loaded
+								});
+								currentDispatch(tr);
+							}
+						});
+						else if (loadResult) {
+							const tr = editorView.state.tr.setMeta(versionHistoryKey, {
+								type: "init",
+								versions: loadResult
+							});
+							editorView.dispatch(tr);
+						}
+					}
+					if (autoSaveInterval > 0) autoSaveTimer = setInterval(() => {
+						if (currentEditorState && currentDispatch) {
+							const tr = currentEditorState.tr.setMeta(versionHistoryKey, {
+								type: "save",
+								name: `自动保存 ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}`
+							});
+							currentDispatch(tr);
+						}
+					}, autoSaveInterval);
+					return {
+						update(view) {
+							currentEditorState = view.state;
+							currentDispatch = view.dispatch.bind(view);
+						},
+						destroy() {
+							if (autoSaveTimer) {
+								clearInterval(autoSaveTimer);
+								autoSaveTimer = null;
+							}
+							currentEditorState = null;
+							currentDispatch = null;
+						}
+					};
+				}
+			})];
+		}
+	};
+}
+function createLocalStorage(key = "mibao-editor-versions") {
+	return {
+		save(versions) {
+			try {
+				localStorage.setItem(key, JSON.stringify(versions));
+			} catch (err) {
+				console.error("[VersionHistory] localStorage save failed:", err);
+			}
+		},
+		load() {
+			try {
+				const data = localStorage.getItem(key);
+				return data ? JSON.parse(data) : null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/toc-node-extension.ts
+function TocNodeExtension() {
+	return {
+		name: "tocNode",
+		type: "node",
+		addNodes() {
+			return { toc: {
+				group: "block",
+				atom: true,
+				attrs: {
+					items: { default: "[]" },
+					title: { default: "目录" }
+				},
+				toDOM(node) {
+					const items = JSON.parse(node.attrs.items);
+					const title = node.attrs.title;
+					const container = document.createElement("div");
+					container.className = "mi-toc";
+					container.contentEditable = "false";
+					const header = document.createElement("div");
+					header.className = "mi-toc-header";
+					const titleSpan = document.createElement("span");
+					titleSpan.className = "mi-toc-title";
+					titleSpan.textContent = title;
+					header.appendChild(titleSpan);
+					container.appendChild(header);
+					if (items.length === 0) {
+						const empty = document.createElement("div");
+						empty.className = "mi-toc-empty";
+						empty.textContent = "暂无标题，添加标题后将自动生成目录";
+						container.appendChild(empty);
+					} else {
+						const list = document.createElement("ul");
+						list.className = "mi-toc-list";
+						const minLevel = Math.min(...items.map((i) => i.level));
+						items.forEach((item) => {
+							const li = document.createElement("li");
+							li.className = `mi-toc-item mi-toc-level-${item.level}`;
+							li.style.paddingLeft = `${(item.level - minLevel) * 16}px`;
+							const a = document.createElement("a");
+							a.href = `#${item.id}`;
+							a.className = "mi-toc-link";
+							a.textContent = item.text;
+							li.appendChild(a);
+							list.appendChild(li);
+						});
+						container.appendChild(list);
+					}
+					const deleteBtn = document.createElement("button");
+					deleteBtn.className = "mi-toc-delete";
+					deleteBtn.textContent = "×";
+					deleteBtn.title = "删除目录";
+					container.appendChild(deleteBtn);
+					return container;
+				},
+				parseDOM: [{
+					tag: "div.mi-toc",
+					getAttrs(dom) {
+						const el = dom;
+						const titleEl = el.querySelector(".mi-toc-title");
+						return {
+							items: el.getAttribute("data-items") || "[]",
+							title: titleEl?.textContent || "目录"
+						};
+					}
+				}]
+			} };
+		},
+		addCommands() {
+			return { insertTocNode: (...args) => {
+				const attrs = args[0];
+				return (state, dispatch) => {
+					const tocType = state.schema.nodes["toc"];
+					if (!tocType) return false;
+					const { from, to } = state.selection;
+					const node = tocType.create({
+						items: attrs?.items || "[]",
+						title: attrs?.title || "目录"
+					});
+					if (dispatch) dispatch(state.tr.replaceWith(from, to, node).scrollIntoView());
+					return true;
+				};
+			} };
+		},
+		addPlugins() {
+			return [new require_dist.Plugin({ props: { handleDOMEvents: { click(view, event) {
+				const target = event.target;
+				if (target.classList.contains("mi-toc-delete")) {
+					event.preventDefault();
+					event.stopPropagation();
+					const toc = target.closest(".mi-toc");
+					if (!toc || !view.dom.contains(toc)) return false;
+					const pos = view.posAtDOM(toc, 0);
+					const node = view.state.doc.nodeAt(pos);
+					if (!node || node.type.name !== "toc") return false;
+					const tr = view.state.tr.delete(pos, pos + node.nodeSize);
+					view.dispatch(tr);
+					return true;
+				}
+				if (target.classList.contains("mi-toc-link")) {
+					event.preventDefault();
+					const href = target.getAttribute("href");
+					if (!href || !href.startsWith("#")) return false;
+					const id = href.slice(1);
+					const targetEl = document.getElementById(id);
+					if (targetEl) targetEl.scrollIntoView({
+						behavior: "smooth",
+						block: "start"
+					});
+					return true;
+				}
+				return false;
+			} } } })];
+		}
+	};
+}
+//#endregion
+//#region src/extensions/code-block-enhanced-extension.ts
+var codeBlockKey = new require_dist.PluginKey("codeBlockEnhanced");
+var DEFAULT_LANGUAGES = [
+	"javascript",
+	"typescript",
+	"python",
+	"java",
+	"cpp",
+	"c",
+	"go",
+	"rust",
+	"html",
+	"css",
+	"scss",
+	"json",
+	"yaml",
+	"markdown",
+	"bash",
+	"sql",
+	"php",
+	"ruby",
+	"swift",
+	"kotlin",
+	"xml",
+	"dockerfile",
+	"plaintext"
+];
+var CodeBlockNodeView = class {
+	constructor(node, view, getPos, _decorations, languages) {
+		this.node = node;
+		this.view = view;
+		this.getPos = getPos;
+		this.languages = languages;
+		const language = node.attrs.language;
+		this.dom = document.createElement("div");
+		this.dom.className = "mi-code-block";
+		this.dom.setAttribute("data-language", language);
+		const header = document.createElement("div");
+		header.className = "mi-code-block-header";
+		const langSelect = document.createElement("select");
+		langSelect.className = "mi-code-block-lang";
+		languages.forEach((lang) => {
+			const option = document.createElement("option");
+			option.value = lang;
+			option.textContent = lang;
+			if (lang === language) option.selected = true;
+			langSelect.appendChild(option);
+		});
+		langSelect.addEventListener("mousedown", (e) => {
+			e.stopPropagation();
+		});
+		langSelect.addEventListener("change", () => {
+			const pos = this.getPos();
+			if (pos === void 0) return;
+			const currentNode = this.view.state.doc.nodeAt(pos);
+			if (!currentNode || currentNode.type.name !== "code_block") return;
+			const tr = this.view.state.tr.setNodeMarkup(pos, null, {
+				...currentNode.attrs,
+				language: langSelect.value
+			});
+			this.view.dispatch(tr);
+		});
+		const copyBtn = document.createElement("button");
+		copyBtn.className = "mi-code-block-copy";
+		copyBtn.textContent = "复制";
+		copyBtn.title = "复制代码";
+		copyBtn.addEventListener("mousedown", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+		});
+		copyBtn.addEventListener("click", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+			const pos = this.getPos();
+			if (pos === void 0) return;
+			const currentNode = this.view.state.doc.nodeAt(pos);
+			if (!currentNode) return;
+			const text = currentNode.textContent || "";
+			navigator.clipboard.writeText(text).then(() => {
+				copyBtn.textContent = "已复制 ✓";
+				setTimeout(() => {
+					copyBtn.textContent = "复制";
+				}, 2e3);
+			}).catch(() => {
+				try {
+					const textarea = document.createElement("textarea");
+					textarea.value = text;
+					textarea.style.cssText = "position:fixed;left:-9999px;top:-9999px;opacity:0";
+					document.body.appendChild(textarea);
+					textarea.select();
+					document.execCommand("copy");
+					document.body.removeChild(textarea);
+				} catch {}
+				copyBtn.textContent = "已复制 ✓";
+				setTimeout(() => {
+					copyBtn.textContent = "复制";
+				}, 2e3);
+			});
+		});
+		header.appendChild(langSelect);
+		header.appendChild(copyBtn);
+		const deleteBtn = document.createElement("button");
+		deleteBtn.className = "mi-code-block-delete";
+		deleteBtn.textContent = "×";
+		deleteBtn.title = "删除代码块";
+		deleteBtn.addEventListener("mousedown", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+		});
+		deleteBtn.addEventListener("click", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+			const pos = this.getPos();
+			if (pos === void 0) return;
+			const currentNode = this.view.state.doc.nodeAt(pos);
+			if (!currentNode || currentNode.type.name !== "code_block") return;
+			const tr = this.view.state.tr.delete(pos, pos + currentNode.nodeSize);
+			this.view.dispatch(tr);
+		});
+		header.appendChild(deleteBtn);
+		const pre = document.createElement("pre");
+		pre.className = "mi-code-block-pre";
+		const codeEl = document.createElement("code");
+		codeEl.className = `language-${language}`;
+		codeEl.spellcheck = false;
+		this.contentDOM = codeEl;
+		pre.appendChild(codeEl);
+		this.dom.appendChild(header);
+		this.dom.appendChild(pre);
+	}
+	update(node) {
+		if (node.type !== this.node.type) return false;
+		this.node = node;
+		const language = node.attrs.language;
+		this.dom.setAttribute("data-language", language);
+		const codeEl = this.contentDOM;
+		codeEl.className = `language-${language}`;
+		const select = this.dom.querySelector(".mi-code-block-lang");
+		if (select && select.value !== language) select.value = language;
+		return true;
+	}
+	stopEvent() {
+		return false;
+	}
+	ignoreMutation() {
+		return false;
+	}
+};
+function CodeBlockEnhancedExtension(config) {
+	const defaultLanguage = config?.defaultLanguage || "plaintext";
+	const languages = config?.languages || DEFAULT_LANGUAGES;
+	return {
+		name: "codeBlockEnhanced",
+		type: "node",
+		addNodes() {
+			return { code_block: {
+				group: "block",
+				content: "text*",
+				marks: "",
+				code: true,
+				defining: true,
+				attrs: { language: { default: defaultLanguage } },
+				toDOM(node) {
+					return [
+						"div",
+						{
+							class: "mi-code-block",
+							"data-language": node.attrs.language
+						},
+						[
+							"div",
+							{ class: "mi-code-block-header" },
+							["select", { class: "mi-code-block-lang" }],
+							[
+								"button",
+								{ class: "mi-code-block-copy" },
+								"复制"
+							],
+							[
+								"button",
+								{ class: "mi-code-block-delete" },
+								"×"
+							]
+						],
+						[
+							"pre",
+							{ class: "mi-code-block-pre" },
+							[
+								"code",
+								{
+									class: `language-${node.attrs.language}`,
+									spellcheck: "false"
+								},
+								0
+							]
+						]
+					];
+				},
+				parseDOM: [{
+					tag: "div.mi-code-block",
+					getAttrs(dom) {
+						const el = dom;
+						return { language: el.querySelector(".mi-code-block-lang")?.value || el.getAttribute("data-language") || defaultLanguage };
+					},
+					getContent: (dom, schema) => {
+						const text = dom.querySelector("code")?.textContent || "";
+						return require_dist.Fragment.from(schema.text(text));
+					},
+					preserveWhitespace: "full"
+				}]
+			} };
+		},
+		addCommands() {
+			return {
+				codeBlock: (...args) => {
+					const language = args[0] || defaultLanguage;
+					return (state, dispatch) => {
+						const nt = state.schema.nodes["code_block"];
+						if (!nt) return false;
+						const { $from } = state.selection;
+						if ($from.parent.type === nt) {
+							const paraType = state.schema.nodes["paragraph"];
+							if (!paraType) return false;
+							return require_dist.setBlockType(paraType)(state, dispatch);
+						}
+						return require_dist.setBlockType(nt, { language })(state, dispatch);
+					};
+				},
+				setCodeBlockLanguage: (...args) => {
+					const language = args[0];
+					return (state, dispatch) => {
+						const { $from } = state.selection;
+						const nt = state.schema.nodes["code_block"];
+						if (!nt) return false;
+						let codeBlockPos = -1;
+						for (let d = $from.depth; d > 0; d--) if ($from.node(d).type === nt) {
+							codeBlockPos = $from.before(d);
+							break;
+						}
+						if (codeBlockPos < 0) return false;
+						if (dispatch) {
+							const node = state.doc.nodeAt(codeBlockPos);
+							if (!node) return false;
+							dispatch(state.tr.setNodeMarkup(codeBlockPos, null, {
+								...node.attrs,
+								language
+							}));
+						}
+						return true;
+					};
+				},
+				deleteCodeBlock: () => {
+					return (state, dispatch) => {
+						const { $from } = state.selection;
+						const nt = state.schema.nodes["code_block"];
+						if (!nt) return false;
+						let codeBlockPos = -1;
+						for (let d = $from.depth; d > 0; d--) if ($from.node(d).type === nt) {
+							codeBlockPos = $from.before(d);
+							break;
+						}
+						if (codeBlockPos < 0) return false;
+						if (dispatch) {
+							const node = state.doc.nodeAt(codeBlockPos);
+							if (!node) return false;
+							dispatch(state.tr.delete(codeBlockPos, codeBlockPos + node.nodeSize));
+						}
+						return true;
+					};
+				}
+			};
+		},
+		addKeyboardShortcuts() {
+			return {
+				"Mod-Shift-c": (state, dispatch) => {
+					const nt = state.schema.nodes["code_block"];
+					if (!nt) return false;
+					const { $from } = state.selection;
+					if ($from.parent.type === nt) {
+						const paraType = state.schema.nodes["paragraph"];
+						if (!paraType) return false;
+						return require_dist.setBlockType(paraType)(state, dispatch);
+					}
+					return require_dist.setBlockType(nt)(state, dispatch);
+				},
+				"Enter": (state, dispatch) => {
+					const nt = state.schema.nodes["code_block"];
+					if (!nt) return false;
+					const { $from } = state.selection;
+					if ($from.parent.type !== nt) return false;
+					if ($from.parent.content.size > 0) return false;
+					const paraType = state.schema.nodes["paragraph"];
+					if (!paraType) return false;
+					return require_dist.setBlockType(paraType)(state, dispatch);
+				},
+				"Backspace": (state, dispatch) => {
+					const nt = state.schema.nodes["code_block"];
+					if (!nt) return false;
+					const { $from } = state.selection;
+					if ($from.parent.type !== nt) return false;
+					if ($from.parent.content.size > 0) return false;
+					const paraType = state.schema.nodes["paragraph"];
+					if (!paraType) return false;
+					return require_dist.setBlockType(paraType)(state, dispatch);
+				}
+			};
+		},
+		addPlugins() {
+			return [inputRules({ rules: [new InputRule(/^```(\w*)$/, (state, match, start, end) => {
+				const nt = state.schema.nodes["code_block"];
+				if (!nt) return null;
+				const language = match[1] || defaultLanguage;
+				const tr = state.tr;
+				tr.delete(start, end);
+				const range = tr.doc.resolve(start).blockRange();
+				if (!range) return null;
+				tr.setBlockType(range.start, range.end, nt, { language });
+				return tr;
+			})] }), new require_dist.Plugin({
+				key: codeBlockKey,
+				props: { nodeViews: { code_block(node, view, getPos, decorations) {
+					return new CodeBlockNodeView(node, view, getPos, decorations, languages);
+				} } }
+			})];
+		}
+	};
+}
+//#endregion
+//#region src/extensions/dark-mode-extension.ts
+var darkModeKey = new require_dist.PluginKey("darkMode");
+function DarkModeExtension(config) {
+	const defaultDark = config?.defaultDark ?? false;
+	return {
+		name: "darkMode",
+		type: "extension",
+		addPlugins() {
+			return [new require_dist.Plugin({
+				key: darkModeKey,
+				state: {
+					init() {
+						return { isDark: defaultDark };
+					},
+					apply(tr, prev) {
+						const meta = tr.getMeta(darkModeKey);
+						if (meta?.type === "toggle") {
+							const isDark = !prev.isDark;
+							if (config?.onChange) setTimeout(() => config.onChange(isDark), 0);
+							return { isDark };
+						}
+						if (meta?.type === "set") {
+							const isDark = !!meta.isDark;
+							if (config?.onChange) setTimeout(() => config.onChange(isDark), 0);
+							return { isDark };
+						}
+						return prev;
+					}
+				},
+				props: { attributes(state) {
+					if (darkModeKey.getState(state)?.isDark) return {
+						"data-theme": "dark",
+						"class": "mi-dark-mode"
+					};
+					return {};
+				} }
+			})];
+		},
+		addCommands() {
+			return {
+				toggleDarkMode: () => (state, dispatch) => {
+					if (dispatch) dispatch(state.tr.setMeta(darkModeKey, { type: "toggle" }));
+					return true;
+				},
+				setDarkMode: (...args) => {
+					const isDark = args[0];
+					return (state, dispatch) => {
+						if (dispatch) dispatch(state.tr.setMeta(darkModeKey, {
+							type: "set",
+							isDark
+						}));
+						return true;
+					};
+				}
+			};
+		}
+	};
+}
+function isDarkMode(state) {
+	return darkModeKey.getState(state)?.isDark ?? false;
+}
+//#endregion
+//#region src/extensions/html-block-extension.ts
+/**
+* HTMLBlockExtension: supports parsing and preserving arbitrary HTML block elements
+* like div, section, etc. This is useful for pasting complex HTML content from
+* external sources (e.g., 135编辑器, wangEditor) while preserving the structure.
+*/
+function HTMLBlockExtension() {
+	return {
+		name: "html_block",
+		type: "node",
+		addNodes() {
+			return { html_block: {
+				group: "block",
+				content: "block*",
+				atom: false,
+				defining: true,
+				attrs: {
+					tagName: { default: "div" },
+					className: { default: "" },
+					style: { default: "" },
+					dataAttributes: { default: {} }
+				},
+				toDOM(node) {
+					const { tagName, className, style, dataAttributes } = node.attrs;
+					const attrs = {};
+					if (className) attrs.class = className;
+					if (style) attrs.style = style;
+					if (dataAttributes && typeof dataAttributes === "object") {
+						for (const [key, value] of Object.entries(dataAttributes)) if (value !== null && value !== void 0) attrs[key] = String(value);
+					}
+					return [
+						tagName || "div",
+						attrs,
+						0
+					];
+				},
+				parseDOM: [
+					{
+						tag: "div:not(.mi-card):not(.mi-product-card):not(.mi-code-block):not(.mi-toc):not(.mi-task-list):not(.mi-task-item)",
+						getAttrs(dom) {
+							return extractAttributes(dom, "div");
+						}
+					},
+					{
+						tag: "section",
+						getAttrs(dom) {
+							return extractAttributes(dom, "section");
+						}
+					},
+					{
+						tag: "article",
+						getAttrs(dom) {
+							return extractAttributes(dom, "article");
+						}
+					},
+					{
+						tag: "aside",
+						getAttrs(dom) {
+							return extractAttributes(dom, "aside");
+						}
+					},
+					{
+						tag: "main",
+						getAttrs(dom) {
+							return extractAttributes(dom, "main");
+						}
+					},
+					{
+						tag: "header",
+						getAttrs(dom) {
+							return extractAttributes(dom, "header");
+						}
+					},
+					{
+						tag: "footer",
+						getAttrs(dom) {
+							return extractAttributes(dom, "footer");
+						}
+					},
+					{
+						tag: "nav",
+						getAttrs(dom) {
+							return extractAttributes(dom, "nav");
+						}
+					}
+				]
+			} };
+		}
+	};
+}
+/**
+* Extract attributes from a DOM element for the html_block node
+*/
+function extractAttributes(el, tagName) {
+	const className = el.className || "";
+	const style = el.getAttribute("style") || "";
+	const dataAttributes = {};
+	for (const attr of Array.from(el.attributes)) if (attr.name.startsWith("data-")) dataAttributes[attr.name] = attr.value;
+	return {
+		tagName,
+		className,
+		style,
+		dataAttributes
+	};
+}
+//#endregion
+exports.BackgroundColorExtension = BackgroundColorExtension;
+exports.BlockquoteExtension = BlockquoteExtension;
+exports.BoldExtension = BoldExtension;
+exports.BulletListExtension = BulletListExtension;
+exports.CardExtension = CardExtension;
+exports.CodeBlockEnhancedExtension = CodeBlockEnhancedExtension;
+exports.CodeBlockExtension = CodeBlockExtension;
+exports.CodeExtension = CodeExtension;
+exports.DEFAULT_COLORS = DEFAULT_COLORS;
+exports.DEFAULT_FONT_FAMILIES = DEFAULT_FONT_FAMILIES;
+exports.DEFAULT_FONT_SIZES = DEFAULT_FONT_SIZES;
+exports.DEFAULT_LINE_HEIGHTS = DEFAULT_LINE_HEIGHTS;
+exports.DarkModeExtension = DarkModeExtension;
+exports.DocExtension = DocExtension;
+exports.FontFamilyExtension = FontFamilyExtension;
+exports.FontSizeExtension = FontSizeExtension;
+exports.HTMLBlockExtension = HTMLBlockExtension;
+exports.HardBreakExtension = HardBreakExtension;
+exports.HeadingExtension = HeadingExtension;
+exports.HistoryExtension = HistoryExtension;
+exports.HorizontalRuleExtension = HorizontalRuleExtension;
+exports.ImageExtension = ImageExtension;
+exports.ImageUploadExtension = ImageUploadExtension;
+exports.ItalicExtension = ItalicExtension;
+exports.LineHeightExtension = LineHeightExtension;
+exports.LinkExtension = LinkExtension;
+exports.OrderedListExtension = OrderedListExtension;
+exports.ParagraphExtension = ParagraphExtension;
+exports.PlaceholderExtension = PlaceholderExtension;
+exports.ProductCardExtension = ProductCardExtension;
+exports.StrikeExtension = StrikeExtension;
+exports.TableExtension = TableExtension;
+exports.TableOfContentsExtension = require_toc_extension.TableOfContentsExtension;
+exports.TaskListExtension = TaskListExtension;
+exports.TextColorExtension = TextColorExtension;
+exports.TextExtension = TextExtension;
+exports.TocNodeExtension = TocNodeExtension;
+exports.UnderlineExtension = UnderlineExtension;
+exports.VersionHistoryExtension = VersionHistoryExtension;
+exports.WordCountExtension = require_toc_extension.WordCountExtension;
+exports.createLocalStorage = createLocalStorage;
+exports.deleteVersion = deleteVersion;
+exports.getTableOfContents = require_toc_extension.getTableOfContents;
+exports.getVersions = getVersions;
+exports.getWordCountStats = require_toc_extension.getWordCountStats;
+exports.isDarkMode = isDarkMode;
+exports.renameVersion = renameVersion;
+exports.restoreVersion = restoreVersion;
+exports.saveVersion = saveVersion;
+
+//# sourceMappingURL=index.cjs.js.map