@haklex/rich-editor 0.0.80 → 0.0.82

package/dist/node-registry-CeVi2y9f.js

@@ -0,0 +1,666 @@
+import { A as _defineProperty, S as ImageNode, T as FootnoteNode, g as KaTeXInlineNode, i as TagNode, p as MentionNode, s as SpoilerNode, t as editorTheme, u as MermaidNode, y as KaTeXBlockNode } from "./theme-DHOUKKSr.js";
+import { l as RendererWrapper, s as useFootnoteDefinitions } from "./KaTeXRenderer-BsyRH5_t.js";
+import { D as BannerNode, O as normalizeBannerType, b as CodeBlockNode, f as $isGridContainerNode, g as FootnoteSectionNode, i as VideoNode, k as BannerRenderer, n as builtinNodes, p as GridContainerNode, s as RubyNode, u as LinkCardNode, v as DetailsNode, w as $isBannerNode, x as CodeBlockRenderer, y as $isCodeBlockNode } from "./config-tfg1FWhG.js";
+import { n as AlertQuoteEditNode, r as NESTED_EDITOR_NODES } from "./AlertQuoteEditNode-BDoonB4u.js";
+import { LinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { createElement, useCallback, useEffect, useState } from "react";
+import { $createNodeSelection, $createParagraphNode, $getNodeByKey, $getRoot, $getSelection, $insertNodes, $isDecoratorNode, $isElementNode, $isNodeSelection, $nodesOfType, $setSelection, createEditor } from "lexical";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Flag, LayoutGrid, Minus, Plus } from "lucide-react";
+import { ContentEditable } from "@lexical/react/LexicalContentEditable";
+import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
+import { LexicalNestedComposer } from "@lexical/react/LexicalNestedComposer";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { useLexicalNodeSelection } from "@lexical/react/useLexicalNodeSelection";
+//#region src/utils/codeBlockSelectionIntent.ts
+var codeBlockCursorIntentMap = /* @__PURE__ */ new Map();
+function setCodeBlockCursorIntent(nodeKey, placement) {
+	codeBlockCursorIntentMap.set(nodeKey, placement);
+}
+function consumeCodeBlockCursorIntent(nodeKey) {
+	const placement = codeBlockCursorIntentMap.get(nodeKey);
+	if (!placement) return null;
+	codeBlockCursorIntentMap.delete(nodeKey);
+	return placement;
+}
+//#endregion
+//#region src/components/decorators/BannerEditDecorator.tsx
+function BannerEditDecorator({ nodeKey, bannerType, contentEditor }) {
+	const [editor] = useLexicalComposerContext();
+	const editable = editor.isEditable();
+	const handleTypeChange = useCallback((newType) => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isBannerNode(node)) node.setBannerType(newType);
+		});
+	}, [editor, nodeKey]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rich-banner-inner",
+		children: [/* @__PURE__ */ jsx(RendererWrapper, {
+			defaultRenderer: BannerRenderer,
+			rendererKey: "Banner",
+			props: {
+				type: bannerType,
+				editable,
+				onTypeChange: editable ? handleTypeChange : void 0
+			}
+		}), /* @__PURE__ */ jsx("div", {
+			className: "rich-banner-content",
+			children: /* @__PURE__ */ jsxs(LexicalNestedComposer, {
+				initialEditor: contentEditor,
+				children: [
+					/* @__PURE__ */ jsx(RichTextPlugin, {
+						ErrorBoundary: LexicalErrorBoundary,
+						contentEditable: /* @__PURE__ */ jsx(ContentEditable, {
+							"aria-placeholder": "",
+							className: "rich-banner-content-editable",
+							placeholder: /* @__PURE__ */ jsx("span", { style: { display: "none" } }),
+							style: { outline: "none" }
+						})
+					}),
+					/* @__PURE__ */ jsx(ListPlugin, {}),
+					/* @__PURE__ */ jsx(LinkPlugin, {})
+				]
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/nodes/BannerEditNode.ts
+function createContentEditor() {
+	return createEditor({
+		namespace: "BannerContent",
+		nodes: NESTED_EDITOR_NODES,
+		theme: editorTheme,
+		onError: (error) => {
+			console.error("[BannerContent]", error);
+		}
+	});
+}
+var BannerEditNode = class BannerEditNode extends BannerNode {
+	static clone(node) {
+		const cloned = new BannerEditNode(node.__bannerType, node.__contentState, node.__key);
+		cloned.__contentEditor = node.__contentEditor;
+		return cloned;
+	}
+	constructor(bannerType, contentState, key) {
+		super(bannerType, contentState, key);
+		_defineProperty(this, "__contentEditor", void 0);
+		this.__contentEditor = createContentEditor();
+		if (contentState) {
+			const editorState = this.__contentEditor.parseEditorState(contentState);
+			this.__contentEditor.setEditorState(editorState);
+		}
+	}
+	getContentEditor() {
+		return this.__contentEditor;
+	}
+	static importJSON(serializedNode) {
+		const legacy = serializedNode;
+		const bannerType = normalizeBannerType(serializedNode.bannerType);
+		if (serializedNode.content) return new BannerEditNode(bannerType, serializedNode.content);
+		if (legacy.children) return new BannerEditNode(bannerType, { root: {
+			children: legacy.children,
+			direction: null,
+			format: "",
+			indent: 0,
+			type: "root",
+			version: 1
+		} });
+		return new BannerEditNode(bannerType);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			type: "banner",
+			bannerType: this.__bannerType,
+			content: this.__contentEditor.getEditorState().toJSON(),
+			version: 1
+		};
+	}
+	decorate(_editor, _config) {
+		return createElement(BannerEditDecorator, {
+			nodeKey: this.__key,
+			bannerType: this.__bannerType,
+			contentEditor: this.__contentEditor
+		});
+	}
+};
+_defineProperty(BannerEditNode, "commandItems", [{
+	title: "Banner",
+	icon: createElement(Flag, { size: 20 }),
+	description: "Highlighted banner block",
+	keywords: [
+		"banner",
+		"notice",
+		"announcement"
+	],
+	section: "ADVANCED",
+	placement: ["slash", "toolbar"],
+	group: "insert",
+	onSelect: (editor) => {
+		editor.update(() => {
+			$insertNodes([$createBannerEditNode("note")]);
+		});
+	}
+}]);
+function $createBannerEditNode(bannerType, contentState) {
+	return new BannerEditNode(bannerType, contentState);
+}
+//#endregion
+//#region src/components/decorators/CodeBlockEditDecorator.tsx
+function CodeBlockEditDecorator({ nodeKey, code, language }) {
+	const [editor] = useLexicalComposerContext();
+	const [isSelected] = useLexicalNodeSelection(nodeKey);
+	const [shouldFocusEditor, setShouldFocusEditor] = useState(false);
+	const [cursorPlacement, setCursorPlacement] = useState("start");
+	const editable = editor.isEditable();
+	useEffect(() => {
+		if (!editable || !isSelected) {
+			setShouldFocusEditor(false);
+			return;
+		}
+		let nextShouldFocus = false;
+		let nextCursorPlacement = "start";
+		editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			const selectedNodes = $isNodeSelection(selection) ? selection.getNodes() : null;
+			nextShouldFocus = selectedNodes !== null && selectedNodes.length === 1 && selectedNodes[0]?.getKey() === nodeKey;
+			if (nextShouldFocus) nextCursorPlacement = consumeCodeBlockCursorIntent(nodeKey) ?? "start";
+		});
+		setShouldFocusEditor(nextShouldFocus);
+		if (nextShouldFocus) setCursorPlacement(nextCursorPlacement);
+	}, [
+		editable,
+		editor,
+		isSelected,
+		nodeKey
+	]);
+	const handleCodeChange = useCallback((newCode) => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isCodeBlockNode(node)) node.setCode(newCode);
+		});
+	}, [editor, nodeKey]);
+	const handleLanguageChange = useCallback((newLanguage) => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isCodeBlockNode(node)) node.setLanguage(newLanguage);
+		});
+	}, [editor, nodeKey]);
+	const handleDelete = useCallback(() => {
+		editor.getRootElement()?.focus({ preventScroll: true });
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if (!node) return;
+			const prev = node.getPreviousSibling();
+			const next = node.getNextSibling();
+			const parent = node.getParent();
+			node.remove();
+			if (prev) {
+				if ($isElementNode(prev)) prev.selectEnd();
+				else {
+					if ($isDecoratorNode(prev) && prev.getType() === "code-block") setCodeBlockCursorIntent(prev.getKey(), "end");
+					const selection = $createNodeSelection();
+					selection.add(prev.getKey());
+					$setSelection(selection);
+				}
+				return;
+			}
+			if (next) {
+				if ($isElementNode(next)) next.selectStart();
+				else {
+					if ($isDecoratorNode(next) && next.getType() === "code-block") setCodeBlockCursorIntent(next.getKey(), "start");
+					const selection = $createNodeSelection();
+					selection.add(next.getKey());
+					$setSelection(selection);
+				}
+				return;
+			}
+			if (parent) {
+				const p = $createParagraphNode();
+				parent.append(p);
+				p.selectStart();
+			}
+		});
+	}, [editor, nodeKey]);
+	const handleExitBlock = useCallback((direction) => {
+		editor.getRootElement()?.focus({ preventScroll: true });
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if (!node) return;
+			if (direction === "before") {
+				const prev = node.getPreviousSibling();
+				if (!prev) return;
+				if ($isElementNode(prev)) prev.selectEnd();
+				else {
+					if ($isDecoratorNode(prev) && prev.getType() === "code-block") setCodeBlockCursorIntent(prev.getKey(), "end");
+					const selection = $createNodeSelection();
+					selection.add(prev.getKey());
+					$setSelection(selection);
+				}
+				return;
+			}
+			let next = node.getNextSibling();
+			if (!next) {
+				const p = $createParagraphNode();
+				node.insertAfter(p);
+				next = p;
+			}
+			if ($isElementNode(next)) next.selectStart();
+			else {
+				if ($isDecoratorNode(next) && next.getType() === "code-block") setCodeBlockCursorIntent(next.getKey(), "start");
+				const selection = $createNodeSelection();
+				selection.add(next.getKey());
+				$setSelection(selection);
+			}
+		});
+	}, [editor, nodeKey]);
+	return /* @__PURE__ */ jsx(RendererWrapper, {
+		defaultRenderer: CodeBlockRenderer,
+		rendererKey: "CodeBlock",
+		props: {
+			code,
+			language,
+			editable,
+			onCodeChange: editable ? handleCodeChange : void 0,
+			onLanguageChange: editable ? handleLanguageChange : void 0,
+			onDelete: editable ? handleDelete : void 0,
+			onExitBlock: editable ? handleExitBlock : void 0,
+			selected: editable ? shouldFocusEditor : false,
+			cursorPlacement: editable ? cursorPlacement : "start"
+		}
+	});
+}
+//#endregion
+//#region src/nodes/CodeBlockEditNode.ts
+var _CodeBlockEditNode;
+var CodeBlockEditNode = class CodeBlockEditNode extends CodeBlockNode {
+	static clone(node) {
+		return new CodeBlockEditNode(node.__code, node.__language, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return new CodeBlockEditNode(serializedNode.code, serializedNode.language);
+	}
+	decorate(_editor, _config) {
+		return createElement(CodeBlockEditDecorator, {
+			nodeKey: this.__key,
+			code: this.__code,
+			language: this.__language
+		});
+	}
+};
+_CodeBlockEditNode = CodeBlockEditNode;
+_defineProperty(CodeBlockEditNode, "commandItems", CodeBlockNode.commandItems.map((item) => ({
+	...item,
+	onSelect: (editor) => {
+		editor.update(() => {
+			$insertNodes([new _CodeBlockEditNode("", "text")]);
+		});
+	}
+})));
+function $createCodeBlockEditNode(code, language) {
+	return new CodeBlockEditNode(code, language);
+}
+//#endregion
+//#region src/components/renderers/FootnoteSectionEditRenderer.tsx
+function FootnoteSectionEditRenderer({ definitions }) {
+	const [editor] = useLexicalComposerContext();
+	const { displayNumberMap } = useFootnoteDefinitions();
+	const sortedEntries = Object.entries(definitions).sort(([a], [b]) => (displayNumberMap[a] ?? 0) - (displayNumberMap[b] ?? 0));
+	const handleContentChange = useCallback((identifier, newContent) => {
+		editor.update(() => {
+			const sectionNodes = $nodesOfType(FootnoteSectionNode);
+			if (sectionNodes.length > 0) sectionNodes[0].setDefinition(identifier, newContent);
+		});
+	}, [editor]);
+	const handleRemove = useCallback((identifier) => {
+		editor.update(() => {
+			const sectionNodes = $nodesOfType(FootnoteSectionNode);
+			if (sectionNodes.length > 0) sectionNodes[0].removeDefinition(identifier);
+		});
+	}, [editor]);
+	if (sortedEntries.length === 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rich-footnote-section-content rich-footnote-section-edit",
+		role: "doc-endnotes",
+		children: [/* @__PURE__ */ jsx("hr", { className: "rich-footnote-section-divider" }), /* @__PURE__ */ jsx("ol", {
+			className: "rich-footnote-section-list",
+			children: sortedEntries.map(([identifier, content]) => {
+				const displayNum = displayNumberMap[identifier] ?? identifier;
+				return /* @__PURE__ */ jsxs("li", {
+					className: "rich-footnote-section-item rich-footnote-section-item-edit",
+					id: `footnote-${identifier}`,
+					children: [
+						/* @__PURE__ */ jsxs("span", {
+							className: "rich-footnote-section-item-num",
+							children: [displayNum, "."]
+						}),
+						/* @__PURE__ */ jsx("input", {
+							className: "rich-footnote-section-item-input",
+							placeholder: `Footnote content for [^${identifier}]`,
+							type: "text",
+							value: content,
+							onChange: (e) => handleContentChange(identifier, e.target.value)
+						}),
+						/* @__PURE__ */ jsx("button", {
+							"aria-label": `Remove footnote ${identifier}`,
+							className: "rich-footnote-section-item-remove",
+							type: "button",
+							onClick: () => handleRemove(identifier),
+							children: "×"
+						})
+					]
+				}, identifier);
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/nodes/FootnoteSectionEditNode.ts
+var FootnoteSectionEditNode = class FootnoteSectionEditNode extends FootnoteSectionNode {
+	static getType() {
+		return "footnote-section";
+	}
+	static clone(node) {
+		return new FootnoteSectionEditNode({ ...node.__definitions }, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return new FootnoteSectionEditNode(serializedNode.definitions);
+	}
+	decorate(_editor, _config) {
+		return createElement(FootnoteSectionEditRenderer, {
+			definitions: this.__definitions,
+			nodeKey: this.__key
+		});
+	}
+};
+//#endregion
+//#region src/components/decorators/GridEditDecorator.tsx
+var COL_OPTIONS = [
+	1,
+	2,
+	3,
+	4
+];
+function GridEditDecorator({ nodeKey, cols: initialCols, gap, cellEditors }) {
+	const [editor] = useLexicalComposerContext();
+	const [currentCols, setCurrentCols] = useState(initialCols);
+	useEffect(() => {
+		return editor.registerUpdateListener(({ editorState }) => {
+			editorState.read(() => {
+				const node = $getNodeByKey(nodeKey);
+				if ($isGridContainerNode(node)) setCurrentCols(node.getCols());
+			});
+		});
+	}, [editor, nodeKey]);
+	const handleSetCols = useCallback((cols) => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isGridContainerNode(node)) node.setCols(cols);
+		});
+	}, [editor, nodeKey]);
+	const handleAddRow = useCallback(() => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isGridContainerNode(node)) node.addCells(node.getCols());
+		});
+	}, [editor, nodeKey]);
+	const handleRemoveRow = useCallback(() => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if (!$isGridEditNode(node)) return;
+			const cols = node.getCols();
+			const editors = node.getCellEditors();
+			if (editors.length <= cols) return;
+			if (!editors.slice(-cols).every((cellEditor) => cellEditor.getEditorState().read(() => $getRoot().getTextContentSize() === 0))) return;
+			node.removeCells(cols);
+		});
+	}, [editor, nodeKey]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "rich-grid-toolbar",
+		onMouseDown: (e) => e.preventDefault(),
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "rich-grid-toolbar-icon",
+				children: /* @__PURE__ */ jsx(LayoutGrid, { size: 14 })
+			}),
+			COL_OPTIONS.map((n) => /* @__PURE__ */ jsx("button", {
+				"aria-label": `${n} columns`,
+				className: `rich-grid-col-btn${n === currentCols ? " rich-grid-col-btn-active" : ""}`,
+				type: "button",
+				onClick: () => handleSetCols(n),
+				children: n
+			}, n)),
+			/* @__PURE__ */ jsx("div", { className: "rich-grid-toolbar-divider" }),
+			/* @__PURE__ */ jsx("button", {
+				"aria-label": "Add row",
+				className: "rich-grid-action-btn",
+				type: "button",
+				onClick: handleAddRow,
+				children: /* @__PURE__ */ jsx(Plus, { size: 14 })
+			}),
+			/* @__PURE__ */ jsx("button", {
+				"aria-label": "Remove row",
+				className: "rich-grid-action-btn",
+				type: "button",
+				onClick: handleRemoveRow,
+				children: /* @__PURE__ */ jsx(Minus, { size: 14 })
+			})
+		]
+	}), /* @__PURE__ */ jsx("div", {
+		className: "rich-grid-inner",
+		style: {
+			gridTemplateColumns: `repeat(${currentCols}, 1fr)`,
+			gap
+		},
+		children: cellEditors.map((cellEditor, i) => /* @__PURE__ */ jsx("div", {
+			className: "rich-grid-cell",
+			children: /* @__PURE__ */ jsxs(LexicalNestedComposer, {
+				initialEditor: cellEditor,
+				children: [
+					/* @__PURE__ */ jsx(RichTextPlugin, {
+						ErrorBoundary: LexicalErrorBoundary,
+						contentEditable: /* @__PURE__ */ jsx(ContentEditable, {
+							"aria-placeholder": "",
+							className: "rich-grid-cell-editable",
+							placeholder: /* @__PURE__ */ jsx("span", { style: { display: "none" } })
+						})
+					}),
+					/* @__PURE__ */ jsx(ListPlugin, {}),
+					/* @__PURE__ */ jsx(LinkPlugin, {})
+				]
+			})
+		}, i))
+	})] });
+}
+//#endregion
+//#region src/nodes/GridEditNode.ts
+function createCellEditor() {
+	return createEditor({
+		namespace: "GridCell",
+		nodes: NESTED_EDITOR_NODES,
+		theme: editorTheme,
+		onError: (error) => {
+			console.error("[GridCell]", error);
+		}
+	});
+}
+var GridEditNode = class GridEditNode extends GridContainerNode {
+	static clone(node) {
+		const cloned = new GridEditNode(node.__cols, node.__gap, node.__cellStates, node.__key);
+		cloned.__cellEditors = [...node.__cellEditors];
+		return cloned;
+	}
+	constructor(cols = 2, gap, cellStates, key) {
+		super(cols, gap, cellStates, key);
+		_defineProperty(this, "__cellEditors", void 0);
+		this.__cellEditors = this.__cellStates.map((state) => {
+			const editor = createCellEditor();
+			const editorState = editor.parseEditorState(state);
+			editor.setEditorState(editorState);
+			return editor;
+		});
+	}
+	getCellEditors() {
+		return this.getLatest().__cellEditors;
+	}
+	setCols(cols) {
+		const writable = this.getWritable();
+		const prev = writable.__cellEditors.length;
+		writable.__cols = cols;
+		if (cols > prev) for (let i = prev; i < cols; i++) {
+			const editor = createCellEditor();
+			writable.__cellEditors.push(editor);
+			writable.__cellStates.push({ root: {
+				children: [{
+					type: "paragraph",
+					children: [],
+					direction: null,
+					format: "",
+					indent: 0,
+					textFormat: 0,
+					textStyle: "",
+					version: 1
+				}],
+				direction: null,
+				format: "",
+				indent: 0,
+				type: "root",
+				version: 1
+			} });
+		}
+	}
+	addCells(count) {
+		const writable = this.getWritable();
+		for (let i = 0; i < count; i++) {
+			const editor = createCellEditor();
+			writable.__cellEditors.push(editor);
+			writable.__cellStates.push({ root: {
+				children: [{
+					type: "paragraph",
+					children: [],
+					direction: null,
+					format: "",
+					indent: 0,
+					textFormat: 0,
+					textStyle: "",
+					version: 1
+				}],
+				direction: null,
+				format: "",
+				indent: 0,
+				type: "root",
+				version: 1
+			} });
+		}
+	}
+	removeCells(count) {
+		const writable = this.getWritable();
+		const editors = writable.__cellEditors;
+		const states = writable.__cellStates;
+		const toRemove = Math.min(count, editors.length);
+		for (let i = 0; i < toRemove; i++) {
+			const editor = editors.at(-1);
+			if (!editor) break;
+			if (!editor.getEditorState().read(() => {
+				return $getRoot().getTextContentSize() === 0;
+			})) break;
+			editors.pop();
+			states.pop();
+		}
+	}
+	static importJSON(serializedNode) {
+		const legacy = serializedNode;
+		const cols = legacy.cols || 2;
+		const rawGap = legacy.gap;
+		const gap = typeof rawGap === "number" ? `${rawGap}px` : rawGap;
+		if (legacy.cells && legacy.cells.length > 0) return new GridEditNode(cols, gap, legacy.cells);
+		if (legacy.children) return new GridEditNode(cols, gap, legacy.children.map((child) => {
+			return { root: {
+				children: [child],
+				direction: null,
+				format: "",
+				indent: 0,
+				type: "root",
+				version: 1
+			} };
+		}));
+		return new GridEditNode(cols, gap);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			type: "grid-container",
+			cols: this.__cols,
+			gap: this.__gap,
+			cells: this.__cellEditors.map((editor) => editor.getEditorState().toJSON()),
+			version: 1
+		};
+	}
+	decorate(_editor, _config) {
+		return createElement(GridEditDecorator, {
+			nodeKey: this.__key,
+			cols: this.__cols,
+			gap: this.__gap,
+			cellEditors: this.__cellEditors
+		});
+	}
+};
+_defineProperty(GridEditNode, "slashMenuItems", [{
+	title: "Grid",
+	icon: createElement(LayoutGrid, { size: 20 }),
+	description: "Grid layout container",
+	keywords: [
+		"grid",
+		"columns",
+		"layout"
+	],
+	section: "LAYOUT",
+	onSelect: (editor) => {
+		editor.update(() => {
+			$insertNodes([$createGridEditNode(2)]);
+		});
+	}
+}]);
+function $createGridEditNode(cols = 2, gap) {
+	return new GridEditNode(cols, gap);
+}
+function $isGridEditNode(node) {
+	return node instanceof GridEditNode;
+}
+//#endregion
+//#region src/config-edit.ts
+var customEditNodes = [
+	SpoilerNode,
+	MentionNode,
+	KaTeXInlineNode,
+	KaTeXBlockNode,
+	ImageNode,
+	AlertQuoteEditNode,
+	CodeBlockEditNode,
+	FootnoteNode,
+	FootnoteSectionEditNode,
+	VideoNode,
+	LinkCardNode,
+	DetailsNode,
+	GridEditNode,
+	BannerEditNode,
+	MermaidNode,
+	RubyNode,
+	TagNode
+];
+var allEditNodes = [...builtinNodes, ...customEditNodes];
+//#endregion
+//#region src/node-registry.ts
+var _resolvedEditNodes = null;
+function setResolvedEditNodes(nodes) {
+	_resolvedEditNodes = nodes;
+}
+function getResolvedEditNodes() {
+	return _resolvedEditNodes ?? allEditNodes;
+}
+//#endregion
+export { FootnoteSectionEditNode as a, setCodeBlockCursorIntent as c, customEditNodes as i, setResolvedEditNodes as n, $createCodeBlockEditNode as o, allEditNodes as r, $createBannerEditNode as s, getResolvedEditNodes as t };