@haklex/rich-editor 0.0.79 → 0.0.81

package/dist/SubmitShortcutPlugin-6IvsbZD-.js

@@ -0,0 +1,1463 @@
+import { c as setCodeBlockCursorIntent, o as $createCodeBlockEditNode, s as $createBannerEditNode, t as getResolvedEditNodes } from "./node-registry-CeVi2y9f.js";
+import { C as OPEN_IMAGE_UPLOAD_DIALOG_COMMAND, T as FootnoteNode, _ as $createKaTeXBlockNode, b as $createImageNode, d as $createMentionNode, g as KaTeXInlineNode, j as extractTextContent, k as AlertQuoteNode, m as $createKaTeXInlineNode, o as $createSpoilerNode, p as MentionNode, s as SpoilerNode, w as $createFootnoteNode, y as KaTeXBlockNode } from "./theme-DHOUKKSr.js";
+import { a as FootnoteDefinitionsProvider, n as computeImageMeta } from "./KaTeXRenderer-BsyRH5_t.js";
+import { D as BannerNode, _ as $createDetailsNode, a as $createRubyNode, b as CodeBlockNode, f as $isGridContainerNode, g as FootnoteSectionNode, h as $isFootnoteSectionNode, m as $createFootnoteSectionNode, s as RubyNode, v as DetailsNode } from "./config-tfg1FWhG.js";
+import { t as $createAlertQuoteEditNode } from "./AlertQuoteEditNode-BDoonB4u.js";
+import { n as probeFavicon, t as getHostname } from "./favicon-DIWusrrw.js";
+import { CheckListPlugin } from "@lexical/react/LexicalCheckListPlugin";
+import { LinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
+import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
+import { AutoLinkNode, LinkNode, createLinkMatcherWithRegExp, registerAutoLink } from "@lexical/link";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { createContext, use, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { $createQuoteNode, $isQuoteNode, DRAG_DROP_PASTE, QuoteNode } from "@lexical/rich-text";
+import { $addUpdateTag, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createTextNode, $getRoot, $getSelection, $getState, $insertNodes, $isDecoratorNode, $isElementNode, $isNodeSelection, $isParagraphNode, $isRangeSelection, $isRootNode, $isTextNode, $nodesOfType, $parseSerializedNode, $setSelection, $setState, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, IS_CODE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, KEY_ENTER_COMMAND, PASTE_COMMAND, createEditor, createState } from "lexical";
+import { $createHorizontalRuleNode, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/extension";
+import { CODE_BLOCK_NODE_TRANSFORMER, CONTAINER_TRANSFORMER, FOOTNOTE_SECTION_TRANSFORMER, FOOTNOTE_TRANSFORMER, GIT_ALERT_TRANSFORMER, HORIZONTAL_RULE_BLOCK_TRANSFORMER, IMAGE_BLOCK_TRANSFORMER, INSERT_TRANSFORMER, KATEX_BLOCK_TRANSFORMER, KATEX_INLINE_TRANSFORMER, LINK_CARD_BLOCK_TRANSFORMER, MENTION_TRANSFORMER, MERMAID_BLOCK_TRANSFORMER, RUBY_TRANSFORMER, SPOILER_TRANSFORMER, SUBSCRIPT_TRANSFORMER, SUPERSCRIPT_TRANSFORMER, TABLE_BLOCK_TRANSFORMER, VIDEO_BLOCK_TRANSFORMER } from "@haklex/rich-headless/transformers";
+import { $convertFromMarkdownString, CHECK_LIST, CODE, QUOTE, TRANSFORMERS } from "@lexical/markdown";
+import { $createTableCellNode, $createTableNode, $createTableRowNode, TableCellHeaderStates } from "@lexical/table";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Check, Info, Link2, Upload } from "lucide-react";
+import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
+import { nanoid } from "nanoid";
+import { ActionBar, ActionButton, Dialog, DialogPopup, DialogTitle, SegmentedControl } from "@haklex/rich-editor-ui";
+//#region src/plugins/AutoLinkPlugin.tsx
+var DEFAULT_MATCHERS = [createLinkMatcherWithRegExp(/https?:\/\/(?:www\.)?[\w#%+.:=@~-]{1,256}\.[A-Za-z]{2}[\w#%&()+./:=?@~-]*/), createLinkMatcherWithRegExp(/(?:[\w%+.-]+@[\d.a-z-]+\.[a-z]{2,})/i, (text) => `mailto:${text}`)];
+function AutoLinkPlugin({ matchers }) {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		return registerAutoLink(editor, {
+			matchers: matchers ?? DEFAULT_MATCHERS,
+			changeHandlers: [],
+			excludeParents: []
+		});
+	}, [editor, matchers]);
+	return null;
+}
+//#endregion
+//#region src/plugins/BlockExitPlugin.tsx
+function selectDecoratorNode(node, cursorPlacement = "start") {
+	if (node.getType() === "code-block") setCodeBlockCursorIntent(node.getKey(), cursorPlacement);
+	const selection = $createNodeSelection();
+	selection.add(node.getKey());
+	$setSelection(selection);
+}
+function isAtTopLevelBoundary(selection, direction) {
+	const point = selection.anchor;
+	const topLevel = point.getNode().getTopLevelElementOrThrow();
+	const pointNode = point.getNode();
+	if (point.type === "text") {
+		if (!$isTextNode(pointNode)) return false;
+		const expectedOffset = direction === "start" ? 0 : pointNode.getTextContentSize();
+		if (point.offset !== expectedOffset) return false;
+	} else {
+		if (!$isElementNode(pointNode)) return false;
+		const expectedOffset = direction === "start" ? 0 : pointNode.getChildrenSize();
+		if (point.offset !== expectedOffset) return false;
+	}
+	let current = pointNode;
+	while (current && current !== topLevel) {
+		if ((direction === "start" ? current.getPreviousSibling() : current.getNextSibling()) !== null) return false;
+		current = current.getParent();
+	}
+	return current === topLevel;
+}
+function isSingleLineParagraph(node) {
+	return $isParagraphNode(node) && !node.getTextContent().includes("\n");
+}
+function getOutermostNodeWithinTopLevel(node, topLevel) {
+	let current = node;
+	while (current.getParent() !== topLevel) {
+		const parent = current.getParent();
+		if (!parent) break;
+		current = parent;
+	}
+	return current;
+}
+function exitInlineCodeAtLineEnd(selection) {
+	if (!selection.isCollapsed() || selection.anchor.type !== "text") return false;
+	const anchorNode = selection.anchor.getNode();
+	if (!$isTextNode(anchorNode) || !anchorNode.hasFormat("code")) return false;
+	if (selection.anchor.offset !== anchorNode.getTextContentSize()) return false;
+	if (!isAtTopLevelBoundary(selection, "end")) return false;
+	const topLevel = anchorNode.getTopLevelElementOrThrow();
+	const exitOffset = getOutermostNodeWithinTopLevel(anchorNode, topLevel).getIndexWithinParent() + 1;
+	selection.anchor.set(topLevel.getKey(), exitOffset, "element");
+	selection.focus.set(topLevel.getKey(), exitOffset, "element");
+	selection.setFormat(anchorNode.getFormat() & ~IS_CODE);
+	selection.setStyle(anchorNode.getStyle());
+	return true;
+}
+function BlockExitPlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		const unregisterArrowRight = editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, (event) => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection)) return false;
+			if (!exitInlineCodeAtLineEnd(selection)) return false;
+			event?.preventDefault();
+			return true;
+		}, COMMAND_PRIORITY_CRITICAL);
+		const unregisterArrowDown = editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+			const anchorNode = selection.anchor.getNode();
+			const topLevelElement = anchorNode.getTopLevelElementOrThrow();
+			const shouldSelectNextDecorator = isAtTopLevelBoundary(selection, "end") || isSingleLineParagraph(topLevelElement);
+			if (!$isQuoteNode(topLevelElement) && shouldSelectNextDecorator) {
+				const next = topLevelElement.getNextSibling();
+				if (next && $isDecoratorNode(next) && next.isKeyboardSelectable()) {
+					event?.preventDefault();
+					selectDecoratorNode(next, "start");
+					return true;
+				}
+			}
+			const element = $isElementNode(anchorNode) ? anchorNode : anchorNode.getParentOrThrow();
+			let quoteChild = element;
+			let quoteNode = null;
+			let current = element;
+			while (current) {
+				const parent = current.getParent();
+				if (!parent || $isRootNode(parent)) break;
+				if ($isQuoteNode(parent)) {
+					quoteNode = parent;
+					quoteChild = current;
+					break;
+				}
+				current = parent;
+			}
+			if (!quoteNode) return false;
+			if (quoteChild.getNextSibling() !== null) return false;
+			if (!$isParagraphNode(quoteChild) || quoteChild.getTextContent() !== "") return false;
+			event?.preventDefault();
+			let next = quoteNode.getNextSibling();
+			if (!next) {
+				next = $createParagraphNode();
+				quoteNode.insertAfter(next);
+			}
+			next.selectStart();
+			return true;
+		}, COMMAND_PRIORITY_CRITICAL);
+		const unregisterCmdEnter = editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+			if (!event?.metaKey && !event?.ctrlKey) return false;
+			const selection = $getSelection();
+			if ($isNodeSelection(selection)) {
+				const nodes = selection.getNodes();
+				if (nodes.length !== 1) return false;
+				const node = nodes[0];
+				if (!$isDecoratorNode(node)) return false;
+				event.preventDefault();
+				let next = node.getNextSibling();
+				if (!next) {
+					next = $createParagraphNode();
+					node.insertAfter(next);
+				}
+				if ($isElementNode(next)) next.selectStart();
+				else if ($isDecoratorNode(next)) selectDecoratorNode(next, "start");
+				return true;
+			}
+			if (!$isRangeSelection(selection)) return false;
+			const topLevelElement = selection.anchor.getNode().getTopLevelElementOrThrow();
+			if ($isParagraphNode(topLevelElement)) return false;
+			event.preventDefault();
+			let next = topLevelElement.getNextSibling();
+			if (!next || !$isParagraphNode(next)) {
+				next = $createParagraphNode();
+				topLevelElement.insertAfter(next);
+			}
+			next.selectStart();
+			return true;
+		}, COMMAND_PRIORITY_CRITICAL);
+		function handleDeleteDecorator(event) {
+			const selection = $getSelection();
+			if (!$isNodeSelection(selection)) return false;
+			const nodes = selection.getNodes();
+			if (nodes.length !== 1) return false;
+			const node = nodes[0];
+			if (!$isDecoratorNode(node)) return false;
+			event?.preventDefault();
+			const prev = node.getPreviousSibling();
+			const next = node.getNextSibling();
+			node.remove();
+			if (prev && $isElementNode(prev)) prev.selectEnd();
+			else if (prev && $isDecoratorNode(prev)) selectDecoratorNode(prev, "end");
+			else if (next && $isElementNode(next)) next.selectStart();
+			else if (next && $isDecoratorNode(next)) selectDecoratorNode(next, "start");
+			else {
+				const root = $getRoot();
+				if (root && $isElementNode(root)) {
+					const p = $createParagraphNode();
+					root.append(p);
+					p.selectStart();
+				}
+			}
+			return true;
+		}
+		const unregisterBackspace = editor.registerCommand(KEY_BACKSPACE_COMMAND, handleDeleteDecorator, COMMAND_PRIORITY_HIGH);
+		const unregisterDelete = editor.registerCommand(KEY_DELETE_COMMAND, handleDeleteDecorator, COMMAND_PRIORITY_HIGH);
+		const unregisterArrowUpDecorator = editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection) && selection.isCollapsed()) {
+				const topLevelElement = selection.anchor.getNode().getTopLevelElementOrThrow();
+				const shouldSelectPreviousDecorator = isAtTopLevelBoundary(selection, "start") || isSingleLineParagraph(topLevelElement);
+				if (!$isQuoteNode(topLevelElement) && shouldSelectPreviousDecorator) {
+					const prev = topLevelElement.getPreviousSibling();
+					if (prev && $isDecoratorNode(prev) && prev.isKeyboardSelectable()) {
+						event?.preventDefault();
+						selectDecoratorNode(prev, "end");
+						return true;
+					}
+				}
+			}
+			if (!$isNodeSelection(selection)) return false;
+			const nodes = selection.getNodes();
+			if (nodes.length !== 1) return false;
+			const node = nodes[0];
+			if (!$isDecoratorNode(node)) return false;
+			const prev = node.getPreviousSibling();
+			if (prev && $isElementNode(prev)) {
+				event?.preventDefault();
+				prev.selectEnd();
+				return true;
+			}
+			if (prev && $isDecoratorNode(prev)) {
+				event?.preventDefault();
+				selectDecoratorNode(prev, "end");
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL);
+		const unregisterArrowDownDecorator = editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
+			const selection = $getSelection();
+			if (!$isNodeSelection(selection)) return false;
+			const nodes = selection.getNodes();
+			if (nodes.length !== 1) return false;
+			const node = nodes[0];
+			if (!$isDecoratorNode(node)) return false;
+			const next = node.getNextSibling();
+			if (next && $isElementNode(next)) {
+				event?.preventDefault();
+				next.selectStart();
+				return true;
+			}
+			if (next && $isDecoratorNode(next)) {
+				event?.preventDefault();
+				selectDecoratorNode(next, "start");
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL);
+		return () => {
+			unregisterArrowRight();
+			unregisterArrowDown();
+			unregisterCmdEnter();
+			unregisterBackspace();
+			unregisterDelete();
+			unregisterArrowUpDecorator();
+			unregisterArrowDownDecorator();
+		};
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/transformers/horizontal-rule.ts
+var HORIZONTAL_RULE_REGEX = /^(---|\*\*\*|___)\s?$/;
+var HORIZONTAL_RULE_BLOCK_TRANSFORMER$1 = {
+	...HORIZONTAL_RULE_BLOCK_TRANSFORMER,
+	dependencies: [HorizontalRuleNode],
+	regExp: HORIZONTAL_RULE_REGEX,
+	replace: (parentNode) => {
+		const hrNode = $createHorizontalRuleNode();
+		const paragraph = $createParagraphNode();
+		parentNode.replace(hrNode);
+		hrNode.insertAfter(paragraph);
+		paragraph.selectStart();
+	}
+};
+//#endregion
+//#region src/plugins/HorizontalRulePlugin.tsx
+function HorizontalRulePlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		const unregisterInsert = editor.registerCommand(INSERT_HORIZONTAL_RULE_COMMAND, () => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection)) return false;
+			const topLevel = selection.focus.getNode().getTopLevelElement();
+			if (!topLevel) return false;
+			const hrNode = $createHorizontalRuleNode();
+			const paragraph = $createParagraphNode();
+			topLevel.insertAfter(hrNode);
+			hrNode.insertAfter(paragraph);
+			paragraph.selectStart();
+			return true;
+		}, COMMAND_PRIORITY_EDITOR);
+		const unregisterEnter = editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+			const selection = $getSelection();
+			if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+			const anchorNode = selection.anchor.getNode();
+			if (!$isTextNode(anchorNode)) return false;
+			const textContent = anchorNode.getTextContent();
+			if (!HORIZONTAL_RULE_REGEX.test(textContent)) return false;
+			const parentNode = anchorNode.getParent();
+			if (!parentNode) return false;
+			event?.preventDefault();
+			const hrNode = $createHorizontalRuleNode();
+			const paragraph = $createParagraphNode();
+			parentNode.replace(hrNode);
+			hrNode.insertAfter(paragraph);
+			paragraph.selectStart();
+			return true;
+		}, COMMAND_PRIORITY_LOW);
+		return () => {
+			unregisterInsert();
+			unregisterEnter();
+		};
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/transformers/alert.ts
+var ALERT_TYPE_MAP = {
+	NOTE: "note",
+	TIP: "tip",
+	IMPORTANT: "important",
+	WARNING: "warning",
+	CAUTION: "caution"
+};
+var GIT_ALERT_TRANSFORMER$1 = {
+	...GIT_ALERT_TRANSFORMER,
+	dependencies: [AlertQuoteNode],
+	regExp: /^>\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*$/,
+	replace: (parentNode, children, match) => {
+		const alertNode = $createAlertQuoteEditNode(ALERT_TYPE_MAP[match[1]] || "note", { root: {
+			children: [{
+				type: "paragraph",
+				children: children.map((child) => child.exportJSON()),
+				direction: null,
+				format: "",
+				indent: 0,
+				textFormat: 0,
+				textStyle: "",
+				version: 1
+			}],
+			direction: null,
+			format: "",
+			indent: 0,
+			type: "root",
+			version: 1
+		} });
+		parentNode.replace(alertNode);
+	}
+};
+//#endregion
+//#region src/transformers/code-block.ts
+function findCodeBlockKlass(nodes) {
+	return nodes.find((n) => n.getType?.() === "code-block") || CodeBlockNode;
+}
+var CODE_BLOCK_MULTILINE_TRANSFORMER = {
+	dependencies: [],
+	regExpEnd: {
+		optional: true,
+		regExp: /[\t ]*```$/
+	},
+	regExpStart: /^[\t ]*```([\w-]+)?/,
+	replace: (rootNode, _children, startMatch, _endMatch, linesInBetween, isImport) => {
+		const lang = startMatch[1] || "";
+		let code = "";
+		if (linesInBetween) {
+			const lines = [...linesInBetween];
+			while (lines.length > 0 && !lines[0].length) lines.shift();
+			while (lines.length > 0 && !lines.at(-1)?.length) lines.pop();
+			code = lines.join("\n");
+		}
+		const node = new (findCodeBlockKlass(getResolvedEditNodes()))(code, lang);
+		if (isImport || $isRootNode(rootNode)) rootNode.append(node);
+		else rootNode.replace(node);
+		const selection = $createNodeSelection();
+		selection.add(node.getKey());
+		$setSelection(selection);
+	},
+	type: "multiline-element"
+};
+//#endregion
+//#region src/transformers/container.ts
+var BANNER_TYPE_MAP = {
+	note: "note",
+	info: "note",
+	tip: "tip",
+	success: "tip",
+	important: "important",
+	warning: "warning",
+	warn: "warning",
+	error: "caution",
+	danger: "caution",
+	caution: "caution"
+};
+var CONTAINER_TRANSFORMER$1 = {
+	...CONTAINER_TRANSFORMER,
+	dependencies: [BannerNode, DetailsNode],
+	regExp: /^:::\s*(\w+)(?:\{([^}]*)\})?\s*$/,
+	replace: (parentNode, children, match) => {
+		const type = match[1];
+		const params = match[2];
+		if (type in BANNER_TYPE_MAP) {
+			const bannerType = BANNER_TYPE_MAP[type];
+			const banner = $createBannerEditNode(bannerType, { root: {
+				children: [{
+					type: "paragraph",
+					children: children.map((child) => child.exportJSON()),
+					direction: null,
+					format: "",
+					indent: 0,
+					textFormat: 0,
+					textStyle: "",
+					version: 1
+				}],
+				direction: null,
+				format: "",
+				indent: 0,
+				type: "root",
+				version: 1
+			} });
+			parentNode.replace(banner);
+			return;
+		}
+		if (type === "details") {
+			const summaryMatch = params?.match(/summary="([^"]*)"/);
+			const details = $createDetailsNode(summaryMatch ? summaryMatch[1] : "Details");
+			children.forEach((child) => {
+				details.append(child);
+			});
+			parentNode.replace(details);
+			return;
+		}
+		const paragraph = $createParagraphNode();
+		paragraph.append($createTextNode(`::: ${type}`));
+		children.forEach((child) => {
+			paragraph.append(child);
+		});
+		parentNode.replace(paragraph);
+	}
+};
+//#endregion
+//#region src/transformers/footnote.ts
+var FOOTNOTE_TRANSFORMER$1 = {
+	...FOOTNOTE_TRANSFORMER,
+	dependencies: [FootnoteNode],
+	replace: (textNode, match) => {
+		const footnoteNode = $createFootnoteNode(match[1]);
+		textNode.replace(footnoteNode);
+	}
+};
+var FOOTNOTE_SECTION_TRANSFORMER$1 = {
+	...FOOTNOTE_SECTION_TRANSFORMER,
+	dependencies: [FootnoteSectionNode],
+	regExp: /^\[\^(\w+)\]:[\t ]+(\S.*)$/,
+	replace: (parentNode, _children, match) => {
+		const identifier = match[1];
+		const content = match[2];
+		const root = parentNode.getParent();
+		if (root) {
+			const children = root.getChildren();
+			for (const child of children) if ($isFootnoteSectionNode(child)) {
+				child.setDefinition(identifier, content);
+				parentNode.remove();
+				return;
+			}
+		}
+		const sectionNode = $createFootnoteSectionNode({ [identifier]: content });
+		parentNode.replace(sectionNode);
+	}
+};
+//#endregion
+//#region src/transformers/katex.ts
+var KATEX_INLINE_TRANSFORMER$1 = {
+	...KATEX_INLINE_TRANSFORMER,
+	dependencies: [KaTeXInlineNode],
+	replace: (textNode, match) => {
+		const katexNode = $createKaTeXInlineNode(match[1]);
+		textNode.replace(katexNode);
+	}
+};
+var KATEX_BLOCK_TRANSFORMER$1 = {
+	...KATEX_BLOCK_TRANSFORMER,
+	dependencies: [KaTeXBlockNode],
+	replace: (textNode, match) => {
+		const katexNode = $createKaTeXBlockNode(match[1]);
+		textNode.replace(katexNode);
+	}
+};
+//#endregion
+//#region src/transformers/mention.ts
+var MENTION_TRANSFORMER$1 = {
+	...MENTION_TRANSFORMER,
+	dependencies: [MentionNode],
+	replace: (textNode, match) => {
+		const displayName = match[1] || void 0;
+		const mentionNode = $createMentionNode(match[2], match[3], displayName);
+		textNode.replace(mentionNode);
+	}
+};
+//#endregion
+//#region src/transformers/quote.ts
+var QUOTE_TRANSFORMER = {
+	dependencies: [QuoteNode],
+	export: (node, exportChildren) => {
+		if (!$isQuoteNode(node)) return null;
+		return exportChildren(node).split("\n").map((line) => `> ${line}`).join("\n");
+	},
+	regExp: /^>\s/,
+	replace: (parentNode, children, _match, isImport) => {
+		if (isImport) {
+			const previousNode = parentNode.getPreviousSibling();
+			if ($isQuoteNode(previousNode)) {
+				previousNode.splice(previousNode.getChildrenSize(), 0, [$createLineBreakNode(), ...children]);
+				parentNode.remove();
+				return;
+			}
+		}
+		const node = $createQuoteNode();
+		const paragraph = $createParagraphNode();
+		paragraph.append(...children);
+		node.append(paragraph);
+		parentNode.replace(node);
+		if (!isImport) paragraph.select(0, 0);
+	},
+	type: "element"
+};
+//#endregion
+//#region src/transformers/grid-container.ts
+function quoteAttr(value) {
+	return value.replaceAll("\"", "\\\"");
+}
+var GRID_CONTAINER_BLOCK_TRANSFORMER = {
+	dependencies: [],
+	export: (node) => {
+		if (!$isGridContainerNode(node)) return null;
+		const body = node.getCellStates().map((state) => extractTextContent(state)).map((content) => `::: cell\n${content}\n:::`).join("\n");
+		return `::: grid{cols=${node.getCols()} gap="${quoteAttr(node.getGap())}"}\n${body}\n:::`;
+	},
+	regExp: /\b\B/,
+	replace: () => {},
+	type: "element"
+};
+//#endregion
+//#region src/transformers/ruby.ts
+var RUBY_TRANSFORMER$1 = {
+	...RUBY_TRANSFORMER,
+	dependencies: [RubyNode],
+	replace: (textNode, match) => {
+		const rubyNode = $createRubyNode(match[2] ?? "");
+		const baseText = match[1] ?? "";
+		if (baseText) rubyNode.append($createTextNode(baseText));
+		textNode.replace(rubyNode);
+	}
+};
+//#endregion
+//#region src/transformers/spoiler.ts
+var SPOILER_TRANSFORMER$1 = {
+	...SPOILER_TRANSFORMER,
+	dependencies: [SpoilerNode],
+	replace: (textNode, match) => {
+		const spoilerNode = $createSpoilerNode();
+		spoilerNode.append($createTextNode(match[1]));
+		textNode.replace(spoilerNode);
+	}
+};
+//#endregion
+//#region src/transformers/table.ts
+var TABLE_ROW_REG_EXP = /^\|(.+)\|\s*$/;
+var TABLE_DIVIDER_REG_EXP = /^\|(?:\s*:?-+:?\s*\|)+\s*$/;
+function parseCells(row) {
+	const match = row.match(TABLE_ROW_REG_EXP);
+	if (!match) return [];
+	return match[1].split("|").map((c) => c.trim());
+}
+//#endregion
+//#region src/transformers/index.ts
+var ALL_TRANSFORMERS = [
+	SPOILER_TRANSFORMER$1,
+	MENTION_TRANSFORMER$1,
+	FOOTNOTE_TRANSFORMER$1,
+	INSERT_TRANSFORMER,
+	SUPERSCRIPT_TRANSFORMER,
+	SUBSCRIPT_TRANSFORMER,
+	RUBY_TRANSFORMER$1,
+	KATEX_INLINE_TRANSFORMER$1,
+	FOOTNOTE_SECTION_TRANSFORMER$1,
+	CONTAINER_TRANSFORMER$1,
+	GIT_ALERT_TRANSFORMER$1,
+	CHECK_LIST,
+	KATEX_BLOCK_TRANSFORMER$1,
+	IMAGE_BLOCK_TRANSFORMER,
+	VIDEO_BLOCK_TRANSFORMER,
+	CODE_BLOCK_NODE_TRANSFORMER,
+	CODE_BLOCK_MULTILINE_TRANSFORMER,
+	LINK_CARD_BLOCK_TRANSFORMER,
+	MERMAID_BLOCK_TRANSFORMER,
+	GRID_CONTAINER_BLOCK_TRANSFORMER,
+	HORIZONTAL_RULE_BLOCK_TRANSFORMER$1,
+	{
+		dependencies: [],
+		export: () => null,
+		handleImportAfterStartMatch({ lines, rootNode, startLineIndex }) {
+			if (startLineIndex + 1 >= lines.length) return null;
+			const dividerLine = lines[startLineIndex + 1];
+			if (!TABLE_DIVIDER_REG_EXP.test(dividerLine)) return null;
+			const headerCells = parseCells(lines[startLineIndex]);
+			if (headerCells.length === 0) return null;
+			let endLineIndex = startLineIndex + 1;
+			const dataRows = [];
+			for (let i = startLineIndex + 2; i < lines.length; i++) {
+				if (!TABLE_ROW_REG_EXP.test(lines[i])) break;
+				dataRows.push(parseCells(lines[i]));
+				endLineIndex = i;
+			}
+			const tableNode = $createTableNode();
+			const headerRow = $createTableRowNode();
+			for (const cell of headerCells) {
+				const cellNode = $createTableCellNode(TableCellHeaderStates.ROW);
+				const p = $createParagraphNode();
+				p.append($createTextNode(cell));
+				cellNode.append(p);
+				headerRow.append(cellNode);
+			}
+			tableNode.append(headerRow);
+			for (const row of dataRows) {
+				const rowNode = $createTableRowNode();
+				for (let i = 0; i < headerCells.length; i++) {
+					const cellNode = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
+					const p = $createParagraphNode();
+					p.append($createTextNode(row[i] ?? ""));
+					cellNode.append(p);
+					rowNode.append(cellNode);
+				}
+				tableNode.append(rowNode);
+			}
+			rootNode.append(tableNode);
+			return [true, endLineIndex];
+		},
+		regExpEnd: {
+			optional: true,
+			regExp: TABLE_ROW_REG_EXP
+		},
+		regExpStart: TABLE_ROW_REG_EXP,
+		replace: () => {},
+		type: "multiline-element"
+	},
+	TABLE_BLOCK_TRANSFORMER,
+	QUOTE_TRANSFORMER,
+	...TRANSFORMERS.filter((t) => t !== QUOTE && t !== CODE)
+];
+//#endregion
+//#region src/plugins/MarkdownPastePlugin.tsx
+function getVSCodePasteData(clipboardData) {
+	const raw = clipboardData.getData("vscode-editor-data");
+	if (!raw) return null;
+	try {
+		return { language: JSON.parse(raw).mode || "text" };
+	} catch {
+		return null;
+	}
+}
+function hasRichHTML(clipboardData) {
+	const html = clipboardData.getData("text/html");
+	if (!html) return false;
+	if (/data-vscode|vscode-/i.test(html)) return false;
+	return new DOMParser().parseFromString(html, "text/html").body.querySelectorAll("strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]").length > 0;
+}
+function detectMarkdown(text) {
+	let score = 0;
+	if (/^#{1,6}\s+\S/m.test(text)) score += 5;
+	if (/^```[\w-]*$/m.test(text)) score += 5;
+	if (/\[[^\]]+\]\([^)]+\)/.test(text)) score += 4;
+	if (/!\[[^\]]*\]\([^)]+\)/.test(text)) score += 5;
+	if (/^\|.+\|$/m.test(text) && /^\|[\s:|-]+\|$/m.test(text)) score += 5;
+	if (/^>\s*\[!(?:note|tip|warning|caution|important)\]/im.test(text)) score += 5;
+	if (/^[*-]\s+\[[ x]\]/m.test(text)) score += 4;
+	if (/\*\*.+?\*\*/.test(text)) score += 2;
+	if (/(?<!\*)\*(?!\*)(?!\s).+?(?<!\s)(?<!\*)\*(?!\*)/.test(text)) score += 1;
+	if (/^[*+-]\s+\S/m.test(text)) score += 1;
+	if (/^\d+\.\s+\S/m.test(text)) score += 1;
+	if (/^>\s+\S/m.test(text)) score += 1;
+	if (/`.+?`/.test(text)) score += 1;
+	if (/^[*_-]{3,}$/m.test(text)) score += 2;
+	if (text.split(/\n{2,}/).filter(Boolean).length >= 2) score += 5;
+	if (text.length < 20) score -= 3;
+	if (!text.includes("\n")) score -= 2;
+	return score >= 5;
+}
+function convertAndInsert(markdown) {
+	let conversionError = null;
+	const tempEditor = createEditor({
+		namespace: "markdown-paste-temp",
+		nodes: getResolvedEditNodes(),
+		onError: (error) => {
+			conversionError = error;
+		}
+	});
+	tempEditor.update(() => {
+		$convertFromMarkdownString(markdown, ALL_TRANSFORMERS);
+	}, { discrete: true });
+	if (conversionError) {
+		console.error("MarkdownPastePlugin: convertAndInsert error", conversionError);
+		return false;
+	}
+	const serializedChildren = tempEditor.getEditorState().toJSON().root.children;
+	if (!serializedChildren.length) return false;
+	$insertNodes(serializedChildren.map((s) => $parseSerializedNode(s)));
+	return true;
+}
+function MarkdownPastePlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		return editor.registerCommand(PASTE_COMMAND, (event) => {
+			const clipboardData = "clipboardData" in event ? event.clipboardData : null;
+			if (!clipboardData) return false;
+			if (Array.from(clipboardData.files).some((f) => f.type.startsWith("image/"))) return false;
+			const vscodeData = getVSCodePasteData(clipboardData);
+			if (vscodeData) {
+				const code = clipboardData.getData("text/plain");
+				if (code) {
+					$insertNodes(code.split(/\r?\n{3,}/).filter(Boolean).map((s) => $createCodeBlockEditNode(s.replace(/^\s*\n/, "").replace(/\n\s*$/, ""), vscodeData.language)));
+					event.preventDefault();
+					return true;
+				}
+			}
+			if (hasRichHTML(clipboardData)) return false;
+			const text = clipboardData.getData("text/plain");
+			if (!text || !detectMarkdown(text)) return false;
+			try {
+				if (!convertAndInsert(text)) return false;
+				event.preventDefault();
+				return true;
+			} catch (error) {
+				console.error("MarkdownPastePlugin: paste error", error);
+				return false;
+			}
+		}, COMMAND_PRIORITY_HIGH);
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/plugins/MarkdownShortcutsPlugin.tsx
+function MarkdownShortcutsPlugin() {
+	return /* @__PURE__ */ jsx(MarkdownShortcutPlugin, { transformers: ALL_TRANSFORMERS });
+}
+//#endregion
+//#region src/components/CorePlugins.tsx
+function CorePlugins() {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(ListPlugin, {}),
+		/* @__PURE__ */ jsx(LinkPlugin, {}),
+		/* @__PURE__ */ jsx(TabIndentationPlugin, {}),
+		/* @__PURE__ */ jsx(TablePlugin, {}),
+		/* @__PURE__ */ jsx(CheckListPlugin, {}),
+		/* @__PURE__ */ jsx(MarkdownShortcutsPlugin, {}),
+		/* @__PURE__ */ jsx(MarkdownPastePlugin, {}),
+		/* @__PURE__ */ jsx(BlockExitPlugin, {}),
+		/* @__PURE__ */ jsx(HorizontalRulePlugin, {}),
+		/* @__PURE__ */ jsx(AutoLinkPlugin, {})
+	] });
+}
+//#endregion
+//#region src/context/ImageUploadContext.tsx
+var ImageUploadContext = createContext(null);
+function ImageUploadProvider({ upload, children }) {
+	return /* @__PURE__ */ jsx(ImageUploadContext.Provider, {
+		value: upload,
+		children
+	});
+}
+function useImageUpload() {
+	return use(ImageUploadContext);
+}
+//#endregion
+//#region src/plugins/BlockIdPlugin.tsx
+var blockIdState = createState("blockId", { parse: (v) => typeof v === "string" ? v : "" });
+var NORMALIZATION_TAG = "block-id-normalization";
+function buildPreviousIdIndex(editorState) {
+	return editorState.read(() => {
+		const map = /* @__PURE__ */ new Map();
+		for (const child of $getRoot().getChildren()) {
+			const id = $getState(child, blockIdState);
+			if (!id) continue;
+			const set = map.get(id) ?? /* @__PURE__ */ new Set();
+			set.add(child.getKey());
+			map.set(id, set);
+		}
+		return map;
+	});
+}
+function collectRootChildren(editorState) {
+	return editorState.read(() => $getRoot().getChildren().map((child) => $getState(child, blockIdState)));
+}
+function hasDuplicateOrMissingId(children) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const id of children) {
+		if (!id || seen.has(id)) return true;
+		seen.add(id);
+	}
+	return false;
+}
+function generateBlockId(used) {
+	while (true) {
+		const id = nanoid(8);
+		if (!used.has(id)) return id;
+	}
+}
+function pickKeeperKey(nodes, previousKeys) {
+	if (!nodes.length) return null;
+	if (previousKeys?.size) {
+		for (const node of nodes) if (previousKeys.has(node.getKey())) return node.getKey();
+	}
+	return nodes[0]?.getKey() ?? null;
+}
+function normalizeRootBlockIds(editor, previousIdIndex) {
+	editor.update(() => {
+		$addUpdateTag("history-merge");
+		const children = $getRoot().getChildren();
+		const groupedById = /* @__PURE__ */ new Map();
+		for (const child of children) {
+			const id = $getState(child, blockIdState);
+			if (!id) continue;
+			const bucket = groupedById.get(id) ?? [];
+			bucket.push(child);
+			groupedById.set(id, bucket);
+		}
+		const keeperById = /* @__PURE__ */ new Map();
+		for (const [id, nodes] of groupedById) {
+			if (nodes.length <= 1) continue;
+			const keeperKey = pickKeeperKey(nodes, previousIdIndex.get(id));
+			if (keeperKey) keeperById.set(id, keeperKey);
+		}
+		const used = /* @__PURE__ */ new Set();
+		for (const child of children) {
+			let id = $getState(child, blockIdState);
+			const keeperKey = id ? keeperById.get(id) : null;
+			if (!id || used.has(id) || keeperKey !== void 0 && child.getKey() !== keeperKey) {
+				id = generateBlockId(used);
+				$setState(child, blockIdState, id);
+			}
+			used.add(id);
+		}
+	}, { tag: NORMALIZATION_TAG });
+}
+function BlockIdPlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		if (hasDuplicateOrMissingId(collectRootChildren(editor.getEditorState()))) normalizeRootBlockIds(editor, /* @__PURE__ */ new Map());
+		return editor.registerUpdateListener(({ tags, editorState, prevEditorState }) => {
+			if (tags.has(NORMALIZATION_TAG)) return;
+			if (!hasDuplicateOrMissingId(collectRootChildren(editorState))) return;
+			normalizeRootBlockIds(editor, buildPreviousIdIndex(prevEditorState));
+		});
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/plugins/image-upload.css.ts
+var draggingWrapperClass = "rich-image-upload-dragging";
+var toastVariant = {
+	info: "_1x58dbf3",
+	success: "_1x58dbf4",
+	error: "_1x58dbf5"
+};
+var spinner = "_1x58dbf7";
+var dialogPopup = "_1x58dbf8";
+var dialogHeader = "_1x58dbf9";
+var dialogTitle = "_1x58dbfa";
+var dialogBody = "_1x58dbfb";
+var tabWrap = "_1x58dbfc";
+var uploadDropzone = "_1x58dbfd";
+var uploadDropzoneState = {
+	idle: "_1x58dbfe",
+	active: "_1x58dbff",
+	busy: "_1x58dbfg"
+};
+var uploadDropIcon = "_1x58dbfh";
+var uploadDropTitle = "_1x58dbfi";
+var uploadDropDesc = "_1x58dbfj";
+var hiddenInput = "_1x58dbfk";
+var uploadBusyWrap = "_1x58dbfl";
+var uploadProgress = "_1x58dbfm";
+var urlInputRow = "_1x58dbfn";
+var textInput = "_1x58dbfo";
+var helperText = "_1x58dbfr";
+var dialogFooter = "_1x58dbfs";
+//#endregion
+//#region src/plugins/ImageUploadPlugin.tsx
+function isImageFile(file) {
+	return file.type.startsWith("image/");
+}
+function hasImageData(dataTransfer) {
+	if (!dataTransfer) return false;
+	if ([...dataTransfer.files].some(isImageFile)) return true;
+	return [...dataTransfer.items].some((item) => item.type.startsWith("image/"));
+}
+var UNSAFE_URL_RE = /^(?:javascript\s*:|vbscript\s*:|data\s*:(?!image\/))/i;
+function isSafeImageUrl(url) {
+	return !UNSAFE_URL_RE.test(url);
+}
+function loadImageByUrl(src) {
+	return new Promise((resolve, reject) => {
+		const image = new Image();
+		image.onload = () => {
+			resolve({
+				width: image.naturalWidth || image.width,
+				height: image.naturalHeight || image.height
+			});
+		};
+		image.onerror = () => reject(/* @__PURE__ */ new Error("Failed to load image"));
+		image.src = src;
+	});
+}
+function readAsDataUrl(file) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => resolve(String(reader.result));
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("File read failed"));
+		reader.readAsDataURL(file);
+	});
+}
+async function defaultImageUpload(file) {
+	return {
+		src: await readAsDataUrl(file),
+		altText: file.name
+	};
+}
+function ImageUploadPlugin({ onUpload }) {
+	const [editor] = useLexicalComposerContext();
+	const uploadRef = useRef(onUpload);
+	uploadRef.current = onUpload;
+	const fileInputRef = useRef(null);
+	const toastTimerRef = useRef(null);
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [tab, setTab] = useState("upload");
+	const [rootDragActive, setRootDragActive] = useState(false);
+	const [dialogDragActive, setDialogDragActive] = useState(false);
+	const [pendingUploads, setPendingUploads] = useState(0);
+	const [dialogUploading, setDialogUploading] = useState(false);
+	const [toast$1, setToast] = useState(null);
+	const [urlInput, setUrlInput] = useState("");
+	const [urlPreview$1, setUrlPreview] = useState(null);
+	const [urlMeta, setUrlMeta] = useState(null);
+	const [urlLoading, setUrlLoading] = useState(false);
+	const [urlError, setUrlError] = useState(null);
+	const tabItems = useMemo(() => [{
+		value: "upload",
+		label: "Upload"
+	}, {
+		value: "url",
+		label: "URL"
+	}], []);
+	const pushToast = useCallback((kind, message) => {
+		setToast({
+			kind,
+			message
+		});
+		if (toastTimerRef.current) window.clearTimeout(toastTimerRef.current);
+		toastTimerRef.current = window.setTimeout(setToast, 2200, null);
+	}, []);
+	const insertByUpload = useCallback(async (file, options) => {
+		if (!isImageFile(file)) return false;
+		const closeDialog = Boolean(options?.closeDialog);
+		setPendingUploads((value) => value + 1);
+		if (closeDialog) setDialogUploading(true);
+		try {
+			const [result, meta] = await Promise.all([uploadRef.current(file), computeImageMeta(file)]);
+			editor.update(() => {
+				$insertNodes([$createImageNode({
+					src: result.src,
+					altText: result.altText ?? file.name,
+					width: result.width ?? meta.width,
+					height: result.height ?? meta.height,
+					thumbhash: result.thumbhash ?? meta.thumbhash
+				})]);
+			});
+			if (closeDialog) {
+				setDialogOpen(false);
+				setUrlInput("");
+				setUrlPreview(null);
+				setUrlMeta(null);
+				setUrlError(null);
+			}
+			pushToast("success", "Image uploaded");
+			return true;
+		} catch (err) {
+			console.error("[ImageUploadPlugin]", err);
+			pushToast("error", "Image upload failed");
+			return false;
+		} finally {
+			setPendingUploads((value) => Math.max(value - 1, 0));
+			setDialogUploading(false);
+		}
+	}, [editor, pushToast]);
+	const handleFiles = useCallback((files) => {
+		const images = files.filter(isImageFile);
+		if (images.length === 0) return false;
+		for (const file of images) insertByUpload(file);
+		return true;
+	}, [insertByUpload]);
+	useEffect(() => {
+		const unregisterDragDrop = editor.registerCommand(DRAG_DROP_PASTE, (files) => handleFiles(files), COMMAND_PRIORITY_HIGH);
+		const unregisterPaste = editor.registerCommand(PASTE_COMMAND, (event) => {
+			const clipboardData = "clipboardData" in event ? event.clipboardData : null;
+			if (!clipboardData) return false;
+			const files = [...clipboardData.files];
+			if (files.some(isImageFile)) return handleFiles(files);
+			return false;
+		}, COMMAND_PRIORITY_HIGH);
+		const unregisterOpenDialog = editor.registerCommand(OPEN_IMAGE_UPLOAD_DIALOG_COMMAND, () => {
+			setDialogOpen(true);
+			return true;
+		}, COMMAND_PRIORITY_EDITOR);
+		const rootElement = editor.getRootElement();
+		const wrapper = rootElement?.parentElement ?? null;
+		if (!wrapper) return () => {
+			unregisterDragDrop();
+			unregisterPaste();
+			unregisterOpenDialog();
+		};
+		let dragCounter = 0;
+		const setWrapperDragging = (next) => {
+			setRootDragActive(next);
+			wrapper.classList.toggle(draggingWrapperClass, next);
+		};
+		const onDragEnter = (event) => {
+			if (!hasImageData(event.dataTransfer)) return;
+			dragCounter += 1;
+			setWrapperDragging(true);
+		};
+		const onDragOver = (event) => {
+			if (!hasImageData(event.dataTransfer)) return;
+			event.preventDefault();
+		};
+		const onDragLeave = () => {
+			dragCounter = Math.max(dragCounter - 1, 0);
+			if (dragCounter === 0) setWrapperDragging(false);
+		};
+		const onDrop = () => {
+			dragCounter = 0;
+			setWrapperDragging(false);
+		};
+		rootElement?.addEventListener("dragenter", onDragEnter);
+		rootElement?.addEventListener("dragover", onDragOver);
+		rootElement?.addEventListener("dragleave", onDragLeave);
+		rootElement?.addEventListener("drop", onDrop);
+		return () => {
+			if (toastTimerRef.current) window.clearTimeout(toastTimerRef.current);
+			unregisterDragDrop();
+			unregisterPaste();
+			unregisterOpenDialog();
+			setWrapperDragging(false);
+			rootElement?.removeEventListener("dragenter", onDragEnter);
+			rootElement?.removeEventListener("dragover", onDragOver);
+			rootElement?.removeEventListener("dragleave", onDragLeave);
+			rootElement?.removeEventListener("drop", onDrop);
+		};
+	}, [editor, handleFiles]);
+	const resetUrlState = useCallback(() => {
+		setUrlInput("");
+		setUrlPreview(null);
+		setUrlMeta(null);
+		setUrlError(null);
+		setUrlLoading(false);
+	}, []);
+	const handleDialogFile = useCallback(async (file) => {
+		if (!file) return;
+		await insertByUpload(file, { closeDialog: true });
+	}, [insertByUpload]);
+	const handleUrlPreview = useCallback(async () => {
+		const nextUrl = urlInput.trim();
+		if (!nextUrl) return;
+		if (!isSafeImageUrl(nextUrl)) {
+			setUrlError("Unsupported URL scheme");
+			return;
+		}
+		setUrlLoading(true);
+		setUrlError(null);
+		try {
+			setUrlMeta(await loadImageByUrl(nextUrl));
+			setUrlPreview(nextUrl);
+		} catch {
+			setUrlPreview(null);
+			setUrlMeta(null);
+			setUrlError("Could not load this image URL");
+		} finally {
+			setUrlLoading(false);
+		}
+	}, [urlInput]);
+	const handleInsertByUrl = useCallback(() => {
+		if (!urlPreview$1 || !isSafeImageUrl(urlPreview$1)) return;
+		editor.update(() => {
+			$insertNodes([$createImageNode({
+				src: urlPreview$1,
+				altText: "",
+				width: urlMeta?.width,
+				height: urlMeta?.height
+			})]);
+		});
+		pushToast("success", "Image inserted");
+		setDialogOpen(false);
+		resetUrlState();
+	}, [
+		editor,
+		pushToast,
+		resetUrlState,
+		urlMeta,
+		urlPreview$1
+	]);
+	const helperMessage = pendingUploads > 0 ? `Uploading ${pendingUploads} image${pendingUploads > 1 ? "s" : ""}...` : rootDragActive ? "Drop image files to upload" : null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [(helperMessage || toast$1) && /* @__PURE__ */ jsxs("div", {
+		className: "_1x58dbf1",
+		children: [helperMessage && /* @__PURE__ */ jsxs("div", {
+			className: `_1x58dbf2 ${toastVariant.info}`,
+			children: [/* @__PURE__ */ jsx("span", { className: "_1x58dbf7" }), helperMessage]
+		}), toast$1 && /* @__PURE__ */ jsxs("div", {
+			className: `_1x58dbf2 ${toastVariant[toast$1.kind]}`,
+			children: [toast$1.kind === "success" ? /* @__PURE__ */ jsx(Check, { size: 12 }) : /* @__PURE__ */ jsx(Info, { size: 12 }), toast$1.message]
+		})]
+	}), /* @__PURE__ */ jsx(Dialog, {
+		open: dialogOpen,
+		onOpenChange: (nextOpen) => {
+			if (!nextOpen && dialogUploading) return;
+			setDialogOpen(nextOpen);
+			if (!nextOpen) {
+				resetUrlState();
+				setDialogUploading(false);
+				setDialogDragActive(false);
+			}
+		},
+		children: /* @__PURE__ */ jsxs(DialogPopup, {
+			className: dialogPopup,
+			showCloseButton: !dialogUploading,
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: dialogHeader,
+					children: /* @__PURE__ */ jsx(DialogTitle, {
+						className: dialogTitle,
+						children: "Insert image"
+					})
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: dialogBody,
+					children: [/* @__PURE__ */ jsx("div", {
+						className: tabWrap,
+						children: /* @__PURE__ */ jsx(SegmentedControl, {
+							fullWidth: true,
+							items: tabItems,
+							value: tab,
+							onChange: setTab
+						})
+					}), tab === "upload" ? /* @__PURE__ */ jsxs("div", {
+						className: `${uploadDropzone} ${uploadDropzoneState[dialogUploading ? "busy" : dialogDragActive ? "active" : "idle"]}`,
+						role: "button",
+						tabIndex: 0,
+						onDragLeave: () => setDialogDragActive(false),
+						onClick: () => {
+							if (!dialogUploading) fileInputRef.current?.click();
+						},
+						onDragEnter: (event) => {
+							if (hasImageData(event.dataTransfer)) {
+								event.preventDefault();
+								setDialogDragActive(true);
+							}
+						},
+						onDragOver: (event) => {
+							if (hasImageData(event.dataTransfer)) event.preventDefault();
+						},
+						onDrop: (event) => {
+							event.preventDefault();
+							setDialogDragActive(false);
+							handleDialogFile([...event.dataTransfer.files].find(isImageFile) ?? null);
+						},
+						onKeyDown: (event) => {
+							if (event.key !== "Enter" && event.key !== " ") return;
+							event.preventDefault();
+							if (!dialogUploading) fileInputRef.current?.click();
+						},
+						children: [/* @__PURE__ */ jsx("input", {
+							accept: "image/*",
+							className: hiddenInput,
+							ref: fileInputRef,
+							type: "file",
+							onChange: (event) => {
+								handleDialogFile(event.currentTarget.files?.[0] ?? null);
+								event.currentTarget.value = "";
+							}
+						}), dialogUploading ? /* @__PURE__ */ jsx("div", {
+							className: uploadBusyWrap,
+							children: /* @__PURE__ */ jsxs("div", {
+								className: uploadProgress,
+								children: [/* @__PURE__ */ jsx("span", { className: spinner }), "Uploading image..."]
+							})
+						}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+							/* @__PURE__ */ jsx("span", {
+								className: uploadDropIcon,
+								children: /* @__PURE__ */ jsx(Upload, { size: 18 })
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: uploadDropTitle,
+								children: "Click to upload or drag and drop"
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: uploadDropDesc,
+								children: "PNG, JPG, GIF, WebP"
+							})
+						] })]
+					}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsxs("div", {
+							className: urlInputRow,
+							children: [
+								/* @__PURE__ */ jsx("input", {
+									className: textInput,
+									placeholder: "https://example.com/image.jpg",
+									type: "url",
+									value: urlInput,
+									onChange: (event) => {
+										setUrlInput(event.target.value);
+										setUrlError(null);
+										setUrlPreview(null);
+										setUrlMeta(null);
+									},
+									onKeyDown: (event) => {
+										if (event.key === "Enter") {
+											event.preventDefault();
+											if (urlPreview$1) handleInsertByUrl();
+											else handleUrlPreview();
+										}
+									}
+								}),
+								/* @__PURE__ */ jsx(ActionButton, {
+									disabled: urlLoading || !urlInput.trim(),
+									size: "md",
+									variant: "outline",
+									onClick: () => void handleUrlPreview(),
+									children: urlLoading ? "Loading" : "Preview"
+								}),
+								/* @__PURE__ */ jsx(ActionButton, {
+									disabled: !urlPreview$1,
+									size: "md",
+									variant: "accent",
+									onClick: handleInsertByUrl,
+									children: "Insert"
+								})
+							]
+						}),
+						urlError && /* @__PURE__ */ jsxs("span", {
+							className: `_1x58dbfr ${toastVariant.error}`,
+							children: [/* @__PURE__ */ jsx(Info, { size: 12 }), urlError]
+						}),
+						urlPreview$1 && /* @__PURE__ */ jsx("div", {
+							className: "_1x58dbfp",
+							children: /* @__PURE__ */ jsx("img", {
+								alt: "Preview",
+								className: "_1x58dbfq",
+								src: urlPreview$1
+							})
+						})
+					] })]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: dialogFooter,
+					children: [/* @__PURE__ */ jsxs("span", {
+						className: helperText,
+						children: [/* @__PURE__ */ jsx(Link2, { size: 12 }), "You can also paste images or drag files directly into the editor."]
+					}), /* @__PURE__ */ jsx(ActionBar, { children: /* @__PURE__ */ jsx(ActionButton, {
+						disabled: dialogUploading,
+						size: "md",
+						variant: "outline",
+						onClick: () => setDialogOpen(false),
+						children: "Close"
+					}) })]
+				})
+			]
+		})
+	})] });
+}
+//#endregion
+//#region src/plugins/LinkFaviconPlugin.tsx
+function applyFavicon(dom, href) {
+	if (dom.dataset.faviconHref === href) return;
+	dom.dataset.faviconHref = href;
+	const hostname = getHostname(href);
+	if (!hostname) return;
+	probeFavicon(hostname).then((faviconUrl) => {
+		if (faviconUrl) {
+			dom.style.setProperty("--rc-link-favicon", `url(${faviconUrl})`);
+			dom.dataset.favicon = "loaded";
+		}
+	});
+}
+function LinkFaviconPlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		const handleMutations = (mutations) => {
+			for (const [nodeKey, mutation] of mutations) {
+				if (mutation === "destroyed") continue;
+				const dom = editor.getElementByKey(nodeKey);
+				if (!dom) continue;
+				const href = dom.getAttribute("href");
+				if (href) applyFavicon(dom, href);
+			}
+		};
+		const unregisterLink = editor.registerMutationListener(LinkNode, handleMutations);
+		const unregisterAutoLink = editor.registerMutationListener(AutoLinkNode, handleMutations);
+		return () => {
+			unregisterLink();
+			unregisterAutoLink();
+		};
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/plugins/AutoFocusPlugin.tsx
+function AutoFocusPlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		const root = editor.getRootElement();
+		if (root) root.focus({ preventScroll: true });
+		else editor.focus();
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/plugins/EditorRefPlugin.tsx
+function EditorRefPlugin({ onEditorReady }) {
+	const [editor] = useLexicalComposerContext();
+	const callbackRef = useRef(onEditorReady);
+	callbackRef.current = onEditorReady;
+	useEffect(() => {
+		callbackRef.current?.(editor);
+		return () => callbackRef.current?.(null);
+	}, [editor]);
+	return null;
+}
+//#endregion
+//#region src/plugins/FootnotePlugin.tsx
+function FootnotePlugin({ children }) {
+	const [editor] = useLexicalComposerContext();
+	const [definitions, setDefinitions] = useState({});
+	const [displayNumberMap, setDisplayNumberMap] = useState({});
+	const pendingUpdateRef = useRef(false);
+	useEffect(() => {
+		return editor.registerUpdateListener(({ editorState }) => {
+			editorState.read(() => {
+				const footnoteNodes = $nodesOfType(FootnoteNode);
+				const seen = /* @__PURE__ */ new Set();
+				const numberMap = {};
+				let counter = 1;
+				for (const node of footnoteNodes) {
+					const id = node.getIdentifier();
+					if (!seen.has(id)) {
+						seen.add(id);
+						numberMap[id] = counter++;
+					}
+				}
+				setDisplayNumberMap(numberMap);
+				const sectionNodes = $nodesOfType(FootnoteSectionNode);
+				if (sectionNodes.length > 0) setDefinitions(sectionNodes[0].getDefinitions());
+				else setDefinitions({});
+				if (!editor.isEditable() || pendingUpdateRef.current) return;
+				if (footnoteNodes.length === 0 && sectionNodes.length > 0) {
+					pendingUpdateRef.current = true;
+					queueMicrotask(() => {
+						editor.update(() => {
+							const sections = $nodesOfType(FootnoteSectionNode);
+							for (const s of sections) s.remove();
+						});
+						pendingUpdateRef.current = false;
+					});
+					return;
+				}
+				if (footnoteNodes.length > 0 && sectionNodes.length === 0) {
+					const seenSnapshot = [...seen];
+					pendingUpdateRef.current = true;
+					queueMicrotask(() => {
+						editor.update(() => {
+							const root = $getRoot();
+							const defs = {};
+							for (const id of seenSnapshot) defs[id] = "";
+							const section = $parseSerializedNode({
+								type: "footnote-section",
+								definitions: defs,
+								version: 1
+							});
+							root.append(section);
+						});
+						pendingUpdateRef.current = false;
+					});
+				} else if (sectionNodes.length > 0) {
+					const existingDefs = sectionNodes[0].getDefinitions();
+					const missingIds = [...seen].filter((id) => !(id in existingDefs));
+					const orphanIds = Object.keys(existingDefs).filter((id) => !seen.has(id));
+					if (missingIds.length > 0 || orphanIds.length > 0) {
+						pendingUpdateRef.current = true;
+						queueMicrotask(() => {
+							editor.update(() => {
+								const freshSections = $nodesOfType(FootnoteSectionNode);
+								if (freshSections.length > 0) {
+									for (const id of missingIds) freshSections[0].setDefinition(id, "");
+									for (const id of orphanIds) freshSections[0].removeDefinition(id);
+								}
+							});
+							pendingUpdateRef.current = false;
+						});
+					}
+				}
+			});
+		});
+	}, [editor]);
+	return /* @__PURE__ */ jsx(FootnoteDefinitionsProvider, {
+		definitions,
+		displayNumberMap,
+		children
+	});
+}
+//#endregion
+//#region src/plugins/OnChangePlugin.tsx
+function OnChangePlugin({ onChange, debounceMs }) {
+	const [editor] = useLexicalComposerContext();
+	const timerRef = useRef(void 0);
+	const onChangeRef = useRef(onChange);
+	onChangeRef.current = onChange;
+	useEffect(() => {
+		const unregister = editor.registerUpdateListener(({ editorState }) => {
+			const fn = onChangeRef.current;
+			if (!fn) return;
+			if (debounceMs && debounceMs > 0) {
+				clearTimeout(timerRef.current);
+				timerRef.current = setTimeout(() => {
+					fn(editorState.toJSON());
+				}, debounceMs);
+			} else fn(editorState.toJSON());
+		});
+		return () => {
+			clearTimeout(timerRef.current);
+			unregister();
+		};
+	}, [editor, debounceMs]);
+	return null;
+}
+//#endregion
+//#region src/plugins/SubmitShortcutPlugin.tsx
+function SubmitShortcutPlugin({ onSubmit }) {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		if (!onSubmit) return;
+		return editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+			if (event && (event.metaKey || event.ctrlKey)) {
+				event.preventDefault();
+				onSubmit();
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_HIGH);
+	}, [editor, onSubmit]);
+	return null;
+}
+//#endregion
+export { HorizontalRulePlugin as _, AutoFocusPlugin as a, defaultImageUpload as c, ImageUploadProvider as d, useImageUpload as f, ALL_TRANSFORMERS as g, MarkdownPastePlugin as h, EditorRefPlugin as i, BlockIdPlugin as l, MarkdownShortcutsPlugin as m, OnChangePlugin as n, LinkFaviconPlugin as o, CorePlugins as p, FootnotePlugin as r, ImageUploadPlugin as s, SubmitShortcutPlugin as t, blockIdState as u, BlockExitPlugin as v, AutoLinkPlugin as y };