@mx-space/cli 0.13.1 → 0.13.2

package/dist/{Lexical.dev-By5dOKBN.mjs → Lexical.dev-BsbWMhb3.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/lexical@0.45.0/node_modules/lexical/dist/Lexical.dev.mjs
+//#region ../../node_modules/.pnpm/lexical@0.46.0_typescript@6.0.3/node_modules/lexical/dist/Lexical.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -135,6 +135,14 @@ function $getActiveBlockCursorElement() {
 	return $getEditor()._blockCursorElement;
 }
 /**
+* A slot value renders slots-first into its own `[data-lexical-slot]`
+* container, prepended ahead of the host's linked-list children. The leading
+* boundary skips these so they are never counted as managed children.
+*/
+function isSlotContainerDOM(node) {
+	return node !== null && node.nodeType === 1 && node.hasAttribute("data-lexical-slot");
+}
+/**
 * Base class for DOM slots — a pointer to the content-bearing element of a
 * node's DOM, plus optional `before` / `after` boundaries marking where the
 * lexical-managed content sits inside that element.
@@ -315,9 +323,14 @@ var ElementDOMSlot = class ElementDOMSlot extends DOMSlot {
 	* a block cursor among their children, so the base slot stays editor-free.
 	*/
 	getFirstChildAnchor() {
-		const after = super.getFirstChildAnchor();
-		const firstChild = after ? after.nextSibling : this.element.firstChild;
-		return firstChild !== null && firstChild === $getActiveBlockCursorElement() ? firstChild : after;
+		let anchor = super.getFirstChildAnchor();
+		let node = anchor ? anchor.nextSibling : this.element.firstChild;
+		while (isSlotContainerDOM(node)) {
+			anchor = node;
+			node = node.nextSibling;
+		}
+		const firstChild = anchor ? anchor.nextSibling : this.element.firstChild;
+		return firstChild !== null && firstChild === $getActiveBlockCursorElement() ? firstChild : anchor;
 	}
 	/**
 	* @internal
@@ -356,10 +369,11 @@ var ElementDOMSlot = class ElementDOMSlot extends DOMSlot {
 		const element = this.element;
 		const before = this.before;
 		const br = document.createElement("br");
+		br.setAttribute("data-lexical-managed-linebreak", "true");
 		element.insertBefore(br, before);
 		if (webkitHack) {
 			const img = document.createElement("img");
-			img.setAttribute("data-lexical-linebreak", "true");
+			img.setAttribute("data-lexical-managed-linebreak", "true");
 			img.style.setProperty("display", "inline", "important");
 			img.style.setProperty("border", "0px", "important");
 			img.style.setProperty("margin", "0px", "important");
@@ -434,9 +448,9 @@ function indexPath(root, child) {
 */
 let envLexicalVersion;
 try {
-	envLexicalVersion = "0.45.0+dev.esm";
+	envLexicalVersion = "0.46.0+dev.esm";
 } catch (_unused) {}
-const LEXICAL_VERSION = envLexicalVersion ?? "0.45.0+source";
+const LEXICAL_VERSION = envLexicalVersion ?? "\"<unknown>+source\"";
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -681,15 +695,25 @@ function $garbageCollectDetachedDecorators(editor, pendingEditorState) {
 	}
 }
 function $garbageCollectDetachedDeepChildNodes(node, parentKey, prevNodeMap, nodeMap, nodeMapDelete, dirtyNodes) {
-	let child = node.getFirstChild();
-	while (child !== null) {
-		const childKey = child.__key;
-		if (child.__parent === parentKey) {
-			if ($isElementNode(child)) $garbageCollectDetachedDeepChildNodes(child, childKey, prevNodeMap, nodeMap, nodeMapDelete, dirtyNodes);
-			if (!prevNodeMap.has(childKey)) dirtyNodes.delete(childKey);
-			nodeMapDelete.push(childKey);
+	if ($isElementNode(node)) {
+		let child = node.getFirstChild();
+		while (child !== null) {
+			const childKey = child.__key;
+			if (child.__parent === parentKey) {
+				if ($isElementNode(child) || $isSlotHost(child) && child.__slots !== null) $garbageCollectDetachedDeepChildNodes(child, childKey, prevNodeMap, nodeMap, nodeMapDelete, dirtyNodes);
+				if (!prevNodeMap.has(childKey)) dirtyNodes.delete(childKey);
+				nodeMapDelete.push(childKey);
+			}
+			child = child.getNextSibling();
+		}
+	}
+	for (const slotKey of $isSlotHost(node) && node.__slots !== null ? node.__slots.values() : []) {
+		const slotNode = nodeMap.get(slotKey);
+		if (slotNode !== void 0 && $isSlotChild(slotNode) && slotNode.__slotHost === parentKey) {
+			if ($isElementNode(slotNode) || $isSlotHost(slotNode) && slotNode.__slots !== null) $garbageCollectDetachedDeepChildNodes(slotNode, slotKey, prevNodeMap, nodeMap, nodeMapDelete, dirtyNodes);
+			if (!prevNodeMap.has(slotKey)) dirtyNodes.delete(slotKey);
+			nodeMapDelete.push(slotKey);
 		}
-		child = child.getNextSibling();
 	}
 }
 function $garbageCollectDetachedNodes(prevEditorState, editorState, dirtyLeaves, dirtyElements) {
@@ -706,14 +730,18 @@ function $garbageCollectDetachedNodes(prevEditorState, editorState, dirtyLeaves,
 			}
 		}
 	}
-	for (const nodeKey of nodeMapDelete) nodeMap.delete(nodeKey);
 	for (const nodeKey of dirtyLeaves) {
 		const node = nodeMap.get(nodeKey);
 		if (node !== void 0 && !node.isAttached()) {
+			if ($isSlotHost(node) && node.__slots !== null) $garbageCollectDetachedDeepChildNodes(node, nodeKey, prevNodeMap, nodeMap, nodeMapDelete, dirtyLeaves);
 			if (!prevNodeMap.has(nodeKey)) dirtyLeaves.delete(nodeKey);
-			nodeMap.delete(nodeKey);
+			nodeMapDelete.push(nodeKey);
 		}
 	}
+	for (const nodeKey of nodeMapDelete) nodeMap.delete(nodeKey);
+	const editor = getActiveEditor();
+	const compositionKey = editor._compositionKey;
+	if (compositionKey !== null && !nodeMap.has(compositionKey)) editor._compositionKey = null;
 }
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -740,18 +768,19 @@ function isManagedLineBreak(dom, target, editor) {
 	return lexicalLineBreak && (dom === lexicalLineBreak || isBR && dom.previousSibling === lexicalLineBreak) || isBR && getNodeKeyFromDOMNode(dom, editor) !== void 0;
 }
 function getLastSelection(editor) {
-	return editor.getEditorState().read(() => {
+	return editor.read("latest", () => {
 		const selection = $getSelection();
 		return selection !== null ? selection.clone() : null;
 	});
 }
 function $handleTextMutation(target, node, editor) {
 	const domSelection = getDOMSelection(getWindow(editor));
+	const domSelectionPoints = domSelection && getDOMSelectionPoints(domSelection, editor._rootElement);
 	let anchorOffset = null;
 	let focusOffset = null;
-	if (domSelection !== null && domSelection.anchorNode === target) {
-		anchorOffset = domSelection.anchorOffset;
-		focusOffset = domSelection.focusOffset;
+	if (domSelectionPoints !== null && domSelectionPoints.anchorNode === target) {
+		anchorOffset = domSelectionPoints.anchorOffset;
+		focusOffset = domSelectionPoints.focusOffset;
 	}
 	const text = target.nodeValue;
 	if (text !== null) $updateTextNodeFromDOMContent(node, text, anchorOffset, focusOffset, false);
@@ -763,13 +792,13 @@ function shouldUpdateTextNodeFromMutation(selection, targetDOM, targetNode) {
 	}
 	return isDOMTextNode(targetDOM) && targetNode.isAttached();
 }
-function $getNearestManagedNodePairFromDOMNode(startingDOM, editor, editorState, rootElement) {
+function $getNearestManagedNodePairFromDOMNode(startingDOM, editor, editorState) {
 	for (let dom = startingDOM; dom && !isDOMUnmanaged(dom); dom = getParentElement(dom)) {
 		const key = getNodeKeyFromDOMNode(dom, editor);
 		if (key !== void 0) {
 			const node = $getNodeByKey(key, editorState);
 			if (node) return $isDecoratorNode(node) || !isHTMLElement(dom) ? void 0 : [dom, node];
-		} else if (dom === rootElement) return [rootElement, internalGetRoot(editorState)];
+		}
 	}
 }
 function flushMutations(editor, mutations, observer) {
@@ -779,7 +808,6 @@ function flushMutations(editor, mutations, observer) {
 		updateEditorSync(editor, () => {
 			const selection = $getSelection() || getLastSelection(editor);
 			const badDOMTargets = /* @__PURE__ */ new Map();
-			const rootElement = editor.getRootElement();
 			const currentEditorState = editor._editorState;
 			const blockCursorElement = editor._blockCursorElement;
 			let shouldRevertSelection = false;
@@ -788,7 +816,7 @@ function flushMutations(editor, mutations, observer) {
 				const mutation = mutations[i];
 				const type = mutation.type;
 				const targetDOM = mutation.target;
-				const pair = $getNearestManagedNodePairFromDOMNode(targetDOM, editor, currentEditorState, rootElement);
+				const pair = $getNearestManagedNodePairFromDOMNode(targetDOM, editor, currentEditorState);
 				if (!pair) continue;
 				const [nodeDOM, targetNode] = pair;
 				if (type === "characterData") {
@@ -800,7 +828,7 @@ function flushMutations(editor, mutations, observer) {
 						const addedDOM = addedDOMs[s];
 						const node = $getNodeFromDOMNode(addedDOM);
 						const parentDOM = addedDOM.parentNode;
-						if (parentDOM != null && addedDOM !== blockCursorElement && node === null && !isManagedLineBreak(addedDOM, parentDOM, editor) && !isDOMUnmanaged(addedDOM)) {
+						if (parentDOM != null && addedDOM !== blockCursorElement && node === null && !isManagedLineBreak(addedDOM, parentDOM, editor) && !(editor._slotsUsed && isHTMLElement(addedDOM) && addedDOM.hasAttribute("data-lexical-slot")) && !isDOMUnmanaged(addedDOM)) {
 							if (IS_FIREFOX) {
 								const possibleText = (isHTMLElement(addedDOM) ? addedDOM.innerText : null) || addedDOM.nodeValue;
 								if (possibleText) possibleTextForFirefoxPaste += possibleText;
@@ -858,6 +886,17 @@ function initMutationObserver(editor) {
 	});
 }
 /**
+* Read the state directly from the given object without `node.getLatest()`.
+* Safe to use outside of editor state context or to read a previous version,
+* equivalent to reading the property directly.
+*/
+const NODE_STATE_DIRECT = "direct";
+/**
+* Use `node.getLatest()` before reading the state, per the lexical convention
+* of only working with the latest version of a node.
+*/
+const NODE_STATE_LATEST = "latest";
+/**
 * Get the value type (V) from a StateConfig
 */
 /**
@@ -996,21 +1035,21 @@ function createState(key, valueConfig) {
 * state on the given node, and will return `stateConfig.defaultValue` if the
 * state has never been set on this node.
 *
-* The `version` parameter is optional and should generally be `'latest'`,
+* The `version` parameter is optional and should generally be {@link NODE_STATE_LATEST},
 * consistent with the behavior of other node methods and functions,
 * but for certain use cases such as `updateDOM` you may have a need to
-* use `'direct'` to read the state from a previous version of the node.
+* use {@link NODE_STATE_DIRECT} to read the state from a previous version of the node.
 *
-* For very advanced use cases, you can expect that 'direct' does not
+* For very advanced use cases, you can expect that {@link NODE_STATE_DIRECT} does not
 * require an editor state, just like directly accessing other properties
 * of a node without an accessor (e.g. `textNode.__text`).
 *
 * @param node Any LexicalNode
 * @param stateConfig The configuration of the state to read
-* @param version The default value 'latest' will read the latest version of the node state, 'direct' will read the version that is stored on this LexicalNode which not reflect the version used in the current editor state
+* @param version The default value {@link NODE_STATE_LATEST} will read the latest version of the node state, {@link NODE_STATE_DIRECT} will read the version that is stored on this LexicalNode which not reflect the version used in the current editor state
 * @returns The current value from the state, or the default value provided by the configuration.
 */
-function $getState(node, stateConfig, version = "latest") {
+function $getState(node, stateConfig, version = NODE_STATE_LATEST) {
 	const state = (version === "latest" ? node.getLatest() : node).__state;
 	if (state) {
 		$checkCollision(node, stateConfig, state);
@@ -1020,11 +1059,11 @@ function $getState(node, stateConfig, version = "latest") {
 }
 /**
 * Given two versions of a node and a stateConfig, compare their state values
-* using `$getState(nodeVersion, stateConfig, 'direct')`.
+* using `$getState(nodeVersion, stateConfig, NODE_STATE_DIRECT)`.
 * If the values are equal according to `stateConfig.isEqual`, return `null`,
 * otherwise return `[value, prevValue]`.
 *
-* This is useful for implementing updateDOM. Note that the `'direct'`
+* This is useful for implementing updateDOM. Note that the `NODE_STATE_DIRECT`
 * version argument is used for both nodes.
 *
 * @param node Any LexicalNode
@@ -1033,8 +1072,8 @@ function $getState(node, stateConfig, version = "latest") {
 * @returns `[value, prevValue]` if changed, otherwise `null`
 */
 function $getStateChange(node, prevNode, stateConfig) {
-	const value = $getState(node, stateConfig, "direct");
-	const prevValue = $getState(prevNode, stateConfig, "direct");
+	const value = $getState(node, stateConfig, NODE_STATE_DIRECT);
+	const prevValue = $getState(prevNode, stateConfig, NODE_STATE_DIRECT);
 	return stateConfig.isEqual(value, prevValue) ? null : [value, prevValue];
 }
 /**
@@ -1100,16 +1139,13 @@ function $checkCollision(node, stateConfig, state) {
 function createSharedNodeState(nodeConfig) {
 	const sharedConfigMap = /* @__PURE__ */ new Map();
 	const flatKeys = /* @__PURE__ */ new Set();
-	for (let klass = typeof nodeConfig === "function" ? nodeConfig : nodeConfig.replace; klass.prototype && klass.prototype.getType !== void 0; klass = Object.getPrototypeOf(klass)) {
-		const { ownNodeConfig } = getStaticNodeConfig(klass);
-		if (ownNodeConfig && ownNodeConfig.stateConfigs) for (const requiredStateConfig of ownNodeConfig.stateConfigs) {
-			let stateConfig;
-			if ("stateConfig" in requiredStateConfig) {
-				stateConfig = requiredStateConfig.stateConfig;
-				if (requiredStateConfig.flat) flatKeys.add(stateConfig.key);
-			} else stateConfig = requiredStateConfig;
-			sharedConfigMap.set(stateConfig.key, stateConfig);
-		}
+	for (const { ownNodeConfig } of iterStaticNodeConfigChain(typeof nodeConfig === "function" ? nodeConfig : nodeConfig.replace)) if (ownNodeConfig && ownNodeConfig.stateConfigs) for (const requiredStateConfig of ownNodeConfig.stateConfigs) {
+		let stateConfig;
+		if ("stateConfig" in requiredStateConfig) {
+			stateConfig = requiredStateConfig.stateConfig;
+			if (requiredStateConfig.flat) flatKeys.add(stateConfig.key);
+		} else stateConfig = requiredStateConfig;
+		sharedConfigMap.set(stateConfig.key, stateConfig);
 	}
 	return {
 		flatKeys,
@@ -1117,6 +1153,19 @@ function createSharedNodeState(nodeConfig) {
 	};
 }
 /**
+* Keys that must never be written into an {@link UnknownStateRecord} from
+* serialized (potentially untrusted) input. Writing a `__proto__` entry would
+* re-parent the record's prototype, and because {@link NodeState.getValue}
+* resolves keys with the `in` operator (which walks the prototype chain) an
+* attacker could otherwise inject arbitrary state values via a crafted
+* `__proto__`. These are never produced by {@link createState}.
+*/
+const UNSAFE_STATE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
 * @internal
 *
 * A Map of string keys to state configurations to be shared across nodes
@@ -1299,6 +1348,7 @@ var NodeState = class NodeState {
 	* @param v The unknown value from an UnknownStateRecord
 	*/
 	updateFromUnknown(k, v) {
+		if (UNSAFE_STATE_KEYS.has(k)) return;
 		const stateConfig = this.sharedNodeState.sharedConfigMap.get(k);
 		if (stateConfig) this.updateFromKnown(stateConfig, stateConfig.parse(v));
 		else {
@@ -1418,6 +1468,7 @@ function coerceToJSON(v) {
 function parseAndPruneNextUnknownState(sharedConfigMap, nextKnownState, unknownState) {
 	let nextUnknownState = void 0;
 	if (unknownState) for (const [k, v] of Object.entries(unknownState)) {
+		if (UNSAFE_STATE_KEYS.has(k)) continue;
 		const stateConfig = sharedConfigMap.get(k);
 		if (stateConfig) {
 			if (!nextKnownState.has(stateConfig)) nextKnownState.set(stateConfig, stateConfig.parse(v));
@@ -1681,7 +1732,14 @@ function $destroyNode(key, parentDOM) {
 		const children = $createChildrenArray(node, activePrevNodeMap);
 		$destroyChildren(children, 0, children.length - 1, null);
 	}
-	if (node !== void 0) setMutatedNode(mutatedNodes, activeEditorNodes, activeMutationListeners, node, "destroyed");
+	if (node !== void 0) {
+		for (const slotKey of $readSlots(node).values()) {
+			const container = $slotContainerForKey(slotKey);
+			$destroyNode(slotKey, null);
+			if (container !== null) container.remove();
+		}
+		setMutatedNode(mutatedNodes, activeEditorNodes, activeMutationListeners, node, "destroyed");
+	}
 }
 function $destroyChildren(children, _startIndex, endIndex, dom) {
 	for (let startIndex = _startIndex; startIndex <= endIndex; ++startIndex) {
@@ -1716,7 +1774,8 @@ function $getReconciledDirection(node) {
 	const direction = node.__dir;
 	if (direction !== null) return direction;
 	if ($isRootNode(node)) return null;
-	const parent = node.getParentOrThrow();
+	const parent = node.getParent();
+	if (parent === null) return "auto";
 	if (!$isRootOrShadowRoot(parent) || parent.__dir !== null) return null;
 	return "auto";
 }
@@ -1725,34 +1784,145 @@ function $setElementDirection(dom, node) {
 	if (direction !== null) dom.dir = direction;
 	else dom.removeAttribute("dir");
 }
+function createSlotDOM(name) {
+	const container = document.createElement("div");
+	container.setAttribute("data-lexical-slot", name);
+	container.style.display = "none";
+	return container;
+}
+function $applySlotEditable(hostDom, decoratorHost, container) {
+	if (decoratorHost || hostDom.contentEditable === "false") $markSlotEditable(container, activeEditor$1);
+	else container.removeAttribute("contenteditable");
+}
+function $mountSlotChildren(node, hostDom, slots) {
+	const previousSubTreeTextContent = subTreeTextContent;
+	const outerSaved = $beginCaptureGuard();
+	subTreeTextContent = "";
+	let totalText = "";
+	const decoratorHost = $isDecoratorNode(node);
+	for (const [name, slotKey] of slots) {
+		const container = createSlotDOM(name);
+		$applySlotEditable(hostDom, decoratorHost, container);
+		hostDom.appendChild(container);
+		subTreeTextContent = "";
+		const saved = $beginCaptureGuard();
+		$createNode(slotKey, $getDOMSlot(node, container, activeEditor$1));
+		$endCaptureGuard(saved);
+		$applySlotTarget(node, name, hostDom, container);
+		totalText += subTreeTextContent;
+	}
+	$endCaptureGuard(outerSaved);
+	subTreeTextContent = previousSubTreeTextContent;
+	return totalText;
+}
+function $readSlots(node) {
+	return $isSlotHost(node) && node.__slots !== null ? node.__slots : EMPTY_SLOTS;
+}
+function $applySlotTarget(node, name, hostDom, container) {
+	const target = activeEditorDOMRenderConfig.$getSlotTargetElement(node, name, hostDom, activeEditor$1);
+	if (target !== null) {
+		if (container.parentElement !== target) target.appendChild(container);
+		container.style.display = "";
+	}
+}
+function $slotContainerForKey(slotKey) {
+	const slotDom = activePrevKeyToDOMMap.get(slotKey);
+	return slotDom !== void 0 ? slotDom.parentElement : null;
+}
+function $reconcileSlotChildren(prevNode, nextNode, hostDom) {
+	const prevSlots = $readSlots(prevNode);
+	const nextSlots = $readSlots(nextNode);
+	for (const [name, prevSlotKey] of prevSlots) if (!nextSlots.has(name)) {
+		const staleContainer = $slotContainerForKey(prevSlotKey);
+		$destroyNode(prevSlotKey, null);
+		if (staleContainer !== null) staleContainer.remove();
+	}
+	const previousSubTreeTextContent = subTreeTextContent;
+	const outerSaved = $beginCaptureGuard();
+	let totalText = "";
+	let prevContainer = null;
+	const decoratorHost = $isDecoratorNode(nextNode);
+	for (const [name, nextSlotKey] of nextSlots) {
+		const prevSlotKey = prevSlots.get(name);
+		let container = prevSlotKey !== void 0 ? $slotContainerForKey(prevSlotKey) : null;
+		subTreeTextContent = "";
+		const saved = $beginCaptureGuard();
+		if (container === null) {
+			container = createSlotDOM(name);
+			let firstNonSlot = null;
+			for (const child of hostDom.children) if (!child.hasAttribute("data-lexical-slot")) {
+				firstNonSlot = child;
+				break;
+			}
+			hostDom.insertBefore(container, firstNonSlot);
+			$createNode(nextSlotKey, $getDOMSlot(nextNode, container, activeEditor$1));
+		} else if (prevSlotKey === nextSlotKey) $reconcileNode(nextSlotKey, container);
+		else {
+			if (prevSlotKey !== void 0) $destroyNode(prevSlotKey, container);
+			$createNode(nextSlotKey, $getDOMSlot(nextNode, container, activeEditor$1));
+		}
+		$endCaptureGuard(saved);
+		$applySlotEditable(hostDom, decoratorHost, container);
+		$applySlotTarget(nextNode, name, hostDom, container);
+		totalText += subTreeTextContent;
+		if (container.parentElement === hostDom) {
+			const anchor = prevContainer === null ? hostDom.firstChild : prevContainer.nextSibling;
+			if (anchor !== container) hostDom.insertBefore(container, anchor);
+			prevContainer = container;
+		}
+	}
+	$endCaptureGuard(outerSaved);
+	subTreeTextContent = previousSubTreeTextContent;
+	return totalText;
+}
 function $createNode(key, slot) {
 	const node = activeNextNodeMap.get(key);
 	if (node === void 0) formatDevErrorMessage(`createNode: node does not exist in nodeMap`);
 	if (slot !== null) {
 		const prevNode = activePrevNodeMap.get(key);
-		if (prevNode !== void 0 && prevNode.__parent !== node.__parent) {
+		if (prevNode !== void 0) {
 			const existingDOM = activePrevKeyToDOMMap.get(key);
 			if (existingDOM !== void 0) {
-				slot.insertChild(existingDOM);
-				return $reconcileNode(key, slot.element);
+				const prevSlotHost = $isSlotChild(prevNode) ? prevNode.__slotHost : null;
+				const nextSlotHost = $isSlotChild(node) ? node.__slotHost : null;
+				const modelMoved = prevNode.__parent !== node.__parent || prevSlotHost !== nextSlotHost;
+				const slotChildDomDetached = nextSlotHost !== null && existingDOM.parentElement !== slot.element;
+				if (modelMoved || slotChildDomDetached) {
+					slot.insertChild(existingDOM);
+					return $reconcileNode(key, slot.element);
+				}
 			}
 		}
 	}
 	const dom = activeEditorDOMRenderConfig.$createDOM(node, activeEditor$1);
 	storeDOMWithKey(key, dom, activeEditor$1);
 	if ($isTextNode(node)) dom.setAttribute("data-lexical-text", "true");
-	else if ($isDecoratorNode(node)) dom.setAttribute("data-lexical-decorator", "true");
+	else if ($isDecoratorNode(node)) {
+		dom.setAttribute("data-lexical-decorator", "true");
+		setDOMUnmanaged(dom, { captureSelection: true });
+	}
 	if ($isElementNode(node)) {
 		const indent = node.__indent;
 		const childrenSize = node.__size;
 		$setElementDirection(dom, node);
 		if (indent !== 0) setElementIndent(dom, indent);
+		const slots = $readSlots(node);
+		const slotTextContent = slots.size > 0 ? $mountSlotChildren(node, dom, slots) : "";
 		if (childrenSize === 0) {
-			dom.__lexicalTextContent = "";
+			dom.__lexicalTextContent = slotTextContent;
 			dom.__lexicalFirstTextKey = null;
+			subTreeTextContent += slotTextContent;
+			if (slots.size > 0) dom.__lexicalSlotTextLength = slotTextContent.length;
 		} else {
+			const outerBefore = subTreeTextContent;
 			const endIndex = childrenSize - 1;
 			$createChildren($createChildrenArray(node, activeNextNodeMap), node, 0, endIndex, $getDOMSlot(node, dom, activeEditor$1));
+			if (slotTextContent !== "") {
+				const childText = dom.__lexicalTextContent || "";
+				dom.__lexicalTextContent = slotTextContent + childText;
+				subTreeTextContent = outerBefore + slotTextContent + childText;
+			}
+			if (slots.size > 0) dom.__lexicalSlotTextLength = slotTextContent.length;
 		}
 		const format = node.__format;
 		if (format !== 0) setElementFormat(dom, format);
@@ -1763,6 +1933,8 @@ function $createNode(key, slot) {
 			const decorator = node.decorate(activeEditor$1, activeEditorConfig);
 			if (decorator !== null) reconcileDecorator(key, decorator);
 			dom.contentEditable = "false";
+			const slots = $readSlots(node);
+			if (slots.size > 0) $mountSlotChildren(node, dom, slots);
 		}
 		subTreeTextContent += text;
 	}
@@ -1801,21 +1973,21 @@ function $createChildren(children, element, _startIndex, endIndex, slot) {
 	subTreeTextContent = previousSubTreeTextContent + subTreeTextContent;
 	$endCaptureGuard(outerSaved);
 }
-function isLastChildLineBreakOrDecorator(element, nodeMap) {
+function $isLastChildLineBreakOrDecorator(element, nodeMap) {
 	if (element) {
 		const lastKey = element.__last;
 		if (lastKey) {
 			const node = nodeMap.get(lastKey);
 			if (node) return $isLineBreakNode(node) ? "line-break" : $isDecoratorNode(node) && node.isInline() ? "decorator" : null;
 		}
-		return "empty";
+		return $readSlots(element).size > 0 ? null : "empty";
 	}
 	return null;
 }
 function $reconcileElementTerminatingLineBreak(prevElement, nextElement, dom) {
 	const slot = $getDOMSlot(nextElement, dom, activeEditor$1);
 	const prevLineBreak = slot.element.__lexicalLastChildKind ?? null;
-	const nextLineBreak = isLastChildLineBreakOrDecorator(nextElement, activeNextNodeMap);
+	const nextLineBreak = $isLastChildLineBreakOrDecorator(nextElement, activeNextNodeMap);
 	if (prevLineBreak !== nextLineBreak) slot.setManagedLineBreak(nextLineBreak);
 }
 function reconcileTextFormat(element) {
@@ -1982,7 +2154,9 @@ function $tryReconcileSuffixWithSizeDelta(prevElement, nextElement, slot, cacheD
 		newSuffix += text;
 		if (i < k - 1 && $isElementNode(node) && !node.isInline()) newSuffix += DOUBLE_LINE_BREAK;
 	}
-	cacheDom.__lexicalTextContent = cachedParentText.slice(0, cachedParentText.length - oldSuffixLength) + newSuffix;
+	const slotLen = cacheDom.__lexicalSlotTextLength || 0;
+	const prevChildText = slotLen > 0 ? cachedParentText.slice(slotLen) : cachedParentText;
+	cacheDom.__lexicalTextContent = prevChildText.slice(0, prevChildText.length - oldSuffixLength) + newSuffix;
 	return true;
 }
 /**
@@ -2084,9 +2258,11 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 						cur = node.__next;
 						i++;
 					}
-					const newParentText = cachedParentText.slice(0, cachedParentText.length - oldSuffixLength) + newSuffix;
-					cacheDom.__lexicalTextContent = newParentText;
-					subTreeTextContent = previousSubTreeTextContent + newParentText;
+					const slotLen = cacheDom.__lexicalSlotTextLength || 0;
+					const prevChildText = slotLen > 0 ? cachedParentText.slice(slotLen) : cachedParentText;
+					const newChildText = prevChildText.slice(0, prevChildText.length - oldSuffixLength) + newSuffix;
+					cacheDom.__lexicalTextContent = newChildText;
+					subTreeTextContent = previousSubTreeTextContent + newChildText;
 					$resolveSuffixPathFormat(nextElement, cacheDom, dirtyChildren);
 					return;
 				}
@@ -2172,7 +2348,7 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 			if (nextChildrenSize !== 0) $createChildren(nextChildren, nextElement, 0, nextChildrenSize - 1, slot);
 		} else if (nextChildrenSize === 0) {
 			if (prevChildrenSize !== 0) {
-				const canUseFastPath = slot.after == null && slot.before == null && slot.element.__lexicalLineBreak == null;
+				const canUseFastPath = slot.after == null && slot.before == null && $readSlots(nextElement).size === 0 && slot.element.__lexicalLineBreak == null;
 				$destroyChildren(prevChildren, 0, prevChildrenSize - 1, canUseFastPath ? null : dom);
 				if (canUseFastPath) dom.textContent = "";
 			}
@@ -2213,9 +2389,17 @@ function $reconcileNode(key, parentDOM) {
 		if (treatAllNodesAsDirty || nextIndent !== prevNode.__indent) setElementIndent(dom, nextIndent);
 		const nextFormat = nextNode.__format;
 		if (treatAllNodesAsDirty || nextFormat !== prevNode.__format) setElementFormat(dom, nextFormat);
+		const slotTextContent = isDirty && ($readSlots(nextNode).size > 0 || $readSlots(prevNode).size > 0) ? $reconcileSlotChildren(prevNode, nextNode, dom) : "";
 		if (isDirty) {
+			const outerBefore = subTreeTextContent;
 			$reconcileChildrenWithDirection(prevNode, nextNode, dom);
 			if (!$isRootNode(nextNode) && !nextNode.isInline()) $reconcileElementTerminatingLineBreak(prevNode, nextNode, dom);
+			if (slotTextContent !== "") {
+				const childText = dom.__lexicalTextContent || "";
+				dom.__lexicalTextContent = slotTextContent + childText;
+				subTreeTextContent = outerBefore + slotTextContent + childText;
+				dom.__lexicalSlotTextLength = slotTextContent.length;
+			} else if ($readSlots(nextNode).size > 0 || $readSlots(prevNode).size > 0) dom.__lexicalSlotTextLength = 0;
 		} else {
 			const previousSubTreeTextContent = dom.__lexicalTextContent;
 			if (!(typeof previousSubTreeTextContent === "string")) formatDevErrorMessage(`reconcileNode: missing __lexicalTextContent on cloned non-dirty element of type ${prevNode.getType()}`);
@@ -2233,6 +2417,7 @@ function $reconcileNode(key, parentDOM) {
 		if ($isDecoratorNode(nextNode)) {
 			const decorator = nextNode.decorate(activeEditor$1, activeEditorConfig);
 			if (decorator !== null) reconcileDecorator(key, decorator);
+			if (isDirty && ($readSlots(nextNode).size > 0 || $readSlots(prevNode).size > 0)) $reconcileSlotChildren(prevNode, nextNode, dom);
 		}
 		subTreeTextContent += text;
 	}
@@ -2411,153 +2596,153 @@ function warnOnlyOnce(message) {
 function createCommand(type) {
 	return { type };
 }
-const SELECTION_CHANGE_COMMAND = createCommand("SELECTION_CHANGE_COMMAND");
-const SELECTION_INSERT_CLIPBOARD_NODES_COMMAND = createCommand("SELECTION_INSERT_CLIPBOARD_NODES_COMMAND");
-const CLICK_COMMAND = createCommand("CLICK_COMMAND");
-const BEFORE_INPUT_COMMAND = createCommand("BEFORE_INPUT_COMMAND");
-const INPUT_COMMAND = createCommand("INPUT_COMMAND");
-const COMPOSITION_START_COMMAND = createCommand("COMPOSITION_START_COMMAND");
-const COMPOSITION_END_COMMAND = createCommand("COMPOSITION_END_COMMAND");
+const SELECTION_CHANGE_COMMAND = /* @__PURE__ */ createCommand("SELECTION_CHANGE_COMMAND");
+const SELECTION_INSERT_CLIPBOARD_NODES_COMMAND = /* @__PURE__ */ createCommand("SELECTION_INSERT_CLIPBOARD_NODES_COMMAND");
+const CLICK_COMMAND = /* @__PURE__ */ createCommand("CLICK_COMMAND");
+const BEFORE_INPUT_COMMAND = /* @__PURE__ */ createCommand("BEFORE_INPUT_COMMAND");
+const INPUT_COMMAND = /* @__PURE__ */ createCommand("INPUT_COMMAND");
+const COMPOSITION_START_COMMAND = /* @__PURE__ */ createCommand("COMPOSITION_START_COMMAND");
+const COMPOSITION_END_COMMAND = /* @__PURE__ */ createCommand("COMPOSITION_END_COMMAND");
 /**
 * Dispatched to delete a character, the payload will be `true` if the deletion
 * is backwards (backspace or delete on macOS) and `false` if forwards
 * (delete or Fn+Delete on macOS).
 */
-const DELETE_CHARACTER_COMMAND = createCommand("DELETE_CHARACTER_COMMAND");
+const DELETE_CHARACTER_COMMAND = /* @__PURE__ */ createCommand("DELETE_CHARACTER_COMMAND");
 /**
 * Dispatched to insert a line break. With a false payload the
 * cursor moves to the new line (Shift+Enter), with a true payload the cursor
 * does not move (Ctrl+O on macOS).
 */
-const INSERT_LINE_BREAK_COMMAND = createCommand("INSERT_LINE_BREAK_COMMAND");
-const INSERT_PARAGRAPH_COMMAND = createCommand("INSERT_PARAGRAPH_COMMAND");
-const CONTROLLED_TEXT_INSERTION_COMMAND = createCommand("CONTROLLED_TEXT_INSERTION_COMMAND");
-const PASTE_COMMAND = createCommand("PASTE_COMMAND");
-const REMOVE_TEXT_COMMAND = createCommand("REMOVE_TEXT_COMMAND");
+const INSERT_LINE_BREAK_COMMAND = /* @__PURE__ */ createCommand("INSERT_LINE_BREAK_COMMAND");
+const INSERT_PARAGRAPH_COMMAND = /* @__PURE__ */ createCommand("INSERT_PARAGRAPH_COMMAND");
+const CONTROLLED_TEXT_INSERTION_COMMAND = /* @__PURE__ */ createCommand("CONTROLLED_TEXT_INSERTION_COMMAND");
+const PASTE_COMMAND = /* @__PURE__ */ createCommand("PASTE_COMMAND");
+const REMOVE_TEXT_COMMAND = /* @__PURE__ */ createCommand("REMOVE_TEXT_COMMAND");
 /**
 * Dispatched to delete a word, the payload will be `true` if the deletion is
 * backwards (Ctrl+Backspace or Opt+Delete on macOS), and `false` if
 * forwards (Ctrl+Delete or Fn+Opt+Delete on macOS).
 */
-const DELETE_WORD_COMMAND = createCommand("DELETE_WORD_COMMAND");
+const DELETE_WORD_COMMAND = /* @__PURE__ */ createCommand("DELETE_WORD_COMMAND");
 /**
 * Dispatched to delete a line, the payload will be `true` if the deletion is
 * backwards (Cmd+Delete on macOS), and `false` if forwards
 * (Fn+Cmd+Delete on macOS).
 */
-const DELETE_LINE_COMMAND = createCommand("DELETE_LINE_COMMAND");
+const DELETE_LINE_COMMAND = /* @__PURE__ */ createCommand("DELETE_LINE_COMMAND");
 /**
 * Dispatched to format the selected text.
 */
-const FORMAT_TEXT_COMMAND = createCommand("FORMAT_TEXT_COMMAND");
+const FORMAT_TEXT_COMMAND = /* @__PURE__ */ createCommand("FORMAT_TEXT_COMMAND");
 /**
 * Dispatched on undo (Cmd+Z on macOS, Ctrl+Z elsewhere).
 */
-const UNDO_COMMAND = createCommand("UNDO_COMMAND");
+const UNDO_COMMAND = /* @__PURE__ */ createCommand("UNDO_COMMAND");
 /**
 * Dispatched on redo (Shift+Cmd+Z on macOS, Shift+Ctrl+Z or Ctrl+Y elsewhere).
 */
-const REDO_COMMAND = createCommand("REDO_COMMAND");
+const REDO_COMMAND = /* @__PURE__ */ createCommand("REDO_COMMAND");
 /**
 * Dispatched when any key is pressed.
 */
-const KEY_DOWN_COMMAND = createCommand("KEYDOWN_COMMAND");
+const KEY_DOWN_COMMAND = /* @__PURE__ */ createCommand("KEYDOWN_COMMAND");
 /**
 * Dispatched when the `'ArrowRight'` key is pressed.
 * The shift modifier key may also be down.
 */
-const KEY_ARROW_RIGHT_COMMAND = createCommand("KEY_ARROW_RIGHT_COMMAND");
+const KEY_ARROW_RIGHT_COMMAND = /* @__PURE__ */ createCommand("KEY_ARROW_RIGHT_COMMAND");
 /**
 * Dispatched when the move to end keyboard shortcut is pressed,
 * (Cmd+Right on macOS; Ctrl+Right elsewhere).
 */
-const MOVE_TO_END = createCommand("MOVE_TO_END");
+const MOVE_TO_END = /* @__PURE__ */ createCommand("MOVE_TO_END");
 /**
 * Dispatched when the `'ArrowLeft'` key is pressed.
 * The shift modifier key may also be down.
 */
-const KEY_ARROW_LEFT_COMMAND = createCommand("KEY_ARROW_LEFT_COMMAND");
+const KEY_ARROW_LEFT_COMMAND = /* @__PURE__ */ createCommand("KEY_ARROW_LEFT_COMMAND");
 /**
 * Dispatched when the move to start keyboard shortcut is pressed,
 * (Cmd+Left on macOS; Ctrl+Left elsewhere).
 */
-const MOVE_TO_START = createCommand("MOVE_TO_START");
+const MOVE_TO_START = /* @__PURE__ */ createCommand("MOVE_TO_START");
 /**
 * Dispatched when the `'ArrowUp'` key is pressed.
 * The shift and/or alt (option) modifier keys may also be down.
 */
-const KEY_ARROW_UP_COMMAND = createCommand("KEY_ARROW_UP_COMMAND");
+const KEY_ARROW_UP_COMMAND = /* @__PURE__ */ createCommand("KEY_ARROW_UP_COMMAND");
 /**
 * Dispatched when the `'ArrowDown'` key is pressed.
 * The shift and/or alt (option) modifier keys may also be down.
 */
-const KEY_ARROW_DOWN_COMMAND = createCommand("KEY_ARROW_DOWN_COMMAND");
+const KEY_ARROW_DOWN_COMMAND = /* @__PURE__ */ createCommand("KEY_ARROW_DOWN_COMMAND");
 /**
 * Dispatched when the enter key is pressed, may also be called with a null
 * payload when the intent is to insert a newline. The shift modifier key
 * must be down, any other modifier keys may also be down.
 */
-const KEY_ENTER_COMMAND = createCommand("KEY_ENTER_COMMAND");
+const KEY_ENTER_COMMAND = /* @__PURE__ */ createCommand("KEY_ENTER_COMMAND");
 /**
 * Dispatched whenever the space (`' '`) key is pressed, any modifier
 * keys may be down.
 */
-const KEY_SPACE_COMMAND = createCommand("KEY_SPACE_COMMAND");
+const KEY_SPACE_COMMAND = /* @__PURE__ */ createCommand("KEY_SPACE_COMMAND");
 /**
 * Dispatched whenever the `'Backspace'` key is pressed, the shift
 * modifier key may be down.
 */
-const KEY_BACKSPACE_COMMAND = createCommand("KEY_BACKSPACE_COMMAND");
+const KEY_BACKSPACE_COMMAND = /* @__PURE__ */ createCommand("KEY_BACKSPACE_COMMAND");
 /**
 * Dispatched whenever the `'Escape'` key is pressed, any modifier
 * keys may be down.
 */
-const KEY_ESCAPE_COMMAND = createCommand("KEY_ESCAPE_COMMAND");
+const KEY_ESCAPE_COMMAND = /* @__PURE__ */ createCommand("KEY_ESCAPE_COMMAND");
 /**
 * Dispatched whenever the `'Delete'` key is pressed (Fn+Delete on macOS).
 */
-const KEY_DELETE_COMMAND = createCommand("KEY_DELETE_COMMAND");
+const KEY_DELETE_COMMAND = /* @__PURE__ */ createCommand("KEY_DELETE_COMMAND");
 /**
 * Dispatched whenever the `'Tab'` key is pressed. The shift modifier key
 * may be down.
 */
-const KEY_TAB_COMMAND = createCommand("KEY_TAB_COMMAND");
-const INSERT_TAB_COMMAND = createCommand("INSERT_TAB_COMMAND");
-const INDENT_CONTENT_COMMAND = createCommand("INDENT_CONTENT_COMMAND");
-const OUTDENT_CONTENT_COMMAND = createCommand("OUTDENT_CONTENT_COMMAND");
-const DROP_COMMAND = createCommand("DROP_COMMAND");
-const FORMAT_ELEMENT_COMMAND = createCommand("FORMAT_ELEMENT_COMMAND");
-const DRAGSTART_COMMAND = createCommand("DRAGSTART_COMMAND");
-const DRAGOVER_COMMAND = createCommand("DRAGOVER_COMMAND");
-const DRAGEND_COMMAND = createCommand("DRAGEND_COMMAND");
+const KEY_TAB_COMMAND = /* @__PURE__ */ createCommand("KEY_TAB_COMMAND");
+const INSERT_TAB_COMMAND = /* @__PURE__ */ createCommand("INSERT_TAB_COMMAND");
+const INDENT_CONTENT_COMMAND = /* @__PURE__ */ createCommand("INDENT_CONTENT_COMMAND");
+const OUTDENT_CONTENT_COMMAND = /* @__PURE__ */ createCommand("OUTDENT_CONTENT_COMMAND");
+const DROP_COMMAND = /* @__PURE__ */ createCommand("DROP_COMMAND");
+const FORMAT_ELEMENT_COMMAND = /* @__PURE__ */ createCommand("FORMAT_ELEMENT_COMMAND");
+const DRAGSTART_COMMAND = /* @__PURE__ */ createCommand("DRAGSTART_COMMAND");
+const DRAGOVER_COMMAND = /* @__PURE__ */ createCommand("DRAGOVER_COMMAND");
+const DRAGEND_COMMAND = /* @__PURE__ */ createCommand("DRAGEND_COMMAND");
 /**
 * Dispatched on a copy event, either via the clipboard or a KeyboardEvent
 * (Cmd+C on macOS, Ctrl+C elsewhere).
 */
-const COPY_COMMAND = createCommand("COPY_COMMAND");
+const COPY_COMMAND = /* @__PURE__ */ createCommand("COPY_COMMAND");
 /**
 * Dispatched on a cut event, either via the clipboard or a KeyboardEvent
 * (Cmd+X on macOS, Ctrl+X elsewhere).
 */
-const CUT_COMMAND = createCommand("CUT_COMMAND");
+const CUT_COMMAND = /* @__PURE__ */ createCommand("CUT_COMMAND");
 /**
 * Dispatched on the select all keyboard shortcut
 * (Cmd+A on macOS, Ctrl+A elsehwere).
 */
-const SELECT_ALL_COMMAND = createCommand("SELECT_ALL_COMMAND");
-const CLEAR_EDITOR_COMMAND = createCommand("CLEAR_EDITOR_COMMAND");
-const CLEAR_HISTORY_COMMAND = createCommand("CLEAR_HISTORY_COMMAND");
-const CAN_REDO_COMMAND = createCommand("CAN_REDO_COMMAND");
-const CAN_UNDO_COMMAND = createCommand("CAN_UNDO_COMMAND");
-const FOCUS_COMMAND = createCommand("FOCUS_COMMAND");
-const BLUR_COMMAND = createCommand("BLUR_COMMAND");
+const SELECT_ALL_COMMAND = /* @__PURE__ */ createCommand("SELECT_ALL_COMMAND");
+const CLEAR_EDITOR_COMMAND = /* @__PURE__ */ createCommand("CLEAR_EDITOR_COMMAND");
+const CLEAR_HISTORY_COMMAND = /* @__PURE__ */ createCommand("CLEAR_HISTORY_COMMAND");
+const CAN_REDO_COMMAND = /* @__PURE__ */ createCommand("CAN_REDO_COMMAND");
+const CAN_UNDO_COMMAND = /* @__PURE__ */ createCommand("CAN_UNDO_COMMAND");
+const FOCUS_COMMAND = /* @__PURE__ */ createCommand("FOCUS_COMMAND");
+const BLUR_COMMAND = /* @__PURE__ */ createCommand("BLUR_COMMAND");
 /**
 * @deprecated in v0.31.0, use KEY_DOWN_COMMAND and check for modifiers
 * directly.
 *
 * Dispatched after any KeyboardEvent when modifiers are pressed
 */
-const KEY_MODIFIER_COMMAND = createCommand("KEY_MODIFIER_COMMAND");
+const KEY_MODIFIER_COMMAND = /* @__PURE__ */ createCommand("KEY_MODIFIER_COMMAND");
 const PASS_THROUGH_COMMAND = Object.freeze({});
 const ANDROID_COMPOSITION_LATENCY = 30;
 const rootElementEvents = [
@@ -2585,7 +2770,7 @@ let unprocessedBeforeInputData = null;
 let isInsertTextAfterHandledSelectionCommand = false;
 let handledSelectionCommandTimeoutId = null;
 const rootElementToDocument = /* @__PURE__ */ new WeakMap();
-const rootElementsRegistered = /* @__PURE__ */ new WeakMap();
+const documentRegistrations = /* @__PURE__ */ new WeakMap();
 let isSelectionChangeFromDOMUpdate = false;
 let isSelectionChangeFromMouseDown = false;
 let isInsertLineBreak = false;
@@ -2600,23 +2785,28 @@ let collapsedSelectionFormat = [
 	"root",
 	0
 ];
-function $shouldPreventDefaultAndInsertText(selection, domTargetRange, text, timeStamp, isBeforeInput) {
+function $shouldPreventDefaultAndInsertText(selection, domTargetRange, text, timeStamp, isBeforeInput, cachedDOMSelectionPoints) {
 	const anchor = selection.anchor;
 	const focus = selection.focus;
 	const anchorNode = anchor.getNode();
 	const editor = getActiveEditor();
-	const domSelection = getDOMSelection(getWindow(editor));
-	const domAnchorNode = domSelection !== null ? domSelection.anchorNode : null;
+	let domSelectionPoints;
+	if (cachedDOMSelectionPoints !== void 0) domSelectionPoints = cachedDOMSelectionPoints;
+	else {
+		const domSelection = getDOMSelection(getWindow(editor));
+		domSelectionPoints = domSelection !== null ? getDOMSelectionPoints(domSelection, editor._rootElement) : null;
+	}
+	const domAnchorNode = domSelectionPoints !== null ? domSelectionPoints.anchorNode : null;
 	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) || domSelection !== null && domTargetRange !== null && (!domTargetRange.collapsed || domTargetRange.startContainer !== domSelection.anchorNode || domTargetRange.startOffset !== domSelection.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 || 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 } = domSelection;
+	const { anchorNode: anchorDOM, anchorOffset, focusNode: focusDOM, focusOffset } = getDOMSelectionPoints(domSelection, editor._rootElement);
 	if (isSelectionChangeFromDOMUpdate) {
 		isSelectionChangeFromDOMUpdate = false;
 		if (shouldSkipSelectionChange(anchorDOM, anchorOffset) && shouldSkipSelectionChange(focusDOM, focusOffset) && !postDeleteSelectionToRestore) return;
@@ -2641,7 +2831,7 @@ function onSelectionChange(domSelection, editor, isActive) {
 			const anchor = selection.anchor;
 			const anchorNode = anchor.getNode();
 			if (selection.isCollapsed()) {
-				if (domSelection.type === "Range" && domSelection.anchorNode === domSelection.focusNode) selection.dirty = true;
+				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;
@@ -2711,7 +2901,7 @@ function onClick(event, editor) {
 					selection.dirty = true;
 				}
 			} else if (event.pointerType === "touch" || event.pointerType === "pen") {
-				const domAnchorNode = domSelection.anchorNode;
+				const domAnchorNode = getDOMSelectionPoints(domSelection, editor._rootElement).anchorNode;
 				if (isHTMLElement(domAnchorNode) || isDOMTextNode(domAnchorNode)) $setSelection($internalCreateRangeSelection(lastSelection, domSelection, editor, event));
 			}
 		}
@@ -2719,10 +2909,10 @@ function onClick(event, editor) {
 	});
 }
 function onPointerDown(event, editor) {
-	const target = event.target;
+	const target = getComposedEventTarget(event);
 	const pointerType = event.pointerType;
 	if (isDOMNode(target) && pointerType !== "touch" && pointerType !== "pen" && event.button === 0) updateEditorSync(editor, () => {
-		if (!$isSelectionCapturedInDecorator(target)) isSelectionChangeFromMouseDown = true;
+		if (!isDOMCapturingSelection(target, editor)) isSelectionChangeFromMouseDown = true;
 	});
 }
 function getTargetRange(event) {
@@ -2779,11 +2969,34 @@ function registerDefaultCommandHandlers(editor) {
 	editor.registerCommand(COMPOSITION_END_COMMAND, $handleCompositionEnd, 0);
 	editor.registerCommand(KEY_DOWN_COMMAND, $handleKeyDown, 0);
 }
+/**
+* Returns true when a `beforeinput` / `input` event belongs to a native
+* control (e.g. an `<input>` or `<textarea>`, or any other subtree marked with
+* `setDOMUnmanaged({captureSelection: true})`) inside a decorator whose
+* selection is owned by the browser rather than managed by Lexical. Turning
+* such an event into a Lexical command would insert text into the editor
+* instead of the focused control.
+*
+* Two signals are checked because Firefox 152 changed how it dispatches
+* `beforeinput` for these controls (#8738): the event is retargeted off of the
+* focused control, so its composed target no longer points at it. The deep
+* active element still does, and is used as a fallback.
+*/
+function isInputEventTargetingCapturedSelection(event, editor) {
+	const composedTarget = getComposedEventTarget(event);
+	if (isHTMLElement(composedTarget) && isDOMCapturingSelection(composedTarget, editor)) return true;
+	const rootElement = editor.getRootElement();
+	if (rootElement === null) return false;
+	const activeElement = getActiveElementDeep(rootElement.ownerDocument);
+	return activeElement !== null && rootElement.contains(activeElement) && isDOMCapturingSelection(activeElement, editor);
+}
 function onBeforeInput(event, editor) {
 	const inputType = event.inputType;
 	if (inputType === "deleteCompositionText" || IS_FIREFOX && isFirefoxClipboardEvents(editor)) return;
 	else if (inputType === "insertCompositionText") return;
-	dispatchCommand(editor, BEFORE_INPUT_COMMAND, event);
+	updateEditorSync(editor, () => {
+		if (!isInputEventTargetingCapturedSelection(event, editor)) dispatchCommand(editor, BEFORE_INPUT_COMMAND, event);
+	}, { event });
 }
 function $handleBeforeInput(event) {
 	const inputType = event.inputType;
@@ -2959,42 +3172,48 @@ function onInput(event, editor) {
 	event.stopPropagation();
 	clearHandledSelectionCommandInsertText();
 	updateEditorSync(editor, () => {
-		editor.dispatchCommand(INPUT_COMMAND, event);
+		if (!isInputEventTargetingCapturedSelection(event, editor)) editor.dispatchCommand(INPUT_COMMAND, event);
 	}, { event });
 	unprocessedBeforeInputData = null;
 }
 function $handleInput(event) {
-	if (isHTMLElement(event.target) && $isSelectionCapturedInDecorator(event.target)) return true;
 	const editor = getActiveEditor();
 	const selection = $getSelection();
 	const data = event.data;
 	const targetRange = getTargetRange(event);
-	if (data != null && $isRangeSelection(selection) && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false)) {
-		if (isFirefoxEndingComposition) {
-			$onCompositionEndImpl(editor, data);
-			isFirefoxEndingComposition = false;
-		}
-		const anchorNode = selection.anchor.getNode();
+	let handled = false;
+	if (data != null && $isRangeSelection(selection)) {
 		const domSelection = getDOMSelection(getWindow(editor));
-		if (domSelection === null) return true;
-		const isBackward = selection.isBackward();
-		const startOffset = isBackward ? selection.anchor.offset : selection.focus.offset;
-		const endOffset = isBackward ? selection.focus.offset : selection.anchor.offset;
-		if (!CAN_USE_BEFORE_INPUT || selection.isCollapsed() || !$isTextNode(anchorNode) || domSelection.anchorNode === null || anchorNode.getTextContent().slice(0, startOffset) + data + anchorNode.getTextContent().slice(startOffset + endOffset) !== getAnchorTextFromDOM(domSelection.anchorNode)) dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
-		const textLength = data.length;
-		if (IS_FIREFOX && textLength > 1 && event.inputType === "insertCompositionText" && !editor.isComposing()) {
-			selection.anchor.offset -= textLength;
-			selection._cachedNodes = null;
-			selection._cachedIsBackward = null;
-		}
-		if (IS_ANDROID_CHROME && editor.isComposing()) {
-			lastKeyDownTimeStamp = 0;
-			$setCompositionKey(null);
+		const domSelectionPoints = domSelection !== null ? getDOMSelectionPoints(domSelection, editor._rootElement) : null;
+		if ($shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, false, domSelectionPoints)) {
+			handled = true;
+			if (isFirefoxEndingComposition) {
+				$onCompositionEndImpl(editor, data);
+				isFirefoxEndingComposition = false;
+			}
+			const anchorNode = selection.anchor.getNode();
+			if (domSelection === null || domSelectionPoints === null) return true;
+			const isBackward = selection.isBackward();
+			const startOffset = isBackward ? selection.anchor.offset : selection.focus.offset;
+			const endOffset = isBackward ? selection.focus.offset : selection.anchor.offset;
+			if (!CAN_USE_BEFORE_INPUT || selection.isCollapsed() || !$isTextNode(anchorNode) || domSelectionPoints.anchorNode === null || anchorNode.getTextContent().slice(0, startOffset) + data + anchorNode.getTextContent().slice(startOffset + endOffset) !== getAnchorTextFromDOM(domSelectionPoints.anchorNode)) dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
+			const textLength = data.length;
+			if (IS_FIREFOX && textLength > 1 && event.inputType === "insertCompositionText" && !editor.isComposing()) {
+				selection.anchor.offset -= textLength;
+				selection._cachedNodes = null;
+				selection._cachedIsBackward = null;
+			}
+			if (IS_ANDROID_CHROME && editor.isComposing()) {
+				lastKeyDownTimeStamp = 0;
+				$setCompositionKey(null);
+			}
 		}
-	} else {
+	}
+	if (!handled) {
 		$updateSelectedTextFromDOM(false, editor, data !== null ? data : void 0);
 		if (isFirefoxEndingComposition) {
 			$onCompositionEndImpl(editor, data || void 0);
+			$addUpdateTag(COMPOSITION_END_TAG);
 			isFirefoxEndingComposition = false;
 		}
 	}
@@ -3031,11 +3250,12 @@ function $onCompositionEndImpl(editor, data) {
 			const textNode = domElement !== null && $isTextNode(node) ? $getDOMTextNode(node, domElement, editor) : null;
 			if (textNode !== null && textNode.nodeValue !== null && $isTextNode(node)) {
 				const domSelection = getDOMSelection(getWindow(editor));
+				const domSelectionPoints = domSelection && getDOMSelectionPoints(domSelection, editor._rootElement);
 				let anchorOffset = null;
 				let focusOffset = null;
-				if (domSelection !== null && domSelection.anchorNode === textNode) {
-					anchorOffset = domSelection.anchorOffset;
-					focusOffset = domSelection.focusOffset;
+				if (domSelectionPoints !== null && domSelectionPoints.anchorNode === textNode) {
+					anchorOffset = domSelectionPoints.anchorOffset;
+					focusOffset = domSelectionPoints.focusOffset;
 				}
 				$updateTextNodeFromDOMContent(node, textNode.nodeValue, anchorOffset, focusOffset, true);
 			}
@@ -3170,13 +3390,64 @@ const activeNestedEditorsMap = /* @__PURE__ */ new Map();
 function onDocumentSelectionChange(event) {
 	const domSelection = getDOMSelectionFromTarget(event.target);
 	if (domSelection === null) return;
-	const nextActiveEditor = getNearestEditorFromDOMNode(domSelection.anchorNode);
+	const ownerDocument = getDOMOwnerDocument(event.target);
+	let nextActiveEditor = null;
+	let resolvedAnchorNode = null;
+	if (ownerDocument !== null) {
+		const registration = documentRegistrations.get(ownerDocument);
+		if (registration !== void 0) {
+			const editorsForDoc = registration.editors;
+			let hasShadow = registration.hasShadowEditor;
+			if (hasShadow === void 0) {
+				hasShadow = false;
+				for (const ed of editorsForDoc) if (ed._rootElement !== null && isDOMShadowRoot(ed._rootElement.getRootNode())) {
+					hasShadow = true;
+					break;
+				}
+				registration.hasShadowEditor = hasShadow;
+			}
+			if (!hasShadow) {
+				const anchorNode = domSelection.anchorNode;
+				if (anchorNode !== null && !(isHTMLElement(anchorNode) && anchorNode.shadowRoot !== null)) {
+					nextActiveEditor = getNearestEditorFromDOMNode(anchorNode);
+					if (nextActiveEditor !== null) resolvedAnchorNode = anchorNode;
+				}
+			} else {
+				let deferredLightEditor = null;
+				let deferredLightAnchor = null;
+				for (const candidate of editorsForDoc) {
+					const candidateRoot = candidate._rootElement;
+					if (candidateRoot === null) continue;
+					const anchorNode = getDOMSelectionPoints(domSelection, candidateRoot).anchorNode;
+					if (anchorNode === null) continue;
+					if (getNearestEditorFromDOMNode(anchorNode) !== candidate) continue;
+					if (isDOMShadowRoot(candidateRoot.getRootNode())) {
+						nextActiveEditor = candidate;
+						resolvedAnchorNode = anchorNode;
+						break;
+					}
+					if (deferredLightEditor === null) {
+						deferredLightEditor = candidate;
+						deferredLightAnchor = anchorNode;
+					}
+				}
+				if (nextActiveEditor === null && deferredLightEditor !== null) {
+					nextActiveEditor = deferredLightEditor;
+					resolvedAnchorNode = deferredLightAnchor;
+				}
+			}
+		}
+		if (nextActiveEditor === null) {
+			const activeElement = getActiveElementDeep(ownerDocument);
+			nextActiveEditor = activeElement !== null ? getNearestEditorFromDOMNode(activeElement) : null;
+		}
+	}
 	if (nextActiveEditor === null) return;
 	if (isSelectionChangeFromMouseDown) {
 		isSelectionChangeFromMouseDown = false;
 		updateEditorSync(nextActiveEditor, () => {
 			const lastSelection = $getPreviousSelection();
-			const domAnchorNode = domSelection.anchorNode;
+			const domAnchorNode = resolvedAnchorNode ?? getDOMSelectionPoints(domSelection, nextActiveEditor._rootElement).anchorNode;
 			if (isHTMLElement(domAnchorNode) || isDOMTextNode(domAnchorNode)) $setSelection($internalCreateRangeSelection(lastSelection, domSelection, nextActiveEditor, event));
 		});
 	}
@@ -3200,9 +3471,19 @@ function hasStoppedLexicalPropagation(event) {
 function addRootElementEvents(rootElement, editor) {
 	const doc = rootElement.ownerDocument;
 	rootElementToDocument.set(rootElement, doc);
-	const documentRootElementsCount = rootElementsRegistered.get(doc) ?? 0;
-	if (documentRootElementsCount < 1) doc.addEventListener("selectionchange", onDocumentSelectionChange);
-	rootElementsRegistered.set(doc, documentRootElementsCount + 1);
+	let registration = documentRegistrations.get(doc);
+	if (registration === void 0) {
+		registration = {
+			editors: /* @__PURE__ */ new Set(),
+			hasShadowEditor: void 0,
+			rootElementCount: 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);
 	for (let i = 0; i < rootElementEvents.length; i++) {
@@ -3240,19 +3521,21 @@ function removeRootElementEvents(rootElement) {
 		rootElementNotRegisteredWarning();
 		return;
 	}
-	const documentRootElementsCount = rootElementsRegistered.get(doc);
-	if (documentRootElementsCount === void 0) {
+	const registration = documentRegistrations.get(doc);
+	if (registration === void 0) {
 		rootElementNotRegisteredWarning();
 		return;
 	}
-	const newCount = documentRootElementsCount - 1;
+	const newCount = registration.rootElementCount - 1;
 	if (!(newCount >= 0)) formatDevErrorMessage(`Root element count less than 0`);
 	rootElementToDocument.delete(rootElement);
-	rootElementsRegistered.set(doc, newCount);
+	registration.rootElementCount = newCount;
 	if (newCount === 0) doc.removeEventListener("selectionchange", onDocumentSelectionChange);
 	const editor = getEditorPropertyFromDOMNode(rootElement);
 	if (isLexicalEditor(editor)) {
 		cleanActiveNestedEditorsMap(editor);
+		registration.editors.delete(editor);
+		registration.hasShadowEditor = void 0;
 		rootElement.__lexicalEditor = null;
 	} else if (editor) formatDevErrorMessage(`Attempted to remove event handlers from a node that does not belong to this build of Lexical`);
 	const removeHandles = getRootElementRemoveHandles(rootElement);
@@ -3297,6 +3580,15 @@ function markCollapsedSelectionFormat(format, style, offset, key, timeStamp) {
 /**
 * This is the type of LexicalNode.$config() that can be
 * overridden by subclasses.
+*
+* Concrete nodes are keyed by their string `type`. An abstract base class
+* (such as ElementNode or DecoratorNode) has no concrete node `type`, so when
+* it needs to declare configuration that is shared with its concrete
+* subclasses (for example required {@link RequiredNodeStateConfig} state or a
+* `$transform`) it is keyed instead by a well-known symbol, by convention
+* `Symbol.for(<NodeClassName>)` (e.g. `Symbol.for('ElementNode')`). The
+* descriptive, globally-registered symbol keeps the config easy to find in a
+* debugger and can never collide with a real node `type`.
 */
 /**
 * Used to extract the node and type from a StaticNodeConfigRecord
@@ -3307,8 +3599,97 @@ function markCollapsedSelectionFormat(format, style, offset, key, timeStamp) {
 /**
 * @internal
 *
+* Type-only key under which a {@link StaticNodeConfigRecord} carries the node's
+* own (most-derived) `type` as a nullary accessor `() => Type`.
+*
+* TypeScript's type system is structural, so a node subclass that adds no
+* type-distinguishable members over its base (e.g. {@link TabNode} over
+* {@link TextNode}, which only overrides methods with identical signatures) is
+* structurally identical to that base despite being a distinct class — the
+* negative branch of an `instanceof`-style guard like `$isTabNode()` would
+* otherwise collapse to `never` because TypeScript concludes the base is also
+* assignable to the subclass.
+*
+* Encoding the type as a *function* (rather than a bare `Type`) lets the
+* accessor accumulate down the `extends` chain by intersection: a subclass'
+* record is `ParentRecord & {[STATIC_NODE_TYPE]: () => OwnType}`, so the key
+* holds `(() => ParentType) & (() => OwnType)`. TypeScript resolves an
+* intersection of call signatures as an overload set, which has two effects:
+*
+* - {@link GetStaticNodeType} reads `ReturnType<...>`, which selects the *last*
+*   overload — the most-derived own `type` — rather than a union of the chain.
+* - A node stays assignable to each of its ancestors (the intersection
+*   satisfies every `() => AncestorType`) while an ancestor is not assignable
+*   to it (it lacks the `() => OwnType` signature), so guards narrow correctly
+*   at every level of the hierarchy — not just one.
+*
+* This keeps the node classes themselves nominally distinguishable along their
+* real hierarchy; it is not a cross-cutting trait marker. The accessor is never
+* read at runtime — `config()` does not set this key — so it is `declare`-only
+* and carries no runtime cost. It is `@internal` (surfaced via the
+* {@link StaticNodeTypeAccessor} interface so that inferred `$config()` return
+* types remain nameable in generated declaration files) and a node never
+* references it. Distinction is automatic for any node that declares its
+* `extends`; a subclass adds nothing by hand.
+*/
+/**
+* @internal
+*
+* Carries a node's own `type` under the {@link STATIC_NODE_TYPE} accessor. This
+* is an `interface` (rather than an inline object type) on purpose: it is never
+* inlined in generated declaration files, so a subclass' `$config()` return type
+* references it by name (`StaticNodeTypeAccessor<'tab'>`) and the symbol key
+* stays encapsulated here rather than leaking — unnamed — into every node's
+* `.d.ts`.
+*/
+/**
+* @internal
+*
+* Type-only key under which a {@link StaticNodeConfigRecord} carries the node's
+* own configuration (the value passed to {@link LexicalNode.config}) as a
+* nullary accessor `() => Config`.
+*
+* This mirrors {@link STATIC_NODE_TYPE}: encoding the config as a *function*
+* lets it accumulate down the `extends` chain by call-signature intersection so
+* that `ReturnType<...>` resolves the most-derived own config. It exists so that
+* an abstract base class keyed by a symbol — which has no string `type` to index
+* the record by — can still expose its own config to the state-config
+* collectors, and so that such a base's symbol-keyed `$config()` return remains
+* a valid override of an accessor-bearing superclass `$config()` (it inherits
+* the superclass record, hence that record's {@link STATIC_NODE_TYPE} accessor).
+* Never read at runtime — `config()` does not set this key — so it is
+* `declare`-only and carries no runtime cost.
+*/
+/**
+* @internal
+*
+* Carries a node's own config under the {@link STATIC_NODE_CONFIG} accessor.
+* Like {@link StaticNodeTypeAccessor} this is a named `interface` so the symbol
+* key stays encapsulated and inferred `$config()` return types remain nameable
+* in generated declaration files.
+*/
+/**
+* @internal
+*
 * This is the more specific type than BaseStaticNodeConfig that a subclass
-* should return from $config()
+* should return from $config().
+*
+* A node that declares its `extends` accumulates the configuration of its
+* superclass and records its own `type` under {@link STATIC_NODE_TYPE} and its
+* own config under {@link STATIC_NODE_CONFIG}, so that it is nominally distinct
+* from — yet still assignable to — that superclass, and so the state-config
+* collectors can read its own config without indexing by `type`.
+*/
+/**
+* @internal
+*
+* The record returned by {@link LexicalNode.config} for an abstract base class
+* keyed by a symbol. Unlike {@link StaticNodeConfigRecord} it records no string
+* `type` and adds no {@link STATIC_NODE_TYPE} accessor (an abstract base has no
+* concrete node type), but it does inherit its superclass record and expose its
+* own config under {@link STATIC_NODE_CONFIG}. Inheriting the superclass record
+* is what keeps the override valid when the superclass is a concrete node whose
+* `$config()` return already carries a {@link STATIC_NODE_TYPE} accessor.
 */
 /**
 * Extract the type from a node based on its $config
@@ -3320,6 +3701,16 @@ function markCollapsedSelectionFormat(format, style, offset, key, timeStamp) {
 * ```
 */
 /**
+* @internal
+*
+* A node's own config (the value it passed to {@link LexicalNode.config}), read
+* from the {@link STATIC_NODE_CONFIG} accessor, or `never` for a node whose
+* `$config()` does not set that accessor (a legacy node, or one whose record
+* uses the {@link BaseStaticNodeConfig} fallback). Unlike indexing the record by
+* a resolved string `type`, this also resolves the own config of an abstract
+* base class keyed by a symbol.
+*/
+/**
 * The most precise type we can infer for the JSON that will
 * be produced by T.exportJSON().
 *
@@ -3334,7 +3725,10 @@ function $removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
 	errorOnReadOnly();
 	const key = nodeToRemove.__key;
 	const parent = nodeToRemove.getParent();
-	if (parent === null) return;
+	if (parent === null) {
+		if (!($getSlotHostKey(nodeToRemove) === null)) formatDevErrorMessage(`$removeNode: node ${key} is slotted into host ${String($getSlotHostKey(nodeToRemove))}; use removeSlot on the host instead of remove().`);
+		return;
+	}
 	const selection = $maybeMoveChildrenSelectionToParent(nodeToRemove);
 	let selectionMoved = false;
 	if ($isRangeSelection(selection) && restoreSelection) {
@@ -3351,9 +3745,9 @@ function $removeNode(nodeToRemove, restoreSelection, preserveEmptyParent) {
 	} else if ($isNodeSelection(selection) && restoreSelection && nodeToRemove.isSelected()) nodeToRemove.selectPrevious();
 	if ($isRangeSelection(selection) && restoreSelection && !selectionMoved) {
 		const index = nodeToRemove.getIndexWithinParent();
-		removeFromParent(nodeToRemove);
+		$removeFromParent(nodeToRemove);
 		$updateElementSelectionOnCreateDeleteNode(selection, parent, index, -1);
-	} else removeFromParent(nodeToRemove);
+	} else $removeFromParent(nodeToRemove);
 	if (!preserveEmptyParent && !$isRootOrShadowRoot(parent) && !parent.canBeEmpty() && parent.isEmpty()) $removeNode(parent, restoreSelection);
 	if (restoreSelection && selection && $isRootNode(parent) && parent.isEmpty()) parent.selectEnd();
 }
@@ -3390,6 +3784,23 @@ const NON_ENUMERABLE_PROP_DESC = {
 	value: void 0,
 	writable: true
 };
+/**
+* A node that can host named slots, implemented by {@link ElementNode} and
+* {@link DecoratorNode}. The map is allocated lazily (null until the first
+* {@link $setSlot}) since most nodes have none. Declaring this off the base
+* {@link LexicalNode} is what lets {@link $setSlot} / {@link $removeSlot}
+* reject a non-host at compile time.
+*
+* @experimental
+*/
+/**
+* A node that can occupy a named slot, implemented by {@link ElementNode} and
+* {@link DecoratorNode}. Its up-pointer is `__slotHost` rather than `__parent`
+* (the two are mutually exclusive), so the slot boundary behaves like a shadow
+* root.
+*
+* @experimental
+*/
 var LexicalNode = class {
 	/** @internal Allow us to look up the type including static props */
 	/** @internal */
@@ -3448,13 +3859,15 @@ var LexicalNode = class {
 	* This is a convenience method for $config that
 	* aids in type inference. See {@link LexicalNode.$config}
 	* for example usage.
+	*
+	* An abstract base class that has no concrete node `type` may pass a
+	* well-known symbol (by convention `Symbol.for(<NodeClassName>)`) instead of
+	* a string `type` to declare configuration shared with its subclasses.
 	*/
 	config(type, config) {
-		const parentKlass = config.extends || Object.getPrototypeOf(this.constructor);
-		Object.assign(config, {
-			extends: parentKlass,
-			type
-		});
+		const parentKlass = config.extends || getSuperclassOf(this.constructor);
+		Object.assign(config, { extends: parentKlass });
+		if (typeof type === "string") Object.assign(config, { type });
 		return { [type]: config };
 	}
 	/**
@@ -3554,7 +3967,7 @@ var LexicalNode = class {
 			if (nodeKey === "root") return true;
 			const node = $getNodeByKey(nodeKey);
 			if (node === null) break;
-			nodeKey = node.__parent;
+			nodeKey = node.__parent !== null ? node.__parent : $getSlotHostKey(node);
 		}
 		return false;
 	}
@@ -3604,6 +4017,12 @@ var LexicalNode = class {
 	/**
 	* Returns the parent of this node, or null if none is found.
 	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getParent() as T | null`, and will be removed
+	* in a future release. Call this method without a type argument and
+	* narrow the result with a type guard instead.
+	*/
 	getParent() {
 		const parent = this.getLatest().__parent;
 		if (parent === null) return null;
@@ -3612,6 +4031,12 @@ var LexicalNode = class {
 	/**
 	* Returns the parent of this node, or throws if none is found.
 	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getParentOrThrow() as T`, and will be removed
+	* in a future release. Call this method without a type argument and
+	* narrow the result with a type guard instead.
+	*/
 	getParentOrThrow() {
 		const parent = this.getParent();
 		if (parent === null) formatDevErrorMessage(`Expected node ${this.__key} to have a parent.`);
@@ -3626,7 +4051,7 @@ var LexicalNode = class {
 		let node = this;
 		while (node !== null) {
 			const parent = node.getParent();
-			if ($isRootOrShadowRoot(parent)) {
+			if ($isRootOrShadowRoot(parent) || $getSlotHostKey(node) !== null) {
 				if (!($isElementNode(node) || node === this && $isDecoratorNode(node))) formatDevErrorMessage(`Children of root nodes must be elements or decorators`);
 				return node;
 			}
@@ -3673,18 +4098,28 @@ var LexicalNode = class {
 		return parents;
 	}
 	/**
-	* Returns the "previous" siblings - that is, the node that comes
-	* before this one in the same parent.
-	*
+	* Returns the node before this one in the same parent, or null
+	* if there is no such node.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getPreviousSibling() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
 	*/
 	getPreviousSibling() {
 		const prevKey = this.getLatest().__prev;
 		return prevKey === null ? null : $getNodeByKey(prevKey);
 	}
 	/**
-	* Returns the "previous" siblings - that is, the nodes that come between
-	* this one and the first child of it's parent, inclusive.
-	*
+	* Returns all nodes before this one in the same parent,
+	* in document order.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getPreviousSiblings() as T[]`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the results with a type guard instead.
 	*/
 	getPreviousSiblings() {
 		const siblings = [];
@@ -3699,18 +4134,28 @@ var LexicalNode = class {
 		return siblings;
 	}
 	/**
-	* Returns the "next" siblings - that is, the node that comes
-	* after this one in the same parent
-	*
+	* Returns the node after this one in the same parent, or null
+	* if there is no such node.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getNextSibling() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
 	*/
 	getNextSibling() {
 		const nextKey = this.getLatest().__next;
 		return nextKey === null ? null : $getNodeByKey(nextKey);
 	}
 	/**
-	* Returns all "next" siblings - that is, the nodes that come between this
-	* one and the last child of it's parent, inclusive.
-	*
+	* Returns all nodes after this one in the same parent,
+	* in document order.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `node.getNextSiblings() as T[]`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the results with a type guard instead.
 	*/
 	getNextSiblings() {
 		const siblings = [];
@@ -3873,7 +4318,7 @@ var LexicalNode = class {
 	*
 	*/
 	getTextContent() {
-		return "";
+		return $getSlotsTextContent(this);
 	}
 	/**
 	* Returns the length of the string produced by calling getTextContent on this node.
@@ -4034,10 +4479,11 @@ var LexicalNode = class {
 		const key = replaceWith.__key;
 		const writableReplaceWith = replaceWith.getWritable();
 		const writableParent = this.getParentOrThrow().getWritable();
+		$errorOnSlotCycleChild(writableParent, writableReplaceWith);
 		const size = writableParent.__size;
 		const replaceWithOldParent = writableReplaceWith.getParent();
 		const replaceWithOldIndex = replaceWithOldParent !== null ? writableReplaceWith.getIndexWithinParent() : -1;
-		removeFromParent(writableReplaceWith);
+		$removeFromParent(writableReplaceWith);
 		if (replaceWithOldParent !== null && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, replaceWithOldParent, replaceWithOldIndex, -1);
 		const prevSibling = self.getPreviousSibling();
 		const nextSibling = self.getNextSibling();
@@ -4065,6 +4511,17 @@ var LexicalNode = class {
 			prevSizeBeforeChildrenTransfer = writableReplaceWith.getChildrenSize();
 			writableReplaceWith.splice(prevSizeBeforeChildrenTransfer, 0, this.getChildren());
 		}
+		const slotNames = $getSlotNames(this);
+		if (slotNames.length > 0) {
+			if (!$isSlotHost(this) || !$isSlotHost(writableReplaceWith)) formatDevErrorMessage(`replace: node ${this.__key} has slots but ${writableReplaceWith.__key} cannot host them; only ElementNodes and DecoratorNodes can host slots.`);
+			for (const slotName of slotNames) {
+				const slot = $getSlot(this, slotName);
+				if (slot !== null) {
+					$removeSlot(this, slotName);
+					$setSlot(writableReplaceWith, slotName, slot);
+				}
+			}
+		}
 		if ($isRangeSelection(selection)) {
 			$setSelection(selection);
 			const anchor = selection.anchor;
@@ -4089,6 +4546,7 @@ var LexicalNode = class {
 		errorOnInsertTextNodeOnRoot(this, nodeToInsert);
 		const writableSelf = this.getWritable();
 		const writableNodeToInsert = nodeToInsert.getWritable();
+		$errorOnSlotCycleChild(this.getParentOrThrow(), writableNodeToInsert);
 		const oldParent = writableNodeToInsert.getParent();
 		const selection = $getSelection();
 		let elementAnchorSelectionOnNode = false;
@@ -4102,9 +4560,9 @@ var LexicalNode = class {
 				elementAnchorSelectionOnNode = anchor.type === "element" && anchor.key === oldParentKey && anchor.offset === oldIndex + 1;
 				elementFocusSelectionOnNode = focus.type === "element" && focus.key === oldParentKey && focus.offset === oldIndex + 1;
 			}
-			removeFromParent(writableNodeToInsert);
+			$removeFromParent(writableNodeToInsert);
 			if (restoreSelection && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, oldParent, oldIndex, -1);
-		}
+		} else $removeFromParent(writableNodeToInsert);
 		const nextSibling = this.getNextSibling();
 		const writableParent = this.getParentOrThrow().getWritable();
 		const insertKey = writableNodeToInsert.__key;
@@ -4140,11 +4598,12 @@ var LexicalNode = class {
 		errorOnInsertTextNodeOnRoot(this, nodeToInsert);
 		const writableSelf = this.getWritable();
 		const writableNodeToInsert = nodeToInsert.getWritable();
+		$errorOnSlotCycleChild(this.getParentOrThrow(), writableNodeToInsert);
 		const insertKey = writableNodeToInsert.__key;
 		const selection = $getSelection();
 		const insertOldParent = writableNodeToInsert.getParent();
 		const insertOldIndex = insertOldParent !== null ? writableNodeToInsert.getIndexWithinParent() : -1;
-		removeFromParent(writableNodeToInsert);
+		$removeFromParent(writableNodeToInsert);
 		if (insertOldParent !== null && restoreSelection && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, insertOldParent, insertOldIndex, -1);
 		const prevSibling = this.getPreviousSibling();
 		const writableParent = this.getParentOrThrow().getWritable();
@@ -4193,6 +4652,8 @@ var LexicalNode = class {
 	* */
 	selectPrevious(anchorOffset, focusOffset) {
 		errorOnReadOnly();
+		const slotHost = $getSlotHost(this);
+		if (slotHost !== null) return slotHost.selectPrevious(anchorOffset, focusOffset);
 		const prevSibling = this.getPreviousSibling();
 		const parent = this.getParentOrThrow();
 		if (prevSibling === null) return parent.select(0, 0);
@@ -4211,6 +4672,8 @@ var LexicalNode = class {
 	* */
 	selectNext(anchorOffset, focusOffset) {
 		errorOnReadOnly();
+		const slotHost = $getSlotHost(this);
+		if (slotHost !== null) return slotHost.selectNext(anchorOffset, focusOffset);
 		const nextSibling = this.getNextSibling();
 		const parent = this.getParentOrThrow();
 		if (nextSibling === null) return parent.select();
@@ -4298,6 +4761,10 @@ const HISTORY_MERGE_TAG = "history-merge";
 */
 const PASTE_TAG = "paste";
 /**
+* Indicates that the update is related to a cut operation
+*/
+const CUT_TAG = "cut";
+/**
 * Indicates that the update is related to collaborative editing
 */
 const COLLABORATION_TAG = "collaboration";
@@ -4341,7 +4808,7 @@ const COMPOSITION_END_TAG = "composition-end";
 * LICENSE file in the root directory of this source tree.
 *
 */
-const IMPORTANT_REG_EXP = /\s*!important\s*$/i;
+const IMPORTANT_FLAG = "!important";
 /**
 * Parses inline CSS text into an object that is compatible with
 * `CSSStyleDeclaration.setProperty()`.
@@ -4359,7 +4826,9 @@ function getStyleObjectFromCSS(css) {
 	let isEscaped = false;
 	let isParsingValue = false;
 	let parenthesisDepth = 0;
-	for (let i = 0; i < css.length; i++) {
+	const length = css.length;
+	let chunkStart = -1;
+	for (let i = 0; i < length; i++) {
 		const char = css[i];
 		if (inComment) {
 			if (char === "*" && css[i + 1] === "/") {
@@ -4369,46 +4838,55 @@ function getStyleObjectFromCSS(css) {
 			continue;
 		}
 		if (isEscaped) {
-			if (isParsingValue) currentValue += char;
-			else currentProperty += char;
+			if (chunkStart === -1) chunkStart = i;
 			isEscaped = false;
 			continue;
 		}
 		if (currentQuote !== null) {
-			if (isParsingValue) currentValue += char;
-			else currentProperty += char;
+			if (chunkStart === -1) chunkStart = i;
 			if (char === "\\") isEscaped = true;
 			else if (char === currentQuote) currentQuote = null;
 			continue;
 		}
 		if (char === "/" && css[i + 1] === "*") {
+			if (chunkStart !== -1) {
+				if (isParsingValue) currentValue += css.slice(chunkStart, i);
+				else currentProperty += css.slice(chunkStart, i);
+				chunkStart = -1;
+			}
 			inComment = true;
 			i++;
 			continue;
 		}
 		if (char === "\"" || char === "'") {
+			if (chunkStart === -1) chunkStart = i;
 			currentQuote = char;
-			if (isParsingValue) currentValue += char;
-			else currentProperty += char;
 			continue;
 		}
 		if (char === "(") {
+			if (chunkStart === -1) chunkStart = i;
 			parenthesisDepth++;
-			if (isParsingValue) currentValue += char;
-			else currentProperty += char;
 			continue;
 		}
 		if (char === ")") {
+			if (chunkStart === -1) chunkStart = i;
 			parenthesisDepth = Math.max(0, parenthesisDepth - 1);
-			if (isParsingValue) currentValue += char;
-			else currentProperty += char;
 			continue;
 		}
 		if (!isParsingValue && char === ":" && parenthesisDepth === 0) {
+			if (chunkStart !== -1) {
+				currentProperty += css.slice(chunkStart, i);
+				chunkStart = -1;
+			}
 			isParsingValue = true;
 			continue;
 		}
 		if (char === ";" && parenthesisDepth === 0) {
+			if (chunkStart !== -1) {
+				if (isParsingValue) currentValue += css.slice(chunkStart, i);
+				else currentProperty += css.slice(chunkStart, i);
+				chunkStart = -1;
+			}
 			const property = currentProperty.trim();
 			const value = currentValue.trim();
 			if (property !== "" && value !== "") styles[property] = value;
@@ -4417,18 +4895,20 @@ function getStyleObjectFromCSS(css) {
 			isParsingValue = false;
 			continue;
 		}
-		if (isParsingValue) currentValue += char;
-		else currentProperty += char;
+		if (chunkStart === -1) chunkStart = i;
 	}
+	if (chunkStart !== -1) if (isParsingValue) currentValue += css.slice(chunkStart, length);
+	else currentProperty += css.slice(chunkStart, length);
 	const property = currentProperty.trim();
 	const value = currentValue.trim();
 	if (property !== "" && value !== "") styles[property] = value;
 	return styles;
 }
 function setDOMStyleProperty(domStyle, property, value) {
-	const priority = IMPORTANT_REG_EXP.test(value) ? "important" : "";
-	const nextValue = priority === "" ? value : value.replace(IMPORTANT_REG_EXP, "").trim();
-	domStyle.setProperty(property, nextValue, priority);
+	const trimmedValue = value.trimEnd();
+	const flagStart = trimmedValue.length - 10;
+	if (flagStart >= 0 && trimmedValue.slice(flagStart).toLowerCase() === IMPORTANT_FLAG) domStyle.setProperty(property, trimmedValue.slice(0, flagStart).trim(), "important");
+	else domStyle.setProperty(property, value, "");
 }
 /**
 * Applies a style object to a DOM style declaration using
@@ -4461,83 +4941,6 @@ function setDOMStyleFromCSS(domStyle, cssText, prevCSSText = "") {
 	}
 	for (const property in prevCSS) domStyle.removeProperty(property);
 }
-/**
-* 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.
-*
-*/
-/** @noInheritDoc */
-var LineBreakNode = class LineBreakNode extends LexicalNode {
-	/** @internal */
-	static getType() {
-		return "linebreak";
-	}
-	static clone(node) {
-		return new LineBreakNode(node.__key);
-	}
-	constructor(key) {
-		super(key);
-	}
-	getTextContent() {
-		return "\n";
-	}
-	createDOM() {
-		return document.createElement("br");
-	}
-	updateDOM() {
-		return false;
-	}
-	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() };
-}
-function $createLineBreakNode() {
-	return $applyNodeReplacement(new LineBreakNode());
-}
-function $isLineBreakNode(node) {
-	return node instanceof LineBreakNode;
-}
-function isOnlyChildInBlockNode(node) {
-	const parentElement = node.parentElement;
-	if (parentElement !== null && isBlockDomNode(parentElement)) {
-		const firstChild = parentElement.firstChild;
-		if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
-			const lastChild = parentElement.lastChild;
-			if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) return true;
-		}
-	}
-	return false;
-}
-function isLastChildInBlockNode(node) {
-	const parentElement = node.parentElement;
-	if (parentElement !== null && isBlockDomNode(parentElement)) {
-		const firstChild = parentElement.firstChild;
-		if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) return false;
-		const lastChild = parentElement.lastChild;
-		if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) return true;
-	}
-	return false;
-}
-function isWhitespaceDomTextNode(node) {
-	return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || "");
-}
 function getElementOuterTag(node, format) {
 	if (format & 16) return "code";
 	if (format & 128) return "mark";
@@ -5273,18 +5676,7 @@ function $convertTextDOMNode(domNode) {
 	const domNode_ = domNode;
 	if (!(domNode.parentElement !== null)) formatDevErrorMessage(`Expected parentElement of Text not to be null`);
 	let textContent = domNode_.textContent || "";
-	if (findParentPreDOMNode(domNode_) !== null) {
-		const parts = textContent.split(/(\r?\n|\t)/);
-		const nodes = [];
-		const length = parts.length;
-		for (let i = 0; i < length; i++) {
-			const part = parts[i];
-			if (part === "\n" || part === "\r\n") nodes.push($createLineBreakNode());
-			else if (part === "	") nodes.push($createTabNode());
-			else if (part !== "") nodes.push($createTextNode(part));
-		}
-		return { node: nodes };
-	}
+	if (findParentPreDOMNode(domNode_) !== null) return { node: $generateNodesFromRawText(textContent) };
 	textContent = textContent.replace(/\r/g, "").replace(/[ \t\n]+/g, " ");
 	if (textContent === "") return { node: null };
 	if (textContent[0] === " ") {
@@ -5401,8 +5793,11 @@ var TabNode = class TabNode extends TextNode {
 	static importJSON(serializedTabNode) {
 		return $createTabNode().updateFromJSON(serializedTabNode);
 	}
-	setTextContent(text) {
-		if (!(text === "	" || text === "")) formatDevErrorMessage(`TabNode does not support setTextContent`);
+	/**
+	* Always normalizes the stored content to `'\t'` regardless of input — see
+	* comment below for the rationale.
+	*/
+	setTextContent(_text) {
 		return super.setTextContent("	");
 	}
 	spliceText(offset, delCount, newText, moveSelection) {
@@ -5520,11 +5915,14 @@ function $transferStartingElementPointToTextPoint(start, end, format, style) {
 	textNode.setFormat(format);
 	textNode.setStyle(style);
 	if ($isParagraphNode(placementNode)) placementNode.splice(0, 0, [textNode]);
-	else {
-		const target = $isRootNode(element) ? $createParagraphNode().append(textNode) : textNode;
-		if (placementNode === null) element.append(target);
-		else placementNode.insertBefore(target);
-	}
+	else if (placementNode !== null) {
+		const target = $isRootOrShadowRoot(element) ? $createParagraphNode().append(textNode) : textNode;
+		placementNode.insertBefore(target);
+	} else if ($isRootOrShadowRoot(element)) {
+		const lastChild = element.getLastChild();
+		if ($isElementNode(lastChild) && !lastChild.isInline() && lastChild.isEmpty()) lastChild.append(textNode);
+		else element.append($createParagraphNode().append(textNode));
+	} else element.append(textNode);
 	if (start.is(end)) end.set(textNode.__key, 0, "text");
 	start.set(textNode.__key, 0, "text");
 }
@@ -5585,8 +5983,9 @@ var NodeSelection = class NodeSelection {
 	insertRawText(text) {}
 	insertText() {}
 	insertNodes(nodes) {
-		const selectedNodes = this.getNodes();
+		const selectedNodes = this.getNodes().filter((node) => $getSlotHostKey(node) === null);
 		const selectedNodesLength = selectedNodes.length;
+		if (selectedNodesLength === 0) return;
 		const lastSelectedNode = selectedNodes[selectedNodesLength - 1];
 		let selectionAtEnd;
 		if ($isTextNode(lastSelectedNode)) selectionAtEnd = lastSelectedNode.select();
@@ -5621,7 +6020,7 @@ var NodeSelection = class NodeSelection {
 	* location of the first node.
 	*/
 	deleteNodes() {
-		const nodes = this.getNodes();
+		const nodes = this.getNodes().filter((node) => $getSlotHostKey(node) === null);
 		if (($getSelection() || $getPreviousSelection()) === this && nodes[0]) {
 			const firstCaret = $getSiblingCaret(nodes[0], "next");
 			$setSelectionFromCaretRange($getCaretRange(firstCaret, firstCaret));
@@ -5729,7 +6128,15 @@ var RangeSelection = class RangeSelection {
 			const node = nodes[i];
 			if ($isElementNode(node) && !node.isInline()) {
 				if (!prevWasElement) textContent += "\n";
-				if (node.isEmpty()) prevWasElement = false;
+				let slotText = "";
+				for (const slotName of $getSlotNames(node)) {
+					const slot = $getSlot(node, slotName);
+					if (slot !== null) slotText += slot.getTextContent();
+				}
+				if (slotText !== "") {
+					textContent += slotText;
+					prevWasElement = false;
+				} else if (node.isEmpty()) prevWasElement = false;
 				else prevWasElement = true;
 			} else {
 				prevWasElement = false;
@@ -5851,14 +6258,15 @@ var RangeSelection = class RangeSelection {
 			endPoint.set(firstPoint.key, endOffset, "text");
 		}
 		if (this.isCollapsed() && startOffset === firstNodeTextLength && ($isTokenOrSegmented(firstNode) || !firstNode.canInsertTextAfter() || !firstNodeParent.canInsertTextAfter() && firstNode.getNextSibling() === null)) {
-			let nextSibling = firstNode.getNextSibling();
-			if (!$isTextNode(nextSibling) || !nextSibling.canInsertTextBefore() || $isTokenOrSegmented(nextSibling)) {
+			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 !== "") {
@@ -5866,13 +6274,14 @@ var RangeSelection = class RangeSelection {
 				return;
 			}
 		} else if (this.isCollapsed() && startOffset === 0 && ($isTokenOrSegmented(firstNode) || !firstNode.canInsertTextBefore() || !firstNodeParent.canInsertTextBefore() && firstNode.getPreviousSibling() === null)) {
-			let prevSibling = firstNode.getPreviousSibling();
-			if (!$isTextNode(prevSibling) || $isTokenOrSegmented(prevSibling)) {
+			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 !== "") {
@@ -6115,11 +6524,27 @@ var RangeSelection = class RangeSelection {
 	insertNodes(nodes) {
 		if (nodes.length === 0) return;
 		if (!this.isCollapsed()) this.removeText();
-		if (this.anchor.key === "root") {
-			this.insertParagraph();
-			const selection = $getSelection();
-			if (!$isRangeSelection(selection)) formatDevErrorMessage(`Expected RangeSelection after insertParagraph`);
-			return selection.insertNodes(nodes);
+		const anchorNode = this.anchor.getNode();
+		if (this.anchor.type === "element" && $isElementNode(anchorNode) && $getSlotHostKey(anchorNode) !== null) {
+			let firstChild = anchorNode.isShadowRoot() ? anchorNode.getFirstChild() ?? anchorNode.append($createParagraphNode()).getFirstChild() : anchorNode.getFirstChild();
+			if (anchorNode.isShadowRoot() && firstChild !== null && !$isElementNode(firstChild)) {
+				const seed = $createParagraphNode();
+				firstChild.insertBefore(seed);
+				firstChild = seed;
+			}
+			if (firstChild !== null) {
+				firstChild.selectStart();
+				const redirected = $getSelection();
+				if (!$isRangeSelection(redirected)) formatDevErrorMessage(`Expected RangeSelection after redirecting into slot subtree`);
+				return redirected.insertNodes(nodes);
+			}
+		}
+		if (this.anchor.type === "element" && $isRootOrShadowRoot(anchorNode)) {
+			const blocksParent = $wrapInlineNodes(nodes);
+			const nodeToSelect = blocksParent.getLastDescendant();
+			anchorNode.splice(this.anchor.offset, 0, blocksParent.getChildren());
+			if (nodeToSelect !== null) nodeToSelect.selectEnd();
+			return;
 		}
 		const firstNode = (this.isBackward() ? this.focus : this.anchor).getNode();
 		const firstBlock = $findMatchingParent(firstNode, INTERNAL_$isBlock);
@@ -6141,6 +6566,32 @@ var RangeSelection = class RangeSelection {
 			last.selectEnd();
 			return;
 		}
+		if ($isElementNode(firstBlock) && $getSlotHostKey(firstBlock) !== null) {
+			const index = $removeTextAndSplitBlock(this);
+			const inlineNodes = $extractInlineFromBlocks(nodes);
+			firstBlock.splice(index, 0, inlineNodes);
+			const lastInserted = inlineNodes[inlineNodes.length - 1];
+			if (lastInserted !== void 0) lastInserted.selectEnd();
+			else firstBlock.select(index, index);
+			return;
+		}
+		if (firstBlock === null) {
+			const blocksParent = $wrapInlineNodes(nodes);
+			const nodeToSelect = blocksParent.getLastDescendant();
+			let caret = $caretFromPoint(this.anchor, "next");
+			for (const block of blocksParent.getChildren()) caret = $insertNodeToNearestRootAtCaret(block, caret);
+			if (nodeToSelect !== null) nodeToSelect.selectEnd();
+			return;
+		}
+		if ($isElementNode(firstBlock) && !firstBlock.isParentRequired() && !$isRootOrShadowRoot(firstBlock.getParentOrThrow())) {
+			const index = $removeTextAndSplitBlock(this);
+			const inlineNodes = $extractInlineFromBlocks(nodes);
+			firstBlock.splice(index, 0, inlineNodes);
+			const lastInserted = inlineNodes[inlineNodes.length - 1];
+			if (lastInserted !== void 0) lastInserted.selectEnd();
+			else firstBlock.select(index, index);
+			return;
+		}
 		const blocksParent = $wrapInlineNodes(nodes);
 		const nodeToSelect = blocksParent.getLastDescendant();
 		const blocks = blocksParent.getChildren();
@@ -6173,14 +6624,16 @@ var RangeSelection = class RangeSelection {
 	* @returns the newly inserted node.
 	*/
 	insertParagraph() {
-		if (this.anchor.key === "root") {
+		const anchorNode = this.anchor.getNode();
+		if (this.anchor.type === "element" && $isRootOrShadowRoot(anchorNode)) {
 			const paragraph = $createParagraphNode();
-			$getRoot().splice(this.anchor.offset, 0, [paragraph]);
+			anchorNode.splice(this.anchor.offset, 0, [paragraph]);
 			paragraph.select();
 			return paragraph;
 		}
 		const index = $removeTextAndSplitBlock(this);
 		const block = $findMatchingParent(this.anchor.getNode(), INTERNAL_$isBlock);
+		if (block !== null && $getSlotHostKey(block) !== null) return null;
 		if (!$isElementNode(block)) formatDevErrorMessage(`Expected ancestor to be a block ElementNode`);
 		const firstToAppend = block.getChildAtIndex(index);
 		const nodesToInsert = firstToAppend ? [firstToAppend, ...firstToAppend.getNextSiblings()] : [];
@@ -6289,7 +6742,8 @@ var RangeSelection = class RangeSelection {
 		}
 		moveNativeSelection(domSelection, alter, isBackward ? "backward" : "forward", granularity);
 		if (domSelection.rangeCount > 0) {
-			const range = domSelection.getRangeAt(0);
+			const composedRange = getComposedStaticRange(domSelection, editor._rootElement);
+			const range = composedRange || domSelection.getRangeAt(0);
 			const anchorNode = this.anchor.getNode();
 			const root = $isRootNode(anchorNode) ? anchorNode : $getNearestRootOrShadowRoot(anchorNode);
 			this.applyDOMRange(range);
@@ -6312,7 +6766,7 @@ var RangeSelection = class RangeSelection {
 					if ($isElementNode(lastValidNode)) lastValidNode.selectEnd();
 					else lastValidNode.getParentOrThrow().selectEnd();
 				}
-				if (domSelection.anchorNode !== range.startContainer || domSelection.anchorOffset !== range.startOffset) $swapPoints(this);
+				if (!(composedRange ? domSelection.direction !== "backward" : domSelection.anchorNode === range.startContainer && domSelection.anchorOffset === range.startOffset)) $swapPoints(this);
 			}
 		}
 		if (granularity === "lineboundary") $modifySelectionAroundDecoratorsAndBlocks(this, alter, isBackward, granularity, "decorators");
@@ -6374,7 +6828,14 @@ var RangeSelection = class RangeSelection {
 						continue;
 					} else if ($isDecoratorNode(caret.origin)) {
 						if (caret.origin.isIsolated());
-						else if (state.type === "merge-next-block" && (caret.origin.isKeyboardSelectable() || !caret.origin.isInline()) && $isElementNode(initialRange.anchor.origin) && initialRange.anchor.origin.isEmpty()) {
+						else if ($getSlotNames(caret.origin).length > 0) {
+							if ($isElementNode(initialRange.anchor.origin) && initialRange.anchor.origin.isEmpty()) {
+								initialRange.anchor.origin.remove();
+								const nodeSelection = $createNodeSelection();
+								nodeSelection.add(caret.origin.getKey());
+								$setSelection(nodeSelection);
+							}
+						} else if (state.type === "merge-next-block" && (caret.origin.isKeyboardSelectable() || !caret.origin.isInline()) && $isElementNode(initialRange.anchor.origin) && initialRange.anchor.origin.isEmpty()) {
 							initialRange.anchor.origin.remove();
 							const nodeSelection = $createNodeSelection();
 							nodeSelection.add(caret.origin.getKey());
@@ -6386,6 +6847,7 @@ var RangeSelection = class RangeSelection {
 				}
 				if (state.type === "merge-block") {
 					const { caret, block } = state;
+					if ($getSlotNames(block).length > 0) return;
 					if (caret.origin.isEmpty() && !block.isEmpty() && caret.origin.getParent() === block.getParent()) {
 						caret.origin.remove(true);
 						return;
@@ -6393,6 +6855,11 @@ var RangeSelection = class RangeSelection {
 					$updateRangeSelectionFromCaretRange(this, $getCaretRange(!caret.origin.isEmpty() && block.isEmpty() ? $rewindSiblingCaret($getSiblingCaret(block, caret.direction)) : initialRange.anchor, caret));
 					return this.removeText();
 				}
+				for (let node = anchor.getNode(); node !== null;) {
+					if ($getSlotHostKey(node) !== null) return;
+					if ($isElementNode(node) && node.isShadowRoot()) break;
+					node = node.getParent();
+				}
 			}
 			const focus = this.focus;
 			this.modify("extend", isBackward, "character");
@@ -6432,6 +6899,12 @@ var RangeSelection = class RangeSelection {
 	* @param isBackward whether or not the selection is backwards.
 	*/
 	deleteLine(isBackward) {
+		const anchorSlotFrame = $getPointSlotFrame(this.anchor);
+		if (anchorSlotFrame !== null && $isDecoratorNode($getSlotHost(anchorSlotFrame))) {
+			if (!this.isCollapsed()) this.focus.set(this.anchor.key, this.anchor.offset, this.anchor.type);
+			this.deleteCharacter(isBackward);
+			return;
+		}
 		if (this.isCollapsed()) this.modify("extend", isBackward, "lineboundary");
 		if (this.isCollapsed()) this.deleteCharacter(isBackward);
 		else this.removeText();
@@ -6654,7 +7127,7 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 			moveSelectionToEnd = true;
 			resolvedOffset = childNodesLength - 1;
 		}
-		if (getNodeKeyFromDOMNode(dom, editor) === void 0 && dom !== editor.getRootElement() && !$isSelectionCapturedInDecorator(dom)) dirty = true;
+		if (getNodeKeyFromDOMNode(dom, editor) === void 0 && !isDOMCapturingSelection(dom, editor)) dirty = true;
 		let childDOM = childNodes[resolvedOffset];
 		let hasBlockCursor = false;
 		if (childDOM === blockCursorElement) {
@@ -6697,7 +7170,9 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 					resolvedOffset = Math.min(resolvedElement.getChildrenSize(), resolvedOffset + 1);
 				}
 			} else {
-				const index = resolvedElement.getIndexWithinParent();
+				const slotHost = $getSlotHost(resolvedElement);
+				const anchorNode = slotHost !== null ? slotHost : resolvedElement;
+				const index = anchorNode.getIndexWithinParent();
 				const elementDOM = editor.getElementByKey(resolvedElement.getKey());
 				let position = "after";
 				if (elementDOM !== null && $getNodeFromDOM(dom) === resolvedElement) {
@@ -6706,7 +7181,7 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 					else if (offset === 0 && $isDecoratorNode(resolvedElement)) position = "before";
 				}
 				resolvedOffset = position === "before" ? index : index + 1;
-				resolvedElement = resolvedElement.getParentOrThrow();
+				resolvedElement = anchorNode.getParentOrThrow();
 			}
 			if ($isElementNode(resolvedElement)) return [$createPoint(resolvedElement.__key, resolvedOffset, "element"), dirty];
 		}
@@ -6746,6 +7221,74 @@ function $normalizeSelectionPointsForBoundaries(anchor, focus, lastSelection) {
 		if (isCollapsed) focus.set(anchor.key, anchor.offset, anchor.type);
 	}
 }
+function $getPointSlotFrame(point) {
+	const node = $getNodeByKey(point.key);
+	return node === null ? null : $getSlotFrame(node);
+}
+function $slotStraddleFocusAfterAnchor(anchorPoint, focusPoint, anchorFrame, focusFrame) {
+	if (anchorFrame !== null && focusFrame !== null) {
+		const anchorHost = $getSlotHost(anchorFrame);
+		const focusHost = $getSlotHost(focusFrame);
+		if (anchorHost !== null && anchorHost.is(focusHost)) {
+			for (const slotKey of $getSlotMap(anchorHost).values()) {
+				if (slotKey === anchorFrame.getKey()) return true;
+				if (slotKey === focusFrame.getKey()) return false;
+			}
+			return true;
+		}
+		return anchorHost !== null && focusHost !== null ? anchorHost.isBefore(focusHost) : true;
+	}
+	if (anchorFrame !== null) {
+		const anchorHost = $getSlotHost(anchorFrame);
+		const focusNode = $getNodeByKey(focusPoint.key);
+		if (anchorHost === null || focusNode === null) return true;
+		if (anchorHost.is(focusNode) || anchorHost.isParentOf(focusNode)) return true;
+		return anchorHost.isBefore(focusNode);
+	}
+	const focusHost = $getSlotHost(focusFrame);
+	const anchorNode = $getNodeByKey(anchorPoint.key);
+	if (focusHost === null || anchorNode === null) return false;
+	if (focusHost.is(anchorNode) || focusHost.isParentOf(anchorNode)) return false;
+	return anchorNode.isBefore(focusHost);
+}
+function $clampSelectionPointsToSlotFrame(anchorPoint, focusPoint, resolveFocusAfterAnchor) {
+	const anchorFrame = $getPointSlotFrame(anchorPoint);
+	const focusFrame = $getPointSlotFrame(focusPoint);
+	if (anchorFrame === focusFrame || anchorFrame !== null && focusFrame !== null && anchorFrame.is(focusFrame)) return false;
+	const focusAfterAnchor = resolveFocusAfterAnchor(anchorFrame, focusFrame);
+	if (anchorFrame !== null) {
+		if ($isElementNode(anchorFrame)) focusPoint.set(anchorFrame.getKey(), focusAfterAnchor ? anchorFrame.getChildrenSize() : 0, "element");
+		else focusPoint.set(anchorFrame.getKey(), focusAfterAnchor ? anchorFrame.getTextContentSize() : 0, "text");
+		return true;
+	}
+	const host = $getSlotHost(focusFrame);
+	if (host === null) return false;
+	const hostParent = host.getParent();
+	if (hostParent === null) return false;
+	const hostIndex = host.getIndexWithinParent();
+	focusPoint.set(hostParent.getKey(), focusAfterAnchor ? hostIndex + 1 : hostIndex, "element");
+	return true;
+}
+/**
+* Programmatic counterpart of the DOM-read clamp: applied when a
+* RangeSelection is committed via $setSelection so an API-built selection
+* cannot straddle a slot boundary either. Direction comes from the model
+* comparator (slots-first content order), not the caret system — a
+* straddling pair has no common ancestor through __parent, so the caret
+* comparison would throw (that integration is the deferred caret-slot work),
+* and not from the DOM either, since $setSelection also runs in headless
+* mode where there is no DOM. Marks the selection dirty when it mutates a
+* point. No-op for non-slot trees (both frames null), evaluated before any
+* direction work, so non-slot and headless callers are unaffected.
+*
+* @experimental named-slots
+* @internal
+*/
+function $clampRangeSelectionToSlotFrame(selection) {
+	const clamped = $clampSelectionPointsToSlotFrame(selection.anchor, selection.focus, (anchorFrame, focusFrame) => $slotStraddleFocusAfterAnchor(selection.anchor, selection.focus, anchorFrame, focusFrame));
+	if (clamped) selection.dirty = true;
+	return clamped;
+}
 function $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection) {
 	if (anchorDOM === null || focusDOM === null || !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) return null;
 	const resolvedAnchor = $internalResolveSelectionPoint(anchorDOM, anchorOffset, $isRangeSelection(lastSelection) ? lastSelection.anchor : null, editor);
@@ -6761,11 +7304,12 @@ function $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focu
 		const focusNode = $getNodeFromDOM(focusDOM);
 		if ($isDecoratorNode(anchorNode) && $isDecoratorNode(focusNode)) return null;
 	}
+	const slotClamped = editor._slotsUsed && $clampSelectionPointsToSlotFrame(resolvedAnchorPoint, resolvedFocusPoint, () => (anchorDOM.compareDocumentPosition(focusDOM) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0);
 	$normalizeSelectionPointsForBoundaries(resolvedAnchorPoint, resolvedFocusPoint);
 	return [
 		resolvedAnchorPoint,
 		resolvedFocusPoint,
-		anchorDirty || focusDirty
+		anchorDirty || focusDirty || slotClamped
 	];
 }
 function $isBlockElementNode(node) {
@@ -6803,10 +7347,11 @@ function $internalCreateRangeSelection(lastSelection, domSelection, editor, even
 	let anchorDOM, focusDOM, anchorOffset, focusOffset;
 	if (!$isRangeSelection(lastSelection) || useDOMSelection) {
 		if (domSelection === null) return null;
-		anchorDOM = domSelection.anchorNode;
-		focusDOM = domSelection.focusNode;
-		anchorOffset = domSelection.anchorOffset;
-		focusOffset = domSelection.focusOffset;
+		const points = getDOMSelectionPoints(domSelection, editor._rootElement);
+		anchorDOM = points.anchorNode;
+		focusDOM = points.focusNode;
+		anchorOffset = points.anchorOffset;
+		focusOffset = points.focusOffset;
 		if ((isSelectionChange || eventType === void 0) && $isRangeSelection(lastSelection) && !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) return lastSelection.clone();
 	} else return lastSelection.clone();
 	const resolvedSelectionPoints = $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection);
@@ -6989,10 +7534,17 @@ function $getElementAndOffsetForPoint(editor, node, offset) {
 }
 /** @internal */
 function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement) {
-	const activeElement = document.activeElement;
-	if (tags.has("collaboration") && activeElement !== rootElement || activeElement !== null && isSelectionCapturedInDecoratorInput(activeElement)) return;
+	const rootForActive = rootElement.getRootNode();
+	const activeElement = isDOMDocumentNode(rootForActive) || isDOMShadowRoot(rootForActive) ? getActiveElementDeep(rootForActive) : null;
+	if (tags.has("collaboration") && activeElement !== rootElement || activeElement !== null && $isSelectionCapturedInDecoratorInput(activeElement, activeElement)) return;
+	const currentPoints = getDOMSelectionPoints(domSelection, rootElement);
+	let currentRangeCache;
+	const getCurrentRange = () => {
+		if (currentRangeCache === void 0) currentRangeCache = getDOMSelectionRange(domSelection, rootElement);
+		return currentRangeCache;
+	};
 	if (!$isRangeSelection(nextSelection)) {
-		if (prevSelection !== null && isSelectionWithinEditor(editor, domSelection.anchorNode, domSelection.focusNode)) domSelection.removeAllRanges();
+		if (prevSelection !== null && isSelectionWithinEditor(editor, currentPoints.anchorNode, currentPoints.focusNode)) domSelection.removeAllRanges();
 		return;
 	}
 	const anchor = nextSelection.anchor;
@@ -7014,20 +7566,28 @@ function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
 	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 (!(domSelection.type === "Range" && isCollapsed) && domSelection.anchorOffset === nextAnchorOffset && domSelection.focusOffset === nextFocusOffset && domSelection.anchorNode === nextAnchorNode && domSelection.focusNode === nextFocusNode) {
+	if (!(domSelection.type === "Range" && isCollapsed) && currentPoints.anchorOffset === nextAnchorOffset && currentPoints.focusOffset === nextFocusOffset && currentPoints.anchorNode === nextAnchorNode && currentPoints.focusNode === nextFocusNode) {
 		if (activeElement === null || !rootElement.contains(activeElement)) {
-			if (!tags.has("skip-selection-focus")) rootElement.focus({ preventScroll: true });
+			const focusEditor = activeElement !== null ? getNearestEditorFromDOMNode(activeElement) : null;
+			if ((focusEditor === null || focusEditor === editor) && !tags.has("skip-selection-focus")) rootElement.focus({ preventScroll: true });
 		}
 		if (anchor.type !== "element") return;
 	}
 	setDOMSelectionBaseAndExtent(domSelection, nextAnchorNode, nextAnchorOffset, nextFocusNode, nextFocusOffset);
-	if (IS_FIREFOX && nextSelection.isCollapsed() && rootElement !== null && !tags.has("skip-selection-focus") && (document.activeElement === null || !rootElement.contains(document.activeElement))) rootElement.focus({ preventScroll: true });
-	if (!tags.has("skip-scroll-into-view") && nextSelection.isCollapsed() && rootElement !== null && rootElement === document.activeElement) {
-		const selectionTarget = $isRangeSelection(nextSelection) && nextSelection.anchor.type === "element" ? nextAnchorNode.childNodes[nextAnchorOffset] || null : domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null;
+	if (IS_FIREFOX && nextSelection.isCollapsed() && rootElement !== null && !tags.has("skip-selection-focus")) {
+		const focusedElement = getActiveElement(rootElement);
+		if (focusedElement === null || !rootElement.contains(focusedElement)) {
+			const deepFocusedElement = getActiveElementDeep(rootElement.ownerDocument);
+			const focusEditor = deepFocusedElement !== null ? getNearestEditorFromDOMNode(deepFocusedElement) : null;
+			if (focusEditor === null || focusEditor === editor) rootElement.focus({ preventScroll: true });
+		}
+	}
+	if (!tags.has("skip-scroll-into-view") && nextSelection.isCollapsed() && rootElement !== null && rootElement === getActiveElement(rootElement)) {
+		const selectionTarget = $isRangeSelection(nextSelection) && nextSelection.anchor.type === "element" ? nextAnchorNode.childNodes[nextAnchorOffset] || null : getCurrentRange();
 		if (selectionTarget !== null) {
 			let selectionRect;
-			if (selectionTarget instanceof Text) {
-				const range = document.createRange();
+			if (isDOMTextNode(selectionTarget)) {
+				const range = selectionTarget.ownerDocument.createRange();
 				range.selectNode(selectionTarget);
 				selectionRect = range.getBoundingClientRect();
 			} else selectionRect = selectionTarget.getBoundingClientRect();
@@ -7086,6 +7646,18 @@ function $getTextContent() {
 	if (selection === null) return "";
 	return selection.getTextContent();
 }
+function $extractInlineFromBlocks(nodes) {
+	const inlineNodes = [];
+	for (const node of nodes) {
+		if ($isLineBreakNode(node)) continue;
+		if (($isElementNode(node) || $isDecoratorNode(node)) && !node.isInline()) {
+			if ($isElementNode(node)) inlineNodes.push(...$extractInlineFromBlocks(node.getChildren()));
+			continue;
+		}
+		inlineNodes.push(node);
+	}
+	return inlineNodes;
+}
 function $removeTextAndSplitBlock(selection) {
 	let selection_ = selection;
 	if (!selection.isCollapsed()) selection_.removeText();
@@ -7095,7 +7667,7 @@ function $removeTextAndSplitBlock(selection) {
 	const anchor = selection_.anchor;
 	let node = anchor.getNode();
 	let offset = anchor.offset;
-	while (!INTERNAL_$isBlock(node)) {
+	while (!INTERNAL_$isBlock(node) && $getSlotHostKey(node) === null) {
 		const prevNode = node;
 		[node, offset] = $splitNodeAtPoint(node, offset);
 		if (prevNode.is(node)) break;
@@ -7125,19 +7697,22 @@ function $splitNodeAtPoint(node, offset) {
 	}
 	return [parent, node.getIndexWithinParent() + 1];
 }
+function $isInlineRunNode(node) {
+	return $isLineBreakNode(node) || $isInlineElementOrDecoratorNode(node) || $isTextNode(node) || node.isParentRequired();
+}
 function $wrapInlineNodes(nodes) {
 	const virtualRoot = $createParagraphNode();
 	let currentBlock = null;
 	for (let i = 0; i < nodes.length; i++) {
 		const node = nodes[i];
-		const isLineBreakNode = $isLineBreakNode(node);
-		if (isLineBreakNode || $isDecoratorNode(node) && node.isInline() || $isElementNode(node) && node.isInline() || $isTextNode(node) || node.isParentRequired()) {
+		if ($isInlineRunNode(node)) {
 			if (currentBlock === null) {
 				currentBlock = node.createParentElementNode();
 				virtualRoot.append(currentBlock);
-				if (isLineBreakNode) continue;
+				const nextNode = nodes[i + 1];
+				if ($isLineBreakNode(node) && (nextNode === void 0 || !$isInlineRunNode(nextNode))) continue;
 			}
-			if (currentBlock !== null) currentBlock.append(node);
+			currentBlock.append(node);
 		} else {
 			virtualRoot.append(node);
 			currentBlock = null;
@@ -7242,6 +7817,8 @@ let activeEditorState = null;
 let activeEditor = null;
 let isReadOnlyMode = false;
 let isAttemptingToRecoverFromReconcilerError = false;
+let isCommittingPendingUpdates = false;
+const editorsWithPendingCascadeReset = /* @__PURE__ */ new Set();
 let infiniteTransformCount = 0;
 const observerOptions = {
 	characterData: true,
@@ -7261,6 +7838,11 @@ function getActiveEditorState() {
 	if (activeEditorState === null) formatDevErrorMessage(`Unable to find an active editor state. State helpers or node methods can only be used synchronously during the callback of editor.update(), editor.read(), or editorState.read().${collectBuildInformation()}`);
 	return activeEditorState;
 }
+/** @internal */
+function $assumeActiveEditor(editor) {
+	if (getActiveEditorState() !== null && activeEditor === null) activeEditor = editor;
+	if (!(activeEditor === editor)) formatDevErrorMessage(`The given editor argument does not match $getEditor() in this context. Use editor.getEditorState().read(..., {editor}) if this cross-editor call is intentional.`);
+}
 function getActiveEditor() {
 	if (activeEditor === null) formatDevErrorMessage(`Unable to find an active editor. This method can only be used synchronously during the callback of editor.update(), editor.read(), or editor.getEditorState().read(..., {editor}).${collectBuildInformation()}`);
 	return activeEditor;
@@ -7281,7 +7863,7 @@ function collectBuildInformation() {
 	let compatibleEditors = 0;
 	const incompatibleEditors = /* @__PURE__ */ new Set();
 	const thisVersion = LexicalEditor.version;
-	if (typeof window !== "undefined") for (const node of document.querySelectorAll("[contenteditable]")) {
+	if (typeof window !== "undefined") for (const node of findAllLexicalElementsDeep(document)) {
 		const editor = getEditorPropertyFromDOMNode(node);
 		if (isLexicalEditor(editor)) compatibleEditors++;
 		else if (editor) {
@@ -7404,6 +7986,11 @@ function $parseSerializedNodeImpl(serializedNode, registeredNodes) {
 		const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, registeredNodes);
 		node.append(childNode);
 	}
+	const slots = serializedNode.$slots;
+	if (slots) {
+		if (!$isSlotHost(node)) formatDevErrorMessage(`$parseSerializedNode: node ${nodeClass.name} has slots but is not a valid slot host; only ElementNodes and DecoratorNodes can host slots.`);
+		for (const name in slots) $setSlot(node, name, $parseSerializedNodeImpl(slots[name], registeredNodes));
+	}
 	return node;
 }
 function parseEditorState(serializedEditorState, editor, updateFn) {
@@ -7429,6 +8016,7 @@ function parseEditorState(serializedEditorState, editor, updateFn) {
 		$parseSerializedNodeImpl(serializedNode, registeredNodes);
 		if (updateFn) updateFn();
 		editorState._readOnly = true;
+		editorState._parsed = true;
 		handleDEVOnlyPendingUpdateGuarantees(editorState);
 	} catch (error) {
 		if (error instanceof Error) editor._onError(error);
@@ -7471,6 +8059,15 @@ function handleDEVOnlyPendingUpdateGuarantees(pendingEditorState) {
 	};
 }
 function $commitPendingUpdates(editor, recoveryEditorState) {
+	const previouslyCommitting = isCommittingPendingUpdates;
+	isCommittingPendingUpdates = true;
+	try {
+		$commitPendingUpdatesImpl(editor, recoveryEditorState);
+	} finally {
+		isCommittingPendingUpdates = previouslyCommitting;
+	}
+}
+function $commitPendingUpdatesImpl(editor, recoveryEditorState) {
 	const pendingEditorState = editor._pendingEditorState;
 	const rootElement = editor._rootElement;
 	const shouldSkipDOM = editor._headless || rootElement === null;
@@ -7540,8 +8137,8 @@ function $commitPendingUpdates(editor, recoveryEditorState) {
 		editor._dirtyLeaves = /* @__PURE__ */ new Set();
 		editor._dirtyElements = /* @__PURE__ */ new Map();
 		editor._normalizedNodes = /* @__PURE__ */ new Set();
-		editor._updateTags = /* @__PURE__ */ new Set();
 	}
+	editor._updateTags = /* @__PURE__ */ new Set();
 	$garbageCollectDetachedDecorators(editor, pendingEditorState);
 	const domSelection = shouldSkipDOM ? null : getDOMSelection(getWindow(editor));
 	if (editor._editable && domSelection !== null && (needsUpdate || pendingSelection === null || pendingSelection.dirty || !pendingSelection.is(currentSelection)) && rootElement !== null && !tags.has("skip-dom-selection")) {
@@ -7624,6 +8221,9 @@ function triggerListeners(type, editor, isCurrentlyEnqueuingUpdates, ...payload)
 function triggerCommandListeners(editor, type, payload, fromEditor) {
 	const editors = getEditorsToPropagate(editor);
 	let updatingParentEditor;
+	if (!isCommittingPendingUpdates) {
+		for (let e = 0; e < editors.length; e++) if (!editors[e]._updating) editors[e]._cascadeCount = 0;
+	}
 	for (let i = 4; i >= 0; i--) for (let e = 0; e < editors.length; e++) {
 		const currentEditor = editors[e];
 		if (e > 0 && currentEditor._updating) {
@@ -7650,20 +8250,25 @@ function triggerCommandListeners(editor, type, payload, fromEditor) {
 	});
 	return false;
 }
+function scheduleCascadeReset(editor) {
+	if (editorsWithPendingCascadeReset.has(editor)) return;
+	editorsWithPendingCascadeReset.add(editor);
+	setTimeout(() => {
+		editorsWithPendingCascadeReset.delete(editor);
+		editor._cascadeCount = 0;
+	}, 0);
+}
 function $triggerEnqueuedUpdates(editor) {
 	const queuedUpdates = editor._updates;
 	if (queuedUpdates.length === 0) {
 		editor._cascadeCount = 0;
 		return;
 	}
+	scheduleCascadeReset(editor);
 	if (editor._cascadeCount++ > 99) {
 		editor._updates = [];
 		editor._cascadeCount = 0;
-		try {
-			formatDevErrorMessage(`One or more update listeners are endlessly enqueueing more updates. May have encountered infinite recursion caused by update listeners that trigger additional updates without a stop condition.`);
-		} catch (error) {
-			if (error instanceof Error) editor._onError(error);
-		}
+		editor._onWarn(/* @__PURE__ */ new Error(`One or more update listeners are endlessly enqueueing more updates. May have encountered infinite recursion caused by update listeners that trigger additional updates without a stop condition. Editor namespace: ${editor._config.namespace}`));
 		return;
 	}
 	const queuedUpdate = queuedUpdates.shift();
@@ -7756,6 +8361,7 @@ function $beginUpdate(editor, updateFn, options) {
 		if (startingCompositionKey !== editor._compositionKey) pendingEditorState._flushSync = true;
 		const pendingSelection = pendingEditorState._selection;
 		if ($isRangeSelection(pendingSelection)) {
+			if (editor._slotsUsed) $clampRangeSelectionToSlotFrame(pendingSelection);
 			const pendingNodeMap = pendingEditorState._nodeMap;
 			const anchorKey = pendingSelection.anchor.key;
 			const focusKey = pendingSelection.focus.key;
@@ -7808,6 +8414,26 @@ function updateEditor(editor, updateFn, options) {
 	if (editor._updating) editor._updates.push([updateFn, options]);
 	else $beginUpdate(editor, updateFn, options);
 }
+/**
+* Wrap any shadow-root child of `node` that is neither an ElementNode nor a
+* DecoratorNode in a paragraph, so the slot-frame invariant set by
+* `getTopLevelElement` continues to hold for external inputs (URL doc
+* payloads, imported JSON, paste round-trips) that may carry shapes the
+* in-editor mutation paths can no longer produce.
+*
+* Single-node helper: runs as the `$config` `$transform` on ElementNode so
+* the existing dirty-node transform cycle drives the normalization. The
+* in-editor mutation paths (insertText, insertNodes, append/splice via the
+* public API) still fail-fast on the invariant.
+*
+* @internal
+*/
+function $normalizeShadowRootChildren(node) {
+	if ($isRootOrShadowRoot(node)) {
+		let block = null;
+		for (const child of node.getChildren()) block = child.isInline() ? (block || child.replace(child.createParentElementNode())).append(child) : null;
+	}
+}
 /** @noInheritDoc */
 var ElementNode = class extends LexicalNode {
 	/** @internal */
@@ -7829,6 +8455,16 @@ var ElementNode = class extends LexicalNode {
 	__textFormat;
 	/** @internal */
 	__textStyle;
+	/** @internal */
+	__slotHost;
+	/** @internal */
+	__slots;
+	$config() {
+		return this.config(Symbol.for("ElementNode"), {
+			$transform: $normalizeShadowRootChildren,
+			extends: LexicalNode
+		});
+	}
 	constructor(key) {
 		super(key);
 		this.__first = null;
@@ -7840,6 +8476,8 @@ var ElementNode = class extends LexicalNode {
 		this.__dir = null;
 		this.__textFormat = 0;
 		this.__textStyle = "";
+		this.__slotHost = null;
+		this.__slots = null;
 	}
 	afterCloneFrom(prevNode) {
 		super.afterCloneFrom(prevNode);
@@ -7847,6 +8485,9 @@ var ElementNode = class extends LexicalNode {
 			this.__first = prevNode.__first;
 			this.__last = prevNode.__last;
 			this.__size = prevNode.__size;
+			this.__slotHost = prevNode.__slotHost;
+			if (!(this.__slotHost === null || this.__parent === null)) formatDevErrorMessage(`ElementNode: node ${this.__key} is both slotted into host ${String(this.__slotHost)} and a child of parent ${String(this.__parent)}; __slotHost and __parent are mutually exclusive`);
+			this.__slots = prevNode.__slots;
 		}
 		this.__indent = prevNode.__indent;
 		this.__format = prevNode.__format;
@@ -7867,6 +8508,15 @@ var ElementNode = class extends LexicalNode {
 	getIndent() {
 		return this.getLatest().__indent;
 	}
+	/**
+	* Returns the children of this node, in document order.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getChildren() as T[]`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the results with a type guard instead.
+	*/
 	getChildren() {
 		const children = [];
 		let child = this.getFirstChild();
@@ -7889,7 +8539,7 @@ var ElementNode = class extends LexicalNode {
 		return this.getLatest().__size;
 	}
 	isEmpty() {
-		return this.getChildrenSize() === 0;
+		return this.getChildrenSize() === 0 && $getSlotNames(this).length === 0;
 	}
 	isDirty() {
 		const dirtyElements = getActiveEditor()._dirtyElements;
@@ -7902,6 +8552,10 @@ var ElementNode = class extends LexicalNode {
 	}
 	getAllTextNodes() {
 		const textNodes = [];
+		for (const name of $getSlotNames(this)) {
+			const slot = $getSlot(this, name);
+			if ($isElementNode(slot)) textNodes.push(...slot.getAllTextNodes());
+		}
 		let child = this.getFirstChild();
 		while (child !== null) {
 			if ($isTextNode(child)) textNodes.push(child);
@@ -7913,6 +8567,19 @@ var ElementNode = class extends LexicalNode {
 		}
 		return textNodes;
 	}
+	/**
+	* Returns the deepest first descendant of this node,
+	* or null if it has no children.
+	*
+	* Descendant navigation is children-only by design: it feeds selectStart /
+	* selectEnd and selection, which must not see slots (slots are isolated).
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getFirstDescendant() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getFirstDescendant() {
 		let node = this.getFirstChild();
 		while ($isElementNode(node)) {
@@ -7922,6 +8589,16 @@ var ElementNode = class extends LexicalNode {
 		}
 		return node;
 	}
+	/**
+	* Returns the deepest last descendant of this node,
+	* or null if it has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getLastDescendant() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getLastDescendant() {
 		let node = this.getLastChild();
 		while ($isElementNode(node)) {
@@ -7931,6 +8608,16 @@ var ElementNode = class extends LexicalNode {
 		}
 		return node;
 	}
+	/**
+	* Returns the deepest descendant corresponding to the child at the given
+	* index, or null if this node has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getDescendantByIndex(index) as T | null`, and
+	* will be removed in a future release. Call this method without a type
+	* argument and narrow the result with a type guard instead.
+	*/
 	getDescendantByIndex(index) {
 		const children = this.getChildren();
 		const childrenLength = children.length;
@@ -7941,24 +8628,70 @@ var ElementNode = class extends LexicalNode {
 		const resolvedNode = children[index];
 		return $isElementNode(resolvedNode) && resolvedNode.getFirstDescendant() || resolvedNode || null;
 	}
+	/**
+	* Returns the first child of this node, or null if it has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getFirstChild() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getFirstChild() {
 		const firstKey = this.getLatest().__first;
 		return firstKey === null ? null : $getNodeByKey(firstKey);
 	}
+	/**
+	* Returns the first child of this node, or throws if it has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getFirstChildOrThrow() as T`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getFirstChildOrThrow() {
 		const firstChild = this.getFirstChild();
 		if (firstChild === null) formatDevErrorMessage(`Expected node ${this.__key} to have a first child.`);
 		return firstChild;
 	}
+	/**
+	* Returns the last child of this node, or null if it has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getLastChild() as T | null`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getLastChild() {
 		const lastKey = this.getLatest().__last;
 		return lastKey === null ? null : $getNodeByKey(lastKey);
 	}
+	/**
+	* Returns the last child of this node, or throws if it has no children.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getLastChildOrThrow() as T`, and will be
+	* removed in a future release. Call this method without a type argument
+	* and narrow the result with a type guard instead.
+	*/
 	getLastChildOrThrow() {
 		const lastChild = this.getLastChild();
 		if (lastChild === null) formatDevErrorMessage(`Expected node ${this.__key} to have a last child.`);
 		return lastChild;
 	}
+	/**
+	* Returns the child of this node at the given index, or null if
+	* the index is out of range.
+	*/
+	/**
+	* @deprecated The type parameter is an unchecked and unsafe cast,
+	* equivalent to `element.getChildAtIndex(index) as T | null`, and will
+	* be removed in a future release. Call this method without a type
+	* argument and narrow the result with a type guard instead.
+	*/
 	getChildAtIndex(index) {
 		const size = this.getChildrenSize();
 		let node;
@@ -7983,7 +8716,7 @@ var ElementNode = class extends LexicalNode {
 		return null;
 	}
 	getTextContent() {
-		let textContent = "";
+		let textContent = $getSlotsTextContent(this);
 		const children = this.getChildren();
 		const childrenLength = children.length;
 		for (let i = 0; i < childrenLength; i++) {
@@ -7994,7 +8727,7 @@ var ElementNode = class extends LexicalNode {
 		return textContent;
 	}
 	getTextContentSize() {
-		let textContentSize = 0;
+		let textContentSize = $getSlotsTextContentSize(this);
 		const children = this.getChildren();
 		const childrenLength = children.length;
 		for (let i = 0; i < childrenLength; i++) {
@@ -8110,6 +8843,7 @@ var ElementNode = class extends LexicalNode {
 		const oldSize = this.getChildrenSize();
 		const writableSelf = this.getWritable();
 		if (!(start + deleteCount <= oldSize)) formatDevErrorMessage(`ElementNode.splice: start + deleteCount > oldSize (${String(start)} + ${String(deleteCount)} > ${String(oldSize)})`);
+		for (const nodeToInsert of nodesToInsert) $errorOnSlotCycleChild(writableSelf, nodeToInsert);
 		const writableSelfKey = writableSelf.__key;
 		const nodesToInsertKeys = [];
 		const nodesToRemoveKeys = [];
@@ -8127,7 +8861,7 @@ var ElementNode = class extends LexicalNode {
 				if (nodeToDelete === null) formatDevErrorMessage(`splice: sibling not found`);
 				const nextSibling = nodeToDelete.getNextSibling();
 				const nodeKeyToDelete = nodeToDelete.__key;
-				removeFromParent(nodeToDelete.getWritable());
+				$removeFromParent(nodeToDelete.getWritable());
 				nodesToRemoveKeys.push(nodeKeyToDelete);
 				nodeToDelete = nextSibling;
 			}
@@ -8137,7 +8871,7 @@ var ElementNode = class extends LexicalNode {
 			if (prevNode !== null && nodeToInsert.is(prevNode)) nodeBeforeRange = prevNode = prevNode.getPreviousSibling();
 			const writableNodeToInsert = nodeToInsert.getWritable();
 			if (writableNodeToInsert.__parent === writableSelfKey) newSize--;
-			removeFromParent(writableNodeToInsert);
+			$removeFromParent(writableNodeToInsert);
 			const nodeKeyToInsert = nodeToInsert.__key;
 			if (prevNode === null) {
 				writableSelf.__first = nodeKeyToInsert;
@@ -8312,16 +9046,26 @@ function isPointRemoved(point, nodesToRemoveKeySet, nodesToInsertKeySet) {
 	}
 	return false;
 }
-/**
-* 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.
-*
-*/
 /** @noInheritDoc */
 var DecoratorNode = class extends LexicalNode {
 	/** @internal */
+	/** @internal */
+	__slotHost;
+	/** @internal */
+	__slots;
+	constructor(key) {
+		super(key);
+		this.__slotHost = null;
+		this.__slots = null;
+	}
+	afterCloneFrom(prevNode) {
+		super.afterCloneFrom(prevNode);
+		if (this.__key === prevNode.__key) {
+			this.__slotHost = prevNode.__slotHost;
+			if (!(this.__slotHost === null || this.__parent === null)) formatDevErrorMessage(`DecoratorNode: node ${this.__key} is both slotted into host ${String(this.__slotHost)} and a child of parent ${String(this.__parent)}; __slotHost and __parent are mutually exclusive`);
+			this.__slots = prevNode.__slots;
+		}
+	}
 	/**
 	* The returned value is added to the LexicalEditor._decorators
 	*/
@@ -8403,12 +9147,12 @@ function editorStateHasDirtySelection(editorState, editor) {
 	return false;
 }
 function cloneEditorState(current) {
-	return new EditorState(cloneMap(current._nodeMap));
+	return new EditorState(cloneMap(current._nodeMap), null, current._slotsUsed);
 }
 function createEmptyEditorState() {
-	return new EditorState(new Map([["root", $createRootNode()]]));
+	return new EditorState(new Map([["root", $createRootNode()]]), null, false);
 }
-function exportNodeToJSON(node) {
+function $exportNodeToJSON(node) {
 	const serializedNode = node.exportJSON();
 	const nodeClass = node.constructor;
 	if (serializedNode.type !== nodeClass.getType()) formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
@@ -8418,10 +9162,20 @@ function exportNodeToJSON(node) {
 		const children = node.getChildren();
 		for (let i = 0; i < children.length; i++) {
 			const child = children[i];
-			const serializedChildNode = exportNodeToJSON(child);
+			const serializedChildNode = $exportNodeToJSON(child);
 			serializedChildren.push(serializedChildNode);
 		}
 	}
+	const slotNames = $getSlotNames(node);
+	if (slotNames.length > 0) {
+		const serializedSlots = {};
+		for (const name of slotNames) {
+			const slotNode = $getSlot(node, name);
+			if (!(slotNode !== null)) formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} has slot "${name}" but it resolved to no node during export.`);
+			serializedSlots[name] = $exportNodeToJSON(slotNode);
+		}
+		serializedNode.$slots = serializedSlots;
+	}
 	return serializedNode;
 }
 /**
@@ -8435,11 +9189,22 @@ var EditorState = class EditorState {
 	_selection;
 	_flushSync;
 	_readOnly;
-	constructor(nodeMap, selection) {
+	/**
+	* True if this EditorState was parsed without running transforms
+	*/
+	_parsed;
+	/**
+	* True if this EditorState or the LexicalEditor that created it has
+	* ever used slots
+	*/
+	_slotsUsed;
+	constructor(nodeMap, selection = null, slotsUsed = false) {
 		this._nodeMap = nodeMap;
 		this._selection = selection || null;
 		this._flushSync = false;
 		this._readOnly = false;
+		this._parsed = false;
+		this._slotsUsed = slotsUsed;
 	}
 	isEmpty() {
 		return this._nodeMap.size === 1 && this._selection === null;
@@ -8448,12 +9213,12 @@ var EditorState = class EditorState {
 		return readEditorState(options && options.editor || null, this, callbackFn);
 	}
 	clone(selection) {
-		const editorState = new EditorState(this._nodeMap, selection === void 0 ? this._selection : selection);
+		const editorState = new EditorState(this._nodeMap, selection === void 0 ? this._selection : selection, this._slotsUsed);
 		editorState._readOnly = true;
 		return editorState;
 	}
 	toJSON() {
-		return readEditorState(null, this, () => ({ root: exportNodeToJSON($getRoot()) }));
+		return readEditorState(null, this, () => ({ root: $exportNodeToJSON($getRoot()) }));
 	}
 };
 /**
@@ -8480,6 +9245,99 @@ var ArtificialNode__DO_NOT_USE = class extends ElementNode {
 *
 */
 /** @noInheritDoc */
+var LineBreakNode = class LineBreakNode extends LexicalNode {
+	/** @internal */
+	static getType() {
+		return "linebreak";
+	}
+	static clone(node) {
+		return new LineBreakNode(node.__key);
+	}
+	constructor(key) {
+		super(key);
+	}
+	getTextContent() {
+		return "\n";
+	}
+	createDOM() {
+		return document.createElement("br");
+	}
+	updateDOM() {
+		return false;
+	}
+	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() };
+}
+function $createLineBreakNode() {
+	return $applyNodeReplacement(new LineBreakNode());
+}
+function $isLineBreakNode(node) {
+	return node instanceof LineBreakNode;
+}
+/**
+* True when `node` is the sole non-whitespace child of a block DOM
+* element. Used by the LineBreak importer to drop stray `<br>` elements
+* that the legacy `$generateNodesFromDOM` also skipped (matches the
+* behavior of `LineBreakNode.importDOM`).
+*
+* @experimental
+*/
+function isOnlyChildInBlockNode(node) {
+	const parentElement = node.parentElement;
+	if (parentElement !== null && isBlockDomNode(parentElement)) {
+		const firstChild = parentElement.firstChild;
+		if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) {
+			const lastChild = parentElement.lastChild;
+			if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) return true;
+		}
+	}
+	return false;
+}
+/**
+* True when `node` is the trailing non-whitespace child of a block DOM
+* element (excluding the only-child case). Used by the LineBreak
+* importer to drop trailing `<br>` elements like the Apple-interchange
+* clipboard artifact (matches `LineBreakNode.importDOM`).
+*
+* @experimental
+*/
+function isLastChildInBlockNode(node) {
+	const parentElement = node.parentElement;
+	if (parentElement !== null && isBlockDomNode(parentElement)) {
+		const firstChild = parentElement.firstChild;
+		if (firstChild === node || firstChild.nextSibling === node && isWhitespaceDomTextNode(firstChild)) return false;
+		const lastChild = parentElement.lastChild;
+		if (lastChild === node || lastChild.previousSibling === node && isWhitespaceDomTextNode(lastChild)) return true;
+	}
+	return false;
+}
+function isWhitespaceDomTextNode(node) {
+	return isDOMTextNode(node) && /^( |\t|\r?\n)+$/.test(node.textContent || "");
+}
+/**
+* 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.
+*
+*/
+/** @noInheritDoc */
 var ParagraphNode = class ParagraphNode extends ElementNode {
 	/** @internal */
 	static getType() {
@@ -8577,6 +9435,20 @@ function $isParagraphNode(node) {
 	return node instanceof ParagraphNode;
 }
 /**
+* Controls which editor state {@link LexicalEditor.read} observes and whether
+* pending updates are flushed before the read.
+*
+* - `'force-commit'` (the default) flushes any pending updates immediately
+*   before the read, so it always observes a fully committed and reconciled
+*   state.
+* - `'pending'` reads the pending state if it exists, otherwise the committed
+*   state, without flushing. This is safe to call when an update may already
+*   be in progress at the cost of possibly observing an uncommitted state
+*   before node transforms, DOM reconciliation, etc. have run.
+* - `'latest'` reads the latest committed state without flushing pending
+*   updates, equivalent to `editor.getEditorState().read(callbackFn, {editor})`.
+*/
+/**
 * Configuration entry passed in {@link CreateEditorArgs.nodes} to substitute
 * a core node class with a custom subclass. The replacement class itself
 * must also appear in `nodes`.
@@ -8596,6 +9468,17 @@ function $isParagraphNode(node) {
 * without manual `instanceof` checks.
 */
 /** @internal @experimental */
+/**
+* Default {@link CreateEditorArgs.onWarn} handler. Used for recoverable,
+* warn-level conditions (e.g. the update-recursion guard tripping) that the
+* editor has already recovered from. Throws in development so the condition is
+* impossible to miss, and only `console.warn`s in production so it is not
+* reported as a fatal error. Embedders can override this via `onWarn` to route
+* the condition to their own telemetry at warn severity.
+*/
+function defaultOnWarn(error) {
+	throw error;
+}
 const DEFAULT_SKIP_INITIALIZATION = false;
 /**
 * The payload passed to an UpdateListener
@@ -8707,10 +9590,14 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
 		observer.disconnect();
 		editor._observer = null;
 	}
-	if (prevRootElement !== null) prevRootElement.textContent = "";
+	if (prevRootElement !== null) {
+		prevRootElement.textContent = "";
+		clearNodeKeyOnDOMNode(prevRootElement, editor);
+	}
 	if (nextRootElement !== null) {
 		nextRootElement.textContent = "";
 		keyNodeMap.set("root", nextRootElement);
+		setNodeKeyOnDOMNode(nextRootElement, editor, "root");
 	}
 }
 function initializeConversionCache(nodes, additionalConversions) {
@@ -8740,9 +9627,7 @@ function initializeConversionCache(nodes, additionalConversions) {
 function getTransformSetFromKlass(klass) {
 	const transforms = /* @__PURE__ */ new Set();
 	const staticTransforms = /* @__PURE__ */ new Set();
-	let currentKlass = klass;
-	while (currentKlass) {
-		const { ownNodeConfig } = getStaticNodeConfig(currentKlass);
+	for (const { klass: currentKlass, ownNodeConfig } of iterStaticNodeConfigChain(klass)) {
 		const staticTransform = currentKlass.transform;
 		if (!staticTransforms.has(staticTransform)) {
 			staticTransforms.add(staticTransform);
@@ -8752,10 +9637,6 @@ function getTransformSetFromKlass(klass) {
 		if (ownNodeConfig) {
 			const $transform = ownNodeConfig.$transform;
 			if ($transform) transforms.add($transform);
-			currentKlass = ownNodeConfig.extends;
-		} else {
-			const parent = Object.getPrototypeOf(currentKlass);
-			currentKlass = parent.prototype instanceof LexicalNode && parent !== LexicalNode ? parent : void 0;
 		}
 	}
 	return transforms;
@@ -8770,6 +9651,7 @@ const DEFAULT_EDITOR_DOM_CONFIG = {
 	},
 	$extractWithChild: (node, childNode, selection, destination, _editor) => $isElementNode(node) && node.extractWithChild(childNode, selection, destination),
 	$getDOMSlot: (node, dom, _editor) => node.getDOMSlot(dom),
+	$getSlotTargetElement: (_node, _slotName, _hostDom, _editor) => null,
 	$shouldExclude: (node, _selection, _editor) => $isElementNode(node) && node.excludeFromCopy("html"),
 	$shouldInclude: (node, selection, _editor) => selection ? node.isSelected(selection) : true,
 	$updateDOM: (nextNode, prevNode, dom, editor) => nextNode.updateDOM(prevNode, dom, editor._config)
@@ -8799,7 +9681,7 @@ function createEditor(editorConfig) {
 		ArtificialNode__DO_NOT_USE,
 		...config.nodes || []
 	];
-	const { onError, html } = config;
+	const { onError, onWarn, html } = config;
 	const isEditable = config.editable !== void 0 ? config.editable : true;
 	let registeredNodes;
 	if (editorConfig === void 0 && activeEditor !== null) registeredNodes = activeEditor._nodes;
@@ -8809,12 +9691,19 @@ function createEditor(editorConfig) {
 			let klass = nodes[i];
 			let replace = null;
 			let replaceWithKlass = null;
-			if (typeof klass !== "function") {
+			if (klass && typeof klass === "object") {
 				const options = klass;
 				klass = options.replace;
 				replace = options.with;
 				replaceWithKlass = options.withKlass || null;
 			}
+			if (typeof klass !== "function" || !klass.prototype || !(klass === LexicalNode || klass.prototype instanceof LexicalNode)) {
+				let version = "<unknown>";
+				try {
+					version = JSON.parse(LEXICAL_VERSION);
+				} catch (_unused) {}
+				formatDevErrorMessage(`createEditor: nodes[${String(i - nodes.length + (config.nodes ? config.nodes.length : 0))}] ${typeof klass === "function" ? `${klass.name}${typeof klass.getType === "function" ? ` (type ${String(klass.getType())})` : ""}` : String(klass)} is not a constructor that subclasses LexicalNode from the lexical package used by this editor (${String(version)})`);
+			}
 			getStaticNodeConfig(klass);
 			{
 				const name = klass.name;
@@ -8826,7 +9715,6 @@ function createEditor(editorConfig) {
 					["getType", "clone"].forEach((method) => {
 						if (!hasOwnStaticMethod(klass, method)) console.warn(`${name} must implement static "${method}" method`);
 					});
-					if (!hasOwnStaticMethod(klass, "importDOM") && hasOwnExportDOM(klass)) console.warn(`${name} should implement "importDOM" if using a custom "exportDOM" method to ensure HTML serialization (important for copy & paste) works as expected`);
 					if (!hasOwnStaticMethod(klass, "importJSON")) console.warn(`${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`);
 				}
 			}
@@ -8850,7 +9738,7 @@ function createEditor(editorConfig) {
 		},
 		namespace,
 		theme
-	}, onError ? onError : console.error, initializeConversionCache(registeredNodes, html ? html.import : void 0), isEditable, editorConfig);
+	}, onError ? onError : console.error, onWarn ? onWarn : defaultOnWarn, initializeConversionCache(registeredNodes, html ? html.import : void 0), isEditable, editorConfig);
 	if (initialEditorState !== void 0) {
 		editor._pendingEditorState = initialEditorState;
 		editor._dirtyType = FULL_RECONCILE;
@@ -8929,6 +9817,8 @@ var LexicalEditor = class {
 	/** @internal */
 	_onError;
 	/** @internal */
+	_onWarn;
+	/** @internal */
 	_htmlConversions;
 	/** @internal */
 	_window;
@@ -8936,10 +9826,21 @@ var LexicalEditor = class {
 	_editable;
 	/** @internal */
 	_blockCursorElement;
+	/**
+	* @internal @experimental
+	*
+	* Latches to `true` the first time {@link $setSlot} runs in this
+	* editor. Gates the commit-time slot-containment clamp so editors that never
+	* use slots skip the per-update frame walk entirely. The latch persists for
+	* the lifetime of the editor instance — `resetEditor` and `setEditorState`
+	* do not clear it, so an editor that once used slots keeps paying the clamp
+	* cost even after switching to a slot-free state.
+	*/
+	_slotsUsed;
 	/** @internal */
 	_createEditorArgs;
 	/** @internal */
-	constructor(editorState, parentEditor, nodes, config, onError, htmlConversions, editable, createEditorArgs) {
+	constructor(editorState, parentEditor, nodes, config, onError, onWarn, htmlConversions, editable, createEditorArgs) {
 		this._createEditorArgs = createEditorArgs;
 		this._parentEditor = parentEditor;
 		this._rootElement = null;
@@ -8973,11 +9874,13 @@ var LexicalEditor = class {
 		this._observer = null;
 		this._key = createUID();
 		this._onError = onError;
+		this._onWarn = onWarn;
 		this._htmlConversions = htmlConversions;
 		this._editable = editable;
 		this._headless = parentEditor !== null && parentEditor._headless;
 		this._window = null;
 		this._blockCursorElement = null;
+		this._slotsUsed = false;
 	}
 	/**
 	*
@@ -9265,7 +10168,7 @@ var LexicalEditor = class {
 				if (!this._config.disableEvents) addRootElementEvents(nextRootElement, this);
 				if (classNames != null) nextRootElement.classList.add(...classNames);
 				{
-					const nextRootElementParent = nextRootElement.parentElement;
+					const nextRootElementParent = getParentElement(nextRootElement);
 					if (nextRootElementParent != null && ["flex", "inline-flex"].includes(getComputedStyle(nextRootElementParent).display)) console.warn(`When using "display: flex" or "display: inline-flex" on an element containing content editable, Chrome may have unwanted focusing behavior when clicking outside of it. Consider wrapping the content editable within a non-flex element.`);
 				}
 			} else {
@@ -9305,18 +10208,21 @@ var LexicalEditor = class {
 		}
 		flushRootMutations(this);
 		const pendingEditorState = this._pendingEditorState;
-		const tags = this._updateTags;
 		const tag = options !== void 0 ? options.tag : null;
 		if (pendingEditorState !== null && !pendingEditorState.isEmpty()) {
-			if (tag != null) tags.add(tag);
+			if (tag != null) this._updateTags.add(tag);
 			$commitPendingUpdates(this);
 		}
 		this._pendingEditorState = writableEditorState;
 		this._dirtyType = FULL_RECONCILE;
 		this._dirtyElements.set("root", false);
 		this._compositionKey = null;
-		if (tag != null) tags.add(tag);
-		if (!this._updating) $commitPendingUpdates(this);
+		this._slotsUsed = this._slotsUsed || editorState._slotsUsed;
+		updateEditorSync(this, () => {
+			if (tag) this._updateTags.add(tag);
+			if (editorState._parsed) for (const [key, node] of writableEditorState._nodeMap.entries()) if ($isElementNode(node)) this._dirtyElements.set(key, true);
+			else this._dirtyLeaves.add(key);
+		}, { discrete: this._updating ? void 0 : true });
 	}
 	/**
 	* Parses a SerializedEditorState (usually produced by {@link EditorState.toJSON}) and returns
@@ -9333,13 +10239,25 @@ var LexicalEditor = class {
 	* Executes a read of the editor's state, with the
 	* editor context available (useful for exporting and read-only DOM
 	* operations). Much like update, but prevents any mutation of the
-	* editor's state. Any pending updates will be flushed immediately before
-	* the read.
+	* editor's state.
+	*
+	* When called with a single argument the `mode` defaults to
+	* `'force-commit'`, which flushes any pending updates immediately before the
+	* read so it always observes a fully committed and reconciled state. See
+	* {@link EditorReadMode} for the behavior of the other modes (`'pending'`
+	* and `'latest'`).
 	* @param callbackFn - A function that has access to read-only editor state.
 	*/
-	read(callbackFn) {
-		$commitPendingUpdates(this);
-		return this.getEditorState().read(callbackFn, { editor: this });
+	/**
+	* Executes a read of the editor's state in the given `mode`, with the editor
+	* context available. See {@link EditorReadMode} for the available modes.
+	* @param mode - Which editor state to read and whether to flush first.
+	* @param callbackFn - A function that has access to read-only editor state.
+	*/
+	read(...args) {
+		const [mode, callbackFn] = args.length === 1 ? ["force-commit", args[0]] : args;
+		if (mode === "force-commit") $commitPendingUpdates(this);
+		return (mode === "pending" ? this._pendingEditorState || this._editorState : this.getEditorState()).read(callbackFn, { editor: this });
 	}
 	/**
 	* Executes an update to the editor state. The updateFn callback is the ONLY place
@@ -9404,6 +10322,7 @@ var LexicalEditor = class {
 		if (this._editable !== editable) {
 			this._editable = editable;
 			triggerListeners("editable", this, true, editable);
+			if (this._slotsUsed) this.update(() => $fullReconcile());
 		}
 	}
 	/**
@@ -9454,22 +10373,28 @@ function getRegisteredNode(editor, nodeType) {
 const scheduleMicroTask = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => {
 	Promise.resolve().then(fn);
 };
-function $isSelectionCapturedInDecorator(node) {
-	return $isDecoratorNode($getNearestNodeFromDOMNode(node));
-}
-function isSelectionCapturedInDecoratorInput(anchorDOM) {
-	const activeElement = document.activeElement;
+function $isSelectionCapturedInDecoratorInput(anchorDOM, preResolvedActiveElement) {
+	const activeElement = preResolvedActiveElement !== void 0 ? preResolvedActiveElement : (() => {
+		const root = anchorDOM.getRootNode();
+		return isDOMDocumentNode(root) || isDOMShadowRoot(root) ? getActiveElementDeep(root) : null;
+	})();
 	if (!isHTMLElement(activeElement)) return false;
+	if (activeElement.hasAttribute("data-lexical-slot")) return false;
+	const nearestNode = $getNearestNodeFromDOMNode(activeElement);
 	const nodeName = activeElement.nodeName;
-	return $isDecoratorNode($getNearestNodeFromDOMNode(anchorDOM)) && (nodeName === "INPUT" || nodeName === "TEXTAREA" || activeElement.contentEditable === "true" && getEditorPropertyFromDOMNode(activeElement) == null);
+	return $isLexicalNode(nearestNode) && (nodeName === "INPUT" || nodeName === "TEXTAREA" || activeElement.contentEditable === "true" && getEditorPropertyFromDOMNode(activeElement) == null);
 }
+/** @deprecated renamed to {@link $isSelectionCapturedInDecoratorInput} by @lexical/eslint-plugin rules-of-lexical */
+const isSelectionCapturedInDecoratorInput = $isSelectionCapturedInDecoratorInput;
 function isSelectionWithinEditor(editor, anchorDOM, focusDOM) {
 	const rootElement = editor.getRootElement();
+	if (!rootElement) return false;
 	try {
-		return rootElement !== null && rootElement.contains(anchorDOM) && rootElement.contains(focusDOM) && anchorDOM !== null && !isSelectionCapturedInDecoratorInput(anchorDOM) && getNearestEditorFromDOMNode(anchorDOM) === editor;
+		if (!anchorDOM || !rootElement.contains(anchorDOM) || !rootElement.contains(focusDOM)) return false;
 	} catch (_error) {
 		return false;
 	}
+	return getNearestEditorFromDOMNode(anchorDOM) === editor && editor.read("latest", () => !$isSelectionCapturedInDecoratorInput(anchorDOM));
 }
 /**
 * @returns true if the given argument is a LexicalEditor instance from this build of Lexical
@@ -9587,7 +10512,7 @@ function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
 		const node = nodeMap.get(nextParentKey);
 		if (node === void 0) break;
 		dirtyElements.set(nextParentKey, false);
-		nextParentKey = node.__parent;
+		nextParentKey = node.__parent !== null ? node.__parent : $isSlotChild(node) ? node.__slotHost : null;
 	}
 }
 /**
@@ -9603,7 +10528,8 @@ function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
 * This function is for internal use of the library.
 * Please do not use it as it may change in the future.
 */
-function removeFromParent(node) {
+function $removeFromParent(node) {
+	if (!($getSlotHostKey(node) === null)) formatDevErrorMessage(`$removeFromParent: node ${node.__key} is slotted into host ${String($getSlotHostKey(node))}; a slotted node and a child are mutually exclusive. Remove it from its slot first.`);
 	const oldParent = node.getParent();
 	if (oldParent !== null) {
 		const writableNode = node.getWritable();
@@ -9624,11 +10550,13 @@ function removeFromParent(node) {
 		writableParent.__size--;
 	}
 }
+/** @deprecated renamed to {@link $removeFromParent} by @lexical/eslint-plugin rules-of-lexical */
+const removeFromParent = $removeFromParent;
 function internalMarkNodeAsDirty(node) {
 	errorOnInfiniteTransforms();
 	if (!!$isEphemeral(node)) formatDevErrorMessage(`internalMarkNodeAsDirty: Ephemeral nodes must not be marked as dirty (key ${node.__key} type ${node.__type})`);
 	const latest = node.getLatest();
-	const parent = latest.__parent;
+	const parent = latest.__parent !== null ? latest.__parent : $isSlotChild(latest) ? latest.__slotHost : null;
 	const editorState = getActiveEditorState();
 	const editor = getActiveEditor();
 	const nodeMap = editorState._nodeMap;
@@ -9665,6 +10593,16 @@ function $getCompositionKey() {
 	if (isCurrentlyReadOnlyMode()) return null;
 	return getActiveEditor()._compositionKey;
 }
+/**
+* Returns the node with the given key from the active EditorState
+* (or the given EditorState), or null if it does not exist.
+*/
+/**
+* @deprecated The type parameter is an unchecked and unsafe cast,
+* equivalent to `$getNodeByKey(key) as T | null`, and will be removed
+* in a future release. Call this function without a type argument and
+* narrow the result with a type guard instead.
+*/
 function $getNodeByKey(key, _editorState) {
 	const node = (_editorState || getActiveEditorState())._nodeMap.get(key);
 	if (node === void 0) return null;
@@ -9679,6 +10617,10 @@ function setNodeKeyOnDOMNode(dom, editor, key) {
 	const prop = `__lexicalKey_${editor._key}`;
 	dom[prop] = key;
 }
+function clearNodeKeyOnDOMNode(dom, editor) {
+	const prop = `__lexicalKey_${editor._key}`;
+	delete dom[prop];
+}
 function getNodeKeyFromDOMNode(dom, editor) {
 	return dom[`__lexicalKey_${editor._key}`];
 }
@@ -9728,6 +10670,7 @@ function $setSelection(selection) {
 		if (Object.isFrozen(selection)) formatDevErrorMessage(`$setSelection called on frozen selection object. Ensure selection is cloned before passing in.`);
 		selection.dirty = true;
 		selection.setCachedNodes(null);
+		if ($isRangeSelection(selection) && getActiveEditor()._slotsUsed) $clampRangeSelectionToSlotFrame(selection);
 	}
 	editorState._selection = selection;
 }
@@ -9736,12 +10679,8 @@ function $flushMutations() {
 	flushRootMutations(getActiveEditor());
 }
 function $getNodeFromDOM(dom) {
-	const editor = getActiveEditor();
-	const nodeKey = getNodeKeyFromDOMTree(dom, editor);
-	if (nodeKey === null) {
-		if (dom === editor.getRootElement()) return $getNodeByKey("root");
-		return null;
-	}
+	const nodeKey = getNodeKeyFromDOMTree(dom, getActiveEditor());
+	if (nodeKey === null) return null;
 	return $getNodeByKey(nodeKey);
 }
 function getNodeKeyFromDOMTree(dom, editor) {
@@ -9776,8 +10715,9 @@ function getAnchorTextFromDOM(anchorNode) {
 function $updateSelectedTextFromDOM(isCompositionEnd, editor, data) {
 	const domSelection = getDOMSelection(getWindow(editor));
 	if (domSelection === null) return;
-	const anchorNode = domSelection.anchorNode;
-	let { anchorOffset, focusOffset } = domSelection;
+	const points = getDOMSelectionPoints(domSelection, editor._rootElement);
+	const anchorNode = points.anchorNode;
+	let { anchorOffset, focusOffset } = points;
 	if (anchorNode !== null) {
 		let textContent = getAnchorTextFromDOM(anchorNode);
 		const node = $getNearestNodeFromDOMNode(anchorNode);
@@ -9811,13 +10751,15 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
 		}
 		const prevTextContent = node.getTextContent();
 		if (compositionEnd || normalizedTextContent !== prevTextContent) {
+			const selection = $getSelection();
 			if (normalizedTextContent === "") {
 				$setCompositionKey(null);
 				if (!IS_SAFARI && !IS_IOS && !IS_APPLE_WEBKIT) {
 					const editor = getActiveEditor();
+					$setTextContentWithSelection(node, "", selection);
 					setTimeout(() => {
 						editor.update(() => {
-							if (node.isAttached()) node.remove();
+							if (node.isAttached() && node.getTextContent() === "") node.remove();
 						});
 					}, 20);
 				} else node.remove();
@@ -9832,7 +10774,6 @@ function $updateTextNodeFromDOMContent(textNode, textContent, anchorOffset, focu
 				node.markDirty();
 				return;
 			}
-			const selection = $getSelection();
 			if (!$isRangeSelection(selection) || anchorOffset === null || focusOffset === null) {
 				$setTextContentWithSelection(node, normalizedTextContent, selection);
 				return;
@@ -10049,7 +10990,24 @@ function $selectAll(selection) {
 	if ($isRangeSelection(selection)) {
 		const anchor = selection.anchor;
 		const focus = selection.focus;
-		const rootNode = anchor.getNode().getTopLevelElementOrThrow().getParentOrThrow();
+		const anchorNode = anchor.getNode();
+		if ($isRootNode(anchorNode)) {
+			anchor.set(anchorNode.getKey(), 0, "element");
+			focus.set(anchorNode.getKey(), anchorNode.getChildrenSize(), "element");
+			$normalizeSelection(selection);
+			return selection;
+		}
+		const topParent = anchorNode.getTopLevelElementOrThrow();
+		const parent = topParent.getParent();
+		if (parent === null) {
+			if ($isElementNode(topParent)) {
+				anchor.set(topParent.getKey(), 0, "element");
+				focus.set(topParent.getKey(), topParent.getChildrenSize(), "element");
+				$normalizeSelection(selection);
+			}
+			return selection;
+		}
+		const rootNode = parent;
 		anchor.set(rootNode.getKey(), 0, "element");
 		focus.set(rootNode.getKey(), rootNode.getChildrenSize(), "element");
 		$normalizeSelection(selection);
@@ -10090,7 +11048,11 @@ function setMutatedNode(mutatedNodes, registeredNodes, mutationListeners, node,
 	if (prevMutation === void 0 || isMove) mutatedNodesByType.set(nodeKey, isMove ? "updated" : mutation);
 }
 /**
-* @deprecated Use {@link LexicalEditor.registerMutationListener} with `skipInitialization: false` instead.
+* Returns all nodes of the given type in the active editor state.
+*
+* Consider {@link LexicalEditor.registerMutationListener} with
+* `skipInitialization: false` instead if you need to track these nodes over
+* time rather than read them once.
 */
 function $nodesOfType(klass) {
 	const klassType = klass.getType();
@@ -10147,7 +11109,9 @@ function getElementByKeyOrThrow(editor, key) {
 }
 function getParentElement(node) {
 	const parentElement = node.assignedSlot || node.parentElement;
-	return isDocumentFragment(parentElement) ? parentElement.host : parentElement;
+	if (parentElement !== null) return parentElement;
+	const parentNode = node.parentNode;
+	return isDOMShadowRoot(parentNode) ? parentNode.host : null;
 }
 function getDOMOwnerDocument(target) {
 	return isDOMDocumentNode(target) ? target : isHTMLElement(target) ? target.ownerDocument : null;
@@ -10246,12 +11210,14 @@ function $isInlineElementOrDecoratorNode(node) {
 	return $isElementNode(node) && node.isInline() || $isDecoratorNode(node) && node.isInline();
 }
 function $getNearestRootOrShadowRoot(node) {
-	let parent = node.getParentOrThrow();
-	while (parent !== null) {
+	let current = node.getLatest();
+	while (current !== null) {
+		if ($getSlotHostKey(current) !== null && $isElementNode(current)) return current;
+		const parent = current.getParentOrThrow();
 		if ($isRootOrShadowRoot(parent)) return parent;
-		parent = parent.getParentOrThrow();
+		current = parent;
 	}
-	return parent;
+	return current;
 }
 function $isRootOrShadowRoot(node) {
 	return $isRootNode(node) || $isElementNode(node) && node.isShadowRoot();
@@ -10294,6 +11260,16 @@ function $applyNodeReplacement(node) {
 function errorOnInsertTextNodeOnRoot(node, insertNode) {
 	if ($isRootNode(node.getParent()) && !$isElementNode(insertNode) && !$isDecoratorNode(insertNode)) formatDevErrorMessage(`Only element or decorator nodes can be inserted in to the root node`);
 }
+/**
+* Returns the node with the given key from the active EditorState,
+* or throws if it does not exist.
+*/
+/**
+* @deprecated The type parameter is an unchecked and unsafe cast,
+* equivalent to `$getNodeByKeyOrThrow(key) as N`, and will be removed
+* in a future release. Call this function without a type argument and
+* narrow the result with a type guard instead.
+*/
 function $getNodeByKeyOrThrow(key) {
 	const node = $getNodeByKey(key);
 	if (node === null) formatDevErrorMessage(`Expected node with key ${key} to exist but it's not in the nodeMap.`);
@@ -10322,7 +11298,7 @@ function removeDOMBlockCursorElement(blockCursorElement, editor, rootElement) {
 }
 function $updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
 	let blockCursorElement = editor._blockCursorElement;
-	if ($isRangeSelection(nextSelection) && nextSelection.isCollapsed() && nextSelection.anchor.type === "element" && rootElement.contains(document.activeElement)) {
+	if ($isRangeSelection(nextSelection) && nextSelection.isCollapsed() && nextSelection.anchor.type === "element" && rootElement.contains(getActiveElement(rootElement))) {
 		const anchor = nextSelection.anchor;
 		const elementNode = anchor.getNode();
 		const offset = anchor.offset;
@@ -10372,6 +11348,306 @@ function getDOMSelectionFromTarget(eventTarget) {
 	const defaultView = getDefaultView(eventTarget);
 	return defaultView ? defaultView.getSelection() : null;
 }
+/**
+* @param node A value that may be a DOM ShadowRoot.
+* @returns True if node is a DOM ShadowRoot (an open or closed shadow tree
+*   root), false otherwise. A ShadowRoot is a DocumentFragment with a host.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function isDOMShadowRoot(node) {
+	return isDocumentFragment(node) && "host" in node;
+}
+/**
+* Collects the DOM ShadowRoots between `node` and its document, innermost
+* first. Returns an empty array when `node` is in the light DOM (its root is
+* the Document) or is detached.
+*
+* Uses the standard {@link https://developer.mozilla.org/docs/Web/API/Node/getRootNode | Node.getRootNode}
+* and `ShadowRoot.host` platform APIs to walk out of any nested shadow trees.
+*
+* @param node The DOM node to start from (typically the editor root element).
+* @returns The enclosing ShadowRoots, innermost first.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+const EMPTY_SHADOW_ROOTS = [];
+function getDOMShadowRoots(node) {
+	const root = node.getRootNode();
+	if (root === node || !isDOMShadowRoot(root)) return EMPTY_SHADOW_ROOTS;
+	const shadowRoots = [root];
+	let current = root.host;
+	for (;;) {
+		const nextRoot = current.getRootNode();
+		if (nextRoot === current || !isDOMShadowRoot(nextRoot)) break;
+		shadowRoots.push(nextRoot);
+		current = nextRoot.host;
+	}
+	return shadowRoots;
+}
+/**
+* Walks `root` and every open shadow root nested inside it, yielding each
+* element that matches `selector`. `querySelectorAll` does not pierce
+* shadow boundaries on its own; this descent does.
+*
+* @internal
+*/
+function* findAllLexicalElementsDeep(initialRoot) {
+	const roots = [initialRoot];
+	let root;
+	while (root = roots.pop()) {
+		yield* root.querySelectorAll("[data-lexical-editor=\"true\"]");
+		const walker = (isDOMDocumentNode(root) ? root : root.ownerDocument).createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+		let el;
+		while (el = walker.nextNode()) if (el.shadowRoot) roots.push(el.shadowRoot);
+	}
+}
+/**
+* Resolves the document that hosts an editor's root element, falling
+* back to the global `document` when the editor isn't mounted. Use this
+* over `editor.getRootElement()?.ownerDocument ?? document` so iframe /
+* shadow-mounted editors land in the right realm.
+*
+* @internal
+*/
+function getRootOwnerDocument(rootElement) {
+	return rootElement !== null ? rootElement.ownerDocument : document;
+}
+/**
+* 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}).
+*
+* `direction` is the standard
+* {@link https://developer.mozilla.org/docs/Web/API/Selection/direction | Selection.direction}
+* pass-through: `'forward'` / `'backward'` / `'none'` when the engine
+* implements it, or `undefined` when a future engine ships
+* `getComposedRanges` without `direction` (no current shipping
+* configuration matches — every engine that ships the former also ships
+* the latter). In the undefined case anchor/focus default to the composed
+* StaticRange's tree order; callers needing strict backward fidelity
+* inside a shadow root should check `direction !== undefined`.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+/**
+* Resolves a DOM Selection's range through any DOM ShadowRoots enclosing
+* `rootElement`, using the standard
+* {@link https://developer.mozilla.org/docs/Web/API/Selection/getComposedRanges | Selection.getComposedRanges}
+* platform API.
+*
+* When a selection is inside a shadow tree the browser retargets
+* `Selection.getRangeAt`/`anchorNode`/`focusNode` to the shadow host, which
+* hides the real nodes Lexical needs to resolve. Passing the enclosing shadow
+* roots to `getComposedRanges` returns the un-retargeted boundary points as a
+* {@link https://developer.mozilla.org/docs/Web/API/StaticRange | StaticRange}
+* (in tree order, i.e. start before end).
+*
+* @returns The composed StaticRange, or `null` when `rootElement` is in the
+*   light DOM, the platform does not implement `getComposedRanges`, or there
+*   is no selection.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getComposedStaticRange(domSelection, rootElement) {
+	if (rootElement === null || typeof domSelection.getComposedRanges !== "function") return null;
+	const shadowRoots = getDOMShadowRoots(rootElement);
+	if (shadowRoots.length === 0) return null;
+	const getComposedRanges = domSelection.getComposedRanges;
+	try {
+		const dictRange = getComposedRanges.call(domSelection, { shadowRoots })[0];
+		if (dictRange !== void 0) return dictRange;
+	} catch (_error) {}
+	try {
+		const variadicRange = getComposedRanges.apply(domSelection, shadowRoots)[0];
+		if (variadicRange !== void 0) return variadicRange;
+	} catch (_error) {}
+	return null;
+}
+/**
+* Returns a live DOM Range for the Selection, resolved through any DOM
+* ShadowRoots enclosing `rootElement`. Inside a shadow tree
+* `Selection.getRangeAt(0)` is retargeted to the shadow host, so this builds a
+* Range from the composed boundary points instead (see
+* {@link getComposedStaticRange}); in the light DOM it returns
+* `getRangeAt(0)` unchanged. Use this instead of `getRangeAt(0)` when the
+* Range is needed for layout (e.g. `getBoundingClientRect`), which a
+* StaticRange cannot provide.
+*
+* @returns A live Range, or null when the selection has no ranges.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getDOMSelectionRange(domSelection, rootElement) {
+	const staticRange = getComposedStaticRange(domSelection, rootElement);
+	if (staticRange !== null) {
+		const range = staticRangeToLiveRange(staticRange);
+		if (range !== null) return range;
+	}
+	return domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null;
+}
+/**
+* Resolves a DOM Selection's anchor/focus boundary points through any DOM
+* ShadowRoots enclosing `rootElement`. Inside a shadow tree the boundary
+* points come from {@link getComposedStaticRange} mapped back onto
+* anchor/focus with the standard
+* {@link https://developer.mozilla.org/docs/Web/API/Selection/direction | Selection.direction};
+* in the light DOM (or when `getComposedRanges` is unavailable) the Selection's
+* own anchorNode/focusNode are already correct, so the Selection is returned
+* as-is (it satisfies {@link DOMSelectionBoundaryPoints}).
+*
+* Use this instead of reading `Selection.anchorNode`/`focusNode` directly,
+* which are retargeted to the shadow host inside a shadow tree.
+*
+* @remarks
+* The two return paths have different read semantics:
+* - light DOM: the return aliases `domSelection`, so subsequent reads
+*   reflect any post-call selection changes. The aliasing is intentional;
+*   each `Selection` property read forces a synchronous style/layout
+*   recalculation, so `$updateDOMSelection` defers these reads until they
+*   are actually needed.
+* - shadow DOM: the return is a snapshot taken at call time, including
+*   `direction`. If a future engine ships `getComposedRanges` without
+*   `Selection.direction` (no current shipping configuration matches),
+*   the snapshot's `direction` is `undefined` and anchor/focus default
+*   to the StaticRange's tree order — a backward selection will appear
+*   forward.
+*
+* Read the four points immediately after the call, or compare identity
+* via `points === domSelection` to detect when the return aliases
+* `domSelection`, rather than caching the returned reference across
+* selection mutations.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getDOMSelectionPoints(domSelection, rootElement) {
+	const staticRange = getComposedStaticRange(domSelection, rootElement);
+	if (staticRange === null) return domSelection;
+	return staticRangeToPoints(staticRange, readDirection(domSelection));
+}
+/**
+* Resolves the live DOM Range (for layout reads like `getBoundingClientRect`)
+* and the anchor/focus boundary points in one pass, sharing a single
+* {@link getComposedStaticRange} read rather than computing it twice as a
+* call to {@link getDOMSelectionRange} followed by {@link getDOMSelectionPoints}
+* would. Use this at sites that need both shapes from the same selection.
+*
+* @returns The composed Range plus the boundary points; the Range is null
+*   when the selection has no ranges.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getDOMSelectionRangeAndPoints(domSelection, rootElement) {
+	const staticRange = getComposedStaticRange(domSelection, rootElement);
+	if (staticRange === null) return {
+		points: domSelection,
+		range: domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null
+	};
+	const range = staticRangeToLiveRange(staticRange) ?? (domSelection.rangeCount > 0 ? domSelection.getRangeAt(0) : null);
+	return {
+		points: staticRangeToPoints(staticRange, readDirection(domSelection)),
+		range
+	};
+}
+function staticRangeToLiveRange(staticRange) {
+	const doc = staticRange.startContainer.ownerDocument;
+	if (doc === null) return null;
+	const range = doc.createRange();
+	try {
+		range.setStart(staticRange.startContainer, staticRange.startOffset);
+		range.setEnd(staticRange.endContainer, staticRange.endOffset);
+		return range;
+	} catch (_error) {
+		return null;
+	}
+}
+function staticRangeToPoints(staticRange, direction) {
+	const { startContainer, startOffset, endContainer, endOffset } = staticRange;
+	return direction === "backward" ? {
+		anchorNode: endContainer,
+		anchorOffset: endOffset,
+		direction,
+		focusNode: startContainer,
+		focusOffset: startOffset
+	} : {
+		anchorNode: startContainer,
+		anchorOffset: startOffset,
+		direction,
+		focusNode: endContainer,
+		focusOffset: endOffset
+	};
+}
+function readDirection(domSelection) {
+	return domSelection.direction;
+}
+/**
+* Returns the focused element within the same Document or ShadowRoot as
+* `node`, using the standard `DocumentOrShadowRoot.activeElement`.
+*
+* Unlike `document.activeElement` — which is retargeted to the outermost
+* shadow host when focus is inside a shadow tree — this returns the focused
+* element within `node`'s own tree (e.g. the editor's contentEditable when it
+* lives inside a shadow root).
+*
+* @param node A node whose tree's active element is wanted.
+* @returns The active element, or null.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getActiveElement(node) {
+	const root = node.getRootNode();
+	return isDOMDocumentNode(root) || isDOMShadowRoot(root) ? root.activeElement : null;
+}
+/**
+* Descends from `root.activeElement` through nested open ShadowRoots to the
+* deepest focused element. `document.activeElement` only reports the outermost
+* shadow host; this walks into the shadow trees via `ShadowRoot.activeElement`
+* to find the element that actually has focus.
+*
+* @param root The Document or ShadowRoot to start from.
+* @returns The deepest active element, or null.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getActiveElementDeep(root) {
+	let active = root.activeElement;
+	while (active !== null && active.shadowRoot !== null) {
+		const inner = active.shadowRoot.activeElement;
+		if (inner === null) break;
+		active = inner;
+	}
+	return active;
+}
+/**
+* Returns the un-retargeted event target — the real element the user
+* interacted with — for events observed by a listener above an enclosing
+* DOM shadow root. `Event.target` is retargeted to the outermost shadow
+* host in that case, hiding the actual element; `composedPath()[0]`
+* returns the original target for `composed: true` events (most
+* user-agent UI events: click, mousedown, pointerdown, focusin, etc.).
+* Falls back to `event.target` when `composedPath` is unavailable or
+* returns an empty array (e.g. the event has already finished
+* dispatching).
+*
+* Pairs with the shadow-aware helpers above
+* ({@link getDOMSelectionPoints}, {@link getActiveElement}) for the
+* event side of the shadow boundary — useful when an
+* `Element.contains(target)` check needs to test against an editor root
+* inside a shadow tree.
+*
+* @param event The dispatched event.
+* @returns The un-retargeted target, or null when the event has none.
+*
+* @experimental Shape may change as shadow DOM support stabilizes.
+*/
+function getComposedEventTarget(event) {
+	const target = event.target;
+	if (target !== null && isHTMLElement(target) && target.shadowRoot !== null && typeof event.composedPath === "function") {
+		const path = event.composedPath();
+		if (path.length > 0) return path[0];
+	}
+	return target;
+}
 function $splitNode(node, offset) {
 	let startNode = node.getChildAtIndex(offset);
 	if (startNode == null) startNode = node;
@@ -10520,6 +11796,73 @@ function $getDOMSlot(node, dom, editor = $getEditor()) {
 	return slot;
 }
 /**
+* @internal
+*
+* Returns the scaffolding container element that `host`'s named slot renders
+* into, or null if the slot is empty or not yet rendered. The container is the
+* parent of the slotted node's DOM, resolved by key so it is found wherever it
+* sits — the reconciler parks it as a hidden placeholder in the host DOM, and
+* an explicit mount ({@link mountSlotContainer}) may relocate it; this lookup
+* still resolves it after that relocation. Editor-time analog of the
+* reconciler's internal `$slotContainerForKey`, which resolves the same
+* container from the reconcile-time DOM map instead of
+* `editor.getElementByKey`.
+*/
+function $getSlotContainer(host, name, editor = $getEditor()) {
+	const slot = $getSlot(host, name);
+	if (slot === null) return null;
+	const slotDom = editor.getElementByKey(slot.getKey());
+	return slotDom !== null ? slotDom.parentElement : null;
+}
+/**
+* @experimental
+*
+* Attach a host's named-slot container to `target` and make it visible.
+* The reconciler renders every slot subtree synchronously into a hidden
+* (`display: 'none'`) placeholder container parked slots-first in the host
+* DOM; nothing is visible until the host explicitly attaches the container
+* somewhere — mirroring how `getDOMSlot` gives an element control over where
+* its linked-list children render. This helper moves the container into
+* `target` (a no-op when it is already there, so mounting in place just
+* reveals it) and clears the inline `display` so the container renders as a
+* normal block that stylesheets may restyle. It deliberately does NOT use
+* `display: 'contents'`: Chromium cannot reliably edit inside a boxless
+* contenteditable subtree (caret hit-testing resolves clicks to a
+* neighboring box and native text insertion is dropped).
+*
+* Idempotent and framework-independent: lexical-react's `useLexicalSlotRef`
+* wraps it, and a node class or extension can call it directly (e.g. from a
+* mutation listener) to control slot placement without React.
+*
+* @returns the container, or null when the slot (or its DOM) does not exist
+* yet — e.g. before the host's first reconciliation.
+*/
+function mountSlotContainer(editor, nodeKey, slotName, target) {
+	const container = editor.read("latest", () => {
+		const host = $getNodeByKey(nodeKey);
+		return host !== null ? $getSlotContainer(host, slotName, editor) : null;
+	});
+	if (container !== null) {
+		if (container.parentElement !== target) target.appendChild(container);
+		container.style.display = "";
+	}
+	return container;
+}
+/**
+* @experimental
+*
+* Reverse of {@link mountSlotContainer}: hide `container` again and park it
+* back in the host's DOM as the leading hidden placeholder, where the
+* reconciler manages it. Call when the mount target goes away while the host
+* remains (e.g. chrome unmount) so the slot subtree stays in the document
+* instead of leaving with the detached target.
+*/
+function unmountSlotContainer(editor, nodeKey, container) {
+	container.style.display = "none";
+	const hostDom = editor.getElementByKey(nodeKey);
+	if (hostDom !== null && container.parentElement !== hostDom) hostDom.insertBefore(container, hostDom.firstChild);
+}
+/**
 * @experimental
 *
 * Type guard narrowing a {@link DOMSlot} to an {@link ElementDOMSlot}, which
@@ -10595,6 +11938,14 @@ function $cloneWithProperties(latestNode) {
 	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)`);
+	if ($isSlotChild(mutableNode) && $isSlotChild(latestNode)) {
+		if (!(mutableNode.__slotHost === latestNode.__slotHost)) formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') overrode afterCloneFrom but did not preserve __slotHost`);
+	}
+	if ($isSlotHost(mutableNode) && $isSlotHost(latestNode)) {
+		const mutSlots = mutableNode.__slots;
+		const latSlots = latestNode.__slots;
+		if (!(mutSlots === latSlots || mutSlots !== null && latSlots !== null && mutSlots.size === latSlots.size && Array.from(mutSlots).every(([k, v]) => latSlots.get(k) === v))) formatDevErrorMessage(`$cloneWithProperties: ${constructor.name}.clone(node) (with type '${constructor.getType()}') overrode afterCloneFrom but did not preserve __slots`);
+	}
 	return mutableNode;
 }
 /**
@@ -10656,15 +12007,25 @@ function $setFormatFromDOM(node, domNode) {
 	return alignment && alignment in ELEMENT_TYPE_TO_FORMAT ? node.setFormat(alignment) : node;
 }
 /**
+* Options accepted by {@link setDOMUnmanaged}.
+*
+* @experimental
+*/
+/**
 * Mark this DOM element as unmanaged by lexical's mutation observer (like
 * decorator nodes are). Extensions that inject non-lexical decoration
 * elements into a node's DOM should mark them so the mutation observer
 * doesn't evict them as "unknown DOM children" during cleanup.
 *
+* Pass `{captureSelection: true}` to additionally treat the subtree's
+* window selection as decorator-like, so resolution does not force-sync
+* the caret out of unmanaged DOM (see {@link isDOMCapturingSelection}).
+*
 * @experimental
 */
-function setDOMUnmanaged(elementDom) {
+function setDOMUnmanaged(elementDom, options) {
 	elementDom.__lexicalUnmanaged = true;
+	if (options && options.captureSelection !== void 0) elementDom.__lexicalCapturedSelection = options.captureSelection;
 }
 /**
 * True if this DOM node was marked with {@link setDOMUnmanaged}.
@@ -10675,6 +12036,50 @@ function isDOMUnmanaged(elementDom) {
 	return elementDom.__lexicalUnmanaged === true;
 }
 /**
+* Mark a DOM element as a named-slot editable island: set its `contentEditable`
+* to follow the editor's editable state. A slot rendered inside a non-editable
+* host (a decorator, or a `contentEditable=false` element shell) does not track
+* the editor on its own, so its container carries an explicit `contentEditable`;
+* {@link $fullReconcile} re-applies this when {@link LexicalEditor.setEditable}
+* toggles. Call it for any other editable island an app attaches itself (e.g. a
+* `getDOMSlot` children element rendered inside a `contentEditable=false` shell).
+*
+* @experimental
+*/
+function $markSlotEditable(element, editor = $getEditor()) {
+	const editable = editor.isEditable();
+	element.contentEditable = editable ? "true" : "false";
+	if (editable) element.__lexicalEditor = editor;
+	else delete element.__lexicalEditor;
+}
+/**
+* True if the DOM node sits inside a subtree marked with
+* `{captureSelection: true}` via {@link setDOMUnmanaged}. Walks ancestors
+* so any descendant of a marked subtree (e.g. an `<input>` inside a marked
+* `<div>`) reports as captured too.
+*
+* The walk aborts at the first DOM node that corresponds to a Lexical
+* node in `editor` — that boundary is the implicit owner of the subtree's
+* selection, so a captureSelection marker above it (in non-Lexical
+* scaffolding around the editor) does not leak in.
+*
+* DecoratorNode DOM is marked with `setDOMUnmanaged({captureSelection:
+* true})` by the reconciler, so decorator subtrees also report as
+* captured here.
+*
+* @experimental
+*/
+function isDOMCapturingSelection(elementDom, editor) {
+	let dom = elementDom;
+	while (dom != null) {
+		if (dom.__lexicalCapturedSelection === true) return true;
+		if (isHTMLElement(dom) && dom.hasAttribute("data-lexical-slot")) return false;
+		if (getNodeKeyFromDOMNode(dom, editor) !== void 0) return false;
+		dom = getParentElement(dom);
+	}
+	return false;
+}
+/**
 * @internal
 *
 * Object.hasOwn ponyfill
@@ -10688,12 +12093,6 @@ function hasOwn(o, k) {
 function hasOwnStaticMethod(klass, k) {
 	return hasOwn(klass, k) && klass[k] !== LexicalNode[k];
 }
-/**
-* @internal
-*/
-function hasOwnExportDOM(klass) {
-	return hasOwn(klass.prototype, "exportDOM");
-}
 /** @internal */
 function isAbstractNodeClass(klass) {
 	if (!(klass === LexicalNode || klass.prototype instanceof LexicalNode)) {
@@ -10709,17 +12108,29 @@ function isAbstractNodeClass(klass) {
 	}
 	return klass === DecoratorNode || klass === ElementNode || klass === LexicalNode;
 }
+const STATIC_NODE_CONFIG_CACHE = /* @__PURE__ */ new WeakMap();
 /** @internal */
 function getStaticNodeConfig(klass) {
-	const nodeConfigRecord = PROTOTYPE_CONFIG_METHOD in klass.prototype ? klass.prototype[PROTOTYPE_CONFIG_METHOD]() : void 0;
+	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;
 	let ownNodeConfig;
 	let ownNodeType = nodeType;
 	if (nodeConfigRecord) if (nodeType) ownNodeConfig = nodeConfigRecord[nodeType];
-	else for (const [k, v] of Object.entries(nodeConfigRecord)) {
-		ownNodeType = k;
-		ownNodeConfig = v;
+	else {
+		for (const [k, v] of Object.entries(nodeConfigRecord)) {
+			ownNodeType = k;
+			ownNodeConfig = v;
+		}
+		if (!ownNodeConfig) for (const symbolKey of Object.getOwnPropertySymbols(nodeConfigRecord)) {
+			const symbolConfig = nodeConfigRecord[symbolKey];
+			if (symbolConfig) {
+				ownNodeConfig = symbolConfig;
+				break;
+			}
+		}
 	}
 	if (!isAbstract && ownNodeType) {
 		if (!hasOwnStaticMethod(klass, "getType")) klass.getType = () => ownNodeType;
@@ -10743,10 +12154,53 @@ function getStaticNodeConfig(klass) {
 			if (importDOM) klass.importDOM = () => importDOM;
 		}
 	}
-	return {
+	const result = {
+		klass,
 		ownNodeConfig,
 		ownNodeType
 	};
+	STATIC_NODE_CONFIG_CACHE.set(klass, result);
+	return result;
+}
+/**
+* Collect all configuration for this class and its superclasses
+*
+* @internal
+*/
+function* iterStaticNodeConfigChain(klass) {
+	for (let current = klass; current && (current === LexicalNode || $isLexicalNode(current.prototype));) {
+		const config = getStaticNodeConfig(current);
+		yield config;
+		current = config.ownNodeConfig && config.ownNodeConfig.extends || getSuperclassOf(current);
+	}
+}
+/**
+* Build a map from each registered node type to the set of registered node
+* types that are it or extend it (including the type itself). For every node
+* class in `nodes`, its prototype chain is walked and the class's own type is
+* added to the bucket of each registered ancestor type it inherits from.
+*
+* The result lets callers expand a base node type to all of its registered
+* subclass types up front, so a subclass instance can be matched by type
+* without a runtime `instanceof`.
+*
+* @experimental
+*/
+function getRegisteredSubtypeMap(nodes) {
+	const subtypes = /* @__PURE__ */ new Map();
+	const klassByType = /* @__PURE__ */ new Map();
+	for (const klass of nodes) {
+		const { ownNodeType } = getStaticNodeConfig(klass);
+		if (ownNodeType) {
+			klassByType.set(ownNodeType, klass);
+			subtypes.set(ownNodeType, /* @__PURE__ */ new Set());
+		}
+	}
+	for (const [type, klass] of klassByType) for (const { ownNodeType } of iterStaticNodeConfigChain(klass)) {
+		const bucket = ownNodeType && subtypes.get(ownNodeType);
+		if (bucket) bucket.add(type);
+	}
+	return subtypes;
 }
 /**
 * Create an node from its class.
@@ -10801,6 +12255,362 @@ function $createChildrenArray(element, nodeMap) {
 	return children;
 }
 /**
+* Look up the superclass of this class, prefer
+* {@link iterStaticNodeConfigChain} when implementing loops.
+*
+* @internal
+*/
+function getSuperclassOf(klass) {
+	const viaStatic = Object.getPrototypeOf(klass);
+	if (typeof viaStatic === "function" && viaStatic !== Function.prototype) return viaStatic;
+	const parentProto = klass.prototype && Object.getPrototypeOf(klass.prototype);
+	return parentProto ? parentProto.constructor : null;
+}
+/**
+* Shared empty slot map. Reads coalesce here when a host's `__slots` is null
+* (lazy allocation), so non-slot trees don't pay a per-node allocation cost.
+*
+* @internal
+*/
+const EMPTY_SLOTS = /* @__PURE__ */ new Map();
+/**
+* Shape predicate: true when `node` carries the host's `__slots` field — i.e.
+* it is an {@link ElementNode} or a {@link DecoratorNode}. Narrows to
+* {@link SlotHostNode} so the mutation helpers' compile-time host requirement
+* is satisfied. This is a type guard only; the value-level invariant on what
+* may actually be slotted is enforced by {@link $setSlot} (shadow-root
+* ElementNode or non-inline DecoratorNode).
+*
+* @experimental
+*/
+function $isSlotHost(node) {
+	return $isElementNode(node) || $isDecoratorNode(node);
+}
+/**
+* Shape predicate: true when `node` carries the child's `__slotHost` field —
+* i.e. it is an {@link ElementNode} or a {@link DecoratorNode}. Narrows to
+* {@link SlotChildNode}. This is a type guard only; {@link $setSlot} rejects
+* inline values at runtime. The slot link acts as a virtual shadow root, so
+* any non-inline block — shadow root or not — can occupy a slot.
+*
+* @experimental
+*/
+function $isSlotChild(node) {
+	return $isElementNode(node) || $isDecoratorNode(node);
+}
+/**
+* Returns the key of the host this node is slotted into, or null when the node
+* is not slotted. Accepts any node and narrows internally so generic callers
+* (removal guard, up-walk, GC, caret) don't have to. Exposes a raw key, so it
+* stays internal to the package; public callers use {@link $getSlotHost}.
+*
+* @internal
+*/
+function $getSlotHostKey(node) {
+	const latest = node.getLatest();
+	return $isSlotChild(latest) ? latest.__slotHost : null;
+}
+/**
+* Returns the host element when this node occupies one of its named slots,
+* or null if this node is not slotted. The up-link is kept separate from
+* {@link LexicalNode.getParent} so the slot boundary behaves like a shadow
+* root.
+*
+* @experimental
+*/
+function $getSlotHost(node) {
+	const slotHostKey = $getSlotHostKey(node);
+	if (slotHostKey === null) return null;
+	const host = $getNodeByKey(slotHostKey);
+	if (!($isElementNode(host) || $isDecoratorNode(host))) formatDevErrorMessage(`slotHost must be an ElementNode or a DecoratorNode`);
+	return host;
+}
+/**
+* Returns the slot name this node occupies on its host, or null when the node
+* is not a slot value. Mirrors {@link LexicalNode#getIndexWithinParent} for
+* slot children — answers "which named slot does this node sit in?".
+*
+* @experimental
+*/
+function $getSlotNameWithinHost(slotChild) {
+	const host = $getSlotHost(slotChild);
+	if (host === null) return null;
+	const childKey = slotChild.getLatest().__key;
+	for (const [name, key] of $getSlotMap(host)) if (key === childKey) return name;
+	return null;
+}
+/**
+* Returns the slot value (the "slot frame") whose isolated subtree contains
+* `node`, or `node` itself when it is a slot value, or null when the node is
+* not inside any slot. The walk follows `getParent()` and naturally stops at a
+* slot value because a slotted node's `__parent` is null. Non-slot trees have
+* `__slotHost === null` everywhere, so this always returns null there.
+*
+* Selection-driven exporters use this to find the isolated subtree a
+* RangeSelection lives in (a selection inside a slot never contains the host,
+* so a root-children walk alone would miss it).
+*
+* @experimental
+*/
+function $getSlotFrame(node) {
+	let current = node.getLatest();
+	while (current !== null) {
+		if ($getSlotHostKey(current) !== null) return current;
+		current = current.getParent();
+	}
+	return null;
+}
+/**
+* Returns the latest slot map (name -> child key, insertion order). Exposes raw
+* keys, so it stays internal to the package; public callers use
+* {@link $getSlotNames} / {@link $getSlot}.
+*
+* @internal
+*/
+function $getSlotMap(node) {
+	const latest = node.getLatest();
+	return $isSlotHost(latest) && latest.__slots !== null ? latest.__slots : EMPTY_SLOTS;
+}
+/**
+* Returns the names of this node's occupied slots, in insertion order. Empty
+* when the node hosts no slots.
+*
+* @experimental
+*/
+function $getSlotNames(node) {
+	return Array.from($getSlotMap(node).keys());
+}
+/**
+* Slot-name hint for a host node's slot accessors: the names declared in the
+* host class's `$config().slots` (for editor autocomplete) unioned with `string`
+* — every string is still accepted (slots take undeclared names at runtime), the
+* declared names just surface as suggestions. A class declaring no slots, or a
+* subclass that inherits them without redeclaring, resolves to plain `string`.
+*
+* @experimental
+*/
+/**
+* Returns the node occupying the named slot, or null if the slot is empty.
+* Slots are a shadow-root-isolated channel kept separate from children; see
+* {@link $getSlotHost} for the reverse up-link.
+*
+* @experimental
+*/
+function $getSlot(node, name) {
+	const key = $getSlotMap(node).get(name);
+	return key === void 0 ? null : $getNodeByKey(key);
+}
+const RESERVED_SLOT_NAMES = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+const SLOT_MAP_OWNER = Symbol("slotMapOwner");
+function $getWritableSlots(writableHost) {
+	let slots = writableHost.__slots;
+	if (slots === null || slots[SLOT_MAP_OWNER] !== writableHost) {
+		slots = new Map(slots);
+		slots[SLOT_MAP_OWNER] = writableHost;
+		writableHost.__slots = slots;
+	}
+	return slots;
+}
+const slotRankCache = /* @__PURE__ */ new WeakMap();
+const EMPTY_DECLARED_SLOTS = [];
+/**
+* Returns the canonical slot declaration for a node class: the `slots` array
+* from the nearest {@link StaticNodeConfigValue} in its prototype chain (a
+* subclass redeclaration overrides its ancestors'), or an empty array when
+* nothing is declared. The declaration is an ordering vocabulary, not a
+* schema — occupied names outside it are still valid and sort after the
+* declared names in code-unit order.
+*
+* @experimental named-slots
+*/
+function getDeclaredSlots(klass) {
+	for (const { ownNodeConfig } of iterStaticNodeConfigChain(klass)) {
+		const declared = ownNodeConfig && ownNodeConfig.slots;
+		if (declared) return declared;
+	}
+	return EMPTY_DECLARED_SLOTS;
+}
+/**
+* @internal
+*
+* Concatenated text of a node's named slots, read slots-first (in slot Map
+* order). Shared by the getTextContent implementations so ElementNode and
+* DecoratorNode hosts fold their slot text the same way; a node with no
+* slots returns the empty string. A free function (not a LexicalNode method)
+* so the framework-owned name cannot collide with a subclass's own members.
+*/
+function $getSlotsTextContent(node) {
+	let textContent = "";
+	for (const name of $getSlotNames(node)) {
+		const slot = $getSlot(node, name);
+		if (slot !== null) textContent += slot.getTextContent();
+	}
+	return textContent;
+}
+/**
+* @internal
+*
+* Size counterpart to {@link $getSlotsTextContent}, summing each slot's
+* getTextContentSize (which a slot subtree may override independently of its
+* text length) slots-first.
+*/
+function $getSlotsTextContentSize(node) {
+	let textContentSize = 0;
+	for (const name of $getSlotNames(node)) {
+		const slot = $getSlot(node, name);
+		if (slot !== null) textContentSize += slot.getTextContentSize();
+	}
+	return textContentSize;
+}
+function getDeclaredSlotRank(klass) {
+	let rank = slotRankCache.get(klass);
+	if (rank === void 0) {
+		const declared = getDeclaredSlots(klass);
+		const built = /* @__PURE__ */ new Map();
+		for (const name of declared) {
+			if (!!RESERVED_SLOT_NAMES.includes(name)) formatDevErrorMessage(`getDeclaredSlotRank: ${klass.name} declares reserved slot name "${name}"; __proto__, constructor, and prototype break the plain-object serialization of slots`);
+			if (!!built.has(name)) formatDevErrorMessage(`getDeclaredSlotRank: ${klass.name} declares slot name "${name}" more than once; the canonical order would be ambiguous`);
+			built.set(name, built.size);
+		}
+		rank = built;
+		slotRankCache.set(klass, rank);
+	}
+	return rank;
+}
+function compareSlotNames(a, b, rank) {
+	const rankA = rank.get(a);
+	const rankB = rank.get(b);
+	if (rankA !== void 0) return rankB !== void 0 ? rankA - rankB : -1;
+	if (rankB !== void 0) return 1;
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function $canonicalizeSlotOrder(host) {
+	const slots = host.__slots;
+	if (slots === null || slots.size < 2) return;
+	const rank = getDeclaredSlotRank(host.constructor);
+	let previous = null;
+	let sorted = true;
+	for (const name of slots.keys()) {
+		if (previous !== null && compareSlotNames(previous, name, rank) > 0) {
+			sorted = false;
+			break;
+		}
+		previous = name;
+	}
+	if (sorted) return;
+	const entries = Array.from(slots).sort(([a], [b]) => compareSlotNames(a, b, rank));
+	slots.clear();
+	for (const [name, key] of entries) slots.set(name, key);
+}
+/**
+* Places `node` into the named slot of `host`, replacing any existing value
+* under that name. Move semantics, mirroring `ElementNode.append` /
+* `insertBefore`: the value is detached from wherever it currently lives —
+* a child of another element, or a slot on this or another host (a node's two
+* up-links, `__parent` and `__slotHost`, are mutually exclusive, so it holds
+* exactly one) — before linking, so re-slotting never requires an explicit
+* remove first. The replaced value, if any, is detached.
+*
+* A slot value must be a non-inline {@link ElementNode} or a non-inline
+* {@link DecoratorNode}: the slot link itself acts as a virtual shadow root
+* between the host and the value, so the value does not need to be a shadow
+* root — a plain block (e.g. a ParagraphNode subclass serving as a
+* single-line field) is a valid slot value, and selection, traversal, and
+* editing treat its slot boundary exactly like a shadow-root boundary.
+*
+* `host` is constrained to {@link SlotHostNode} so a non-host is rejected at
+* compile time.
+*
+* @experimental
+*/
+function $setSlot(host, name, node) {
+	if (!(name !== "__proto__" && name !== "constructor" && name !== "prototype")) formatDevErrorMessage(`$setSlot: "${name}" is a reserved slot name; __proto__, constructor, and prototype break the plain-object serialization of slots`);
+	const latestHost = host.getLatest();
+	if (latestHost.__slots !== null && latestHost.__slots.get(name) === node.getLatest().__key) return latestHost;
+	if (!(($isElementNode(node) || $isDecoratorNode(node)) && !node.isInline())) formatDevErrorMessage(`$setSlot: node ${node.__key} is not a valid slot value; a slot value must be a non-inline ElementNode or DecoratorNode (the slot link itself is the shadow boundary).`);
+	if (!!$isSlotAncestorOrSelf(node, host)) formatDevErrorMessage(`$setSlot: node ${node.__key} cannot be slotted into ${host.__key}; a node may not host itself or an ancestor reached through children or slot up-links — the slot up-link would form a cycle that loops isAttached/GC.`);
+	const writableSelf = host.getWritable();
+	const slots = $getWritableSlots(writableSelf);
+	const previousKey = slots.get(name);
+	if (previousKey !== void 0) $detachSlottedNode(previousKey);
+	const writableNode = node.getWritable();
+	const previousHost = $getSlotHost(writableNode);
+	if (previousHost !== null) {
+		const previousName = $getSlotNameWithinHost(writableNode);
+		if (previousName !== null) $getWritableSlots(previousHost.getWritable()).delete(previousName);
+		writableNode.__slotHost = null;
+	}
+	$removeFromParent(writableNode);
+	writableNode.__slotHost = writableSelf.__key;
+	slots.set(name, writableNode.__key);
+	$canonicalizeSlotOrder(writableSelf);
+	$setSlotsUsed();
+	return writableSelf;
+}
+function $setSlotsUsed() {
+	const editor = $getEditor();
+	editor._slotsUsed = true;
+	if (editor._pendingEditorState) editor._pendingEditorState._slotsUsed = true;
+}
+/**
+* Removes the named slot from `host`, detaching its value (its slot up-link is
+* cleared). No-op if the slot is empty. `host` is constrained to
+* {@link SlotHostNode} so a non-host is rejected at compile time.
+*
+* @experimental
+*/
+function $removeSlot(host, name) {
+	const writableSelf = host.getWritable();
+	if (writableSelf.__slots === null) return writableSelf;
+	const previousKey = writableSelf.__slots.get(name);
+	if (previousKey !== void 0) {
+		$detachSlottedNode(previousKey);
+		$getWritableSlots(writableSelf).delete(name);
+	}
+	return writableSelf;
+}
+function $isSlotAncestorOrSelf(node, host) {
+	let key = host.__key;
+	while (key !== null) {
+		if (key === node.__key) return true;
+		const current = $getNodeByKey(key);
+		if (current === null) break;
+		key = current.__parent !== null ? current.__parent : $getSlotHostKey(current);
+	}
+	return false;
+}
+/**
+* @internal
+*
+* Reverse guard of {@link $setSlot}'s cycle invariant for the children
+* channel: inserting `child` under `parent` must not close a cycle through a
+* slot up-link (e.g. `slotValue.append(host)` would make `host.__parent`
+* reach `slotValue` while `slotValue.__slotHost` reaches `host`, looping
+* isAttached/GC — and hanging the commit itself). Called from the child
+* attachment points (ElementNode.splice, insertBefore/insertAfter/replace).
+* __DEV__-only and gated on the editor slot latch: the up-walk is an O(depth)
+* cost on the hot children path, and like {@link $setSlot}'s direct guard it
+* only catches direct local programmer error (collab/JSON can't alias a host
+* into its own slot value), so production matches the unguarded children
+* channel's own ancestor-append behavior.
+*/
+function $errorOnSlotCycleChild(parent, child) {
+	if (!$getEditor()._slotsUsed) return;
+	if (!!$isSlotAncestorOrSelf(child, parent)) formatDevErrorMessage(`insert: node ${child.__key} cannot become a child of ${parent.__key}; the parent is reachable from the node through slot up-links, so the insertion would form a cycle that loops isAttached/GC.`);
+}
+function $detachSlottedNode(slotKey) {
+	const previous = $getNodeByKey(slotKey);
+	if (previous === null) return;
+	const writablePrevious = previous.getWritable();
+	if (!$isSlotChild(writablePrevious)) formatDevErrorMessage(`detach: slotted node ${slotKey} must be an ElementNode or a DecoratorNode`);
+	writablePrevious.__slotHost = null;
+	writablePrevious.remove();
+}
+/**
 * The direction of a caret, 'next' points towards the end of the document
 * and 'previous' points towards the beginning
 */
@@ -11017,7 +12827,8 @@ function flipDirection(direction) {
 	return FLIP_DIRECTION[direction];
 }
 function $filterByMode(node, mode = "root") {
-	return MODE_PREDICATE[mode](node) ? null : node;
+	if (node === null || MODE_PREDICATE[mode](node)) return null;
+	return $getSlotHostKey(node) === null ? node : null;
 }
 var AbstractSiblingCaret = class AbstractSiblingCaret extends AbstractCaret {
 	type = "sibling";
@@ -11727,6 +13538,7 @@ function $getBlockMergeTargets(anchor, focus, seenStart) {
 	};
 	const anchorBlock = $getBlock(anchorElements, INTERNAL_$isBlock);
 	const focusBlock = anchorBlock && $getBlock(focusElements, (node) => seenStart.has(node.getKey()) && INTERNAL_$isBlock(node));
+	if (focusBlock && $getSlotNames(focusBlock).length > 0) return null;
 	return anchorBlock && focusBlock ? [anchorBlock, focusBlock] : null;
 }
 /**
@@ -11900,6 +13712,30 @@ function $splitAtPointCaretNext(pointCaret, { $copyElementNode = $copyNode, $spl
 	return parentCaret;
 }
 /**
+* If the insertion caret is the root/shadow root node (see {@link $isRootOrShadowRoot}),
+* the node will be inserted there, otherwise the parent nodes will be split according to the
+* given options.
+* @param node - The node to be inserted
+* @param caret - The location to insert or split from
+* @returns The node after its insertion
+*/
+function $insertNodeToNearestRootAtCaret(node, caret, options) {
+	let insertCaret = $getCaretInDirection(caret, "next");
+	if ($isTextPointCaret(insertCaret)) {
+		if (insertCaret.offset === 0) insertCaret = $getSiblingCaret(insertCaret.origin, "previous").getFlipped();
+		else if (insertCaret.offset === insertCaret.origin.getTextContentSize()) insertCaret = $getSiblingCaret(insertCaret.origin, "next");
+	}
+	if (insertCaret.origin.is(node)) {
+		if (!$isSiblingCaret(insertCaret)) formatDevErrorMessage(`$insertNodeToNearestRootAtCaret node ${node.getKey()} of type ${node.getType()} can not be inserted into itself`);
+		insertCaret = $rewindSiblingCaret(insertCaret);
+	}
+	if (node.is(insertCaret.getNodeAtCaret()) || node.is(insertCaret.getFlipped().getNodeAtCaret())) node.remove(true);
+	for (let nextCaret = insertCaret; nextCaret; nextCaret = $splitAtPointCaretNext(nextCaret, options)) insertCaret = nextCaret;
+	if (!!$isTextPointCaret(insertCaret)) formatDevErrorMessage(`$insertNodeToNearestRootAtCaret: An unattached TextNode can not be split`);
+	insertCaret.insert(node.isInline() ? $createParagraphNode().append(node) : node);
+	return $getCaretInDirection($getSiblingCaret(node.getLatest(), "next"), caret.direction);
+}
+/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
@@ -12117,4 +13953,4 @@ function mergeRegister(...func) {
 	};
 }
 //#endregion
-export { $addUpdateTag, $applyNodeReplacement, $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, $getState, $getStateChange, $getTextContent, $getTextNodeOffset, $getTextPointCaret, $getTextPointCaretSlice, $getWritableNodeState, $hasAncestor, $hasUpdateTag, $insertNodes, $isBlockElementNode, $isChildCaret, $isDecoratorNode, $isEditorState, $isElementDOMSlot, $isElementNode, $isExtendableTextPointCaret, $isInlineElementOrDecoratorNode, $isLeafNode, $isLexicalNode, $isLineBreakNode, $isNodeCaret, $isNodeSelection, $isParagraphNode, $isRangeSelection, $isRootNode, $isRootOrShadowRoot, $isSiblingCaret, $isTabNode, $isTextNode, $isTextPointCaret, $isTextPointCaretSlice, $isTokenOrSegmented, $isTokenOrTab, $nodesOfType, $normalizeCaret, $normalizeSelection as $normalizeSelection__EXPERIMENTAL, $onUpdate, $parseSerializedNode, $removeTextFromCaretRange, $rewindSiblingCaret, $selectAll, $setCompositionKey, $setDirectionFromDOM, $setFormatFromDOM, $setPointFromCaret, $setSelection, $setSelectionFromCaretRange, $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, 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_KEY, 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, flipDirection, getDOMOwnerDocument, getDOMSelection, getDOMSelectionFromTarget, getDOMTextNode, getEditorPropertyFromDOMNode, getNearestEditorFromDOMNode, getRegisteredNode, getRegisteredNodeOrThrow, getStaticNodeConfig, getStyleObjectFromCSS, getTextDirection, getTransformSetFromKlass, isBlockDomNode, isCurrentlyReadOnlyMode, isDOMDocumentNode, isDOMNode, isDOMTextNode, isDOMUnmanaged, isDocumentFragment, isExactShortcutMatch, isHTMLAnchorElement, isHTMLElement, isHTMLTableCellElement, isHTMLTableRowElement, isInlineDomNode, isLexicalEditor, isModifierMatch, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, makeStepwiseIterator, mergeRegister, normalizeClassNames, removeClassNamesFromElement, removeFromParent, resetRandomKey, safeCast, setDOMStyleFromCSS, setDOMStyleObject, setDOMUnmanaged, setNodeIndentFromDOM, shallowMergeConfig, stopLexicalPropagation, toggleTextFormatType, tokenizeRawText };
+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 };