@haklex/rich-editor 0.1.1 → 0.3.0

package/dist/SubmitShortcutPlugin-DhyVFzoj.js

@@ -0,0 +1,2186 @@
+import { d as setCodeBlockCursorIntent, l as $createCodeBlockEditNode, t as getResolvedEditNodes, u as $createBannerEditNode } from "./node-registry-Dz5OTkh4.js";
+import { A as AlertQuoteNode, E as FootnoteNode, M as extractTextContent, T as $createFootnoteNode, _ as KaTeXInlineNode, b as KaTeXBlockNode, c as SpoilerNode, f as $createMentionNode, h as $createKaTeXInlineNode, m as MentionNode, o as $createSpoilerNode, v as $createKaTeXBlockNode, w as OPEN_IMAGE_UPLOAD_DIALOG_COMMAND, x as $createImageNode } from "./theme-B5B2EOWM.js";
+import { a as FootnoteDefinitionsProvider, n as computeImageMeta } from "./KaTeXRenderer-CQQT3BMw.js";
+import "./katex.css-CIOEOXyd.js";
+import { A as $createCommentPlaceholderNode, D as $createDetailsNode, E as FootnoteSectionNode, M as CommentNode, O as DetailsNode, P as CodeBlockNode, S as $isGridContainerNode, T as $isFootnoteSectionNode, V as BannerNode, a as $createRubyNode, k as $createCommentNode, s as RubyNode, w as $createFootnoteSectionNode } from "./config-B5BuLljq.js";
+import { t as $createAlertQuoteEditNode } from "./AlertQuoteEditNode-C55sxsR3.js";
+import { n as getHostname, r as probeFavicon, t as normalizeSerializedEditorState } from "./normalizeSerializedEditorState-B-1wmGzd.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, useSyncExternalStore } from "react";
+import { $createQuoteNode, $isQuoteNode, DRAG_DROP_PASTE, QuoteNode } from "@lexical/rich-text";
+import { $addUpdateTag, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createRangeSelection, $createTextNode, $getNodeByKey, $getRoot, $getSelection, $getState, $insertNodes, $isDecoratorNode, $isElementNode, $isLineBreakNode, $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, SELECTION_CHANGE_COMMAND, createEditor, createState } from "lexical";
+import { $createHorizontalRuleNode, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/extension";
+import { CODE_BLOCK_NODE_TRANSFORMER, COMMENT_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 { nanoid } from "nanoid";
+import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
+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 isDeeplyEmptyElement(node) {
+	if (!$isElementNode(node)) return false;
+	if (node.getChildrenSize() === 0) return true;
+	for (const child of node.getChildren()) {
+		if ($isTextNode(child)) {
+			if (child.getTextContent().trim().length > 0) return false;
+			continue;
+		}
+		if (!$isElementNode(child) || !isDeeplyEmptyElement(child)) return false;
+	}
+	return true;
+}
+function isSelectionInsideTopLevel(selection, topLevelKey) {
+	return selection.anchor.getNode().getTopLevelElementOrThrow().getKey() === topLevelKey && selection.focus.getNode().getTopLevelElementOrThrow().getKey() === topLevelKey;
+}
+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(() => {
+		return registerBlockExitCommands(editor);
+	}, [editor]);
+	return null;
+}
+function registerBlockExitCommands(editor) {
+	let virtualParagraphKey = null;
+	const clearVirtualParagraph = () => {
+		virtualParagraphKey = null;
+	};
+	const getVirtualParagraph = () => {
+		if (!virtualParagraphKey) return null;
+		const node = $getNodeByKey(virtualParagraphKey);
+		return $isParagraphNode(node) ? node : null;
+	};
+	const insertVirtualParagraph = (target, position, cursorPlacement = "start") => {
+		const paragraph = $createParagraphNode();
+		if (position === "before") target.insertBefore(paragraph);
+		else target.insertAfter(paragraph);
+		virtualParagraphKey = paragraph.getKey();
+		if (cursorPlacement === "end") paragraph.selectEnd();
+		else paragraph.selectStart();
+		return true;
+	};
+	const unregisterVirtualParagraphCleanup = editor.registerUpdateListener(({ editorState }) => {
+		if (!virtualParagraphKey) return;
+		let shouldKeepTracking = false;
+		let shouldRemove = false;
+		editorState.read(() => {
+			const paragraph = getVirtualParagraph();
+			if (!paragraph) return;
+			const selection = $getSelection();
+			if ($isRangeSelection(selection) && isSelectionInsideTopLevel(selection, paragraph.getKey())) {
+				shouldKeepTracking = true;
+				return;
+			}
+			shouldRemove = isDeeplyEmptyElement(paragraph);
+		});
+		if (shouldKeepTracking) return;
+		editor.update(() => {
+			const paragraph = getVirtualParagraph();
+			if (paragraph && shouldRemove && isDeeplyEmptyElement(paragraph)) paragraph.remove();
+			clearVirtualParagraph();
+		});
+	});
+	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 && quoteChild.getNextSibling() === null && $isParagraphNode(quoteChild) && quoteChild.getTextContent() === "") {
+			event?.preventDefault();
+			let next = quoteNode.getNextSibling();
+			if (!next) {
+				next = $createParagraphNode();
+				quoteNode.insertAfter(next);
+			}
+			next.selectStart();
+			return true;
+		}
+		if (!event?.shiftKey && topLevelElement.getNextSibling() === null && isAtTopLevelBoundary(selection, "end") && topLevelElement.getKey() !== virtualParagraphKey && !isDeeplyEmptyElement(topLevelElement)) {
+			event?.preventDefault();
+			return insertVirtualParagraph(topLevelElement, "after");
+		}
+		return false;
+	}, 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 (!event?.shiftKey && topLevelElement.getPreviousSibling() === null && isAtTopLevelBoundary(selection, "start") && topLevelElement.getKey() !== virtualParagraphKey && !isDeeplyEmptyElement(topLevelElement)) {
+				event?.preventDefault();
+				return insertVirtualParagraph(topLevelElement, "before");
+			}
+		}
+		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;
+		}
+		if (!event?.shiftKey && node.getTopLevelElementOrThrow().getPreviousSibling() === null && node.getKey() !== virtualParagraphKey) {
+			event?.preventDefault();
+			return insertVirtualParagraph(node, "before", "end");
+		}
+		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;
+		}
+		if (!event?.shiftKey && node.getTopLevelElementOrThrow().getNextSibling() === null && node.getKey() !== virtualParagraphKey) {
+			event?.preventDefault();
+			return insertVirtualParagraph(node, "after");
+		}
+		return false;
+	}, COMMAND_PRIORITY_CRITICAL);
+	return () => {
+		unregisterVirtualParagraphCleanup();
+		unregisterArrowRight();
+		unregisterArrowDown();
+		unregisterCmdEnter();
+		unregisterBackspace();
+		unregisterDelete();
+		unregisterArrowUpDecorator();
+		unregisterArrowDownDecorator();
+		clearVirtualParagraph();
+	};
+}
+//#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"
+};
+var COMMENT_OPEN_TRANSFORMER = {
+	dependencies: [CommentNode],
+	export: () => null,
+	importRegExp: /a^/,
+	regExp: /<!--$/,
+	replace: (textNode) => {
+		const node = $createCommentPlaceholderNode();
+		textNode.replace(node);
+		node.select(0, node.getTextContentSize());
+	},
+	trigger: "-",
+	type: "text-match"
+};
+var COMMENT_TRANSFORMER$1 = {
+	...COMMENT_TRANSFORMER,
+	dependencies: [CommentNode],
+	replace: (textNode, match) => {
+		textNode.replace($createCommentNode(match[1] ?? ""));
+	}
+};
+//#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,
+	COMMENT_OPEN_TRANSFORMER,
+	COMMENT_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 (clipboardData.getData("application/x-lexical-editor")) 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 syncBlockIdAttributes(editor) {
+	editor.getEditorState().read(() => {
+		for (const child of $getRoot().getChildren()) {
+			const id = $getState(child, blockIdState);
+			if (!id) continue;
+			const dom = editor.getElementByKey(child.getKey());
+			if (dom && dom.getAttribute("data-block-id") !== id) dom.setAttribute("data-block-id", id);
+		}
+	});
+}
+function BlockIdPlugin() {
+	const [editor] = useLexicalComposerContext();
+	useEffect(() => {
+		if (hasDuplicateOrMissingId(collectRootChildren(editor.getEditorState()))) normalizeRootBlockIds(editor, /* @__PURE__ */ new Map());
+		syncBlockIdAttributes(editor);
+		return editor.registerUpdateListener(({ tags, editorState, prevEditorState }) => {
+			if (tags.has(NORMALIZATION_TAG)) {
+				syncBlockIdAttributes(editor);
+				return;
+			}
+			if (!hasDuplicateOrMissingId(collectRootChildren(editorState))) {
+				syncBlockIdAttributes(editor);
+				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/context/TextSelectionContext.tsx
+function areSnapshotsEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.text === b.text && a.anchorBlockId === b.anchorBlockId && a.anchorOffset === b.anchorOffset && a.focusBlockId === b.focusBlockId && a.focusOffset === b.focusOffset;
+}
+function createTextSelectionStore(initialState = { snapshot: null }) {
+	let state = initialState;
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		getState: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		setSnapshot: (snapshot) => {
+			if (areSnapshotsEqual(state.snapshot, snapshot)) return;
+			state = {
+				...state,
+				snapshot
+			};
+			emit();
+		},
+		clearSnapshot: () => {
+			if (state.snapshot === null) return;
+			state = {
+				...state,
+				snapshot: null
+			};
+			emit();
+		}
+	};
+}
+var TextSelectionStoreContext = createContext(null);
+function TextSelectionStoreProvider({ children }) {
+	const storeRef = useRef(null);
+	if (!storeRef.current) storeRef.current = createTextSelectionStore();
+	return /* @__PURE__ */ jsx(TextSelectionStoreContext.Provider, {
+		value: storeRef.current,
+		children
+	});
+}
+function useTextSelectionStore() {
+	const store = use(TextSelectionStoreContext);
+	if (!store) throw new Error("useTextSelectionStore must be used within TextSelectionStoreProvider");
+	return store;
+}
+function useTextSelectionSnapshot() {
+	const store = useTextSelectionStore();
+	return useSyncExternalStore(store.subscribe, () => store.getState().snapshot, () => store.getState().snapshot);
+}
+//#endregion
+//#region src/utils/comment-anchor.ts
+function computeBlockFingerprint(block) {
+	const text = block.getTextContent();
+	const input = text.slice(0, 200) + String(text.length);
+	let hash = 5381;
+	for (let i = 0; i < input.length; i++) hash = (hash << 5) + hash + (input.codePointAt(i) ?? 0) | 0;
+	return (hash >>> 0).toString(16);
+}
+function $getRootBlock(node) {
+	const root = $getRoot();
+	let current = node;
+	while (current) {
+		const parent = current.getParent();
+		if (parent === root && "getChildren" in current) return current;
+		current = parent;
+	}
+	return null;
+}
+function $resolveSelectionPoint(selection, which) {
+	const point = selection[which];
+	const node = point.getNode();
+	if ($isElementNode(node)) {
+		const children = node.getChildren();
+		if (point.offset < children.length) return {
+			node: children[point.offset],
+			offset: 0
+		};
+		const last = children.at(-1);
+		if (last && $isTextNode(last)) return {
+			node: last,
+			offset: last.getTextContentSize()
+		};
+		return {
+			node,
+			offset: 0
+		};
+	}
+	return {
+		node,
+		offset: point.offset
+	};
+}
+function $getTextOffsetInBlock(block, targetNode, targetOffset) {
+	let offset = 0;
+	function walk(node) {
+		if (node.is(targetNode)) {
+			offset += targetOffset;
+			return true;
+		}
+		if ($isTextNode(node)) offset += node.getTextContentSize();
+		else if ($isLineBreakNode(node)) offset += 1;
+		else if ($isElementNode(node)) {
+			for (const child of node.getChildren()) if (walk(child)) return true;
+		}
+		return false;
+	}
+	for (const child of block.getChildren()) if (walk(child)) break;
+	return offset;
+}
+function $buildBlockAnchorData(block) {
+	const blockId = $getState(block, blockIdState);
+	if (!blockId) return {
+		ok: false,
+		error: "no-block-id"
+	};
+	return {
+		ok: true,
+		anchor: {
+			mode: "block",
+			blockId,
+			blockType: block.getType(),
+			blockFingerprint: computeBlockFingerprint(block),
+			snapshotText: block.getTextContent().slice(0, 300)
+		}
+	};
+}
+function buildBlockAnchor(editor, blockKey) {
+	return editor.read(() => {
+		if (blockKey) {
+			const node = $getRoot().getChildren().find((c) => c.getKey() === blockKey);
+			if (!node || !("getChildren" in node)) return {
+				ok: false,
+				error: "not-root-block"
+			};
+			return $buildBlockAnchorData(node);
+		}
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return {
+			ok: false,
+			error: "no-selection"
+		};
+		const block = $getRootBlock(selection.anchor.getNode());
+		if (!block) return {
+			ok: false,
+			error: "not-root-block"
+		};
+		return $buildBlockAnchorData(block);
+	});
+}
+function buildRangeAnchor(editor) {
+	return editor.read(() => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return {
+			ok: false,
+			error: "no-selection"
+		};
+		if (selection.isCollapsed()) return {
+			ok: false,
+			error: "collapsed"
+		};
+		const anchorBlock = $getRootBlock(selection.anchor.getNode());
+		const focusBlock = $getRootBlock(selection.focus.getNode());
+		if (!anchorBlock || !focusBlock) return {
+			ok: false,
+			error: "not-root-block"
+		};
+		if (anchorBlock !== focusBlock) return {
+			ok: false,
+			error: "cross-block"
+		};
+		const block = anchorBlock;
+		const blockId = $getState(block, blockIdState);
+		if (!blockId) return {
+			ok: false,
+			error: "no-block-id"
+		};
+		const anchorPoint = $resolveSelectionPoint(selection, "anchor");
+		const focusPoint = $resolveSelectionPoint(selection, "focus");
+		let startOffset = $getTextOffsetInBlock(block, anchorPoint.node, anchorPoint.offset);
+		let endOffset = $getTextOffsetInBlock(block, focusPoint.node, focusPoint.offset);
+		if (startOffset > endOffset) [startOffset, endOffset] = [endOffset, startOffset];
+		const text = block.getTextContent();
+		const quote = text.slice(startOffset, endOffset);
+		const prefix = text.slice(Math.max(0, startOffset - 50), startOffset);
+		const suffix = text.slice(endOffset, endOffset + 50);
+		return {
+			ok: true,
+			anchor: {
+				mode: "range",
+				blockId,
+				blockType: block.getType(),
+				blockFingerprint: computeBlockFingerprint(block),
+				snapshotText: text.slice(0, 300),
+				quote,
+				prefix,
+				suffix,
+				startOffset,
+				endOffset
+			}
+		};
+	});
+}
+//#endregion
+//#region src/utils/text-selection-constants.ts
+var TEXT_SELECTION_HIGHLIGHT_NAME = "rich-editor-text-selection";
+var TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME = "rich-editor-text-selection-inactive";
+//#endregion
+//#region src/utils/text-selection.ts
+function clampOffset(offset, max) {
+	return Math.max(0, Math.min(offset, max));
+}
+function getTopLevelBlockById(blockId) {
+	for (const child of $getRoot().getChildren()) if ($getState(child, blockIdState) === blockId && $isElementNode(child)) return child;
+	return null;
+}
+function getTextLengthOfDomNode(node) {
+	if (node.nodeType === Node.TEXT_NODE) return node.textContent?.length ?? 0;
+	if (node.nodeType !== Node.ELEMENT_NODE) return 0;
+	if (node.tagName === "BR") return 1;
+	let length = 0;
+	for (const child of node.childNodes) length += getTextLengthOfDomNode(child);
+	return length;
+}
+function compareBlockElements(a, b) {
+	if (a === b) return 0;
+	const position = a.compareDocumentPosition(b);
+	if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+	if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+	return 0;
+}
+function buildDomRectFromClientRects(rects) {
+	if (!rects.length) return null;
+	let left = rects[0].left;
+	let top = rects[0].top;
+	let right = rects[0].right;
+	let bottom = rects[0].bottom;
+	for (const rect of rects.slice(1)) {
+		left = Math.min(left, rect.left);
+		top = Math.min(top, rect.top);
+		right = Math.max(right, rect.right);
+		bottom = Math.max(bottom, rect.bottom);
+	}
+	return new DOMRect(left, top, right - left, bottom - top);
+}
+function resolveLexicalSelectionTarget(block, requestedOffset) {
+	let remaining = clampOffset(requestedOffset, block.getTextContent().length);
+	let lastTarget = {
+		key: block.getKey(),
+		offset: block.getChildrenSize(),
+		type: "element"
+	};
+	function walk(node) {
+		if ($isTextNode(node)) {
+			const length = node.getTextContentSize();
+			lastTarget = {
+				key: node.getKey(),
+				offset: length,
+				type: "text"
+			};
+			if (remaining <= length) return {
+				key: node.getKey(),
+				offset: remaining,
+				type: "text"
+			};
+			remaining -= length;
+			return null;
+		}
+		if ($isLineBreakNode(node)) {
+			const parent = node.getParent();
+			if (!parent) return null;
+			const index = node.getIndexWithinParent();
+			if (remaining === 0) return {
+				key: parent.getKey(),
+				offset: index,
+				type: "element"
+			};
+			if (remaining === 1) return {
+				key: parent.getKey(),
+				offset: index + 1,
+				type: "element"
+			};
+			remaining -= 1;
+			lastTarget = {
+				key: parent.getKey(),
+				offset: index + 1,
+				type: "element"
+			};
+			return null;
+		}
+		if (!$isElementNode(node)) return null;
+		if (node.getChildrenSize() === 0) {
+			lastTarget = {
+				key: node.getKey(),
+				offset: 0,
+				type: "element"
+			};
+			return null;
+		}
+		for (const child of node.getChildren()) {
+			const resolved = walk(child);
+			if (resolved) return resolved;
+		}
+		lastTarget = {
+			key: node.getKey(),
+			offset: node.getChildrenSize(),
+			type: "element"
+		};
+		return null;
+	}
+	return walk(block) ?? lastTarget;
+}
+function $captureTextSelectionFromRangeSelection(selection) {
+	if (selection.isCollapsed()) return null;
+	const anchorBlock = $getRootBlock(selection.anchor.getNode());
+	const focusBlock = $getRootBlock(selection.focus.getNode());
+	if (!anchorBlock || !focusBlock) return null;
+	const anchorBlockId = $getState(anchorBlock, blockIdState);
+	const focusBlockId = $getState(focusBlock, blockIdState);
+	if (!anchorBlockId || !focusBlockId) return null;
+	const anchorPoint = $resolveSelectionPoint(selection, "anchor");
+	const focusPoint = $resolveSelectionPoint(selection, "focus");
+	return {
+		text: selection.getTextContent(),
+		anchorBlockId,
+		anchorOffset: $getTextOffsetInBlock(anchorBlock, anchorPoint.node, anchorPoint.offset),
+		focusBlockId,
+		focusOffset: $getTextOffsetInBlock(focusBlock, focusPoint.node, focusPoint.offset)
+	};
+}
+function $captureTextSelection() {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection)) return null;
+	return $captureTextSelectionFromRangeSelection(selection);
+}
+function $restoreTextSelection(snapshot) {
+	const anchorBlock = getTopLevelBlockById(snapshot.anchorBlockId);
+	const focusBlock = getTopLevelBlockById(snapshot.focusBlockId);
+	if (!anchorBlock || !focusBlock) return false;
+	const anchor = resolveLexicalSelectionTarget(anchorBlock, snapshot.anchorOffset);
+	const focus = resolveLexicalSelectionTarget(focusBlock, snapshot.focusOffset);
+	const selection = $createRangeSelection();
+	selection.anchor.set(anchor.key, anchor.offset, anchor.type);
+	selection.focus.set(focus.key, focus.offset, focus.type);
+	$setSelection(selection);
+	return true;
+}
+function getTextOffsetFromDOMPoint(container, targetNode, targetOffset) {
+	let offset = 0;
+	function walk(node) {
+		if (node === targetNode) {
+			if (node.nodeType === Node.TEXT_NODE) {
+				offset += Math.min(targetOffset, node.textContent?.length ?? 0);
+				return true;
+			}
+			const childNodes = Array.from(node.childNodes);
+			const boundary = Math.min(targetOffset, childNodes.length);
+			for (let i = 0; i < boundary; i++) offset += getTextLengthOfDomNode(childNodes[i]);
+			return true;
+		}
+		if (node.nodeType === Node.TEXT_NODE) {
+			offset += node.textContent?.length ?? 0;
+			return false;
+		}
+		if (node.nodeType !== Node.ELEMENT_NODE) return false;
+		if (node.tagName === "BR") {
+			offset += 1;
+			return false;
+		}
+		for (const child of node.childNodes) if (walk(child)) return true;
+		return false;
+	}
+	walk(container);
+	return offset;
+}
+function findDOMPointByTextOffset(container, requestedOffset) {
+	const targetOffset = clampOffset(requestedOffset, getTextLengthOfDomNode(container));
+	let consumed = 0;
+	function walk(node) {
+		if (node.nodeType === Node.TEXT_NODE) {
+			const length = node.textContent?.length ?? 0;
+			if (targetOffset <= consumed + length) return {
+				node,
+				offset: targetOffset - consumed
+			};
+			consumed += length;
+			return null;
+		}
+		if (node.nodeType !== Node.ELEMENT_NODE) return null;
+		const element = node;
+		if (element.tagName === "BR") {
+			const parent = element.parentNode;
+			if (!parent) return null;
+			const index = Array.from(parent.childNodes).indexOf(element);
+			if (targetOffset === consumed) return {
+				node: parent,
+				offset: index
+			};
+			if (targetOffset === consumed + 1) return {
+				node: parent,
+				offset: index + 1
+			};
+			consumed += 1;
+			return null;
+		}
+		for (const child of node.childNodes) {
+			const resolved = walk(child);
+			if (resolved) return resolved;
+		}
+		return null;
+	}
+	return walk(container) ?? {
+		node: container,
+		offset: container.childNodes.length
+	};
+}
+function getBlockElementById(rootElement, blockId) {
+	return rootElement.querySelector(`[data-block-id="${blockId}"]`);
+}
+function createDOMRangeFromTextSelection(rootElement, snapshot) {
+	const anchorBlock = getBlockElementById(rootElement, snapshot.anchorBlockId);
+	const focusBlock = getBlockElementById(rootElement, snapshot.focusBlockId);
+	if (!anchorBlock || !focusBlock) return null;
+	const anchor = findDOMPointByTextOffset(anchorBlock, snapshot.anchorOffset);
+	const focus = findDOMPointByTextOffset(focusBlock, snapshot.focusOffset);
+	if (!anchor || !focus) return null;
+	const anchorComesFirst = anchorBlock === focusBlock ? snapshot.anchorOffset <= snapshot.focusOffset : compareBlockElements(anchorBlock, focusBlock) <= 0;
+	const start = anchorComesFirst ? anchor : focus;
+	const end = anchorComesFirst ? focus : anchor;
+	try {
+		const range = document.createRange();
+		range.setStart(start.node, start.offset);
+		range.setEnd(end.node, end.offset);
+		return range;
+	} catch {
+		return null;
+	}
+}
+function getDOMRectFromTextSelection(rootElement, snapshot) {
+	const range = createDOMRangeFromTextSelection(rootElement, snapshot);
+	if (!range) return null;
+	const rect = range.getBoundingClientRect();
+	if (rect.width > 0 || rect.height > 0) return rect;
+	return buildDomRectFromClientRects(Array.from(range.getClientRects()));
+}
+//#endregion
+//#region src/plugins/text-selection.css.ts
+var nativeSelectionActive = "gr1ebt0";
+var nativeSelectionInactive = "gr1ebt1";
+//#endregion
+//#region src/plugins/TextSelectionPlugin.tsx
+var activeHighlightOwner = null;
+function getHighlightRegistry() {
+	if (typeof CSS === "undefined" || !("highlights" in CSS) || typeof Highlight === "undefined") return null;
+	return CSS.highlights;
+}
+function clearManagedHighlight(rootElement) {
+	if (rootElement && rootElement !== activeHighlightOwner) {
+		rootElement.classList.remove(nativeSelectionActive, nativeSelectionInactive);
+		return;
+	}
+	const registry = getHighlightRegistry();
+	registry?.delete(TEXT_SELECTION_HIGHLIGHT_NAME);
+	registry?.delete(TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME);
+	activeHighlightOwner?.classList.remove(nativeSelectionActive, nativeSelectionInactive);
+	activeHighlightOwner = null;
+}
+function TextSelectionPlugin() {
+	const [editor] = useLexicalComposerContext();
+	const store = useTextSelectionStore();
+	const snapshot = useTextSelectionSnapshot();
+	const [isEditorFocused, setIsEditorFocused] = useState(false);
+	const frameRef = useRef(null);
+	const focusFrameRef = useRef(null);
+	useEffect(() => {
+		const syncSnapshot = () => {
+			if (!editor.getRootElement()) {
+				store.clearSnapshot();
+				return;
+			}
+			const nextSnapshot = editor.getEditorState().read(() => $captureTextSelection());
+			store.setSnapshot(nextSnapshot);
+		};
+		const syncFocusState = () => {
+			const rootElement = editor.getRootElement();
+			const activeElement = rootElement?.ownerDocument.activeElement;
+			setIsEditorFocused(Boolean(rootElement && activeElement && rootElement.contains(activeElement)));
+		};
+		const scheduleFocusStateSync = () => {
+			if (focusFrameRef.current !== null) cancelAnimationFrame(focusFrameRef.current);
+			focusFrameRef.current = requestAnimationFrame(() => {
+				focusFrameRef.current = null;
+				syncFocusState();
+			});
+		};
+		const unregisterSelectionChange = editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+			syncSnapshot();
+			return false;
+		}, COMMAND_PRIORITY_LOW);
+		const unregisterUpdate = editor.registerUpdateListener(() => {
+			syncSnapshot();
+		});
+		const rootElement = editor.getRootElement();
+		if (rootElement) {
+			const onFocusIn = (event) => {
+				const target = event.target;
+				if (!target) return;
+				const nestedEditable = target.closest("[contenteditable=\"true\"]");
+				if (nestedEditable && nestedEditable !== rootElement) {
+					store.clearSnapshot();
+					scheduleFocusStateSync();
+					return;
+				}
+				scheduleFocusStateSync();
+				syncSnapshot();
+			};
+			const onFocusOut = () => {
+				scheduleFocusStateSync();
+				syncSnapshot();
+			};
+			rootElement.addEventListener("focusin", onFocusIn);
+			rootElement.addEventListener("focusout", onFocusOut);
+			syncFocusState();
+			syncSnapshot();
+			return () => {
+				unregisterSelectionChange();
+				unregisterUpdate();
+				if (focusFrameRef.current !== null) {
+					cancelAnimationFrame(focusFrameRef.current);
+					focusFrameRef.current = null;
+				}
+				rootElement.removeEventListener("focusin", onFocusIn);
+				rootElement.removeEventListener("focusout", onFocusOut);
+				store.clearSnapshot();
+			};
+		}
+		syncFocusState();
+		syncSnapshot();
+		return () => {
+			unregisterSelectionChange();
+			unregisterUpdate();
+			if (focusFrameRef.current !== null) {
+				cancelAnimationFrame(focusFrameRef.current);
+				focusFrameRef.current = null;
+			}
+			store.clearSnapshot();
+		};
+	}, [editor, store]);
+	useEffect(() => {
+		const registry = getHighlightRegistry();
+		const cancelScheduledSync = () => {
+			if (frameRef.current !== null) {
+				cancelAnimationFrame(frameRef.current);
+				frameRef.current = null;
+			}
+		};
+		const syncManagedHighlight = () => {
+			cancelScheduledSync();
+			frameRef.current = requestAnimationFrame(() => {
+				frameRef.current = null;
+				const rootElement = editor.getRootElement();
+				if (!rootElement) {
+					clearManagedHighlight();
+					return;
+				}
+				if (!snapshot) {
+					clearManagedHighlight(rootElement);
+					return;
+				}
+				if (activeHighlightOwner && activeHighlightOwner !== rootElement) activeHighlightOwner.classList.remove(nativeSelectionActive, nativeSelectionInactive);
+				const activeSelectionClass = isEditorFocused ? nativeSelectionActive : nativeSelectionInactive;
+				const inactiveSelectionClass = isEditorFocused ? nativeSelectionInactive : nativeSelectionActive;
+				const highlightName = isEditorFocused ? TEXT_SELECTION_HIGHLIGHT_NAME : TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME;
+				const staleHighlightName = isEditorFocused ? TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME : TEXT_SELECTION_HIGHLIGHT_NAME;
+				rootElement.classList.remove(inactiveSelectionClass);
+				rootElement.classList.add(activeSelectionClass);
+				activeHighlightOwner = rootElement;
+				if (!registry) return;
+				const range = createDOMRangeFromTextSelection(rootElement, snapshot);
+				if (!range) {
+					clearManagedHighlight(rootElement);
+					return;
+				}
+				registry.delete(staleHighlightName);
+				registry.set(highlightName, new Highlight(range));
+			});
+		};
+		syncManagedHighlight();
+		return () => {
+			cancelScheduledSync();
+			clearManagedHighlight(editor.getRootElement());
+		};
+	}, [
+		editor,
+		isEditorFocused,
+		snapshot
+	]);
+	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;
+			const serializedState = normalizeSerializedEditorState(editorState.toJSON());
+			if (debounceMs && debounceMs > 0) {
+				clearTimeout(timerRef.current);
+				timerRef.current = setTimeout(() => {
+					fn(serializedState);
+				}, debounceMs);
+			} else fn(serializedState);
+		});
+		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 { ImageUploadProvider as A, useTextSelectionSnapshot as C, defaultImageUpload as D, ImageUploadPlugin as E, ALL_TRANSFORMERS as F, HorizontalRulePlugin as I, BlockExitPlugin as L, CorePlugins as M, MarkdownShortcutsPlugin as N, BlockIdPlugin as O, MarkdownPastePlugin as P, AutoLinkPlugin as R, createTextSelectionStore as S, LinkFaviconPlugin as T, $getTextOffsetInBlock as _, AutoFocusPlugin as a, buildRangeAnchor as b, $captureTextSelectionFromRangeSelection as c, findDOMPointByTextOffset as d, getBlockElementById as f, $getRootBlock as g, TEXT_SELECTION_HIGHLIGHT_NAME as h, EditorRefPlugin as i, useImageUpload as j, blockIdState as k, $restoreTextSelection as l, getTextOffsetFromDOMPoint as m, OnChangePlugin as n, TextSelectionPlugin as o, getDOMRectFromTextSelection as p, FootnotePlugin as r, $captureTextSelection as s, SubmitShortcutPlugin as t, createDOMRangeFromTextSelection as u, $resolveSelectionPoint as v, useTextSelectionStore as w, TextSelectionStoreProvider as x, buildBlockAnchor as y };