@fluentui-copilot/chat-input-plugins 0.0.0-nightly-20251002-0405-17b34fb7.1 → 0.0.0-nightly-20251010-0406-7df7c6d1.1

package/CHANGELOG.json

@@ -2,9 +2,9 @@
   "name": "@fluentui-copilot/chat-input-plugins",
   "entries": [
     {
-      "date": "Thu, 02 Oct 2025 04:13:19 GMT",
-      "tag": "@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251002-0405-17b34fb7.1",
-      "version": "0.0.0-nightly-20251002-0405-17b34fb7.1",
+      "date": "Fri, 10 Oct 2025 04:08:17 GMT",
+      "tag": "@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251010-0406-7df7c6d1.1",
+      "version": "0.0.0-nightly-20251010-0406-7df7c6d1.1",
       "comments": {
         "prerelease": [
           {

package/CHANGELOG.md

@@ -1,13 +1,13 @@
 # Change Log - @fluentui-copilot/chat-input-plugins
 
-This log was last generated on Thu, 02 Oct 2025 04:13:19 GMT and should not be manually modified.
+This log was last generated on Fri, 10 Oct 2025 04:08:17 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## [0.0.0-nightly-20251002-0405-17b34fb7.1](https://github.com/microsoft/fluentai/tree/@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251002-0405-17b34fb7.1)
+## [0.0.0-nightly-20251010-0406-7df7c6d1.1](https://github.com/microsoft/fluentai/tree/@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251010-0406-7df7c6d1.1)
 
-Thu, 02 Oct 2025 04:13:19 GMT 
-[Compare changes](https://github.com/microsoft/fluentai/compare/@fluentui-copilot/chat-input-plugins_v0.5.1..@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251002-0405-17b34fb7.1)
+Fri, 10 Oct 2025 04:08:17 GMT 
+[Compare changes](https://github.com/microsoft/fluentai/compare/@fluentui-copilot/chat-input-plugins_v0.5.1..@fluentui-copilot/chat-input-plugins_v0.0.0-nightly-20251010-0406-7df7c6d1.1)
 
 ### Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui-copilot/chat-input-plugins",
-  "version": "0.0.0-nightly-20251002-0405-17b34fb7.1",
+  "version": "0.0.0-nightly-20251010-0406-7df7c6d1.1",
   "description": "A Fluent AI package for non-react specific chat input plugins.",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -12,7 +12,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@fluentui-copilot/text-editor": "0.0.0-nightly-20251002-0405-17b34fb7.1",
+    "@fluentui-copilot/text-editor": "0.0.0-nightly-20251010-0406-7df7c6d1.1",
     "@swc/helpers": "^0.5.1"
   },
   "beachball": {},

package/dist/index.d.ts

@@ -1,192 +0,0 @@
-import type { EditorConfig } from '@fluentui-copilot/text-editor';
-import type { EditorState } from '@fluentui-copilot/text-editor';
-import type { Klass } from '@fluentui-copilot/text-editor';
-import { LexicalEditor } from '@fluentui-copilot/text-editor';
-import { LexicalNode } from '@fluentui-copilot/text-editor';
-import type { NodeKey } from '@fluentui-copilot/text-editor';
-import type { SerializedTextNode } from '@fluentui-copilot/text-editor';
-import { TextNode } from '@fluentui-copilot/text-editor';
-
-export declare function $createSentinelNode(key?: NodeKey): SentinelNode;
-
-export declare function $isSentinelNode(node: LexicalNode | null): node is SentinelNode;
-
-export declare class BasicFunctionalityBase implements IBasicFunctionalityBase {
-    private __editor;
-    private __contentChangeCleanup?;
-    private __trimWhitespaceCleanup?;
-    private __baseHandlersCleanup?;
-    private __pasteHandlerCleanup?;
-    private __enterHandler;
-    constructor(editor: LexicalEditor, isSentinelNodeEnabled?: boolean);
-    activateContentCallbacks(onContentChange?: ((value: string) => void) | undefined, onCountChanged?: ((count: number) => void) | undefined): void;
-    deactivateContentCallbacks(): void;
-    activatePasteCallback(onPaste: (event: ClipboardEvent) => void): void;
-    deactivatePasteCallback(): void;
-    activateTrimWhitespace(): void;
-    deactivateTrimWhitespace(): void;
-    setIsDisabled(isDisabled: boolean): void;
-    cleanup(): void;
-}
-
-export declare type ChatInputEntityData<ExtraDataType, NodePropsType> = {
-    text: string;
-    entityProps?: NodePropsType;
-    data?: ExtraDataType;
-};
-
-export declare class ChatInputEntityPluginBase<ExtraDataType, NodePropsType, NodeType extends IEntityNode<ExtraDataType, NodePropsType>> implements IChatInputEntityPluginBase<ExtraDataType, NodePropsType> {
-    private __nodeClass;
-    private __editor;
-    private __id;
-    private __deleteDirection;
-    private __$createNode;
-    private _cleanup;
-    cleanup(): void;
-    constructor(editor: LexicalEditor, id: string, nodeClass: Klass<NodeType>, $createNode: (pluginId: string, text: string, data?: ExtraDataType, entityProps?: NodePropsType, key?: NodeKey) => NodeType, $isChatInputEntityNode: (node: LexicalNode | null) => node is NodeType, onChatInputEntityAdded?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityAdded'], onChatInputEntityDeleted?: ChatInputEntityPluginProps<ExtraDataType, NodePropsType>['onChatInputEntityDeleted']);
-    insertChatInputEntity(props: ChatInputEntityData<ExtraDataType, NodePropsType>): string | undefined;
-    removeChatInputEntity(keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean)): void;
-    updateChatInputEntityProps(keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean), props: ChatInputEntityData<ExtraDataType, NodePropsType> | ((oldProps: ChatInputEntityData<ExtraDataType, NodePropsType>) => ChatInputEntityData<ExtraDataType, NodePropsType>)): void;
-    getActiveEntities(): ChatInputEntityData<ExtraDataType, NodePropsType>[];
-}
-
-export declare type ChatInputEntityPluginProps<ExtraDataType, NodePropsType> = {
-    id: string;
-    onChatInputEntityAdded?: (entity: ChatInputEntityData<ExtraDataType, NodePropsType>, nodeKey: NodeKey) => void;
-    onChatInputEntityDeleted?: (entity: ChatInputEntityData<ExtraDataType, NodePropsType>, nodeKey: NodeKey) => void;
-    skipInitialization?: boolean;
-};
-
-export declare type GetGhostTextFunction = (editor: LexicalEditor, editorState: EditorState, prevEditorState: EditorState) => Promise<string | undefined>;
-
-export declare class GhostTextPluginBase<ComponentPropsType> {
-    private __id;
-    private __$getGhostText;
-    private __componentProps?;
-    private __exposeText?;
-    private __allowCompletion?;
-    private __cleanup?;
-    cleanup(): void;
-    constructor(editor: LexicalEditor, id: string, $getGhostText: GetGhostTextFunction, nodeClass: Klass<IGhostTextNode<ComponentPropsType>>, createNode: (id: string, content: string, exposeText?: boolean, componentProps?: ComponentPropsType) => IGhostTextNode<ComponentPropsType>, componentProps?: ComponentPropsType, exposeText?: boolean, allowCompletion?: boolean);
-    setExposeText(exposeText?: boolean): void;
-    setComponentProps(componentProps?: ComponentPropsType): void;
-    setGetGhostText($getGhostText: GetGhostTextFunction): void;
-    setAllowCompletion(allowCompletion?: boolean): void;
-}
-
-export declare interface IBasicFunctionalityBase {
-    setIsDisabled: (isDisabled: boolean) => void;
-    activateContentCallbacks(onContentChange?: (value: string) => void, onCountChanged?: (count: number) => void): void;
-    deactivateContentCallbacks(): void;
-    activateTrimWhitespace(): void;
-    deactivateTrimWhitespace(): void;
-    activatePasteCallback(onPaste: (event: ClipboardEvent) => void): void;
-    deactivatePasteCallback(): void;
-    cleanup(): void;
-}
-
-export declare interface IChatInputEntityPluginBase<ExtraDataType, NodePropsType> {
-    insertChatInputEntity: (props: ChatInputEntityData<ExtraDataType, NodePropsType>) => string | undefined;
-    removeChatInputEntity: (keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean)) => void;
-    updateChatInputEntityProps: (keyOrPredicate: string | ((entity: ChatInputEntityData<ExtraDataType, NodePropsType>, i: number) => boolean), props: ChatInputEntityData<ExtraDataType, NodePropsType> | ((oldProps: ChatInputEntityData<ExtraDataType, NodePropsType>) => ChatInputEntityData<ExtraDataType, NodePropsType>)) => void;
-    getActiveEntities: () => ChatInputEntityData<ExtraDataType, NodePropsType>[];
-}
-
-/**
- * A lexical node representing an entity should conform to this interface
- */
-export declare interface IEntityNode<ExtraDataType, NodePropsType> extends LexicalNode {
-    getEntityData: () => ChatInputEntityData<ExtraDataType, NodePropsType>;
-    updateEntityData: (data: ChatInputEntityData<ExtraDataType, NodePropsType>) => void;
-    __pluginId: string;
-}
-
-export declare interface IGhostTextNode<ComponentPropsType> extends LexicalNode {
-    __content: string;
-    __id: string;
-    __allowCommitting?: boolean;
-    __componentProps?: ComponentPropsType;
-    __exposeText?: boolean;
-}
-
-export declare interface IImperativeControlBase {
-    setInputText: (inputText: string) => void;
-    appendText: (text: string) => void;
-    prependText: (text: string) => void;
-    insertTextAtCursor: (text: string) => void;
-    /**
-     * @param transform will be called for each Lexical node in the input. This enables custom string representation for each node.
-     */
-    getInputText: (transform?: (node: LexicalNode) => string) => string;
-    scrollToBottom: () => void;
-    moveCursor: (location: number) => void;
-}
-
-export declare interface IManualGhostTextBase<ComponentPropsType> {
-    getGhostText: () => string | undefined;
-    setGhostText: (text: string, exposeText?: boolean, componentProps?: ComponentPropsType, discrete?: boolean) => void;
-    commitGhostText: (finalText: string, discrete?: boolean) => void;
-    cancelGhostText: (discrete?: boolean) => void;
-}
-
-export declare class ImperativeControlBase implements IImperativeControlBase {
-    private __editor;
-    constructor(editor: LexicalEditor);
-    moveCursor(location: number): void;
-    setInputText(inputText: string): void;
-    appendText(text: string): void;
-    prependText(text: string): void;
-    insertTextAtCursor(text: string): void;
-    getInputText(transform?: (node: LexicalNode) => string): string;
-    scrollToBottom(): void;
-}
-
-export declare class ManualGhostTextBase<ComponentPropsType> implements IManualGhostTextBase<ComponentPropsType> {
-    private __editor;
-    private __nodeKey?;
-    private __id;
-    private __$isNodeType;
-    private __$createNode;
-    constructor(editor: LexicalEditor, id: string, $isNodeType: (node: LexicalNode | null) => node is IGhostTextNode<ComponentPropsType>, $createNode: (id: string, content: string, exposeText?: boolean, componentProps?: ComponentPropsType) => IGhostTextNode<ComponentPropsType>);
-    getGhostText(): string | undefined;
-    setGhostText(text: string, exposeText?: boolean, componentProps?: ComponentPropsType, discrete?: boolean): void;
-    commitGhostText(finalText: string, discrete?: boolean): void;
-    cancelGhostText(discrete?: boolean): void;
-}
-
-export declare type PasteUnfurlingPluginBaseProps<ExtraDataType, NodePropsType> = {
-    entityPluginId: string;
-    transforms: PasteUnfurlingTransformFunction<ExtraDataType, NodePropsType>[];
-    $createEntityNode: (pluginId: string, text: string, data?: ExtraDataType, entityProps?: NodePropsType, key?: NodeKey) => LexicalNode;
-};
-
-export declare type PasteUnfurlingTransformedPart<ExtraDataType, NodePropsType> = {
-    type: 'text';
-    value: string;
-} | {
-    type: 'entity';
-    value: ChatInputEntityData<ExtraDataType, NodePropsType>;
-};
-
-export declare type PasteUnfurlingTransformFunction<ExtraDataType, NodePropsType> = (event: ClipboardEvent, editor: LexicalEditor) => PasteUnfurlingTransformResult<ExtraDataType, NodePropsType> | Promise<PasteUnfurlingTransformResult<ExtraDataType, NodePropsType>>;
-
-export declare type PasteUnfurlingTransformResult<ExtraDataType, NodePropsType> = {
-    handled: boolean;
-    transformedParts?: PasteUnfurlingTransformedPart<ExtraDataType, NodePropsType>[];
-};
-
-export declare function registerPasteUnfurlingPlugin<ExtraDataType, NodePropsType>(editor: LexicalEditor, props: PasteUnfurlingPluginBaseProps<ExtraDataType, NodePropsType>): () => void;
-
-export declare const SENTINEL_VALUE = "\u200B\u200C";
-
-export declare class SentinelNode extends TextNode {
-    constructor(key?: NodeKey);
-    static getType(): string;
-    static clone(node: SentinelNode): SentinelNode;
-    createDOM(config: EditorConfig): HTMLElement;
-    isToken(): boolean;
-    exportJSON(): SerializedTextNode;
-    static importJSON(serializedNode: SerializedTextNode): SentinelNode;
-}
-
-export { }

package/lib/BasicFunctionality/BasicFunctionality.base.js

@@ -1,107 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { COMMAND_PRIORITY_HIGH } from '@fluentui-copilot/text-editor';
-import { $getRoot, $getSelection, $isRangeSelection, INSERT_PARAGRAPH_COMMAND, KEY_ENTER_COMMAND, PASTE_COMMAND, mergeRegister } from '@fluentui-copilot/text-editor';
-import { SENTINEL_VALUE } from './SentinelNode';
-import { registerSentinelNodeHandlers } from './SentinelNodeHandlers';
-function isClipboardEvent(event) {
-    return event.type === 'paste';
-}
-function getTextFromEditorState(state) {
-    // Remove the sentinel node whenever getting the text
-    return state.read(()=>$getRoot().getTextContent()).replace(SENTINEL_VALUE, '');
-}
-export class BasicFunctionalityBase {
-    __enterHandler(event) {
-        const selection = $getSelection();
-        if (!$isRangeSelection(selection)) {
-            return false;
-        }
-        if (event === null) {
-            return false;
-        }
-        event.preventDefault();
-        if (event.shiftKey) {
-            return this.__editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);
-        }
-        // Mark event handled to override default behavior
-        return true;
-    }
-    activateContentCallbacks(onContentChange, onCountChanged) {
-        this.deactivateContentCallbacks();
-        this.__contentChangeCleanup = this.__editor.registerUpdateListener(({ editorState, prevEditorState, tags })=>{
-            const prevText = getTextFromEditorState(prevEditorState);
-            const newText = getTextFromEditorState(editorState);
-            // If the text has not changed, don't trigger callbacks
-            if (prevText === newText) {
-                return;
-            }
-            onContentChange === null || onContentChange === void 0 ? void 0 : onContentChange(newText);
-            onCountChanged === null || onCountChanged === void 0 ? void 0 : onCountChanged(newText.length);
-        });
-    }
-    deactivateContentCallbacks() {
-        var _this___contentChangeCleanup, _this;
-        (_this___contentChangeCleanup = (_this = this).__contentChangeCleanup) === null || _this___contentChangeCleanup === void 0 ? void 0 : _this___contentChangeCleanup.call(_this);
-        this.__contentChangeCleanup = undefined;
-    }
-    activatePasteCallback(onPaste) {
-        this.__pasteHandlerCleanup = this.__editor.registerCommand(PASTE_COMMAND, (event)=>{
-            if (!isClipboardEvent(event)) {
-                return false;
-            }
-            onPaste(event);
-            if (event.defaultPrevented) {
-                return true;
-            }
-            return false;
-        }, COMMAND_PRIORITY_HIGH);
-    }
-    deactivatePasteCallback() {
-        var _this___pasteHandlerCleanup, _this;
-        (_this___pasteHandlerCleanup = (_this = this).__pasteHandlerCleanup) === null || _this___pasteHandlerCleanup === void 0 ? void 0 : _this___pasteHandlerCleanup.call(_this);
-        this.__pasteHandlerCleanup = undefined;
-    }
-    activateTrimWhitespace() {
-        this.deactivateTrimWhitespace();
-        this.__trimWhitespaceCleanup = this.__editor.registerTextContentListener((text)=>{
-            if (text.trim() === '') {
-                this.__editor.update(()=>{
-                    $getRoot().getAllTextNodes().forEach((node)=>{
-                        node.remove();
-                    });
-                }, // Don't allow undoing this action
-                {
-                    tag: 'historic'
-                });
-            }
-        });
-    }
-    deactivateTrimWhitespace() {
-        var _this___trimWhitespaceCleanup, _this;
-        (_this___trimWhitespaceCleanup = (_this = this).__trimWhitespaceCleanup) === null || _this___trimWhitespaceCleanup === void 0 ? void 0 : _this___trimWhitespaceCleanup.call(_this);
-        this.__trimWhitespaceCleanup = undefined;
-    }
-    setIsDisabled(isDisabled) {
-        this.__editor.setEditable(!isDisabled);
-    }
-    cleanup() {
-        var _this___baseHandlersCleanup, _this;
-        this.deactivateContentCallbacks();
-        this.deactivateTrimWhitespace();
-        this.deactivatePasteCallback();
-        (_this___baseHandlersCleanup = (_this = this).__baseHandlersCleanup) === null || _this___baseHandlersCleanup === void 0 ? void 0 : _this___baseHandlersCleanup.call(_this);
-        this.__baseHandlersCleanup = undefined;
-    }
-    constructor(editor, isSentinelNodeEnabled = true){
-        _define_property(this, "__editor", void 0);
-        _define_property(this, "__contentChangeCleanup", void 0);
-        _define_property(this, "__trimWhitespaceCleanup", void 0);
-        _define_property(this, "__baseHandlersCleanup", void 0);
-        _define_property(this, "__pasteHandlerCleanup", void 0);
-        this.__editor = editor;
-        this.__baseHandlersCleanup = mergeRegister(this.__editor.registerCommand(KEY_ENTER_COMMAND, this.__enterHandler.bind(this), COMMAND_PRIORITY_HIGH), isSentinelNodeEnabled ? registerSentinelNodeHandlers(editor) : noop);
-    }
-}
-function noop() {
-    return;
-}

package/lib/BasicFunctionality/BasicFunctionality.base.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["BasicFunctionality.base.ts"],"sourcesContent":["import type { EditorState, LexicalEditor } from '@fluentui-copilot/text-editor';\nimport { COMMAND_PRIORITY_HIGH } from '@fluentui-copilot/text-editor';\nimport {\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  INSERT_PARAGRAPH_COMMAND,\n  KEY_ENTER_COMMAND,\n  PASTE_COMMAND,\n  mergeRegister,\n} from '@fluentui-copilot/text-editor';\nimport { SENTINEL_VALUE } from './SentinelNode';\nimport { registerSentinelNodeHandlers } from './SentinelNodeHandlers';\n\nfunction isClipboardEvent(event: ClipboardEvent | KeyboardEvent | InputEvent): event is ClipboardEvent {\n  return event.type === 'paste';\n}\n\nexport interface IBasicFunctionalityBase {\n  setIsDisabled: (isDisabled: boolean) => void;\n  activateContentCallbacks(onContentChange?: (value: string) => void, onCountChanged?: (count: number) => void): void;\n  deactivateContentCallbacks(): void;\n  activateTrimWhitespace(): void;\n  deactivateTrimWhitespace(): void;\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void): void;\n  deactivatePasteCallback(): void;\n  cleanup(): void;\n}\n\nfunction getTextFromEditorState(state: EditorState): string {\n  // Remove the sentinel node whenever getting the text\n  return state.read(() => $getRoot().getTextContent()).replace(SENTINEL_VALUE, '');\n}\n\nexport class BasicFunctionalityBase implements IBasicFunctionalityBase {\n  private __editor: LexicalEditor;\n  private __contentChangeCleanup?: () => void;\n  private __trimWhitespaceCleanup?: () => void;\n  private __baseHandlersCleanup?: () => void;\n  private __pasteHandlerCleanup?: () => void;\n\n  private __enterHandler(event: KeyboardEvent) {\n    const selection = $getSelection();\n    if (!$isRangeSelection(selection)) {\n      return false;\n    }\n\n    if (event === null) {\n      return false;\n    }\n\n    event.preventDefault();\n\n    if (event.shiftKey) {\n      return this.__editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);\n    }\n\n    // Mark event handled to override default behavior\n    return true;\n  }\n\n  constructor(editor: LexicalEditor, isSentinelNodeEnabled = true) {\n    this.__editor = editor;\n\n    this.__baseHandlersCleanup = mergeRegister(\n      this.__editor.registerCommand(KEY_ENTER_COMMAND, this.__enterHandler.bind(this), COMMAND_PRIORITY_HIGH),\n      isSentinelNodeEnabled ? registerSentinelNodeHandlers(editor) : noop,\n    );\n  }\n\n  activateContentCallbacks(\n    onContentChange?: ((value: string) => void) | undefined,\n    onCountChanged?: ((count: number) => void) | undefined,\n  ) {\n    this.deactivateContentCallbacks();\n    this.__contentChangeCleanup = this.__editor.registerUpdateListener(({ editorState, prevEditorState, tags }) => {\n      const prevText = getTextFromEditorState(prevEditorState);\n      const newText = getTextFromEditorState(editorState);\n\n      // If the text has not changed, don't trigger callbacks\n      if (prevText === newText) {\n        return;\n      }\n\n      onContentChange?.(newText);\n      onCountChanged?.(newText.length);\n    });\n  }\n\n  deactivateContentCallbacks() {\n    this.__contentChangeCleanup?.();\n    this.__contentChangeCleanup = undefined;\n  }\n\n  activatePasteCallback(onPaste: (event: ClipboardEvent) => void) {\n    this.__pasteHandlerCleanup = this.__editor.registerCommand(\n      PASTE_COMMAND,\n      (event: ClipboardEvent | KeyboardEvent | InputEvent) => {\n        if (!isClipboardEvent(event)) {\n          return false;\n        }\n\n        onPaste(event);\n\n        if (event.defaultPrevented) {\n          return true;\n        }\n\n        return false;\n      },\n      COMMAND_PRIORITY_HIGH,\n    );\n  }\n\n  deactivatePasteCallback() {\n    this.__pasteHandlerCleanup?.();\n    this.__pasteHandlerCleanup = undefined;\n  }\n\n  activateTrimWhitespace() {\n    this.deactivateTrimWhitespace();\n    this.__trimWhitespaceCleanup = this.__editor.registerTextContentListener(text => {\n      if (text.trim() === '') {\n        this.__editor.update(\n          () => {\n            $getRoot()\n              .getAllTextNodes()\n              .forEach(node => {\n                node.remove();\n              });\n          },\n          // Don't allow undoing this action\n          { tag: 'historic' },\n        );\n      }\n    });\n  }\n\n  deactivateTrimWhitespace() {\n    this.__trimWhitespaceCleanup?.();\n    this.__trimWhitespaceCleanup = undefined;\n  }\n\n  setIsDisabled(isDisabled: boolean) {\n    this.__editor.setEditable(!isDisabled);\n  }\n\n  cleanup() {\n    this.deactivateContentCallbacks();\n    this.deactivateTrimWhitespace();\n    this.deactivatePasteCallback();\n    this.__baseHandlersCleanup?.();\n    this.__baseHandlersCleanup = undefined;\n  }\n}\n\nfunction noop() {\n  return;\n}\n"],"names":["COMMAND_PRIORITY_HIGH","$getRoot","$getSelection","$isRangeSelection","INSERT_PARAGRAPH_COMMAND","KEY_ENTER_COMMAND","PASTE_COMMAND","mergeRegister","SENTINEL_VALUE","registerSentinelNodeHandlers","isClipboardEvent","event","type","getTextFromEditorState","state","read","getTextContent","replace","BasicFunctionalityBase","__enterHandler","selection","preventDefault","shiftKey","__editor","dispatchCommand","undefined","activateContentCallbacks","onContentChange","onCountChanged","deactivateContentCallbacks","__contentChangeCleanup","registerUpdateListener","editorState","prevEditorState","tags","prevText","newText","length","activatePasteCallback","onPaste","__pasteHandlerCleanup","registerCommand","defaultPrevented","deactivatePasteCallback","activateTrimWhitespace","deactivateTrimWhitespace","__trimWhitespaceCleanup","registerTextContentListener","text","trim","update","getAllTextNodes","forEach","node","remove","tag","setIsDisabled","isDisabled","setEditable","cleanup","__baseHandlersCleanup","constructor","editor","isSentinelNodeEnabled","bind","noop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/BasicFunctionality/SentinelNode.js

@@ -1,41 +0,0 @@
-import { TextNode } from '@fluentui-copilot/text-editor';
-// 2 zero width characters will not be visible in the editor.
-// \u200b is the zero width space character which can allow line wrapping in a word
-// \u200c is the zero width non-joiner character which prevents ligatures from connecting the two surrounding characters
-// These two characters together are a no-op and should not be present together in any legitimate user input.
-export const SENTINEL_VALUE = '\u200b\u200c';
-export class SentinelNode extends TextNode {
-    static getType() {
-        return 'sentinel';
-    }
-    static clone(node) {
-        return new SentinelNode(node.__key);
-    }
-    createDOM(config) {
-        const element = super.createDOM(config);
-        element.ariaHidden = 'true';
-        return element;
-    }
-    isToken() {
-        return true;
-    }
-    exportJSON() {
-        return {
-            ...super.exportJSON(),
-            type: 'sentinel',
-            version: 1
-        };
-    }
-    static importJSON(serializedNode) {
-        return $createSentinelNode();
-    }
-    constructor(key){
-        super(SENTINEL_VALUE, key);
-    }
-}
-export function $createSentinelNode(key) {
-    return new SentinelNode(key);
-}
-export function $isSentinelNode(node) {
-    return node instanceof SentinelNode;
-}

package/lib/BasicFunctionality/SentinelNode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["SentinelNode.ts"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedTextNode } from '@fluentui-copilot/text-editor';\nimport { TextNode } from '@fluentui-copilot/text-editor';\n\n// 2 zero width characters will not be visible in the editor.\n// \\u200b is the zero width space character which can allow line wrapping in a word\n// \\u200c is the zero width non-joiner character which prevents ligatures from connecting the two surrounding characters\n// These two characters together are a no-op and should not be present together in any legitimate user input.\nexport const SENTINEL_VALUE = '\\u200b\\u200c';\n\nexport class SentinelNode extends TextNode {\n  constructor(key?: NodeKey) {\n    super(SENTINEL_VALUE, key);\n  }\n\n  static getType() {\n    return 'sentinel';\n  }\n  static clone(node: SentinelNode) {\n    return new SentinelNode(node.__key);\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = super.createDOM(config);\n    element.ariaHidden = 'true';\n    return element;\n  }\n\n  isToken() {\n    return true;\n  }\n\n  exportJSON(): SerializedTextNode {\n    return {\n      ...super.exportJSON(),\n      type: 'sentinel',\n      version: 1,\n    };\n  }\n\n  static importJSON(serializedNode: SerializedTextNode): SentinelNode {\n    return $createSentinelNode();\n  }\n}\n\nexport function $createSentinelNode(key?: NodeKey) {\n  return new SentinelNode(key);\n}\n\nexport function $isSentinelNode(node: LexicalNode | null): node is SentinelNode {\n  return node instanceof SentinelNode;\n}\n"],"names":["TextNode","SENTINEL_VALUE","SentinelNode","getType","clone","node","__key","createDOM","config","element","ariaHidden","isToken","exportJSON","type","version","importJSON","serializedNode","$createSentinelNode","constructor","key","$isSentinelNode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AACA,SAASA,QAAQ,QAAQ,gCAAgC;AAEzD,6DAA6D;AAC7D,mFAAmF;AACnF,wHAAwH;AACxH,6GAA6G;AAC7G,OAAO,MAAMC,iBAAiB,eAAe;AAE7C,OAAO,MAAMC,qBAAqBF;IAKhC,OAAOG,UAAU;QACf,OAAO;IACT;IACA,OAAOC,MAAMC,IAAkB,EAAE;QAC/B,OAAO,IAAIH,aAAaG,KAAKC,KAAK;IACpC;IAEAC,UAAUC,MAAoB,EAAe;QAC3C,MAAMC,UAAU,KAAK,CAACF,UAAUC;QAChCC,QAAQC,UAAU,GAAG;QACrB,OAAOD;IACT;IAEAE,UAAU;QACR,OAAO;IACT;IAEAC,aAAiC;QAC/B,OAAO;YACL,GAAG,KAAK,CAACA,YAAY;YACrBC,MAAM;YACNC,SAAS;QACX;IACF;IAEA,OAAOC,WAAWC,cAAkC,EAAgB;QAClE,OAAOC;IACT;IA/BAC,YAAYC,GAAa,CAAE;QACzB,KAAK,CAAClB,gBAAgBkB;IACxB;AA8BF;AAEA,OAAO,SAASF,oBAAoBE,GAAa;IAC/C,OAAO,IAAIjB,aAAaiB;AAC1B;AAEA,OAAO,SAASC,gBAAgBf,IAAwB;IACtD,OAAOA,gBAAgBH;AACzB"}

package/lib/BasicFunctionality/SentinelNodeHandlers.js

@@ -1,79 +0,0 @@
-import { $getLeafNodes, $getNodeByKey, $getRoot, $getSelection, $isRangeSelection, $normalizeSelection__EXPERIMENTAL, $setSelection, mergeRegister } from '@fluentui-copilot/text-editor';
-import { $isSentinelNode, $createSentinelNode, SentinelNode } from './SentinelNode';
-export function registerSentinelNodeHandlers(editor) {
-    // Add a sentinel node at the end of the input when there is content.
-    // This sentinel node fixes a number of issues.
-    // In Safari, Lexical's behaviour of adding <br /> tags to the end of the input when it ends
-    // in a decorator node causes cursor location issues: https://github.com/facebook/lexical/issues/4487
-    // Otherwise, when a decorator node is the last node in the input, the cursor can't move past it.
-    // Adding an invisible text node that doesn't contribute to the content and can't be selected to the end of the input
-    // mitigates these issues.
-    const sentinelNodeUpdateHandler = ({ editorState })=>{
-        editorState.read(()=>{
-            const leaves = $getLeafNodes($getRoot());
-            if (leaves.length === 0) {
-                return;
-            }
-            const lastNode = leaves[leaves.length - 1];
-            const lastNodeKey = lastNode.getKey();
-            // If the last node isn't a sentinel, add one
-            if (!$isSentinelNode(lastNode)) {
-                editor.update(()=>{
-                    var // We find the node by its key again in case the node was removed before this update runs
-                    _$getNodeByKey;
-                    (_$getNodeByKey = $getNodeByKey(lastNodeKey)) === null || _$getNodeByKey === void 0 ? void 0 : _$getNodeByKey.insertAfter($createSentinelNode());
-                }, // historic tag prevents every sentinel node addition from being added to LexicalHistoryPlugin undo stack
-                {
-                    discrete: true,
-                    tag: 'historic'
-                });
-                return;
-            }
-            // If the sentinel node is not selected, we're done
-            const previous = lastNode.getPreviousSibling();
-            if (!previous || !lastNode.isSelected()) {
-                return;
-            }
-            const selection = $getSelection();
-            if (!$isRangeSelection(selection)) {
-                return;
-            }
-            // If the cursor is inside the sentinel node, move it out (next to the beginning)
-            // We allow selection on the boundary of the sentinel in case the adjacent node is a decorator node
-            // where selection is ill-defined.
-            if (selection.isCollapsed() && selection.anchor.offset > 0) {
-                editor.update(()=>{
-                    var _$getNodeByKey;
-                    (_$getNodeByKey = $getNodeByKey(lastNodeKey)) === null || _$getNodeByKey === void 0 ? void 0 : _$getNodeByKey.selectStart();
-                });
-                return;
-            }
-            // If the selection is a range which includes the sentinel, modify the range to exclude it
-            if (!selection.isCollapsed()) {
-                let selectionChanged = false;
-                const newSelection = selection.clone();
-                if (newSelection.anchor.getNode() === lastNode && newSelection.anchor.offset > 0) {
-                    newSelection.anchor.set(lastNodeKey, 0, 'text');
-                    selectionChanged = true;
-                }
-                if (newSelection.focus.getNode() === lastNode && newSelection.focus.offset > 0) {
-                    newSelection.focus.set(lastNodeKey, 0, 'text');
-                    selectionChanged = true;
-                }
-                if (selectionChanged) {
-                    editor.update(()=>{
-                        if ($getNodeByKey(lastNodeKey) !== null) {
-                            $setSelection($normalizeSelection__EXPERIMENTAL(newSelection));
-                        }
-                    });
-                }
-            }
-        });
-    };
-    return mergeRegister(editor.registerUpdateListener(sentinelNodeUpdateHandler), editor.registerNodeTransform(SentinelNode, (node)=>{
-        if (!node.getPreviousSibling() || node.getNextSibling()) {
-            node.remove();
-            return;
-        }
-    }));
-}

package/lib/BasicFunctionality/SentinelNodeHandlers.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["SentinelNodeHandlers.ts"],"sourcesContent":["import type {\n  LexicalEditor,\n  UpdateListener} from '@fluentui-copilot/text-editor';\nimport {\n  $getLeafNodes,\n  $getNodeByKey,\n  $getRoot,\n  $getSelection,\n  $isRangeSelection,\n  $normalizeSelection__EXPERIMENTAL,\n  $setSelection,\n  mergeRegister\n} from '@fluentui-copilot/text-editor';\nimport { $isSentinelNode, $createSentinelNode, SentinelNode } from './SentinelNode';\n\nexport function registerSentinelNodeHandlers(editor: LexicalEditor) {\n  // Add a sentinel node at the end of the input when there is content.\n  // This sentinel node fixes a number of issues.\n  // In Safari, Lexical's behaviour of adding <br /> tags to the end of the input when it ends\n  // in a decorator node causes cursor location issues: https://github.com/facebook/lexical/issues/4487\n  // Otherwise, when a decorator node is the last node in the input, the cursor can't move past it.\n  // Adding an invisible text node that doesn't contribute to the content and can't be selected to the end of the input\n  // mitigates these issues.\n  const sentinelNodeUpdateHandler: UpdateListener = ({ editorState }) => {\n    editorState.read(() => {\n      const leaves = $getLeafNodes($getRoot());\n      if (leaves.length === 0) {\n        return;\n      }\n\n      const lastNode = leaves[leaves.length - 1];\n      const lastNodeKey = lastNode.getKey();\n\n      // If the last node isn't a sentinel, add one\n      if (!$isSentinelNode(lastNode)) {\n        editor.update(\n          () => {\n            // We find the node by its key again in case the node was removed before this update runs\n            $getNodeByKey(lastNodeKey)?.insertAfter($createSentinelNode());\n          },\n          // historic tag prevents every sentinel node addition from being added to LexicalHistoryPlugin undo stack\n          { discrete: true, tag: 'historic' },\n        );\n        return;\n      }\n\n      // If the sentinel node is not selected, we're done\n      const previous = lastNode.getPreviousSibling();\n      if (!previous || !lastNode.isSelected()) {\n        return;\n      }\n\n      const selection = $getSelection();\n      if (!$isRangeSelection(selection)) {\n        return;\n      }\n\n      // If the cursor is inside the sentinel node, move it out (next to the beginning)\n      // We allow selection on the boundary of the sentinel in case the adjacent node is a decorator node\n      // where selection is ill-defined.\n      if (selection.isCollapsed() && selection.anchor.offset > 0) {\n        editor.update(() => {\n          $getNodeByKey(lastNodeKey)?.selectStart();\n        });\n        return;\n      }\n\n      // If the selection is a range which includes the sentinel, modify the range to exclude it\n      if (!selection.isCollapsed()) {\n        let selectionChanged = false;\n        const newSelection = selection.clone();\n\n        if (newSelection.anchor.getNode() === lastNode && newSelection.anchor.offset > 0) {\n          newSelection.anchor.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n        if (newSelection.focus.getNode() === lastNode && newSelection.focus.offset > 0) {\n          newSelection.focus.set(lastNodeKey, 0, 'text');\n          selectionChanged = true;\n        }\n\n        if (selectionChanged) {\n          editor.update(() => {\n            if ($getNodeByKey(lastNodeKey) !== null) {\n              $setSelection($normalizeSelection__EXPERIMENTAL(newSelection));\n            }\n          });\n        }\n      }\n    });\n  };\n\n  return mergeRegister(\n    editor.registerUpdateListener(sentinelNodeUpdateHandler),\n    editor.registerNodeTransform(SentinelNode, node => {\n      if (!node.getPreviousSibling() || node.getNextSibling()) {\n        node.remove();\n        return;\n      }\n    }),\n  );\n}\n"],"names":["$getLeafNodes","$getNodeByKey","$getRoot","$getSelection","$isRangeSelection","$normalizeSelection__EXPERIMENTAL","$setSelection","mergeRegister","$isSentinelNode","$createSentinelNode","SentinelNode","registerSentinelNodeHandlers","editor","sentinelNodeUpdateHandler","editorState","read","leaves","length","lastNode","lastNodeKey","getKey","update","insertAfter","discrete","tag","previous","getPreviousSibling","isSelected","selection","isCollapsed","anchor","offset","selectStart","selectionChanged","newSelection","clone","getNode","set","focus","registerUpdateListener","registerNodeTransform","node","getNextSibling","remove"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAGA,SACEA,aAAa,EACbC,aAAa,EACbC,QAAQ,EACRC,aAAa,EACbC,iBAAiB,EACjBC,iCAAiC,EACjCC,aAAa,EACbC,aAAa,QACR,gCAAgC;AACvC,SAASC,eAAe,EAAEC,mBAAmB,EAAEC,YAAY,QAAQ,iBAAiB;AAEpF,OAAO,SAASC,6BAA6BC,MAAqB;IAChE,qEAAqE;IACrE,+CAA+C;IAC/C,4FAA4F;IAC5F,qGAAqG;IACrG,iGAAiG;IACjG,qHAAqH;IACrH,0BAA0B;IAC1B,MAAMC,4BAA4C,CAAC,EAAEC,WAAW,EAAE;QAChEA,YAAYC,IAAI,CAAC;YACf,MAAMC,SAAShB,cAAcE;YAC7B,IAAIc,OAAOC,MAAM,KAAK,GAAG;gBACvB;YACF;YAEA,MAAMC,WAAWF,MAAM,CAACA,OAAOC,MAAM,GAAG,EAAE;YAC1C,MAAME,cAAcD,SAASE,MAAM;YAEnC,6CAA6C;YAC7C,IAAI,CAACZ,gBAAgBU,WAAW;gBAC9BN,OAAOS,MAAM,CACX;wBACE,yFAAyF;oBACzFpB;qBAAAA,iBAAAA,cAAckB,0BAAdlB,qCAAAA,eAA4BqB,WAAW,CAACb;gBAC1C,GACA,yGAAyG;gBACzG;oBAAEc,UAAU;oBAAMC,KAAK;gBAAW;gBAEpC;YACF;YAEA,mDAAmD;YACnD,MAAMC,WAAWP,SAASQ,kBAAkB;YAC5C,IAAI,CAACD,YAAY,CAACP,SAASS,UAAU,IAAI;gBACvC;YACF;YAEA,MAAMC,YAAYzB;YAClB,IAAI,CAACC,kBAAkBwB,YAAY;gBACjC;YACF;YAEA,iFAAiF;YACjF,mGAAmG;YACnG,kCAAkC;YAClC,IAAIA,UAAUC,WAAW,MAAMD,UAAUE,MAAM,CAACC,MAAM,GAAG,GAAG;gBAC1DnB,OAAOS,MAAM,CAAC;wBACZpB;qBAAAA,iBAAAA,cAAckB,0BAAdlB,qCAAAA,eAA4B+B,WAAW;gBACzC;gBACA;YACF;YAEA,0FAA0F;YAC1F,IAAI,CAACJ,UAAUC,WAAW,IAAI;gBAC5B,IAAII,mBAAmB;gBACvB,MAAMC,eAAeN,UAAUO,KAAK;gBAEpC,IAAID,aAAaJ,MAAM,CAACM,OAAO,OAAOlB,YAAYgB,aAAaJ,MAAM,CAACC,MAAM,GAAG,GAAG;oBAChFG,aAAaJ,MAAM,CAACO,GAAG,CAAClB,aAAa,GAAG;oBACxCc,mBAAmB;gBACrB;gBACA,IAAIC,aAAaI,KAAK,CAACF,OAAO,OAAOlB,YAAYgB,aAAaI,KAAK,CAACP,MAAM,GAAG,GAAG;oBAC9EG,aAAaI,KAAK,CAACD,GAAG,CAAClB,aAAa,GAAG;oBACvCc,mBAAmB;gBACrB;gBAEA,IAAIA,kBAAkB;oBACpBrB,OAAOS,MAAM,CAAC;wBACZ,IAAIpB,cAAckB,iBAAiB,MAAM;4BACvCb,cAAcD,kCAAkC6B;wBAClD;oBACF;gBACF;YACF;QACF;IACF;IAEA,OAAO3B,cACLK,OAAO2B,sBAAsB,CAAC1B,4BAC9BD,OAAO4B,qBAAqB,CAAC9B,cAAc+B,CAAAA;QACzC,IAAI,CAACA,KAAKf,kBAAkB,MAAMe,KAAKC,cAAc,IAAI;YACvDD,KAAKE,MAAM;YACX;QACF;IACF;AAEJ"}

package/lib/BasicFunctionality/index.js

@@ -1,2 +0,0 @@
-export { BasicFunctionalityBase } from './BasicFunctionality.base';
-export { $createSentinelNode, $isSentinelNode, SENTINEL_VALUE, SentinelNode } from './SentinelNode';

package/lib/BasicFunctionality/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export type { IBasicFunctionalityBase } from './BasicFunctionality.base';\nexport { BasicFunctionalityBase } from './BasicFunctionality.base';\nexport { $createSentinelNode, $isSentinelNode, SENTINEL_VALUE, SentinelNode } from './SentinelNode';\n"],"names":["BasicFunctionalityBase","$createSentinelNode","$isSentinelNode","SENTINEL_VALUE","SentinelNode"],"rangeMappings":";","mappings":"AACA,SAASA,sBAAsB,QAAQ,4BAA4B;AACnE,SAASC,mBAAmB,EAAEC,eAAe,EAAEC,cAAc,EAAEC,YAAY,QAAQ,iBAAiB"}

package/lib/ChatInputEntity/ChatInputEntityPlugin.base.js

@@ -1,117 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { $createParagraphNode, $createTextNode, $getNodeByKey, $getSelection, $insertNodes, $isDecoratorNode, $isRangeSelection, $isRootOrShadowRoot, $nodesOfType, $wrapNodeInElement, COMMAND_PRIORITY_CRITICAL, DELETE_CHARACTER_COMMAND, mergeRegister } from '@fluentui-copilot/text-editor';
-export class ChatInputEntityPluginBase {
-    cleanup() {
-        this._cleanup();
-    }
-    insertChatInputEntity(props) {
-        let key = undefined;
-        this.__editor.update(()=>{
-            const { text, data, entityProps } = props;
-            const entityNode = this.__$createNode(this.__id, text, data, entityProps);
-            $insertNodes([
-                entityNode
-            ]);
-            entityNode.selectEnd();
-            if ($isRootOrShadowRoot(entityNode.getParentOrThrow())) {
-                $wrapNodeInElement(entityNode, $createParagraphNode).selectEnd();
-            }
-            key = entityNode.getKey();
-        });
-        return key;
-    }
-    removeChatInputEntity(keyOrPredicate) {
-        this.__editor.update(()=>{
-            if (typeof keyOrPredicate === 'function') {
-                $nodesOfType(this.__nodeClass).filter((node, i)=>node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i)).forEach((node)=>node.remove());
-            } else {
-                var _$getNodeByKey;
-                (_$getNodeByKey = $getNodeByKey(keyOrPredicate)) === null || _$getNodeByKey === void 0 ? void 0 : _$getNodeByKey.remove();
-            }
-        });
-    }
-    updateChatInputEntityProps(keyOrPredicate, props) {
-        const updateNode = (node)=>{
-            const newProps = typeof props === 'function' ? props(node.getEntityData()) : props;
-            node.updateEntityData(newProps);
-        };
-        this.__editor.update(()=>{
-            if (typeof keyOrPredicate === 'function') {
-                $nodesOfType(this.__nodeClass).filter((node, i)=>node.__pluginId === this.__id && keyOrPredicate(node.getEntityData(), i)).forEach(updateNode);
-            } else {
-                const node = $getNodeByKey(keyOrPredicate);
-                if (node) {
-                    updateNode(node);
-                }
-            }
-        }, {
-            tag: 'historic'
-        });
-    }
-    getActiveEntities() {
-        return this.__editor.getEditorState().read(()=>$nodesOfType(this.__nodeClass).filter((node)=>node.__pluginId === this.__id).map((node)=>node.getEntityData()));
-    }
-    constructor(editor, id, nodeClass, $createNode, $isChatInputEntityNode, onChatInputEntityAdded, onChatInputEntityDeleted){
-        _define_property(this, "__nodeClass", void 0);
-        _define_property(this, "__editor", void 0);
-        _define_property(this, "__id", void 0);
-        _define_property(this, "__deleteDirection", null);
-        _define_property(this, "__$createNode", void 0);
-        _define_property(this, "_cleanup", void 0);
-        this.__$createNode = $createNode;
-        this.__editor = editor;
-        this.__id = id;
-        this.__nodeClass = nodeClass;
-        this._cleanup = mergeRegister(// Keep track of delete direction so we know where to put the selection after adding back a space
-        editor.registerCommand(DELETE_CHARACTER_COMMAND, (isBackward)=>{
-            this.__deleteDirection = isBackward ? 'backward' : 'forward';
-            return false;
-        }, COMMAND_PRIORITY_CRITICAL), // Always maintain a space before, after, and between entities in order for selection to work properly
-        editor.registerNodeTransform(this.__nodeClass, (node)=>{
-            const nextSibling = node.getNextSibling();
-            if (!nextSibling || $isDecoratorNode(nextSibling)) {
-                const selection = $getSelection();
-                // If selection is between the two nodes, that means the user is trying to delete the space
-                // If they deleted to the left, we should move the cursor to the end of the entity
-                // If they delete to the right, we should move the cursor to the end of the newly added space
-                // This mimics changing the delete into a cursor move action
-                const shouldMoveSelection = selection && $isRangeSelection(selection) && selection.isCollapsed() && selection.anchor.offset === node.getIndexWithinParent() + 1;
-                const text = $createTextNode(' ');
-                node.insertAfter(text);
-                if (shouldMoveSelection) {
-                    if (this.__deleteDirection === 'forward') {
-                        text.selectEnd();
-                    } else {
-                        node.selectEnd();
-                    }
-                }
-            }
-            // In the case the entity is the first node, we need a space before it.
-            if (!node.getPreviousSibling()) {
-                const text = $createTextNode(' ');
-                node.insertBefore(text);
-            }
-        }), onChatInputEntityAdded || onChatInputEntityDeleted ? editor.registerMutationListener(this.__nodeClass, (nodes, payload)=>{
-            for (const [nodeKey, mutation] of nodes){
-                if (onChatInputEntityDeleted && mutation === 'destroyed') {
-                    payload.prevEditorState.read(()=>{
-                        const node = $getNodeByKey(nodeKey);
-                        if ($isChatInputEntityNode(node) && node.__pluginId === id) {
-                            onChatInputEntityDeleted(node.getEntityData(), nodeKey);
-                        }
-                    });
-                } else if (onChatInputEntityAdded && mutation === 'created') {
-                    editor.getEditorState().read(()=>{
-                        const node = $getNodeByKey(nodeKey);
-                        if ($isChatInputEntityNode(node) && node.__pluginId === id) {
-                            onChatInputEntityAdded(node.getEntityData(), nodeKey);
-                        }
-                    });
-                }
-            }
-        }) : noop);
-    }
-}
-function noop() {
-    return;
-}