@haklex/rich-editor 0.1.1 → 0.3.0

package/dist/node-registry-Dz5OTkh4.js

@@ -0,0 +1,946 @@
+import { C as ImageNode, E as FootnoteNode, _ as KaTeXInlineNode, b as KaTeXBlockNode, c as SpoilerNode, d as MermaidNode, i as TagNode, j as _defineProperty, m as MentionNode, t as editorTheme } from "./theme-B5B2EOWM.js";
+import { l as RendererWrapper, s as useFootnoteDefinitions } from "./KaTeXRenderer-CQQT3BMw.js";
+import { l as semanticClassNames, r as clsx, u as sharedStyles } from "./katex.css-CIOEOXyd.js";
+import { C as GridContainerNode, E as FootnoteSectionNode, F as CodeBlockRenderer, H as normalizeBannerType, M as CommentNode, N as $isCodeBlockNode, O as DetailsNode, P as CodeBlockNode, R as $isBannerNode, S as $isGridContainerNode, U as BannerRenderer, V as BannerNode, b as LinkCardNode, i as VideoNode, l as $isPollNode, n as builtinNodes, s as RubyNode, u as PollNode } from "./config-B5BuLljq.js";
+import { n as gridStyles, t as gridClassNames } from "./grid.css-CJCkLTZc.js";
+import { n as AlertQuoteEditNode, r as NESTED_EDITOR_NODES } from "./AlertQuoteEditNode-C55sxsR3.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, Vote } from "lucide-react";
+import { customAlphabet } from "nanoid";
+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", {
+		role: "doc-endnotes",
+		className: clsx("rich-footnote-section-content", "rich-footnote-section-edit", semanticClassNames.footnoteSection, sharedStyles.footnoteSection),
+		children: [/* @__PURE__ */ jsx("hr", { className: clsx(semanticClassNames.footnoteSectionDivider, sharedStyles.footnoteSectionDivider) }), /* @__PURE__ */ jsx("ol", {
+			className: clsx(semanticClassNames.footnoteSectionList, sharedStyles.footnoteSectionList),
+			children: sortedEntries.map(([identifier, content]) => {
+				const displayNum = displayNumberMap[identifier] ?? identifier;
+				return /* @__PURE__ */ jsxs("li", {
+					id: `footnote-${identifier}`,
+					className: clsx(semanticClassNames.footnoteSectionItem, sharedStyles.footnoteSectionItem, semanticClassNames.footnoteSectionItemEdit, sharedStyles.footnoteSectionItemEdit),
+					children: [
+						/* @__PURE__ */ jsxs("span", {
+							className: clsx(semanticClassNames.footnoteSectionItemNum, sharedStyles.footnoteSectionItemNum),
+							children: [displayNum, "."]
+						}),
+						/* @__PURE__ */ jsx("input", {
+							placeholder: `Footnote content for [^${identifier}]`,
+							type: "text",
+							value: content,
+							className: clsx(semanticClassNames.footnoteSectionItemInput, sharedStyles.footnoteSectionItemInput),
+							onChange: (e) => handleContentChange(identifier, e.target.value)
+						}),
+						/* @__PURE__ */ jsx("button", {
+							"aria-label": `Remove footnote ${identifier}`,
+							type: "button",
+							className: clsx(semanticClassNames.footnoteSectionItemRemove, sharedStyles.footnoteSectionItemRemove),
+							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: clsx(gridClassNames.toolbar, gridStyles.toolbar),
+		onMouseDown: (e) => e.preventDefault(),
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: clsx(gridClassNames.toolbarIcon, gridStyles.toolbarIcon),
+				children: /* @__PURE__ */ jsx(LayoutGrid, { size: 14 })
+			}),
+			COL_OPTIONS.map((n) => /* @__PURE__ */ jsx("button", {
+				"aria-label": `${n} columns`,
+				type: "button",
+				className: clsx(gridClassNames.colButton, gridStyles.colButton, n === currentCols && gridClassNames.colButtonActive, n === currentCols && gridStyles.colButtonActive),
+				onClick: () => handleSetCols(n),
+				children: n
+			}, n)),
+			/* @__PURE__ */ jsx("div", { className: clsx(gridClassNames.toolbarDivider, gridStyles.toolbarDivider) }),
+			/* @__PURE__ */ jsx("button", {
+				"aria-label": "Add row",
+				className: clsx(gridClassNames.actionButton, gridStyles.actionButton),
+				type: "button",
+				onClick: handleAddRow,
+				children: /* @__PURE__ */ jsx(Plus, { size: 14 })
+			}),
+			/* @__PURE__ */ jsx("button", {
+				"aria-label": "Remove row",
+				className: clsx(gridClassNames.actionButton, gridStyles.actionButton),
+				type: "button",
+				onClick: handleRemoveRow,
+				children: /* @__PURE__ */ jsx(Minus, { size: 14 })
+			})
+		]
+	}), /* @__PURE__ */ jsx("div", {
+		className: clsx(gridClassNames.inner, gridStyles.inner),
+		style: {
+			gridTemplateColumns: `repeat(${currentCols}, 1fr)`,
+			gap
+		},
+		children: cellEditors.map((cellEditor, i) => /* @__PURE__ */ jsx("div", {
+			className: clsx(gridClassNames.cell, gridStyles.cell),
+			children: /* @__PURE__ */ jsxs(LexicalNestedComposer, {
+				initialEditor: cellEditor,
+				children: [
+					/* @__PURE__ */ jsx(RichTextPlugin, {
+						ErrorBoundary: LexicalErrorBoundary,
+						contentEditable: /* @__PURE__ */ jsx(ContentEditable, {
+							"aria-placeholder": "",
+							className: clsx(gridClassNames.cellEditable, gridStyles.cellEditable),
+							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/styles/poll-edit.css.ts
+var pollEditClasses = {
+	container: "_15l32q50",
+	meta: "_15l32q51",
+	question: "_15l32q52",
+	optionList: "_15l32q53",
+	optionRow: "_15l32q54",
+	reorderColumn: "_15l32q55",
+	reorderButton: "_15l32q56",
+	optionInput: "_15l32q57",
+	removeButton: "_15l32q58",
+	addOption: "_15l32q59",
+	advancedSummary: "_15l32q5a",
+	advancedGrid: "_15l32q5b",
+	advancedLabel: "_15l32q5c",
+	advancedInput: "_15l32q5d",
+	modeRow: "_15l32q5e",
+	modeLabel: "_15l32q5f"
+};
+//#endregion
+//#region src/components/decorators/PollEditDecorator.tsx
+var makeOptionId = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 6);
+function moveItem(arr, from, to) {
+	if (to < 0 || to >= arr.length) return arr;
+	const next = arr.slice();
+	const [item] = next.splice(from, 1);
+	next.splice(to, 0, item);
+	return next;
+}
+function PollEditDecorator({ closeAt, mode, nodeKey, options, pollId, question, showResults }) {
+	const [editor] = useLexicalComposerContext();
+	const editable = editor.isEditable();
+	const updatePoll = useCallback((mutate) => {
+		editor.update(() => {
+			const node = $getNodeByKey(nodeKey);
+			if ($isPollNode(node)) mutate(node);
+		});
+	}, [editor, nodeKey]);
+	const handleQuestionChange = useCallback((value) => {
+		updatePoll((node) => node.setQuestion(value));
+	}, [updatePoll]);
+	const handleOptionLabelChange = useCallback((id, label) => {
+		updatePoll((node) => node.setOptions(node.getOptions().map((o) => o.id === id ? {
+			...o,
+			label
+		} : o)));
+	}, [updatePoll]);
+	const handleOptionRemove = useCallback((id) => {
+		updatePoll((node) => node.setOptions(node.getOptions().filter((o) => o.id !== id)));
+	}, [updatePoll]);
+	const handleOptionAdd = useCallback(() => {
+		updatePoll((node) => node.setOptions([...node.getOptions(), {
+			id: `o_${makeOptionId()}`,
+			label: ""
+		}]));
+	}, [updatePoll]);
+	const handleOptionMove = useCallback((index, direction) => {
+		updatePoll((node) => {
+			const current = node.getOptions();
+			const next = moveItem(current, index, index + direction);
+			if (next !== current) node.setOptions(next);
+		});
+	}, [updatePoll]);
+	const handleModeChange = useCallback((next) => {
+		updatePoll((node) => node.setMode(next));
+	}, [updatePoll]);
+	const handleCloseAtChange = useCallback((value) => {
+		updatePoll((node) => node.setCloseAt(value || void 0));
+	}, [updatePoll]);
+	const handleShowResultsChange = useCallback((value) => {
+		updatePoll((node) => {
+			if (value === "always" || value === "after-vote" || value === "after-close") node.setShowResults(value);
+			else node.setShowResults(void 0);
+		});
+	}, [updatePoll]);
+	const handleOptionKeyDown = useCallback((event, index) => {
+		if (event.key === "Enter") {
+			event.preventDefault();
+			if (index === options.length - 1) handleOptionAdd();
+		}
+	}, [handleOptionAdd, options.length]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: pollEditClasses.container,
+		"data-poll-id": pollId,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: pollEditClasses.meta,
+				children: ["Poll · ", mode === "single" ? "Single choice" : "Multiple choice"]
+			}),
+			/* @__PURE__ */ jsx("input", {
+				"aria-label": "Poll question",
+				className: pollEditClasses.question,
+				disabled: !editable,
+				placeholder: "Question",
+				value: question,
+				onChange: (event) => handleQuestionChange(event.target.value)
+			}),
+			/* @__PURE__ */ jsx("ul", {
+				className: pollEditClasses.optionList,
+				children: options.map((option, index) => /* @__PURE__ */ jsxs("li", {
+					className: pollEditClasses.optionRow,
+					children: [
+						editable && options.length > 1 && /* @__PURE__ */ jsxs("span", {
+							className: pollEditClasses.reorderColumn,
+							children: [/* @__PURE__ */ jsx("button", {
+								"aria-label": "Move option up",
+								className: pollEditClasses.reorderButton,
+								disabled: index === 0,
+								type: "button",
+								onClick: () => handleOptionMove(index, -1),
+								children: "▲"
+							}), /* @__PURE__ */ jsx("button", {
+								"aria-label": "Move option down",
+								className: pollEditClasses.reorderButton,
+								disabled: index === options.length - 1,
+								type: "button",
+								onClick: () => handleOptionMove(index, 1),
+								children: "▼"
+							})]
+						}),
+						/* @__PURE__ */ jsx("input", {
+							"aria-label": "Option label",
+							className: pollEditClasses.optionInput,
+							disabled: !editable,
+							placeholder: "Option",
+							value: option.label,
+							onChange: (event) => handleOptionLabelChange(option.id, event.target.value),
+							onKeyDown: (event) => handleOptionKeyDown(event, index)
+						}),
+						editable && options.length > 2 && /* @__PURE__ */ jsx("button", {
+							"aria-label": "Remove option",
+							className: pollEditClasses.removeButton,
+							type: "button",
+							onClick: () => handleOptionRemove(option.id),
+							children: "×"
+						})
+					]
+				}, option.id))
+			}),
+			editable && /* @__PURE__ */ jsx("button", {
+				className: pollEditClasses.addOption,
+				type: "button",
+				onClick: handleOptionAdd,
+				children: "+ Add option"
+			}),
+			editable && /* @__PURE__ */ jsxs("div", {
+				className: pollEditClasses.modeRow,
+				children: [/* @__PURE__ */ jsxs("label", {
+					className: pollEditClasses.modeLabel,
+					children: [/* @__PURE__ */ jsx("input", {
+						checked: mode === "single",
+						name: `poll-mode-${nodeKey}`,
+						type: "radio",
+						onChange: () => handleModeChange("single")
+					}), "Single"]
+				}), /* @__PURE__ */ jsxs("label", {
+					className: pollEditClasses.modeLabel,
+					children: [/* @__PURE__ */ jsx("input", {
+						checked: mode === "multiple",
+						name: `poll-mode-${nodeKey}`,
+						type: "radio",
+						onChange: () => handleModeChange("multiple")
+					}), "Multiple"]
+				})]
+			}),
+			editable && /* @__PURE__ */ jsxs("details", { children: [/* @__PURE__ */ jsx("summary", {
+				className: pollEditClasses.advancedSummary,
+				children: "Advanced"
+			}), /* @__PURE__ */ jsxs("div", {
+				className: pollEditClasses.advancedGrid,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: pollEditClasses.advancedLabel,
+						children: "Close at"
+					}),
+					/* @__PURE__ */ jsx("input", {
+						"aria-label": "Closing time",
+						className: pollEditClasses.advancedInput,
+						type: "datetime-local",
+						value: closeAt ?? "",
+						onChange: (event) => handleCloseAtChange(event.target.value)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: pollEditClasses.advancedLabel,
+						children: "Show results"
+					}),
+					/* @__PURE__ */ jsxs("select", {
+						"aria-label": "Show results policy",
+						className: pollEditClasses.advancedInput,
+						value: showResults ?? "always",
+						onChange: (event) => handleShowResultsChange(event.target.value),
+						children: [
+							/* @__PURE__ */ jsx("option", {
+								value: "always",
+								children: "Always"
+							}),
+							/* @__PURE__ */ jsx("option", {
+								value: "after-vote",
+								children: "After vote"
+							}),
+							/* @__PURE__ */ jsx("option", {
+								value: "after-close",
+								children: "After close"
+							})
+						]
+					})
+				]
+			})] })
+		]
+	});
+}
+//#endregion
+//#region src/nodes/PollEditNode.ts
+var PollEditNode = class PollEditNode extends PollNode {
+	static getType() {
+		return "poll";
+	}
+	static clone(node) {
+		return new PollEditNode({
+			pollId: node.__pollId,
+			question: node.__question,
+			options: node.__options,
+			mode: node.__mode,
+			closeAt: node.__closeAt,
+			showResults: node.__showResults
+		}, node.__key);
+	}
+	constructor(payload, key) {
+		super(payload, key);
+	}
+	static importJSON(serializedNode) {
+		return new PollEditNode({
+			pollId: serializedNode.pollId,
+			question: serializedNode.question,
+			options: serializedNode.options,
+			mode: serializedNode.mode,
+			closeAt: serializedNode.closeAt,
+			showResults: serializedNode.showResults
+		});
+	}
+	decorate(_editor, _config) {
+		return createElement(PollEditDecorator, {
+			nodeKey: this.__key,
+			pollId: this.__pollId,
+			question: this.__question,
+			options: this.__options,
+			mode: this.__mode,
+			closeAt: this.__closeAt,
+			showResults: this.__showResults
+		});
+	}
+};
+_defineProperty(PollEditNode, "commandItems", [{
+	title: "Poll",
+	icon: createElement(Vote, { size: 20 }),
+	description: "Reader-facing vote widget",
+	keywords: [
+		"poll",
+		"vote",
+		"survey",
+		"choice"
+	],
+	section: "ADVANCED",
+	placement: ["slash", "toolbar"],
+	group: "insert",
+	onSelect: (editor) => {
+		editor.update(() => {
+			$insertNodes([$createPollEditNode()]);
+		});
+	}
+}]);
+function $createPollEditNode(payload) {
+	return new PollEditNode(payload);
+}
+//#endregion
+//#region src/config-edit.ts
+var customEditNodes = [
+	SpoilerNode,
+	MentionNode,
+	KaTeXInlineNode,
+	KaTeXBlockNode,
+	ImageNode,
+	AlertQuoteEditNode,
+	CodeBlockEditNode,
+	FootnoteNode,
+	FootnoteSectionEditNode,
+	VideoNode,
+	LinkCardNode,
+	CommentNode,
+	DetailsNode,
+	GridEditNode,
+	BannerEditNode,
+	MermaidNode,
+	RubyNode,
+	TagNode,
+	PollEditNode
+];
+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 { $createPollEditNode as a, FootnoteSectionEditNode as c, setCodeBlockCursorIntent as d, customEditNodes as i, $createCodeBlockEditNode as l, setResolvedEditNodes as n, PollEditNode as o, allEditNodes as r, pollEditClasses as s, getResolvedEditNodes as t, $createBannerEditNode as u };