@mx-space/cli 0.7.7 → 0.8.0

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

@@ -1,6 +1,6 @@
-import { $n as safeCast, An as createState, At as COMMAND_PRIORITY_LOW, Cn as TabNode, Dn as configExtension, Dt as COMMAND_PRIORITY_CRITICAL, G as $isBlockElementNode, Gt as FORMAT_TEXT_COMMAND, Hn as isDOMNode, I as $getNodeFromDOMNode, In as getStaticNodeConfig, J as $isEditorState, Mn as defineExtension, On as createCommand, Ot as COMMAND_PRIORITY_EDITOR, P as $getNodeByKey, Qn as removeClassNamesFromElement, Qt as INSERT_TAB_COMMAND, R as $getRoot, Sn as TEXT_TYPE_TO_FORMAT, Tn as addClassNamesToElement, Tt as CLICK_COMMAND, V as $getState, Vt as DecoratorNode, Xn as mergeRegister, Yt as INDENT_CONTENT_COMMAND, bt as $setState, d as $createNodeSelection, dn as OUTDENT_CONTENT_COMMAND, f as $createParagraphNode, ft as $normalizeSelection__EXPERIMENTAL, gn as RootNode, ir as toggleTextFormatType, j as $getEditor, jn as declarePeerDependency, kn as createEditor, l as $create, ln as KEY_TAB_COMMAND, m as $createRangeSelection, mn as ParagraphNode, qt as HISTORY_MERGE_TAG, rr as shallowMergeConfig, rt as $isRangeSelection, tt as $isNodeSelection, un as LineBreakNode, vt as $setSelection, wn as TextNode, wt as CLEAR_EDITOR_COMMAND, z as $getSelection } from "./Lexical.node-BUsI9gWr.mjs";
-import { c as $insertNodeToNearestRoot, i as $getNearestBlockElementAncestorOrThrow, o as $handleIndentAndOutdent, v as selectionAlwaysOnDisplay } from "./LexicalUtils.node-lCWjRjoG.mjs";
-//#region ../../node_modules/.pnpm/@lexical+extension@0.44.0/node_modules/@lexical/extension/LexicalExtension.dev.mjs
+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
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -509,6 +509,110 @@ const ClearEditorExtension = defineExtension({
 *
 */
 /**
+* @experimental
+*
+* Default predicate matches {@link DecoratorNode} and shadow-root
+* `ElementNode`s (e.g. `TableNode`). Apps that want to also trigger on
+* other node types — `CodeNode`, custom non-editable blocks — should
+* compose this default in their own predicate rather than re-deriving
+* the check:
+*
+* ```ts
+* configExtension(ClickAfterLastBlockExtension, {
+*   $shouldInsertAfter: (node) =>
+*     $defaultShouldInsertAfter(node) || $isCodeNode(node),
+* });
+* ```
+*/
+function $defaultShouldInsertAfter(node) {
+	if ($isDecoratorNode(node)) return true;
+	if ($isElementNode(node) && node.isShadowRoot()) return true;
+	return false;
+}
+/**
+* Decide whether a click at `event` should be claimed by this extension.
+* Used by both the mousedown listener (to call preventDefault on the
+* browser's native caret pick) and the click listener (to actually
+* insert the paragraph). Factored out so the two handlers stay in sync
+* — they would otherwise share ~22 lines of byte-for-byte identical
+* logic and have to be maintained together.
+*
+* Read-only because it is called outside an editor.update; mutation
+* happens in the click handler's editor.update below.
+*/
+function shouldClaimClick(editor, rootElement, event, $shouldInsertAfter) {
+	if (!editor.isEditable()) return false;
+	if (event.target !== rootElement) return false;
+	return editor.getEditorState().read(() => {
+		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.
+*
+* Without this extension, clicking the area below the last block when that
+* block is a {@link DecoratorNode}, a shadow-root ElementNode (e.g.
+* `TableNode`), or any other block that doesn't accept the click naturally
+* leaves the selection in an awkward place — `null` for a bare decorator,
+* or at the end of a table cell. Users typically expect a new paragraph
+* to appear below the block with the caret in it, matching the behavior
+* of editors like Notion.
+*
+* This extension intercepts clicks under those conditions, inserts a new
+* empty paragraph after the last block, and selects it.
+*
+* Closes #8544.
+*/
+const ClickAfterLastBlockExtension = defineExtension({
+	build: (_editor, config) => namedSignals(config),
+	config: safeCast({
+		$shouldInsertAfter: $defaultShouldInsertAfter,
+		disabled: false
+	}),
+	name: "@lexical/ClickAfterLastBlock",
+	register: (editor, _config, _state) => j(() => {
+		const output = _state.getOutput();
+		if (output.disabled.value) return;
+		return editor.registerRootListener((rootElement) => {
+			if (rootElement === null) return;
+			const onMouseDown = (event) => {
+				if (shouldClaimClick(editor, rootElement, event, output.$shouldInsertAfter.peek())) event.preventDefault();
+			};
+			const onClick = (event) => {
+				if (!shouldClaimClick(editor, rootElement, event, output.$shouldInsertAfter.peek())) return;
+				event.preventDefault();
+				stopLexicalPropagation(event);
+				editor.update(() => {
+					const lastChild = $getRoot().getLastChild();
+					if (lastChild === null) return;
+					if (!output.$shouldInsertAfter.peek()(lastChild)) return;
+					const paragraph = $createParagraphNode();
+					lastChild.insertAfter(paragraph);
+					paragraph.select();
+				});
+			};
+			rootElement.addEventListener("mousedown", onMouseDown, true);
+			rootElement.addEventListener("click", onClick, true);
+			return () => {
+				rootElement.removeEventListener("mousedown", onMouseDown, true);
+				rootElement.removeEventListener("click", onClick, 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.
+*
+*/
+/**
 * Get the sets of nodes and types registered in the
 * {@link InitialEditorConfig}. This is to be used when an extension
 * needs to register optional behavior if some node or type is present.
@@ -720,6 +824,18 @@ function formatDevErrorMessage(message) {
 * 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
+* LICENSE file in the root directory of this source tree.
+*
+*/
 /**
 * Recursively merge the given theme configuration in-place.
 *
@@ -1065,7 +1181,7 @@ function maybeWithBuilder(editor) {
 function normalizeExtensionArgument(arg) {
 	return Array.isArray(arg) ? arg : [arg];
 }
-const PACKAGE_VERSION = "0.44.0+dev.esm";
+const PACKAGE_VERSION = LEXICAL_VERSION;
 /** @internal */
 var LexicalBuilder = class LexicalBuilder {
 	roots;
@@ -1271,6 +1387,10 @@ var LexicalBuilder = class LexicalBuilder {
 *
 * It will throw if the Editor was not built using this Extension.
 *
+* Inside an editor read/update, prefer {@link $getExtensionDependency} or
+* {@link $getExtensionOutput} — they resolve the editor via `$getEditor()`
+* so you don't have to thread it through.
+*
 * @param editor - The editor that was built using extension
 * @param extension - The concrete reference to an Extension used to build this editor
 * @returns The config and output for that Extension
@@ -1292,6 +1412,10 @@ function getExtensionDependencyFromEditor(editor, extension) {
 *
 * Both the explicit Extension type and the name are required.
 *
+* Inside an editor read/update, prefer {@link $getPeerDependency} — it
+* resolves the editor via `$getEditor()` so you don't have to thread it
+* through.
+*
 *  @example
 * ```tsx
 * import type { HistoryExtension } from "@lexical/history";
@@ -1320,6 +1444,10 @@ function getPeerDependencyFromEditor(editor, extensionName) {
 *
 * Both the explicit Extension type and the name are required.
 *
+* Inside an editor read/update, prefer {@link $getPeerDependency} (which
+* resolves the editor via `$getEditor()`) and add your own invariant if
+* the peer is required.
+*
 *  @example
 * ```tsx
 * import type { EmojiExtension } from "./EmojiExtension";
@@ -1358,6 +1486,91 @@ function getPeerDependencyFromEditorOrThrow(editor, extensionName) {
 * LICENSE file in the root directory of this source tree.
 *
 */
+/**
+* Get the finalized config and output for `extension` from the editor
+* currently in scope. A `$`-flavored shorthand for
+* `getExtensionDependencyFromEditor($getEditor(), extension)`.
+*
+* Throws if the editor was not built with `extension` as a dependency.
+*
+* @example
+* ```ts
+* import {$getExtensionDependency} from '@lexical/extension';
+* import {KeywordsExtension} from './KeywordsExtension';
+*
+* class KeywordNode extends TextNode {
+*   createDOM(config: EditorConfig): HTMLElement {
+*     const dom = super.createDOM(config);
+*     dom.className =
+*       $getExtensionDependency(KeywordsExtension).config.className;
+*     return dom;
+*   }
+* }
+* ```
+*
+* @see {@link getExtensionDependencyFromEditor} when you have an explicit
+*   editor reference (e.g. outside a read/update).
+*/
+function $getExtensionDependency(extension) {
+	return getExtensionDependencyFromEditor($getEditor(), extension);
+}
+/**
+* Shorthand for `$getExtensionDependency(extension).output` — the most
+* common reason to look up an extension dependency. Throws if the editor
+* was not built with `extension` as a dependency.
+*
+* @example
+* ```ts
+* import {$getExtensionOutput} from '@lexical/extension';
+* import {DOMImportExtension} from '@lexical/html';
+*
+* const nodes = $getExtensionOutput(DOMImportExtension).$generateNodesFromDOM(
+*   dom,
+* );
+* ```
+*
+* @see {@link $getExtensionDependency} when you need both `.config` and
+*   `.output` (or want to mirror the shape of
+*   {@link getExtensionDependencyFromEditor}).
+*/
+function $getExtensionOutput(extension) {
+	return $getExtensionDependency(extension).output;
+}
+/**
+* Get the finalized config and output for an optional peer extension by
+* name, from the editor currently in scope. A `$`-flavored shorthand for
+* `getPeerDependencyFromEditor($getEditor(), extensionName)`.
+*
+* Returns `undefined` if the editor was not built with the named
+* extension. Both the explicit `Extension` type and the name are
+* required so the returned `config` / `output` types are correct.
+*
+* @example
+* ```ts
+* import {$getPeerDependency} from '@lexical/extension';
+* import type {HistoryExtension} from '@lexical/history';
+*
+* const dep = $getPeerDependency<typeof HistoryExtension>(
+*   '@lexical/history/History',
+* );
+* if (dep) {
+*   // …read dep.config / dep.output…
+* }
+* ```
+*
+* @see {@link getPeerDependencyFromEditor} when you have an explicit
+*   editor reference.
+*/
+function $getPeerDependency(extensionName) {
+	return getPeerDependencyFromEditor($getEditor(), extensionName);
+}
+/**
+* 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 EMPTY_SET = /* @__PURE__ */ new Set();
 /**
 * An extension that provides a `watchNodeKey` output that
@@ -1574,6 +1787,122 @@ const NestedEditorExtension = defineExtension({
 * LICENSE file in the root directory of this source tree.
 *
 */
+function deleteEmptyInline(node) {
+	if ($isElementNode(node) && node.isInline() && node.isEmpty()) {
+		node.remove();
+		if (node.canBeEmpty()) console.warn(`Empty inline elements are removed from the EditorState, so returning 'true' from ${node.constructor.name}.canBeEmpty() is not allowed`);
+	}
+}
+/**
+* This extension removes empty inline nodes from the EditorState.
+* This extension is designed to facilitate a smooth migration from
+* 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({
+	build: (editor, config, state) => namedSignals(config),
+	config: safeCast({ disabled: false }),
+	name: "@lexical/NormalizeInlineElements",
+	register: (editor, config, state) => {
+		const stores = state.getOutput();
+		return j(() => {
+			if (!stores.disabled.value) {
+				const disposeTransformers = [];
+				for (const { klass, transforms } of editor._nodes.values()) if (klass.prototype instanceof ElementNode && klass.prototype.isInline !== ElementNode.prototype.isInline) {
+					transforms.add(deleteEmptyInline);
+					disposeTransformers.push(() => transforms.delete(deleteEmptyInline));
+				}
+				return () => disposeTransformers.forEach((fn) => fn());
+			}
+		});
+	}
+});
+/**
+* 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 SKIP_TAGS = new Set([SKIP_SELECTION_FOCUS_TAG, SKIP_SCROLL_INTO_VIEW_TAG]);
+function $fixFocusOverselection() {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection)) return;
+	if (!selection.isCollapsed()) {
+		const range = $getCaretRangeInDirection($caretRangeFromSelection(selection), "next");
+		let focusCaret = range.focus;
+		if ($isTextPointCaret(focusCaret) && range.anchor.origin !== focusCaret.origin && focusCaret.offset === 0) focusCaret = $rewindSiblingCaret(focusCaret.getSiblingCaret());
+		if ($isSiblingCaret(focusCaret) && range.anchor.origin !== focusCaret.origin && $isLineBreakNode(focusCaret.origin)) focusCaret = $rewindSiblingCaret(focusCaret);
+		while ($isChildCaret(focusCaret) && range.anchor.origin !== focusCaret.origin) focusCaret = $rewindSiblingCaret($getSiblingCaret(focusCaret.origin, "next"));
+		if ($isSiblingCaret(focusCaret) && $isElementNode(focusCaret.origin)) focusCaret = $normalizeCaret($getChildCaret(focusCaret.origin, "previous")).getFlipped();
+		focusCaret = $normalizeCaret(focusCaret);
+		if (!focusCaret.isSamePointCaret(range.focus)) {
+			const sel = $setSelectionFromCaretRange($getCaretRange(range.anchor, focusCaret));
+			const rootElement = $getEditor().getRootElement();
+			const domSelection = rootElement && getDOMSelection(rootElement.ownerDocument.defaultView);
+			if (domSelection) $updateDOMSelection($getPreviousSelection(), sel, $getEditor(), domSelection, SKIP_TAGS, rootElement);
+		}
+	}
+}
+/**
+* This extension handles triple-click events and will move the focus
+* towards the anchor in certain conditions to meet expectations.
+* Simply speaking, the focus should prefer to land at the end of a node
+* rather than the beginning of its next sibling, and it should not skip
+* over a LineBreakNode.
+*
+* In order to fix the result visually and avoid a flash of over-selection
+* it will also eagerly manipulate the DOM selection directly.
+*
+* It is conservative in that it only fires this
+* `$fixFocusOverselection` callback when it has detected a triple click,
+* but it provides the function as an output signal so that it can both
+* be called from other places and it can be replaced or wrapped with
+* different functionality.
+*/
+const NormalizeTripleClickSelectionExtension = defineExtension({
+	build: (editor, config, state) => namedSignals(config),
+	config: safeCast({
+		$fixFocusOverselection,
+		dateNow: Date.now,
+		disabled: false,
+		thresholdMsec: 100
+	}),
+	name: "@lexical/NormalizeTripleClickSelection",
+	register: (editor, config, state) => j(() => {
+		const stores = state.getOutput();
+		if (stores.disabled.value) return;
+		return editor.registerRootListener((rootElement) => {
+			if (!rootElement) return;
+			let lastTripleClick = 0;
+			const refreshTripleClick = (event) => {
+				if (event ? event.detail === 3 : lastTripleClick > 0) {
+					const now = stores.dateNow.peek()();
+					lastTripleClick = event && event.type === "mousedown" || now - lastTripleClick <= stores.thresholdMsec.peek() ? now : 0;
+				}
+				return lastTripleClick;
+			};
+			return mergeRegister(editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+				if (refreshTripleClick(null)) {
+					lastTripleClick = 0;
+					stores.$fixFocusOverselection.peek()();
+				}
+				return false;
+			}, COMMAND_PRIORITY_BEFORE_CRITICAL), (() => {
+				const events = ["mouseup", "mousedown"];
+				events.forEach((v) => rootElement.addEventListener(v, refreshTripleClick, true));
+				return () => events.forEach((v) => rootElement.removeEventListener(v, refreshTripleClick, 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.
+*
+*/
 /**
 * An extension that highlights selected content in the Lexical editor
 * even when the editor is not currently focused.
@@ -1616,7 +1945,7 @@ function $indentOverTab(selection) {
 	return false;
 }
 function $defaultCanIndent(node) {
-	return node.canBeEmpty();
+	return node.canIndent();
 }
 function registerTabIndentation(editor, maxIndent, $canIndent = $defaultCanIndent) {
 	return mergeRegister(editor.registerCommand(KEY_TAB_COMMAND, (event) => {
@@ -1660,4 +1989,4 @@ const TabIndentationExtension = defineExtension({
 	}
 });
 //#endregion
-export { $createHorizontalRuleNode, $isDecoratorTextNode, $isHorizontalRuleNode, AutoFocusExtension, ClearEditorExtension, DecoratorTextExtension, DecoratorTextNode, EditorStateExtension, HorizontalRuleExtension, HorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND, InitialStateExtension, LexicalBuilder, NestedEditorExtension, NodeSelectionExtension, 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, 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 };

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

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@lexical+extension@0.44.0/node_modules/@lexical/extension/LexicalExtension.node.mjs
+//#region ../../node_modules/.pnpm/@lexical+extension@0.45.0/node_modules/@lexical/extension/dist/LexicalExtension.node.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -6,22 +6,29 @@
 * LICENSE file in the root directory of this source tree.
 *
 */
-const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalExtension.dev-DVbjljrm.mjs") : import("./LexicalExtension.prod-DklHHErZ.mjs"));
-mod.$createHorizontalRuleNode;
+const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalExtension.dev-BPNyvGqe.mjs") : import("./LexicalExtension.prod-DFKbiNt-.mjs"));
+const $createHorizontalRuleNode = mod.$createHorizontalRuleNode;
+mod.$defaultShouldInsertAfter;
+mod.$getExtensionDependency;
+const $getExtensionOutput = mod.$getExtensionOutput;
+const $getPeerDependency = mod.$getPeerDependency;
 mod.$isDecoratorTextNode;
 mod.$isHorizontalRuleNode;
 mod.AutoFocusExtension;
 mod.ClearEditorExtension;
+mod.ClickAfterLastBlockExtension;
 mod.DecoratorTextExtension;
 mod.DecoratorTextNode;
 mod.EditorStateExtension;
-mod.HorizontalRuleExtension;
+const HorizontalRuleExtension = mod.HorizontalRuleExtension;
 const HorizontalRuleNode = mod.HorizontalRuleNode;
 mod.INSERT_HORIZONTAL_RULE_COMMAND;
 mod.InitialStateExtension;
-const LexicalBuilder = mod.LexicalBuilder;
+mod.LexicalBuilder;
 mod.NestedEditorExtension;
 mod.NodeSelectionExtension;
+const NormalizeInlineElementsExtension = mod.NormalizeInlineElementsExtension;
+const NormalizeTripleClickSelectionExtension = mod.NormalizeTripleClickSelectionExtension;
 mod.SelectionAlwaysOnDisplayExtension;
 mod.TabIndentationExtension;
 mod.applyFormatFromStyle;
@@ -29,11 +36,11 @@ mod.applyFormatToDom;
 mod.batch;
 mod.buildEditorFromExtensions;
 mod.computed;
-mod.configExtension;
+const configExtension = mod.configExtension;
 mod.declarePeerDependency;
 mod.defineExtension;
 const effect = mod.effect;
-const getExtensionDependencyFromEditor = mod.getExtensionDependencyFromEditor;
+mod.getExtensionDependencyFromEditor;
 const getKnownTypesAndNodes = mod.getKnownTypesAndNodes;
 const getPeerDependencyFromEditor = mod.getPeerDependencyFromEditor;
 mod.getPeerDependencyFromEditorOrThrow;
@@ -46,4 +53,4 @@ const signal = mod.signal;
 mod.untracked;
 mod.watchedSignal;
 //#endregion
-export { getKnownTypesAndNodes as a, signal as c, getExtensionDependencyFromEditor as i, LexicalBuilder as n, getPeerDependencyFromEditor as o, effect as r, namedSignals as s, HorizontalRuleNode as t };
+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 };