@uipath/apollo-wind 2.23.0 → 2.24.0

package/dist/components/ui/prompt-editor/plugins/NodeSelectionFixPlugin.cjs

@@ -0,0 +1,313 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    registerNodeSelectionFixCommands: ()=>registerNodeSelectionFixCommands,
+    NodeSelectionFixPlugin: ()=>NodeSelectionFixPlugin
+});
+const external_react_namespaceObject = require("react");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const external_lexical_namespaceObject = require("lexical");
+const token_nodes_cjs_namespaceObject = require("./shared/token-nodes.cjs");
+const index_cjs_namespaceObject = require("../utils/index.cjs");
+const $setCollapsedSelection = (key, offset, type)=>{
+    const sel = (0, external_lexical_namespaceObject.$createRangeSelection)();
+    sel.anchor.set(key, offset, type);
+    sel.focus.set(key, offset, type);
+    (0, external_lexical_namespaceObject.$setSelection)(sel);
+};
+const getSelectedPromptToken = ()=>{
+    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+    if (!(0, external_lexical_namespaceObject.$isNodeSelection)(selection)) return null;
+    const nodes = selection.getNodes();
+    if (1 !== nodes.length) return null;
+    const node = nodes[0];
+    return (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(node) ? node : null;
+};
+const getCollapsedRangeSelection = ()=>{
+    const selection = (0, external_lexical_namespaceObject.$getSelection)();
+    if (!(0, external_lexical_namespaceObject.$isRangeSelection)(selection) || !selection.isCollapsed()) return null;
+    return selection;
+};
+const getPromptTokenBeforeCursor = ()=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return null;
+    const anchorNode = selection.anchor.getNode();
+    if ((0, external_lexical_namespaceObject.$isTextNode)(anchorNode) && 0 === selection.anchor.offset) {
+        const prev = anchorNode.getPreviousSibling();
+        return (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(prev) ? prev : null;
+    }
+    if ((0, external_lexical_namespaceObject.$isParagraphNode)(anchorNode)) {
+        const offset = selection.anchor.offset;
+        if (0 === offset) return null;
+        const prev = anchorNode.getChildAtIndex(offset - 1);
+        return (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(prev) ? prev : null;
+    }
+    return null;
+};
+const getPromptTokenAfterCursor = ()=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return null;
+    const anchorNode = selection.anchor.getNode();
+    if ((0, external_lexical_namespaceObject.$isTextNode)(anchorNode) && selection.anchor.offset === anchorNode.getTextContentSize()) {
+        const next = anchorNode.getNextSibling();
+        return (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(next) ? next : null;
+    }
+    if ((0, external_lexical_namespaceObject.$isParagraphNode)(anchorNode)) {
+        const next = anchorNode.getChildAtIndex(selection.anchor.offset);
+        return (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(next) ? next : null;
+    }
+    return null;
+};
+const skipLineBreaks = (node, direction)=>{
+    let sibling = 'left' === direction ? node.getPreviousSibling() : node.getNextSibling();
+    while(sibling && (0, external_lexical_namespaceObject.$isLineBreakNode)(sibling))sibling = 'left' === direction ? sibling.getPreviousSibling() : sibling.getNextSibling();
+    return sibling;
+};
+const skipStandaloneJoiner = (direction)=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return false;
+    const anchorNode = selection.anchor.getNode();
+    if (!(0, external_lexical_namespaceObject.$isTextNode)(anchorNode) || anchorNode.getTextContent() !== index_cjs_namespaceObject.WORD_JOINER) return false;
+    const sibling = skipLineBreaks(anchorNode, direction);
+    if (sibling && (0, token_nodes_cjs_namespaceObject.isPromptTokenNode)(sibling)) {
+        focusPromptToken(sibling);
+        return true;
+    }
+    if ((0, external_lexical_namespaceObject.$isTextNode)(sibling)) {
+        $setCollapsedSelection(sibling.getKey(), 'left' === direction ? sibling.getTextContentSize() : 0, 'text');
+        return true;
+    }
+    const parent = anchorNode.getParent();
+    if (!parent) return false;
+    const idx = anchorNode.getIndexWithinParent() + ('left' === direction ? 0 : 1);
+    $setCollapsedSelection(parent.getKey(), idx, 'element');
+    return true;
+};
+const placeCursorBefore = (node)=>{
+    const prev = node.getPreviousSibling();
+    if ((0, external_lexical_namespaceObject.$isTextNode)(prev)) {
+        const content = prev.getTextContent();
+        if (!content.endsWith(index_cjs_namespaceObject.WORD_JOINER)) prev.setTextContent(content + index_cjs_namespaceObject.WORD_JOINER);
+        $setCollapsedSelection(prev.getKey(), prev.getTextContentSize(), 'text');
+    } else {
+        const anchor = (0, external_lexical_namespaceObject.$createTextNode)(index_cjs_namespaceObject.WORD_JOINER);
+        node.insertBefore(anchor);
+        $setCollapsedSelection(anchor.getKey(), 1, 'text');
+    }
+};
+const placeCursorAfter = (node)=>{
+    const next = node.getNextSibling();
+    if ((0, external_lexical_namespaceObject.$isTextNode)(next)) $setCollapsedSelection(next.getKey(), 0, 'text');
+    else {
+        const parent = node.getParent();
+        if (!parent) return;
+        $setCollapsedSelection(parent.getKey(), node.getIndexWithinParent() + 1, 'element');
+    }
+};
+const focusPromptToken = (node)=>{
+    const newSelection = (0, external_lexical_namespaceObject.$createNodeSelection)();
+    newSelection.add(node.getKey());
+    (0, external_lexical_namespaceObject.$setSelection)(newSelection);
+};
+const registerNodeSelectionFixCommands = (editor)=>{
+    const handleBackspace = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            const before = (()=>{
+                const prev = selectedToken.getPreviousSibling();
+                if ((0, external_lexical_namespaceObject.$isTextNode)(prev)) return {
+                    kind: 'text',
+                    key: prev.getKey(),
+                    offset: prev.getTextContentSize()
+                };
+                const parent = selectedToken.getParent();
+                if (parent) return {
+                    kind: 'element',
+                    key: parent.getKey(),
+                    offset: selectedToken.getIndexWithinParent()
+                };
+                return null;
+            })();
+            selectedToken.remove();
+            if (before) $setCollapsedSelection(before.key, before.offset, before.kind);
+            event.preventDefault();
+            return true;
+        }
+        const pillBefore = getPromptTokenBeforeCursor();
+        if (pillBefore) {
+            focusPromptToken(pillBefore);
+            event.preventDefault();
+            return true;
+        }
+        const selection = getCollapsedRangeSelection();
+        if (!selection) return false;
+        const anchorNode = selection.anchor.getNode();
+        let paragraph = null;
+        let offset = 0;
+        if ('element' === selection.anchor.type && (0, external_lexical_namespaceObject.$isParagraphNode)(anchorNode)) {
+            paragraph = anchorNode;
+            offset = selection.anchor.offset;
+        } else {
+            if (!('text' === selection.anchor.type && (0, external_lexical_namespaceObject.$isTextNode)(anchorNode)) || 0 !== selection.anchor.offset) return false;
+            const parent = anchorNode.getParent();
+            if (!(0, external_lexical_namespaceObject.$isParagraphNode)(parent)) return false;
+            paragraph = parent;
+            offset = anchorNode.getIndexWithinParent();
+        }
+        if (offset <= 0) return false;
+        const previousNode = paragraph.getChildAtIndex(offset - 1);
+        if (!(0, external_lexical_namespaceObject.$isLineBreakNode)(previousNode)) return false;
+        const lineStartNode = paragraph.getChildAtIndex(offset);
+        previousNode.remove();
+        (0, external_lexical_namespaceObject.$isTextNode)(lineStartNode) && lineStartNode.isAttached() ? $setCollapsedSelection(lineStartNode.getKey(), 0, 'text') : $setCollapsedSelection(paragraph.getKey(), Math.max(0, offset - 1), 'element');
+        event.preventDefault();
+        return true;
+    };
+    const handleDelete = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            const after = (()=>{
+                const next = selectedToken.getNextSibling();
+                if ((0, external_lexical_namespaceObject.$isTextNode)(next)) return {
+                    kind: 'text',
+                    key: next.getKey(),
+                    offset: 0
+                };
+                const parent = selectedToken.getParent();
+                if (parent) return {
+                    kind: 'element',
+                    key: parent.getKey(),
+                    offset: selectedToken.getIndexWithinParent()
+                };
+                return null;
+            })();
+            selectedToken.remove();
+            if (after) $setCollapsedSelection(after.key, after.offset, after.kind);
+            event.preventDefault();
+            return true;
+        }
+        const pillAfter = getPromptTokenAfterCursor();
+        if (pillAfter) {
+            focusPromptToken(pillAfter);
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleArrowLeft = (event)=>{
+        if (event.shiftKey) return false;
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            placeCursorBefore(selectedToken);
+            event.preventDefault();
+            return true;
+        }
+        const pillBefore = getPromptTokenBeforeCursor();
+        if (pillBefore) {
+            focusPromptToken(pillBefore);
+            event.preventDefault();
+            return true;
+        }
+        if (skipStandaloneJoiner('left')) {
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleArrowRight = (event)=>{
+        if (event.shiftKey) return false;
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            placeCursorAfter(selectedToken);
+            event.preventDefault();
+            return true;
+        }
+        const pillAfter = getPromptTokenAfterCursor();
+        if (pillAfter) {
+            focusPromptToken(pillAfter);
+            event.preventDefault();
+            return true;
+        }
+        if (skipStandaloneJoiner('right')) {
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleEscape = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (!selectedToken) return false;
+        placeCursorAfter(selectedToken);
+        event.preventDefault();
+        return true;
+    };
+    const handleArrowUp = (event)=>{
+        if (!event.shiftKey) {
+            const selectedToken = getSelectedPromptToken();
+            if (selectedToken) placeCursorBefore(selectedToken);
+        }
+        return false;
+    };
+    const handleArrowDown = (event)=>{
+        if (!event.shiftKey) {
+            const selectedToken = getSelectedPromptToken();
+            if (selectedToken) placeCursorAfter(selectedToken);
+        }
+        return false;
+    };
+    const unregisterBackspace = editor.registerCommand(external_lexical_namespaceObject.KEY_BACKSPACE_COMMAND, handleBackspace, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterDelete = editor.registerCommand(external_lexical_namespaceObject.KEY_DELETE_COMMAND, handleDelete, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterArrowLeft = editor.registerCommand(external_lexical_namespaceObject.KEY_ARROW_LEFT_COMMAND, handleArrowLeft, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterArrowRight = editor.registerCommand(external_lexical_namespaceObject.KEY_ARROW_RIGHT_COMMAND, handleArrowRight, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterArrowUp = editor.registerCommand(external_lexical_namespaceObject.KEY_ARROW_UP_COMMAND, handleArrowUp, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterArrowDown = editor.registerCommand(external_lexical_namespaceObject.KEY_ARROW_DOWN_COMMAND, handleArrowDown, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    const unregisterEscape = editor.registerCommand(external_lexical_namespaceObject.KEY_ESCAPE_COMMAND, handleEscape, external_lexical_namespaceObject.COMMAND_PRIORITY_HIGH);
+    return ()=>{
+        unregisterBackspace();
+        unregisterDelete();
+        unregisterArrowLeft();
+        unregisterArrowRight();
+        unregisterArrowUp();
+        unregisterArrowDown();
+        unregisterEscape();
+    };
+};
+const NodeSelectionFixPlugin = ()=>{
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    (0, external_react_namespaceObject.useEffect)(()=>registerNodeSelectionFixCommands(editor), [
+        editor
+    ]);
+    return null;
+};
+exports.NodeSelectionFixPlugin = __webpack_exports__.NodeSelectionFixPlugin;
+exports.registerNodeSelectionFixCommands = __webpack_exports__.registerNodeSelectionFixCommands;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NodeSelectionFixPlugin",
+    "registerNodeSelectionFixCommands"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/prompt-editor/plugins/NodeSelectionFixPlugin.d.ts

@@ -0,0 +1,7 @@
+import { type LexicalEditor } from 'lexical';
+/**
+ * Registers the focus controller commands on a Lexical editor. Exported so tests can drive the
+ * exact same logic the React plugin wires up at mount time, against a headless `createEditor()`.
+ */
+export declare const registerNodeSelectionFixCommands: (editor: LexicalEditor) => (() => void);
+export declare const NodeSelectionFixPlugin: () => null;

package/dist/components/ui/prompt-editor/plugins/NodeSelectionFixPlugin.js

@@ -0,0 +1,276 @@
+import { useEffect } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $createNodeSelection, $createRangeSelection, $createTextNode, $getSelection, $isLineBreakNode, $isNodeSelection, $isParagraphNode, $isRangeSelection, $isTextNode, $setSelection, COMMAND_PRIORITY_HIGH, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, KEY_ESCAPE_COMMAND } from "lexical";
+import { isPromptTokenNode } from "./shared/token-nodes.js";
+import { WORD_JOINER } from "../utils/index.js";
+const $setCollapsedSelection = (key, offset, type)=>{
+    const sel = $createRangeSelection();
+    sel.anchor.set(key, offset, type);
+    sel.focus.set(key, offset, type);
+    $setSelection(sel);
+};
+const getSelectedPromptToken = ()=>{
+    const selection = $getSelection();
+    if (!$isNodeSelection(selection)) return null;
+    const nodes = selection.getNodes();
+    if (1 !== nodes.length) return null;
+    const node = nodes[0];
+    return isPromptTokenNode(node) ? node : null;
+};
+const getCollapsedRangeSelection = ()=>{
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection) || !selection.isCollapsed()) return null;
+    return selection;
+};
+const getPromptTokenBeforeCursor = ()=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return null;
+    const anchorNode = selection.anchor.getNode();
+    if ($isTextNode(anchorNode) && 0 === selection.anchor.offset) {
+        const prev = anchorNode.getPreviousSibling();
+        return isPromptTokenNode(prev) ? prev : null;
+    }
+    if ($isParagraphNode(anchorNode)) {
+        const offset = selection.anchor.offset;
+        if (0 === offset) return null;
+        const prev = anchorNode.getChildAtIndex(offset - 1);
+        return isPromptTokenNode(prev) ? prev : null;
+    }
+    return null;
+};
+const getPromptTokenAfterCursor = ()=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return null;
+    const anchorNode = selection.anchor.getNode();
+    if ($isTextNode(anchorNode) && selection.anchor.offset === anchorNode.getTextContentSize()) {
+        const next = anchorNode.getNextSibling();
+        return isPromptTokenNode(next) ? next : null;
+    }
+    if ($isParagraphNode(anchorNode)) {
+        const next = anchorNode.getChildAtIndex(selection.anchor.offset);
+        return isPromptTokenNode(next) ? next : null;
+    }
+    return null;
+};
+const skipLineBreaks = (node, direction)=>{
+    let sibling = 'left' === direction ? node.getPreviousSibling() : node.getNextSibling();
+    while(sibling && $isLineBreakNode(sibling))sibling = 'left' === direction ? sibling.getPreviousSibling() : sibling.getNextSibling();
+    return sibling;
+};
+const skipStandaloneJoiner = (direction)=>{
+    const selection = getCollapsedRangeSelection();
+    if (!selection) return false;
+    const anchorNode = selection.anchor.getNode();
+    if (!$isTextNode(anchorNode) || anchorNode.getTextContent() !== WORD_JOINER) return false;
+    const sibling = skipLineBreaks(anchorNode, direction);
+    if (sibling && isPromptTokenNode(sibling)) {
+        focusPromptToken(sibling);
+        return true;
+    }
+    if ($isTextNode(sibling)) {
+        $setCollapsedSelection(sibling.getKey(), 'left' === direction ? sibling.getTextContentSize() : 0, 'text');
+        return true;
+    }
+    const parent = anchorNode.getParent();
+    if (!parent) return false;
+    const idx = anchorNode.getIndexWithinParent() + ('left' === direction ? 0 : 1);
+    $setCollapsedSelection(parent.getKey(), idx, 'element');
+    return true;
+};
+const placeCursorBefore = (node)=>{
+    const prev = node.getPreviousSibling();
+    if ($isTextNode(prev)) {
+        const content = prev.getTextContent();
+        if (!content.endsWith(WORD_JOINER)) prev.setTextContent(content + WORD_JOINER);
+        $setCollapsedSelection(prev.getKey(), prev.getTextContentSize(), 'text');
+    } else {
+        const anchor = $createTextNode(WORD_JOINER);
+        node.insertBefore(anchor);
+        $setCollapsedSelection(anchor.getKey(), 1, 'text');
+    }
+};
+const placeCursorAfter = (node)=>{
+    const next = node.getNextSibling();
+    if ($isTextNode(next)) $setCollapsedSelection(next.getKey(), 0, 'text');
+    else {
+        const parent = node.getParent();
+        if (!parent) return;
+        $setCollapsedSelection(parent.getKey(), node.getIndexWithinParent() + 1, 'element');
+    }
+};
+const focusPromptToken = (node)=>{
+    const newSelection = $createNodeSelection();
+    newSelection.add(node.getKey());
+    $setSelection(newSelection);
+};
+const registerNodeSelectionFixCommands = (editor)=>{
+    const handleBackspace = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            const before = (()=>{
+                const prev = selectedToken.getPreviousSibling();
+                if ($isTextNode(prev)) return {
+                    kind: 'text',
+                    key: prev.getKey(),
+                    offset: prev.getTextContentSize()
+                };
+                const parent = selectedToken.getParent();
+                if (parent) return {
+                    kind: 'element',
+                    key: parent.getKey(),
+                    offset: selectedToken.getIndexWithinParent()
+                };
+                return null;
+            })();
+            selectedToken.remove();
+            if (before) $setCollapsedSelection(before.key, before.offset, before.kind);
+            event.preventDefault();
+            return true;
+        }
+        const pillBefore = getPromptTokenBeforeCursor();
+        if (pillBefore) {
+            focusPromptToken(pillBefore);
+            event.preventDefault();
+            return true;
+        }
+        const selection = getCollapsedRangeSelection();
+        if (!selection) return false;
+        const anchorNode = selection.anchor.getNode();
+        let paragraph = null;
+        let offset = 0;
+        if ('element' === selection.anchor.type && $isParagraphNode(anchorNode)) {
+            paragraph = anchorNode;
+            offset = selection.anchor.offset;
+        } else {
+            if (!('text' === selection.anchor.type && $isTextNode(anchorNode)) || 0 !== selection.anchor.offset) return false;
+            const parent = anchorNode.getParent();
+            if (!$isParagraphNode(parent)) return false;
+            paragraph = parent;
+            offset = anchorNode.getIndexWithinParent();
+        }
+        if (offset <= 0) return false;
+        const previousNode = paragraph.getChildAtIndex(offset - 1);
+        if (!$isLineBreakNode(previousNode)) return false;
+        const lineStartNode = paragraph.getChildAtIndex(offset);
+        previousNode.remove();
+        $isTextNode(lineStartNode) && lineStartNode.isAttached() ? $setCollapsedSelection(lineStartNode.getKey(), 0, 'text') : $setCollapsedSelection(paragraph.getKey(), Math.max(0, offset - 1), 'element');
+        event.preventDefault();
+        return true;
+    };
+    const handleDelete = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            const after = (()=>{
+                const next = selectedToken.getNextSibling();
+                if ($isTextNode(next)) return {
+                    kind: 'text',
+                    key: next.getKey(),
+                    offset: 0
+                };
+                const parent = selectedToken.getParent();
+                if (parent) return {
+                    kind: 'element',
+                    key: parent.getKey(),
+                    offset: selectedToken.getIndexWithinParent()
+                };
+                return null;
+            })();
+            selectedToken.remove();
+            if (after) $setCollapsedSelection(after.key, after.offset, after.kind);
+            event.preventDefault();
+            return true;
+        }
+        const pillAfter = getPromptTokenAfterCursor();
+        if (pillAfter) {
+            focusPromptToken(pillAfter);
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleArrowLeft = (event)=>{
+        if (event.shiftKey) return false;
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            placeCursorBefore(selectedToken);
+            event.preventDefault();
+            return true;
+        }
+        const pillBefore = getPromptTokenBeforeCursor();
+        if (pillBefore) {
+            focusPromptToken(pillBefore);
+            event.preventDefault();
+            return true;
+        }
+        if (skipStandaloneJoiner('left')) {
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleArrowRight = (event)=>{
+        if (event.shiftKey) return false;
+        const selectedToken = getSelectedPromptToken();
+        if (selectedToken) {
+            placeCursorAfter(selectedToken);
+            event.preventDefault();
+            return true;
+        }
+        const pillAfter = getPromptTokenAfterCursor();
+        if (pillAfter) {
+            focusPromptToken(pillAfter);
+            event.preventDefault();
+            return true;
+        }
+        if (skipStandaloneJoiner('right')) {
+            event.preventDefault();
+            return true;
+        }
+        return false;
+    };
+    const handleEscape = (event)=>{
+        const selectedToken = getSelectedPromptToken();
+        if (!selectedToken) return false;
+        placeCursorAfter(selectedToken);
+        event.preventDefault();
+        return true;
+    };
+    const handleArrowUp = (event)=>{
+        if (!event.shiftKey) {
+            const selectedToken = getSelectedPromptToken();
+            if (selectedToken) placeCursorBefore(selectedToken);
+        }
+        return false;
+    };
+    const handleArrowDown = (event)=>{
+        if (!event.shiftKey) {
+            const selectedToken = getSelectedPromptToken();
+            if (selectedToken) placeCursorAfter(selectedToken);
+        }
+        return false;
+    };
+    const unregisterBackspace = editor.registerCommand(KEY_BACKSPACE_COMMAND, handleBackspace, COMMAND_PRIORITY_HIGH);
+    const unregisterDelete = editor.registerCommand(KEY_DELETE_COMMAND, handleDelete, COMMAND_PRIORITY_HIGH);
+    const unregisterArrowLeft = editor.registerCommand(KEY_ARROW_LEFT_COMMAND, handleArrowLeft, COMMAND_PRIORITY_HIGH);
+    const unregisterArrowRight = editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, handleArrowRight, COMMAND_PRIORITY_HIGH);
+    const unregisterArrowUp = editor.registerCommand(KEY_ARROW_UP_COMMAND, handleArrowUp, COMMAND_PRIORITY_HIGH);
+    const unregisterArrowDown = editor.registerCommand(KEY_ARROW_DOWN_COMMAND, handleArrowDown, COMMAND_PRIORITY_HIGH);
+    const unregisterEscape = editor.registerCommand(KEY_ESCAPE_COMMAND, handleEscape, COMMAND_PRIORITY_HIGH);
+    return ()=>{
+        unregisterBackspace();
+        unregisterDelete();
+        unregisterArrowLeft();
+        unregisterArrowRight();
+        unregisterArrowUp();
+        unregisterArrowDown();
+        unregisterEscape();
+    };
+};
+const NodeSelectionFixPlugin = ()=>{
+    const [editor] = useLexicalComposerContext();
+    useEffect(()=>registerNodeSelectionFixCommands(editor), [
+        editor
+    ]);
+    return null;
+};
+export { NodeSelectionFixPlugin, registerNodeSelectionFixCommands };