@mx-space/cli 0.14.2 → 0.15.0

package/dist/{Lexical.dev-CtGmYDoh.mjs → Lexical.dev-Cck4n26y.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.
 *
@@ -448,7 +448,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 +2970,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 +3004,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 +3201,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 +3240,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,10 +3287,10 @@ function $handleBeforeInput(event) {
 			dispatchCommand(editor, FORMAT_TEXT_COMMAND, "underline");
 			break;
 		case "historyUndo":
-			dispatchCommand(editor, UNDO_COMMAND, void 0);
+			dispatchCommand(editor, UNDO_COMMAND);
 			break;
 		case "historyRedo":
-			dispatchCommand(editor, REDO_COMMAND, void 0);
+			dispatchCommand(editor, REDO_COMMAND);
 			break;
 	}
 	return true;
@@ -3510,10 +3531,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)) {
@@ -5173,7 +5194,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 +5209,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 +5457,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 +5942,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 +6089,26 @@ 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;
@@ -6401,201 +6424,91 @@ 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;
 			}
+			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 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);
-			} 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.
@@ -8503,7 +8416,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
 	*/
@@ -8754,7 +8667,10 @@ function $beginUpdate(editor, updateFn, options) {
 * within an update
 */
 function updateEditorSync(editor, updateFn, options) {
-	if (activeEditor === editor && options === void 0) updateFn();
+	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) {
@@ -9434,14 +9350,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 +9491,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 +9506,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 +9529,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 +9587,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 +9607,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 +9616,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 +10387,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.
@@ -10728,6 +10623,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;
@@ -11480,8 +11376,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);
@@ -11620,7 +11516,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 +12254,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,13 +12429,16 @@ 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];
@@ -12557,18 +12456,28 @@ function getStaticNodeConfig(klass) {
 		}
 	}
 	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));
@@ -13876,7 +13785,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;