@mx-space/cli 0.7.7 → 0.8.0

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

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/lexical@0.44.0/node_modules/lexical/Lexical.dev.mjs
+//#region ../../node_modules/.pnpm/lexical@0.45.0/node_modules/lexical/dist/Lexical.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -24,13 +24,6 @@ function formatDevErrorMessage(message) {
 *
 */
 const CAN_USE_DOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
-/**
-* 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.
-*
-*/
 const documentMode = CAN_USE_DOM && "documentMode" in document ? document.documentMode : null;
 const IS_APPLE = CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
 const IS_FIREFOX = CAN_USE_DOM && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
@@ -82,9 +75,8 @@ const NON_BREAKING_SPACE = "\xA0";
 const COMPOSITION_SUFFIX = IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT ? NON_BREAKING_SPACE : "​";
 const DOUBLE_LINE_BREAK = "\n\n";
 const COMPOSITION_START_CHAR = IS_FIREFOX ? NON_BREAKING_SPACE : COMPOSITION_SUFFIX;
-const RTL = "֑-߿יִ-﷽ﹰ-ﻼ";
 const RTL_REGEX = /* @__PURE__ */ new RegExp("^[^A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿]*[֑-߿יִ-﷽ﹰ-ﻼ]");
-const LTR_REGEX = new RegExp("^[^" + RTL + "]*[A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿]");
+const LTR_REGEX = /* @__PURE__ */ new RegExp("^[^֑-߿יִ-﷽ﹰ-ﻼ]*[A-Za-zÀ-ÖØ-öø-ʸ̀-֐ࠀ-῿‎Ⰰ-﬜︀-﹯﻽-￿]");
 const TEXT_TYPE_TO_FORMAT = {
 	bold: 1,
 	capitalize: IS_CAPITALIZE,
@@ -131,6 +123,321 @@ const TEXT_TYPE_TO_MODE = {
 const NODE_STATE_KEY = "$";
 const PROTOTYPE_CONFIG_METHOD = "$config";
 /**
+* The editor has at most one block cursor element
+* ({@link LexicalEditor._blockCursorElement}) — a transient, non-lexical
+* element the selection layer inserts among an ElementNode's children when a
+* collapsed element selection is adjacent to a node that can't host the caret
+* (a block decorator, or a non-empty-capable block). Slots must skip it so it
+* is never mistaken for managed content. There is only ever one, read from the
+* active editor.
+*/
+function $getActiveBlockCursorElement() {
+	return $getEditor()._blockCursorElement;
+}
+/**
+* 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.
+*
+* For ElementNode children management see {@link ElementDOMSlot}. For
+* non-Element nodes (TextNode, LineBreakNode, DecoratorNode) the slot still
+* supports an internal `before` / `after` so subclasses can prepend or
+* append non-lexical siblings around the content node and the reconciler /
+* `setTextContent` route the actual content through the slot.
+*
+* @experimental
+*/
+var DOMSlot = class DOMSlot {
+	/** The content-bearing element of the node's DOM. */
+	element;
+	/** Upper boundary: the lexical-managed range ends before this node. */
+	before;
+	/** Lower boundary: the lexical-managed range starts after this node. */
+	after;
+	constructor(element, before, after) {
+		this.element = element;
+		this.before = before || null;
+		this.after = after || null;
+	}
+	/** Return a new slot with `before` updated. */
+	withBefore(before) {
+		return new DOMSlot(this.element, before, this.after);
+	}
+	/** Return a new slot with `after` updated. */
+	withAfter(after) {
+		return new DOMSlot(this.element, this.before, after);
+	}
+	/** Return a new slot with `element` updated. */
+	withElement(element) {
+		if (this.element === element) return this;
+		return new DOMSlot(element, this.before, this.after);
+	}
+	/**
+	* Insert the given node before `this.before` (if defined) or append it to
+	* `this.element` otherwise. Subclasses may override to respect additional
+	* boundaries (e.g. `ElementDOMSlot` also keeps the managed line break at
+	* the end).
+	*/
+	insertChild(dom) {
+		const before = this.getInsertionAnchor();
+		if (!(before === null || before.parentElement === this.element)) formatDevErrorMessage(`DOMSlot.insertChild: before is not in element`);
+		this.element.insertBefore(dom, before);
+		return this;
+	}
+	/**
+	* Remove the given child from `this.element`. Throws if it was not a child.
+	*/
+	removeChild(dom) {
+		if (!(dom.parentElement === this.element)) formatDevErrorMessage(`DOMSlot.removeChild: dom is not in element`);
+		this.element.removeChild(dom);
+		return this;
+	}
+	/**
+	* Replace `prevDom` with `dom`. Throws if `prevDom` is not a child.
+	*/
+	replaceChild(dom, prevDom) {
+		if (!(prevDom.parentElement === this.element)) formatDevErrorMessage(`DOMSlot.replaceChild: prevDom is not in element`);
+		this.element.replaceChild(dom, prevDom);
+		return this;
+	}
+	/**
+	* Returns the first managed child (the first node in
+	* `this.element` that is not a non-lexical prelude / decoration), or
+	* `null` if there is none. Subclasses may override to also skip
+	* reconciler-managed scaffolding such as the managed line break.
+	*/
+	getFirstChild() {
+		const anchor = this.getFirstChildAnchor();
+		const firstChild = anchor ? anchor.nextSibling : this.element.firstChild;
+		return firstChild === this.getInsertionAnchor() ? null : firstChild;
+	}
+	/**
+	* @internal
+	*
+	* The leading-boundary counterpart to {@link getInsertionAnchor}: the node
+	* the lexical-managed range starts immediately after (its `nextSibling` is
+	* the first managed child), or `null` when managed children begin at
+	* `this.element.firstChild`. The base slot uses `this.after`; subclasses
+	* extend it to skip leading non-lexical scaffolding (e.g. the block cursor).
+	*/
+	getFirstChildAnchor() {
+		return this.after;
+	}
+	/**
+	* Map a DOM selection point landing at or inside `leafDOM` (the node's
+	* keyed DOM) to whether the caret is positioned BEFORE or AFTER the
+	* node in document order. The default implementation derives the
+	* boundary from `this.element`'s index inside `leafDOM`:
+	*
+	* - When `this.element === leafDOM` (no wrap exposed an inner content
+	*   element via `withElement`): only a DOM caret directly on
+	*   `leafDOM` at offset 0 counts as "before". Matches the historical
+	*   decorator rule.
+	* - When `this.element !== leafDOM` (wrap pattern that exposed the
+	*   inner content element via `withElement`, e.g. a `<br>` inside a
+	*   decoration `<span>`): caret positions at or before the content
+	*   element are "before", later positions are "after". Handles
+	*   nested wraps by walking each side up to its top-level child of
+	*   `leafDOM`.
+	*
+	* Symmetric with {@link ElementDOMSlot.resolveChildIndex}, which
+	* performs the analogous mapping for ElementNode children. Together
+	* they let the slot abstraction own all DOM-offset to lexical-offset
+	* translation.
+	*
+	* @internal
+	*/
+	resolveLeafPosition(leafDOM, initialDOM, initialOffset) {
+		if (this.element === leafDOM) return initialDOM === leafDOM && initialOffset === 0 ? "before" : "after";
+		const innerChild = $topLevelChildOf(leafDOM, this.element);
+		if (innerChild === null) return "after";
+		const innerIndex = Array.prototype.indexOf.call(leafDOM.childNodes, innerChild);
+		if (innerIndex < 0) return "after";
+		if (initialDOM === leafDOM) return initialOffset <= innerIndex ? "before" : "after";
+		const initialChild = $topLevelChildOf(leafDOM, initialDOM);
+		if (initialChild === null) return "after";
+		const childIndex = Array.prototype.indexOf.call(leafDOM.childNodes, initialChild);
+		return childIndex >= 0 && childIndex <= innerIndex ? "before" : "after";
+	}
+	/**
+	* @internal
+	*
+	* The node managed children are inserted before, or `null` to append.
+	* Subclasses widen this to reserve trailing scaffolding (e.g.
+	* {@link ElementDOMSlot} keeps the managed line break last).
+	*/
+	getInsertionAnchor() {
+		return this.before;
+	}
+};
+function $topLevelChildOf(parent, descendant) {
+	let node = descendant;
+	while (node !== null && node.parentNode !== parent) node = node.parentNode;
+	return node;
+}
+/**
+* A utility class for managing the DOM children of an ElementNode.
+*
+* Extends {@link DOMSlot} with ElementNode-specific scaffolding — the
+* reconciler-managed line break that keeps empty elements selectable, and
+* the offset / index resolution helpers needed when mapping DOM selections
+* onto lexical positions. The base `before` / `after` boundaries and the
+* children mutation helpers (`insertChild`, `removeChild`, …) live on
+* {@link DOMSlot}.
+*/
+var ElementDOMSlot = class ElementDOMSlot extends DOMSlot {
+	/** Return a new slot with `before` updated, preserving subclass type. */
+	withBefore(before) {
+		return new ElementDOMSlot(this.element, before, this.after);
+	}
+	/** Return a new slot with `after` updated, preserving subclass type. */
+	withAfter(after) {
+		return new ElementDOMSlot(this.element, this.before, after);
+	}
+	/** Return a new slot with `element` updated, preserving subclass type. */
+	withElement(element) {
+		if (this.element === element) return this;
+		return new ElementDOMSlot(element, this.before, this.after);
+	}
+	/**
+	* @internal
+	*/
+	getInsertionAnchor() {
+		return super.getInsertionAnchor() || this.getManagedLineBreak();
+	}
+	/**
+	* @internal
+	*
+	* Extends the leading boundary to skip the editor's transient block cursor
+	* when it sits at the head of the managed range (a collapsed element
+	* selection at offset 0), mirroring how {@link getInsertionAnchor} extends
+	* the trailing boundary past the managed line break. Only ElementNodes host
+	* 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;
+	}
+	/**
+	* @internal
+	*/
+	getManagedLineBreak() {
+		return this.element.__lexicalLineBreak || null;
+	}
+	/** @internal */
+	setManagedLineBreak(lineBreakType) {
+		const element = this.element;
+		element.__lexicalLastChildKind = lineBreakType;
+		if (lineBreakType === null) this.removeManagedLineBreak();
+		else {
+			const webkitHack = lineBreakType === "decorator" && (IS_APPLE_WEBKIT || IS_IOS || IS_SAFARI);
+			this.insertManagedLineBreak(webkitHack);
+		}
+	}
+	/** @internal */
+	removeManagedLineBreak() {
+		const br = this.getManagedLineBreak();
+		if (br) {
+			const element = this.element;
+			const sibling = br.nodeName === "IMG" ? br.nextSibling : null;
+			if (sibling) element.removeChild(sibling);
+			element.removeChild(br);
+			element.__lexicalLineBreak = void 0;
+		}
+	}
+	/** @internal */
+	insertManagedLineBreak(webkitHack) {
+		const prevBreak = this.getManagedLineBreak();
+		if (prevBreak) {
+			if (webkitHack === (prevBreak.nodeName === "IMG")) return;
+			this.removeManagedLineBreak();
+		}
+		const element = this.element;
+		const before = this.before;
+		const br = document.createElement("br");
+		element.insertBefore(br, before);
+		if (webkitHack) {
+			const img = document.createElement("img");
+			img.setAttribute("data-lexical-linebreak", "true");
+			img.style.setProperty("display", "inline", "important");
+			img.style.setProperty("border", "0px", "important");
+			img.style.setProperty("margin", "0px", "important");
+			img.alt = "";
+			element.insertBefore(img, br);
+			element.__lexicalLineBreak = img;
+		} else element.__lexicalLineBreak = br;
+	}
+	/**
+	* @internal
+	*
+	* The DOM child index at which the first managed child appears — i.e. the
+	* count of leading non-lexical nodes (the `this.after` region, plus the
+	* block cursor when it sits at the head). Walks forward from the start,
+	* stopping at the first managed child, or at the trailing boundary
+	* (`this.before` / the managed line break via {@link getInsertionAnchor})
+	* when there are no managed children.
+	*/
+	getFirstChildOffset() {
+		const firstChild = this.getFirstChild();
+		const insertionAnchor = this.getInsertionAnchor();
+		let i = 0;
+		for (let node = this.element.firstChild; node !== null && node !== firstChild && node !== insertionAnchor; node = node.nextSibling) i++;
+		return i;
+	}
+	/**
+	* @internal
+	*/
+	resolveChildIndex(element, elementDOM, initialDOM, initialOffset) {
+		if (initialDOM === this.element) {
+			const firstChildOffset = this.getFirstChildOffset();
+			const blockCursor = $getActiveBlockCursorElement();
+			const childNodes = this.element.childNodes;
+			const limit = Math.min(initialOffset, childNodes.length);
+			let idx = 0;
+			for (let i = firstChildOffset; i < limit; i++) if (childNodes[i] !== blockCursor) idx++;
+			return [element, Math.min(idx, element.getChildrenSize())];
+		}
+		const initialPath = indexPath(elementDOM, initialDOM);
+		initialPath.push(initialOffset);
+		const elementPath = indexPath(elementDOM, this.element);
+		let offset = element.getIndexWithinParent();
+		for (let i = 0; i < elementPath.length; i++) {
+			const target = initialPath[i];
+			const source = elementPath[i];
+			if (target === void 0 || target < source) break;
+			else if (target > source) {
+				offset += 1;
+				break;
+			}
+		}
+		return [element.getParentOrThrow(), offset];
+	}
+};
+function indexPath(root, child) {
+	const path = [];
+	let node = child;
+	for (; node !== root && node !== null; node = node.parentNode) {
+		let i = 0;
+		for (let sibling = node.previousSibling; sibling !== null; sibling = sibling.previousSibling) i++;
+		path.push(i);
+	}
+	if (!(node === root)) formatDevErrorMessage(`indexPath: root is not a parent of child`);
+	return path.reverse();
+}
+/**
+* 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.
+*
+*/
+let envLexicalVersion;
+try {
+	envLexicalVersion = "0.45.0+dev.esm";
+} catch (_unused) {}
+const LEXICAL_VERSION = envLexicalVersion ?? "0.45.0+source";
+/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
@@ -178,6 +485,191 @@ var DequeSet = class {
 * LICENSE file in the root directory of this source tree.
 *
 */
+const TOMBSTONE = null;
+const GEN_MAP_SIZE_THRESHOLD = 1e3;
+/**
+* @internal
+*
+* Create a copy of the given Map, returning either a fresh Map or a clone
+* of a copy-on-write GenMap depending on the source type and size.
+*
+* - If the source is already a GenMap, returns `map.clone()` (O(1)).
+* - If the source is a plain Map below the threshold, returns
+*   `new Map(map)` to avoid the GenMap overhead on small docs.
+* - Otherwise wraps a fresh GenMap around the source.
+*/
+function cloneMap(map, minGenMapSize = GEN_MAP_SIZE_THRESHOLD) {
+	if (map instanceof GenMap) return map.clone();
+	if (map.size < minGenMapSize) return new Map(map);
+	return new GenMap().init(new Map(map), void 0, map.size);
+}
+/**
+* @internal
+*
+* A copy-on-write Map suitable for cloning large collections cheaply.
+*
+* Before being written to, a GenMap shares its `_old` and `_nursery` Maps
+* with the GenMap it was cloned from. On first write it either compacts
+* (folds `_nursery` into a new `_old`) or shallow-copies `_nursery`,
+* isolating subsequent writes from sibling clones.
+*
+* `_old` is the immutable snapshot from the most recent compaction;
+* `_nursery` holds writes since the last compaction (deletions stored as
+* `TOMBSTONE`). `_mutable` tracks whether `_nursery` may be written to
+* directly or must first be cloned.
+*
+* Implements the full `Map<K, V>` interface; methods not documented
+* individually behave as their native `Map` counterparts.
+*/
+var GenMap = class GenMap {
+	_mutable = false;
+	_old = void 0;
+	_nursery = void 0;
+	_size = 0;
+	/**
+	* Returns a new GenMap that initially shares `_old` and `_nursery`
+	* with this one. Marks both as not-mutable so the next write on either
+	* side triggers a copy-on-write of the nursery before mutating.
+	*/
+	clone() {
+		this._mutable = false;
+		return new GenMap().init(this._old, this._nursery, this._size);
+	}
+	init(old, nursery, size) {
+		this._old = old;
+		this._nursery = nursery;
+		this._size = size;
+		return this;
+	}
+	get size() {
+		return this._size;
+	}
+	has(key) {
+		return this.get(key) !== void 0;
+	}
+	/**
+	* Returns the raw value for `key`, including TOMBSTONE for keys deleted
+	* since the last compaction. Used internally to distinguish "missing"
+	* from "deleted" without doing a second lookup.
+	*/
+	getWithTombstone(key) {
+		const v = this._nursery && this._nursery.get(key);
+		if (v !== void 0) return v;
+		return this._old && this._old.get(key);
+	}
+	get(key) {
+		const v = this.getWithTombstone(key);
+		return v === TOMBSTONE ? void 0 : v;
+	}
+	shouldCompact() {
+		return this._nursery !== void 0 && this._nursery.size * 2 > this._size;
+	}
+	/**
+	* Returns the nursery for in-place writes. If this GenMap is currently
+	* sharing its nursery with an ancestor clone, this either compacts (if
+	* the nursery has grown large enough) or makes a shallow copy.
+	*/
+	getNursery() {
+		if (!this._mutable || !this._nursery) {
+			this.compact();
+			this._nursery = new Map(this._nursery);
+			this._mutable = true;
+		}
+		return this._nursery;
+	}
+	/**
+	* Fold the nursery into a new `_old` snapshot when it has grown large
+	* enough that lookup overhead outweighs the savings from sharing.
+	* Triggered automatically from `getNursery` once `_nursery.size * 2 >
+	* _size`; can be forced via `compact(true)`.
+	*/
+	compact(force = false) {
+		if (this._nursery && this._nursery.size > 0 && (force || this.shouldCompact())) {
+			const compact = new Map(this._old);
+			for (const [k, v] of this._nursery) if (v !== TOMBSTONE) compact.set(k, v);
+			else compact.delete(k);
+			this._old = compact;
+			this._nursery = void 0;
+		}
+		this._mutable = false;
+		return this;
+	}
+	set(key, value) {
+		const v = this.getWithTombstone(key);
+		if (v === value) return this;
+		const nursery = this.getNursery();
+		if (v === TOMBSTONE || v === void 0) {
+			this._size++;
+			if (v === TOMBSTONE) nursery.delete(key);
+		}
+		nursery.set(key, value);
+		return this;
+	}
+	delete(key) {
+		const deleted = this.has(key);
+		if (deleted) {
+			this.getNursery().set(key, TOMBSTONE);
+			this._size--;
+		}
+		return deleted;
+	}
+	getOrInsert(key, defaultValue) {
+		const existing = this.get(key);
+		if (existing !== void 0) return existing;
+		this.set(key, defaultValue);
+		return defaultValue;
+	}
+	getOrInsertComputed(key, computer) {
+		const existing = this.get(key);
+		if (existing !== void 0) return existing;
+		const value = computer(key);
+		this.set(key, value);
+		return value;
+	}
+	clear() {
+		this._mutable = false;
+		this._old = void 0;
+		this._nursery = void 0;
+		this._size = 0;
+	}
+	*keys() {
+		for (const pair of this.entries()) yield pair[0];
+	}
+	*values() {
+		for (const pair of this.entries()) yield pair[1];
+	}
+	*entries() {
+		const nursery = this._nursery;
+		const old = this._old;
+		if (old) for (const pair of old) {
+			const k = pair[0];
+			const v = nursery ? nursery.get(k) : void 0;
+			if (v === TOMBSTONE) continue;
+			else if (v !== void 0) pair[1] = v;
+			yield pair;
+		}
+		if (nursery) {
+			for (const pair of nursery) if (pair[1] !== TOMBSTONE && !(old && old.has(pair[0]))) yield pair;
+		}
+	}
+	forEach(callbackfn, thisArg) {
+		if (thisArg !== void 0) callbackfn = callbackfn.bind(thisArg);
+		for (const [k, v] of this.entries()) callbackfn(v, k, this);
+	}
+	get [Symbol.toStringTag]() {
+		return "GenMap";
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+/**
+* 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.
+*
+*/
 function $garbageCollectDetachedDecorators(editor, pendingEditorState) {
 	const currentDecorators = editor._decorators;
 	let decorators = editor._pendingDecorators || currentDecorators;
@@ -308,7 +800,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)) {
+						if (parentDOM != null && addedDOM !== blockCursorElement && node === null && !isManagedLineBreak(addedDOM, parentDOM, editor) && !isDOMUnmanaged(addedDOM)) {
 							if (IS_FIREFOX) {
 								const possibleText = (isHTMLElement(addedDOM) ? addedDOM.innerText : null) || addedDOM.nodeValue;
 								if (possibleText) possibleTextForFirefoxPaste += possibleText;
@@ -587,7 +1079,7 @@ function $setState(node, stateConfig, valueOrUpdater) {
 * @internal
 *
 * Register the config to this node's sharedConfigMap and throw an exception in
-* `true` when a collision is detected.
+* `__DEV__` when a collision is detected.
 */
 function $checkCollision(node, stateConfig, state) {
 	{
@@ -1055,9 +1547,112 @@ function $normalizePoint(point) {
 		point.set(nextNode.__key, nextOffsetAtEnd ? nextNode.getChildrenSize() : 0, "element", true);
 	}
 }
+/**
+* @internal
+*
+* A reconcile-managed cache of `getTextContentSize()` for leaf nodes.
+*
+* Stored as a Symbol-keyed property on the node instance itself so that
+* read/write are direct slot access. The slot is pre-allocated to
+* `undefined` as a non-enumerable property in the LexicalNode constructor
+* so all instances share the same V8 hidden-class shape and the setter is
+* a stable inline cache hit instead of a per-instance shape transition.
+*
+* ElementNodes are NOT stored here: an element can be dirty without being
+* cloned (a descendant edit marks ancestors dirty via
+* `internalMarkParentElementsAsDirty` but does not `getWritable()` them), so
+* the same — DEV-frozen — instance would need its size rewritten when its
+* text changes, which the skip-if-set guard cannot do. Element sizes come
+* from `dom.__lexicalTextContent` instead (see `$prevSuffixTextSize`).
+*
+* Leaf writes are skipped when the slot is already not `undefined`. The
+* setter is only re-entered for the same instance via cross-parent moves
+* (where the leaf is reused in a new parent without going through
+* `getWritable` — text is unchanged, so the prior cycle's value is still
+* correct). A leaf whose text actually changed went through
+* `getWritable()` and produced a fresh clone via `static clone(node)` ->
+* ctor -> fresh `undefined` slot, so the setter writes through normally.
+*
+* The reconciler sets this on every reconciled leaf at the end of
+* `$reconcileNode` (and on every newly-created leaf in `$createNode`), so
+* the previous editor state's leaves always carry a valid cached size from
+* the cycle that just committed.
+*
+* Suffix-incremental fast path reads this off the previous-state instance
+* to get the pre-reconcile size of dirty children in O(1), avoiding both
+* the `getLatest()` -> next-state trap and a recursive prev-tree walk.
+*/
+const CACHED_TEXT_SIZE_KEY = Symbol.for("@lexical/CachedTextSize");
+function $prevSuffixTextSize(startKey, count) {
+	return activePrevEditorState.read(() => {
+		let size = 0;
+		let cur = startKey;
+		for (let i = 0; i < count && cur !== null; i++) {
+			const prevNode = activePrevNodeMap.get(cur);
+			if (!(prevNode !== void 0)) formatDevErrorMessage(`prevSuffixTextSize: missing prev node for key ${cur}`);
+			if ($isElementNode(prevNode)) {
+				const nextNode = activeNextNodeMap.get(cur);
+				if (nextNode !== void 0 && $isElementNode(nextNode) && nextNode.__parent !== prevNode.__parent) size += prevNode.getTextContentSize();
+				else {
+					const keyedDom = activePrevKeyToDOMMap.get(cur);
+					const cached = keyedDom && keyedDom.__lexicalTextContent;
+					if (!(typeof cached === "string")) formatDevErrorMessage(`prevSuffixTextSize: missing __lexicalTextContent for ElementNode of type ${prevNode.getType()}`);
+					size += cached.length;
+				}
+				if (i < count - 1 && !prevNode.isInline()) size += 2;
+			} else {
+				const cached = prevNode[CACHED_TEXT_SIZE_KEY];
+				if (!(cached !== void 0)) formatDevErrorMessage(`prevSuffixTextSize: missing cached size for leaf ${prevNode.getType()} key ${cur}`);
+				size += cached;
+			}
+			cur = prevNode.__next;
+		}
+		return size;
+	}, { editor: activeEditor$1 });
+}
+function $setCachedTextSize(node) {
+	if ($isElementNode(node)) return;
+	if (node[CACHED_TEXT_SIZE_KEY] !== void 0) return;
+	node[CACHED_TEXT_SIZE_KEY] = $isTextNode(node) ? node.__text.length : node.getTextContentSize();
+}
+/**
+* Minimum children count for the suffix-incremental fast path to engage.
+* The fast path adds bookkeeping (cache lookups, suffix walks, splice) that
+* a few-children parent's general walk would beat — gate by a threshold so
+* the overhead only kicks in where the prefix preservation pays for it.
+* Tuned via `editorCycle.bench`.
+*/
+const MIN_FAST_PATH_CHILDREN = 4;
 let subTreeTextContent = "";
 let subTreeTextFormat = null;
 let subTreeTextStyle = null;
+let subTreeFirstTextKey = null;
+function $beginCaptureGuard() {
+	return {
+		firstTextKey: subTreeFirstTextKey,
+		format: subTreeTextFormat,
+		style: subTreeTextStyle
+	};
+}
+function $endCaptureGuard(saved) {
+	if (saved.firstTextKey !== null) {
+		subTreeTextFormat = saved.format;
+		subTreeTextStyle = saved.style;
+		subTreeFirstTextKey = saved.firstTextKey;
+	}
+}
+function $bubbleChildFirstText(childKeyedDom) {
+	if (subTreeFirstTextKey !== null) return;
+	const childFirstKey = childKeyedDom.__lexicalFirstTextKey;
+	if (!(childFirstKey !== void 0)) formatDevErrorMessage(`$bubbleChildFirstText: missing __lexicalFirstTextKey on element keyed DOM`);
+	if (childFirstKey === null) return;
+	const textNode = activeNextNodeMap.get(childFirstKey);
+	if ($isTextNode(textNode)) {
+		subTreeTextFormat = textNode.getFormat();
+		subTreeTextStyle = textNode.getStyle();
+		subTreeFirstTextKey = childFirstKey;
+	}
+}
 let activeEditorConfig;
 let activeEditor$1;
 let activeEditorNodes;
@@ -1067,17 +1662,21 @@ let activeMutationListeners;
 let activeDirtyElements;
 let activeDirtyLeaves;
 let activePrevNodeMap;
+let activePrevEditorState;
 let activeNextNodeMap;
 let activePrevKeyToDOMMap;
+let activeDirtyChildrenByParent;
 let mutatedNodes;
 let activeEditorDOMRenderConfig;
 function $destroyNode(key, parentDOM) {
 	const node = activePrevNodeMap.get(key);
+	const isMoved = activeNextNodeMap.has(key);
 	if (parentDOM !== null) {
 		const dom = getPrevElementByKeyOrThrow(key);
 		if (dom.parentNode === parentDOM) parentDOM.removeChild(dom);
 	}
-	if (!activeNextNodeMap.has(key)) activeEditor$1._keyToDOMMap.delete(key);
+	if (isMoved) return;
+	activeEditor$1._keyToDOMMap.delete(key);
 	if ($isElementNode(node)) {
 		const children = $createChildrenArray(node, activePrevNodeMap);
 		$destroyChildren(children, 0, children.length - 1, null);
@@ -1101,12 +1700,7 @@ function setElementIndent(dom, indent) {
 		if (indent > 0 && !elementHasClassName) dom.classList.add(indentClassName);
 		else if (indent < 1 && elementHasClassName) dom.classList.remove(indentClassName);
 	}
-	if (indent === 0) {
-		dom.style.setProperty("padding-inline-start", "");
-		return;
-	}
-	const indentationBaseValue = getComputedStyle(activeEditor$1._rootElement || dom).getPropertyValue("--lexical-indent-base-value") || DEFAULT_INDENT_VALUE;
-	dom.style.setProperty("padding-inline-start", `calc(${indent} * ${indentationBaseValue})`);
+	dom.style.setProperty("padding-inline-start", indent === 0 ? "" : `calc(${indent} * var(--lexical-indent-base-value, ${DEFAULT_INDENT_VALUE}))`);
 }
 function setElementFormat(dom, format) {
 	const domStyle = dom.style;
@@ -1123,7 +1717,7 @@ function $getReconciledDirection(node) {
 	if (direction !== null) return direction;
 	if ($isRootNode(node)) return null;
 	const parent = node.getParentOrThrow();
-	if (!$isRootNode(parent) || parent.__dir !== null) return null;
+	if (!$isRootOrShadowRoot(parent) || parent.__dir !== null) return null;
 	return "auto";
 }
 function $setElementDirection(dom, node) {
@@ -1134,6 +1728,16 @@ function $setElementDirection(dom, node) {
 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) {
+			const existingDOM = activePrevKeyToDOMMap.get(key);
+			if (existingDOM !== void 0) {
+				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");
@@ -1143,9 +1747,12 @@ function $createNode(key, slot) {
 		const childrenSize = node.__size;
 		$setElementDirection(dom, node);
 		if (indent !== 0) setElementIndent(dom, indent);
-		if (childrenSize !== 0) {
+		if (childrenSize === 0) {
+			dom.__lexicalTextContent = "";
+			dom.__lexicalFirstTextKey = null;
+		} else {
 			const endIndex = childrenSize - 1;
-			$createChildren($createChildrenArray(node, activeNextNodeMap), node, 0, endIndex, activeEditorDOMRenderConfig.$getDOMSlot(node, dom, activeEditor$1));
+			$createChildren($createChildrenArray(node, activeNextNodeMap), node, 0, endIndex, $getDOMSlot(node, dom, activeEditor$1));
 		}
 		const format = node.__format;
 		if (format !== 0) setElementFormat(dom, format);
@@ -1161,27 +1768,38 @@ function $createNode(key, slot) {
 	}
 	if (slot !== null) slot.insertChild(dom);
 	activeEditorDOMRenderConfig.$decorateDOM(node, null, dom, activeEditor$1);
+	$setCachedTextSize(node);
 	Object.freeze(node);
 	setMutatedNode(mutatedNodes, activeEditorNodes, activeMutationListeners, node, "created");
 	return dom;
 }
 function $createChildren(children, element, _startIndex, endIndex, slot) {
 	const previousSubTreeTextContent = subTreeTextContent;
+	const outerSaved = $beginCaptureGuard();
 	subTreeTextContent = "";
+	subTreeTextFormat = null;
+	subTreeTextStyle = null;
+	subTreeFirstTextKey = null;
 	let startIndex = _startIndex;
 	for (; startIndex <= endIndex; ++startIndex) {
+		const saved = $beginCaptureGuard();
 		$createNode(children[startIndex], slot);
 		const node = activeNextNodeMap.get(children[startIndex]);
 		if (node !== null && $isTextNode(node)) {
 			if (subTreeTextFormat === null) {
 				subTreeTextFormat = node.getFormat();
 				subTreeTextStyle = node.getStyle();
+				subTreeFirstTextKey = node.__key;
 			}
 		} else if ($isElementNode(node) && startIndex < endIndex && !node.isInline()) subTreeTextContent += DOUBLE_LINE_BREAK;
+		$endCaptureGuard(saved);
 	}
-	const dom = slot.element;
-	dom.__lexicalTextContent = subTreeTextContent;
+	const cacheDom = activeEditor$1._keyToDOMMap.get(element.__key);
+	if (!(cacheDom !== void 0)) formatDevErrorMessage(`$createChildren: Element with key ${element.__key} missing from keyToDOMMap`);
+	cacheDom.__lexicalTextContent = subTreeTextContent;
+	cacheDom.__lexicalFirstTextKey = subTreeFirstTextKey;
 	subTreeTextContent = previousSubTreeTextContent + subTreeTextContent;
+	$endCaptureGuard(outerSaved);
 }
 function isLastChildLineBreakOrDecorator(element, nodeMap) {
 	if (element) {
@@ -1195,9 +1813,10 @@ function isLastChildLineBreakOrDecorator(element, nodeMap) {
 	return null;
 }
 function $reconcileElementTerminatingLineBreak(prevElement, nextElement, dom) {
-	const prevLineBreak = isLastChildLineBreakOrDecorator(prevElement, activePrevNodeMap);
+	const slot = $getDOMSlot(nextElement, dom, activeEditor$1);
+	const prevLineBreak = slot.element.__lexicalLastChildKind ?? null;
 	const nextLineBreak = isLastChildLineBreakOrDecorator(nextElement, activeNextNodeMap);
-	if (prevLineBreak !== nextLineBreak) activeEditorDOMRenderConfig.$getDOMSlot(nextElement, dom, activeEditor$1).setManagedLineBreak(nextLineBreak);
+	if (prevLineBreak !== nextLineBreak) slot.setManagedLineBreak(nextLineBreak);
 }
 function reconcileTextFormat(element) {
 	if (subTreeTextFormat != null && subTreeTextFormat !== element.__textFormat && !activeEditorStateReadOnly) element.setTextFormat(subTreeTextFormat);
@@ -1208,9 +1827,210 @@ function reconcileTextStyle(element) {
 function $reconcileChildrenWithDirection(prevElement, nextElement, dom) {
 	subTreeTextFormat = null;
 	subTreeTextStyle = null;
-	$reconcileChildren(prevElement, nextElement, activeEditorDOMRenderConfig.$getDOMSlot(nextElement, dom, activeEditor$1));
-	reconcileTextFormat(nextElement);
-	reconcileTextStyle(nextElement);
+	subTreeFirstTextKey = null;
+	$reconcileChildren(prevElement, nextElement, $getDOMSlot(nextElement, dom, activeEditor$1));
+	if (!$isRootOrShadowRoot(nextElement)) {
+		reconcileTextFormat(nextElement);
+		reconcileTextStyle(nextElement);
+	}
+}
+function $buildDirtyChildrenByParent() {
+	const map = /* @__PURE__ */ new Map();
+	const addKeysToMap = (keys) => {
+		for (const key of keys) {
+			const node = activeNextNodeMap.get(key);
+			if (node === void 0) continue;
+			const parentKey = node.__parent;
+			if (parentKey === null) continue;
+			let set = map.get(parentKey);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				map.set(parentKey, set);
+			}
+			set.add(key);
+		}
+	};
+	addKeysToMap(activeDirtyElements.keys());
+	addKeysToMap(activeDirtyLeaves);
+	return map;
+}
+function $suffixStartIfContiguous(parent, dirty) {
+	const k = dirty.size;
+	if (k === 0 || k >= parent.__size) return null;
+	let cur = parent.__last;
+	let suffixStart = null;
+	let i = 0;
+	while (cur !== null && i < k) {
+		if (!dirty.has(cur)) return null;
+		suffixStart = cur;
+		const node = activeNextNodeMap.get(cur);
+		if (node === void 0) return null;
+		cur = node.__prev;
+		i++;
+	}
+	if (i !== k) return null;
+	if (cur !== null && dirty.has(cur)) return null;
+	return suffixStart;
+}
+function $tryReconcileSuffixWithSizeDelta(prevElement, nextElement, slot, cacheDom, cachedParentText, suffixStartKey, k, sizeDelta) {
+	if (sizeDelta !== 1 && sizeDelta !== -1) return false;
+	if (k !== (sizeDelta === 1 ? 2 : 1)) return false;
+	const kPrime = k - sizeDelta;
+	let prevSuffixStartKey = prevElement.__last;
+	for (let i = 0; i < kPrime - 1; i++) {
+		if (prevSuffixStartKey === null) return false;
+		const node = activePrevNodeMap.get(prevSuffixStartKey);
+		if (node === void 0) return false;
+		prevSuffixStartKey = node.__prev;
+	}
+	if (prevSuffixStartKey === null) return false;
+	const nextStartNode = activeNextNodeMap.get(suffixStartKey);
+	const prevStartNode = activePrevNodeMap.get(prevSuffixStartKey);
+	if (nextStartNode === void 0 || prevStartNode === void 0) return false;
+	if (nextStartNode.__prev !== prevStartNode.__prev) return false;
+	const nextSuffixKeys = [];
+	let cur = suffixStartKey;
+	for (let i = 0; i < k; i++) {
+		if (cur === null) return false;
+		nextSuffixKeys.push(cur);
+		const node = activeNextNodeMap.get(cur);
+		cur = node ? node.__next : null;
+	}
+	const prevSuffixKeys = [];
+	cur = prevSuffixStartKey;
+	for (let i = 0; i < kPrime; i++) {
+		if (cur === null) return false;
+		prevSuffixKeys.push(cur);
+		const node = activePrevNodeMap.get(cur);
+		cur = node ? node.__next : null;
+	}
+	const prevSet = new Set(prevSuffixKeys);
+	const nextSet = new Set(nextSuffixKeys);
+	const ops = [];
+	let pi = 0;
+	let ni = 0;
+	while (pi < kPrime && ni < k) if (nextSuffixKeys[ni] === prevSuffixKeys[pi]) {
+		ops.push({
+			key: nextSuffixKeys[ni],
+			kind: "reconcile"
+		});
+		pi++;
+		ni++;
+	} else if (!nextSet.has(prevSuffixKeys[pi])) {
+		ops.push({
+			key: prevSuffixKeys[pi],
+			kind: "destroy"
+		});
+		pi++;
+	} else if (!prevSet.has(nextSuffixKeys[ni])) {
+		ops.push({
+			key: nextSuffixKeys[ni],
+			kind: "create",
+			nextIndex: ni
+		});
+		ni++;
+	} else return false;
+	while (pi < kPrime) ops.push({
+		key: prevSuffixKeys[pi++],
+		kind: "destroy"
+	});
+	while (ni < k) {
+		ops.push({
+			key: nextSuffixKeys[ni],
+			kind: "create",
+			nextIndex: ni
+		});
+		ni++;
+	}
+	const oldSuffixLength = $prevSuffixTextSize(prevSuffixStartKey, kPrime);
+	for (const op of ops) {
+		const saved = $beginCaptureGuard();
+		if (op.kind === "reconcile") $reconcileNode(op.key, slot.element);
+		else if (op.kind === "destroy") $destroyNode(op.key, slot.element);
+		else {
+			let beforeDOM = null;
+			for (let j = op.nextIndex + 1; j < k; j++) {
+				const siblingDOM = activeEditor$1._keyToDOMMap.get(nextSuffixKeys[j]);
+				if (siblingDOM !== void 0) {
+					beforeDOM = siblingDOM;
+					break;
+				}
+			}
+			$createNode(op.key, slot.withBefore(beforeDOM ?? slot.before));
+		}
+		if (op.kind !== "destroy") {
+			const opNode = activeNextNodeMap.get(op.key);
+			if (opNode && $isTextNode(opNode) && subTreeTextFormat === null) {
+				subTreeTextFormat = opNode.getFormat();
+				subTreeTextStyle = opNode.getStyle();
+				subTreeFirstTextKey = opNode.__key;
+			}
+		}
+		$endCaptureGuard(saved);
+	}
+	let newSuffix = "";
+	for (let i = 0; i < k; i++) {
+		const node = activeNextNodeMap.get(nextSuffixKeys[i]);
+		if (node === void 0) return false;
+		let text;
+		if ($isElementNode(node)) {
+			const childKeyedDom = activeEditor$1._keyToDOMMap.get(nextSuffixKeys[i]);
+			const cached = childKeyedDom && childKeyedDom.__lexicalTextContent;
+			if (!(typeof cached === "string")) formatDevErrorMessage(`tryReconcileSuffixWithSizeDelta: missing __lexicalTextContent on child of type ${node.getType()} after suffix reconcile`);
+			text = cached;
+		} else text = node.getTextContent();
+		newSuffix += text;
+		if (i < k - 1 && $isElementNode(node) && !node.isInline()) newSuffix += DOUBLE_LINE_BREAK;
+	}
+	cacheDom.__lexicalTextContent = cachedParentText.slice(0, cachedParentText.length - oldSuffixLength) + newSuffix;
+	return true;
+}
+/**
+* Decide whether the post-suffix-walk values of `subTreeTextFormat` /
+* `subTreeTextStyle` should be kept (the prefix has no text descendant
+* and the suffix carries the canonical first text) or replaced with the
+* prev-cycle's canonical values (the prefix is still authoritative).
+*
+* The cached `__lexicalFirstTextKey` on `dom` is the deep TextNode key
+* recorded when this element's children were last walked. We climb its
+* ancestor chain in next-state until we reach a direct child of
+* `nextElement`, then probe `dirtyChildren`: if that direct child is
+* dirty (or the cached key is missing from the next map), the cached
+* key has been moved into the suffix's subtree or destroyed, so the
+* suffix-derived values are authoritative. Otherwise the prefix is
+* canonical and we recover format/style from the live text node, which
+* lets `reconcileTextFormat` / `reconcileTextStyle` no-op via their
+* existing equality check against the parent's `__textFormat` /
+* `__textStyle`.
+*
+* Walk depth is bounded by tree depth from the text node to the
+* reconciled element (typically 1 — text directly under a paragraph).
+* Always refreshes the cache for the next cycle.
+*/
+function $resolveSuffixPathFormat(nextElement, dom, dirtyChildren) {
+	const cachedFirstTextKey = dom.__lexicalFirstTextKey;
+	if (cachedFirstTextKey != null) {
+		const parentKey = nextElement.__key;
+		let ancestor = cachedFirstTextKey;
+		while (ancestor !== null) {
+			const node = activeNextNodeMap.get(ancestor);
+			if (node === void 0) {
+				ancestor = null;
+				break;
+			}
+			if (node.__parent === parentKey) break;
+			ancestor = node.__parent;
+		}
+		if (ancestor !== null && !dirtyChildren.has(ancestor)) {
+			const textNode = activeNextNodeMap.get(cachedFirstTextKey);
+			if ($isTextNode(textNode)) {
+				subTreeTextFormat = textNode.getFormat();
+				subTreeTextStyle = textNode.getStyle();
+				return;
+			}
+		}
+	}
+	dom.__lexicalFirstTextKey = subTreeFirstTextKey;
 }
 function $reconcileChildren(prevElement, nextElement, slot) {
 	const previousSubTreeTextContent = subTreeTextContent;
@@ -1218,6 +2038,105 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 	const nextChildrenSize = nextElement.__size;
 	subTreeTextContent = "";
 	const dom = slot.element;
+	const cacheDom = activeEditor$1._keyToDOMMap.get(nextElement.__key);
+	if (!(cacheDom !== void 0)) formatDevErrorMessage(`$reconcileChildren: Element with key ${nextElement.__key} missing from keyToDOMMap`);
+	const sizeDelta = nextChildrenSize - prevChildrenSize;
+	if (!treatAllNodesAsDirty && Math.abs(sizeDelta) <= 1 && prevChildrenSize >= MIN_FAST_PATH_CHILDREN && prevElement.__first === nextElement.__first && (sizeDelta !== 0 || !activeEditor$1._cloneNotNeeded.has(prevElement.__key))) {
+		const cachedParentText = cacheDom.__lexicalTextContent;
+		const dirtyChildren = activeDirtyChildrenByParent.get(prevElement.__key);
+		if (!treatAllNodesAsDirty && typeof cachedParentText === "string" && dirtyChildren !== void 0) {
+			const suffixStartKey = $suffixStartIfContiguous(nextElement, dirtyChildren);
+			if (suffixStartKey !== null) {
+				const k = dirtyChildren.size;
+				if (sizeDelta === 0) {
+					const oldSuffixLength = $prevSuffixTextSize(suffixStartKey, k);
+					let cur = suffixStartKey;
+					let i = 0;
+					while (cur !== null && i < k) {
+						const node = activeNextNodeMap.get(cur);
+						if (node === void 0) break;
+						const saved = $beginCaptureGuard();
+						$reconcileNode(cur, dom);
+						if ($isTextNode(node) && subTreeTextFormat === null) {
+							subTreeTextFormat = node.getFormat();
+							subTreeTextStyle = node.getStyle();
+							subTreeFirstTextKey = node.__key;
+						}
+						$endCaptureGuard(saved);
+						cur = node.__next;
+						i++;
+					}
+					let newSuffix = "";
+					cur = suffixStartKey;
+					i = 0;
+					while (cur !== null && i < k) {
+						const node = activeNextNodeMap.get(cur);
+						if (node === void 0) break;
+						let text;
+						if ($isElementNode(node)) {
+							const childKeyedDom = activeEditor$1._keyToDOMMap.get(cur);
+							const cached = childKeyedDom && childKeyedDom.__lexicalTextContent;
+							if (!(typeof cached === "string")) formatDevErrorMessage(`reconcileChildren same-size suffix: missing __lexicalTextContent on child of type ${node.getType()} after reconcile`);
+							text = cached;
+						} else text = node.getTextContent();
+						newSuffix += text;
+						if (i < k - 1 && $isElementNode(node) && !node.isInline()) newSuffix += DOUBLE_LINE_BREAK;
+						cur = node.__next;
+						i++;
+					}
+					const newParentText = cachedParentText.slice(0, cachedParentText.length - oldSuffixLength) + newSuffix;
+					cacheDom.__lexicalTextContent = newParentText;
+					subTreeTextContent = previousSubTreeTextContent + newParentText;
+					$resolveSuffixPathFormat(nextElement, cacheDom, dirtyChildren);
+					return;
+				}
+				if ($tryReconcileSuffixWithSizeDelta(prevElement, nextElement, slot, cacheDom, cachedParentText, suffixStartKey, k, sizeDelta)) {
+					const newCachedText = cacheDom.__lexicalTextContent;
+					if (!(typeof newCachedText === "string")) formatDevErrorMessage(`reconcileChildren: $tryReconcileSuffixWithSizeDelta returned true without writing __lexicalTextContent`);
+					subTreeTextContent = previousSubTreeTextContent + newCachedText;
+					$resolveSuffixPathFormat(nextElement, cacheDom, dirtyChildren);
+					return;
+				}
+			}
+		}
+		if (sizeDelta === 0) {
+			let nodeKey = prevElement.__first;
+			let i = 0;
+			while (nodeKey !== null) {
+				const node = activeNextNodeMap.get(nodeKey);
+				if (node === void 0) break;
+				const isDirty = treatAllNodesAsDirty || activeDirtyLeaves.has(nodeKey) || activeDirtyElements.has(nodeKey);
+				const saved = $beginCaptureGuard();
+				if (isDirty) $reconcileNode(nodeKey, dom);
+				else {
+					let text;
+					let childKeyedDom;
+					if ($isElementNode(node)) {
+						childKeyedDom = activePrevKeyToDOMMap.get(nodeKey);
+						const cached = childKeyedDom && childKeyedDom.__lexicalTextContent;
+						if (!(typeof cached === "string")) formatDevErrorMessage(`reconcileChildren structurally-clean walk: missing __lexicalTextContent on non-dirty child of type ${node.getType()}`);
+						text = cached;
+					} else text = node.getTextContent();
+					subTreeTextContent += text;
+					if (childKeyedDom !== void 0) $bubbleChildFirstText(childKeyedDom);
+				}
+				if ($isTextNode(node)) {
+					if (subTreeTextFormat === null) {
+						subTreeTextFormat = node.getFormat();
+						subTreeTextStyle = node.getStyle();
+						subTreeFirstTextKey = node.__key;
+					}
+				} else if ($isElementNode(node) && i < nextChildrenSize - 1 && !node.isInline()) subTreeTextContent += DOUBLE_LINE_BREAK;
+				$endCaptureGuard(saved);
+				nodeKey = node.__next;
+				i++;
+			}
+			cacheDom.__lexicalTextContent = subTreeTextContent;
+			cacheDom.__lexicalFirstTextKey = subTreeFirstTextKey;
+			subTreeTextContent = previousSubTreeTextContent + subTreeTextContent;
+			return;
+		}
+	}
 	if (prevChildrenSize === 1 && nextChildrenSize === 1) {
 		const prevFirstChildKey = prevElement.__first;
 		const nextFirstChildKey = nextElement.__first;
@@ -1226,7 +2145,8 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 			const lastDOM = getPrevElementByKeyOrThrow(prevFirstChildKey);
 			const replacementDOM = $createNode(nextFirstChildKey, null);
 			try {
-				dom.replaceChild(replacementDOM, lastDOM);
+				if (lastDOM.parentNode === dom) dom.replaceChild(replacementDOM, lastDOM);
+				else slot.insertChild(replacementDOM);
 			} catch (error) {
 				if (typeof error === "object" && error != null) {
 					const msg = `${error.toString()} Parent: ${dom.tagName}, new child: {tag: ${replacementDOM.tagName} key: ${nextFirstChildKey}}, old child: {tag: ${lastDOM.tagName}, key: ${prevFirstChildKey}}.`;
@@ -1240,6 +2160,7 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 			if (subTreeTextFormat === null) {
 				subTreeTextFormat = nextChildNode.getFormat();
 				subTreeTextStyle = nextChildNode.getStyle();
+				subTreeFirstTextKey = nextChildNode.__key;
 			}
 		}
 	} else {
@@ -1257,7 +2178,8 @@ function $reconcileChildren(prevElement, nextElement, slot) {
 			}
 		} else $reconcileNodeChildren(nextElement, prevChildren, nextChildren, prevChildrenSize, nextChildrenSize, slot);
 	}
-	dom.__lexicalTextContent = subTreeTextContent;
+	cacheDom.__lexicalTextContent = subTreeTextContent;
+	cacheDom.__lexicalFirstTextKey = subTreeFirstTextKey;
 	subTreeTextContent = previousSubTreeTextContent + subTreeTextContent;
 }
 function $reconcileNode(key, parentDOM) {
@@ -1270,11 +2192,9 @@ function $reconcileNode(key, parentDOM) {
 		let text;
 		if ($isElementNode(prevNode)) {
 			const previousSubTreeTextContent = dom.__lexicalTextContent;
-			if (typeof previousSubTreeTextContent === "string") text = previousSubTreeTextContent;
-			else {
-				text = prevNode.getTextContent();
-				dom.__lexicalTextContent = text;
-			}
+			if (!(typeof previousSubTreeTextContent === "string")) formatDevErrorMessage(`reconcileNode: missing __lexicalTextContent on non-dirty element of type ${prevNode.getType()}`);
+			text = previousSubTreeTextContent;
+			$bubbleChildFirstText(dom);
 		} else text = prevNode.getTextContent();
 		subTreeTextContent += text;
 		return dom;
@@ -1298,15 +2218,11 @@ function $reconcileNode(key, parentDOM) {
 			if (!$isRootNode(nextNode) && !nextNode.isInline()) $reconcileElementTerminatingLineBreak(prevNode, nextNode, dom);
 		} else {
 			const previousSubTreeTextContent = dom.__lexicalTextContent;
-			let text;
-			if (typeof previousSubTreeTextContent === "string") text = previousSubTreeTextContent;
-			else {
-				text = prevNode.getTextContent();
-				dom.__lexicalTextContent = text;
-			}
-			subTreeTextContent += text;
+			if (!(typeof previousSubTreeTextContent === "string")) formatDevErrorMessage(`reconcileNode: missing __lexicalTextContent on cloned non-dirty element of type ${prevNode.getType()}`);
+			subTreeTextContent += previousSubTreeTextContent;
+			$bubbleChildFirstText(dom);
 		}
-		if (treatAllNodesAsDirty || nextNode.__dir !== prevNode.__dir) {
+		if (treatAllNodesAsDirty || nextNode.__dir !== prevNode.__dir || nextNode.__parent !== prevNode.__parent) {
 			$setElementDirection(dom, nextNode);
 			if ($isRootNode(nextNode) && !treatAllNodesAsDirty) {
 				for (const child of nextNode.getChildren()) if ($isElementNode(child)) $setElementDirection(getElementByKeyOrThrow(activeEditor$1, child.getKey()), child);
@@ -1320,12 +2236,16 @@ function $reconcileNode(key, parentDOM) {
 		}
 		subTreeTextContent += text;
 	}
-	if (!activeEditorStateReadOnly && $isRootNode(nextNode) && nextNode.__cachedText !== subTreeTextContent) {
-		const nextRootNode = nextNode.getWritable();
-		nextRootNode.__cachedText = subTreeTextContent;
-		nextNode = nextRootNode;
+	if (!activeEditorStateReadOnly && $isRootNode(nextNode)) {
+		const latestRoot = nextNode.getLatest();
+		if (latestRoot.__cachedText !== subTreeTextContent) {
+			const nextRootNode = latestRoot.getWritable();
+			nextRootNode.__cachedText = subTreeTextContent;
+			nextNode = nextRootNode;
+		}
 	}
 	activeEditorDOMRenderConfig.$decorateDOM(nextNode, prevNode, dom, activeEditor$1);
+	$setCachedTextSize(nextNode);
 	Object.freeze(nextNode);
 	return dom;
 }
@@ -1359,6 +2279,7 @@ function $reconcileNodeChildren(nextElement, prevChildren, nextChildren, prevChi
 	while (prevIndex <= prevEndIndex && nextIndex <= nextEndIndex) {
 		const prevKey = prevChildren[prevIndex];
 		const nextKey = nextChildren[nextIndex];
+		const saved = $beginCaptureGuard();
 		if (prevKey === nextKey) {
 			siblingDOM = getNextSibling($reconcileNode(nextKey, slot.element));
 			prevIndex++;
@@ -1368,6 +2289,7 @@ function $reconcileNodeChildren(nextElement, prevChildren, nextChildren, prevChi
 			if (prevChildrenSet === void 0) prevChildrenSet = childrenSet(prevChildren, prevIndex);
 			else if (!prevChildrenSet.has(prevKey)) {
 				prevIndex++;
+				$endCaptureGuard(saved);
 				continue;
 			}
 			if (!nextChildrenSet.has(prevKey)) {
@@ -1375,14 +2297,15 @@ function $reconcileNodeChildren(nextElement, prevChildren, nextChildren, prevChi
 				$destroyNode(prevKey, slot.element);
 				prevIndex++;
 				prevChildrenSet.delete(prevKey);
+				$endCaptureGuard(saved);
 				continue;
 			}
 			if (!prevChildrenSet.has(nextKey)) {
-				$createNode(nextKey, slot.withBefore(siblingDOM));
+				$createNode(nextKey, slot.withBefore(siblingDOM ?? slot.before));
 				nextIndex++;
 			} else {
 				const childDOM = getElementByKeyOrThrow(activeEditor$1, nextKey);
-				if (childDOM !== siblingDOM) slot.withBefore(siblingDOM).insertChild(childDOM);
+				if (childDOM !== siblingDOM) slot.withBefore(siblingDOM ?? slot.before).insertChild(childDOM);
 				siblingDOM = getNextSibling($reconcileNode(nextKey, slot.element));
 				prevIndex++;
 				nextIndex++;
@@ -1393,19 +2316,24 @@ function $reconcileNodeChildren(nextElement, prevChildren, nextChildren, prevChi
 			if (subTreeTextFormat === null) {
 				subTreeTextFormat = node.getFormat();
 				subTreeTextStyle = node.getStyle();
+				subTreeFirstTextKey = node.__key;
 			}
 		} else if ($isElementNode(node) && nextIndex <= nextEndIndex && !node.isInline()) subTreeTextContent += DOUBLE_LINE_BREAK;
+		$endCaptureGuard(saved);
 	}
 	const appendNewChildren = prevIndex > prevEndIndex;
 	const removeOldChildren = nextIndex > nextEndIndex;
 	if (appendNewChildren && !removeOldChildren) {
 		const previousNode = nextChildren[nextEndIndex + 1];
 		const insertDOM = previousNode === void 0 ? null : activeEditor$1.getElementByKey(previousNode);
-		$createChildren(nextChildren, nextElement, nextIndex, nextEndIndex, slot.withBefore(insertDOM));
+		$createChildren(nextChildren, nextElement, nextIndex, nextEndIndex, slot.withBefore(insertDOM ?? slot.before));
 	} else if (removeOldChildren && !appendNewChildren) $destroyChildren(prevChildren, prevIndex, prevEndIndex, slot.element);
 }
 function $reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dirtyElements, dirtyLeaves) {
 	subTreeTextContent = "";
+	subTreeTextFormat = null;
+	subTreeTextStyle = null;
+	subTreeFirstTextKey = null;
 	treatAllNodesAsDirty = dirtyType === FULL_RECONCILE;
 	activeEditor$1 = editor;
 	activeEditorConfig = editor._config;
@@ -1415,9 +2343,11 @@ function $reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dir
 	activeDirtyElements = dirtyElements;
 	activeDirtyLeaves = dirtyLeaves;
 	activePrevNodeMap = prevEditorState._nodeMap;
+	activePrevEditorState = prevEditorState;
 	activeNextNodeMap = nextEditorState._nodeMap;
 	activeEditorStateReadOnly = nextEditorState._readOnly;
-	activePrevKeyToDOMMap = new Map(editor._keyToDOMMap);
+	activePrevKeyToDOMMap = cloneMap(editor._keyToDOMMap);
+	activeDirtyChildrenByParent = $buildDirtyChildrenByParent();
 	const currentMutatedNodes = /* @__PURE__ */ new Map();
 	mutatedNodes = currentMutatedNodes;
 	$reconcileNode("root", null);
@@ -1426,9 +2356,11 @@ function $reconcileRoot(prevEditorState, nextEditorState, editor, dirtyType, dir
 	activeDirtyElements = void 0;
 	activeDirtyLeaves = void 0;
 	activePrevNodeMap = void 0;
+	activePrevEditorState = void 0;
 	activeNextNodeMap = void 0;
 	activeEditorConfig = void 0;
 	activePrevKeyToDOMMap = void 0;
+	activeDirtyChildrenByParent = void 0;
 	mutatedNodes = void 0;
 	activeEditorDOMRenderConfig = DEFAULT_EDITOR_DOM_CONFIG;
 	return currentMutatedNodes;
@@ -1650,6 +2582,8 @@ let lastKeyDownTimeStamp = 0;
 let lastKeyCode = null;
 let lastBeforeInputInsertTextTimeStamp = 0;
 let unprocessedBeforeInputData = null;
+let isInsertTextAfterHandledSelectionCommand = false;
+let handledSelectionCommandTimeoutId = null;
 const rootElementToDocument = /* @__PURE__ */ new WeakMap();
 const rootElementsRegistered = /* @__PURE__ */ new WeakMap();
 let isSelectionChangeFromDOMUpdate = false;
@@ -1676,7 +2610,7 @@ function $shouldPreventDefaultAndInsertText(selection, domTargetRange, text, tim
 	const anchorKey = anchor.key;
 	const backingAnchorElement = editor.getElementByKey(anchorKey);
 	const textLength = text.length;
-	return anchorKey !== focus.key || !$isTextNode(anchorNode) || (!isBeforeInput && (!CAN_USE_BEFORE_INPUT || lastBeforeInputInsertTextTimeStamp < timeStamp + 50) || anchorNode.isDirty() && textLength < 2 || doesContainSurrogatePair(text)) && anchor.offset !== focus.offset && !anchorNode.isComposing() || $isTokenOrSegmented(anchorNode) || anchorNode.isDirty() && textLength > 1 || (isBeforeInput || !CAN_USE_BEFORE_INPUT) && backingAnchorElement !== null && !anchorNode.isComposing() && domAnchorNode !== getDOMTextNode(backingAnchorElement) || 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) || 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);
 }
 function shouldSkipSelectionChange(domNode, offset) {
 	return isDOMTextNode(domNode) && domNode.nodeValue !== null && offset !== 0 && offset !== domNode.nodeValue.length;
@@ -1775,11 +2709,6 @@ function onClick(event, editor) {
 				if (anchor.type === "element" && anchor.offset === 0 && selection.isCollapsed() && !$isRootNode(anchorNode) && $getRoot().getChildrenSize() === 1 && anchorNode.getTopLevelElementOrThrow().isEmpty() && lastSelection !== null && selection.is(lastSelection)) {
 					domSelection.removeAllRanges();
 					selection.dirty = true;
-				} else if (event.detail === 3 && !selection.isCollapsed()) {
-					if (anchorNode !== selection.focus.getNode()) {
-						const parentNode = $findMatchingParent(anchorNode, (node) => $isElementNode(node) && !node.isInline());
-						if ($isElementNode(parentNode)) parentNode.select(0);
-					}
 				}
 			} else if (event.pointerType === "touch" || event.pointerType === "pen") {
 				const domAnchorNode = domSelection.anchorNode;
@@ -1802,12 +2731,47 @@ function getTargetRange(event) {
 	if (targetRanges.length === 0) return null;
 	return targetRanges[0];
 }
+function $maybeMoveSelectionPastTrailingAcceptanceBoundary(insertedText) {
+	if (insertedText == null || insertedText.length <= 1 || lastKeyCode == null) return;
+	const characterToSearchFor = lastKeyCode.length === 1 ? lastKeyCode : lastKeyCode === "Enter" ? "\n" : lastKeyCode === "Tab" ? "	" : null;
+	if (!characterToSearchFor) return;
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection) || !selection.isCollapsed()) return;
+	const anchorNode = selection.anchor.getNode();
+	if (!$isTextNode(anchorNode)) return;
+	const { offset } = selection.anchor;
+	if (anchorNode.getTextContentSize() === offset) {
+		const nextSibling = anchorNode.getNextSibling();
+		if (characterToSearchFor === "\n") {
+			if ($isLineBreakNode(nextSibling)) nextSibling.selectEnd();
+			else if (!nextSibling) {
+				const block = $findMatchingParent(anchorNode, $isBlockElementNode);
+				const nextBlock = block && block.getNextSibling();
+				if ($isElementNode(nextBlock)) nextBlock.selectStart();
+			}
+		} else if (characterToSearchFor === "	") {
+			if ($isTabNode(nextSibling)) nextSibling.selectEnd();
+		} else if ($isTextNode(nextSibling) && nextSibling.getTextContent()[0] === characterToSearchFor) nextSibling.select(1, 1);
+	} else if (anchorNode.getTextContent()[offset] === characterToSearchFor) anchorNode.select(offset + 1, offset + 1);
+}
 function $canRemoveText(anchorNode, focusNode) {
 	return anchorNode !== focusNode || $isElementNode(anchorNode) || $isElementNode(focusNode) || !$isTokenOrTab(anchorNode) || !$isTokenOrTab(focusNode);
 }
 function isPossiblyAndroidKeyPress(timeStamp) {
 	return lastKeyCode === "MediaLast" && timeStamp < lastKeyDownTimeStamp + ANDROID_COMPOSITION_LATENCY;
 }
+function clearHandledSelectionCommandInsertText() {
+	isInsertTextAfterHandledSelectionCommand = false;
+	if (handledSelectionCommandTimeoutId !== null) {
+		clearTimeout(handledSelectionCommandTimeoutId);
+		handledSelectionCommandTimeoutId = null;
+	}
+}
+function markHandledSelectionCommandInsertText() {
+	clearHandledSelectionCommandInsertText();
+	isInsertTextAfterHandledSelectionCommand = true;
+	handledSelectionCommandTimeoutId = setTimeout(clearHandledSelectionCommandInsertText, 0);
+}
 function registerDefaultCommandHandlers(editor) {
 	editor.registerCommand(BEFORE_INPUT_COMMAND, $handleBeforeInput, 0);
 	editor.registerCommand(INPUT_COMMAND, $handleInput, 0);
@@ -1826,6 +2790,16 @@ function $handleBeforeInput(event) {
 	const targetRange = getTargetRange(event);
 	const editor = getActiveEditor();
 	const selection = $getSelection();
+	if (inputType === "insertText" && event.data && isInsertTextAfterHandledSelectionCommand) {
+		clearHandledSelectionCommandInsertText();
+		event.preventDefault();
+		if ($isRangeSelection(selection) && !selection.isCollapsed()) {
+			const point = selection.isBackward() ? selection.anchor : selection.focus;
+			selection.anchor.set(point.key, point.offset, point.type);
+			selection.focus.set(point.key, point.offset, point.type);
+		}
+		return true;
+	}
 	if (inputType === "deleteContentBackward") {
 		if (selection === null) {
 			const prevSelection = $getPreviousSelection();
@@ -1850,6 +2824,14 @@ function $handleBeforeInput(event) {
 				}
 			} else {
 				$setCompositionKey(null);
+				if (IS_IOS && targetRange !== null && !targetRange.collapsed) {
+					selection.applyDOMRange(targetRange);
+					if (!selection.isCollapsed()) {
+						event.preventDefault();
+						selection.removeText();
+						return true;
+					}
+				}
 				event.preventDefault();
 				const selectedNode = selection.anchor.getNode();
 				const selectedNodeText = selectedNode.getTextContent();
@@ -1892,6 +2874,7 @@ function $handleBeforeInput(event) {
 		} else if (data != null && $shouldPreventDefaultAndInsertText(selection, targetRange, data, event.timeStamp, true)) {
 			event.preventDefault();
 			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, data);
+			$maybeMoveSelectionPastTrailingAcceptanceBoundary(data);
 		} else unprocessedBeforeInputData = data;
 		lastBeforeInputInsertTextTimeStamp = event.timeStamp;
 		return true;
@@ -1902,6 +2885,7 @@ function $handleBeforeInput(event) {
 		case "insertFromDrop":
 		case "insertReplacementText":
 			dispatchCommand(editor, CONTROLLED_TEXT_INSERTION_COMMAND, event);
+			$maybeMoveSelectionPastTrailingAcceptanceBoundary((event.dataTransfer ? event.dataTransfer.getData("text/plain") : null) ?? event.data);
 			break;
 		case "insertFromComposition":
 			$setCompositionKey(null);
@@ -1973,6 +2957,7 @@ function $handleBeforeInput(event) {
 }
 function onInput(event, editor) {
 	event.stopPropagation();
+	clearHandledSelectionCommandInsertText();
 	updateEditorSync(editor, () => {
 		editor.dispatchCommand(INPUT_COMMAND, event);
 	}, { event });
@@ -1997,7 +2982,11 @@ function $handleInput(event) {
 		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;
+		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);
@@ -2038,7 +3027,8 @@ function $onCompositionEndImpl(editor, data) {
 	if (compositionKey !== null && data != null) {
 		if (data === "") {
 			const node = $getNodeByKey(compositionKey);
-			const textNode = getDOMTextNode(editor.getElementByKey(compositionKey));
+			const domElement = editor.getElementByKey(compositionKey);
+			const textNode = domElement !== null && $isTextNode(node) ? $getDOMTextNode(node, domElement, editor) : null;
 			if (textNode !== null && textNode.nodeValue !== null && $isTextNode(node)) {
 				const domSelection = getDOMSelection(getWindow(editor));
 				let anchorOffset = null;
@@ -2074,6 +3064,7 @@ function onCompositionEnd(event, editor) {
 function onKeyDown(event, editor) {
 	lastKeyDownTimeStamp = event.timeStamp;
 	lastKeyCode = event.key;
+	if (event.key !== "Backspace") clearHandledSelectionCommandInsertText();
 	if (editor.isComposing()) return;
 	dispatchCommand(editor, KEY_DOWN_COMMAND, event);
 }
@@ -2109,8 +3100,9 @@ function $handleKeyDown(event) {
 	} else if (isParagraph(event)) {
 		isInsertLineBreak = false;
 		dispatchCommand(editor, KEY_ENTER_COMMAND, event);
-	} else if (isDeleteBackward(event)) if (isBackspace(event)) dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event);
-	else {
+	} else if (isDeleteBackward(event)) if (isBackspace(event)) {
+		if (dispatchCommand(editor, KEY_BACKSPACE_COMMAND, event)) markHandledSelectionCommandInsertText();
+	} else {
 		event.preventDefault();
 		dispatchCommand(editor, DELETE_CHARACTER_COMMAND, true);
 	}
@@ -2150,20 +3142,17 @@ function $handleKeyDown(event) {
 		dispatchCommand(editor, REDO_COMMAND, void 0);
 	} else {
 		const prevSelection = editor._editorState._selection;
-		if (prevSelection !== null && !$isRangeSelection(prevSelection)) {
+		if (isSelectAll(event)) {
+			event.preventDefault();
+			if (dispatchCommand(editor, SELECT_ALL_COMMAND, event)) markHandledSelectionCommandInsertText();
+		} else if (prevSelection !== null && !$isRangeSelection(prevSelection)) {
 			if (isCopy(event)) {
 				event.preventDefault();
 				dispatchCommand(editor, COPY_COMMAND, event);
 			} else if (isCut(event)) {
 				event.preventDefault();
 				dispatchCommand(editor, CUT_COMMAND, event);
-			} else if (isSelectAll(event)) {
-				event.preventDefault();
-				dispatchCommand(editor, SELECT_ALL_COMMAND, event);
 			}
-		} else if (isSelectAll(event)) {
-			event.preventDefault();
-			dispatchCommand(editor, SELECT_ALL_COMMAND, event);
 		}
 	}
 	if (isModifier(event)) editor.dispatchCommand(KEY_MODIFIER_COMMAND, event);
@@ -2201,6 +3190,7 @@ function onDocumentSelectionChange(event) {
 	if (nextActiveEditor !== rootEditor) activeNestedEditorsMap.set(rootEditorKey, nextActiveEditor);
 	else if (activeNestedEditor) activeNestedEditorsMap.delete(rootEditorKey);
 }
+/** @internal */
 function stopLexicalPropagation(event) {
 	event._lexicalHandled = true;
 }
@@ -2393,6 +3383,13 @@ function $markEphemeral(node) {
 	node[EPHEMERAL] = true;
 	return node;
 }
+/** @internal */
+const NON_ENUMERABLE_PROP_DESC = {
+	configurable: true,
+	enumerable: false,
+	value: void 0,
+	writable: true
+};
 var LexicalNode = class {
 	/** @internal Allow us to look up the type including static props */
 	/** @internal */
@@ -2407,6 +3404,8 @@ var LexicalNode = class {
 	__next;
 	/** @internal */
 	__state;
+	/** @internal */
+	[CACHED_TEXT_SIZE_KEY];
 	/**
 	* Returns the string type of this node. Every node must
 	* implement this and it MUST BE UNIQUE amongst nodes registered
@@ -2530,12 +3529,8 @@ var LexicalNode = class {
 		this.__parent = null;
 		this.__prev = null;
 		this.__next = null;
-		Object.defineProperty(this, "__state", {
-			configurable: true,
-			enumerable: false,
-			value: void 0,
-			writable: true
-		});
+		Object.defineProperty(this, "__state", NON_ENUMERABLE_PROP_DESC);
+		Object.defineProperty(this, CACHED_TEXT_SIZE_KEY, NON_ENUMERABLE_PROP_DESC);
 		$setNodeKey(this, key);
 		if (this.__type !== "root") errorOnTypeKlassMismatch(this.__type, this.constructor);
 	}
@@ -2916,6 +3911,23 @@ var LexicalNode = class {
 		formatDevErrorMessage(`updateDOM: base method not extended`);
 	}
 	/**
+	* Returns a {@link DOMSlot} pointing at the content-bearing element of this
+	* node's DOM. The default returns a slot wrapping the keyed DOM as-is.
+	*
+	* Override this when {@link createDOM} returns a wrapper around the
+	* content-bearing element (e.g. `<span><br/></span>` for a styled line
+	* break), so selection / reconciliation logic can target the inner element.
+	*
+	* {@link ElementNode} overrides this to return an {@link ElementDOMSlot}
+	* with children-management semantics (used by the reconciler to place
+	* managed children).
+	*
+	* @experimental
+	*/
+	getDOMSlot(element) {
+		return new DOMSlot(element);
+	}
+	/**
 	* Controls how the this node is serialized to HTML. This is important for
 	* copy and paste between Lexical and non-Lexical editors, or Lexical editors with different namespaces,
 	* in which case the primary transfer format is HTML. It's also important if you're serializing
@@ -3023,7 +4035,10 @@ var LexicalNode = class {
 		const writableReplaceWith = replaceWith.getWritable();
 		const writableParent = this.getParentOrThrow().getWritable();
 		const size = writableParent.__size;
+		const replaceWithOldParent = writableReplaceWith.getParent();
+		const replaceWithOldIndex = replaceWithOldParent !== null ? writableReplaceWith.getIndexWithinParent() : -1;
 		removeFromParent(writableReplaceWith);
+		if (replaceWithOldParent !== null && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, replaceWithOldParent, replaceWithOldIndex, -1);
 		const prevSibling = self.getPreviousSibling();
 		const nextSibling = self.getNextSibling();
 		const prevKey = self.__prev;
@@ -3044,18 +4059,20 @@ var LexicalNode = class {
 		writableReplaceWith.__next = nextKey;
 		writableReplaceWith.__parent = parentKey;
 		writableParent.__size = size;
+		let prevSizeBeforeChildrenTransfer = 0;
 		if (includeChildren) {
 			if (!($isElementNode(this) && $isElementNode(writableReplaceWith))) formatDevErrorMessage(`includeChildren should only be true for ElementNodes`);
-			this.getChildren().forEach((child) => {
-				writableReplaceWith.append(child);
-			});
+			prevSizeBeforeChildrenTransfer = writableReplaceWith.getChildrenSize();
+			writableReplaceWith.splice(prevSizeBeforeChildrenTransfer, 0, this.getChildren());
 		}
 		if ($isRangeSelection(selection)) {
 			$setSelection(selection);
 			const anchor = selection.anchor;
 			const focus = selection.focus;
-			if (anchor.key === toReplaceKey) $moveSelectionPointToEnd(anchor, writableReplaceWith);
-			if (focus.key === toReplaceKey) $moveSelectionPointToEnd(focus, writableReplaceWith);
+			if (anchor.key === toReplaceKey) if (includeChildren && anchor.type === "element") anchor.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + anchor.offset, "element");
+			else $moveSelectionPointToEnd(anchor, writableReplaceWith);
+			if (focus.key === toReplaceKey) if (includeChildren && focus.type === "element") focus.set(writableReplaceWith.__key, prevSizeBeforeChildrenTransfer + focus.offset, "element");
+			else $moveSelectionPointToEnd(focus, writableReplaceWith);
 		}
 		if ($getCompositionKey() === toReplaceKey) $setCompositionKey(key);
 		return writableReplaceWith;
@@ -3078,7 +4095,6 @@ var LexicalNode = class {
 		let elementFocusSelectionOnNode = false;
 		if (oldParent !== null) {
 			const oldIndex = nodeToInsert.getIndexWithinParent();
-			removeFromParent(writableNodeToInsert);
 			if ($isRangeSelection(selection)) {
 				const oldParentKey = oldParent.__key;
 				const anchor = selection.anchor;
@@ -3086,6 +4102,8 @@ 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);
+			if (restoreSelection && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, oldParent, oldIndex, -1);
 		}
 		const nextSibling = this.getNextSibling();
 		const writableParent = this.getParentOrThrow().getWritable();
@@ -3123,7 +4141,11 @@ var LexicalNode = class {
 		const writableSelf = this.getWritable();
 		const writableNodeToInsert = nodeToInsert.getWritable();
 		const insertKey = writableNodeToInsert.__key;
+		const selection = $getSelection();
+		const insertOldParent = writableNodeToInsert.getParent();
+		const insertOldIndex = insertOldParent !== null ? writableNodeToInsert.getIndexWithinParent() : -1;
 		removeFromParent(writableNodeToInsert);
+		if (insertOldParent !== null && restoreSelection && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, insertOldParent, insertOldIndex, -1);
 		const prevSibling = this.getPreviousSibling();
 		const writableParent = this.getParentOrThrow().getWritable();
 		const prevKey = writableSelf.__prev;
@@ -3138,7 +4160,6 @@ var LexicalNode = class {
 		writableNodeToInsert.__prev = prevKey;
 		writableNodeToInsert.__next = writableSelf.__key;
 		writableNodeToInsert.__parent = writableSelf.__parent;
-		const selection = $getSelection();
 		if (restoreSelection && $isRangeSelection(selection)) $updateElementSelectionOnCreateDeleteNode(selection, this.getParentOrThrow(), index);
 		return nodeToInsert;
 	}
@@ -3570,22 +4591,27 @@ function diffComposedText(a, b) {
 		b.slice(left, bLength - right)
 	];
 }
-function setTextContent(nextText, dom, node) {
-	const firstChild = dom.firstChild;
+function $setTextContent(nextText, dom, node) {
 	const isComposing = node.isComposing();
 	const text = nextText + (isComposing ? COMPOSITION_SUFFIX : "");
-	if (firstChild == null) dom.textContent = text;
-	else {
-		const nodeValue = firstChild.nodeValue;
-		if (nodeValue !== text) if (isComposing || IS_FIREFOX) {
-			const [index, remove, insert] = diffComposedText(nodeValue, text);
-			if (remove !== 0) firstChild.deleteData(index, remove);
-			firstChild.insertData(index, insert);
-		} else firstChild.nodeValue = text;
+	const editor = $getEditor();
+	const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(node, dom, editor);
+	const firstChild = slot.getFirstChild();
+	if (firstChild === null || firstChild.nodeType !== Node.TEXT_NODE) {
+		slot.insertChild(document.createTextNode(text));
+		return;
 	}
-}
-function createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
-	setTextContent(text, innerDOM, node);
+	const textChild = firstChild;
+	const nodeValue = textChild.nodeValue;
+	if (nodeValue === text) return;
+	if (isComposing || IS_FIREFOX) {
+		const [index, remove, insert] = diffComposedText(nodeValue, text);
+		if (remove !== 0) textChild.deleteData(index, remove);
+		textChild.insertData(index, insert);
+	} else textChild.nodeValue = text;
+}
+function $createTextInnerDOM(innerDOM, node, innerTag, format, text, config) {
+	$setTextContent(text, innerDOM, node);
 	const textClassNames = config.theme.text;
 	if (textClassNames !== void 0) setTextThemeClassNames(innerTag, 0, format, innerDOM, textClassNames);
 }
@@ -3770,7 +4796,7 @@ var TextNode = class TextNode extends LexicalNode {
 			dom.appendChild(innerDOM);
 		}
 		const text = this.__text;
-		createTextInnerDOM(innerDOM, this, innerTag, format, text, config);
+		$createTextInnerDOM(innerDOM, this, innerTag, format, text, config);
 		const style = this.__style;
 		if (style !== "") setDOMStyleFromCSS(dom.style, style);
 		return dom;
@@ -3788,7 +4814,7 @@ var TextNode = class TextNode extends LexicalNode {
 			const prevInnerDOM = dom.firstChild;
 			if (prevInnerDOM == null) formatDevErrorMessage(`updateDOM: prevInnerDOM is null or undefined`);
 			const nextInnerDOM = document.createElement(nextInnerTag);
-			createTextInnerDOM(nextInnerDOM, this, nextInnerTag, nextFormat, nextText, config);
+			$createTextInnerDOM(nextInnerDOM, this, nextInnerTag, nextFormat, nextText, config);
 			dom.replaceChild(nextInnerDOM, prevInnerDOM);
 			return false;
 		}
@@ -3799,7 +4825,7 @@ var TextNode = class TextNode extends LexicalNode {
 				if (innerDOM == null) formatDevErrorMessage(`updateDOM: innerDOM is null or undefined`);
 			}
 		}
-		setTextContent(nextText, innerDOM, this);
+		$setTextContent(nextText, innerDOM, this);
 		const textClassNames = config.theme.text;
 		if (textClassNames !== void 0 && prevFormat !== nextFormat) setTextThemeClassNames(nextInnerTag, prevFormat, nextFormat, innerDOM, textClassNames);
 		const prevStyle = prevNode.__style;
@@ -4447,6 +5473,7 @@ var Point = class {
 			if ($getCompositionKey() === oldKey) $setCompositionKey(key);
 			if (selection !== null) {
 				selection.setCachedNodes(null);
+				if ($isRangeSelection(selection)) selection._cachedIsBackward = null;
 				selection.dirty = true;
 			}
 		}
@@ -4611,6 +5638,8 @@ var RangeSelection = class RangeSelection {
 	anchor;
 	focus;
 	_cachedNodes;
+	/** @internal */
+	_cachedIsBackward;
 	dirty;
 	constructor(anchor, focus, format, style) {
 		this.anchor = anchor;
@@ -4618,6 +5647,7 @@ var RangeSelection = class RangeSelection {
 		anchor._selection = this;
 		focus._selection = this;
 		this._cachedNodes = null;
+		this._cachedIsBackward = null;
 		this.format = format;
 		this.style = style;
 		this.dirty = false;
@@ -4677,6 +5707,7 @@ var RangeSelection = class RangeSelection {
 	setTextNodeRange(anchorNode, anchorOffset, focusNode, focusOffset) {
 		this.anchor.set(anchorNode.__key, anchorOffset, "text");
 		this.focus.set(focusNode.__key, focusOffset, "text");
+		return this;
 	}
 	/**
 	* Gets the (plain) text content of all the nodes in the selection.
@@ -4725,9 +5756,10 @@ var RangeSelection = class RangeSelection {
 		const lastSelection = editor.getEditorState()._selection;
 		const resolvedSelectionPoints = $internalResolveSelectionPoints(range.startContainer, range.startOffset, range.endContainer, range.endOffset, editor, lastSelection);
 		if (resolvedSelectionPoints === null) return;
-		const [anchorPoint, focusPoint] = resolvedSelectionPoints;
+		const [anchorPoint, focusPoint, dirty] = resolvedSelectionPoints;
 		this.anchor.set(anchorPoint.key, anchorPoint.offset, anchorPoint.type, true);
 		this.focus.set(focusPoint.key, focusPoint.offset, focusPoint.type, true);
+		if (dirty) this.dirty = true;
 		$normalizeSelection(this);
 	}
 	/**
@@ -4785,16 +5817,7 @@ var RangeSelection = class RangeSelection {
 	* @param text the text to insert into the Selection
 	*/
 	insertRawText(text) {
-		const parts = text.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 nodes.push($createTextNode(part));
-		}
-		this.insertNodes(nodes);
+		this.insertNodes($generateNodesFromRawText(text));
 	}
 	/**
 	* Insert the provided text into the EditorState at the current Selection.
@@ -4892,7 +5915,11 @@ var RangeSelection = class RangeSelection {
 					const [targetNode] = firstNode.splitText(startOffset);
 					targetNode.insertAfter(textNode, false);
 				}
-				if (textNode.isComposing() && this.anchor.type === "text") this.anchor.offset -= text.length;
+				if (textNode.isComposing() && this.anchor.type === "text") {
+					this.anchor.offset -= text.length;
+					this._cachedNodes = null;
+					this._cachedIsBackward = null;
+				}
 				return;
 			}
 			else if ($isTabNode(firstNode)) {
@@ -4909,7 +5936,11 @@ var RangeSelection = class RangeSelection {
 			else if (this.anchor.type === "text") {
 				this.format = firstNodeFormat;
 				this.style = firstNodeStyle;
-				if (firstNode.isComposing()) this.anchor.offset -= text.length;
+				if (firstNode.isComposing()) {
+					this.anchor.offset -= text.length;
+					this._cachedNodes = null;
+					this._cachedIsBackward = null;
+				}
 			}
 		} else {
 			const markedNodeKeysForKeep = new Set([...firstNode.getParentKeys(), ...lastNode.getParentKeys()]);
@@ -4964,7 +5995,11 @@ var RangeSelection = class RangeSelection {
 				else if (this.anchor.type === "text") {
 					this.format = firstNode.getFormat();
 					this.style = firstNode.getStyle();
-					if (firstNode.isComposing()) this.anchor.offset -= text.length;
+					if (firstNode.isComposing()) {
+						this.anchor.offset -= text.length;
+						this._cachedNodes = null;
+						this._cachedIsBackward = null;
+					}
 				}
 			} else if (startOffset === firstNodeTextLength) firstNode.select();
 			else {
@@ -5238,10 +6273,18 @@ var RangeSelection = class RangeSelection {
 		const focusNode = this.focus.getNode();
 		if (rootElement !== null && blockCursorElement !== null && $isElementNode(focusNode) && !focusNode.isInline() && !focusNode.canBeEmpty()) removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
 		if (this.dirty) {
-			let nextAnchorDOM = getElementByKeyOrThrow(editor, this.anchor.key);
-			let nextFocusDOM = getElementByKeyOrThrow(editor, this.focus.key);
-			if (this.anchor.type === "text") nextAnchorDOM = getDOMTextNode(nextAnchorDOM);
-			if (this.focus.type === "text") nextFocusDOM = getDOMTextNode(nextFocusDOM);
+			const anchorKeyedDOM = getElementByKeyOrThrow(editor, this.anchor.key);
+			const focusKeyedDOM = getElementByKeyOrThrow(editor, this.focus.key);
+			let nextAnchorDOM = anchorKeyedDOM;
+			let nextFocusDOM = focusKeyedDOM;
+			if (this.anchor.type === "text") {
+				const node = this.anchor.getNode();
+				nextAnchorDOM = $isTextNode(node) ? $getDOMTextNode(node, anchorKeyedDOM, editor) : null;
+			}
+			if (this.focus.type === "text") {
+				const node = this.focus.getNode();
+				nextFocusDOM = $isTextNode(node) ? $getDOMTextNode(node, focusKeyedDOM, editor) : null;
+			}
 			if (nextAnchorDOM && nextFocusDOM) setDOMSelectionBaseAndExtent(domSelection, nextAnchorDOM, this.anchor.offset, nextFocusDOM, this.focus.offset);
 		}
 		moveNativeSelection(domSelection, alter, isBackward ? "backward" : "forward", granularity);
@@ -5343,6 +6386,10 @@ var RangeSelection = class RangeSelection {
 				}
 				if (state.type === "merge-block") {
 					const { caret, block } = state;
+					if (caret.origin.isEmpty() && !block.isEmpty() && caret.origin.getParent() === block.getParent()) {
+						caret.origin.remove(true);
+						return;
+					}
 					$updateRangeSelectionFromCaretRange(this, $getCaretRange(!caret.origin.isEmpty() && block.isEmpty() ? $rewindSiblingCaret($getSiblingCaret(block, caret.direction)) : initialRange.anchor, caret));
 					return this.removeText();
 				}
@@ -5411,7 +6458,11 @@ var RangeSelection = class RangeSelection {
 	* @returns true if the Selection is backwards, false otherwise.
 	*/
 	isBackward() {
-		return this.focus.isBefore(this.anchor);
+		const cached = this._cachedIsBackward;
+		if (cached !== null) return cached;
+		const isBackward = this.focus.isBefore(this.anchor);
+		if (!isCurrentlyReadOnlyMode()) this._cachedIsBackward = isBackward;
+		return isBackward;
 	}
 	getStartEndPoints() {
 		return [this.anchor, this.focus];
@@ -5593,15 +6644,17 @@ function shouldResolveAncestor(resolvedElement, resolvedOffset, lastPoint) {
 function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 	let resolvedOffset = offset;
 	let resolvedNode;
+	let dirty = false;
 	if (isHTMLElement(dom)) {
 		let moveSelectionToEnd = false;
 		const childNodes = dom.childNodes;
 		const childNodesLength = childNodes.length;
 		const blockCursorElement = editor._blockCursorElement;
-		if (resolvedOffset === childNodesLength) {
+		if (resolvedOffset === childNodesLength && childNodesLength > 0) {
 			moveSelectionToEnd = true;
 			resolvedOffset = childNodesLength - 1;
 		}
+		if (getNodeKeyFromDOMNode(dom, editor) === void 0 && dom !== editor.getRootElement() && !$isSelectionCapturedInDecorator(dom)) dirty = true;
 		let childDOM = childNodes[resolvedOffset];
 		let hasBlockCursor = false;
 		if (childDOM === blockCursorElement) {
@@ -5621,7 +6674,7 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 			if ($isElementNode(resolvedElement)) {
 				const elementDOM = editor.getElementByKey(resolvedElement.getKey());
 				if (!(elementDOM !== null)) formatDevErrorMessage(`$internalResolveSelectionPoint: node in DOM but not keyToDOMMap`);
-				const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(resolvedElement, elementDOM, editor);
+				const slot = $getDOMSlot(resolvedElement, elementDOM, editor);
 				[resolvedElement, resolvedOffset] = slot.resolveChildIndex(resolvedElement, elementDOM, dom, offset);
 				if (!$isElementNode(resolvedElement)) formatDevErrorMessage(`$internalResolveSelectionPoint: resolvedElement is not an ElementNode`);
 				if (moveSelectionToEnd && resolvedOffset >= resolvedElement.getChildrenSize()) resolvedOffset = Math.max(0, resolvedElement.getChildrenSize() - 1);
@@ -5645,15 +6698,21 @@ function $internalResolveSelectionPoint(dom, offset, lastPoint, editor) {
 				}
 			} else {
 				const index = resolvedElement.getIndexWithinParent();
-				if (offset === 0 && $isDecoratorNode(resolvedElement) && $getNodeFromDOM(dom) === resolvedElement) resolvedOffset = index;
-				else resolvedOffset = index + 1;
+				const elementDOM = editor.getElementByKey(resolvedElement.getKey());
+				let position = "after";
+				if (elementDOM !== null && $getNodeFromDOM(dom) === resolvedElement) {
+					const slot = $getDOMSlot(resolvedElement, elementDOM, editor);
+					if (slot.element !== elementDOM) position = slot.resolveLeafPosition(elementDOM, dom, offset);
+					else if (offset === 0 && $isDecoratorNode(resolvedElement)) position = "before";
+				}
+				resolvedOffset = position === "before" ? index : index + 1;
 				resolvedElement = resolvedElement.getParentOrThrow();
 			}
-			if ($isElementNode(resolvedElement)) return $createPoint(resolvedElement.__key, resolvedOffset, "element");
+			if ($isElementNode(resolvedElement)) return [$createPoint(resolvedElement.__key, resolvedOffset, "element"), dirty];
 		}
 	} else resolvedNode = $getNodeFromDOM(dom);
 	if (!$isTextNode(resolvedNode)) return null;
-	return $createPoint(resolvedNode.__key, $getTextNodeOffset(resolvedNode, resolvedOffset, "clamp"), "text");
+	return [$createPoint(resolvedNode.__key, $getTextNodeOffset(resolvedNode, resolvedOffset, "clamp"), "text"), dirty];
 }
 function resolveSelectionPointOnBoundary(point, isBackward, isCollapsed) {
 	const offset = point.offset;
@@ -5689,10 +6748,12 @@ function $normalizeSelectionPointsForBoundaries(anchor, focus, lastSelection) {
 }
 function $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection) {
 	if (anchorDOM === null || focusDOM === null || !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) return null;
-	const resolvedAnchorPoint = $internalResolveSelectionPoint(anchorDOM, anchorOffset, $isRangeSelection(lastSelection) ? lastSelection.anchor : null, editor);
-	if (resolvedAnchorPoint === null) return null;
-	const resolvedFocusPoint = $internalResolveSelectionPoint(focusDOM, focusOffset, $isRangeSelection(lastSelection) ? lastSelection.focus : null, editor);
-	if (resolvedFocusPoint === null) return null;
+	const resolvedAnchor = $internalResolveSelectionPoint(anchorDOM, anchorOffset, $isRangeSelection(lastSelection) ? lastSelection.anchor : null, editor);
+	if (resolvedAnchor === null) return null;
+	const resolvedFocus = $internalResolveSelectionPoint(focusDOM, focusOffset, $isRangeSelection(lastSelection) ? lastSelection.focus : null, editor);
+	if (resolvedFocus === null) return null;
+	const [resolvedAnchorPoint, anchorDirty] = resolvedAnchor;
+	const [resolvedFocusPoint, focusDirty] = resolvedFocus;
 	$validatePoint("anchor", resolvedAnchorPoint);
 	$validatePoint("focus", resolvedFocusPoint);
 	if (resolvedAnchorPoint.type === "element" && resolvedFocusPoint.type === "element") {
@@ -5701,7 +6762,11 @@ function $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focu
 		if ($isDecoratorNode(anchorNode) && $isDecoratorNode(focusNode)) return null;
 	}
 	$normalizeSelectionPointsForBoundaries(resolvedAnchorPoint, resolvedFocusPoint);
-	return [resolvedAnchorPoint, resolvedFocusPoint];
+	return [
+		resolvedAnchorPoint,
+		resolvedFocusPoint,
+		anchorDirty || focusDirty
+	];
 }
 function $isBlockElementNode(node) {
 	return $isElementNode(node) && !node.isInline();
@@ -5746,7 +6811,7 @@ function $internalCreateRangeSelection(lastSelection, domSelection, editor, even
 	} else return lastSelection.clone();
 	const resolvedSelectionPoints = $internalResolveSelectionPoints(anchorDOM, anchorOffset, focusDOM, focusOffset, editor, lastSelection);
 	if (resolvedSelectionPoints === null) return null;
-	const [resolvedAnchorPoint, resolvedFocusPoint] = resolvedSelectionPoints;
+	const [resolvedAnchorPoint, resolvedFocusPoint, dirty] = resolvedSelectionPoints;
 	let format = 0;
 	let style = "";
 	if ($isRangeSelection(lastSelection)) {
@@ -5765,7 +6830,9 @@ function $internalCreateRangeSelection(lastSelection, domSelection, editor, even
 			}
 		}
 	}
-	return new RangeSelection(resolvedAnchorPoint, resolvedFocusPoint, format, style);
+	const newSelection = new RangeSelection(resolvedAnchorPoint, resolvedFocusPoint, format, style);
+	if (dirty) newSelection.dirty = true;
+	return newSelection;
 }
 function $validatePoint(name, point) {
 	const node = $getNodeByKey(point.key);
@@ -5915,20 +6982,17 @@ function setDOMSelectionBaseAndExtent(domSelection, nextAnchorDOM, nextAnchorOff
 function $getElementAndOffsetForPoint(editor, node, offset) {
 	const element = getElementByKeyOrThrow(editor, node.getKey());
 	if ($isElementNode(node)) {
-		const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(node, element, editor);
+		const slot = $getDOMSlot(node, element, editor);
 		return [slot.element, offset + slot.getFirstChildOffset()];
 	}
 	return [element, offset];
 }
-function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement, nodeCount) {
-	const anchorDOMNode = domSelection.anchorNode;
-	const focusDOMNode = domSelection.focusNode;
-	const anchorOffset = domSelection.anchorOffset;
-	const focusOffset = domSelection.focusOffset;
+/** @internal */
+function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection, tags, rootElement) {
 	const activeElement = document.activeElement;
 	if (tags.has("collaboration") && activeElement !== rootElement || activeElement !== null && isSelectionCapturedInDecoratorInput(activeElement)) return;
 	if (!$isRangeSelection(nextSelection)) {
-		if (prevSelection !== null && isSelectionWithinEditor(editor, anchorDOMNode, focusDOMNode)) domSelection.removeAllRanges();
+		if (prevSelection !== null && isSelectionWithinEditor(editor, domSelection.anchorNode, domSelection.focusNode)) domSelection.removeAllRanges();
 		return;
 	}
 	const anchor = nextSelection.anchor;
@@ -5944,13 +7008,13 @@ function $updateDOMSelection(prevSelection, nextSelection, editor, domSelection,
 	let nextFocusNode = focusDOM;
 	let anchorFormatOrStyleChanged = false;
 	if (anchor.type === "text") {
-		nextAnchorNode = getDOMTextNode(anchorDOM);
+		nextAnchorNode = $isTextNode(anchorNode) ? $getDOMTextNode(anchorNode, anchorDOM, editor) : null;
 		anchorFormatOrStyleChanged = anchorNode.getFormat() !== nextFormat || anchorNode.getStyle() !== nextStyle;
 	} else if ($isRangeSelection(prevSelection) && prevSelection.anchor.type === "text") anchorFormatOrStyleChanged = true;
-	if (focus.type === "text") nextFocusNode = getDOMTextNode(focusDOM);
+	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 (anchorOffset === nextAnchorOffset && focusOffset === nextFocusOffset && anchorDOMNode === nextAnchorNode && focusDOMNode === nextFocusNode && !(domSelection.type === "Range" && isCollapsed)) {
+	if (!(domSelection.type === "Range" && isCollapsed) && domSelection.anchorOffset === nextAnchorOffset && domSelection.focusOffset === nextFocusOffset && domSelection.anchorNode === nextAnchorNode && domSelection.focusNode === nextFocusNode) {
 		if (activeElement === null || !rootElement.contains(activeElement)) {
 			if (!tags.has("skip-selection-focus")) rootElement.focus({ preventScroll: true });
 		}
@@ -5977,6 +7041,46 @@ function $insertNodes(nodes) {
 	if (selection === null) selection = $getRoot().selectEnd();
 	selection.insertNodes(nodes);
 }
+/**
+* Push-lexer visitor passed to {@link tokenizeRawText}. The tokenizer
+* invokes one callback per token it emits; empty text runs are
+* suppressed, so `text` is only invoked with a non-empty string.
+*/
+/**
+* Push-lex a raw text string into `linebreak` (`\n` / `\r\n`), `tab`
+* (`\t`), and `text` (everything else) tokens, dispatching each to the
+* matching callback on `visitor` in source order.
+*
+* Shared by {@link $generateNodesFromRawText} (which builds
+* `LineBreakNode` / `TabNode` / `TextNode` siblings) and by
+* `@lexical/clipboard`'s default `text/plain` clipboard importer
+* (which maps `linebreak` to a real paragraph break via
+* `insertParagraph` so multi-line plain text becomes multi-paragraph
+* rich text). Empty text runs are dropped so callers don't need to
+* special-case them.
+*/
+function tokenizeRawText(text, visitor) {
+	for (const part of text.split(/(\r?\n|\t)/)) if (part === "\n" || part === "\r\n") visitor.linebreak();
+	else if (part === "	") visitor.tab();
+	else if (part !== "") visitor.text(part);
+}
+/**
+* Convert a raw text string into a flat array of `TextNode`,
+* `LineBreakNode`, and `TabNode` siblings, splitting on `\n`, `\r\n`,
+* and `\t`. Use this when you need the same `\n` / `\t` → real-node
+* conversion that {@link RangeSelection.insertRawText} performs but
+* without a selection — e.g. when building a `CodeNode`'s children
+* inside a DOM-import rule.
+*/
+function $generateNodesFromRawText(text) {
+	const nodes = [];
+	tokenizeRawText(text, {
+		linebreak: () => nodes.push($createLineBreakNode()),
+		tab: () => nodes.push($createTabNode()),
+		text: (part) => nodes.push($createTextNode(part))
+	});
+	return nodes;
+}
 function $getTextContent() {
 	const selection = $getSelection();
 	if (selection === null) return "";
@@ -6161,6 +7265,18 @@ 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;
 }
+/**
+* Schedule a full reconcile of the active editor, so that every node is
+* re-rendered through the current {@link EditorDOMRenderConfig} on the next
+* commit. Unlike {@link LexicalNode.markDirty}, this does not clone or
+* otherwise mutate the node map, so no mutation/collaboration listeners
+* observe a change. Must be called within an `editor.update`.
+*
+* @internal
+*/
+function $fullReconcile() {
+	getActiveEditor()._dirtyType = FULL_RECONCILE;
+}
 function collectBuildInformation() {
 	let compatibleEditors = 0;
 	const incompatibleEditors = /* @__PURE__ */ new Set();
@@ -6302,7 +7418,7 @@ function parseEditorState(serializedEditorState, editor, updateFn) {
 	editor._dirtyElements = /* @__PURE__ */ new Map();
 	editor._dirtyLeaves = /* @__PURE__ */ new Set();
 	editor._cloneNotNeeded = /* @__PURE__ */ new Set();
-	editor._dirtyType = 0;
+	editor._dirtyType = NO_DIRTY_NODES;
 	activeEditorState = editorState;
 	isReadOnlyMode = false;
 	activeEditor = editor;
@@ -6438,7 +7554,7 @@ function $commitPendingUpdates(editor, recoveryEditorState) {
 				if (blockCursorElement !== null) removeDOMBlockCursorElement(blockCursorElement, editor, rootElement);
 				$updateDOMSelection(currentSelection, pendingSelection, editor, domSelection, tags, rootElement);
 			}
-			updateDOMBlockCursorElement(editor, rootElement, pendingSelection);
+			$updateDOMBlockCursorElement(editor, rootElement, pendingSelection);
 		} finally {
 			if (observer !== null) observer.observe(rootElement, observerOptions);
 			activeEditor = previousActiveEditor;
@@ -6536,12 +7652,24 @@ function triggerCommandListeners(editor, type, payload, fromEditor) {
 }
 function $triggerEnqueuedUpdates(editor) {
 	const queuedUpdates = editor._updates;
-	if (queuedUpdates.length !== 0) {
-		const queuedUpdate = queuedUpdates.shift();
-		if (queuedUpdate) {
-			const [updateFn, options] = queuedUpdate;
-			$beginUpdate(editor, updateFn, options);
+	if (queuedUpdates.length === 0) {
+		editor._cascadeCount = 0;
+		return;
+	}
+	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);
 		}
+		return;
+	}
+	const queuedUpdate = queuedUpdates.shift();
+	if (queuedUpdate) {
+		const [updateFn, options] = queuedUpdate;
+		$beginUpdate(editor, updateFn, options);
 	}
 }
 function triggerDeferredUpdateCallbacks(editor, deferred) {
@@ -6680,167 +7808,6 @@ function updateEditor(editor, updateFn, options) {
 	if (editor._updating) editor._updates.push([updateFn, options]);
 	else $beginUpdate(editor, updateFn, options);
 }
-/**
-* A utility class for managing the DOM children of an ElementNode
-*/
-var ElementDOMSlot = class ElementDOMSlot {
-	element;
-	before;
-	after;
-	constructor(element, before, after) {
-		this.element = element;
-		this.before = before || null;
-		this.after = after || null;
-	}
-	/**
-	* Return a new ElementDOMSlot where all managed children will be inserted before this node
-	*/
-	withBefore(before) {
-		return new ElementDOMSlot(this.element, before, this.after);
-	}
-	/**
-	* Return a new ElementDOMSlot where all managed children will be inserted after this node
-	*/
-	withAfter(after) {
-		return new ElementDOMSlot(this.element, this.before, after);
-	}
-	/**
-	* Return a new ElementDOMSlot with an updated root element
-	*/
-	withElement(element) {
-		if (this.element === element) return this;
-		return new ElementDOMSlot(element, this.before, this.after);
-	}
-	/**
-	* Insert the given child before this.before and any reconciler managed line break node,
-	* or append it if this.before is not defined
-	*/
-	insertChild(dom) {
-		const before = this.before || this.getManagedLineBreak();
-		if (!(before === null || before.parentElement === this.element)) formatDevErrorMessage(`ElementDOMSlot.insertChild: before is not in element`);
-		this.element.insertBefore(dom, before);
-		return this;
-	}
-	/**
-	* Remove the managed child from this container, will throw if it was not already there
-	*/
-	removeChild(dom) {
-		if (!(dom.parentElement === this.element)) formatDevErrorMessage(`ElementDOMSlot.removeChild: dom is not in element`);
-		this.element.removeChild(dom);
-		return this;
-	}
-	/**
-	* Replace managed child prevDom with dom. Will throw if prevDom is not a child
-	*
-	* @param dom The new node to replace prevDom
-	* @param prevDom the node that will be replaced
-	*/
-	replaceChild(dom, prevDom) {
-		if (!(prevDom.parentElement === this.element)) formatDevErrorMessage(`ElementDOMSlot.replaceChild: prevDom is not in element`);
-		this.element.replaceChild(dom, prevDom);
-		return this;
-	}
-	/**
-	* Returns the first managed child of this node,
-	* which will either be this.after.nextSibling or this.element.firstChild,
-	* and will never be this.before if it is defined.
-	*/
-	getFirstChild() {
-		const firstChild = this.after ? this.after.nextSibling : this.element.firstChild;
-		return firstChild === this.before || firstChild === this.getManagedLineBreak() ? null : firstChild;
-	}
-	/**
-	* @internal
-	*/
-	getManagedLineBreak() {
-		return this.element.__lexicalLineBreak || null;
-	}
-	/** @internal */
-	setManagedLineBreak(lineBreakType) {
-		if (lineBreakType === null) this.removeManagedLineBreak();
-		else {
-			const webkitHack = lineBreakType === "decorator" && (IS_APPLE_WEBKIT || IS_IOS || IS_SAFARI);
-			this.insertManagedLineBreak(webkitHack);
-		}
-	}
-	/** @internal */
-	removeManagedLineBreak() {
-		const br = this.getManagedLineBreak();
-		if (br) {
-			const element = this.element;
-			const sibling = br.nodeName === "IMG" ? br.nextSibling : null;
-			if (sibling) element.removeChild(sibling);
-			element.removeChild(br);
-			element.__lexicalLineBreak = void 0;
-		}
-	}
-	/** @internal */
-	insertManagedLineBreak(webkitHack) {
-		const prevBreak = this.getManagedLineBreak();
-		if (prevBreak) {
-			if (webkitHack === (prevBreak.nodeName === "IMG")) return;
-			this.removeManagedLineBreak();
-		}
-		const element = this.element;
-		const before = this.before;
-		const br = document.createElement("br");
-		element.insertBefore(br, before);
-		if (webkitHack) {
-			const img = document.createElement("img");
-			img.setAttribute("data-lexical-linebreak", "true");
-			img.style.setProperty("display", "inline", "important");
-			img.style.setProperty("border", "0px", "important");
-			img.style.setProperty("margin", "0px", "important");
-			img.alt = "";
-			element.insertBefore(img, br);
-			element.__lexicalLineBreak = img;
-		} else element.__lexicalLineBreak = br;
-	}
-	/**
-	* @internal
-	*
-	* Returns the offset of the first child
-	*/
-	getFirstChildOffset() {
-		let i = 0;
-		for (let node = this.after; node !== null; node = node.previousSibling) i++;
-		return i;
-	}
-	/**
-	* @internal
-	*/
-	resolveChildIndex(element, elementDOM, initialDOM, initialOffset) {
-		if (initialDOM === this.element) {
-			const firstChildOffset = this.getFirstChildOffset();
-			return [element, Math.min(firstChildOffset + element.getChildrenSize(), Math.max(firstChildOffset, initialOffset))];
-		}
-		const initialPath = indexPath(elementDOM, initialDOM);
-		initialPath.push(initialOffset);
-		const elementPath = indexPath(elementDOM, this.element);
-		let offset = element.getIndexWithinParent();
-		for (let i = 0; i < elementPath.length; i++) {
-			const target = initialPath[i];
-			const source = elementPath[i];
-			if (target === void 0 || target < source) break;
-			else if (target > source) {
-				offset += 1;
-				break;
-			}
-		}
-		return [element.getParentOrThrow(), offset];
-	}
-};
-function indexPath(root, child) {
-	const path = [];
-	let node = child;
-	for (; node !== root && node !== null; node = node.parentNode) {
-		let i = 0;
-		for (let sibling = node.previousSibling; sibling !== null; sibling = sibling.previousSibling) i++;
-		path.push(i);
-	}
-	if (!(node === root)) formatDevErrorMessage(`indexPath: root is not a parent of child`);
-	return path.reverse();
-}
 /** @noInheritDoc */
 var ElementNode = class extends LexicalNode {
 	/** @internal */
@@ -7214,12 +8181,12 @@ var ElementNode = class extends LexicalNode {
 		return writableSelf;
 	}
 	/**
-	* @internal
+	* @experimental
 	*
-	* An experimental API that an ElementNode can override to control where its
-	* children are inserted into the DOM, this is useful to add a wrapping node
-	* or accessory nodes before or after the children. The root of the node returned
-	* by createDOM must still be exactly one HTMLElement.
+	* An ElementNode subclass can override this to control where its children
+	* are inserted into the DOM, e.g. to add a wrapping node or accessory nodes
+	* before or after the children. The root of the node returned by createDOM
+	* must still be exactly one HTMLElement.
 	*/
 	getDOMSlot(element) {
 		return new ElementDOMSlot(element);
@@ -7228,7 +8195,10 @@ var ElementNode = class extends LexicalNode {
 		const { element } = super.exportDOM(editor);
 		if (isHTMLElement(element)) {
 			const indent = this.getIndent();
-			if (indent > 0) element.style.paddingInlineStart = `${indent * 40}px`;
+			if (indent > 0) {
+				element.style.paddingInlineStart = `${indent * 40}px`;
+				element.setAttribute("data-lexical-indent", String(indent));
+			}
 			const direction = this.getDirection();
 			if (direction) element.dir = direction;
 		}
@@ -7282,6 +8252,10 @@ var ElementNode = class extends LexicalNode {
 	canInsertTextAfter() {
 		return true;
 	}
+	/**
+	* If the method is overridden and returns true, ensure that `canBeEmpty()`
+	* returns false for the inline node to work correctly
+	*/
 	isInline() {
 		return false;
 	}
@@ -7313,7 +8287,7 @@ var ElementNode = class extends LexicalNode {
 	}
 	/** @internal */
 	reconcileObservedMutation(dom, editor) {
-		const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(this, dom, editor);
+		const slot = $getDOMSlot(this, dom, editor);
 		let currentDOM = slot.getFirstChild();
 		for (let currentNode = this.getFirstChild(); currentNode; currentNode = currentNode.getNextSibling()) {
 			const correctDOM = editor.getElementByKey(currentNode.getKey());
@@ -7386,10 +8360,7 @@ var RootNode = class RootNode extends ElementNode {
 	}
 	getTextContent() {
 		const cachedText = this.__cachedText;
-		if (isCurrentlyReadOnlyMode() || getActiveEditor()._dirtyType === NO_DIRTY_NODES) {
-			if (cachedText !== null) return cachedText;
-		}
-		return super.getTextContent();
+		return cachedText !== null && (isCurrentlyReadOnlyMode() || getActiveEditor()._dirtyType === NO_DIRTY_NODES) ? cachedText : super.getTextContent();
 	}
 	remove() {
 		formatDevErrorMessage(`remove: cannot be called on root nodes`);
@@ -7432,7 +8403,7 @@ function editorStateHasDirtySelection(editorState, editor) {
 	return false;
 }
 function cloneEditorState(current) {
-	return new EditorState(new Map(current._nodeMap));
+	return new EditorState(cloneMap(current._nodeMap));
 }
 function createEmptyEditorState() {
 	return new EditorState(new Map([["root", $createRootNode()]]));
@@ -7588,16 +8559,15 @@ var ParagraphNode = class ParagraphNode extends ElementNode {
 };
 function $convertParagraphElement(element) {
 	const node = $createParagraphNode();
-	if (element.style) {
-		node.setFormat(element.style.textAlign);
-		setNodeIndentFromDOM(element, node);
-	}
+	$setFormatFromDOM(node, element);
+	setNodeIndentFromDOM(element, node);
 	if (node.getFormatType() === "") {
 		const align = element.getAttribute("align");
 		if (align) {
 			if (align && align in ELEMENT_TYPE_TO_FORMAT) node.setFormat(align);
 		}
 	}
+	$setDirectionFromDOM(node, element);
 	return { node };
 }
 function $createParagraphNode() {
@@ -7607,8 +8577,24 @@ function $isParagraphNode(node) {
 	return node instanceof ParagraphNode;
 }
 /**
+* 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`.
+*
+* See [Node Replacement](https://lexical.dev/docs/concepts/node-replacement).
+*/
+/**
 * A LexicalNode class or LexicalNodeReplacement configuration
 */
+/**
+* @experimental
+*
+* The slot type produced by `$getDOMSlot` for a given node, narrowed via
+* the node's static class: `ElementNode` resolves to {@link ElementDOMSlot}
+* (with children-management methods), other nodes to the base
+* {@link DOMSlot}. Callers passing a known node type get the narrowed slot
+* without manual `instanceof` checks.
+*/
 /** @internal @experimental */
 const DEFAULT_SKIP_INITIALIZATION = false;
 /**
@@ -7690,7 +8676,16 @@ function normalizePriority(priority) {
 * }
 * ```
 */
-function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorState) {
+/** @internal */
+/**
+* @internal
+*
+* Resets the editor's transient state — DOM mappings, dirty tracking,
+* composition, and (by default) the queued updates and tags — while
+* applying the given pendingEditorState. Used during root element
+* transitions and reconciler error recovery.
+*/
+function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorState, options) {
 	const keyNodeMap = editor._keyToDOMMap;
 	keyNodeMap.clear();
 	editor._editorState = createEmptyEditorState();
@@ -7701,8 +8696,11 @@ function resetEditor(editor, prevRootElement, nextRootElement, pendingEditorStat
 	editor._dirtyLeaves = /* @__PURE__ */ new Set();
 	editor._dirtyElements.clear();
 	editor._normalizedNodes = /* @__PURE__ */ new Set();
-	editor._updateTags = /* @__PURE__ */ new Set();
-	editor._updates = [];
+	if (!options || !options.preserveUpdateQueue) {
+		editor._updateTags = /* @__PURE__ */ new Set();
+		editor._updates = [];
+		editor._cascadeCount = 0;
+	}
 	editor._blockCursorElement = null;
 	const observer = editor._observer;
 	if (observer !== null) {
@@ -7771,10 +8769,7 @@ const DEFAULT_EDITOR_DOM_CONFIG = {
 		return registeredNode && registeredNode.exportDOM !== void 0 ? registeredNode.exportDOM(editor, node) : node.exportDOM(editor);
 	},
 	$extractWithChild: (node, childNode, selection, destination, _editor) => $isElementNode(node) && node.extractWithChild(childNode, selection, destination),
-	$getDOMSlot: (node, dom, _editor) => {
-		if (!$isElementNode(node)) formatDevErrorMessage(`$getDOMSlot called on a non-ElementNode (key ${node.getKey()} type ${node.getType()})`);
-		return node.getDOMSlot(dom);
-	},
+	$getDOMSlot: (node, dom, _editor) => node.getDOMSlot(dom),
 	$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)
@@ -7902,6 +8897,8 @@ var LexicalEditor = class {
 	/** @internal */
 	_updating;
 	/** @internal */
+	_cascadeCount;
+	/** @internal */
 	_listeners;
 	/** @internal */
 	_commands;
@@ -7950,9 +8947,10 @@ var LexicalEditor = class {
 		this._pendingEditorState = null;
 		this._compositionKey = null;
 		this._deferred = [];
-		this._keyToDOMMap = /* @__PURE__ */ new Map();
+		this._keyToDOMMap = new GenMap();
 		this._updates = [];
 		this._updating = false;
+		this._cascadeCount = 0;
 		this._listeners = {
 			decorator: /* @__PURE__ */ new Map(),
 			editable: /* @__PURE__ */ new Map(),
@@ -8247,7 +9245,7 @@ var LexicalEditor = class {
 			const classNames = getCachedClassNameArray(this._config.theme, "root");
 			const pendingEditorState = this._pendingEditorState || this._editorState;
 			this._rootElement = nextRootElement;
-			resetEditor(this, prevRootElement, nextRootElement, pendingEditorState);
+			resetEditor(this, prevRootElement, nextRootElement, pendingEditorState, { preserveUpdateQueue: true });
 			if (prevRootElement !== null) {
 				if (!this._config.disableEvents) removeRootElementEvents(prevRootElement);
 				if (classNames != null) prevRootElement.classList.remove(...classNames);
@@ -8421,7 +9419,7 @@ var LexicalEditor = class {
 		return { editorState: this._editorState.toJSON() };
 	}
 };
-LexicalEditor.version = "0.44.0+dev.esm";
+LexicalEditor.version = LEXICAL_VERSION;
 let pendingNodeToClone = null;
 function setPendingNodeToClone(pendingNode) {
 	pendingNodeToClone = pendingNode;
@@ -8569,7 +9567,7 @@ function $setNodeKey(node, existingKey) {
 	if ($isElementNode(node)) editor._dirtyElements.set(key, true);
 	else editor._dirtyLeaves.add(key);
 	editor._cloneNotNeeded.add(key);
-	editor._dirtyType = HAS_DIRTY_NODES;
+	if (editor._dirtyType === NO_DIRTY_NODES) editor._dirtyType = HAS_DIRTY_NODES;
 	node.__key = key;
 }
 function errorOnNodeKeyConstructorMismatch(node, existingKey, pendingNode) {
@@ -8596,6 +9594,12 @@ function internalMarkParentElementsAsDirty(parentKey, nodeMap, dirtyElements) {
 * Removes a node from its parent, updating all necessary pointers and links.
 * @internal
 *
+* This function does not adjust the editor's current selection. Callers
+* that need element-anchored offsets in the old parent to track the child
+* count change must call `$updateElementSelectionOnCreateDeleteNode` (with
+* `times = -1`) after invoking this — see `$removeNode`, `replace`,
+* `insertBefore`, and `insertAfter` for the pattern.
+*
 * This function is for internal use of the library.
 * Please do not use it as it may change in the future.
 */
@@ -8631,7 +9635,7 @@ function internalMarkNodeAsDirty(node) {
 	const dirtyElements = editor._dirtyElements;
 	if (parent !== null) internalMarkParentElementsAsDirty(parent, nodeMap, dirtyElements);
 	const key = latest.__key;
-	editor._dirtyType = HAS_DIRTY_NODES;
+	if (editor._dirtyType === NO_DIRTY_NODES) editor._dirtyType = HAS_DIRTY_NODES;
 	if ($isElementNode(node)) dirtyElements.set(key, true);
 	else editor._dirtyLeaves.add(key);
 }
@@ -8847,9 +9851,17 @@ function $setTextContentWithSelection(node, textContent, selection) {
 	node.setTextContent(textContent);
 	if ($isRangeSelection(selection)) {
 		const key = node.getKey();
+		let pointMutated = false;
 		for (const k of ["anchor", "focus"]) {
 			const pt = selection[k];
-			if (pt.type === "text" && pt.key === key) pt.offset = $getTextNodeOffset(node, pt.offset, "clamp");
+			if (pt.type === "text" && pt.key === key) {
+				pt.offset = $getTextNodeOffset(node, pt.offset, "clamp");
+				pointMutated = true;
+			}
+		}
+		if (pointMutated) {
+			selection._cachedNodes = null;
+			selection._cachedIsBackward = null;
 		}
 	}
 }
@@ -8988,13 +10000,19 @@ function isMoveBackward(event) {
 	return isExactShortcutMatch(event, "ArrowLeft", { shiftKey: "any" });
 }
 function isMoveToStart(event) {
-	return isExactShortcutMatch(event, "ArrowLeft", CONTROL_OR_META);
+	return isExactShortcutMatch(event, "ArrowLeft", {
+		...CONTROL_OR_META,
+		shiftKey: "any"
+	});
 }
 function isMoveForward(event) {
 	return isExactShortcutMatch(event, "ArrowRight", { shiftKey: "any" });
 }
 function isMoveToEnd(event) {
-	return isExactShortcutMatch(event, "ArrowRight", CONTROL_OR_META);
+	return isExactShortcutMatch(event, "ArrowRight", {
+		...CONTROL_OR_META,
+		shiftKey: "any"
+	});
 }
 function isMoveUp(event) {
 	return isExactShortcutMatch(event, "ArrowUp", {
@@ -9145,8 +10163,15 @@ function scrollIntoViewIfNeeded(editor, selectionRect, rootElement) {
 	while (element !== null) {
 		const isBodyElement = element === doc.body;
 		if (isBodyElement) {
-			targetTop = 0;
-			targetBottom = getWindow(editor).innerHeight;
+			const visualViewport = defaultView.visualViewport;
+			if (visualViewport) {
+				const offsetTop = visualViewport.offsetTop;
+				targetTop = offsetTop;
+				targetBottom = offsetTop + visualViewport.height;
+			} else {
+				targetTop = 0;
+				targetBottom = getWindow(editor).innerHeight;
+			}
 			const computedStyle = defaultView.getComputedStyle(doc.documentElement);
 			const scrollPaddingTop = parseFloat(computedStyle.scrollPaddingTop);
 			const scrollPaddingBottom = parseFloat(computedStyle.scrollPaddingBottom);
@@ -9295,7 +10320,7 @@ function removeDOMBlockCursorElement(blockCursorElement, editor, rootElement) {
 	const parentElement = blockCursorElement.parentElement;
 	if (parentElement !== null) parentElement.removeChild(blockCursorElement);
 }
-function updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
+function $updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
 	let blockCursorElement = editor._blockCursorElement;
 	if ($isRangeSelection(nextSelection) && nextSelection.isCollapsed() && nextSelection.anchor.type === "element" && rootElement.contains(document.activeElement)) {
 		const anchor = nextSelection.anchor;
@@ -9317,7 +10342,7 @@ function updateDOMBlockCursorElement(editor, rootElement, nextSelection) {
 			}
 		}
 		if (isBlockCursor) {
-			const elementDOM = editor.getElementByKey(elementNode.__key);
+			const elementDOM = $getDOMSlot(elementNode, editor.getElementByKey(elementNode.__key), editor).element;
 			if (blockCursorElement === null) editor._blockCursorElement = blockCursorElement = createBlockCursorElement(editor._config);
 			rootElement.style.caretColor = "transparent";
 			if (insertBeforeElement === null) elementDOM.appendChild(blockCursorElement);
@@ -9386,6 +10411,21 @@ function isHTMLAnchorElement(x) {
 }
 /**
 * @param x - The element being tested
+* @returns Returns true if x is an HTML `<tr>` element, false otherwise
+*/
+function isHTMLTableRowElement(x) {
+	return isHTMLElement(x) && x.tagName === "TR";
+}
+/**
+* @param x - The element being tested
+* @returns Returns true if x is an HTML `<td>` or `<th>` element, false
+*   otherwise
+*/
+function isHTMLTableCellElement(x) {
+	return isHTMLElement(x) && (x.tagName === "TD" || x.tagName === "TH");
+}
+/**
+* @param x - The element being tested
 * @returns Returns true if x is an HTML element, false otherwise.
 */
 function isHTMLElement(x) {
@@ -9405,18 +10445,23 @@ function isDOMNode(x) {
 function isDocumentFragment(x) {
 	return isDOMNode(x) && x.nodeType === DOM_DOCUMENT_FRAGMENT_TYPE;
 }
+const INLINE_TAG_RE = /^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|mark|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var|#text)$/i;
 /**
 *
 * @param node - the Dom Node to check
 * @returns if the Dom Node is an inline node
 */
 function isInlineDomNode(node) {
-	const inlineNodes = /* @__PURE__ */ new RegExp(/^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|mark|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var|#text)$/, "i");
-	return node.nodeName.match(inlineNodes) !== null;
+	return isHTMLElement(node) && node.style.display.startsWith("inline") ? true : INLINE_TAG_RE.test(node.nodeName);
 }
+const BLOCK_TAG_RE = /^(address|article|aside|blockquote|canvas|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h1|h2|h3|h4|h5|h6|header|hr|li|main|nav|noscript|ol|p|pre|section|table|td|tfoot|ul|video)$/i;
+/**
+*
+* @param node - the Dom Node to check
+* @returns if the Dom Node is a block node
+*/
 function isBlockDomNode(node) {
-	const blockNodes = /* @__PURE__ */ new RegExp(/^(address|article|aside|blockquote|canvas|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h1|h2|h3|h4|h5|h6|header|hr|li|main|nav|noscript|ol|p|pre|section|table|td|tfoot|ul|video)$/, "i");
-	return node.nodeName.match(blockNodes) !== null;
+	return isHTMLElement(node) && node.style.display.startsWith("inline") ? false : BLOCK_TAG_RE.test(node.nodeName);
 }
 /**
 * @internal
@@ -9446,11 +10491,57 @@ function $getEditor() {
 	return getActiveEditor();
 }
 /**
-* @internal @experimental
+* @experimental
+*
+* Read the editor's `$getDOMSlot` configuration (defaulting to the base
+* implementation when no override is registered via {@link DOMRenderExtension}).
+* Cross-package consumers (`@lexical/utils`, `@lexical/react`) use this to
+* route selection / DOM lookups through extension-configured slots.
 */
 function $getEditorDOMRenderConfig(editor = $getEditor()) {
 	return editor._config.dom || DEFAULT_EDITOR_DOM_CONFIG;
 }
+/**
+* @experimental
+*
+* Resolve the DOM slot for a node through the configured `$getDOMSlot` hook,
+* narrowing the return type via {@link DOMSlotForNode}: for an `ElementNode`
+* the result is an {@link ElementDOMSlot} (with children-management methods),
+* for non-Element nodes the base {@link DOMSlot} pointing at the keyed DOM.
+*
+* Invariants if an extension override returns a slot that doesn't match the
+* expected narrow type for the node (extension contract violation).
+*/
+function $getDOMSlot(node, dom, editor = $getEditor()) {
+	const slot = $getEditorDOMRenderConfig(editor).$getDOMSlot(node, dom, editor);
+	if ($isElementNode(node)) {
+		if (!$isElementDOMSlot(slot)) formatDevErrorMessage(`$getDOMSlot: expected ElementDOMSlot for ElementNode (key ${node.getKey()} type ${node.getType()})`);
+	}
+	return slot;
+}
+/**
+* @experimental
+*
+* Type guard narrowing a {@link DOMSlot} to an {@link ElementDOMSlot}, which
+* exposes children-management methods like `insertChild` and the managed
+* line-break helpers.
+*/
+function $isElementDOMSlot(slot) {
+	return slot instanceof ElementDOMSlot;
+}
+/**
+* @experimental
+*
+* Resolve the actual text DOM (`Text`) for a `TextNode` through the
+* configured `$getDOMSlot` hook. Unlike the plain {@link getDOMTextNode}
+* which descends the first child chain from a raw element, this routes
+* through the slot so an extension wrapping the text node's keyed DOM
+* (e.g. one that injects a `contentEditable=false` sibling before the
+* text) still points at the correct content element.
+*/
+function $getDOMTextNode(node, dom, editor = $getEditor()) {
+	return getDOMTextNode($getDOMSlot(node, dom, editor).element);
+}
 /** @internal */
 /**
 * @internal
@@ -9522,24 +10613,63 @@ function $cloneWithPropertiesEphemeral(latestNode) {
 	return $markEphemeral($cloneWithProperties(latestNode));
 }
 function setNodeIndentFromDOM(elementDom, elementNode) {
+	const indentAttr = elementDom.getAttribute("data-lexical-indent");
+	if (indentAttr !== null) {
+		const parsed = parseInt(indentAttr, 10);
+		if (Number.isFinite(parsed) && parsed >= 0) {
+			elementNode.setIndent(parsed);
+			return;
+		}
+	}
 	const indentSize = parseInt(elementDom.style.paddingInlineStart, 10) || 0;
 	const indent = Math.round(indentSize / 40);
 	elementNode.setIndent(indent);
 }
 /**
-* @internal
+* Reads the `dir` attribute from a DOM element and applies it to the given
+* ElementNode via {@link ElementNode.setDirection} when it is a valid direction
+* value (`'ltr'` or `'rtl'`). Other values, including missing or empty `dir`,
+* leave the node unchanged. Useful inside `importDOM` converters to preserve
+* explicit text direction from imported HTML.
+*
+* @param node - The ElementNode to update.
+* @param domNode - The source HTMLElement whose `dir` attribute is read.
+* @returns The node, with its direction set when the source `dir` was valid.
+*/
+function $setDirectionFromDOM(node, domNode) {
+	const dir = domNode.getAttribute("dir");
+	return dir === "ltr" || dir === "rtl" ? node.setDirection(dir) : node;
+}
+/**
+* Reads the `style` and CSS `textAlign` property from a DOM element
+* and set format to the given ElementNode via {@link ElementNode.setFormat}
+* when it is a valid alignment value {@link ElementFormatType}
+* Other values, including missing or empty, leave the node unchanged.
+* Useful inside `importDOM` converters to preserve explicit alignment from imported HTML.
+*
+* @param node - The ElementNode to update.
+* @param domNode - The source HTMLElement whose `style` property is read.
+* @returns The node, with its align format set when the source `style.textAlign` was valid.
+*/
+function $setFormatFromDOM(node, domNode) {
+	const alignment = domNode.style.textAlign;
+	return alignment && alignment in ELEMENT_TYPE_TO_FORMAT ? node.setFormat(alignment) : node;
+}
+/**
+* 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.
 *
-* Mark this node as unmanaged by lexical's mutation observer like
-* decorator nodes
+* @experimental
 */
 function setDOMUnmanaged(elementDom) {
-	const el = elementDom;
-	el.__lexicalUnmanaged = true;
+	elementDom.__lexicalUnmanaged = true;
 }
 /**
-* @internal
+* True if this DOM node was marked with {@link setDOMUnmanaged}.
 *
-* True if this DOM node was marked with {@link setDOMUnmanaged}
+* @experimental
 */
 function isDOMUnmanaged(elementDom) {
 	return elementDom.__lexicalUnmanaged === true;
@@ -10987,4 +12117,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, $getAdjacentChildCaret, $getAdjacentNode, $getAdjacentSiblingOrParentSiblingCaret, $getCaretInDirection, $getCaretRange, $getCaretRangeInDirection, $getCharacterOffsets, $getChildCaret, $getChildCaretAtIndex, $getChildCaretOrSelf, $getCollapsedCaretRange, $getCommonAncestor, $getCommonAncestorResultBranchOrder, $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, $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, $setPointFromCaret, $setSelection, $setSelectionFromCaretRange, $setState, $splitAtPointCaretNext, $splitNode, $updateRangeSelectionFromCaretRange, ArtificialNode__DO_NOT_USE, BEFORE_INPUT_COMMAND, BLUR_COMMAND, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, 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_BOLD, IS_CODE, IS_HIGHLIGHT, IS_ITALIC, 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, isInlineDomNode, isLexicalEditor, isModifierMatch, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, makeStepwiseIterator, mergeRegister, normalizeClassNames, removeClassNamesFromElement, removeFromParent, resetRandomKey, safeCast, setDOMStyleFromCSS, setDOMStyleObject, setDOMUnmanaged, setNodeIndentFromDOM, shallowMergeConfig, toggleTextFormatType };
+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 };