@mx-space/cli 0.13.1 → 0.13.2

package/dist/{LexicalExtension.dev-BPNyvGqe.mjs → LexicalExtension.dev-CXtOJb83.mjs}

@@ -1,6 +1,6 @@
-import { $ as $isElementNode, $n as TabNode, $t as ElementNode, Ar as removeClassNamesFromElement, B as $getNodeFromDOMNode, Bn as OUTDENT_CONTENT_COMMAND, Bt as COMMAND_PRIORITY_LOW, D as $getCaretRangeInDirection, E as $getCaretRange, Et as $setState, F as $getEditor, Fr as shallowMergeConfig, G as $getState, Gn as RootNode, H as $getRoot, In as KEY_TAB_COMMAND, Ir as stopLexicalPropagation, It as COMMAND_PRIORITY_BEFORE_CRITICAL, Kn as SELECTION_CHANGE_COMMAND, Ln as LineBreakNode, Lr as toggleTextFormatType, Lt as COMMAND_PRIORITY_CRITICAL, Nt as CLEAR_EDITOR_COMMAND, Or as mergeRegister, Pt as CLICK_COMMAND, Q as $isEditorState, Qn as TEXT_TYPE_TO_FORMAT, Qt as DecoratorNode, R as $getNodeByKey, Rt as COMMAND_PRIORITY_EDITOR, Tt as $setSelectionFromCaretRange, U as $getSelection, Un as ParagraphNode, V as $getPreviousSelection, W as $getSiblingCaret, X as $isChildCaret, Xn as SKIP_SCROLL_INTO_VIEW_TAG, Y as $isBlockElementNode, Z as $isDecoratorNode, Zn as SKIP_SELECTION_FOCUS_TAG, ar as createEditor, at as $isNodeSelection, cr as defineExtension, d as $createNodeSelection, er as TextNode, f as $createParagraphNode, fr as getStaticNodeConfig, gt as $normalizeSelection__EXPERIMENTAL, ht as $normalizeCaret, i as $caretRangeFromSelection, in as HISTORY_MERGE_TAG, ir as createCommand, it as $isLineBreakNode, jr as safeCast, k as $getChildCaret, kt as $updateDOMSelection, l as $create, ln as INSERT_TAB_COMMAND, lr as getDOMSelection, m as $createRangeSelection, nn as FORMAT_TEXT_COMMAND, on as INDENT_CONTENT_COMMAND, or as createState, pt as $isTextPointCaret, rr as configExtension, sr as declarePeerDependency, st as $isRangeSelection, tr as addClassNamesToElement, ut as $isSiblingCaret, vr as isDOMNode, wt as $setSelection, yt as $rewindSiblingCaret } from "./Lexical.node-fXM8Jp7p.mjs";
-import { c as $insertNodeToNearestRoot, i as $getNearestBlockElementAncestorOrThrow, o as $handleIndentAndOutdent, v as selectionAlwaysOnDisplay } from "./LexicalUtils.node-j3Llm7Y3.mjs";
-//#region ../../node_modules/.pnpm/@lexical+extension@0.45.0/node_modules/@lexical/extension/dist/LexicalExtension.dev.mjs
+import { A as $getChildCaret, Ct as $normalizeCaret, D as $getCaretRange, Dt as $rewindSiblingCaret, Fr as getStaticNodeConfig, G as $getSiblingCaret, Gr as isExactShortcutMatch, Gt as COMMAND_PRIORITY_BEFORE_EDITOR, H as $getPreviousSelection, Ht as CLICK_COMMAND, I as $getEditor, J as $getSlotHost, Jn as KEY_TAB_COMMAND, Kt as COMMAND_PRIORITY_CRITICAL, Lt as $updateDOMSelection, Mt as $setSelection, Nr as getRegisteredSubtypeMap, Nt as $setSelectionFromCaretRange, O as $getCaretRangeInDirection, Ot as $selectAll, Pt as $setState, Qn as OUTDENT_CONTENT_COMMAND, Qt as COMPOSITION_START_TAG, Sr as getActiveElement, Tr as getDOMSelection, U as $getRoot, V as $getNodeFromDOMNode, Vr as isDOMNode, Vt as CLEAR_EDITOR_COMMAND, W as $getSelection, Wt as COMMAND_PRIORITY_BEFORE_CRITICAL, X as $getState, Yn as LineBreakNode, Yt as COMMAND_PRIORITY_LOW, Zt as COMPOSITION_START_COMMAND, _r as createEditor, _t as $isSiblingCaret, a as $caretRangeFromSelection, ai as safeCast, at as $isElementNode, br as defineExtension, bt as $isTextNode, cr as SKIP_SCROLL_INTO_VIEW_TAG, di as toggleTextFormatType, dn as ElementNode, dr as TabNode, dt as $isNodeSelection, f as $createNodeSelection, fr as TextNode, gn as HISTORY_MERGE_TAG, gr as createCommand, h as $createRangeSelection, hr as configExtension, ii as removeClassNamesFromElement, ir as SELECTION_CHANGE_COMMAND, it as $isEditorState, li as shallowMergeConfig, lr as SKIP_SELECTION_FOCUS_TAG, mn as FORMAT_TEXT_COMMAND, mt as $isRootNode, ni as mergeRegister, nt as $isChildCaret, or as SELECT_ALL_COMMAND, p as $createParagraphNode, pr as addClassNamesToElement, pt as $isRangeSelection, q as $getSlotFrame, qr as isHTMLElement, qt as COMMAND_PRIORITY_EDITOR, rr as RootNode, rt as $isDecoratorNode, tr as ParagraphNode, tt as $isBlockElementNode, u as $create, ui as stopLexicalPropagation, un as DecoratorNode, ur as TEXT_TYPE_TO_FORMAT, ut as $isLineBreakNode, vn as INDENT_CONTENT_COMMAND, vr as createState, wt as $normalizeSelection__EXPERIMENTAL, xn as INSERT_TAB_COMMAND, xt as $isTextPointCaret, yr as declarePeerDependency, z as $getNodeByKey } from "./Lexical.node-DnR_u_Ke.mjs";
+import { a as $handleIndentAndOutdent, c as $isBlockFullySelected, f as IS_APPLE, g as selectionAlwaysOnDisplay, r as $getNearestBlockElementAncestorOrThrow, s as $insertNodeToNearestRoot } from "./LexicalUtils.node-Ck74ludK.mjs";
+//#region ../../node_modules/.pnpm/@lexical+extension@0.46.0_typescript@6.0.3/node_modules/@lexical/extension/dist/LexicalExtension.dev.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -446,11 +446,11 @@ function namedSignals(defaults, opts = {}) {
 * An Extension to focus the LexicalEditor when the root element is set
 * (typically only when the editor is first created).
 */
-const AutoFocusExtension = defineExtension({
+const AutoFocusExtension = /* @__PURE__ */ defineExtension({
 	build: (editor, config, state) => {
 		return namedSignals(config);
 	},
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		defaultSelection: "rootEnd",
 		disabled: false
 	}),
@@ -459,7 +459,7 @@ const AutoFocusExtension = defineExtension({
 		const stores = state.getOutput();
 		return j(() => stores.disabled.value ? void 0 : editor.registerRootListener((rootElement) => {
 			editor.focus(() => {
-				const activeElement = document.activeElement;
+				const activeElement = rootElement !== null ? getActiveElement(rootElement) : null;
 				if (rootElement !== null && (activeElement === null || !rootElement.contains(activeElement))) rootElement.focus({ preventScroll: true });
 			}, { defaultSelection: stores.defaultSelection.peek() });
 		}));
@@ -490,11 +490,11 @@ function registerClearEditor(editor, $onClear = $defaultOnClear) {
 /**
 * An extension to provide an implementation of {@link CLEAR_EDITOR_COMMAND}
 */
-const ClearEditorExtension = defineExtension({
+const ClearEditorExtension = /* @__PURE__ */ defineExtension({
 	build(editor, config, state) {
 		return namedSignals(config);
 	},
-	config: safeCast({ $onClear: $defaultOnClear }),
+	config: /* @__PURE__ */ safeCast({ $onClear: $defaultOnClear }),
 	name: "@lexical/extension/ClearEditor",
 	register(editor, config, state) {
 		const { $onClear } = state.getOutput();
@@ -543,14 +543,14 @@ function $defaultShouldInsertAfter(node) {
 function shouldClaimClick(editor, rootElement, event, $shouldInsertAfter) {
 	if (!editor.isEditable()) return false;
 	if (event.target !== rootElement) return false;
-	return editor.getEditorState().read(() => {
+	return editor.read("latest", () => {
 		const lastChild = $getRoot().getLastChild();
 		if (lastChild === null) return false;
 		const lastChildDOM = editor.getElementByKey(lastChild.getKey());
 		if (lastChildDOM === null) return false;
 		if (event.clientY <= lastChildDOM.getBoundingClientRect().bottom) return false;
 		return $shouldInsertAfter(lastChild);
-	}, { editor });
+	});
 }
 /**
 * Click handling for the empty area below the last block of the document.
@@ -568,9 +568,9 @@ function shouldClaimClick(editor, rootElement, event, $shouldInsertAfter) {
 *
 * Closes #8544.
 */
-const ClickAfterLastBlockExtension = defineExtension({
+const ClickAfterLastBlockExtension = /* @__PURE__ */ defineExtension({
 	build: (_editor, config) => namedSignals(config),
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		$shouldInsertAfter: $defaultShouldInsertAfter,
 		disabled: false
 	}),
@@ -644,7 +644,7 @@ function getNodeConfig(config) {
 * LICENSE file in the root directory of this source tree.
 *
 */
-const formatState = createState("format", { parse: (value) => typeof value === "number" ? value : 0 });
+const formatState = /* @__PURE__ */ createState("format", { parse: (value) => typeof value === "number" ? value : 0 });
 var DecoratorTextNode = class extends DecoratorNode {
 	$config() {
 		return this.config("decorator-text", {
@@ -746,7 +746,7 @@ const DEFAULT_TAG_NAME_TO_FORMAT = {
 * An extension for DecoratorTextNode that sets the format for the node and CSS classes for the DOM container.
 * The base class is always set, and the focus class is set when the node is selected.
 */
-const DecoratorTextExtension = defineExtension({
+const DecoratorTextExtension = /* @__PURE__ */ defineExtension({
 	name: "@lexical/extension/DecoratorText",
 	nodes: () => [DecoratorTextNode],
 	register(editor, config, state) {
@@ -799,7 +799,7 @@ function watchedSignal(getSnapshot, register) {
 /**
 * An extension to provide the current EditorState as a signal
 */
-const EditorStateExtension = defineExtension({
+const EditorStateExtension = /* @__PURE__ */ defineExtension({
 	build(editor) {
 		return watchedSignal(() => editor.getEditorState(), (editorStateSignal) => editor.registerUpdateListener((payload) => {
 			editorStateSignal.value = payload.editorState;
@@ -826,9 +826,9 @@ function formatDevErrorMessage(message) {
 */
 let envLexicalVersion;
 try {
-	envLexicalVersion = "0.45.0+dev.esm";
+	envLexicalVersion = "0.46.0+dev.esm";
 } catch (_unused) {}
-const LEXICAL_VERSION = envLexicalVersion ?? "0.45.0+source";
+const LEXICAL_VERSION = envLexicalVersion ?? "\"<unknown>+source\"";
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -852,11 +852,19 @@ const LEXICAL_VERSION = envLexicalVersion ?? "0.45.0+source";
 * expect(a).toEqual({ a: "a", b: "b", nested: { a: 1, b: 2 } });
 * ```
 */
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
 function deepThemeMergeInPlace(a, b) {
 	if (a && b && !Array.isArray(b) && typeof a === "object" && typeof b === "object") {
 		const aObj = a;
 		const bObj = b;
-		for (const k in bObj) aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);
+		for (const k in bObj) {
+			if (UNSAFE_KEYS.has(k) || !Object.prototype.hasOwnProperty.call(bObj, k)) continue;
+			aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);
+		}
 		return a;
 	}
 	return b;
@@ -1091,8 +1099,8 @@ function $defaultInitializer() {
 * but you should not call `editor.setRootElement` earlier than
 * this phase to avoid rendering an empty editor first.
 */
-const InitialStateExtension = defineExtension({
-	config: safeCast({
+const InitialStateExtension = /* @__PURE__ */ defineExtension({
+	config: /* @__PURE__ */ safeCast({
 		setOptions: HISTORY_MERGE_OPTIONS,
 		updateOptions: HISTORY_MERGE_OPTIONS
 	}),
@@ -1220,11 +1228,14 @@ var LexicalBuilder = class LexicalBuilder {
 		return builder;
 	}
 	constructEditor() {
-		const { $initialEditorState: _$initialEditorState, onError, ...editorConfig } = this.buildCreateEditorArgs();
+		const { $initialEditorState: _$initialEditorState, onError, onWarn, ...editorConfig } = this.buildCreateEditorArgs();
 		const editor = Object.assign(createEditor({
 			...editorConfig,
 			...onError ? { onError: (err) => {
 				onError(err, editor);
+			} } : {},
+			...onWarn ? { onWarn: (err) => {
+				onWarn(err, editor);
 			} } : {}
 		}), { [builderSymbol]: this });
 		for (const extensionRep of this.sortedExtensionReps()) extensionRep.build(editor);
@@ -1345,6 +1356,7 @@ var LexicalBuilder = class LexicalBuilder {
 		for (const extensionRep of extensionReps) {
 			const { extension } = extensionRep;
 			if (extension.onError !== void 0) config.onError = extension.onError;
+			if (extension.onWarn !== void 0) config.onWarn = extension.onWarn;
 			if (extension.disableEvents !== void 0) config.disableEvents = extension.disableEvents;
 			if (extension.parentEditor !== void 0) config.parentEditor = extension.parentEditor;
 			if (extension.editable !== void 0) config.editable = extension.editable;
@@ -1580,7 +1592,7 @@ const EMPTY_SET = /* @__PURE__ */ new Set();
 * currently selected or not. A framework independent
 * alternative to {@link useLexicalNodeSelection}.
 */
-const NodeSelectionExtension = defineExtension({
+const NodeSelectionExtension = /* @__PURE__ */ defineExtension({
 	build(editor, config, state) {
 		const editorStateStore = state.getDependency(EditorStateExtension).output;
 		const watchedNodeStore = a({ watchedNodeKeys: /* @__PURE__ */ new Map() });
@@ -1631,7 +1643,16 @@ const NodeSelectionExtension = defineExtension({
 * LICENSE file in the root directory of this source tree.
 *
 */
-const INSERT_HORIZONTAL_RULE_COMMAND = createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
+/**
+* The serialized form of a {@link HorizontalRuleNode}. It has no extra fields
+* beyond the base serialized node.
+*/
+/**
+* Command that inserts a {@link HorizontalRuleNode} at the current selection.
+* Dispatch it with
+* `editor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, undefined)`.
+*/
+const INSERT_HORIZONTAL_RULE_COMMAND = /* @__PURE__ */ createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
 var HorizontalRuleNode = class HorizontalRuleNode extends DecoratorNode {
 	static getType() {
 		return "horizontalrule";
@@ -1672,6 +1693,9 @@ function $convertHorizontalRuleElement() {
 function $createHorizontalRuleNode() {
 	return $create(HorizontalRuleNode);
 }
+/**
+* @returns `true` if `node` is a {@link HorizontalRuleNode}, narrowing its type.
+*/
 function $isHorizontalRuleNode(node) {
 	return node instanceof HorizontalRuleNode;
 }
@@ -1692,7 +1716,7 @@ function $toggleNodeSelection(node, shiftKey = false) {
 * An extension for HorizontalRuleNode that provides an implementation that
 * works without any React dependency.
 */
-const HorizontalRuleExtension = defineExtension({
+const HorizontalRuleExtension = /* @__PURE__ */ defineExtension({
 	dependencies: [EditorStateExtension, NodeSelectionExtension],
 	name: "@lexical/extension/HorizontalRule",
 	nodes: () => [HorizontalRuleNode],
@@ -1753,14 +1777,93 @@ const HorizontalRuleExtension = defineExtension({
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* Centralizes IME composition state so extensions that react to
+* composition lifecycle don't each re-implement the
+* COMPOSITION_START_COMMAND + compositionend listener dance.
+*
+* Exposes two signals (both always-active for the editor's lifetime —
+* listeners are wired up by `register`, not lazily on subscription, so
+* consumers can read `.value` from anywhere without holding a
+* subscription themselves):
+*
+* - `compositionKey` is the raw mirror — the value Lexical's own
+*   `$handleCompositionStart` writes to its internal `_compositionKey`,
+*   i.e. the `selection.anchor.key` at the moment composition starts.
+*   This can be a non-TextNode key when composition begins on an
+*   element-anchor selection (e.g. empty paragraph). Cleared on
+*   `compositionend`.
+*
+* - `composingTextNode` is the resolved view — the actual TextNode
+*   being composed on, or `null` while there is no TextNode-level
+*   composition. For an element-anchor start it stays `null` until
+*   the `COMPOSITION_START_TAG`-tagged update fires with the
+*   post-ZWSP-heuristic selection, at which point it updates to the
+*   new TextNode.
+*
+*/
+const IMEExtension = /* @__PURE__ */ defineExtension({
+	build(_editor) {
+		return {
+			composingTextNode: a(null),
+			compositionKey: a(null)
+		};
+	},
+	name: "@lexical/extension/IME",
+	register(editor, _config, state) {
+		const { compositionKey, composingTextNode } = state.getOutput();
+		return mergeRegister(editor.registerCommand(COMPOSITION_START_COMMAND, () => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection)) compositionKey.value = selection.anchor.key;
+			return false;
+		}, COMMAND_PRIORITY_BEFORE_EDITOR), j(() => {
+			const key = compositionKey.value;
+			if (key === null) {
+				composingTextNode.value = null;
+				return;
+			}
+			composingTextNode.value = editor.read("latest", () => {
+				const node = $getNodeByKey(key);
+				return $isTextNode(node) ? node : null;
+			});
+		}), editor.registerUpdateListener(({ tags, editorState }) => {
+			if (!tags.has(COMPOSITION_START_TAG)) return;
+			editorState.read(() => {
+				const selection = $getSelection();
+				if (!$isRangeSelection(selection)) return;
+				const node = selection.anchor.getNode();
+				if ($isTextNode(node)) composingTextNode.value = node;
+			});
+		}), editor.registerRootListener((rootElem) => {
+			if (rootElem === null) {
+				compositionKey.value = null;
+				return;
+			}
+			const onCompositionEnd = () => {
+				compositionKey.value = null;
+			};
+			rootElem.addEventListener("compositionend", onCompositionEnd);
+			return () => {
+				rootElem.removeEventListener("compositionend", onCompositionEnd);
+			};
+		}));
+	}
+});
+/**
+* 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 $defaultGetParentEditor() {
 	const editor = $getEditor();
 	LexicalBuilder.fromEditor(editor);
 	return editor;
 }
-const NestedEditorExtension = defineExtension({
+const NestedEditorExtension = /* @__PURE__ */ defineExtension({
 	build: (editor, config) => namedSignals({ inheritEditableFromParent: config.inheritEditableFromParent }),
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		$getParentEditor: $defaultGetParentEditor,
 		inheritEditableFromParent: false
 	}),
@@ -1781,6 +1884,77 @@ const NestedEditorExtension = defineExtension({
 	})
 });
 /**
+* @experimental
+*
+* Mirrors {@link NodeSelection} membership onto the host DOM as an attribute
+* so CSS can render a selection outline for `ElementNode` hosts, which have
+* no `decorate()` render path of their own. Configure it per node type:
+*
+* ```ts
+* configExtension(NodeSelectionDataSelectedExtension, {nodes: [CardNode]})
+* ```
+*
+* The matched host needs a corresponding CSS rule, e.g.
+* `.lexical-card-node[data-selected='true'] { outline: ... }`.
+*/
+const NodeSelectionDataSelectedExtension = /* @__PURE__ */ defineExtension({
+	config: /* @__PURE__ */ safeCast({
+		attribute: "data-selected",
+		nodes: []
+	}),
+	init(editorConfig, config) {
+		const matchTypes = /* @__PURE__ */ new Set();
+		const subtypeMap = getRegisteredSubtypeMap(getKnownTypesAndNodes(editorConfig).nodes);
+		for (const klass of config.nodes) {
+			const type = klass.getType();
+			const subtypes = subtypeMap.get(type);
+			if (!(subtypes !== void 0)) formatDevErrorMessage(`Node class ${klass.name} with type ${type} not registered in editor`);
+			matchTypes.add(type);
+			for (const subtype of subtypes) matchTypes.add(subtype);
+		}
+		return { matchTypes };
+	},
+	mergeConfig(config, partial) {
+		return shallowMergeConfig(config, {
+			...partial,
+			...partial.nodes && { nodes: [...config.nodes, ...partial.nodes] }
+		});
+	},
+	name: "@lexical/extension/NodeSelectionDataSelected",
+	register(editor, config, state) {
+		const { attribute } = config;
+		const { matchTypes } = state.getInitResult();
+		const marked = /* @__PURE__ */ new Map();
+		const syncFromEditorState = (editorState) => {
+			const nextKeys = /* @__PURE__ */ new Set();
+			editorState.read(() => {
+				const selection = $getSelection();
+				if ($isNodeSelection(selection)) {
+					for (const node of selection.getNodes()) if (matchTypes.has(node.getType())) nextKeys.add(node.getKey());
+				}
+			});
+			for (const [key, dom] of marked) if (!nextKeys.has(key)) {
+				dom.removeAttribute(attribute);
+				marked.delete(key);
+			}
+			for (const key of nextKeys) {
+				const dom = editor.getElementByKey(key);
+				if (dom !== null) {
+					dom.setAttribute(attribute, "true");
+					marked.set(key, dom);
+				}
+			}
+		};
+		syncFromEditorState(editor.getEditorState());
+		const removeUpdateListener = editor.registerUpdateListener(({ editorState }) => syncFromEditorState(editorState));
+		return () => {
+			removeUpdateListener();
+			for (const dom of marked.values()) dom.removeAttribute(attribute);
+			marked.clear();
+		};
+	}
+});
+/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
@@ -1799,9 +1973,9 @@ function deleteEmptyInline(node) {
 * the plugin API with the option to disable it, but it may be removed
 * in the future and integrated into the core
 */
-const NormalizeInlineElementsExtension = defineExtension({
+const NormalizeInlineElementsExtension = /* @__PURE__ */ defineExtension({
 	build: (editor, config, state) => namedSignals(config),
-	config: safeCast({ disabled: false }),
+	config: /* @__PURE__ */ safeCast({ disabled: false }),
 	name: "@lexical/NormalizeInlineElements",
 	register: (editor, config, state) => {
 		const stores = state.getOutput();
@@ -1860,9 +2034,9 @@ function $fixFocusOverselection() {
 * be called from other places and it can be replaced or wrapped with
 * different functionality.
 */
-const NormalizeTripleClickSelectionExtension = defineExtension({
+const NormalizeTripleClickSelectionExtension = /* @__PURE__ */ defineExtension({
 	build: (editor, config, state) => namedSignals(config),
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		$fixFocusOverselection,
 		dateNow: Date.now,
 		disabled: false,
@@ -1903,13 +2077,123 @@ const NormalizeTripleClickSelectionExtension = defineExtension({
 * LICENSE file in the root directory of this source tree.
 *
 */
+function captureKeydown(e) {
+	const target = e.target;
+	if (isExactShortcutMatch(e, "a", {
+		ctrlKey: !IS_APPLE,
+		metaKey: IS_APPLE
+	}) && isHTMLElement(target) && (target.tagName === "INPUT" || target.tagName === "TEXTAREA")) target.addEventListener("keydown", stopLexicalPropagation, { once: true });
+}
+/**
+* By default, lexical intercepts most events and dispatches the appropriate commands.
+* This extension prevents the keydown event propagating from input/textarea elements,
+* which are typically part of a decorator node, in order to stop dispatching the SELECT_ALL_COMMAND.
+*
+* When used as a dependency of SelectBlockExtension, its disabled state is
+* kept in sync with that extension.
+*/
+const PreventSelectAllExtension = /* @__PURE__ */ defineExtension({
+	build: (editor, config, state) => namedSignals(config),
+	config: /* @__PURE__ */ safeCast({ disabled: false }),
+	name: "@lexical/extension/PreventSelectAll",
+	register: (editor, config, state) => {
+		const stores = state.getOutput();
+		return j(() => {
+			if (!stores.disabled.value) return editor.registerRootListener((rootElement) => {
+				if (rootElement) {
+					rootElement.addEventListener("keydown", captureKeydown, true);
+					return () => rootElement.removeEventListener("keydown", captureKeydown, true);
+				}
+			});
+		});
+	}
+});
+/**
+* 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 $hasCommonTopParent(nodes, commonTopParent) {
+	return nodes.every((node) => commonTopParent.is(node.getTopLevelElement()));
+}
+/**
+* This extension includes block selection.
+* If you press Ctrl + A, the nearest block element, for example paragraph, is selected first.
+* Pressing Ctrl + A again selects all content in the document. A selection
+* that already spans multiple blocks expands directly to the whole document.
+*/
+const SelectBlockExtension = /* @__PURE__ */ defineExtension({
+	build: (editor, config, state) => namedSignals(config),
+	config: /* @__PURE__ */ safeCast({
+		cascadeSelection: false,
+		disabled: false
+	}),
+	dependencies: [PreventSelectAllExtension],
+	name: "@lexical/extension/SelectBlock",
+	register: (editor, config, state) => {
+		const stores = state.getOutput();
+		const preventSelectAllStores = state.getDependency(PreventSelectAllExtension).output;
+		return mergeRegister(j(() => {
+			preventSelectAllStores.disabled.value = stores.disabled.value;
+		}), j(() => {
+			if (!stores.disabled.value) return editor.registerCommand(SELECT_ALL_COMMAND, (event, triggerEditor) => {
+				if (triggerEditor !== editor) {
+					if (!stores.cascadeSelection.peek()) return false;
+					if (!triggerEditor.read("pending", () => {
+						const nestedSelection = $getSelection();
+						return $isRangeSelection(nestedSelection) && $isBlockFullySelected($getRoot(), nestedSelection);
+					})) return false;
+					$selectAll();
+					return true;
+				}
+				const selection = $getSelection();
+				if ($isNodeSelection(selection)) {
+					const selectedNodes = selection.getNodes();
+					const firstNode = selectedNodes[0];
+					if (!firstNode) return false;
+					const topParent = firstNode.getTopLevelElement();
+					if (!topParent || $isRootNode(topParent) || topParent.is(firstNode) || selectedNodes.length > 1 && !$hasCommonTopParent(selectedNodes, topParent)) $selectAll();
+					else if ($isElementNode(topParent)) topParent.select(0, topParent.getChildrenSize());
+					return true;
+				}
+				if (!$isRangeSelection(selection)) return false;
+				const anchorNode = selection.anchor.getNode();
+				const blockNode = anchorNode.getTopLevelElement();
+				if (blockNode && blockNode.is(selection.focus.getNode().getTopLevelElement()) && !$isBlockFullySelected(blockNode, selection)) {
+					blockNode.select(0, blockNode.getChildrenSize());
+					return true;
+				}
+				let frame = $getSlotFrame(anchorNode);
+				while (frame !== null) {
+					if ($isElementNode(frame) && !$isBlockFullySelected(frame, selection)) {
+						frame.select(0, frame.getChildrenSize());
+						return true;
+					}
+					const host = $getSlotHost(frame);
+					frame = host === null ? null : $getSlotFrame(host);
+				}
+				if (!$isBlockFullySelected($getRoot(), selection)) $selectAll();
+				return true;
+			}, COMMAND_PRIORITY_LOW);
+		}));
+	}
+});
+/**
+* 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.
+*
+*/
 /**
 * An extension that highlights selected content in the Lexical editor
 * even when the editor is not currently focused.
 */
-const SelectionAlwaysOnDisplayExtension = defineExtension({
+const SelectionAlwaysOnDisplayExtension = /* @__PURE__ */ defineExtension({
 	build: (editor, config, state) => namedSignals(config),
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		disabled: false,
 		onReposition: void 0
 	}),
@@ -1947,6 +2231,13 @@ function $indentOverTab(selection) {
 function $defaultCanIndent(node) {
 	return node.canIndent();
 }
+/**
+* Registers a `KEY_TAB_COMMAND` handler that makes Tab and Shift+Tab indent and
+* outdent block elements (and otherwise insert a tab). Pass `maxIndent` to cap
+* the indent depth and `$canIndent` to control which elements may be indented.
+*
+* @returns A cleanup function that unregisters the handler.
+*/
 function registerTabIndentation(editor, maxIndent, $canIndent = $defaultCanIndent) {
 	return mergeRegister(editor.registerCommand(KEY_TAB_COMMAND, (event) => {
 		const selection = $getSelection();
@@ -1971,11 +2262,11 @@ function registerTabIndentation(editor, maxIndent, $canIndent = $defaultCanInden
 * recommend using this plugin as it could negatively affect accessibility for keyboard
 * users, causing focus to become trapped within the editor.
 */
-const TabIndentationExtension = defineExtension({
+const TabIndentationExtension = /* @__PURE__ */ defineExtension({
 	build(editor, config, state) {
 		return namedSignals(config);
 	},
-	config: safeCast({
+	config: /* @__PURE__ */ safeCast({
 		$canIndent: $defaultCanIndent,
 		disabled: false,
 		maxIndent: null
@@ -1988,5 +2279,28 @@ const TabIndentationExtension = defineExtension({
 		});
 	}
 });
+/**
+* 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.
+*
+*/
+/**
+* Exposes the editor's editable state as a reactive `Signal<boolean>` that
+* mirrors `editor.isEditable()` via an editable listener.
+*
+* Depend on this extension and read its output `Signal` from a signals
+* `effect`/`computed` to react to editability changes without subscribing
+* through React (or any other framework).
+*/
+const WatchEditableExtension = /* @__PURE__ */ defineExtension({
+	build(editor) {
+		return watchedSignal(() => editor.isEditable(), (signal) => editor.registerEditableListener((editable) => {
+			signal.value = editable;
+		}));
+	},
+	name: "@lexical/extension/WatchEditable"
+});
 //#endregion
-export { $createHorizontalRuleNode, $defaultShouldInsertAfter, $getExtensionDependency, $getExtensionOutput, $getPeerDependency, $isDecoratorTextNode, $isHorizontalRuleNode, AutoFocusExtension, ClearEditorExtension, ClickAfterLastBlockExtension, DecoratorTextExtension, DecoratorTextNode, EditorStateExtension, HorizontalRuleExtension, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND, InitialStateExtension, LexicalBuilder, NestedEditorExtension, NodeSelectionExtension, NormalizeInlineElementsExtension, NormalizeTripleClickSelectionExtension, SelectionAlwaysOnDisplayExtension, TabIndentationExtension, applyFormatFromStyle, applyFormatToDom, n as batch, buildEditorFromExtensions, g as computed, configExtension, declarePeerDependency, defineExtension, j as effect, getExtensionDependencyFromEditor, getKnownTypesAndNodes, getPeerDependencyFromEditor, getPeerDependencyFromEditorOrThrow, namedSignals, registerClearEditor, registerTabIndentation, safeCast, shallowMergeConfig, a as signal, h as untracked, watchedSignal };
+export { $createHorizontalRuleNode, $defaultShouldInsertAfter, $getExtensionDependency, $getExtensionOutput, $getPeerDependency, $isDecoratorTextNode, $isHorizontalRuleNode, AutoFocusExtension, ClearEditorExtension, ClickAfterLastBlockExtension, DecoratorTextExtension, DecoratorTextNode, EditorStateExtension, HorizontalRuleExtension, HorizontalRuleNode, IMEExtension, INSERT_HORIZONTAL_RULE_COMMAND, InitialStateExtension, LexicalBuilder, NestedEditorExtension, NodeSelectionDataSelectedExtension, NodeSelectionExtension, NormalizeInlineElementsExtension, NormalizeTripleClickSelectionExtension, PreventSelectAllExtension, SelectBlockExtension, SelectionAlwaysOnDisplayExtension, TabIndentationExtension, WatchEditableExtension, applyFormatFromStyle, applyFormatToDom, n as batch, buildEditorFromExtensions, g as computed, configExtension, declarePeerDependency, defineExtension, j as effect, getExtensionDependencyFromEditor, getKnownTypesAndNodes, getPeerDependencyFromEditor, getPeerDependencyFromEditorOrThrow, namedSignals, registerClearEditor, registerTabIndentation, safeCast, shallowMergeConfig, a as signal, h as untracked, watchedSignal };

package/dist/{LexicalExtension.node-BVlcrgOx.mjs → LexicalExtension.node-CMsupJZs.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@lexical+extension@0.45.0/node_modules/@lexical/extension/dist/LexicalExtension.node.mjs
+//#region ../../node_modules/.pnpm/@lexical+extension@0.46.0_typescript@6.0.3/node_modules/@lexical/extension/dist/LexicalExtension.node.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -6,7 +6,7 @@
 * LICENSE file in the root directory of this source tree.
 *
 */
-const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalExtension.dev-BPNyvGqe.mjs") : import("./LexicalExtension.prod-DFKbiNt-.mjs"));
+const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalExtension.dev-CXtOJb83.mjs") : import("./LexicalExtension.prod-BCLGhzcg.mjs"));
 const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
 mod.$defaultShouldInsertAfter;
 mod.$getExtensionDependency;
@@ -22,15 +22,20 @@ mod.DecoratorTextNode;
 mod.EditorStateExtension;
 const HorizontalRuleExtension = mod.HorizontalRuleExtension;
 const HorizontalRuleNode = mod.HorizontalRuleNode;
+mod.IMEExtension;
 mod.INSERT_HORIZONTAL_RULE_COMMAND;
 mod.InitialStateExtension;
 mod.LexicalBuilder;
 mod.NestedEditorExtension;
+mod.NodeSelectionDataSelectedExtension;
 mod.NodeSelectionExtension;
 const NormalizeInlineElementsExtension = mod.NormalizeInlineElementsExtension;
 const NormalizeTripleClickSelectionExtension = mod.NormalizeTripleClickSelectionExtension;
+mod.PreventSelectAllExtension;
+mod.SelectBlockExtension;
 mod.SelectionAlwaysOnDisplayExtension;
 mod.TabIndentationExtension;
+mod.WatchEditableExtension;
 mod.applyFormatFromStyle;
 mod.applyFormatToDom;
 mod.batch;
@@ -51,6 +56,6 @@ mod.safeCast;
 mod.shallowMergeConfig;
 const signal = mod.signal;
 mod.untracked;
-mod.watchedSignal;
+const watchedSignal = mod.watchedSignal;
 //#endregion
-export { HorizontalRuleNode as a, configExtension as c, getPeerDependencyFromEditor as d, namedSignals as f, HorizontalRuleExtension as i, effect as l, $getExtensionOutput as n, NormalizeInlineElementsExtension as o, signal as p, $getPeerDependency as r, NormalizeTripleClickSelectionExtension as s, $createHorizontalRuleNode as t, getKnownTypesAndNodes as u };
+export { HorizontalRuleNode as a, configExtension as c, getPeerDependencyFromEditor as d, namedSignals as f, HorizontalRuleExtension as i, effect as l, watchedSignal as m, $getExtensionOutput as n, NormalizeInlineElementsExtension as o, signal as p, $getPeerDependency as r, NormalizeTripleClickSelectionExtension as s, $createHorizontalRuleNode as t, getKnownTypesAndNodes as u };