@mx-space/cli 0.14.1 → 0.15.0

package/dist/{Lexical.dev-DTxuYHmG.mjs → Lexical.dev-Cck4n26y.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/lexical@0.46.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.
 *
@@ -368,11 +368,11 @@ var ElementDOMSlot = class ElementDOMSlot extends DOMSlot {
 		}
 		const element = this.element;
 		const before = this.before;
-		const br = document.createElement("br");
+		const br = $getDocument().createElement("br");
 		br.setAttribute("data-lexical-managed-linebreak", "true");
 		element.insertBefore(br, before);
 		if (webkitHack) {
-			const img = document.createElement("img");
+			const img = $getDocument().createElement("img");
 			img.setAttribute("data-lexical-managed-linebreak", "true");
 			img.style.setProperty("display", "inline", "important");
 			img.style.setProperty("border", "0px", "important");
@@ -448,7 +448,7 @@ function indexPath(root, child) {
 */
 let envLexicalVersion;
 try {
-	envLexicalVersion = "0.46.0+dev.esm";
+	envLexicalVersion = "0.49.0+dev.esm";
 } catch (_unused) {}
 const LEXICAL_VERSION = envLexicalVersion ?? "\"<unknown>+source\"";
 /**
@@ -1784,8 +1784,8 @@ function $setElementDirection(dom, node) {
 	if (direction !== null) dom.dir = direction;
 	else dom.removeAttribute("dir");
 }
-function createSlotDOM(name) {
-	const container = document.createElement("div");
+function $createSlotDOM(name) {
+	const container = $getDocument().createElement("div");
 	container.setAttribute("data-lexical-slot", name);
 	container.style.display = "none";
 	return container;
@@ -1801,7 +1801,7 @@ function $mountSlotChildren(node, hostDom, slots) {
 	let totalText = "";
 	const decoratorHost = $isDecoratorNode(node);
 	for (const [name, slotKey] of slots) {
-		const container = createSlotDOM(name);
+		const container = $createSlotDOM(name);
 		$applySlotEditable(hostDom, decoratorHost, container);
 		hostDom.appendChild(container);
 		subTreeTextContent = "";
@@ -1848,7 +1848,7 @@ function $reconcileSlotChildren(prevNode, nextNode, hostDom) {
 		subTreeTextContent = "";
 		const saved = $beginCaptureGuard();
 		if (container === null) {
-			container = createSlotDOM(name);
+			container = $createSlotDOM(name);
 			let firstNonSlot = null;
 			for (const child of hostDom.children) if (!child.hasAttribute("data-lexical-slot")) {
 				firstNonSlot = child;
@@ -2636,6 +2636,12 @@ const DELETE_LINE_COMMAND = /* @__PURE__ */ createCommand("DELETE_LINE_COMMAND")
 */
 const FORMAT_TEXT_COMMAND = /* @__PURE__ */ createCommand("FORMAT_TEXT_COMMAND");
 /**
+* Dispatched to explicitly set or unset text formats on the selection.
+* Unlike FORMAT_TEXT_COMMAND which toggles, this command sets each specified
+* format to the exact boolean value provided.
+*/
+const SET_TEXT_FORMAT_COMMAND = /* @__PURE__ */ createCommand("SET_TEXT_FORMAT_COMMAND");
+/**
 * Dispatched on undo (Cmd+Z on macOS, Ctrl+Z elsewhere).
 */
 const UNDO_COMMAND = /* @__PURE__ */ createCommand("UNDO_COMMAND");
@@ -2743,6 +2749,114 @@ const BLUR_COMMAND = /* @__PURE__ */ createCommand("BLUR_COMMAND");
 * Dispatched after any KeyboardEvent when modifiers are pressed
 */
 const KEY_MODIFIER_COMMAND = /* @__PURE__ */ createCommand("KEY_MODIFIER_COMMAND");
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* A registry mapping keys to a per-key activation, reference counted so the
+* activation is created on the first registration for a key and torn down
+* only when the last outstanding registration for that key is released. This
+* lets the same key be driven by more than one caller (or survive a
+* re-entrant / double registration) without double-wiring or premature
+* teardown.
+*
+* Keys are compared by identity (Map semantics), so any object works — a DOM
+* element, a `Document`, a `Window`, or an opaque handle.
+*/
+/**
+* Creates a {@link RefCountedRegistry}.
+*
+* @param activate - Wires `key` and returns its teardown. Called on the first
+*   registration of each key.
+*/
+function createRefCountedRegistry(activate) {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		dispose() {
+			for (const entry of entries.values()) entry.dispose();
+			entries.clear();
+		},
+		register(key, options) {
+			let entry = entries.get(key);
+			if (entry === void 0) {
+				entry = {
+					dispose: activate(key, options),
+					holders: /* @__PURE__ */ new Set()
+				};
+				entries.set(key, entry);
+			}
+			const release = () => {
+				const current = entries.get(key);
+				if (current && current.holders.delete(release) && current.holders.size === 0) {
+					entries.delete(key);
+					current.dispose();
+				}
+			};
+			entry.holders.add(release);
+			return release;
+		}
+	};
+}
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* The typed event map for a given {@link EventTarget}. Falls back to the global
+* handlers map (rather than a permissive `Record<string, Event>`) so unknown
+* event names are rejected as typos. Shared by {@link registerEventListener}
+* and `registerEventListeners`; the former additionally has a `string` overload
+* as an escape hatch for non-standard names (e.g. the legacy `textInput`),
+* which the object form intentionally does not.
+*/
+/**
+* Add an event listener to `target` and return a function that removes it.
+*
+* This is a thin, strongly typed wrapper around
+* {@link EventTarget.addEventListener} that mirrors its overloads but returns a
+* dispose function instead of `void`. It removes the
+* `addEventListener`/`removeEventListener` boilerplate that every DOM
+* subscription would otherwise duplicate, and composes cleanly with
+* {@link mergeRegister} or as the return value of an effect.
+*
+* The same `options` value is forwarded to both `addEventListener` and
+* `removeEventListener` so that the `capture` flag always matches, which is
+* required for the listener to be removed correctly.
+*
+* @example
+* ```ts
+* // Returned directly from a React effect
+* useEffect(
+*   () => registerEventListener(container, 'keydown', handler),
+*   [container],
+* );
+* ```
+* @example
+* ```ts
+* // Composed with other teardown via mergeRegister
+* return mergeRegister(
+*   registerEventListener(window, 'resize', onResize),
+*   registerEventListener(document, 'selectionchange', onSelectionChange),
+* );
+* ```
+*
+* @param target - The {@link EventTarget} to subscribe to
+* @param type - The event type to listen for (e.g. `'keydown'`)
+* @param listener - The listener invoked when a matching event is dispatched
+* @param options - Options forwarded to `add`/`removeEventListener`
+* @returns A function that removes the listener when called
+*/
+function registerEventListener(target, type, listener, options) {
+	target.addEventListener(type, listener, options);
+	return target.removeEventListener.bind(target, type, listener, options);
+}
 const PASS_THROUGH_COMMAND = Object.freeze({});
 const ANDROID_COMPOSITION_LATENCY = 30;
 const rootElementEvents = [
@@ -2763,28 +2877,12 @@ const rootElementEvents = [
 	["drop", PASS_THROUGH_COMMAND]
 ];
 if (CAN_USE_BEFORE_INPUT) rootElementEvents.push(["beforeinput", (event, editor) => onBeforeInput(event, editor)]);
-let lastKeyDownTimeStamp = 0;
-let lastKeyCode = null;
-let lastBeforeInputInsertTextTimeStamp = 0;
-let unprocessedBeforeInputData = null;
-let isInsertTextAfterHandledSelectionCommand = false;
-let handledSelectionCommandTimeoutId = null;
 const rootElementToDocument = /* @__PURE__ */ new WeakMap();
 const documentRegistrations = /* @__PURE__ */ new WeakMap();
-let isSelectionChangeFromDOMUpdate = false;
-let isSelectionChangeFromMouseDown = false;
-let isInsertLineBreak = false;
-let isFirefoxEndingComposition = false;
-let isSafariEndingComposition = false;
-let safariEndCompositionEventData = "";
-let postDeleteSelectionToRestore = null;
-let collapsedSelectionFormat = [
-	0,
-	"",
-	0,
-	"root",
-	0
-];
+const documentSelectionChange = createRefCountedRegistry((doc) => {
+	doc.addEventListener("selectionchange", onDocumentSelectionChange);
+	return () => doc.removeEventListener("selectionchange", onDocumentSelectionChange);
+});
 function $shouldPreventDefaultAndInsertText(selection, domTargetRange, text, timeStamp, isBeforeInput, cachedDOMSelectionPoints) {
 	const anchor = selection.anchor;
 	const focus = selection.focus;
@@ -2800,16 +2898,17 @@ function $shouldPreventDefaultAndInsertText(selection, domTargetRange, text, tim
 	const anchorKey = anchor.key;
 	const backingAnchorElement = editor.getElementByKey(anchorKey);
 	const textLength = text.length;
-	return anchorKey !== focus.key || !$isTextNode(anchorNode) || (!isBeforeInput && (!CAN_USE_BEFORE_INPUT || lastBeforeInputInsertTextTimeStamp < timeStamp + 50) || anchorNode.isDirty() && textLength < 2 || doesContainSurrogatePair(text)) && anchor.offset !== focus.offset && !anchorNode.isComposing() || $isTokenOrSegmented(anchorNode) || anchorNode.isDirty() && textLength > 1 || (isBeforeInput || !CAN_USE_BEFORE_INPUT) && backingAnchorElement !== null && !anchorNode.isComposing() && domAnchorNode !== $getDOMTextNode(anchorNode, backingAnchorElement, editor) || domSelectionPoints !== null && domTargetRange !== null && (!domTargetRange.collapsed || domTargetRange.startContainer !== domSelectionPoints.anchorNode || domTargetRange.startOffset !== domSelectionPoints.anchorOffset) || !anchorNode.isComposing() && (anchorNode.getFormat() !== selection.format || anchorNode.getStyle() !== selection.style) || $shouldInsertTextAfterOrBeforeTextNode(selection, anchorNode);
+	return anchorKey !== focus.key || !$isTextNode(anchorNode) || (!isBeforeInput && (!CAN_USE_BEFORE_INPUT || editor._inputState.lastBeforeInputInsertTextTimeStamp < timeStamp + 50) || anchorNode.isDirty() && textLength < 2 || doesContainSurrogatePair(text)) && anchor.offset !== focus.offset && !anchorNode.isComposing() || $isTokenOrSegmented(anchorNode) || anchorNode.isDirty() && textLength > 1 || (isBeforeInput || !CAN_USE_BEFORE_INPUT) && backingAnchorElement !== null && !anchorNode.isComposing() && domAnchorNode !== $getDOMTextNode(anchorNode, backingAnchorElement, editor) || domSelectionPoints !== null && domTargetRange !== null && (!domTargetRange.collapsed || domTargetRange.startContainer !== domSelectionPoints.anchorNode || domTargetRange.startOffset !== domSelectionPoints.anchorOffset) || !anchorNode.isComposing() && (anchorNode.getFormat() !== selection.format || anchorNode.getStyle() !== selection.style) || $shouldInsertTextAfterOrBeforeTextNode(selection, anchorNode);
 }
 function shouldSkipSelectionChange(domNode, offset) {
 	return isDOMTextNode(domNode) && domNode.nodeValue !== null && offset !== 0 && offset !== domNode.nodeValue.length;
 }
 function onSelectionChange(domSelection, editor, isActive) {
 	const { anchorNode: anchorDOM, anchorOffset, focusNode: focusDOM, focusOffset } = getDOMSelectionPoints(domSelection, editor._rootElement);
-	if (isSelectionChangeFromDOMUpdate) {
-		isSelectionChangeFromDOMUpdate = false;
-		if (shouldSkipSelectionChange(anchorDOM, anchorOffset) && shouldSkipSelectionChange(focusDOM, focusOffset) && !postDeleteSelectionToRestore) return;
+	const inputState = editor._inputState;
+	if (inputState.isSelectionChangeFromDOMUpdate) {
+		inputState.isSelectionChangeFromDOMUpdate = false;
+		if (shouldSkipSelectionChange(anchorDOM, anchorOffset) && shouldSkipSelectionChange(focusDOM, focusOffset) && !inputState.postDeleteSelectionToRestore) return;
 	}
 	updateEditorSync(editor, () => {
 		if (!isActive) {
@@ -2818,15 +2917,15 @@ function onSelectionChange(domSelection, editor, isActive) {
 		}
 		if (!isSelectionWithinEditor(editor, anchorDOM, focusDOM)) return;
 		let selection = $getSelection();
-		if (postDeleteSelectionToRestore && $isRangeSelection(selection) && selection.isCollapsed()) {
+		if (inputState.postDeleteSelectionToRestore && $isRangeSelection(selection) && selection.isCollapsed()) {
 			const curAnchor = selection.anchor;
-			const prevAnchor = postDeleteSelectionToRestore.anchor;
+			const prevAnchor = inputState.postDeleteSelectionToRestore.anchor;
 			if (curAnchor.key === prevAnchor.key && curAnchor.offset === prevAnchor.offset + 1 || curAnchor.offset === 1 && prevAnchor.getNode().is(curAnchor.getNode().getPreviousSibling())) {
-				selection = postDeleteSelectionToRestore.clone();
+				selection = inputState.postDeleteSelectionToRestore.clone();
 				$setSelection(selection);
 			}
 		}
-		postDeleteSelectionToRestore = null;
+		inputState.postDeleteSelectionToRestore = null;
 		if ($isRangeSelection(selection)) {
 			const anchor = selection.anchor;
 			const anchorNode = anchor.getNode();
@@ -2834,7 +2933,7 @@ function onSelectionChange(domSelection, editor, isActive) {
 				if (domSelection.type === "Range" && anchorDOM === focusDOM) selection.dirty = true;
 				const windowEvent = getWindow(editor).event;
 				const currentTimeStamp = windowEvent ? windowEvent.timeStamp : performance.now();
-				const [lastFormat, lastStyle, lastOffset, lastKey, timeStamp] = collapsedSelectionFormat;
+				const { format: lastFormat, style: lastStyle, offset: lastOffset, key: lastKey, timeStamp } = inputState.collapsedSelectionFormat;
 				const root = $getRoot();
 				const isRootTextContentEmpty = editor.isComposing() === false && root.getTextContent() === "";
 				if (currentTimeStamp < timeStamp + 200 && anchor.offset === lastOffset && anchor.key === lastKey) $updateSelectionFormatStyle(selection, lastFormat, lastStyle);
@@ -2871,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) {
@@ -2905,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);
 	});
 }
@@ -2912,7 +3032,7 @@ function onPointerDown(event, editor) {
 	const target = getComposedEventTarget(event);
 	const pointerType = event.pointerType;
 	if (isDOMNode(target) && pointerType !== "touch" && pointerType !== "pen" && event.button === 0) updateEditorSync(editor, () => {
-		if (!isDOMCapturingSelection(target, editor)) isSelectionChangeFromMouseDown = true;
+		if (!isDOMCapturingSelection(target, editor)) editor._inputState.isSelectionChangeFromMouseDown = true;
 	});
 }
 function getTargetRange(event) {
@@ -2922,6 +3042,7 @@ function getTargetRange(event) {
 	return targetRanges[0];
 }
 function $maybeMoveSelectionPastTrailingAcceptanceBoundary(insertedText) {
+	const { lastKeyCode } = getActiveEditor()._inputState;
 	if (insertedText == null || insertedText.length <= 1 || lastKeyCode == null) return;
 	const characterToSearchFor = lastKeyCode.length === 1 ? lastKeyCode : lastKeyCode === "Enter" ? "\n" : lastKeyCode === "Tab" ? "	" : null;
 	if (!characterToSearchFor) return;
@@ -2947,20 +3068,20 @@ function $maybeMoveSelectionPastTrailingAcceptanceBoundary(insertedText) {
 function $canRemoveText(anchorNode, focusNode) {
 	return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !$isTokenOrTab(anchorNode) || !$isTokenOrTab(focusNode);
 }
-function isPossiblyAndroidKeyPress(timeStamp) {
-	return lastKeyCode === "MediaLast" && timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
+function isPossiblyAndroidKeyPress(inputState, timeStamp) {
+	return inputState.lastKeyCode === "MediaLast" && timeStamp < inputState.lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
 }
-function clearHandledSelectionCommandInsertText() {
-	isInsertTextAfterHandledSelectionCommand = false;
-	if (handledSelectionCommandTimeoutId !== null) {
-		clearTimeout(handledSelectionCommandTimeoutId);
-		handledSelectionCommandTimeoutId = null;
+function clearHandledSelectionCommandInsertText(inputState) {
+	inputState.isInsertTextAfterHandledSelectionCommand = false;
+	if (inputState.handledSelectionCommandTimeoutId !== null) {
+		clearTimeout(inputState.handledSelectionCommandTimeoutId);
+		inputState.handledSelectionCommandTimeoutId = null;
 	}
 }
-function markHandledSelectionCommandInsertText() {
-	clearHandledSelectionCommandInsertText();
-	isInsertTextAfterHandledSelectionCommand = true;
-	handledSelectionCommandTimeoutId = setTimeout(clearHandledSelectionCommandInsertText, 0);
+function markHandledSelectionCommandInsertText(inputState) {
+	clearHandledSelectionCommandInsertText(inputState);
+	inputState.isInsertTextAfterHandledSelectionCommand = true;
+	inputState.handledSelectionCommandTimeoutId = setTimeout(() => clearHandledSelectionCommandInsertText(inputState), 0);
 }
 function registerDefaultCommandHandlers(editor) {
 	editor.registerCommand(BEFORE_INPUT_COMMAND, $handleBeforeInput, 0);
@@ -3002,9 +3123,10 @@ function $handleBeforeInput(event) {
 	const inputType = event.inputType;
 	const targetRange = getTargetRange(event);
 	const editor = getActiveEditor();
+	const inputState = editor._inputState;
 	const selection = $getSelection();
-	if (inputType === "insertText" && event.data && isInsertTextAfterHandledSelectionCommand) {
-		clearHandledSelectionCommandInsertText();
+	if (inputType === "insertText" && event.data && inputState.isInsertTextAfterHandledSelectionCommand) {
+		clearHandledSelectionCommandInsertText(inputState);
 		event.preventDefault();
 		if ($isRangeSelection(selection) && !selection.isCollapsed()) {
 			const point = selection.isBackward() ? selection.anchor : selection.focus;
@@ -3021,9 +3143,9 @@ function $handleBeforeInput(event) {
 		}
 		if ($isRangeSelection(selection)) {
 			const isSelectionAnchorSameAsFocus = selection.anchor.key === selection.focus.key;
-			if (isPossiblyAndroidKeyPress(event.timeStamp) && editor.isComposing() && isSelectionAnchorSameAsFocus) {
+			if (isPossiblyAndroidKeyPress(inputState, event.timeStamp) && editor.isComposing() && isSelectionAnchorSameAsFocus) {
 				$setCompositionKey(null);
-				lastKeyDownTimeStamp = 0;
+				inputState.lastKeyDownTimeStamp = 0;
 				setTimeout(() => {
 					updateEditorSync(editor, () => {
 						$setCompositionKey(null);
@@ -3056,8 +3178,8 @@ function $handleBeforeInput(event) {
 					dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
 					const selectionAfterDelete = $getSelection();
 					if (IS_ANDROID_CHROME && $isRangeSelection(selectionAfterDelete) && selectionAfterDelete.isCollapsed()) {
-						postDeleteSelectionToRestore = selectionAfterDelete;
-						setTimeout(() => postDeleteSelectionToRestore = null);
+						inputState.postDeleteSelectionToRestore = selectionAfterDelete;
+						setTimeout(() => inputState.postDeleteSelectionToRestore = null);
 					}
 				}
 			}
@@ -3066,9 +3188,9 @@ function $handleBeforeInput(event) {
 	}
 	if (!$isRangeSelection(selection)) return true;
 	const data = event.data;
-	if (unprocessedBeforeInputData !== null) $updateSelectedTextFromDOM(false, editor, unprocessedBeforeInputData);
-	if ((!selection.dirty || unprocessedBeforeInputData !== null) && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode()) && targetRange !== null) selection.applyDOMRange(targetRange);
-	unprocessedBeforeInputData = null;
+	if (inputState.unprocessedBeforeInputData !== null) $updateSelectedTextFromDOM(false, editor, inputState.unprocessedBeforeInputData);
+	if ((!selection.dirty || inputState.unprocessedBeforeInputData !== null) && selection.isCollapsed() && !$isRootNode(selection.anchor.getNode()) && targetRange !== null) selection.applyDOMRange(targetRange);
+	inputState.unprocessedBeforeInputData = null;
 	const anchor = selection.anchor;
 	const focus = selection.focus;
 	const anchorNode = anchor.getNode();
@@ -3079,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();
@@ -3088,8 +3210,8 @@ function $handleBeforeInput(event) {
 			event.preventDefault();
 			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
 			$maybeMoveSelectionPastTrailingAcceptanceBoundary(data);
-		} else unprocessedBeforeInputData = data;
-		lastBeforeInputInsertTextTimeStamp = event.timeStamp;
+		} else inputState.unprocessedBeforeInputData = data;
+		inputState.lastBeforeInputInsertTextTimeStamp = event.timeStamp;
 		return true;
 	}
 	event.preventDefault();
@@ -3100,20 +3222,25 @@ function $handleBeforeInput(event) {
 			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
 			$maybeMoveSelectionPastTrailingAcceptanceBoundary((event.dataTransfer ? event.dataTransfer.getData("text/plain") : null) ?? event.data);
 			break;
-		case "insertFromComposition":
+		case "insertFromComposition": {
+			const skipRedundantInsert = inputState.hadOrphanedCompositionEvents;
+			inputState.hadOrphanedCompositionEvents = false;
+			const prevCompositionKey = editor._compositionKey;
 			$setCompositionKey(null);
-			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
+			if (!skipRedundantInsert) dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
+			$cleanupComposedSubclass(prevCompositionKey);
 			break;
+		}
 		case "insertLineBreak":
 			$setCompositionKey(null);
 			dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, false);
 			break;
 		case "insertParagraph":
 			$setCompositionKey(null);
-			if (isInsertLineBreak && !IS_IOS) {
-				isInsertLineBreak = false;
+			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":
@@ -3160,24 +3287,26 @@ 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;
 }
 function onInput(event, editor) {
 	event.stopPropagation();
-	clearHandledSelectionCommandInsertText();
+	const inputState = editor._inputState;
+	clearHandledSelectionCommandInsertText(inputState);
 	updateEditorSync(editor, () => {
 		if (!isInputEventTargetingCapturedSelection(event, editor)) editor.dispatchCommand(INPUT_COMMAND, event);
 	}, { event });
-	unprocessedBeforeInputData = null;
+	inputState.unprocessedBeforeInputData = null;
 }
 function $handleInput(event) {
 	const editor = getActiveEditor();
+	const inputState = editor._inputState;
 	const selection = $getSelection();
 	const data = event.data;
 	const targetRange = getTargetRange(event);
@@ -3185,11 +3314,20 @@ function $handleInput(event) {
 	if (data != null && $isRangeSelection(selection)) {
 		const domSelection = getDOMSelection(getWindow(editor));
 		const domSelectionPoints = domSelection !== null ? getDOMSelectionPoints(domSelection, editor._rootElement) : null;
-		if ($shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false, domSelectionPoints)) {
+		const isOrphanedCompositionEnd = event.inputType === "insertCompositionText" && inputState.compositionPhase !== "ending-firefox" && !editor.isComposing();
+		if (isOrphanedCompositionEnd) inputState.hadOrphanedCompositionEvents = true;
+		const inputAnchorNode = selection.anchor.getNode();
+		const isCompositionOnToken = event.inputType === "insertCompositionText" && inputState.compositionPhase !== "ending-firefox" && editor.isComposing() && $isTextNode(inputAnchorNode) && $isTokenOrSegmented(inputAnchorNode);
+		if (!isOrphanedCompositionEnd && !isCompositionOnToken && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false, domSelectionPoints)) {
 			handled = true;
-			if (isFirefoxEndingComposition) {
-				$onCompositionEndImpl(editor, data);
-				isFirefoxEndingComposition = false;
+			if (inputState.compositionPhase === "ending-firefox") {
+				const tokenRedirected = $onCompositionEndImpl(editor, data);
+				inputState.compositionPhase = "idle";
+				if (tokenRedirected) {
+					$addUpdateTag(COMPOSITION_END_TAG);
+					$flushMutations();
+					return true;
+				}
 			}
 			const anchorNode = selection.anchor.getNode();
 			if (domSelection === null || domSelectionPoints === null) return true;
@@ -3204,17 +3342,17 @@ function $handleInput(event) {
 				selection._cachedIsBackward = null;
 			}
 			if (IS_ANDROID_CHROME && editor.isComposing()) {
-				lastKeyDownTimeStamp = 0;
+				inputState.lastKeyDownTimeStamp = 0;
 				$setCompositionKey(null);
 			}
 		}
 	}
 	if (!handled) {
 		$updateSelectedTextFromDOM(false, editor, data !== null ? data : void 0);
-		if (isFirefoxEndingComposition) {
+		if (inputState.compositionPhase === "ending-firefox") {
 			$onCompositionEndImpl(editor, data || void 0);
 			$addUpdateTag(COMPOSITION_END_TAG);
-			isFirefoxEndingComposition = false;
+			inputState.compositionPhase = "idle";
 		}
 	}
 	$flushMutations();
@@ -3225,21 +3363,45 @@ function onCompositionStart(event, editor) {
 }
 function $handleCompositionStart(event) {
 	const editor = getActiveEditor();
+	const inputState = editor._inputState;
 	const selection = $getSelection();
 	if ($isRangeSelection(selection) && !editor.isComposing()) {
+		inputState.compositionPhase = "composing";
+		inputState.hadOrphanedCompositionEvents = false;
 		const anchor = selection.anchor;
 		const node = selection.anchor.getNode();
 		$setCompositionKey(anchor.key);
 		$addUpdateTag(COMPOSITION_START_TAG);
-		if (event.timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY || anchor.type === "element" || !selection.isCollapsed() || node.getFormat() !== selection.format || $isTextNode(node) && node.getStyle() !== selection.style) dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, COMPOSITION_START_CHAR);
+		if (event.timeStamp < inputState.lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY || anchor.type === "element" || !selection.isCollapsed() || !IS_ANDROID_CHROME && (node.getFormat() !== selection.format || $isTextNode(node) && node.getStyle() !== selection.style) || $isTextNode(node) && ($isTokenOrSegmented(node) || anchor.offset === 0 && !node.canInsertTextBefore() || anchor.offset === node.getTextContentSize() && !node.canInsertTextAfter())) {
+			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, COMPOSITION_START_CHAR);
+			const updatedSelection = $getSelection();
+			if ($isRangeSelection(updatedSelection)) $setCompositionKey(updatedSelection.anchor.key);
+		}
 	}
 	return true;
 }
 function $handleCompositionEnd(event) {
-	$onCompositionEndImpl(getActiveEditor(), event.data);
+	const editor = getActiveEditor();
+	editor._inputState.compositionPhase = "idle";
+	$onCompositionEndImpl(editor, event.data);
 	$addUpdateTag(COMPOSITION_END_TAG);
 	return true;
 }
+function $cleanupComposedSubclass(compositionKey) {
+	if (compositionKey === null) return;
+	const composedNode = $getNodeByKey(compositionKey);
+	if (!$isTextNode(composedNode) || composedNode.getType() === "text" || $isTokenOrSegmented(composedNode) || !composedNode.isAttached()) return;
+	const sel = $getSelection();
+	const offset = $isRangeSelection(sel) && sel.anchor.key === compositionKey ? sel.anchor.offset : null;
+	const replacement = $createTextNode(composedNode.getTextContent());
+	replacement.setFormat(composedNode.getFormat());
+	replacement.setStyle(composedNode.getStyle());
+	composedNode.replace(replacement);
+	if (offset !== null) {
+		const safeOffset = Math.min(offset, replacement.getTextContentSize());
+		replacement.select(safeOffset, safeOffset);
+	}
+}
 function $onCompositionEndImpl(editor, data) {
 	const compositionKey = editor._compositionKey;
 	$setCompositionKey(null);
@@ -3259,7 +3421,8 @@ function $onCompositionEndImpl(editor, data) {
 				}
 				$updateTextNodeFromDOMContent(node, textNode.nodeValue, anchorOffset, focusOffset, true);
 			}
-			return;
+			$cleanupComposedSubclass(compositionKey);
+			return false;
 		} else if (data[data.length - 1] === "\n") {
 			const selection = $getSelection();
 			if ($isRangeSelection(selection) || $isNodeSelection(selection)) {
@@ -3268,40 +3431,52 @@ function $onCompositionEndImpl(editor, data) {
 					selection.anchor.set(focus.key, focus.offset, focus.type);
 				}
 				dispatchCommand(editor, KEY_ENTER_COMMAND, null);
-				return;
+				$cleanupComposedSubclass(compositionKey);
+				return false;
 			}
 		}
+		const node = $getNodeByKey(compositionKey);
+		if (node !== null && $isTextNode(node) && $isTokenOrSegmented(node)) {
+			node.markDirty();
+			const selection = $getSelection();
+			const textLen = node.getTextContentSize();
+			const offset = $isRangeSelection(selection) && selection.anchor.key === compositionKey ? selection.anchor.offset : textLen;
+			node.select(offset, offset).insertText(data);
+			return true;
+		}
 	}
 	$updateSelectedTextFromDOM(true, editor, data);
+	$cleanupComposedSubclass(compositionKey);
+	return false;
 }
 function onCompositionEnd(event, editor) {
-	if (IS_FIREFOX) isFirefoxEndingComposition = true;
+	const inputState = editor._inputState;
+	if (IS_FIREFOX) inputState.compositionPhase = "ending-firefox";
 	else if (!IS_IOS && (IS_SAFARI || IS_APPLE_WEBKIT)) {
-		isSafariEndingComposition = true;
-		safariEndCompositionEventData = event.data;
+		inputState.compositionPhase = "ending-safari";
+		inputState.compositionEndData = event.data;
 	} else dispatchCommand(editor, COMPOSITION_END_COMMAND, event);
 }
 function onKeyDown(event, editor) {
-	lastKeyDownTimeStamp = event.timeStamp;
-	lastKeyCode = event.key;
-	if (event.key !== "Backspace") clearHandledSelectionCommandInsertText();
+	const inputState = editor._inputState;
+	inputState.lastKeyDownTimeStamp = event.timeStamp;
+	inputState.lastKeyCode = event.key;
+	if (event.key !== "Backspace") clearHandledSelectionCommandInsertText(inputState);
 	if (editor.isComposing()) return;
 	dispatchCommand(editor, KEY_DOWN_COMMAND, event);
 }
 function $handleKeyDown(event) {
 	const editor = getActiveEditor();
+	const inputState = editor._inputState;
 	if (event.key == null) return true;
-	if (isSafariEndingComposition) {
-		if (isBackspace(event)) {
-			updateEditorSync(editor, () => {
-				$onCompositionEndImpl(editor, safariEndCompositionEventData);
-			});
-			isSafariEndingComposition = false;
-			safariEndCompositionEventData = "";
-			return true;
-		}
-		isSafariEndingComposition = false;
-		safariEndCompositionEventData = "";
+	if (inputState.compositionPhase === "ending-safari") {
+		const isBack = isBackspace(event);
+		if (isBack) updateEditorSync(editor, () => {
+			$onCompositionEndImpl(editor, inputState.compositionEndData);
+		});
+		inputState.compositionPhase = "idle";
+		inputState.compositionEndData = "";
+		if (isBack) return true;
 	}
 	if (isMoveForward(event)) dispatchCommand(editor, KEY_ARROW_RIGHT_COMMAND, event);
 	else if (isMoveToEnd(event)) dispatchCommand(editor, MOVE_TO_END, event);
@@ -3310,18 +3485,18 @@ function $handleKeyDown(event) {
 	else if (isMoveUp(event)) dispatchCommand(editor, KEY_ARROW_UP_COMMAND, event);
 	else if (isMoveDown(event)) dispatchCommand(editor, KEY_ARROW_DOWN_COMMAND, event);
 	else if (isLineBreak(event)) {
-		isInsertLineBreak = true;
+		inputState.isInsertLineBreak = true;
 		dispatchCommand(editor, KEY_ENTER_COMMAND, event);
 	} else if (isSpace(event)) dispatchCommand(editor, KEY_SPACE_COMMAND, event);
 	else if (isOpenLineBreak(event)) {
 		event.preventDefault();
-		isInsertLineBreak = true;
+		inputState.isInsertLineBreak = true;
 		dispatchCommand(editor, INSERT_LINE_BREAK_COMMAND, true);
 	} else if (isParagraph(event)) {
-		isInsertLineBreak = false;
+		inputState.isInsertLineBreak = false;
 		dispatchCommand(editor, KEY_ENTER_COMMAND, event);
 	} else if (isDeleteBackward(event)) if (isBackspace(event)) {
-		if (dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event)) markHandledSelectionCommandInsertText();
+		if (dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event)) markHandledSelectionCommandInsertText(inputState);
 	} else {
 		event.preventDefault();
 		dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
@@ -3356,15 +3531,15 @@ 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)) {
 			event.preventDefault();
-			if (dispatchCommand(editor, SELECT_ALL_COMMAND, event)) markHandledSelectionCommandInsertText();
+			if (dispatchCommand(editor, SELECT_ALL_COMMAND, event)) markHandledSelectionCommandInsertText(inputState);
 		} else if (prevSelection !== null && !$isRangeSelection(prevSelection)) {
 			if (isCopy(event)) {
 				event.preventDefault();
@@ -3393,8 +3568,8 @@ function onDocumentSelectionChange(event) {
 	const ownerDocument = getDOMOwnerDocument(event.target);
 	let nextActiveEditor = null;
 	let resolvedAnchorNode = null;
+	const registration = ownerDocument !== null ? documentRegistrations.get(ownerDocument) : void 0;
 	if (ownerDocument !== null) {
-		const registration = documentRegistrations.get(ownerDocument);
 		if (registration !== void 0) {
 			const editorsForDoc = registration.editors;
 			let hasShadow = registration.hasShadowEditor;
@@ -3443,8 +3618,8 @@ function onDocumentSelectionChange(event) {
 		}
 	}
 	if (nextActiveEditor === null) return;
-	if (isSelectionChangeFromMouseDown) {
-		isSelectionChangeFromMouseDown = false;
+	if (nextActiveEditor._inputState.isSelectionChangeFromMouseDown) {
+		if (registration !== void 0) for (const ed of registration.editors) ed._inputState.isSelectionChangeFromMouseDown = false;
 		updateEditorSync(nextActiveEditor, () => {
 			const lastSelection = $getPreviousSelection();
 			const domAnchorNode = resolvedAnchorNode ?? getDOMSelectionPoints(domSelection, nextActiveEditor._rootElement).anchorNode;
@@ -3475,17 +3650,15 @@ function addRootElementEvents(rootElement, editor) {
 	if (registration === void 0) {
 		registration = {
 			editors: /* @__PURE__ */ new Set(),
-			hasShadowEditor: void 0,
-			rootElementCount: 0
+			hasShadowEditor: void 0
 		};
 		documentRegistrations.set(doc, registration);
 	}
-	if (registration.rootElementCount < 1) doc.addEventListener("selectionchange", onDocumentSelectionChange);
-	registration.rootElementCount += 1;
 	registration.editors.add(editor);
 	registration.hasShadowEditor = void 0;
 	rootElement.__lexicalEditor = editor;
 	const removeHandles = getRootElementRemoveHandles(rootElement);
+	removeHandles.push(documentSelectionChange.register(doc));
 	for (let i = 0; i < rootElementEvents.length; i++) {
 		const [eventName, onEvent] = rootElementEvents[i];
 		const eventHandler = typeof onEvent === "function" ? (event) => {
@@ -3508,10 +3681,7 @@ function addRootElementEvents(rootElement, editor) {
 				case "drop": return isEditable && dispatchCommand(editor, DROP_COMMAND, event);
 			}
 		};
-		rootElement.addEventListener(eventName, eventHandler);
-		removeHandles.push(() => {
-			rootElement.removeEventListener(eventName, eventHandler);
-		});
+		removeHandles.push(registerEventListener(rootElement, eventName, eventHandler));
 	}
 }
 const rootElementNotRegisteredWarning = warnOnlyOnce("Root element not registered");
@@ -3526,11 +3696,7 @@ function removeRootElementEvents(rootElement) {
 		rootElementNotRegisteredWarning();
 		return;
 	}
-	const newCount = registration.rootElementCount - 1;
-	if (!(newCount >= 0)) formatDevErrorMessage(`Root element count less than 0`);
 	rootElementToDocument.delete(rootElement);
-	registration.rootElementCount = newCount;
-	if (newCount === 0) doc.removeEventListener("selectionchange", onDocumentSelectionChange);
 	const editor = getEditorPropertyFromDOMNode(rootElement);
 	if (isLexicalEditor(editor)) {
 		cleanActiveNestedEditorsMap(editor);
@@ -3549,17 +3715,19 @@ function cleanActiveNestedEditorsMap(editor) {
 		if (activeNestedEditorsMap.get(rootEditorKey) === editor) activeNestedEditorsMap.delete(rootEditorKey);
 	} else activeNestedEditorsMap.delete(editor._key);
 }
-function markSelectionChangeFromDOMUpdate() {
-	isSelectionChangeFromDOMUpdate = true;
+/** @internal */
+function markSelectionChangeFromDOMUpdate(editor) {
+	editor._inputState.isSelectionChangeFromDOMUpdate = true;
 }
-function markCollapsedSelectionFormat(format, style, offset, key, timeStamp) {
-	collapsedSelectionFormat = [
+/** @internal */
+function markCollapsedSelectionFormat(editor, format, style, offset, key, timeStamp) {
+	editor._inputState.collapsedSelectionFormat = {
 		format,
-		style,
-		offset,
 		key,
+		offset,
+		style,
 		timeStamp
-	];
+	};
 }
 /**
 * The base type for all serialized nodes
@@ -4215,8 +4383,7 @@ var LexicalNode = class {
 	* @param targetNode - the would-be child node.
 	*/
 	isParentOf(targetNode) {
-		const result = $getCommonAncestor(this, targetNode);
-		return result !== null && result.type === "ancestor";
+		return $hasAncestor(targetNode, this);
 	}
 	/**
 	* Returns a list of nodes that are between this node and
@@ -5001,7 +5168,7 @@ function $setTextContent(nextText, dom, node) {
 	const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(node, dom, editor);
 	const firstChild = slot.getFirstChild();
 	if (firstChild === null || firstChild.nodeType !== Node.TEXT_NODE) {
-		slot.insertChild(document.createTextNode(text));
+		slot.insertChild($getDocument().createTextNode(text));
 		return;
 	}
 	const textChild = firstChild;
@@ -5018,13 +5185,16 @@ function $createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
 	const textClassNames = config.theme.text;
 	if (textClassNames !== void 0) setTextThemeClassNames(innerTag, 0, format, innerDOM, textClassNames);
 }
-function wrapElementWith(element, tag) {
-	const el = document.createElement(tag);
+function $wrapElementWith(element, tag) {
+	const el = $getDocument().createElement(tag);
 	el.appendChild(element);
 	return el;
 }
+function $isInlineFormattable(node) {
+	return node != null && node.__isInlineFormattable === true;
+}
 /** @noInheritDoc */
-var TextNode = class TextNode extends LexicalNode {
+var TextNode = class extends LexicalNode {
 	/** @internal */
 	__text;
 	/** @internal */
@@ -5035,11 +5205,61 @@ var TextNode = class TextNode extends LexicalNode {
 	__mode;
 	/** @internal */
 	__detail;
-	static getType() {
-		return "text";
+	/** @internal */
+	get __isInlineFormattable() {
+		return true;
 	}
-	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);
@@ -5082,7 +5302,8 @@ var TextNode = class TextNode extends LexicalNode {
 	* @returns TextModeType.
 	*/
 	getMode() {
-		return TEXT_TYPE_TO_MODE[this.getLatest().__mode];
+		const self = this.getLatest();
+		return TEXT_TYPE_TO_MODE[self.__mode];
 	}
 	/**
 	* Returns the styles currently applied to the node. This is analogous to CSSText in the DOM.
@@ -5191,11 +5412,11 @@ var TextNode = class TextNode extends LexicalNode {
 		const outerTag = getElementOuterTag(this, format);
 		const innerTag = getElementInnerTag(this, format);
 		const tag = outerTag === null ? innerTag : outerTag;
-		const dom = document.createElement(tag);
+		const dom = $getDocument().createElement(tag);
 		let innerDOM = dom;
 		if (this.hasFormat("code")) dom.setAttribute("spellcheck", "false");
 		if (outerTag !== null) {
-			innerDOM = document.createElement(innerTag);
+			innerDOM = $getDocument().createElement(innerTag);
 			dom.appendChild(innerDOM);
 		}
 		const text = this.__text;
@@ -5216,7 +5437,7 @@ var TextNode = class TextNode extends LexicalNode {
 		if (prevOuterTag === nextOuterTag && prevInnerTag !== nextInnerTag) {
 			const prevInnerDOM = dom.firstChild;
 			if (prevInnerDOM == null) formatDevErrorMessage(`updateDOM: prevInnerDOM is null or undefined`);
-			const nextInnerDOM = document.createElement(nextInnerTag);
+			const nextInnerDOM = $getDocument().createElement(nextInnerTag);
 			$createTextInnerDOM(nextInnerDOM, this, nextInnerTag, nextFormat, nextText, config);
 			dom.replaceChild(nextInnerDOM, prevInnerDOM);
 			return false;
@@ -5236,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);
 	}
@@ -5301,10 +5467,10 @@ var TextNode = class TextNode extends LexicalNode {
 		if (this.hasFormat("lowercase")) element.style.textTransform = "lowercase";
 		else if (this.hasFormat("uppercase")) element.style.textTransform = "uppercase";
 		else if (this.hasFormat("capitalize")) element.style.textTransform = "capitalize";
-		if (this.hasFormat("bold")) element = wrapElementWith(element, "b");
-		if (this.hasFormat("italic")) element = wrapElementWith(element, "i");
-		if (this.hasFormat("strikethrough")) element = wrapElementWith(element, "s");
-		if (this.hasFormat("underline")) element = wrapElementWith(element, "u");
+		if (this.hasFormat("bold")) element = $wrapElementWith(element, "b");
+		if (this.hasFormat("italic")) element = $wrapElementWith(element, "i");
+		if (this.hasFormat("strikethrough")) element = $wrapElementWith(element, "s");
+		if (this.hasFormat("underline")) element = $wrapElementWith(element, "u");
 		return { element };
 	}
 	exportJSON() {
@@ -5398,6 +5564,12 @@ var TextNode = class TextNode extends LexicalNode {
 	/**
 	* Sets the mode of the node.
 	*
+	* Note: during IME composition, a segmented TextNode may be temporarily
+	* switched to normal mode to preserve the DOM element that the browser's
+	* composition tracker is bound to. Subclass transforms or method overrides
+	* that assume the node is always in segmented mode should account for this
+	* transient state.
+	*
 	* @returns this TextNode.
 	*/
 	setMode(type) {
@@ -5758,7 +5930,7 @@ function applyTextFormatFromStyle(style, shouldApply) {
 	const hasUnderlineTextDecoration = textDecoration.includes("underline");
 	const verticalAlign = style.verticalAlign;
 	return (lexicalNode) => {
-		if (!$isTextNode(lexicalNode)) return lexicalNode;
+		if (!$isTextNode(lexicalNode) && !$isInlineFormattable(lexicalNode)) return lexicalNode;
 		if (hasBoldFontWeight && !lexicalNode.hasFormat("bold")) lexicalNode.toggleFormat("bold");
 		if (hasLinethroughTextDecoration && !lexicalNode.hasFormat("strikethrough")) lexicalNode.toggleFormat("strikethrough");
 		if (hasItalicFontStyle && !lexicalNode.hasFormat("italic")) lexicalNode.toggleFormat("italic");
@@ -5770,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.
@@ -5926,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;
@@ -6026,8 +6209,17 @@ var NodeSelection = class NodeSelection {
 			$setSelectionFromCaretRange($getCaretRange(firstCaret, firstCaret));
 		}
 		for (const node of nodes) node.remove();
+		$ensureRootHasParagraph();
 	}
 };
+function $ensureRootHasParagraph() {
+	const root = $getRoot();
+	if (root.isEmpty()) {
+		const paragraph = $createParagraphNode();
+		root.append(paragraph);
+		paragraph.select();
+	}
+}
 function $isRangeSelection(x) {
 	return x instanceof RangeSelection;
 }
@@ -6207,11 +6399,11 @@ var RangeSelection = class RangeSelection {
 		this.dirty = true;
 	}
 	/**
-	* Returns whether the provided TextFormatType is present on the Selection. This will be true if any node in the Selection
-	* has the specified format.
+	* Returns whether the provided TextFormatType is present on the Selection. This will be true if all text nodes in the Selection
+	* have the specified format.
 	*
 	* @param type the TextFormatType to check for.
-	* @returns true if the provided format is currently toggled on on the Selection, false otherwise.
+	* @returns true if the provided format is currently toggled on the Selection, false otherwise.
 	*/
 	hasFormat(type) {
 		const formatFlag = TEXT_TYPE_TO_FORMAT[type];
@@ -6232,196 +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;
+		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();
 			}
-		} 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) {
-			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);
+			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") 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.
@@ -6440,79 +6527,7 @@ var RangeSelection = class RangeSelection {
 	* @param alignWithFormat a 32-bit integer representing formatting flags to align with.
 	*/
 	formatText(formatType, alignWithFormat = null) {
-		if (this.isCollapsed()) {
-			this.toggleFormat(formatType);
-			$setCompositionKey(null);
-			return;
-		}
-		const selectedNodes = this.getNodes();
-		const selectedTextNodes = [];
-		for (const selectedNode of selectedNodes) if ($isTextNode(selectedNode)) selectedTextNodes.push(selectedNode);
-		const applyFormatToElements = (alignWith) => {
-			selectedNodes.forEach((node) => {
-				if ($isElementNode(node)) {
-					const newFormat = node.getFormatFlags(formatType, alignWith);
-					node.setTextFormat(newFormat);
-				}
-			});
-		};
-		const selectedTextNodesLength = selectedTextNodes.length;
-		if (selectedTextNodesLength === 0) {
-			this.toggleFormat(formatType);
-			$setCompositionKey(null);
-			applyFormatToElements(alignWithFormat);
-			return;
-		}
-		const anchor = this.anchor;
-		const focus = this.focus;
-		const isBackward = this.isBackward();
-		const startPoint = isBackward ? focus : anchor;
-		const endPoint = isBackward ? anchor : focus;
-		let firstIndex = 0;
-		let firstNode = selectedTextNodes[0];
-		let startOffset = startPoint.type === "element" ? 0 : startPoint.offset;
-		if (startPoint.type === "text" && startOffset === firstNode.getTextContentSize()) {
-			firstIndex = 1;
-			firstNode = selectedTextNodes[1];
-			startOffset = 0;
-		}
-		if (firstNode == null) return;
-		const firstNextFormat = firstNode.getFormatFlags(formatType, alignWithFormat);
-		applyFormatToElements(firstNextFormat);
-		const lastIndex = selectedTextNodesLength - 1;
-		let lastNode = selectedTextNodes[lastIndex];
-		const endOffset = endPoint.type === "text" ? endPoint.offset : lastNode.getTextContentSize();
-		if (firstNode.is(lastNode)) {
-			if (startOffset === endOffset) return;
-			if ($isTokenOrSegmented(firstNode) || startOffset === 0 && endOffset === firstNode.getTextContentSize()) firstNode.setFormat(firstNextFormat);
-			else {
-				const splitNodes = firstNode.splitText(startOffset, endOffset);
-				const replacement = startOffset === 0 ? splitNodes[0] : splitNodes[1];
-				replacement.setFormat(firstNextFormat);
-				if (startPoint.type === "text") startPoint.set(replacement.__key, 0, "text");
-				if (endPoint.type === "text") endPoint.set(replacement.__key, endOffset - startOffset, "text");
-			}
-			this.format = firstNextFormat;
-			return;
-		}
-		if (startOffset !== 0 && !$isTokenOrSegmented(firstNode)) {
-			[, firstNode] = firstNode.splitText(startOffset);
-			startOffset = 0;
-		}
-		firstNode.setFormat(firstNextFormat);
-		const lastNextFormat = lastNode.getFormatFlags(formatType, firstNextFormat);
-		if (endOffset > 0) {
-			if (endOffset !== lastNode.getTextContentSize() && !$isTokenOrSegmented(lastNode)) [lastNode] = lastNode.splitText(endOffset);
-			lastNode.setFormat(lastNextFormat);
-		}
-		for (let i = firstIndex + 1; i < lastIndex; i++) {
-			const textNode = selectedTextNodes[i];
-			const nextFormat = textNode.getFormatFlags(formatType, lastNextFormat);
-			textNode.setFormat(nextFormat);
-		}
-		if (startPoint.type === "text") startPoint.set(firstNode.__key, startOffset, "text");
-		if (endPoint.type === "text") endPoint.set(lastNode.__key, endOffset, "text");
-		this.format = firstNextFormat | lastNextFormat;
+		$formatText(this, formatType, alignWithFormat);
 	}
 	/**
 	* Attempts to "intelligently" insert an arbitrary list of Lexical nodes into the EditorState at the
@@ -6546,8 +6561,8 @@ var RangeSelection = class RangeSelection {
 			if (nodeToSelect !== null) nodeToSelect.selectEnd();
 			return;
 		}
-		const firstNode = (this.isBackward() ? this.focus : this.anchor).getNode();
-		const firstBlock = $findMatchingParent(firstNode, INTERNAL_$isBlock);
+		let firstNode = (this.isBackward() ? this.focus : this.anchor).getNode();
+		let firstBlock = $findMatchingParent(firstNode, INTERNAL_$isBlock);
 		const last = nodes[nodes.length - 1];
 		if ($isElementNode(firstBlock) && "__language" in firstBlock) {
 			if ("__language" in nodes[0]) this.insertText(nodes[0].getTextContent());
@@ -6597,6 +6612,10 @@ var RangeSelection = class RangeSelection {
 		const blocks = blocksParent.getChildren();
 		const isMergeable = (node) => $isElementNode(node) && INTERNAL_$isBlock(node) && !node.isEmpty() && $isElementNode(firstBlock) && (!firstBlock.isEmpty() || firstBlock.canMergeWhenEmpty());
 		const insertedParagraph = !$isElementNode(firstBlock) || !firstBlock.isEmpty() ? this.insertParagraph() : null;
+		if (insertedParagraph && !firstBlock.isAttached()) {
+			firstNode = this.anchor.getNode();
+			firstBlock = $findMatchingParent(firstNode, INTERNAL_$isBlock);
+		}
 		const lastToInsert = blocks[blocks.length - 1];
 		let firstToInsert = blocks[0];
 		if (isMergeable(firstToInsert)) {
@@ -6725,21 +6744,37 @@ var RangeSelection = class RangeSelection {
 		const rootElement = editor._rootElement;
 		const focusNode = this.focus.getNode();
 		if (rootElement !== null && blockCursorElement !== null && $isElementNode(focusNode) && !focusNode.isInline() && !focusNode.canBeEmpty()) removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
+		const focusKeyedDOM = getElementByKeyOrThrow(editor, this.focus.key);
+		let nextFocusDOM = focusKeyedDOM;
+		if (this.focus.type === "text") nextFocusDOM = $isTextNode(focusNode) ? $getDOMTextNode(focusNode, focusKeyedDOM, editor) : null;
 		if (this.dirty) {
 			const anchorKeyedDOM = getElementByKeyOrThrow(editor, this.anchor.key);
-			const focusKeyedDOM = getElementByKeyOrThrow(editor, this.focus.key);
 			let nextAnchorDOM = anchorKeyedDOM;
-			let nextFocusDOM = focusKeyedDOM;
 			if (this.anchor.type === "text") {
 				const node = this.anchor.getNode();
 				nextAnchorDOM = $isTextNode(node) ? $getDOMTextNode(node, anchorKeyedDOM, editor) : null;
 			}
-			if (this.focus.type === "text") {
-				const node = this.focus.getNode();
-				nextFocusDOM = $isTextNode(node) ? $getDOMTextNode(node, focusKeyedDOM, editor) : null;
-			}
 			if (nextAnchorDOM && nextFocusDOM) setDOMSelectionBaseAndExtent(domSelection, nextAnchorDOM, this.anchor.offset, nextFocusDOM, this.focus.offset);
 		}
+		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);
+					}
+				} 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;
+				}
+			}
+		}
 		moveNativeSelection(domSelection, alter, isBackward ? "backward" : "forward", granularity);
 		if (domSelection.rangeCount > 0) {
 			const composedRange = getComposedStaticRange(domSelection, editor._rootElement);
@@ -6749,23 +6784,7 @@ var RangeSelection = class RangeSelection {
 			this.applyDOMRange(range);
 			this.dirty = true;
 			if (!collapse) {
-				const nodes = this.getNodes();
-				const validNodes = [];
-				let shrinkSelection = false;
-				for (let i = 0; i < nodes.length; i++) {
-					const nextNode = nodes[i];
-					if ($hasAncestor(nextNode, root)) validNodes.push(nextNode);
-					else shrinkSelection = true;
-				}
-				if (shrinkSelection && validNodes.length > 0) if (isBackward) {
-					const firstValidNode = validNodes[0];
-					if ($isElementNode(firstValidNode)) firstValidNode.selectStart();
-					else firstValidNode.getParentOrThrow().selectStart();
-				} else {
-					const lastValidNode = validNodes[validNodes.length - 1];
-					if ($isElementNode(lastValidNode)) lastValidNode.selectEnd();
-					else lastValidNode.getParentOrThrow().selectEnd();
-				}
+				$shrinkSelectionToRoot(this, isBackward, root);
 				if (!(composedRange ? domSelection.direction !== "backward" : domSelection.anchorNode === range.startContainer && domSelection.anchorOffset === range.startOffset)) $swapPoints(this);
 			}
 		}
@@ -6862,7 +6881,7 @@ var RangeSelection = class RangeSelection {
 				}
 			}
 			const focus = this.focus;
-			this.modify("extend", isBackward, "character");
+			$extendSelectionForDeletion(this, isBackward, "character");
 			if (!this.isCollapsed()) {
 				const focusNode = focus.type === "text" ? focus.getNode() : null;
 				anchorNode = anchor.type === "text" ? anchor.getNode() : null;
@@ -6890,6 +6909,7 @@ var RangeSelection = class RangeSelection {
 		if (isBackward && !wasCollapsed && this.isCollapsed() && this.anchor.type === "element" && this.anchor.offset === 0) {
 			const anchorNode = this.anchor.getNode();
 			if (anchorNode.isEmpty() && $isRootNode(anchorNode.getParent()) && anchorNode.getPreviousSibling() === null) $collapseAtStart(this, anchorNode);
+			$ensureRootHasParagraph();
 		}
 	}
 	/**
@@ -6905,9 +6925,12 @@ var RangeSelection = class RangeSelection {
 			this.deleteCharacter(isBackward);
 			return;
 		}
-		if (this.isCollapsed()) this.modify("extend", isBackward, "lineboundary");
+		if (this.isCollapsed()) $extendSelectionForDeletion(this, isBackward, "lineboundary");
 		if (this.isCollapsed()) this.deleteCharacter(isBackward);
-		else this.removeText();
+		else if ($findMatchingParent(this.anchor.getNode(), INTERNAL_$isBlock) !== $findMatchingParent(this.focus.getNode(), INTERNAL_$isBlock)) {
+			this.focus.set(this.anchor.key, this.anchor.offset, this.anchor.type);
+			this.deleteCharacter(isBackward);
+		} else this.removeText();
 	}
 	/**
 	* Performs one logical word deletion operation on the EditorState based on the current Selection.
@@ -6920,7 +6943,7 @@ var RangeSelection = class RangeSelection {
 			const anchor = this.anchor;
 			const anchorNode = anchor.getNode();
 			if (this.forwardDeletion(anchor, anchorNode, isBackward)) return;
-			this.modify("extend", isBackward, "word");
+			$extendSelectionForDeletion(this, isBackward, "word");
 		}
 		if (this.isCollapsed()) this.deleteCharacter(isBackward);
 		else this.removeText();
@@ -6944,6 +6967,124 @@ var RangeSelection = class RangeSelection {
 function $isNodeSelection(x) {
 	return x instanceof NodeSelection;
 }
+/**
+* Applies a pure bitmask transform to every formattable node in the selection
+* in a single traversal, splitting the first and last TextNodes as necessary
+* so that only the selected text is affected. Each node receives exactly one
+* `setFormat(applyFormat(getFormat()))` (ElementNodes use their textFormat).
+*
+* @param selection - the selection whose nodes should be formatted.
+* @param applyFormat - maps a node's current 32-bit format to its new format.
+*/
+function $updateTextFormat(selection, applyFormat) {
+	if ($isNodeSelection(selection)) {
+		for (const node of selection.getNodes()) if ($isInlineFormattable(node)) node.setFormat(applyFormat(node.getFormat()));
+		return;
+	}
+	if (selection.isCollapsed()) {
+		selection.setFormat(applyFormat(selection.format));
+		$setCompositionKey(null);
+		return;
+	}
+	const selectedTextNodes = [];
+	for (const node of selection.getNodes()) if ($isTextNode(node)) selectedTextNodes.push(node);
+	else if ($isElementNode(node)) node.setTextFormat(applyFormat(node.getTextFormat()));
+	else if ($isInlineFormattable(node)) node.setFormat(applyFormat(node.getFormat()));
+	const selectedTextNodesLength = selectedTextNodes.length;
+	if (selectedTextNodesLength === 0) {
+		selection.setFormat(applyFormat(selection.format));
+		$setCompositionKey(null);
+		return;
+	}
+	const anchor = selection.anchor;
+	const focus = selection.focus;
+	const isBackward = selection.isBackward();
+	const startPoint = isBackward ? focus : anchor;
+	const endPoint = isBackward ? anchor : focus;
+	let firstIndex = 0;
+	let firstNode = selectedTextNodes[0];
+	let startOffset = startPoint.type === "element" ? 0 : startPoint.offset;
+	if (startPoint.type === "text" && startOffset === firstNode.getTextContentSize()) {
+		firstIndex = 1;
+		firstNode = selectedTextNodes[1];
+		startOffset = 0;
+	}
+	if (firstNode == null) return;
+	const lastIndex = selectedTextNodesLength - 1;
+	let lastNode = selectedTextNodes[lastIndex];
+	const endOffset = endPoint.type === "text" ? endPoint.offset : lastNode.getTextContentSize();
+	if (firstNode.is(lastNode)) {
+		if (startOffset === endOffset) return;
+		const newFormat = applyFormat(firstNode.getFormat());
+		if ($isTokenOrSegmented(firstNode) || startOffset === 0 && endOffset === firstNode.getTextContentSize()) firstNode.setFormat(newFormat);
+		else {
+			const splitNodes = firstNode.splitText(startOffset, endOffset);
+			const replacement = startOffset === 0 ? splitNodes[0] : splitNodes[1];
+			replacement.setFormat(newFormat);
+			if (startPoint.type === "text") startPoint.set(replacement.__key, 0, "text");
+			if (endPoint.type === "text") endPoint.set(replacement.__key, endOffset - startOffset, "text");
+		}
+		selection.format = newFormat;
+		return;
+	}
+	if (startOffset !== 0 && !$isTokenOrSegmented(firstNode)) {
+		[, firstNode] = firstNode.splitText(startOffset);
+		startOffset = 0;
+	}
+	const firstNextFormat = applyFormat(firstNode.getFormat());
+	firstNode.setFormat(firstNextFormat);
+	const lastNextFormat = applyFormat(lastNode.getFormat());
+	if (endOffset > 0) {
+		if (endOffset !== lastNode.getTextContentSize() && !$isTokenOrSegmented(lastNode)) [lastNode] = lastNode.splitText(endOffset);
+		lastNode.setFormat(lastNextFormat);
+	}
+	for (let i = firstIndex + 1; i < lastIndex; i++) {
+		const textNode = selectedTextNodes[i];
+		textNode.setFormat(applyFormat(textNode.getFormat()));
+	}
+	if (startPoint.type === "text") startPoint.set(firstNode.__key, startOffset, "text");
+	if (endPoint.type === "text") endPoint.set(lastNode.__key, endOffset, "text");
+	selection.format = firstNextFormat | lastNextFormat;
+}
+/**
+* Explicitly sets or unsets text formats on the selection. Unlike $formatText
+* which toggles based on the current selection state, this function sets each
+* specified format to the exact boolean value provided. Mutually exclusive
+* formats (subscript/superscript, lowercase/uppercase/capitalize) are
+* reconciled by {@link toggleTextFormatType}, with later entries winning when
+* the requested formats conflict.
+*
+* @param selection - the selection whose nodes should be formatted.
+* @param formats - a partial record mapping TextFormatType to boolean.
+*/
+function $setTextFormat(selection, formats) {
+	const entries = [];
+	for (const [type, value] of Object.entries(formats)) if (typeof value === "boolean") entries.push([type, value]);
+	if (entries.length === 0) return;
+	$updateTextFormat(selection, (format) => {
+		for (const [type, value] of entries) format = toggleTextFormatType(format, type, value ? TEXT_TYPE_TO_FORMAT[type] : 0);
+		return format;
+	});
+}
+/**
+* Applies the provided format to TextNodes and inline formattable nodes
+* (e.g. DecoratorTextNode) in the selection, splitting or merging TextNodes
+* as necessary and aligning all formattable nodes to the same target format.
+*
+* For RangeSelection the toggle direction is determined by the selection's
+* computed format (intersection of all text nodes) when no explicit alignment
+* is given. For NodeSelection each node is toggled independently when no
+* explicit alignment is given, since there is no TextNode to use as an
+* alignment reference.
+*
+* @param selection - the selection whose nodes should be formatted.
+* @param formatType - the format type to apply.
+* @param alignWithFormat - optional 32-bit bitmask to align with.
+*/
+function $formatText(selection, formatType, alignWithFormat = null) {
+	const effectiveAlign = alignWithFormat === null && $isRangeSelection(selection) ? toggleTextFormatType(selection.format, formatType, null) : alignWithFormat;
+	$updateTextFormat(selection, (format) => toggleTextFormatType(format, formatType, effectiveAlign));
+}
 function getCharacterOffset(point) {
 	const offset = point.offset;
 	if (point.type === "text") return offset;
@@ -6980,9 +7121,126 @@ function moveNativeSelection(domSelection, alter, direction, granularity) {
 	domSelection.modify(alter, direction, granularity);
 }
 /**
+* Validate that the selection respects `root` (the nearest root or shadow
+* root): if any selected node lies outside of it, shrink the selection to the
+* valid edge in the given direction. The valid node check is a safeguard
+* against an invalid selection, for which getNodes() returns an empty array.
+*
+* @returns true if the selection was shrunk
+*/
+function $shrinkSelectionToRoot(selection, isBackward, root) {
+	const nodes = selection.getNodes();
+	const validNodes = nodes.filter((node) => $hasAncestor(node, root));
+	if (validNodes.length === 0 || validNodes.length === nodes.length) return false;
+	const edgeNode = isBackward ? validNodes[0] : validNodes[validNodes.length - 1];
+	const edgeElement = $isElementNode(edgeNode) ? edgeNode : edgeNode.getParentOrThrow();
+	if (isBackward) edgeElement.selectStart();
+	else edgeElement.selectEnd();
+	return true;
+}
+/**
+* Extend a collapsed selection by one unit (`character`, `word` or
+* `lineboundary`) in the deletion direction without ever creating a
+* non-collapsed DOM selection.
+*
+* On Linux/X11, browsers propagate any non-collapsed DOM selection made
+* during a user gesture to the PRIMARY selection (the middle-click paste
+* buffer), so a deletion must never pass through a transient non-collapsed
+* DOM selection or every Backspace/Delete overwrites the user's paste
+* buffer (https://github.com/facebook/lexical/issues/8766). A collapsed
+* caret never takes PRIMARY ownership, so the DOM caret is moved with the
+* native `modify('move')` to measure where the engine places the unit
+* boundary, and the `[original .. landed]` range is constructed in the
+* model only. `applyDOMRange` reads just the range's boundary points (it
+* never touches the DOM selection), giving the same point resolution,
+* decorator pre/post handling, shadow-root shrink validation and
+* anchor/focus orientation as a native selection extension would, while
+* the DOM selection is only ever collapsed.
+*
+* When the measurement is not possible — no DOM selection or no
+* `Selection.modify` (headless environments can polyfill it), or an
+* unresolvable anchor — the selection is left collapsed, so the deletion
+* becomes a no-op for that keystroke.
+*/
+function $extendSelectionForDeletion(selection, isBackward, granularity) {
+	if ($modifySelectionAroundDecoratorsAndBlocks(selection, "extend", isBackward, granularity)) return;
+	const editor = getActiveEditor();
+	const domSelection = getDOMSelection(getWindow(editor));
+	if (!domSelection || typeof domSelection.modify !== "function") return;
+	const blockCursorElement = editor._blockCursorElement;
+	const rootElement = editor._rootElement;
+	const anchor = selection.anchor;
+	const focusNode = selection.focus.getNode();
+	if (rootElement !== null && blockCursorElement !== null && $isElementNode(focusNode) && !focusNode.isInline() && !focusNode.canBeEmpty()) removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
+	const $resolvePointDOM = (point) => {
+		const pointNode = point.getNode();
+		const keyedDOM = editor.getElementByKey(point.key);
+		return keyedDOM !== null && point.type === "text" && $isTextNode(pointNode) ? $getDOMTextNode(pointNode, keyedDOM, editor) : keyedDOM;
+	};
+	const anchorNode = anchor.getNode();
+	const anchorDOM = $resolvePointDOM(anchor);
+	if (anchorDOM === null) return;
+	const anchorOffset = anchor.offset;
+	const wasCollapsed = selection.isCollapsed();
+	const focus = selection.focus;
+	const focusDOM = wasCollapsed ? anchorDOM : $resolvePointDOM(focus);
+	if (focusDOM === null) return;
+	const focusOffset = focus.offset;
+	setDOMSelectionBaseAndExtent(domSelection, focusDOM, focusOffset, focusDOM, focusOffset);
+	moveNativeSelection(domSelection, "move", isBackward ? "backward" : "forward", granularity);
+	if (domSelection.rangeCount === 0) return;
+	const landedRange = getComposedStaticRange(domSelection, rootElement) || domSelection.getRangeAt(0);
+	const landedContainer = landedRange.startContainer;
+	const landedOffset = landedRange.startOffset;
+	if (wasCollapsed && granularity === "character" && anchor.type === "text" && $isTextNode(anchorNode) && anchorNode.isUnmergeable()) {
+		if (anchorOffset === (isBackward ? 0 : anchorNode.getTextContentSize())) {
+			const sibling = $getSiblingCaret(anchorNode, isBackward ? "previous" : "next").getNodeAtCaret();
+			if ($isTextNode(sibling)) {
+				const sibOffset = isBackward ? sibling.getTextContentSize() - 1 : 1;
+				selection.focus.set(sibling.__key, sibOffset, "text");
+				selection.dirty = true;
+				return;
+			}
+		}
+	}
+	if (wasCollapsed && granularity === "character" && anchor.type === "text") {
+		const edgeOffset = isBackward ? 0 : anchorNode.getTextContentSize();
+		const clampedOffset = landedContainer === anchorDOM ? landedOffset : anchorOffset !== edgeOffset ? edgeOffset : -1;
+		if (clampedOffset >= 0) {
+			if (clampedOffset !== anchorOffset) {
+				selection.focus.set(anchor.key, clampedOffset, "text");
+				selection.dirty = true;
+			}
+			return;
+		}
+	}
+	const [startContainer, startOffset, endContainer, endOffset] = isBackward ? [
+		landedContainer,
+		landedOffset,
+		anchorDOM,
+		anchorOffset
+	] : [
+		anchorDOM,
+		anchorOffset,
+		landedContainer,
+		landedOffset
+	];
+	const root = $isRootNode(anchorNode) ? anchorNode : $getNearestRootOrShadowRoot(anchorNode);
+	selection.applyDOMRange({
+		collapsed: false,
+		endContainer,
+		endOffset,
+		startContainer,
+		startOffset
+	});
+	selection.dirty = true;
+	if (!$shrinkSelectionToRoot(selection, isBackward, root) && isBackward) $swapPoints(selection);
+	if (granularity === "lineboundary") $modifySelectionAroundDecoratorsAndBlocks(selection, "extend", isBackward, granularity, "decorators");
+}
+/**
 * Called by `RangeSelection.deleteCharacter` to determine if
-* `this.modify('extend', isBackward, 'character')` extended the selection
-* further than a user would expect for that operation.
+* `$extendSelectionForDeletion` extended the selection further
+* than a user would expect for that operation.
 *
 * A short(?) JavaScript string vs. Unicode primer:
 *
@@ -7016,7 +7274,7 @@ function moveNativeSelection(domSelection, alter, direction, granularity) {
 * essentially be arbitrarily long, as there are many ways to combine
 * them.
 *
-* The `this.modify(…)` call has already extended our selection by one
+* The native caret measurement has already extended our selection by one
 * *grapheme* in the direction we want to delete. Sounds great, it's done
 * a lot of awfully tricky work for us because this functionality has only
 * recently become available in JavaScript via `Intl.Segmenter`. The
@@ -7197,7 +7455,7 @@ function resolveSelectionPointOnBoundary(point, isBackward, isCollapsed) {
 		const parent = node.getParent();
 		if (!isBackward) {
 			if ($isElementNode(prevSibling) && !isCollapsed && prevSibling.isInline()) point.set(prevSibling.__key, prevSibling.getChildrenSize(), "element");
-			else if ($isTextNode(prevSibling)) point.set(prevSibling.__key, prevSibling.getTextContent().length, "text");
+			else if ($isTextNode(prevSibling) && !node.isUnmergeable()) point.set(prevSibling.__key, prevSibling.getTextContent().length, "text");
 		} else if ((isCollapsed || !isBackward) && prevSibling === null && $isElementNode(parent) && parent.isInline()) {
 			const parentSibling = parent.getPreviousSibling();
 			if ($isTextNode(parentSibling)) point.set(parentSibling.__key, parentSibling.getTextContent().length, "text");
@@ -7206,7 +7464,7 @@ function resolveSelectionPointOnBoundary(point, isBackward, isCollapsed) {
 		const nextSibling = node.getNextSibling();
 		const parent = node.getParent();
 		if (isBackward && $isElementNode(nextSibling) && nextSibling.isInline()) point.set(nextSibling.__key, 0, "element");
-		else if ((isCollapsed || isBackward) && nextSibling === null && $isElementNode(parent) && parent.isInline() && !parent.canInsertTextAfter()) {
+		else if ((isCollapsed || isBackward) && nextSibling === null && $isElementNode(parent) && parent.isInline() && !parent.canInsertTextAfter() && parent.getTextContentSize() > 1) {
 			const parentSibling = parent.getNextSibling();
 			if ($isTextNode(parentSibling)) point.set(parentSibling.__key, 0, "text");
 		}
@@ -7565,7 +7823,7 @@ function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
 	} else if ($isRangeSelection(prevSelection) && prevSelection.anchor.type === "text") anchorFormatOrStyleChanged = true;
 	if (focus.type === "text") nextFocusNode = $isTextNode(focusNode) ? $getDOMTextNode(focusNode, focusDOM, editor) : null;
 	if (nextAnchorNode === null || nextFocusNode === null) return;
-	if (isCollapsed && (prevSelection === null || anchorFormatOrStyleChanged || $isRangeSelection(prevSelection) && (prevSelection.format !== nextFormat || prevSelection.style !== nextStyle))) markCollapsedSelectionFormat(nextFormat, nextStyle, nextAnchorOffset, anchor.key, performance.now());
+	if (isCollapsed && (prevSelection === null || anchorFormatOrStyleChanged || $isRangeSelection(prevSelection) && (prevSelection.format !== nextFormat || prevSelection.style !== nextStyle))) markCollapsedSelectionFormat(editor, nextFormat, nextStyle, nextAnchorOffset, anchor.key, performance.now());
 	if (!(domSelection.type === "Range" && isCollapsed) && currentPoints.anchorOffset === nextAnchorOffset && currentPoints.focusOffset === nextFocusOffset && currentPoints.anchorNode === nextAnchorNode && currentPoints.focusNode === nextFocusNode) {
 		if (activeElement === null || !rootElement.contains(activeElement)) {
 			const focusEditor = activeElement !== null ? getNearestEditorFromDOMNode(activeElement) : null;
@@ -7594,7 +7852,7 @@ function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
 			scrollIntoViewIfNeeded(editor, selectionRect, rootElement);
 		}
 	}
-	markSelectionChangeFromDOMUpdate();
+	markSelectionChangeFromDOMUpdate(editor);
 }
 function $insertNodes(nodes) {
 	let selection = $getSelection() || $getPreviousSelection();
@@ -8072,7 +8330,7 @@ function $commitPendingUpdatesImpl(editor, recoveryEditorState) {
 	const rootElement = editor._rootElement;
 	const shouldSkipDOM = editor._headless || rootElement === null;
 	if (pendingEditorState === null) {
-		if (editor._deferred.length > 0) triggerDeferredUpdateCallbacks(editor, editor._deferred);
+		if (!editor._updating && editor._deferred.length > 0) triggerDeferredUpdateCallbacks(editor, editor._deferred);
 		return;
 	}
 	const currentEditorState = editor._editorState;
@@ -8130,7 +8388,6 @@ function $commitPendingUpdatesImpl(editor, recoveryEditorState) {
 	const dirtyElements = editor._dirtyElements;
 	const normalizedNodes = editor._normalizedNodes;
 	const tags = editor._updateTags;
-	const deferred = editor._deferred;
 	if (needsUpdate) {
 		editor._dirtyType = NO_DIRTY_NODES;
 		editor._cloneNotNeeded.clear();
@@ -8159,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
 	*/
@@ -8179,7 +8436,10 @@ function $commitPendingUpdatesImpl(editor, recoveryEditorState) {
 		prevEditorState: recoveryEditorState || currentEditorState,
 		tags
 	});
-	triggerDeferredUpdateCallbacks(editor, deferred);
+	if (!previouslyUpdating) {
+		const deferred = editor._deferred;
+		triggerDeferredUpdateCallbacks(editor, deferred);
+	}
 	$triggerEnqueuedUpdates(editor);
 }
 function triggerTextContentListeners(editor, currentEditorState, pendingEditorState) {
@@ -8407,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) {
@@ -8500,7 +8763,8 @@ var ElementNode = class extends LexicalNode {
 		return this.getLatest().__format;
 	}
 	getFormatType() {
-		return ELEMENT_FORMAT_TO_TYPE[this.getFormat()] || "";
+		const format = this.getFormat();
+		return ELEMENT_FORMAT_TO_TYPE[format] || "";
 	}
 	getStyle() {
 		return this.getLatest().__style;
@@ -9086,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");
@@ -9230,11 +9491,11 @@ 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 document.createElement("div");
+		return $getDocument().createElement("div");
 	}
 };
 /**
@@ -9245,22 +9506,22 @@ 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";
 	}
 	createDOM() {
-		return document.createElement("br");
+		return $getDocument().createElement("br");
 	}
 	updateDOM() {
 		return false;
@@ -9268,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() };
@@ -9338,16 +9587,19 @@ 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 = document.createElement("p");
+		const dom = $getDocument().createElement("p");
 		const classNames = getCachedClassNameArray(config.theme, "paragraph");
 		if (classNames !== void 0) dom.classList.add(...classNames);
 		return dom;
@@ -9355,24 +9607,15 @@ 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)) {
-			if (this.isEmpty()) element.append(document.createElement("br"));
+			if (this.isEmpty()) element.append($getDocument().createElement("br"));
 			const formatType = this.getFormatType();
 			if (formatType) element.style.textAlign = formatType;
 		}
 		return { element };
 	}
-	static importJSON(serializedNode) {
-		return $createParagraphNode().updateFromJSON(serializedNode);
-	}
 	exportJSON() {
 		const json = super.exportJSON();
 		if (json.textFormat === void 0 || json.textStyle === void 0) {
@@ -9448,6 +9691,33 @@ function $isParagraphNode(node) {
 * - `'latest'` reads the latest committed state without flushing pending
 *   updates, equivalent to `editor.getEditorState().read(callbackFn, {editor})`.
 */
+/** @internal */
+/** @internal */
+/** @internal */
+function createInputState() {
+	return {
+		collapsedSelectionFormat: {
+			format: 0,
+			key: "root",
+			offset: 0,
+			style: "",
+			timeStamp: 0
+		},
+		compositionEndData: "",
+		compositionPhase: "idle",
+		hadOrphanedCompositionEvents: false,
+		handledSelectionCommandTimeoutId: null,
+		isInsertLineBreak: false,
+		isInsertTextAfterHandledSelectionCommand: false,
+		isSelectionChangeFromDOMUpdate: false,
+		isSelectionChangeFromMouseDown: false,
+		lastBeforeInputInsertTextTimeStamp: 0,
+		lastKeyCode: null,
+		lastKeyDownTimeStamp: 0,
+		postDeleteSelectionToRestore: null,
+		unprocessedBeforeInputData: null
+	};
+}
 /**
 * Configuration entry passed in {@link CreateEditorArgs.nodes} to substitute
 * a core node class with a custom subclass. The replacement class itself
@@ -9585,6 +9855,8 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
 		editor._cascadeCount = 0;
 	}
 	editor._blockCursorElement = null;
+	if (editor._inputState.handledSelectionCommandTimeoutId !== null) clearTimeout(editor._inputState.handledSelectionCommandTimeoutId);
+	editor._inputState = createInputState();
 	const observer = editor._observer;
 	if (observer !== null) {
 		observer.disconnect();
@@ -9838,6 +10110,8 @@ var LexicalEditor = class {
 	*/
 	_slotsUsed;
 	/** @internal */
+	_inputState;
+	/** @internal */
 	_createEditorArgs;
 	/** @internal */
 	constructor(editorState, parentEditor, nodes, config, onError, onWarn, htmlConversions, editable, createEditorArgs) {
@@ -9881,6 +10155,7 @@ var LexicalEditor = class {
 		this._window = null;
 		this._blockCursorElement = null;
 		this._slotsUsed = false;
+		this._inputState = createInputState();
 	}
 	/**
 	*
@@ -9901,7 +10176,7 @@ var LexicalEditor = class {
 		return registerListener(this._listeners.update, listener);
 	}
 	/**
-	* Registers a listener for for when the editor changes between editable and non-editable states.
+	* Registers a listener for when the editor changes between editable and non-editable states.
 	* Will trigger the provided callback each time the editor transitions between these states until the
 	* teardown function is called.
 	*
@@ -10112,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.
@@ -10348,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;
@@ -10736,6 +11012,7 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
 	let node = textNode;
 	if (node.isAttached() && (compositionEnd || !node.isDirty())) {
 		const isComposing = node.isComposing();
+		if (node.isToken() && isComposing) return;
 		let normalizedTextContent = textContent;
 		if (isComposing || compositionEnd) {
 			if (textContent.endsWith(COMPOSITION_SUFFIX)) normalizedTextContent = textContent.slice(0, -COMPOSITION_SUFFIX.length);
@@ -10770,7 +11047,7 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
 			const prevTextContentSize = node.getTextContentSize();
 			const compositionKey = $getCompositionKey();
 			const nodeKey = node.getKey();
-			if (node.isToken() || compositionKey !== null && nodeKey === compositionKey && !isComposing || $isRangeSelection(prevSelection) && (parent !== null && !parent.canInsertTextBefore() && prevSelection.anchor.offset === 0 || prevSelection.anchor.key === textNode.__key && prevSelection.anchor.offset === 0 && !node.canInsertTextBefore() && !isComposing || prevSelection.focus.key === textNode.__key && prevSelection.focus.offset === prevTextContentSize && !node.canInsertTextAfter() && !isComposing)) {
+			if (node.isToken() && !isComposing || compositionKey !== null && nodeKey === compositionKey && !isComposing || $isRangeSelection(prevSelection) && (parent !== null && !parent.canInsertTextBefore() && prevSelection.anchor.offset === 0 || prevSelection.anchor.key === textNode.__key && prevSelection.anchor.offset === 0 && !node.canInsertTextBefore() && !isComposing || prevSelection.focus.key === textNode.__key && prevSelection.focus.offset === prevTextContentSize && !node.canInsertTextAfter() && !isComposing)) {
 				node.markDirty();
 				return;
 			}
@@ -11099,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);
@@ -11120,6 +11397,8 @@ function scrollIntoViewIfNeeded(editor, selectionRect, rootElement) {
 	const doc = getDOMOwnerDocument(rootElement);
 	const defaultView = getDefaultView(doc);
 	if (doc === null || defaultView === null) return;
+	const rootRect = rootElement.getBoundingClientRect();
+	if (selectionRect.bottom < rootRect.top) return;
 	let { top: currentTop, bottom: currentBottom } = selectionRect;
 	let targetTop = 0;
 	let targetBottom = 0;
@@ -11142,7 +11421,7 @@ function scrollIntoViewIfNeeded(editor, selectionRect, rootElement) {
 			if (isFinite(scrollPaddingTop)) targetTop += scrollPaddingTop;
 			if (isFinite(scrollPaddingBottom)) targetBottom -= scrollPaddingBottom;
 		} else {
-			const targetRect = element.getBoundingClientRect();
+			const targetRect = element === rootElement ? rootRect : element.getBoundingClientRect();
 			targetTop = targetRect.top;
 			targetBottom = targetRect.bottom;
 		}
@@ -11219,8 +11498,11 @@ function $getNearestRootOrShadowRoot(node) {
 	}
 	return current;
 }
+function $isShadowRootNode(node) {
+	return $isElementNode(node) && node.isShadowRoot();
+}
 function $isRootOrShadowRoot(node) {
-	return $isRootNode(node) || $isElementNode(node) && node.isShadowRoot();
+	return $isRootNode(node) || $isShadowRootNode(node);
 }
 /**
 * Returns a shallow clone of node with a new key. All properties of the node
@@ -11234,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);
@@ -11275,9 +11557,9 @@ function $getNodeByKeyOrThrow(key) {
 	if (node === null) formatDevErrorMessage(`Expected node with key ${key} to exist but it's not in the nodeMap.`);
 	return node;
 }
-function createBlockCursorElement(editorConfig) {
+function $createBlockCursorElement(editorConfig) {
 	const theme = editorConfig.theme;
-	const element = document.createElement("div");
+	const element = $getDocument().createElement("div");
 	element.contentEditable = "false";
 	element.setAttribute("data-lexical-cursor", "true");
 	let blockCursorTheme = theme.blockCursor;
@@ -11287,8 +11569,24 @@ function createBlockCursorElement(editorConfig) {
 	}
 	return element;
 }
-function needsBlockCursor(node) {
-	return ($isDecoratorNode(node) || $isElementNode(node) && !node.canBeEmpty()) && !node.isInline();
+/**
+* Returns true if the given node needs a block cursor given an adjacent selection,
+* the node must be non-inline and one of:
+* - DecoratorNode
+* - ShadowRootNode with a parent that is not also a ShadowRootNode
+* - An ElementNode that can't be empty
+*/
+function $needsBlockCursorBeside(node) {
+	if (!node || node.isInline()) return false;
+	if ($isDecoratorNode(node)) return true;
+	if ($isElementNode(node)) {
+		if (node.isShadowRoot()) {
+			const parent = node.getParent();
+			return !($isElementNode(parent) && parent.isShadowRoot());
+		}
+		return !node.canBeEmpty();
+	}
+	return false;
 }
 function removeDOMBlockCursorElement(blockCursorElement, editor, rootElement) {
 	rootElement.style.removeProperty("caret-color");
@@ -11306,12 +11604,12 @@ function $updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
 		let isBlockCursor = false;
 		let insertBeforeElement = null;
 		if (offset === elementNodeSize) {
-			if (needsBlockCursor(elementNode.getChildAtIndex(offset - 1))) isBlockCursor = true;
+			if ($needsBlockCursorBeside(elementNode.getChildAtIndex(offset - 1))) isBlockCursor = true;
 		} else {
 			const child = elementNode.getChildAtIndex(offset);
-			if (child !== null && needsBlockCursor(child)) {
+			if (child !== null && $needsBlockCursorBeside(child)) {
 				const sibling = child.getPreviousSibling();
-				if (sibling === null || needsBlockCursor(sibling)) {
+				if (sibling === null || $needsBlockCursorBeside(sibling)) {
 					isBlockCursor = true;
 					insertBeforeElement = editor.getElementByKey(child.__key);
 				}
@@ -11319,7 +11617,7 @@ function $updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
 		}
 		if (isBlockCursor) {
 			const elementDOM = $getDOMSlot(elementNode, editor.getElementByKey(elementNode.__key), editor).element;
-			if (blockCursorElement === null) editor._blockCursorElement = blockCursorElement = createBlockCursorElement(editor._config);
+			if (blockCursorElement === null) editor._blockCursorElement = blockCursorElement = $createBlockCursorElement(editor._config);
 			rootElement.style.caretColor = "transparent";
 			if (insertBeforeElement === null) elementDOM.appendChild(blockCursorElement);
 			else elementDOM.insertBefore(blockCursorElement, insertBeforeElement);
@@ -11414,6 +11712,28 @@ function getRootOwnerDocument(rootElement) {
 	return rootElement !== null ? rootElement.ownerDocument : document;
 }
 /**
+* Returns the {@link Document} that owns the active editor's root element.
+* Falls back to `globalThis.document` when there is no active editor (e.g.
+* a node method such as `createDOM` / `exportDOM` is invoked headlessly,
+* outside of `editor.update()` / `editor.read()`), or when the active
+* editor has no root element (e.g. headless mode with
+* {@link @lexical/headless!withDOM | withDOM}).
+*
+* Use this inside `createDOM`, `updateDOM`, and `exportDOM` instead of the
+* bare `document` global so the node works correctly when the editor lives
+* inside a Shadow DOM or a cross-origin `<iframe>`.
+*
+* Unlike most `$`-prefixed helpers, this does NOT require an ambient active
+* editor: it must remain callable from `createDOM` / `exportDOM`, which are
+* public methods that consumers may legitimately call while serializing
+* nodes headlessly. Throwing here would silently break every node whose DOM
+* methods were migrated off the bare `document` global.
+*/
+function $getDocument() {
+	const editor = internalGetActiveEditor();
+	return getRootOwnerDocument(editor !== null ? editor._rootElement : null);
+}
+/**
 * A subset of `Selection` covering the four boundary-point fields Lexical
 * reads plus `direction`. Designed so a `Selection` instance can be returned
 * where a `DOMSelectionBoundaryPoints` is expected (see {@link getDOMSelectionPoints}).
@@ -11934,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)`);
@@ -12109,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];
@@ -12133,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));
@@ -13452,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;
@@ -13495,6 +13834,21 @@ function $removeTextFromCaretRange(initialRange, sliceMode = "removeEmptySlices"
 			parent = parent.getParent();
 			element.remove(true);
 		}
+	} else if (focusCandidate) {
+		const focusBlock = $getBlockFromCaret(focusCandidate);
+		const focusBlockParent = focusBlock && focusBlock.getParent();
+		const topmostShadowRoot = focusBlock && focusBlock.getParents().findLast($isShadowRootNode);
+		if (focusBlock && focusBlockParent && !$isRootNode(focusBlockParent) && focusBlock.isEmpty() && seenStart.has(focusBlock.getKey()) && $getSlotNames(focusBlock).length === 0 && (!topmostShadowRoot || seenStart.has(topmostShadowRoot.getKey()))) {
+			focusBlock.remove(true);
+			let parent = focusBlockParent;
+			while (parent && !$isRootNode(parent) && parent.isEmpty()) {
+				const grandparent = parent.getParent();
+				if (grandparent && $isRootNode(grandparent) && grandparent.getChildrenSize() <= 1) break;
+				const element = parent;
+				parent = grandparent;
+				element.remove(true);
+			}
+		}
 	}
 	const bestCandidate = [
 		anchorCandidate,
@@ -13505,6 +13859,16 @@ function $removeTextFromCaretRange(initialRange, sliceMode = "removeEmptySlices"
 	if (bestCandidate) return $getCollapsedCaretRange($getCaretInDirection($normalizeCaret(bestCandidate), initialRange.direction));
 	formatDevErrorMessage(`$removeTextFromCaretRange: selection was lost, could not find a new anchor given candidates with keys: ${JSON.stringify(anchorCandidates.map((n) => n.origin.__key))}`);
 }
+function $getBlockFromCaret(caret) {
+	if ($isChildCaret(caret)) {
+		const origin = caret.origin;
+		if (INTERNAL_$isBlock(origin)) return origin;
+	} else {
+		const parent = caret.getParentAtCaret();
+		if (parent && INTERNAL_$isBlock(parent)) return parent;
+	}
+	return null;
+}
 /**
 * Determine if the two caret origins are in distinct blocks that
 * should be merged.
@@ -13952,5 +14316,55 @@ function mergeRegister(...func) {
 		func.length = 0;
 	};
 }
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* A map of event type to listener for a given {@link EventTarget}. Each
+* listener's event argument is inferred from the event type, e.g. for an
+* `HTMLElement` the `'keydown'` listener receives a `KeyboardEvent`.
+*/
+/**
+* Add several event listeners to a single `target` and return one function
+* that removes all of them.
+*
+* This is the batch form of {@link registerEventListener}: it takes a
+* `{type: listener}` object (strongly typed per event type) and shares one
+* `options` value across every listener. The returned dispose function removes
+* the listeners in reverse registration order (via {@link mergeRegister}).
+*
+* Because `options` is shared, register listeners that need a different
+* `options` value (e.g. a different `capture` flag) with a separate call and
+* combine the results with `mergeRegister`.
+*
+* @example
+* ```ts
+* // All five listeners share {capture: true}
+* return registerEventListeners(
+*   window,
+*   {
+*     beforeinput: report,
+*     cut: report,
+*     keydown: report,
+*     paste: report,
+*     selectionchange: report,
+*   },
+*   {capture: true},
+* );
+* ```
+*
+* @param target - The {@link EventTarget} to subscribe to
+* @param listeners - A map of event type to listener
+* @param options - Options forwarded to `add`/`removeEventListener` for every
+*   listener
+* @returns A function that removes every listener when called
+*/
+function registerEventListeners(target, listeners, options) {
+	return mergeRegister(...Object.entries(listeners).map(([type, listener]) => registerEventListener(target, type, listener, options)));
+}
 //#endregion
-export { $addUpdateTag, $applyNodeReplacement, $assumeActiveEditor, $caretFromPoint, $caretRangeFromSelection, $cloneWithProperties, $cloneWithPropertiesEphemeral, $comparePointCaretNext, $copyNode, $create, $createChildrenArray, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createPoint, $createRangeSelection, $createRangeSelectionFromDom, $createTabNode, $createTextNode, $extendCaretToRange, $findMatchingParent, $fullReconcile, $generateNodesFromRawText, $getAdjacentChildCaret, $getAdjacentNode, $getAdjacentSiblingOrParentSiblingCaret, $getCaretInDirection, $getCaretRange, $getCaretRangeInDirection, $getCharacterOffsets, $getChildCaret, $getChildCaretAtIndex, $getChildCaretOrSelf, $getCollapsedCaretRange, $getCommonAncestor, $getCommonAncestorResultBranchOrder, $getDOMSlot, $getDOMTextNode, $getEditor, $getEditorDOMRenderConfig, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $getNodeByKey, $getNodeByKeyOrThrow, $getNodeFromDOMNode, $getPreviousSelection, $getRoot, $getSelection, $getSiblingCaret, $getSlot, $getSlotFrame, $getSlotHost, $getSlotNameWithinHost, $getSlotNames, $getState, $getStateChange, $getTextContent, $getTextNodeOffset, $getTextPointCaret, $getTextPointCaretSlice, $getWritableNodeState, $hasAncestor, $hasUpdateTag, $insertNodeToNearestRootAtCaret, $insertNodes, $isBlockElementNode, $isChildCaret, $isDecoratorNode, $isEditorState, $isElementDOMSlot, $isElementNode, $isExtendableTextPointCaret, $isInlineElementOrDecoratorNode, $isLeafNode, $isLexicalNode, $isLineBreakNode, $isNodeCaret, $isNodeSelection, $isParagraphNode, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isSelectionCapturedInDecoratorInput, $isSiblingCaret, $isSlotChild, $isSlotHost, $isTabNode, $isTextNode, $isTextPointCaret, $isTextPointCaretSlice, $isTokenOrSegmented, $isTokenOrTab, $markSlotEditable, $nodesOfType, $normalizeCaret, $normalizeSelection as $normalizeSelection__EXPERIMENTAL, $onUpdate, $parseSerializedNode, $removeFromParent, $removeSlot, $removeTextFromCaretRange, $rewindSiblingCaret, $selectAll, $setCompositionKey, $setDirectionFromDOM, $setFormatFromDOM, $setPointFromCaret, $setSelection, $setSelectionFromCaretRange, $setSlot, $setState, $splitAtPointCaretNext, $splitNode, $updateDOMSelection, $updateRangeSelectionFromCaretRange, ArtificialNode__DO_NOT_USE, BEFORE_INPUT_COMMAND, BLUR_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, CAN_USE_BEFORE_INPUT, CAN_USE_DOM, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CLICK_COMMAND, COLLABORATION_TAG, COMMAND_PRIORITY_BEFORE_CRITICAL, COMMAND_PRIORITY_BEFORE_EDITOR, COMMAND_PRIORITY_BEFORE_HIGH, COMMAND_PRIORITY_BEFORE_LOW, COMMAND_PRIORITY_BEFORE_NORMAL, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, COMPOSITION_END_COMMAND, COMPOSITION_END_TAG, COMPOSITION_START_COMMAND, COMPOSITION_START_TAG, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, CUT_COMMAND, CUT_TAG, DEFAULT_EDITOR_DOM_CONFIG, DELETE_CHARACTER_COMMAND, DELETE_LINE_COMMAND, DELETE_WORD_COMMAND, DRAGEND_COMMAND, DRAGOVER_COMMAND, DRAGSTART_COMMAND, DROP_COMMAND, DecoratorNode, ElementNode, FOCUS_COMMAND, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INPUT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, INTERNAL_$isBlock, IS_ALL_FORMATTING, IS_ANDROID, IS_ANDROID_CHROME, IS_APPLE, IS_APPLE_WEBKIT, IS_BOLD, IS_CHROME, IS_CODE, IS_FIREFOX, IS_HIGHLIGHT, IS_IOS, IS_ITALIC, IS_SAFARI, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_MODIFIER_COMMAND, KEY_SPACE_COMMAND, KEY_TAB_COMMAND, LineBreakNode, MOVE_TO_END, MOVE_TO_START, NODE_STATE_DIRECT, NODE_STATE_KEY, NODE_STATE_LATEST, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, PASTE_TAG, ParagraphNode, REDO_COMMAND, REMOVE_TEXT_COMMAND, RootNode, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, SELECT_ALL_COMMAND, SKIP_COLLAB_TAG, SKIP_DOM_SELECTION_TAG, SKIP_SCROLL_INTO_VIEW_TAG, SKIP_SELECTION_FOCUS_TAG, TEXT_TYPE_TO_FORMAT, TabNode, TextNode, UNDO_COMMAND, addClassNamesToElement, buildImportMap, configExtension, createCommand, createEditor, createSharedNodeState, createState, declarePeerDependency, defineExtension, findAllLexicalElementsDeep, flipDirection, getActiveElement, getActiveElementDeep, getComposedEventTarget, getComposedStaticRange, getDOMOwnerDocument, getDOMSelection, getDOMSelectionFromTarget, getDOMSelectionPoints, getDOMSelectionRange, getDOMSelectionRangeAndPoints, getDOMShadowRoots, getDOMTextNode, getDeclaredSlots, getEditorPropertyFromDOMNode, getNearestEditorFromDOMNode, getParentElement, getRegisteredNode, getRegisteredNodeOrThrow, getRegisteredSubtypeMap, getRootOwnerDocument, getStaticNodeConfig, getStyleObjectFromCSS, getTextDirection, getTransformSetFromKlass, isBlockDomNode, isCurrentlyReadOnlyMode, isDOMCapturingSelection, isDOMDocumentNode, isDOMNode, isDOMShadowRoot, isDOMTextNode, isDOMUnmanaged, isDocumentFragment, isExactShortcutMatch, isHTMLAnchorElement, isHTMLElement, isHTMLTableCellElement, isHTMLTableRowElement, isInlineDomNode, isLastChildInBlockNode, isLexicalEditor, isModifierMatch, isOnlyChildInBlockNode, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, iterStaticNodeConfigChain, makeStepwiseIterator, mergeRegister, mountSlotContainer, normalizeClassNames, removeClassNamesFromElement, removeFromParent, resetRandomKey, safeCast, setDOMStyleFromCSS, setDOMStyleObject, setDOMUnmanaged, setNodeIndentFromDOM, shallowMergeConfig, stopLexicalPropagation, toggleTextFormatType, tokenizeRawText, unmountSlotContainer };
+export { $addUpdateTag, $applyNodeReplacement, $assumeActiveEditor, $caretFromPoint, $caretRangeFromSelection, $cloneWithProperties, $cloneWithPropertiesEphemeral, $comparePointCaretNext, $copyNode, $create, $createChildrenArray, $createLineBreakNode, $createNodeSelection, $createParagraphNode, $createPoint, $createRangeSelection, $createRangeSelectionFromDom, $createTabNode, $createTextNode, $extendCaretToRange, $findMatchingParent, $formatText, $fullReconcile, $generateNodesFromRawText, $getAdjacentChildCaret, $getAdjacentNode, $getAdjacentSiblingOrParentSiblingCaret, $getCaretInDirection, $getCaretRange, $getCaretRangeInDirection, $getCharacterOffsets, $getChildCaret, $getChildCaretAtIndex, $getChildCaretOrSelf, $getCollapsedCaretRange, $getCommonAncestor, $getCommonAncestorResultBranchOrder, $getDOMSlot, $getDOMTextNode, $getDocument, $getEditor, $getEditorDOMRenderConfig, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $getNodeByKey, $getNodeByKeyOrThrow, $getNodeFromDOMNode, $getPreviousSelection, $getRoot, $getSelection, $getSiblingCaret, $getSlot, $getSlotFrame, $getSlotHost, $getSlotNameWithinHost, $getSlotNames, $getState, $getStateChange, $getTextContent, $getTextNodeOffset, $getTextPointCaret, $getTextPointCaretSlice, $getWritableNodeState, $hasAncestor, $hasUpdateTag, $insertNodeToNearestRootAtCaret, $insertNodes, $isBlockElementNode, $isChildCaret, $isDecoratorNode, $isEditorState, $isElementDOMSlot, $isElementNode, $isExtendableTextPointCaret, $isInlineElementOrDecoratorNode, $isInlineFormattable, $isLeafNode, $isLexicalNode, $isLineBreakNode, $isNodeCaret, $isNodeSelection, $isParagraphNode, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isSelectionCapturedInDecoratorInput, $isShadowRootNode, $isSiblingCaret, $isSlotChild, $isSlotHost, $isTabNode, $isTextNode, $isTextPointCaret, $isTextPointCaretSlice, $isTokenOrSegmented, $isTokenOrTab, $markSlotEditable, $needsBlockCursorBeside, $nodesOfType, $normalizeCaret, $normalizeSelection as $normalizeSelection__EXPERIMENTAL, $onUpdate, $parseSerializedNode, $removeFromParent, $removeSlot, $removeTextFromCaretRange, $rewindSiblingCaret, $selectAll, $setCompositionKey, $setDirectionFromDOM, $setFormatFromDOM, $setPointFromCaret, $setSelection, $setSelectionFromCaretRange, $setSlot, $setState, $setTextFormat, $splitAtPointCaretNext, $splitNode, $updateDOMSelection, $updateRangeSelectionFromCaretRange, ArtificialNode__DO_NOT_USE, BEFORE_INPUT_COMMAND, BLUR_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, CAN_USE_BEFORE_INPUT, CAN_USE_DOM, CLEAR_EDITOR_COMMAND, CLEAR_HISTORY_COMMAND, CLICK_COMMAND, COLLABORATION_TAG, COMMAND_PRIORITY_BEFORE_CRITICAL, COMMAND_PRIORITY_BEFORE_EDITOR, COMMAND_PRIORITY_BEFORE_HIGH, COMMAND_PRIORITY_BEFORE_LOW, COMMAND_PRIORITY_BEFORE_NORMAL, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, COMPOSITION_END_COMMAND, COMPOSITION_END_TAG, COMPOSITION_START_COMMAND, COMPOSITION_START_TAG, CONTROLLED_TEXT_INSERTION_COMMAND, COPY_COMMAND, CUT_COMMAND, CUT_TAG, DEFAULT_EDITOR_DOM_CONFIG, DELETE_CHARACTER_COMMAND, DELETE_LINE_COMMAND, DELETE_WORD_COMMAND, DRAGEND_COMMAND, DRAGOVER_COMMAND, DRAGSTART_COMMAND, DROP_COMMAND, DecoratorNode, ElementNode, FOCUS_COMMAND, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, HISTORIC_TAG, HISTORY_MERGE_TAG, HISTORY_PUSH_TAG, INDENT_CONTENT_COMMAND, INPUT_COMMAND, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, INSERT_TAB_COMMAND, INTERNAL_$isBlock, IS_ALL_FORMATTING, IS_ANDROID, IS_ANDROID_CHROME, IS_APPLE, IS_APPLE_WEBKIT, IS_BOLD, IS_CHROME, IS_CODE, IS_FIREFOX, IS_HIGHLIGHT, IS_IOS, IS_ITALIC, IS_SAFARI, IS_STRIKETHROUGH, IS_SUBSCRIPT, IS_SUPERSCRIPT, IS_UNDERLINE, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, KEY_DOWN_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND, KEY_MODIFIER_COMMAND, KEY_SPACE_COMMAND, KEY_TAB_COMMAND, LineBreakNode, MOVE_TO_END, MOVE_TO_START, NODE_STATE_DIRECT, NODE_STATE_KEY, NODE_STATE_LATEST, OUTDENT_CONTENT_COMMAND, PASTE_COMMAND, PASTE_TAG, ParagraphNode, REDO_COMMAND, REMOVE_TEXT_COMMAND, RootNode, SELECTION_CHANGE_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, SELECT_ALL_COMMAND, SET_TEXT_FORMAT_COMMAND, SKIP_COLLAB_TAG, SKIP_DOM_SELECTION_TAG, SKIP_SCROLL_INTO_VIEW_TAG, SKIP_SELECTION_FOCUS_TAG, TEXT_TYPE_TO_FORMAT, TabNode, TextNode, UNDO_COMMAND, addClassNamesToElement, buildImportMap, configExtension, createCommand, createEditor, createRefCountedRegistry, createSharedNodeState, createState, declarePeerDependency, defineExtension, findAllLexicalElementsDeep, flipDirection, getActiveElement, getActiveElementDeep, getComposedEventTarget, getComposedStaticRange, getDOMOwnerDocument, getDOMSelection, getDOMSelectionFromTarget, getDOMSelectionPoints, getDOMSelectionRange, getDOMSelectionRangeAndPoints, getDOMShadowRoots, getDOMTextNode, getDeclaredSlots, getEditorPropertyFromDOMNode, getNearestEditorFromDOMNode, getParentElement, getRegisteredNode, getRegisteredNodeOrThrow, getRegisteredSubtypeMap, getRootOwnerDocument, getStaticNodeConfig, getStyleObjectFromCSS, getTextDirection, getTransformSetFromKlass, isBlockDomNode, isCurrentlyReadOnlyMode, isDOMCapturingSelection, isDOMDocumentNode, isDOMNode, isDOMShadowRoot, isDOMTextNode, isDOMUnmanaged, isDocumentFragment, isExactShortcutMatch, isHTMLAnchorElement, isHTMLElement, isHTMLTableCellElement, isHTMLTableRowElement, isInlineDomNode, isLastChildInBlockNode, isLexicalEditor, isModifierMatch, isOnlyChildInBlockNode, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, iterStaticNodeConfigChain, makeStepwiseIterator, mergeRegister, mountSlotContainer, normalizeClassNames, registerEventListener, registerEventListeners, removeClassNamesFromElement, removeFromParent, resetRandomKey, safeCast, setDOMStyleFromCSS, setDOMStyleObject, setDOMUnmanaged, setNodeIndentFromDOM, shallowMergeConfig, stopLexicalPropagation, toggleTextFormatType, tokenizeRawText, unmountSlotContainer };