@mx-space/cli 0.14.2 → 0.15.1

package/dist/{Lexical.dev-CtGmYDoh.mjs → Lexical.dev-BSvx45_E.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/lexical@0.48.0_typescript@6.0.3/node_modules/lexical/dist/Lexical.dev.mjs
+//#region ../../node_modules/.pnpm/lexical@0.49.0_typescript@6.0.3/node_modules/lexical/dist/Lexical.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -75,8 +75,10 @@ const NON_BREAKING_SPACE = "\xA0";
 const COMPOSITION_SUFFIX = IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT ? NON_BREAKING_SPACE : "​";
 const DOUBLE_LINE_BREAK = "\n\n";
 const COMPOSITION_START_CHAR = IS_FIREFOX ? NON_BREAKING_SPACE : COMPOSITION_SUFFIX;
-const RTL_REGEX = /* @__PURE__ */ new RegExp("^[^A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿]*[֑-߿יִ-﷽ﹰ-ﻼ]");
-const LTR_REGEX = /* @__PURE__ */ new RegExp("^[^֑-߿יִ-﷽ﹰ-ﻼ]*[A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿]");
+const RTL = "֑-߿יִ-﷽ﹰ-ﻼ";
+const LTR = "A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿";
+const RTL_REGEX = new RegExp("^[^" + LTR + "]*[" + RTL + "]");
+const LTR_REGEX = new RegExp("^[^" + RTL + "]*[" + LTR + "]");
 const TEXT_TYPE_TO_FORMAT = {
 	bold: 1,
 	capitalize: IS_CAPITALIZE,
@@ -448,7 +450,7 @@ function indexPath(root, child) {
 */
 let envLexicalVersion;
 try {
-	envLexicalVersion = "0.48.0+dev.esm";
+	envLexicalVersion = "0.49.0+dev.esm";
 } catch (_unused) {}
 const LEXICAL_VERSION = envLexicalVersion ?? "\"<unknown>+source\"";
 /**
@@ -2970,7 +2972,7 @@ function onSelectionChange(domSelection, editor, isActive) {
 				selection.format = hasTextNodes ? combinedFormat : 0;
 			}
 		}
-		dispatchCommand(editor, SELECTION_CHANGE_COMMAND, void 0);
+		dispatchCommand(editor, SELECTION_CHANGE_COMMAND);
 	});
 }
 function $updateSelectionFormatStyle(selection, format, style) {
@@ -3004,6 +3006,27 @@ function onClick(event, editor) {
 				if (isHTMLElement(domAnchorNode) || isDOMTextNode(domAnchorNode)) $setSelection($internalCreateRangeSelection(lastSelection, domSelection, editor, event));
 			}
 		}
+		if (IS_FIREFOX && domSelection !== null && domSelection.rangeCount === 0) {
+			const rootElement = editor._rootElement;
+			if (rootElement !== null && event.target === rootElement) {
+				const clientY = event.clientY;
+				let offset = rootElement.childNodes.length;
+				for (let i = 0; i < rootElement.childNodes.length; i++) {
+					const child = rootElement.childNodes[i];
+					if (isHTMLElement(child)) {
+						const rect = child.getBoundingClientRect();
+						if (clientY <= (rect.top + rect.bottom) / 2) {
+							offset = i;
+							break;
+						}
+					}
+				}
+				domSelection.setBaseAndExtent(rootElement, offset, rootElement, offset);
+				const newSelection = $internalCreateRangeSelection(lastSelection, domSelection, editor, event);
+				if (newSelection !== null) $setSelection(newSelection);
+				else domSelection.removeAllRanges();
+			}
+		}
 		dispatchCommand(editor, CLICK_COMMAND, event);
 	});
 }
@@ -3180,7 +3203,7 @@ function $handleBeforeInput(event) {
 			dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
 		} else if (data === DOUBLE_LINE_BREAK) {
 			event.preventDefault();
-			dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, void 0);
+			dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND);
 		} else if (data == null && event.dataTransfer) {
 			const text = event.dataTransfer.getData("text/plain");
 			event.preventDefault();
@@ -3219,7 +3242,7 @@ function $handleBeforeInput(event) {
 			if (inputState.isInsertLineBreak && !IS_IOS) {
 				inputState.isInsertLineBreak = false;
 				dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
-			} else dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND, void 0);
+			} else dispatchCommand(editor, INSERT_PARAGRAPH_COMMAND);
 			break;
 		case "insertFromPaste":
 		case "insertFromPasteAsQuotation":
@@ -3266,11 +3289,9 @@ function $handleBeforeInput(event) {
 			dispatchCommand(editor, FORMAT_TEXT_COMMAND, "underline");
 			break;
 		case "historyUndo":
-			dispatchCommand(editor, UNDO_COMMAND, void 0);
-			break;
-		case "historyRedo":
-			dispatchCommand(editor, REDO_COMMAND, void 0);
+			dispatchCommand(editor, UNDO_COMMAND);
 			break;
+		case "historyRedo": dispatchCommand(editor, REDO_COMMAND);
 	}
 	return true;
 }
@@ -3474,19 +3495,21 @@ function $handleKeyDown(event) {
 	} else if (isParagraph(event)) {
 		inputState.isInsertLineBreak = false;
 		dispatchCommand(editor, KEY_ENTER_COMMAND, event);
-	} else if (isDeleteBackward(event)) if (isBackspace(event)) {
-		if (dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event)) markHandledSelectionCommandInsertText(inputState);
-	} else {
-		event.preventDefault();
-		dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
-	}
-	else if (isEscape(event)) dispatchCommand(editor, KEY_ESCAPE_COMMAND, event);
-	else if (isDeleteForward(event)) if (isDelete(event)) dispatchCommand(editor, KEY_DELETE_COMMAND, event);
-	else {
-		event.preventDefault();
-		dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
-	}
-	else if (isDeleteWordBackward(event)) {
+	} else if (isDeleteBackward(event)) {
+		if (isBackspace(event)) {
+			if (dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event)) markHandledSelectionCommandInsertText(inputState);
+		} else {
+			event.preventDefault();
+			dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
+		}
+	} else if (isEscape(event)) dispatchCommand(editor, KEY_ESCAPE_COMMAND, event);
+	else if (isDeleteForward(event)) {
+		if (isDelete(event)) dispatchCommand(editor, KEY_DELETE_COMMAND, event);
+		else {
+			event.preventDefault();
+			dispatchCommand(editor, DELETE_CHARACTER_COMMAND, false);
+		}
+	} else if (isDeleteWordBackward(event)) {
 		event.preventDefault();
 		dispatchCommand(editor, DELETE_WORD_COMMAND, true);
 	} else if (isDeleteWordForward(event)) {
@@ -3510,10 +3533,10 @@ function $handleKeyDown(event) {
 	} else if (isTab(event)) dispatchCommand(editor, KEY_TAB_COMMAND, event);
 	else if (isUndo(event)) {
 		event.preventDefault();
-		dispatchCommand(editor, UNDO_COMMAND, void 0);
+		dispatchCommand(editor, UNDO_COMMAND);
 	} else if (isRedo(event)) {
 		event.preventDefault();
-		dispatchCommand(editor, REDO_COMMAND, void 0);
+		dispatchCommand(editor, REDO_COMMAND);
 	} else {
 		const prevSelection = editor._editorState._selection;
 		if (isSelectAll(event)) {
@@ -4672,10 +4695,14 @@ var LexicalNode = class {
 			$setSelection(selection);
 			const anchor = selection.anchor;
 			const focus = selection.focus;
-			if (anchor.key === toReplaceKey) if (includeChildren && anchor.type === "element") anchor.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + anchor.offset, "element");
-			else $moveSelectionPointToEnd(anchor, writableReplaceWith);
-			if (focus.key === toReplaceKey) if (includeChildren && focus.type === "element") focus.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + focus.offset, "element");
-			else $moveSelectionPointToEnd(focus, writableReplaceWith);
+			if (anchor.key === toReplaceKey) {
+				if (includeChildren && anchor.type === "element") anchor.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + anchor.offset, "element");
+				else $moveSelectionPointToEnd(anchor, writableReplaceWith);
+			}
+			if (focus.key === toReplaceKey) {
+				if (includeChildren && focus.type === "element") focus.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + focus.offset, "element");
+				else $moveSelectionPointToEnd(focus, writableReplaceWith);
+			}
 		}
 		if ($getCompositionKey() === toReplaceKey) $setCompositionKey(key);
 		return writableReplaceWith;
@@ -5043,8 +5070,10 @@ function getStyleObjectFromCSS(css) {
 		}
 		if (chunkStart === -1) chunkStart = i;
 	}
-	if (chunkStart !== -1) if (isParsingValue) currentValue += css.slice(chunkStart, length);
-	else currentProperty += css.slice(chunkStart, length);
+	if (chunkStart !== -1) {
+		if (isParsingValue) currentValue += css.slice(chunkStart, length);
+		else currentProperty += css.slice(chunkStart, length);
+	}
 	const property = currentProperty.trim();
 	const value = currentValue.trim();
 	if (property !== "" && value !== "") styles[property] = value;
@@ -5173,7 +5202,7 @@ function $isInlineFormattable(node) {
 	return node != null && node.__isInlineFormattable === true;
 }
 /** @noInheritDoc */
-var TextNode = class TextNode extends LexicalNode {
+var TextNode = class extends LexicalNode {
 	/** @internal */
 	__text;
 	/** @internal */
@@ -5188,11 +5217,57 @@ var TextNode = class TextNode extends LexicalNode {
 	get __isInlineFormattable() {
 		return true;
 	}
-	static getType() {
-		return "text";
-	}
-	static clone(node) {
-		return new TextNode(node.__text, node.__key);
+	$config() {
+		return this.config("text", { importDOM: {
+			"#text": () => ({
+				conversion: $convertTextDOMNode,
+				priority: 0
+			}),
+			b: () => ({
+				conversion: convertBringAttentionToElement,
+				priority: 0
+			}),
+			code: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			em: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			i: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			mark: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			s: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			span: () => ({
+				conversion: convertSpanElement,
+				priority: 0
+			}),
+			strong: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			sub: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			sup: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			}),
+			u: () => ({
+				conversion: convertTextFormatElement,
+				priority: 0
+			})
+		} });
 	}
 	afterCloneFrom(prevNode) {
 		super.afterCloneFrom(prevNode);
@@ -5390,61 +5465,6 @@ var TextNode = class TextNode extends LexicalNode {
 		if (prevStyle !== nextStyle) setDOMStyleFromCSS(dom.style, nextStyle, prevStyle);
 		return false;
 	}
-	static importDOM() {
-		return {
-			"#text": () => ({
-				conversion: $convertTextDOMNode,
-				priority: 0
-			}),
-			b: () => ({
-				conversion: convertBringAttentionToElement,
-				priority: 0
-			}),
-			code: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			em: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			i: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			mark: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			s: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			span: () => ({
-				conversion: convertSpanElement,
-				priority: 0
-			}),
-			strong: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			sub: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			sup: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			}),
-			u: () => ({
-				conversion: convertTextFormatElement,
-				priority: 0
-			})
-		};
-	}
-	static importJSON(serializedNode) {
-		return $createTextNode().updateFromJSON(serializedNode);
-	}
 	updateFromJSON(serializedNode) {
 		return super.updateFromJSON(serializedNode).setTextContent(serializedNode.text).setFormat(serializedNode.format).setDetail(serializedNode.detail).setMode(serializedNode.mode).setStyle(serializedNode.style);
 	}
@@ -5930,29 +5950,20 @@ function applyTextFormatFromStyle(style, shouldApply) {
 	};
 }
 /** @noInheritDoc */
-var TabNode = class TabNode extends TextNode {
-	static getType() {
-		return "tab";
-	}
-	static clone(node) {
-		return new TabNode(node.__key);
+var TabNode = class extends TextNode {
+	$config() {
+		return this.config("tab", { extends: TextNode });
 	}
-	constructor(key) {
+	constructor(key = void 0) {
 		super("	", key);
 		this.__detail = IS_UNMERGEABLE;
 	}
-	static importDOM() {
-		return null;
-	}
 	createDOM(config) {
 		const dom = super.createDOM(config);
 		const classNames = getCachedClassNameArray(config.theme, "tab");
 		if (classNames !== void 0) dom.classList.add(...classNames);
 		return dom;
 	}
-	static importJSON(serializedTabNode) {
-		return $createTabNode().updateFromJSON(serializedTabNode);
-	}
 	/**
 	* Always normalizes the stored content to `'\t'` regardless of input — see
 	* comment below for the rationale.
@@ -6086,6 +6097,28 @@ function $transferStartingElementPointToTextPoint(start, end, format, style) {
 	if (start.is(end)) end.set(textNode.__key, 0, "text");
 	start.set(textNode.__key, 0, "text");
 }
+function $insertTextAtPoint(selection, text, format, style) {
+	const anchorNode = selection.anchor.getNode();
+	if (!$isTextNode(anchorNode)) formatDevErrorMessage(`insertText: anchor is not a text node`);
+	const offset = selection.anchor.offset;
+	const textNode = $createTextNode(text);
+	textNode.setFormat(format);
+	textNode.setStyle(style);
+	const parent = anchorNode.getParentOrThrow();
+	if (offset === 0) {
+		if (parent.isInline() && !anchorNode.__prev) parent.insertBefore(textNode);
+		else anchorNode.insertBefore(textNode, false);
+	} else if (offset === anchorNode.getTextContentSize()) {
+		if (parent.isInline() && !anchorNode.__next) parent.insertAfter(textNode);
+		else anchorNode.insertAfter(textNode, false);
+	} else {
+		const [before] = anchorNode.splitText(offset);
+		before.insertAfter(textNode, false);
+	}
+	if (anchorNode.getTextContent() === "" && anchorNode.isAttached()) anchorNode.remove();
+	textNode.selectEnd();
+	if (textNode.isComposing() && selection.anchor.type === "text") selection.anchor.set(selection.anchor.key, selection.anchor.offset - text.length, selection.anchor.type);
+}
 var NodeSelection = class NodeSelection {
 	_nodes;
 	_cachedNodes;
@@ -6311,10 +6344,11 @@ var RangeSelection = class RangeSelection {
 				prevWasElement = false;
 				if ($isTextNode(node)) {
 					let text = node.getTextContent();
-					if (node === firstNode) if (node === lastNode) {
-						if (anchor.type !== "element" || focus.type !== "element" || focus.offset === anchor.offset) text = anchorOffset < focusOffset ? text.slice(anchorOffset, focusOffset) : text.slice(focusOffset, anchorOffset);
-					} else text = isBefore ? text.slice(anchorOffset) : text.slice(focusOffset);
-					else if (node === lastNode) text = isBefore ? text.slice(0, focusOffset) : text.slice(0, anchorOffset);
+					if (node === firstNode) {
+						if (node === lastNode) {
+							if (anchor.type !== "element" || focus.type !== "element" || focus.offset === anchor.offset) text = anchorOffset < focusOffset ? text.slice(anchorOffset, focusOffset) : text.slice(focusOffset, anchorOffset);
+						} else text = isBefore ? text.slice(anchorOffset) : text.slice(focusOffset);
+					} else if (node === lastNode) text = isBefore ? text.slice(0, focusOffset) : text.slice(0, anchorOffset);
 					textContent += text;
 				} else if (($isDecoratorNode(node) || $isLineBreakNode(node)) && (node !== lastNode || !this.isCollapsed())) textContent += node.getTextContent();
 			}
@@ -6401,201 +6435,93 @@ var RangeSelection = class RangeSelection {
 	* @param text the text to insert into the Selection
 	*/
 	insertText(text) {
-		const anchor = this.anchor;
-		const focus = this.focus;
-		const format = this.format;
-		const style = this.style;
-		let firstPoint = anchor;
-		let endPoint = focus;
-		if (!this.isCollapsed() && focus.isBefore(anchor)) {
-			firstPoint = focus;
-			endPoint = anchor;
-		}
-		if (firstPoint.type === "element") $transferStartingElementPointToTextPoint(firstPoint, endPoint, format, style);
-		if (endPoint.type === "element") $setPointFromCaret(endPoint, $normalizeCaret($caretFromPoint(endPoint, "next")));
-		const startOffset = firstPoint.offset;
-		let endOffset = endPoint.offset;
-		const selectedNodes = this.getNodes();
-		const selectedNodesLength = selectedNodes.length;
-		let firstNode = selectedNodes[0];
-		if (!$isTextNode(firstNode)) formatDevErrorMessage(`insertText: first node is not a text node`);
-		const firstNodeTextLength = firstNode.getTextContent().length;
-		const firstNodeParent = firstNode.getParentOrThrow();
-		let lastNode = selectedNodes[selectedNodesLength - 1];
-		if (selectedNodesLength === 1 && endPoint.type === "element") {
-			endOffset = firstNodeTextLength;
-			endPoint.set(firstPoint.key, endOffset, "text");
-		}
-		if (this.isCollapsed() && startOffset === firstNodeTextLength && ($isTokenOrSegmented(firstNode) || !firstNode.canInsertTextAfter() || !firstNodeParent.canInsertTextAfter() && firstNode.getNextSibling() === null)) {
-			const candidateNextSibling = firstNode.getNextSibling();
-			let nextSibling;
-			if (!$isTextNode(candidateNextSibling) || !candidateNextSibling.canInsertTextBefore() || $isTokenOrSegmented(candidateNextSibling)) {
-				nextSibling = $createTextNode();
-				nextSibling.setFormat(format);
-				nextSibling.setStyle(style);
-				if (!firstNodeParent.canInsertTextAfter()) firstNodeParent.insertAfter(nextSibling);
-				else firstNode.insertAfter(nextSibling);
-			} else nextSibling = candidateNextSibling;
-			nextSibling.select(0, 0);
-			firstNode = nextSibling;
-			if (text !== "") {
-				this.insertText(text);
-				return;
-			}
-		} else if (this.isCollapsed() && startOffset === 0 && ($isTokenOrSegmented(firstNode) || !firstNode.canInsertTextBefore() || !firstNodeParent.canInsertTextBefore() && firstNode.getPreviousSibling() === null)) {
-			const candidatePrevSibling = firstNode.getPreviousSibling();
-			let prevSibling;
-			if (!$isTextNode(candidatePrevSibling) || $isTokenOrSegmented(candidatePrevSibling)) {
-				prevSibling = $createTextNode();
-				prevSibling.setFormat(format);
-				if (!firstNodeParent.canInsertTextBefore()) firstNodeParent.insertBefore(prevSibling);
-				else firstNode.insertBefore(prevSibling);
-			} else prevSibling = candidatePrevSibling;
-			prevSibling.select();
-			firstNode = prevSibling;
-			if (text !== "") {
-				this.insertText(text);
-				return;
-			}
-		} else if (firstNode.isSegmented() && startOffset !== firstNodeTextLength) if ($getCompositionKey() !== null) firstNode = firstNode.setMode("normal").setFormat(format).setStyle(style);
-		else {
-			const textNode = $createTextNode(firstNode.getTextContent());
-			textNode.setFormat(format);
-			firstNode.replace(textNode);
-			firstNode = textNode;
-		}
-		else if (!this.isCollapsed() && text !== "") {
-			const lastNodeParent = lastNode.getParent();
-			if (!firstNodeParent.canInsertTextBefore() || !firstNodeParent.canInsertTextAfter() || $isElementNode(lastNodeParent) && (!lastNodeParent.canInsertTextBefore() || !lastNodeParent.canInsertTextAfter())) {
-				this.insertText("");
-				$normalizeSelectionPointsForBoundaries(this.anchor, this.focus);
-				this.insertText(text);
+		let format = this.format;
+		let style = this.style;
+		if (!this.isCollapsed()) {
+			const firstNode = (this.focus.isBefore(this.anchor) ? this.focus : this.anchor).getNode();
+			if ($isTextNode(firstNode)) {
+				format = firstNode.getFormat();
+				style = firstNode.getStyle();
+			}
+			this.removeText();
+			this.format = format;
+			this.style = style;
+			if (text === "") return;
+			if ($getCompositionKey() === null) {
+				if (this.anchor.type === "element") $transferStartingElementPointToTextPoint(this.anchor, this.focus, format, style);
+				$insertTextAtPoint(this, text, format, style);
 				return;
 			}
 		}
-		if (selectedNodesLength === 1) {
-			if ($isTokenOrTab(firstNode)) {
-				const textNode = $createTextNode(text);
-				textNode.select();
-				firstNode.replace(textNode);
-				return;
-			}
-			const firstNodeFormat = firstNode.getFormat();
-			const firstNodeStyle = firstNode.getStyle();
-			if (startOffset === endOffset && (firstNodeFormat !== format || firstNodeStyle !== style)) if (firstNode.getTextContent() === "") {
-				firstNode.setFormat(format);
-				firstNode.setStyle(style);
-			} else {
-				const textNode = $createTextNode(text);
-				textNode.setFormat(format);
-				textNode.setStyle(style);
-				textNode.select();
-				if (startOffset === 0) firstNode.insertBefore(textNode, false);
+		if (this.anchor.type === "element") $transferStartingElementPointToTextPoint(this.anchor, this.focus, format, style);
+		const anchorNode = this.anchor.getNode();
+		if (!$isTextNode(anchorNode)) formatDevErrorMessage(`insertText: anchor is not a text node`);
+		const offset = this.anchor.offset;
+		const anchorParent = anchorNode.getParentOrThrow();
+		const anchorSize = anchorNode.getTextContentSize();
+		if ($isTokenOrSegmented(anchorNode) || offset === 0 && (!anchorNode.canInsertTextBefore() || !anchorParent.canInsertTextBefore() && !anchorNode.__prev) || offset === anchorSize && (!anchorNode.canInsertTextAfter() || !anchorParent.canInsertTextAfter() && !anchorNode.__next)) {
+			if (anchorNode.isSegmented() && offset !== 0 && offset !== anchorSize) {
+				if ($getCompositionKey() !== null) anchorNode.setMode("normal").setFormat(format).setStyle(style);
 				else {
-					const [targetNode] = firstNode.splitText(startOffset);
-					targetNode.insertAfter(textNode, false);
-				}
-				if (textNode.isComposing() && this.anchor.type === "text") {
-					this.anchor.offset -= text.length;
-					this._cachedNodes = null;
-					this._cachedIsBackward = null;
+					const replacement = $createTextNode(anchorNode.getTextContent());
+					replacement.setFormat(format);
+					replacement.setStyle(style);
+					anchorNode.replace(replacement);
+					replacement.select(offset, offset);
 				}
+				if (text !== "") this.insertText(text);
 				return;
 			}
-			else if ($isTabNode(firstNode)) {
-				const textNode = $createTextNode(text);
-				textNode.setFormat(format);
-				textNode.setStyle(style);
-				textNode.select();
-				firstNode.replace(textNode);
+			if (text === "") return;
+			if (offset === 0) {
+				const prev = anchorNode.getPreviousSibling();
+				if ($isTextNode(prev) && prev.canInsertTextAfter() && !$isTokenOrSegmented(prev)) prev.select();
+				else {
+					const newNode = $createTextNode();
+					newNode.setFormat(format);
+					newNode.setStyle(style);
+					if (!anchorParent.canInsertTextBefore()) anchorParent.insertBefore(newNode);
+					else anchorNode.insertBefore(newNode);
+					newNode.select();
+				}
+				this.insertText(text);
 				return;
-			}
-			const delCount = endOffset - startOffset;
-			firstNode = firstNode.spliceText(startOffset, delCount, text, true);
-			if (firstNode.getTextContent() === "") firstNode.remove();
-			else if (this.anchor.type === "text") {
-				this.format = firstNodeFormat;
-				this.style = firstNodeStyle;
-				if (firstNode.isComposing()) {
-					this.anchor.offset -= text.length;
-					this._cachedNodes = null;
-					this._cachedIsBackward = null;
+			} else if (offset === anchorSize) {
+				const next = anchorNode.getNextSibling();
+				if ($isTextNode(next) && next.canInsertTextBefore() && !$isTokenOrSegmented(next)) next.select(0, 0);
+				else {
+					const newNode = $createTextNode();
+					newNode.setFormat(format);
+					newNode.setStyle(style);
+					if (!anchorParent.canInsertTextAfter()) anchorParent.insertAfter(newNode);
+					else anchorNode.insertAfter(newNode);
+					newNode.select(0, 0);
 				}
+				this.insertText(text);
+				return;
 			}
-		} else {
-			const markedNodeKeysForKeep = /* @__PURE__ */ new Set([...firstNode.getParentKeys(), ...lastNode.getParentKeys()]);
-			const firstElement = $isElementNode(firstNode) ? firstNode : firstNode.getParentOrThrow();
-			let lastElement = $isElementNode(lastNode) ? lastNode : lastNode.getParentOrThrow();
-			let lastElementChild = lastNode;
-			if (!firstElement.is(lastElement) && lastElement.isInline()) do {
-				lastElementChild = lastElement;
-				lastElement = lastElement.getParentOrThrow();
-			} while (lastElement.isInline());
-			if (endPoint.type === "text" && (endOffset !== 0 || lastNode.getTextContent() === "") || endPoint.type === "element" && lastNode.getIndexWithinParent() < endOffset) if ($isTextNode(lastNode) && !$isTokenOrTab(lastNode) && endOffset !== lastNode.getTextContentSize()) {
-				if (lastNode.isSegmented()) {
-					const textNode = $createTextNode(lastNode.getTextContent());
-					lastNode.replace(textNode);
-					lastNode = textNode;
-				}
-				if (!$isRootNode(endPoint.getNode()) && endPoint.type === "text") {
-					if (!$isTextNode(lastNode)) formatDevErrorMessage(`insertText: lastNode is not a TextNode`);
-					lastNode = lastNode.spliceText(0, endOffset, "");
-				}
-				markedNodeKeysForKeep.add(lastNode.__key);
+			const newNode = $createTextNode(text);
+			newNode.setFormat(format);
+			newNode.setStyle(style);
+			anchorNode.replace(newNode);
+			newNode.select();
+			return;
+		}
+		if (text === "") return;
+		const atStartOfInline = anchorParent.isInline() && offset === 0 && !anchorNode.__prev;
+		const atEndOfInline = anchorParent.isInline() && offset === anchorSize && !anchorNode.__next;
+		const formatDiffers = anchorNode.getFormat() !== format || anchorNode.getStyle() !== style;
+		if (atStartOfInline || atEndOfInline || formatDiffers) {
+			if (anchorNode.getTextContent() === "" && !atStartOfInline && !atEndOfInline) {
+				anchorNode.setFormat(format);
+				anchorNode.setStyle(style);
 			} else {
-				const lastNodeParent = lastNode.getParentOrThrow();
-				if (!lastNodeParent.canBeEmpty() && lastNodeParent.getChildrenSize() === 1) lastNodeParent.remove();
-				else lastNode.remove();
-			}
-			else markedNodeKeysForKeep.add(lastNode.__key);
-			const lastNodeChildren = lastElement.getChildren();
-			const selectedNodesSet = new Set(selectedNodes);
-			const firstAndLastElementsAreEqual = firstElement.is(lastElement);
-			const insertionTarget = firstElement.isInline() && firstNode.getNextSibling() === null ? firstElement : firstNode;
-			for (let i = lastNodeChildren.length - 1; i >= 0; i--) {
-				const lastNodeChild = lastNodeChildren[i];
-				if (lastNodeChild.is(firstNode) || $isElementNode(lastNodeChild) && lastNodeChild.isParentOf(firstNode)) break;
-				if (lastNodeChild.isAttached()) if (!selectedNodesSet.has(lastNodeChild) || lastNodeChild.is(lastElementChild)) {
-					if (!firstAndLastElementsAreEqual) insertionTarget.insertAfter(lastNodeChild, false);
-				} else lastNodeChild.remove();
-			}
-			if (!firstAndLastElementsAreEqual) {
-				let parent = lastElement;
-				let lastRemovedParent = null;
-				while (parent !== null) {
-					const children = parent.getChildren();
-					const childrenLength = children.length;
-					if (childrenLength === 0 || children[childrenLength - 1].is(lastRemovedParent)) {
-						markedNodeKeysForKeep.delete(parent.__key);
-						lastRemovedParent = parent;
-					}
-					parent = parent.getParent();
-				}
-			}
-			if (!$isTokenOrTab(firstNode)) {
-				firstNode = firstNode.spliceText(startOffset, firstNodeTextLength - startOffset, text, true);
-				if (firstNode.getTextContent() === "") firstNode.remove();
-				else if (this.anchor.type === "text") {
-					this.format = firstNode.getFormat();
-					this.style = firstNode.getStyle();
-					if (firstNode.isComposing()) {
-						this.anchor.offset -= text.length;
-						this._cachedNodes = null;
-						this._cachedIsBackward = null;
-					}
-				}
-			} else if (startOffset === firstNodeTextLength) firstNode.select();
-			else {
-				const textNode = $createTextNode(text);
-				textNode.select();
-				firstNode.replace(textNode);
-			}
-			for (let i = 1; i < selectedNodesLength; i++) {
-				const selectedNode = selectedNodes[i];
-				const key = selectedNode.__key;
-				if (!markedNodeKeysForKeep.has(key)) selectedNode.remove();
+				$insertTextAtPoint(this, text, format, style);
+				return;
 			}
 		}
+		anchorNode.spliceText(offset, 0, text, true);
+		if (anchorNode.isComposing() && this.anchor.type === "text") this.anchor.set(this.anchor.key, this.anchor.offset - text.length, this.anchor.type);
 	}
 	/**
 	* Removes the text in the Selection, adjusting the EditorState accordingly.
@@ -6846,19 +6772,21 @@ var RangeSelection = class RangeSelection {
 		if (granularity === "character" && $isTextNode(focusNode) && focusNode.isUnmergeable()) {
 			if (isBackward ? this.focus.offset === 0 : this.focus.offset === focusNode.getTextContentSize()) {
 				const sibling = $getSiblingCaret(focusNode, isBackward ? "previous" : "next").getNodeAtCaret();
-				if ($isTextNode(sibling)) if (collapse) {
-					const sibKeyedDOM = editor.getElementByKey(sibling.getKey());
-					const sibDOM = sibKeyedDOM ? $getDOMTextNode(sibling, sibKeyedDOM, editor) : null;
-					if (sibDOM) {
-						const sibOffset = isBackward ? sibDOM.length : 0;
-						setDOMSelectionBaseAndExtent(domSelection, sibDOM, sibOffset, sibDOM, sibOffset);
+				if ($isTextNode(sibling)) {
+					if (collapse) {
+						const sibKeyedDOM = editor.getElementByKey(sibling.getKey());
+						const sibDOM = sibKeyedDOM ? $getDOMTextNode(sibling, sibKeyedDOM, editor) : null;
+						if (sibDOM) {
+							const sibOffset = isBackward ? sibDOM.length : 0;
+							setDOMSelectionBaseAndExtent(domSelection, sibDOM, sibOffset, sibDOM, sibOffset);
+						}
+					} else {
+						const sibLen = sibling.getTextContentSize();
+						if (isBackward) this.focus.set(sibling.__key, sibLen - 1, "text");
+						else this.focus.set(sibling.__key, 1, "text");
+						this.dirty = true;
+						return;
 					}
-				} else {
-					const sibLen = sibling.getTextContentSize();
-					if (isBackward) this.focus.set(sibling.__key, sibLen - 1, "text");
-					else this.focus.set(sibling.__key, 1, "text");
-					this.dirty = true;
-					return;
 				}
 			}
 		}
@@ -7400,8 +7328,10 @@ function $updateCaretSelectionForUnicodeCharacter(selection, isBackward) {
 		const endOffset = isBefore ? focusOffset : anchorOffset;
 		const characterOffset = endOffset - 1;
 		if (startOffset !== characterOffset) {
-			if (shouldDeleteExactlyOneCodeUnit(anchorNode.getTextContent().slice(startOffset, endOffset))) if (isBackward) focus.set(focus.key, characterOffset, focus.type);
-			else anchor.set(anchor.key, characterOffset, anchor.type);
+			if (shouldDeleteExactlyOneCodeUnit(anchorNode.getTextContent().slice(startOffset, endOffset))) {
+				if (isBackward) focus.set(focus.key, characterOffset, focus.type);
+				else anchor.set(anchor.key, characterOffset, anchor.type);
+			}
 		}
 	}
 }
@@ -8095,10 +8025,12 @@ function $getNodesFromCaretRangeCompat(range) {
 	}
 	while (nodes.length > 1) {
 		const lastIncludedNode = nodes[nodes.length - 1];
-		if ($isElementNode(lastIncludedNode)) if (seenElements.has(lastIncludedNode) || lastIncludedNode.isEmpty() || seenAncestors.has(lastIncludedNode));
-		else {
-			nodes.pop();
-			continue;
+		if ($isElementNode(lastIncludedNode)) {
+			if (seenElements.has(lastIncludedNode) || lastIncludedNode.isEmpty() || seenAncestors.has(lastIncludedNode));
+			else {
+				nodes.pop();
+				continue;
+			}
 		}
 		break;
 	}
@@ -8503,7 +8435,7 @@ function $commitPendingUpdatesImpl(editor, recoveryEditorState) {
 		}
 	}
 	if (mutatedNodes !== null) triggerMutationListeners(editor, mutatedNodes, tags, dirtyLeaves, currentEditorState);
-	if (!$isRangeSelection(pendingSelection) && pendingSelection !== null && (currentSelection === null || !currentSelection.is(pendingSelection))) editor.dispatchCommand(SELECTION_CHANGE_COMMAND, void 0);
+	if (!$isRangeSelection(pendingSelection) && pendingSelection !== null && (currentSelection === null || !currentSelection.is(pendingSelection))) editor.dispatchCommand(SELECTION_CHANGE_COMMAND);
 	/**
 	* Capture pendingDecorators after garbage collecting detached decorators
 	*/
@@ -8692,9 +8624,11 @@ function $beginUpdate(editor, updateFn, options) {
 	const headless = editor._headless || editor.getRootElement() === null;
 	setPendingNodeToClone(null);
 	try {
-		if (editorStateWasCloned) if (headless) {
-			if (currentEditorState._selection !== null) pendingEditorState._selection = currentEditorState._selection.clone();
-		} else pendingEditorState._selection = $internalCreateSelection(editor, options && options.event || null);
+		if (editorStateWasCloned) {
+			if (headless) {
+				if (currentEditorState._selection !== null) pendingEditorState._selection = currentEditorState._selection.clone();
+			} else pendingEditorState._selection = $internalCreateSelection(editor, options && options.event || null);
+		}
 		const startingCompositionKey = editor._compositionKey;
 		updateFn();
 		skipTransforms = $processNestedUpdates(editor, skipTransforms);
@@ -8754,8 +8688,12 @@ function $beginUpdate(editor, updateFn, options) {
 * within an update
 */
 function updateEditorSync(editor, updateFn, options) {
-	if (activeEditor === editor && options === void 0) updateFn();
-	else $beginUpdate(editor, updateFn, options);
+	if (activeEditor === editor && options === void 0) {
+		if (isCurrentlyReadOnlyMode()) {
+			console.warn("updateEditorSync: an editor update (e.g. a command listener that mutates the editor) ran while a read-only context was on the stack. This most commonly happens when a command is dispatched from inside editor.read(). The update has been deferred to a fresh writable update so it still applies, but dispatching mutations from a read-only context is an anti-pattern — dispatch after editor.read() returns, or via queueMicrotask.");
+			$beginUpdate(editor, updateFn, options);
+		} else updateFn();
+	} else $beginUpdate(editor, updateFn, options);
 }
 function updateEditor(editor, updateFn, options) {
 	if (editor._updating) editor._updates.push([updateFn, options]);
@@ -9198,10 +9136,12 @@ var ElementNode = class extends LexicalNode {
 		const nodeAfterRange = this.getChildAtIndex(start + deleteCount);
 		let nodeBeforeRange = null;
 		let newSize = oldSize - deleteCount + nodesToInsert.length;
-		if (start !== 0) if (start === oldSize) nodeBeforeRange = this.getLastChild();
-		else {
-			const node = this.getChildAtIndex(start);
-			if (node !== null) nodeBeforeRange = node.getPreviousSibling();
+		if (start !== 0) {
+			if (start === oldSize) nodeBeforeRange = this.getLastChild();
+			else {
+				const node = this.getChildAtIndex(start);
+				if (node !== null) nodeBeforeRange = node.getPreviousSibling();
+			}
 		}
 		if (deleteCount > 0) {
 			let nodeToDelete = nodeBeforeRange === null ? this.getFirstChild() : nodeBeforeRange.getNextSibling();
@@ -9434,14 +9374,11 @@ function $isDecoratorNode(node) {
 	return node instanceof DecoratorNode;
 }
 /** @noInheritDoc */
-var RootNode = class RootNode extends ElementNode {
+var RootNode = class extends ElementNode {
 	/** @internal */
 	__cachedText;
-	static getType() {
-		return "root";
-	}
-	static clone() {
-		return new RootNode();
+	$config() {
+		return this.config("root", { extends: ElementNode });
 	}
 	constructor() {
 		super("root");
@@ -9578,8 +9515,8 @@ var EditorState = class EditorState {
 */
 /** @internal */
 var ArtificialNode__DO_NOT_USE = class extends ElementNode {
-	static getType() {
-		return "artificial";
+	$config() {
+		return this.config("artificial", { extends: ElementNode });
 	}
 	createDOM(config) {
 		return $getDocument().createElement("div");
@@ -9593,16 +9530,16 @@ var ArtificialNode__DO_NOT_USE = class extends ElementNode {
 *
 */
 /** @noInheritDoc */
-var LineBreakNode = class LineBreakNode extends LexicalNode {
+var LineBreakNode = class extends LexicalNode {
 	/** @internal */
-	static getType() {
-		return "linebreak";
-	}
-	static clone(node) {
-		return new LineBreakNode(node.__key);
-	}
-	constructor(key) {
-		super(key);
+	$config() {
+		return this.config("linebreak", { importDOM: { br: (node) => {
+			if (isOnlyChildInBlockNode(node) || isLastChildInBlockNode(node)) return null;
+			return {
+				conversion: $convertLineBreakElement,
+				priority: 0
+			};
+		} } });
 	}
 	getTextContent() {
 		return "\n";
@@ -9616,18 +9553,6 @@ var LineBreakNode = class LineBreakNode extends LexicalNode {
 	isInline() {
 		return true;
 	}
-	static importDOM() {
-		return { br: (node) => {
-			if (isOnlyChildInBlockNode(node) || isLastChildInBlockNode(node)) return null;
-			return {
-				conversion: $convertLineBreakElement,
-				priority: 0
-			};
-		} };
-	}
-	static importJSON(serializedLineBreakNode) {
-		return $createLineBreakNode().updateFromJSON(serializedLineBreakNode);
-	}
 };
 function $convertLineBreakElement(node) {
 	return { node: $createLineBreakNode() };
@@ -9686,13 +9611,16 @@ function isWhitespaceDomTextNode(node) {
 *
 */
 /** @noInheritDoc */
-var ParagraphNode = class ParagraphNode extends ElementNode {
+var ParagraphNode = class extends ElementNode {
 	/** @internal */
-	static getType() {
-		return "paragraph";
-	}
-	static clone(node) {
-		return new ParagraphNode(node.__key);
+	$config() {
+		return this.config("paragraph", {
+			extends: ElementNode,
+			importDOM: { p: () => ({
+				conversion: $convertParagraphElement,
+				priority: 0
+			}) }
+		});
 	}
 	createDOM(config) {
 		const dom = $getDocument().createElement("p");
@@ -9703,12 +9631,6 @@ var ParagraphNode = class ParagraphNode extends ElementNode {
 	updateDOM(prevNode, dom, config) {
 		return false;
 	}
-	static importDOM() {
-		return { p: (node) => ({
-			conversion: $convertParagraphElement,
-			priority: 0
-		}) };
-	}
 	exportDOM(editor) {
 		const { element } = super.exportDOM(editor);
 		if (isHTMLElement(element)) {
@@ -9718,9 +9640,6 @@ var ParagraphNode = class ParagraphNode extends ElementNode {
 		}
 		return { element };
 	}
-	static importJSON(serializedNode) {
-		return $createParagraphNode().updateFromJSON(serializedNode);
-	}
 	exportJSON() {
 		const json = super.exportJSON();
 		if (json.textFormat === void 0 || json.textStyle === void 0) {
@@ -10492,8 +10411,8 @@ var LexicalEditor = class {
 	* @param type - the type of command listeners to trigger.
 	* @param payload - the data to pass as an argument to the command listeners.
 	*/
-	dispatchCommand(type, payload) {
-		return dispatchCommand(this, type, payload);
+	dispatchCommand(type, ...args) {
+		return dispatchCommand(this, type, ...args);
 	}
 	/**
 	* Gets a map of all decorators in the editor.
@@ -10666,8 +10585,10 @@ var LexicalEditor = class {
 				const root = $getRoot();
 				if (selection !== null) {
 					if (!selection.dirty) $setSelection(selection.clone());
-				} else if (root.getChildrenSize() !== 0) if (options.defaultSelection === "rootStart") root.selectStart();
-				else root.selectEnd();
+				} else if (root.getChildrenSize() !== 0) {
+					if (options.defaultSelection === "rootStart") root.selectStart();
+					else root.selectEnd();
+				}
 				$addUpdateTag(FOCUS_TAG);
 				$onUpdate(() => {
 					rootElement.removeAttribute("autocapitalize");
@@ -10728,6 +10649,7 @@ function getPendingNodeToClone() {
 	pendingNodeToClone = null;
 	return node;
 }
+const INTERNAL_SKIP_AFTER_CLONE_FROM = Symbol("INTERNAL_SKIP_AFTER_CLONE_FROM");
 let keyCounter = 1;
 function resetRandomKey() {
 	keyCounter = 1;
@@ -10882,8 +10804,10 @@ function errorOnNodeKeyConstructorMismatch(node, existingKey, pendingNode) {
 	if (pendingNode) {
 		if (!(existingKey === pendingNode.__key)) formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} (type ${node.getType()}) has an incorrect clone implementation, got ${String(existingKey)} for nodeKey when expecting ${pendingNode.__key}`);
 	}
-	if (existingNode && existingNode.constructor !== node.constructor) if (node.constructor.name !== existingNode.constructor.name) formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with constructor ${existingNode.constructor.name}. Keys must not be re-used when the type is changed.`);
-	else formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with different constructor with the same name (possibly due to invalid Hot Module Replacement). Keys must not be re-used when the type is changed.`);
+	if (existingNode && existingNode.constructor !== node.constructor) {
+		if (node.constructor.name !== existingNode.constructor.name) formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with constructor ${existingNode.constructor.name}. Keys must not be re-used when the type is changed.`);
+		else formatDevErrorMessage(`Lexical node with constructor ${node.constructor.name} attempted to re-use key from node in active editor state with different constructor with the same name (possibly due to invalid Hot Module Replacement). Keys must not be re-used when the type is changed.`);
+	}
 }
 function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
 	let nextParentKey = parentKey;
@@ -11480,8 +11404,8 @@ function isFirefoxClipboardEvents(editor) {
 	const inputType = event && event.inputType;
 	return inputType === "insertFromPaste" || inputType === "insertFromPasteAsQuotation";
 }
-function dispatchCommand(editor, command, payload) {
-	return triggerCommandListeners(editor, command, payload, editor);
+function dispatchCommand(editor, command, ...args) {
+	return triggerCommandListeners(editor, command, args[0], editor);
 }
 function getElementByKeyOrThrow(editor, key) {
 	const element = editor._keyToDOMMap.get(key);
@@ -11532,13 +11456,15 @@ function scrollIntoViewIfNeeded(editor, selectionRect, rootElement) {
 		let diff = 0;
 		if (currentTop < targetTop) diff = -(targetTop - currentTop);
 		else if (currentBottom > targetBottom) diff = currentBottom - targetBottom;
-		if (diff !== 0) if (isBodyElement) defaultView.scrollBy(0, diff);
-		else {
-			const scrollTop = element.scrollTop;
-			element.scrollTop += diff;
-			const yOffset = element.scrollTop - scrollTop;
-			currentTop -= yOffset;
-			currentBottom -= yOffset;
+		if (diff !== 0) {
+			if (isBodyElement) defaultView.scrollBy(0, diff);
+			else {
+				const scrollTop = element.scrollTop;
+				element.scrollTop += diff;
+				const yOffset = element.scrollTop - scrollTop;
+				currentTop -= yOffset;
+				currentBottom -= yOffset;
+			}
 		}
 		if (isBodyElement) break;
 		element = getParentElement(element);
@@ -11620,7 +11546,7 @@ function $isRootOrShadowRoot(node) {
 * @returns The copy of the node.
 */
 function $copyNode(node, skipReset = false) {
-	const copy = node.constructor.clone(node);
+	const copy = node.constructor.clone(node, INTERNAL_SKIP_AFTER_CLONE_FROM);
 	$setNodeKey(copy, null);
 	copy.afterCloneFrom(node);
 	if (!skipReset) copy.resetOnCopyNodeFrom(node);
@@ -12358,7 +12284,7 @@ function computeTypeToNodeMap(editorState) {
 */
 function $cloneWithProperties(latestNode) {
 	const constructor = latestNode.constructor;
-	const mutableNode = constructor.clone(latestNode);
+	const mutableNode = constructor.clone(latestNode, INTERNAL_SKIP_AFTER_CLONE_FROM);
 	mutableNode.afterCloneFrom(latestNode);
 	if (!(mutableNode.__key === latestNode.__key)) formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') did not return a node with the same key, make sure to specify node.__key as the last argument to the constructor`);
 	if (!(mutableNode.__parent === latestNode.__parent && mutableNode.__next === latestNode.__next && mutableNode.__prev === latestNode.__prev)) formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') overrode afterCloneFrom but did not call super.afterCloneFrom(prevNode)`);
@@ -12533,42 +12459,57 @@ function isAbstractNodeClass(klass) {
 	return klass === DecoratorNode || klass === ElementNode || klass === LexicalNode;
 }
 const STATIC_NODE_CONFIG_CACHE = /* @__PURE__ */ new WeakMap();
+const SYNTHESIZED_GET_TYPE = Symbol("lexical.synthesizedGetType");
+const IS_UNOPTIMIZED_DEV_BUILD = TabNode.length === 0 && TextNode.length === 0 && TextNode.name === "TextNode";
 /** @internal */
 function getStaticNodeConfig(klass) {
 	const cache = STATIC_NODE_CONFIG_CACHE.get(klass);
 	if (cache) return cache;
 	const nodeConfigRecord = klass.prototype != null && PROTOTYPE_CONFIG_METHOD in klass.prototype ? klass.prototype[PROTOTYPE_CONFIG_METHOD]() : void 0;
 	const isAbstract = isAbstractNodeClass(klass);
-	const nodeType = !isAbstract && hasOwnStaticMethod(klass, "getType") ? klass.getType() : void 0;
+	const ownGetType = !isAbstract && hasOwnStaticMethod(klass, "getType") ? klass.getType : void 0;
+	const nodeType = ownGetType && !(SYNTHESIZED_GET_TYPE in ownGetType) ? ownGetType.call(klass) : void 0;
 	let ownNodeConfig;
 	let ownNodeType = nodeType;
-	if (nodeConfigRecord) if (nodeType) ownNodeConfig = nodeConfigRecord[nodeType];
-	else {
-		for (const [k, v] of Object.entries(nodeConfigRecord)) {
-			ownNodeType = k;
-			ownNodeConfig = v;
-		}
-		if (!ownNodeConfig) for (const symbolKey of Object.getOwnPropertySymbols(nodeConfigRecord)) {
-			const symbolConfig = nodeConfigRecord[symbolKey];
-			if (symbolConfig) {
-				ownNodeConfig = symbolConfig;
-				break;
+	if (nodeConfigRecord) {
+		if (nodeType) ownNodeConfig = nodeConfigRecord[nodeType];
+		else {
+			for (const [k, v] of Object.entries(nodeConfigRecord)) {
+				ownNodeType = k;
+				ownNodeConfig = v;
+			}
+			if (!ownNodeConfig) for (const symbolKey of Object.getOwnPropertySymbols(nodeConfigRecord)) {
+				const symbolConfig = nodeConfigRecord[symbolKey];
+				if (symbolConfig) {
+					ownNodeConfig = symbolConfig;
+					break;
+				}
 			}
 		}
 	}
 	if (!isAbstract && ownNodeType) {
-		if (!hasOwnStaticMethod(klass, "getType")) klass.getType = () => ownNodeType;
+		if (!hasOwnStaticMethod(klass, "getType")) {
+			const synthesizedForKlass = klass;
+			const synthesizedGetType = function() {
+				if (this !== synthesizedForKlass) return LexicalNode.getType.call(this);
+				return ownNodeType;
+			};
+			synthesizedGetType[SYNTHESIZED_GET_TYPE] = true;
+			klass.getType = synthesizedGetType;
+		}
 		if (!hasOwnStaticMethod(klass, "clone")) {
-			if (TextNode.length === 0) {
+			if (IS_UNOPTIMIZED_DEV_BUILD) {
 				if (!(klass.length === 0)) formatDevErrorMessage(`${klass.name} (type ${ownNodeType}) must implement a static clone method since its constructor has ${String(klass.length)} required arguments (expecting 0). Use an explicit default in the first argument of your constructor(prop: T=X, nodeKey?: NodeKey).`);
 			}
-			klass.clone = (prevNode) => {
+			klass.clone = (prevNode, internalSkipAfterCloneFrom) => {
 				setPendingNodeToClone(prevNode);
-				return new klass();
+				const node = new klass();
+				if (internalSkipAfterCloneFrom !== INTERNAL_SKIP_AFTER_CLONE_FROM) node.afterCloneFrom(prevNode);
+				return node;
 			};
 		}
 		if (!hasOwnStaticMethod(klass, "importJSON")) {
-			if (TextNode.length === 0) {
+			if (IS_UNOPTIMIZED_DEV_BUILD) {
 				if (!(klass.length === 0)) formatDevErrorMessage(`${klass.name} (type ${ownNodeType}) must implement a static importJSON method since its constructor has ${String(klass.length)} required arguments (expecting 0). Use an explicit default in the first argument of your constructor(prop: T=X, nodeKey?: NodeKey).`);
 			}
 			klass.importJSON = ownNodeConfig && ownNodeConfig.$importJSON || ((serializedNode) => new klass().updateFromJSON(serializedNode));
@@ -13787,9 +13728,10 @@ function $setPointFromCaret(point, caret) {
 	const { origin, direction } = caret;
 	const isNext = direction === "next";
 	if ($isTextPointCaret(caret)) point.set(origin.getKey(), caret.offset, "text");
-	else if ($isSiblingCaret(caret)) if ($isTextNode(origin)) point.set(origin.getKey(), $getTextNodeOffset(origin, direction), "text");
-	else point.set(origin.getParentOrThrow().getKey(), origin.getIndexWithinParent() + (isNext ? 1 : 0), "element");
-	else {
+	else if ($isSiblingCaret(caret)) {
+		if ($isTextNode(origin)) point.set(origin.getKey(), $getTextNodeOffset(origin, direction), "text");
+		else point.set(origin.getParentOrThrow().getKey(), origin.getIndexWithinParent() + (isNext ? 1 : 0), "element");
+	} else {
 		if (!($isChildCaret(caret) && $isElementNode(origin))) formatDevErrorMessage(`$setPointFromCaret: exhaustiveness check`);
 		point.set(origin.getKey(), isNext ? 0 : origin.getChildrenSize(), "element");
 	}
@@ -13876,7 +13818,13 @@ function $removeTextFromCaretRange(initialRange, sliceMode = "removeEmptySlices"
 		const { origin } = caret;
 		if (!$isElementNode(origin) || seenStart.has(origin.getKey())) removedNodes.push(origin);
 	}
-	for (const node of removedNodes) node.remove();
+	const removedParents = /* @__PURE__ */ new Set();
+	for (const node of removedNodes) {
+		const parent = node.getParent();
+		if (parent !== null && !seenStart.has(parent.getKey())) removedParents.add(parent);
+		$removeFromParent(node);
+	}
+	for (const parent of removedParents) if (!parent.canBeEmpty() && !$isRootOrShadowRoot(parent) && parent.isEmpty() && parent.isAttached()) parent.remove();
 	for (const slice of range.getTextSlices()) {
 		if (!slice) continue;
 		const { origin } = slice.caret;