@mx-space/cli 0.13.1 → 0.13.3

package/dist/{LexicalUtils.dev-BiFU3789.mjs → LexicalUtils.dev-BRgK0L6G.mjs}

@@ -1,6 +1,6 @@
-import { $ as $isElementNode, Ar as removeClassNamesFromElement, D as $getCaretRangeInDirection, Dr as makeStepwiseIterator, Dt as $splitAtPointCaretNext, E as $getCaretRange, Et as $setState, G as $getState, H as $getRoot, M as $getCollapsedCaretRange, Mt as CAN_USE_DOM, N as $getDOMSlot, Or as mergeRegister, Ot as $splitNode, P as $getDOMTextNode, S as $getAdjacentChildCaret, Sn as IS_SAFARI, Sr as isHTMLElement, T as $getCaretInDirection, Tt as $setSelectionFromCaretRange, U as $getSelection, V as $getPreviousSelection, W as $getSiblingCaret, X as $isChildCaret, a as $cloneWithProperties, b as $fullReconcile, bn as IS_IOS, dn as IS_ANDROID, f as $createParagraphNode, fn as IS_ANDROID_CHROME, ft as $isTextNode, gn as IS_CHROME, hr as isBlockDomNode, ht as $normalizeCaret, i as $caretRangeFromSelection, j as $getChildCaretOrSelf, jt as CAN_USE_BEFORE_INPUT, k as $getChildCaret, mn as IS_APPLE_WEBKIT, pn as IS_APPLE, pt as $isTextPointCaret, r as $caretFromPoint, st as $isRangeSelection, tr as addClassNamesToElement, ur as getDOMTextNode, ut as $isSiblingCaret, vn as IS_FIREFOX, vt as $removeTextFromCaretRange, w as $getAdjacentSiblingOrParentSiblingCaret, wr as isInlineDomNode, wt as $setSelection, xr as isHTMLAnchorElement, y as $findMatchingParent, yt as $rewindSiblingCaret } from "./Lexical.node-fXM8Jp7p.mjs";
-import { a as createRectsFromDOMRange } from "./LexicalSelection.node-BU5L4193.mjs";
-//#region ../../node_modules/.pnpm/@lexical+utils@0.45.0/node_modules/@lexical/utils/dist/LexicalUtils.dev.mjs
+import { $ as $insertNodeToNearestRootAtCaret, A as $getChildCaret, An as IS_FIREFOX, Bt as CAN_USE_DOM, C as $getAdjacentChildCaret, Cn as IS_ANDROID, Ct as $normalizeCaret, D as $getCaretRange, Dt as $rewindSiblingCaret, E as $getCaretInDirection, En as IS_APPLE_WEBKIT, Er as getDOMSelectionPoints, Et as $removeTextFromCaretRange, F as $getDOMTextNode, Ft as $splitAtPointCaretNext, G as $getSiblingCaret, H as $getPreviousSelection, It as $splitNode, J as $getSlotHost, K as $getSlot, Kr as isHTMLAnchorElement, M as $getChildCaretOrSelf, Mn as IS_IOS, Mr as getParentElement, Mt as $setSelection, N as $getCollapsedCaretRange, Nt as $setSelectionFromCaretRange, O as $getCaretRangeInDirection, On as IS_CHROME, P as $getDOMSlot, Pn as IS_SAFARI, Pt as $setState, Rr as isBlockDomNode, T as $getAdjacentSiblingOrParentSiblingCaret, Tn as IS_APPLE, U as $getRoot, W as $getSelection, X as $getState, Y as $getSlotNames, Yr as isInlineDomNode, _t as $isSiblingCaret, a as $caretRangeFromSelection, at as $isElementNode, b as $findMatchingParent, bt as $isTextNode, c as $comparePointCaretNext, i as $caretFromPoint, ii as removeClassNamesFromElement, kr as getDOMTextNode, ni as mergeRegister, nt as $isChildCaret, o as $cloneWithProperties, p as $createParagraphNode, pr as addClassNamesToElement, pt as $isRangeSelection, q as $getSlotFrame, qr as isHTMLElement, ti as makeStepwiseIterator, vt as $isSlotHost, wn as IS_ANDROID_CHROME, x as $fullReconcile, xt as $isTextPointCaret, zt as CAN_USE_BEFORE_INPUT } from "./Lexical.node-BlCLnfA6.mjs";
+import { o as createRectsFromDOMRange, t as $isAtNodeEnd } from "./LexicalSelection.node-CLKroUMQ.mjs";
+//#region ../../node_modules/.pnpm/@lexical+utils@0.46.0_typescript@6.0.3/node_modules/@lexical/utils/dist/LexicalUtils.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -25,6 +25,61 @@ function formatDevErrorMessage(message) {
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* Dedupe a list of selection client-rects before they are drawn as fills.
+*
+* `Range.getClientRects()` can return rects that are duplicated or contained
+* within another, and WebKit in particular emits a spurious wider rect alongside
+* the real text rect on some blocks (balanced or letter-spaced headings are the
+* reproducible case). Drawn as semi-transparent fills, duplicates read brighter
+* than a single rect, and the wider rect paints the "extra empty selection area"
+* reported in facebook/lexical#7106.
+*
+* This drops zero-area rects and any rect that contains another, keeping the
+* smaller text-hugging one, with a 1px tolerance for sub-pixel jitter. The
+* assumption is that genuine same-line rects are horizontally disjoint (one rect
+* per visual row; inline boxes on a row tile side by side), so containment only
+* holds for the duplicate or spurious-wider cases, never for a legitimate
+* sub-fragment that should be kept.
+*
+* On the `createRectsFromDOMRange` path (e.g. `positionNodeOnRange`): that
+* helper's own `selectionSpansElement` filter already drops the full-block-width
+* spurious rect, so there this mainly prevents the duplicate-doubling. The #7106
+* extra-area paint is addressed for consumers that feed raw `getClientRects()`,
+* where `selectionSpansElement` does not run — that is the path that needs it.
+*
+* Known limitation: the disjoint assumption holds for normal flow. Overlapping
+* inline content — a negative margin, a transform, or a baseline-shifted inline
+* decorator — can place a real sub-fragment inside a wider real-text rect on the
+* same row; if a sub-pixel top offset also lets both clear
+* `createRectsFromDOMRange`'s asymmetric overlap filter, keep-smaller drops the
+* wider rect and under-paints the glyphs it uniquely covered. There is no
+* rect-only fix: that wider rect is geometrically indistinguishable from the
+* spurious-wider (#7106) rect, so keeping it would re-introduce the extra-area
+* paint. See the under-paint characterization browser test.
+*
+* Typed on the structural subset of `DOMRect` it reads, so it accepts a live
+* `DOMRectList` from `getClientRects()` as well as the `DOMRect[]` returned by
+* `createRectsFromDOMRange`, and is unit-testable without a DOM.
+*/
+function dedupeSelectionRects(rects) {
+	const contains = (a, b) => b.left >= a.left - 1 && b.top >= a.top - 1 && b.right <= a.right + 1 && b.bottom <= a.bottom + 1;
+	const kept = [];
+	for (const rect of Array.from(rects)) {
+		if (rect.width < .5 || rect.height < .5) continue;
+		if (kept.some((keptRect) => contains(rect, keptRect))) continue;
+		for (let i = kept.length - 1; i >= 0; i--) if (contains(kept[i], rect)) kept.splice(i, 1);
+		kept.push(rect);
+	}
+	return kept;
+}
+/**
+* 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 px(value) {
 	return `${value}px`;
 }
@@ -60,7 +115,7 @@ function mlcPositionNodeOnRange(editor, range, onReposition) {
 		if (!(rootDOMNode !== null)) formatDevErrorMessage(`Unexpected null rootDOMNode`);
 		if (!(parentDOMNode !== null)) formatDevErrorMessage(`Unexpected null parentDOMNode`);
 		const { left: parentLeft, top: parentTop } = parentDOMNode.getBoundingClientRect();
-		const rects = createRectsFromDOMRange(editor, range);
+		const rects = dedupeSelectionRects(createRectsFromDOMRange(editor, range));
 		if (!wrapperNode.isConnected) prependDOMNode(parentDOMNode, wrapperNode);
 		let hasRepositioned = false;
 		for (let i = 0; i < rects.length; i++) {
@@ -233,9 +288,10 @@ function markSelection(editor, onReposition = defaultOnReposition) {
 function selectionAlwaysOnDisplay(editor, onReposition) {
 	let removeSelectionMark = null;
 	const onSelectionChange = () => {
-		const domSelection = getSelection();
-		const domAnchorNode = domSelection && domSelection.anchorNode;
 		const editorRootElement = editor.getRootElement();
+		const targetWindow = editorRootElement !== null ? editorRootElement.ownerDocument.defaultView : null;
+		const domSelection = targetWindow !== null ? targetWindow.getSelection() : null;
+		const domAnchorNode = domSelection !== null ? getDOMSelectionPoints(domSelection, editorRootElement).anchorNode : null;
 		if (domAnchorNode !== null && editorRootElement !== null && editorRootElement.contains(domAnchorNode)) {
 			if (removeSelectionMark !== null) {
 				removeSelectionMark();
@@ -256,6 +312,38 @@ function selectionAlwaysOnDisplay(editor, onReposition) {
 	});
 }
 /**
+* 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.
+*
+*/
+/**
+* Walks up from `element` and returns the nearest scrollable ancestor (or
+* `ownerDocument.body` if none is found), used to keep the active typeahead
+* option scrolled into view. Set `includeHidden` to also treat
+* `overflow: hidden` ancestors as scroll parents.
+*
+* The walk crosses ShadowRoot→host (via `getParentElement`) so a
+* shadow-mounted editor's scroll parent is found in the enclosing light-DOM
+* ancestor chain, and the styles / body are resolved through the element's
+* own realm so an iframe-mounted editor stays inside its document.
+*/
+function getScrollParent(element, includeHidden) {
+	const ownerDocument = element.ownerDocument;
+	const win = ownerDocument.defaultView || window;
+	let style = win.getComputedStyle(element);
+	const excludeStaticParent = style.position === "absolute";
+	const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;
+	if (style.position === "fixed") return ownerDocument.body;
+	for (let parent = element; parent = getParentElement(parent);) {
+		style = win.getComputedStyle(parent);
+		if (excludeStaticParent && style.position === "static") continue;
+		if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) return parent;
+	}
+	return ownerDocument.body;
+}
+/**
 * Returns true if the file type matches the types passed within the acceptableMimeTypes array, false otherwise.
 * The types passed must be strings and are CASE-SENSITIVE.
 * eg. if file is of type 'text' and acceptableMimeTypes = ['TEXT', 'IMAGE'] the function will return false.
@@ -307,6 +395,11 @@ function mediaFileReader(files, acceptableMimeTypes) {
 * branch until you hit a dead-end (leaf) and backtracking to find the nearest branching path and repeat.
 * It will then return all the nodes found in the search in an array of objects.
 * Preorder traversal is used, meaning that nodes are listed in the order of when they are FIRST encountered.
+*
+* Children-only spine: named slot subtrees are skipped. Use {@link $dfsWithSlots}
+* when you need to descend into slots (e.g. character counting, slot-aware
+* content extraction).
+*
 * @param startNode - The node to start the search (inclusive), if omitted, it will start at the root node.
 * @param endNode - The node to end the search (inclusive), if omitted, it will find all descendants of the startingNode. If endNode
 * is an ElementNode, it will stop before visiting any of its children.
@@ -337,6 +430,12 @@ function $reverseDfs(startNode, endNode) {
 /**
 * $dfs iterator (left to right). Tree traversal is done on the fly as new values are requested with O(1) memory.
 * Preorder traversal is used, meaning that nodes are iterated over in the order of when they are FIRST encountered.
+*
+* Children-only spine: named slot subtrees are skipped. Use {@link $dfsWithSlotsIterator}
+* (or {@link $dfsWithSlots}) when you need to descend into slots — e.g. character
+* counting, content extraction, or any cross-tree analysis where slotted content
+* should be visited.
+*
 * @param startNode - The node to start the search (inclusive), if omitted, it will start at the root node.
 * @param endNode - The node to end the search (inclusive), if omitted, it will find all descendants of the startingNode.
 * If endNode is an ElementNode, the iterator will end as soon as it reaches the endNode (no children will be visited).
@@ -345,6 +444,61 @@ function $reverseDfs(startNode, endNode) {
 function $dfsIterator(startNode, endNode) {
 	return $dfsCaretIterator("next", startNode, endNode);
 }
+/**
+* Like {@link $dfs}, but also descends into named slots. Slots are not on the
+* linked-list spine, so each host's slot subtrees are emitted slots-first,
+* right after the host node and before its linked-list children.
+* @experimental
+* @param startNode - The node to start the search (inclusive), defaults to the root node.
+* @param endNode - The node to end the search (inclusive), defaults to all descendants of startNode.
+* Like {@link $dfs}, reaching endNode stops the traversal before visiting any of its
+* children — including its slot subtrees. An endNode strictly inside a slot subtree
+* is never reached (slot subtrees are spliced in whole), so it does not truncate
+* the traversal.
+* @returns An array of DFSNodes. It will always return at least 1 node (the start node).
+*/
+function $dfsWithSlots(startNode, endNode) {
+	return Array.from($dfsWithSlotsIterator(startNode, endNode));
+}
+/**
+* Slot-aware {@link $dfsIterator}: a host's slot subtrees are emitted
+* slots-first, right after the host node and before its linked-list children.
+* The caret iterator drives the linked-list spine untouched.
+* @experimental
+* @param startNode - The node to start the search (inclusive), defaults to the root node.
+* @param endNode - The node to end the search (inclusive), defaults to all descendants of startNode.
+* Like {@link $dfs}, reaching endNode stops the traversal before visiting any of its
+* children — including its slot subtrees. An endNode strictly inside a slot subtree
+* is never reached (slot subtrees are spliced in whole), so it does not truncate
+* the traversal.
+* @returns An iterator, each yielded value is a DFSNode. It will always return at least 1 node (the start node).
+*/
+function* $dfsWithSlotsIterator(startNode, endNode) {
+	for (const dfsNode of $dfsCaretIterator("next", startNode, endNode)) {
+		yield dfsNode;
+		const { node, depth } = dfsNode;
+		if ($isSlotHost(node) && !node.is(endNode)) for (const name of $getSlotNames(node)) {
+			const slot = $getSlot(node, name);
+			if (slot !== null) yield* $dfsSubtreeIterator(slot, depth + 1);
+		}
+	}
+}
+/**
+* Slots-first preorder traversal of a self-contained subtree (a slot node and
+* everything it owns). Used to splice slot subtrees into $dfsWithSlotsIterator.
+*/
+function* $dfsSubtreeIterator(node, depth) {
+	yield {
+		depth,
+		node
+	};
+	const childDepth = depth + 1;
+	if ($isSlotHost(node)) for (const name of $getSlotNames(node)) {
+		const slot = $getSlot(node, name);
+		if (slot !== null) yield* $dfsSubtreeIterator(slot, childDepth);
+	}
+	if ($isElementNode(node)) for (const child of node.getChildren()) yield* $dfsSubtreeIterator(child, childDepth);
+}
 function $getEndCaret(startNode, direction) {
 	const rval = $getAdjacentSiblingOrParentSiblingCaret($getSiblingCaret(startNode, direction));
 	return rval && rval[0];
@@ -387,7 +541,7 @@ function $getNextSiblingOrParentSibling(node) {
 }
 function $getDepth(node) {
 	let depth = -1;
-	for (let innerNode = node; innerNode !== null; innerNode = innerNode.getParent()) depth++;
+	for (let innerNode = node; innerNode !== null; innerNode = innerNode.getParent() ?? $getSlotHost(innerNode)) depth++;
 	return depth;
 }
 /**
@@ -412,6 +566,80 @@ function $reverseDfsIterator(startNode, endNode) {
 	return $dfsCaretIterator("previous", startNode, endNode);
 }
 /**
+* Like {@link $reverseDfs}, but also descends into named slots. Mirror of
+* {@link $dfsWithSlots}.
+* @experimental
+* @param startNode - The node to start the search (inclusive), defaults to the root node.
+* @param endNode - The node to end the search (inclusive), defaults to all descendants of startNode.
+* Mirroring {@link $dfsWithSlots}, reaching endNode stops the traversal without
+* emitting its slot subtrees. An endNode strictly inside a slot subtree is never
+* reached (slot subtrees are spliced in whole), so it does not truncate the
+* traversal.
+* @returns An array of DFSNodes. It will always return at least 1 node (the start node).
+*/
+function $reverseDfsWithSlots(startNode, endNode) {
+	return Array.from($reverseDfsWithSlotsIterator(startNode, endNode));
+}
+/**
+* Right-to-left mirror of {@link $dfsWithSlotsIterator}. Forward visits slots
+* before children, so the mirror visits them last: a host's slot subtrees are
+* emitted (in reverse slot order) only once its linked-list subtree is fully
+* traversed. Because the caret spine streams nodes, "left the host subtree" is
+* detected when a node at the host's depth or shallower arrives, flushing the
+* host's pending slots. The caret iterator drives the spine untouched.
+* @experimental
+* @param startNode - The node to start the search (inclusive), defaults to the root node.
+* @param endNode - The node to end the search (inclusive), defaults to all descendants of startNode.
+* Mirroring {@link $dfsWithSlotsIterator}, reaching endNode stops the traversal
+* without emitting its slot subtrees. An endNode strictly inside a slot subtree is
+* never reached (slot subtrees are spliced in whole), so it does not truncate the
+* traversal.
+* @returns An iterator, each yielded value is a DFSNode. It will always return at least 1 node (the start node).
+*/
+function* $reverseDfsWithSlotsIterator(startNode, endNode) {
+	const pending = [];
+	for (const dfsNode of $dfsCaretIterator("previous", startNode, endNode)) {
+		while (pending.length > 0 && dfsNode.depth <= pending[pending.length - 1].depth) {
+			const host = pending.pop();
+			yield* $reverseSlotsOf(host.node, host.depth + 1);
+		}
+		yield dfsNode;
+		const { node, depth } = dfsNode;
+		if ($isSlotHost(node) && $getSlotNames(node).length > 0 && !node.is(endNode)) pending.push({
+			depth,
+			node
+		});
+	}
+	while (pending.length > 0) {
+		const host = pending.pop();
+		yield* $reverseSlotsOf(host.node, host.depth + 1);
+	}
+}
+/** Emit a host's slot subtrees in reverse slot order (mirror of slots-first). */
+function* $reverseSlotsOf(host, childDepth) {
+	const names = $getSlotNames(host);
+	for (let i = names.length - 1; i >= 0; i--) {
+		const slot = $getSlot(host, names[i]);
+		if (slot !== null) yield* $reverseDfsSubtreeIterator(slot, childDepth);
+	}
+}
+/**
+* Right-to-left slots-last preorder of a self-contained subtree: children in
+* reverse order, then slots in reverse order. Mirror of $dfsSubtreeIterator.
+*/
+function* $reverseDfsSubtreeIterator(node, depth) {
+	yield {
+		depth,
+		node
+	};
+	const childDepth = depth + 1;
+	if ($isElementNode(node)) {
+		const children = node.getChildren();
+		for (let i = children.length - 1; i >= 0; i--) yield* $reverseDfsSubtreeIterator(children[i], childDepth);
+	}
+	if ($isSlotHost(node)) yield* $reverseSlotsOf(node, childDepth);
+}
+/**
 * Takes a node and traverses up its ancestors (toward the root node)
 * in order to find a specific type of node.
 * @param node - the node to begin searching.
@@ -437,6 +665,27 @@ function $getNearestBlockElementAncestorOrThrow(startNode) {
 	return blockNode;
 }
 /**
+* Checks whether the selection covers the entire block: the selection's
+* start point is at or before the first position inside blockNode and its
+* end point is at or after the last position inside blockNode. A selection
+* that extends beyond the block's boundaries still fully selects the block,
+* and an empty block is fully selected by any selection that touches or
+* surrounds it.
+*
+* @param blockNode - The ElementNode to check, typically a top-level block or the RootNode
+* @param selectionOrRange - The RangeSelection or CaretRange to check
+* @returns true if the selection covers the entire blockNode
+*/
+function $isBlockFullySelected(blockNode, selectionOrRange) {
+	const range = $getCaretRangeInDirection($isRangeSelection(selectionOrRange) ? $caretRangeFromSelection(selectionOrRange) : selectionOrRange, "next");
+	const anchorFrame = $getSlotFrame(range.anchor.origin);
+	const blockFrame = $getSlotFrame(blockNode.getLatest());
+	if (anchorFrame === null ? blockFrame !== null : !anchorFrame.is(blockFrame)) return false;
+	const blockStart = $normalizeCaret($getChildCaret(blockNode, "next"));
+	const blockEnd = $getCaretInDirection($normalizeCaret($getChildCaret(blockNode, "previous")), "next");
+	return $comparePointCaretNext(range.anchor, blockStart) <= 0 && $comparePointCaretNext(range.focus, blockEnd) >= 0;
+}
+/**
 * Attempts to resolve nested element nodes of the same type into a single node of that type.
 * It is generally used for marks/commenting
 * @param editor - The lexical editor
@@ -528,30 +777,6 @@ function $insertNodeToNearestRoot(node) {
 	return node.getLatest();
 }
 /**
-* If the insertion caret is the root/shadow root node (see {@link lexical!$isRootOrShadowRoot}),
-* the node will be inserted there, otherwise the parent nodes will be split according to the
-* given options.
-* @param node - The node to be inserted
-* @param caret - The location to insert or split from
-* @returns The node after its insertion
-*/
-function $insertNodeToNearestRootAtCaret(node, caret, options) {
-	let insertCaret = $getCaretInDirection(caret, "next");
-	if ($isTextPointCaret(insertCaret)) {
-		if (insertCaret.offset === 0) insertCaret = $getSiblingCaret(insertCaret.origin, "previous").getFlipped();
-		else if (insertCaret.offset === insertCaret.origin.getTextContentSize()) insertCaret = $getSiblingCaret(insertCaret.origin, "next");
-	}
-	if (insertCaret.origin.is(node)) {
-		if (!$isSiblingCaret(insertCaret)) formatDevErrorMessage(`$insertNodeToNearestRootAtCaret node ${node.getKey()} of type ${node.getType()} can not be inserted into itself`);
-		insertCaret = $rewindSiblingCaret(insertCaret);
-	}
-	if (node.is(insertCaret.getNodeAtCaret()) || node.is(insertCaret.getFlipped().getNodeAtCaret())) node.remove(true);
-	for (let nextCaret = insertCaret; nextCaret; nextCaret = $splitAtPointCaretNext(nextCaret, options)) insertCaret = nextCaret;
-	if (!!$isTextPointCaret(insertCaret)) formatDevErrorMessage(`$insertNodeToNearestRootAtCaret: An unattached TextNode can not be split`);
-	insertCaret.insert(node.isInline() ? $createParagraphNode().append(node) : node);
-	return $getCaretInDirection($getSiblingCaret(node.getLatest(), "next"), caret.direction);
-}
-/**
 * Inserts a node into leaf — the deepest accessible node at the carriage position
 * @param node - The node to be inserted
 */
@@ -591,6 +816,24 @@ function $wrapNodeInElement(node, createElementNode) {
 function objectKlassEquals(object, objectClass) {
 	return object !== null ? Object.getPrototypeOf(object).constructor.name === objectClass.name : false;
 }
+function eventFiles(event) {
+	let dataTransfer = null;
+	if (objectKlassEquals(event, DragEvent)) dataTransfer = event.dataTransfer;
+	else if (objectKlassEquals(event, ClipboardEvent)) dataTransfer = event.clipboardData;
+	if (dataTransfer === null) return [
+		false,
+		[],
+		false
+	];
+	const types = dataTransfer.types;
+	const hasFiles = types.includes("Files");
+	const hasContent = types.includes("text/html") || types.includes("text/plain");
+	return [
+		hasFiles,
+		Array.from(dataTransfer.files),
+		hasContent
+	];
+}
 /**
 * @deprecated Use Array filter or flatMap
 *
@@ -666,9 +909,12 @@ function needsManualZoom() {
 */
 function calculateZoomLevel(element, useManualZoom = false) {
 	let zoom = 1;
-	if (needsManualZoom() || useManualZoom) while (element) {
-		zoom *= Number(window.getComputedStyle(element).getPropertyValue("zoom"));
-		element = element.parentElement;
+	if (needsManualZoom() || useManualZoom) {
+		const win = element && element.ownerDocument.defaultView || window;
+		while (element) {
+			zoom *= Number(win.getComputedStyle(element).getPropertyValue("zoom"));
+			element = getParentElement(element);
+		}
 	}
 	return zoom;
 }
@@ -807,5 +1053,99 @@ function makeStateWrapper(stateConfig) {
 		stateConfig
 	};
 }
+/**
+* Inserts a new paragraph before a container node when the cursor moves outside the container element
+*
+* Intended for use ArrowLeft/ArrowUp keyboard handlers to allow the user to break out
+* of a container node by creating a new paragraph before it.
+*
+* A paragraph is inserted if that the cursor is positioned at the beginning inside the container,
+* and the container itself is the first element in the document and has no preceding sibling
+*
+* When a paragraph is inserted the selection is moved to it and, if the
+* triggering keyboard event is provided, its default action is prevented so
+* the browser does not additionally move the selection. Relying on the native
+* caret movement is not portable: Chromium moves into the freshly inserted
+* paragraph while Firefox leaves the caret inside the container.
+*
+* @param $isContainerNode - Type guard identifying the container node type to escape from.
+* @param event - The keyboard event that triggered the escape, if any. Its
+*   default action is prevented when a paragraph is inserted.
+* @returns `true` if a paragraph was inserted, `false` otherwise.
+*/
+function $onEscapeUp($isContainerNode, event) {
+	const selection = $getSelection();
+	if ($isRangeSelection(selection) && selection.isCollapsed()) {
+		const containerNode = $findMatchingParent(selection.anchor.getNode(), $isContainerNode);
+		if (containerNode) {
+			const parent = containerNode.getParent();
+			if (parent !== null && parent.getFirstChild() === containerNode && $isAtStartOfNode(selection.anchor, containerNode)) {
+				containerNode.insertBefore($createParagraphNode()).selectEnd();
+				if (event) event.preventDefault();
+				return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* Inserts a new paragraph after a container node when the cursor moves outside the container element
+*
+* Intended for use ArrowRight/ArrowDown keyboard handlers to allow the user to break out
+* of a container node by creating a new paragraph after it.
+*
+* A paragraph is inserted if that the cursor is positioned at the ending inside the container,
+* and the container itself is the last element in the document and has no next sibling
+*
+* When a paragraph is inserted the selection is moved to it and, if the
+* triggering keyboard event is provided, its default action is prevented so
+* the browser does not additionally move the selection. Relying on the native
+* caret movement is not portable: Chromium moves into the freshly inserted
+* paragraph while Firefox leaves the caret inside the container.
+*
+* @param $isContainerNode - Type guard identifying the container node type to escape from.
+* @param event - The keyboard event that triggered the escape, if any. Its
+*   default action is prevented when a paragraph is inserted.
+* @returns `true` if a paragraph was inserted, `false` otherwise.
+*/
+function $onEscapeDown($isContainerNode, event) {
+	const selection = $getSelection();
+	if ($isRangeSelection(selection) && selection.isCollapsed()) {
+		const containerNode = $findMatchingParent(selection.anchor.getNode(), $isContainerNode);
+		if (containerNode) {
+			const parent = containerNode.getParent();
+			if (parent !== null && parent.getLastChild() === containerNode && $isAtEndOfNode(selection.anchor, containerNode)) {
+				containerNode.insertAfter($createParagraphNode()).selectEnd();
+				if (event) event.preventDefault();
+				return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* Whether the collapsed `point` sits at the very start of `node`'s content —
+* on its first descendant (or on the empty node itself) at offset 0. Shared by
+* {@link $onEscapeUp} and slot-aware variants so the "at the leading edge of a
+* container" test stays in one place.
+*/
+function $isAtStartOfNode(point, node) {
+	if (point.offset !== 0) return false;
+	const first = node.getFirstDescendant() ?? node;
+	const anchorNode = point.getNode();
+	return anchorNode === first || $isElementNode(anchorNode) && anchorNode.getFirstDescendant() === first;
+}
+/**
+* Whether the collapsed `point` sits at the very end of `node`'s content — on
+* its last descendant (or on the empty node itself) at that node's end. Shared
+* by {@link $onEscapeDown} and slot-aware variants so the "at the trailing edge
+* of a container" test stays in one place.
+*/
+function $isAtEndOfNode(point, node) {
+	if (!$isAtNodeEnd(point)) return false;
+	const last = node.getLastDescendant() ?? node;
+	const anchorNode = point.getNode();
+	return anchorNode === last || $isElementNode(anchorNode) && anchorNode.getLastDescendant() === last;
+}
 //#endregion
-export { $descendantsMatching, $dfs, $dfsIterator, $filter, $findMatchingParent, $firstToLastIterator, $getAdjacentCaret, $getAdjacentSiblingOrParentSiblingCaret, $getDepth, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $getNextRightPreorderNode, $getNextSiblingOrParentSibling, $handleIndentAndOutdent, $insertFirst, $insertNodeIntoLeaf, $insertNodeToNearestRoot, $insertNodeToNearestRootAtCaret, $isEditorIsNestedEditor, $lastToFirstIterator, $restoreEditorState, $reverseDfs, $reverseDfsIterator, $splitNode, $unwrapAndFilterDescendants, $unwrapNode, $wrapNodeInElement, CAN_USE_BEFORE_INPUT, CAN_USE_DOM, IS_ANDROID, IS_ANDROID_CHROME, IS_APPLE, IS_APPLE_WEBKIT, IS_CHROME, IS_FIREFOX, IS_IOS, IS_SAFARI, addClassNamesToElement, calculateZoomLevel, isBlockDomNode, isHTMLAnchorElement, isHTMLElement, isInlineDomNode, isMimeType, makeStateWrapper, markSelection, mediaFileReader, mergeRegister, objectKlassEquals, mlcPositionNodeOnRange as positionNodeOnRange, registerNestedElementResolver, removeClassNamesFromElement, selectionAlwaysOnDisplay };
+export { $descendantsMatching, $dfs, $dfsIterator, $dfsWithSlots, $dfsWithSlotsIterator, $filter, $findMatchingParent, $firstToLastIterator, $getAdjacentCaret, $getAdjacentSiblingOrParentSiblingCaret, $getDepth, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, $getNextRightPreorderNode, $getNextSiblingOrParentSibling, $handleIndentAndOutdent, $insertFirst, $insertNodeIntoLeaf, $insertNodeToNearestRoot, $insertNodeToNearestRootAtCaret, $isAtEndOfNode, $isAtStartOfNode, $isBlockFullySelected, $isEditorIsNestedEditor, $lastToFirstIterator, $onEscapeDown, $onEscapeUp, $restoreEditorState, $reverseDfs, $reverseDfsIterator, $reverseDfsWithSlots, $reverseDfsWithSlotsIterator, $splitNode, $unwrapAndFilterDescendants, $unwrapNode, $wrapNodeInElement, CAN_USE_BEFORE_INPUT, CAN_USE_DOM, IS_ANDROID, IS_ANDROID_CHROME, IS_APPLE, IS_APPLE_WEBKIT, IS_CHROME, IS_FIREFOX, IS_IOS, IS_SAFARI, addClassNamesToElement, calculateZoomLevel, dedupeSelectionRects, eventFiles, getScrollParent, isBlockDomNode, isHTMLAnchorElement, isHTMLElement, isInlineDomNode, isMimeType, makeStateWrapper, markSelection, mediaFileReader, mergeRegister, objectKlassEquals, mlcPositionNodeOnRange as positionNodeOnRange, registerNestedElementResolver, removeClassNamesFromElement, selectionAlwaysOnDisplay };

package/dist/{LexicalUtils.node-j3Llm7Y3.mjs → LexicalUtils.node-BVAwOkL4.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@lexical+utils@0.45.0/node_modules/@lexical/utils/dist/LexicalUtils.node.mjs
+//#region ../../node_modules/.pnpm/@lexical+utils@0.46.0_typescript@6.0.3/node_modules/@lexical/utils/dist/LexicalUtils.node.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -6,12 +6,14 @@
 * LICENSE file in the root directory of this source tree.
 *
 */
-const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalUtils.dev-BiFU3789.mjs") : import("./LexicalUtils.prod-DCvrA78p.mjs"));
+const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalUtils.dev-BRgK0L6G.mjs") : import("./LexicalUtils.prod-C1gtvVDP.mjs"));
 const $descendantsMatching = mod.$descendantsMatching;
-const $dfs = mod.$dfs;
+mod.$dfs;
 mod.$dfsIterator;
+const $dfsWithSlots = mod.$dfsWithSlots;
+mod.$dfsWithSlotsIterator;
 mod.$filter;
-const $findMatchingParent = mod.$findMatchingParent;
+mod.$findMatchingParent;
 mod.$firstToLastIterator;
 mod.$getAdjacentCaret;
 mod.$getAdjacentSiblingOrParentSiblingCaret;
@@ -24,12 +26,19 @@ const $handleIndentAndOutdent = mod.$handleIndentAndOutdent;
 const $insertFirst = mod.$insertFirst;
 mod.$insertNodeIntoLeaf;
 const $insertNodeToNearestRoot = mod.$insertNodeToNearestRoot;
-const $insertNodeToNearestRootAtCaret = mod.$insertNodeToNearestRootAtCaret;
+mod.$insertNodeToNearestRootAtCaret;
+mod.$isAtEndOfNode;
+mod.$isAtStartOfNode;
+const $isBlockFullySelected = mod.$isBlockFullySelected;
 mod.$isEditorIsNestedEditor;
 mod.$lastToFirstIterator;
+const $onEscapeDown = mod.$onEscapeDown;
+const $onEscapeUp = mod.$onEscapeUp;
 mod.$restoreEditorState;
 mod.$reverseDfs;
 mod.$reverseDfsIterator;
+mod.$reverseDfsWithSlots;
+mod.$reverseDfsWithSlotsIterator;
 mod.$splitNode;
 const $unwrapAndFilterDescendants = mod.$unwrapAndFilterDescendants;
 mod.$unwrapNode;
@@ -38,27 +47,30 @@ mod.CAN_USE_BEFORE_INPUT;
 mod.CAN_USE_DOM;
 mod.IS_ANDROID;
 mod.IS_ANDROID_CHROME;
-mod.IS_APPLE;
+const IS_APPLE = mod.IS_APPLE;
 mod.IS_APPLE_WEBKIT;
 mod.IS_CHROME;
 mod.IS_FIREFOX;
 mod.IS_IOS;
 mod.IS_SAFARI;
-const addClassNamesToElement = mod.addClassNamesToElement;
+mod.addClassNamesToElement;
 const calculateZoomLevel = mod.calculateZoomLevel;
+mod.dedupeSelectionRects;
+const eventFiles = mod.eventFiles;
+mod.getScrollParent;
 mod.isBlockDomNode;
-const isHTMLAnchorElement = mod.isHTMLAnchorElement;
-const isHTMLElement = mod.isHTMLElement;
+mod.isHTMLAnchorElement;
+mod.isHTMLElement;
 mod.isInlineDomNode;
 mod.isMimeType;
 mod.makeStateWrapper;
 mod.markSelection;
 mod.mediaFileReader;
-const mergeRegister = mod.mergeRegister;
+mod.mergeRegister;
 const objectKlassEquals = mod.objectKlassEquals;
 mod.positionNodeOnRange;
 mod.registerNestedElementResolver;
-const removeClassNamesFromElement = mod.removeClassNamesFromElement;
+mod.removeClassNamesFromElement;
 const selectionAlwaysOnDisplay = mod.selectionAlwaysOnDisplay;
 //#endregion
-export { removeClassNamesFromElement as _, $getNearestNodeOfType as a, $insertNodeToNearestRoot as c, addClassNamesToElement as d, calculateZoomLevel as f, objectKlassEquals as g, mergeRegister as h, $getNearestBlockElementAncestorOrThrow as i, $insertNodeToNearestRootAtCaret as l, isHTMLElement as m, $dfs as n, $handleIndentAndOutdent as o, isHTMLAnchorElement as p, $findMatchingParent as r, $insertFirst as s, $descendantsMatching as t, $unwrapAndFilterDescendants as u, selectionAlwaysOnDisplay as v };
+export { $handleIndentAndOutdent as a, $isBlockFullySelected as c, $unwrapAndFilterDescendants as d, IS_APPLE as f, selectionAlwaysOnDisplay as g, objectKlassEquals as h, $getNearestNodeOfType as i, $onEscapeDown as l, eventFiles as m, $dfsWithSlots as n, $insertFirst as o, calculateZoomLevel as p, $getNearestBlockElementAncestorOrThrow as r, $insertNodeToNearestRoot as s, $descendantsMatching as t, $onEscapeUp as u };