@fluentui-copilot/chat-input-plugins 0.0.0-nightly-20251006-0406-b5da4f6a.1 → 0.0.0-nightly-20251010-0406-7df7c6d1.1

package/lib-commonjs/ManualGhostText/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "ManualGhostTextBase", {
-    enumerable: true,
-    get: function() {
-        return _ManualGhostTextbase.ManualGhostTextBase;
-    }
-});
-const _ManualGhostTextbase = require("./ManualGhostText.base");

package/lib-commonjs/ManualGhostText/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export type { IManualGhostTextBase } from './ManualGhostText.base';\nexport { ManualGhostTextBase } from './ManualGhostText.base';\n"],"names":["ManualGhostTextBase"],"rangeMappings":";;;;;;;;;;","mappings":";;;;+BACSA;;;eAAAA,wCAAmB;;;qCAAQ"}

package/lib-commonjs/PasteUnfurling/PasteUnfurling.base.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "registerPasteUnfurlingPlugin", {
-    enumerable: true,
-    get: function() {
-        return registerPasteUnfurlingPlugin;
-    }
-});
-const _texteditor = require("@fluentui-copilot/text-editor");
-function unhandledPart(part) {
-    throw new Error(`Unhandled part: ${part}`);
-}
-function registerPasteUnfurlingPlugin(editor, props) {
-    const { entityPluginId, transforms, $createEntityNode } = props;
-    function insertParts(parts) {
-        editor.update(()=>{
-            const nodes = parts.map((part)=>{
-                switch(part.type){
-                    case 'entity':
-                        return $createEntityNode(entityPluginId, part.value.text, part.value.data, part.value.entityProps);
-                    case 'text':
-                        return (0, _texteditor.$createTextNode)(part.value);
-                }
-                return unhandledPart(part);
-            });
-            (0, _texteditor.$insertNodes)(nodes);
-        });
-    }
-    function handlePaste(event) {
-        const transformPromises = [];
-        for (const transform of transforms){
-            transformPromises.push(Promise.resolve(transform(event, editor)));
-        }
-        Promise.allSettled(transformPromises).then((results)=>{
-            let handledPaste = false;
-            for (const result of results){
-                if (result.status === 'fulfilled') {
-                    const transformResult = result.value;
-                    if (transformResult.transformedParts) {
-                        insertParts(transformResult.transformedParts);
-                    }
-                    if (transformResult.handled) {
-                        handledPaste = true;
-                        break;
-                    }
-                }
-            }
-            if (!handledPaste) {
-                var _commandsMap_get;
-                const commandsMap = editor._commands;
-                const defaultEditorListeners = (_commandsMap_get = commandsMap.get(_texteditor.PASTE_COMMAND)) === null || _commandsMap_get === void 0 ? void 0 : _commandsMap_get[_texteditor.COMMAND_PRIORITY_EDITOR];
-                if (defaultEditorListeners) {
-                    // After the promises have resolved, we're not guaranteed to be in the same update state as the original command
-                    editor.update(()=>{
-                        for (const listener of defaultEditorListeners){
-                            const defaultHandled = listener(event, editor);
-                            if (defaultHandled) {
-                                break;
-                            }
-                        }
-                    });
-                }
-            }
-        });
-        return true;
-    }
-    return editor.registerCommand(_texteditor.PASTE_COMMAND, handlePaste, _texteditor.COMMAND_PRIORITY_LOW);
-}

package/lib-commonjs/PasteUnfurling/PasteUnfurling.base.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["PasteUnfurling.base.ts"],"sourcesContent":["import type { LexicalEditor } from '@fluentui-copilot/text-editor';\nimport {\n  COMMAND_PRIORITY_EDITOR,\n  COMMAND_PRIORITY_LOW,\n  PASTE_COMMAND,\n  $insertNodes,\n  $createTextNode,\n} from '@fluentui-copilot/text-editor';\nimport type {\n  PasteUnfurlingPluginBaseProps,\n  PasteUnfurlingTransformedPart,\n  PasteUnfurlingTransformResult,\n} from './PasteUnfurling.types';\n\nfunction unhandledPart(part: never): never {\n  throw new Error(`Unhandled part: ${part}`);\n}\n\nexport function registerPasteUnfurlingPlugin<ExtraDataType, NodePropsType>(\n  editor: LexicalEditor,\n  props: PasteUnfurlingPluginBaseProps<ExtraDataType, NodePropsType>,\n): () => void {\n  const { entityPluginId, transforms, $createEntityNode } = props;\n\n  function insertParts(parts: PasteUnfurlingTransformedPart<ExtraDataType, NodePropsType>[]) {\n    editor.update(() => {\n      const nodes = parts.map(part => {\n        switch (part.type) {\n          case 'entity':\n            return $createEntityNode(entityPluginId, part.value.text, part.value.data, part.value.entityProps);\n          case 'text':\n            return $createTextNode(part.value);\n        }\n        return unhandledPart(part);\n      });\n      $insertNodes(nodes);\n    });\n  }\n\n  function handlePaste(event: ClipboardEvent): boolean {\n    const transformPromises: Promise<PasteUnfurlingTransformResult<ExtraDataType, NodePropsType>>[] = [];\n\n    for (const transform of transforms) {\n      transformPromises.push(Promise.resolve(transform(event, editor)));\n    }\n\n    Promise.allSettled(transformPromises).then(results => {\n      let handledPaste = false;\n\n      for (const result of results) {\n        if (result.status === 'fulfilled') {\n          const transformResult = result.value;\n          if (transformResult.transformedParts) {\n            insertParts(transformResult.transformedParts);\n          }\n\n          if (transformResult.handled) {\n            handledPaste = true;\n            break;\n          }\n        }\n      }\n\n      if (!handledPaste) {\n        const commandsMap = editor._commands;\n        const defaultEditorListeners = commandsMap.get(PASTE_COMMAND)?.[COMMAND_PRIORITY_EDITOR];\n        if (defaultEditorListeners) {\n          // After the promises have resolved, we're not guaranteed to be in the same update state as the original command\n          editor.update(() => {\n            for (const listener of defaultEditorListeners) {\n              const defaultHandled = listener(event, editor);\n              if (defaultHandled) {\n                break;\n              }\n            }\n          });\n        }\n      }\n    });\n\n    return true;\n  }\n\n  return editor.registerCommand(PASTE_COMMAND, handlePaste, COMMAND_PRIORITY_LOW);\n}\n"],"names":["registerPasteUnfurlingPlugin","unhandledPart","part","Error","editor","props","entityPluginId","transforms","$createEntityNode","insertParts","parts","update","nodes","map","type","value","text","data","entityProps","$createTextNode","$insertNodes","handlePaste","event","transformPromises","transform","push","Promise","resolve","allSettled","then","results","handledPaste","result","status","transformResult","transformedParts","handled","commandsMap","_commands","defaultEditorListeners","get","PASTE_COMMAND","COMMAND_PRIORITY_EDITOR","listener","defaultHandled","registerCommand","COMMAND_PRIORITY_LOW"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAkBgBA;;;eAAAA;;;4BAXT;AAOP,SAASC,cAAcC,IAAW;IAChC,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAED,KAAK,CAAC;AAC3C;AAEO,SAASF,6BACdI,MAAqB,EACrBC,KAAkE;IAElE,MAAM,EAAEC,cAAc,EAAEC,UAAU,EAAEC,iBAAiB,EAAE,GAAGH;IAE1D,SAASI,YAAYC,KAAoE;QACvFN,OAAOO,MAAM,CAAC;YACZ,MAAMC,QAAQF,MAAMG,GAAG,CAACX,CAAAA;gBACtB,OAAQA,KAAKY,IAAI;oBACf,KAAK;wBACH,OAAON,kBAAkBF,gBAAgBJ,KAAKa,KAAK,CAACC,IAAI,EAAEd,KAAKa,KAAK,CAACE,IAAI,EAAEf,KAAKa,KAAK,CAACG,WAAW;oBACnG,KAAK;wBACH,OAAOC,IAAAA,2BAAAA,EAAgBjB,KAAKa,KAAK;gBACrC;gBACA,OAAOd,cAAcC;YACvB;YACAkB,IAAAA,wBAAAA,EAAaR;QACf;IACF;IAEA,SAASS,YAAYC,KAAqB;QACxC,MAAMC,oBAA4F,EAAE;QAEpG,KAAK,MAAMC,aAAajB,WAAY;YAClCgB,kBAAkBE,IAAI,CAACC,QAAQC,OAAO,CAACH,UAAUF,OAAOlB;QAC1D;QAEAsB,QAAQE,UAAU,CAACL,mBAAmBM,IAAI,CAACC,CAAAA;YACzC,IAAIC,eAAe;YAEnB,KAAK,MAAMC,UAAUF,QAAS;gBAC5B,IAAIE,OAAOC,MAAM,KAAK,aAAa;oBACjC,MAAMC,kBAAkBF,OAAOjB,KAAK;oBACpC,IAAImB,gBAAgBC,gBAAgB,EAAE;wBACpC1B,YAAYyB,gBAAgBC,gBAAgB;oBAC9C;oBAEA,IAAID,gBAAgBE,OAAO,EAAE;wBAC3BL,eAAe;wBACf;oBACF;gBACF;YACF;YAEA,IAAI,CAACA,cAAc;oBAEcM;gBAD/B,MAAMA,cAAcjC,OAAOkC,SAAS;gBACpC,MAAMC,yBAAAA,AAAyBF,CAAAA,mBAAAA,YAAYG,GAAG,CAACC,yBAAAA,CAAAA,MAAAA,QAAhBJ,qBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,gBAAgC,CAACK,mCAAAA,CAAwB;gBACxF,IAAIH,wBAAwB;oBAC1B,gHAAgH;oBAChHnC,OAAOO,MAAM,CAAC;wBACZ,KAAK,MAAMgC,YAAYJ,uBAAwB;4BAC7C,MAAMK,iBAAiBD,SAASrB,OAAOlB;4BACvC,IAAIwC,gBAAgB;gCAClB;4BACF;wBACF;oBACF;gBACF;YACF;QACF;QAEA,OAAO;IACT;IAEA,OAAOxC,OAAOyC,eAAe,CAACJ,yBAAAA,EAAepB,aAAayB,gCAAAA;AAC5D"}

package/lib-commonjs/PasteUnfurling/PasteUnfurling.types.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/lib-commonjs/PasteUnfurling/PasteUnfurling.types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["PasteUnfurling.types.ts"],"sourcesContent":["import type { LexicalEditor, LexicalNode, NodeKey } from '@fluentui-copilot/text-editor';\nimport type { ChatInputEntityData } from '../ChatInputEntity';\n\nexport type PasteUnfurlingTransformedPart<ExtraDataType, NodePropsType> =\n  | { type: 'text'; value: string }\n  | { type: 'entity'; value: ChatInputEntityData<ExtraDataType, NodePropsType> };\n\nexport type PasteUnfurlingTransformResult<ExtraDataType, NodePropsType> = {\n  handled: boolean;\n  transformedParts?: PasteUnfurlingTransformedPart<ExtraDataType, NodePropsType>[];\n};\n\nexport type PasteUnfurlingTransformFunction<ExtraDataType, NodePropsType> = (\n  event: ClipboardEvent,\n  editor: LexicalEditor,\n) =>\n  | PasteUnfurlingTransformResult<ExtraDataType, NodePropsType>\n  | Promise<PasteUnfurlingTransformResult<ExtraDataType, NodePropsType>>;\n\nexport type PasteUnfurlingPluginBaseProps<ExtraDataType, NodePropsType> = {\n  entityPluginId: string;\n  transforms: PasteUnfurlingTransformFunction<ExtraDataType, NodePropsType>[];\n  $createEntityNode: (\n    pluginId: string,\n    text: string,\n    data?: ExtraDataType,\n    entityProps?: NodePropsType,\n    key?: NodeKey,\n  ) => LexicalNode;\n};\n"],"names":[],"rangeMappings":"","mappings":""}

package/lib-commonjs/PasteUnfurling/PasteUnfurlingTestUtils.js

@@ -1,197 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    $createMockEntityNode: function() {
-        return $createMockEntityNode;
-    },
-    $isMockEntityNode: function() {
-        return $isMockEntityNode;
-    },
-    MockClipboardEvent: function() {
-        return MockClipboardEvent;
-    },
-    MockEntityNode: function() {
-        return MockEntityNode;
-    },
-    createPasteEvent: function() {
-        return createPasteEvent;
-    },
-    parseEntity: function() {
-        return parseEntity;
-    },
-    parseLink: function() {
-        return parseLink;
-    },
-    parseLinkPreview: function() {
-        return parseLinkPreview;
-    }
-});
-const _define_property = require("@swc/helpers/_/_define_property");
-const _texteditor = require("@fluentui-copilot/text-editor");
-class MockClipboardEvent extends Event {
-    constructor(...args){
-        super(...args);
-        (0, _define_property._)(this, "clipboardData", null);
-    }
-}
-function createPasteEvent(data) {
-    const event = new MockClipboardEvent('paste');
-    event.clipboardData = {
-        types: [
-            data.map(({ mimeType })=>mimeType)
-        ],
-        getData: (format)=>{
-            const item = data.find(({ mimeType })=>mimeType === format);
-            if (item) {
-                return item.value;
-            }
-            return '';
-        }
-    };
-    return event;
-}
-class MockEntityNode extends _texteditor.TextNode {
-    static getType() {
-        return 'mockEntity';
-    }
-    constructor(text, url){
-        super(text);
-        (0, _define_property._)(this, "url", void 0);
-        this.url = url;
-    }
-}
-function $createMockEntityNode(text, url) {
-    return new MockEntityNode(text, url);
-}
-function $isMockEntityNode(node) {
-    return node instanceof MockEntityNode;
-}
-const parseLinkPreview = (event)=>{
-    let previewData;
-    try {
-        var _event_clipboardData;
-        const previewDataString = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/link-preview');
-        if (previewDataString === undefined || previewDataString === '') {
-            return {
-                handled: false
-            };
-        }
-        previewData = JSON.parse(previewDataString);
-    } catch (e) {
-        return {
-            handled: false
-        };
-    }
-    const title = previewData.title;
-    const url = previewData.url;
-    if (!title || !url) {
-        return {
-            handled: false
-        };
-    }
-    return {
-        handled: true,
-        transformedParts: [
-            {
-                type: 'entity',
-                value: {
-                    text: title,
-                    data: {
-                        url
-                    }
-                }
-            }
-        ]
-    };
-};
-const urlRegex = /(\b(?:https?):\/\/[^\s]+)/gi;
-const parseLink = (event)=>{
-    var _event_clipboardData;
-    const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
-    if (!text) {
-        return {
-            handled: false
-        };
-    }
-    const parts = text.split(urlRegex);
-    // If an entity was found, parts will be at least 3 elements long
-    if (parts.length < 3) {
-        return {
-            handled: false
-        };
-    }
-    const transformedParts = parts.map((str, i)=>{
-        if (i % 2 === 0) {
-            return {
-                type: 'text',
-                value: str
-            };
-        } else {
-            return {
-                type: 'entity',
-                value: {
-                    text: str,
-                    data: {
-                        url: str
-                    }
-                }
-            };
-        }
-    }) // Filter out all the nulls for empty strings
-    .filter((node)=>node !== null);
-    return {
-        handled: true,
-        transformedParts
-    };
-};
-const parseEntity = async (event)=>{
-    var _event_clipboardData;
-    const text = (_event_clipboardData = event.clipboardData) === null || _event_clipboardData === void 0 ? void 0 : _event_clipboardData.getData('text/plain');
-    if (!text) {
-        return {
-            handled: false
-        };
-    }
-    // Assume entities come in the syntax <entity>title</entity>
-    const re = /<entity[^>]*>([^<]*)<\/entity>/g;
-    const parts = text.split(re);
-    // If an entity was found, parts will be at least 3 elements long
-    if (parts.length < 3) {
-        return {
-            handled: false
-        };
-    }
-    // Even elements are text, odd elements are entities
-    // ["", entity, "", entity, "", ...]
-    const transformedParts = parts.map((str, i)=>{
-        if (i % 2 === 0) {
-            return {
-                type: 'text',
-                value: str
-            };
-        } else {
-            return {
-                type: 'entity',
-                value: {
-                    text: str,
-                    data: {
-                        url: str
-                    }
-                }
-            };
-        }
-    }) // Filter out all the nulls for empty strings
-    .filter((node)=>node !== null);
-    return {
-        handled: true,
-        transformedParts
-    };
-};

package/lib-commonjs/PasteUnfurling/PasteUnfurlingTestUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["PasteUnfurlingTestUtils.ts"],"sourcesContent":["import type { LexicalNode } from '@fluentui-copilot/text-editor';\nimport { TextNode } from '@fluentui-copilot/text-editor';\nimport type { PasteUnfurlingTransformedPart, PasteUnfurlingTransformResult } from '..';\n\nexport class MockClipboardEvent extends Event implements ClipboardEvent {\n  clipboardData: DataTransfer | null = null;\n}\n\nexport function createPasteEvent(data: { mimeType: string; value: string }[]) {\n  const event = new MockClipboardEvent('paste');\n\n  event.clipboardData = {\n    types: [data.map(({ mimeType }) => mimeType)],\n    getData: (format: string) => {\n      const item = data.find(({ mimeType }) => mimeType === format);\n      if (item) {\n        return item.value;\n      }\n      return '';\n    },\n  } as unknown as DataTransfer;\n\n  return event;\n}\n\nexport class MockEntityNode extends TextNode {\n  url: string;\n\n  constructor(text: string, url: string) {\n    super(text);\n    this.url = url;\n  }\n\n  static getType(): string {\n    return 'mockEntity';\n  }\n}\n\nexport type ExtraDataType = { url: string };\n\nexport function $createMockEntityNode(text: string, url: string): MockEntityNode {\n  return new MockEntityNode(text, url);\n}\n\nexport function $isMockEntityNode(node: LexicalNode | null | undefined): node is MockEntityNode {\n  return node instanceof MockEntityNode;\n}\n\nexport const parseLinkPreview = (event: ClipboardEvent): PasteUnfurlingTransformResult<ExtraDataType, {}> => {\n  let previewData;\n  try {\n    const previewDataString = event.clipboardData?.getData('text/link-preview');\n    if (previewDataString === undefined || previewDataString === '') {\n      return { handled: false };\n    }\n\n    previewData = JSON.parse(previewDataString);\n  } catch (e) {\n    return { handled: false };\n  }\n\n  const title: string | undefined = previewData.title;\n  const url: string | undefined = previewData.url;\n  if (!title || !url) {\n    return { handled: false };\n  }\n\n  return {\n    handled: true,\n    transformedParts: [{ type: 'entity', value: { text: title, data: { url } } }],\n  };\n};\nconst urlRegex = /(\\b(?:https?):\\/\\/[^\\s]+)/gi;\n\nexport const parseLink = (event: ClipboardEvent): PasteUnfurlingTransformResult<ExtraDataType, {}> => {\n  const text = event.clipboardData?.getData('text/plain');\n  if (!text) {\n    return {\n      handled: false,\n    };\n  }\n\n  const parts = text.split(urlRegex);\n  // If an entity was found, parts will be at least 3 elements long\n  if (parts.length < 3) {\n    return { handled: false };\n  }\n  const transformedParts = parts\n    .map((str, i) => {\n      if (i % 2 === 0) {\n        return { type: 'text', value: str };\n      } else {\n        return {\n          type: 'entity',\n          value: { text: str, data: { url: str } },\n        };\n      }\n    })\n    // Filter out all the nulls for empty strings\n    .filter(node => node !== null) as PasteUnfurlingTransformedPart<ExtraDataType, {}>[];\n\n  return { handled: true, transformedParts };\n};\n\n// A transform can be async in case it needs to fetch data from a server.\nexport const parseEntity = async (event: ClipboardEvent): Promise<PasteUnfurlingTransformResult<ExtraDataType, {}>> => {\n  const text = event.clipboardData?.getData('text/plain');\n  if (!text) {\n    return {\n      handled: false,\n    };\n  }\n\n  // Assume entities come in the syntax <entity>title</entity>\n  const re = /<entity[^>]*>([^<]*)<\\/entity>/g;\n  const parts = text.split(re);\n  // If an entity was found, parts will be at least 3 elements long\n  if (parts.length < 3) {\n    return { handled: false };\n  }\n\n  // Even elements are text, odd elements are entities\n  // [\"\", entity, \"\", entity, \"\", ...]\n  const transformedParts = parts\n    .map((str, i) => {\n      if (i % 2 === 0) {\n        return { type: 'text', value: str };\n      } else {\n        return {\n          type: 'entity',\n          value: { text: str, data: { url: str } },\n        };\n      }\n    })\n    // Filter out all the nulls for empty strings\n    .filter(node => node !== null) as PasteUnfurlingTransformedPart<ExtraDataType, {}>[];\n\n  return { handled: true, transformedParts };\n};\n"],"names":["$createMockEntityNode","$isMockEntityNode","MockClipboardEvent","MockEntityNode","createPasteEvent","parseEntity","parseLink","parseLinkPreview","Event","clipboardData","data","event","types","map","mimeType","getData","format","item","find","value","TextNode","getType","constructor","text","url","node","previewData","previewDataString","undefined","handled","JSON","parse","e","title","transformedParts","type","urlRegex","parts","split","length","str","i","filter","re"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/PasteUnfurling/index.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "registerPasteUnfurlingPlugin", {
-    enumerable: true,
-    get: function() {
-        return _PasteUnfurlingbase.registerPasteUnfurlingPlugin;
-    }
-});
-const _PasteUnfurlingbase = require("./PasteUnfurling.base");

package/lib-commonjs/PasteUnfurling/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export { registerPasteUnfurlingPlugin } from './PasteUnfurling.base';\nexport type { PasteUnfurlingPluginBaseProps, PasteUnfurlingTransformFunction, PasteUnfurlingTransformResult, PasteUnfurlingTransformedPart } from './PasteUnfurling.types';\n"],"names":["registerPasteUnfurlingPlugin"],"rangeMappings":";;;;;;;;;;","mappings":";;;;+BAASA;;;eAAAA,gDAA4B;;;oCAAQ"}

package/lib-commonjs/index.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    $createSentinelNode: function() {
-        return _BasicFunctionality.$createSentinelNode;
-    },
-    $isSentinelNode: function() {
-        return _BasicFunctionality.$isSentinelNode;
-    },
-    BasicFunctionalityBase: function() {
-        return _BasicFunctionality.BasicFunctionalityBase;
-    },
-    ChatInputEntityPluginBase: function() {
-        return _ChatInputEntity.ChatInputEntityPluginBase;
-    },
-    GhostTextPluginBase: function() {
-        return _GhostText.GhostTextPluginBase;
-    },
-    ImperativeControlBase: function() {
-        return _ImperativeControl.ImperativeControlBase;
-    },
-    ManualGhostTextBase: function() {
-        return _ManualGhostText.ManualGhostTextBase;
-    },
-    SENTINEL_VALUE: function() {
-        return _BasicFunctionality.SENTINEL_VALUE;
-    },
-    SentinelNode: function() {
-        return _BasicFunctionality.SentinelNode;
-    },
-    registerPasteUnfurlingPlugin: function() {
-        return _PasteUnfurling.registerPasteUnfurlingPlugin;
-    }
-});
-const _BasicFunctionality = require("./BasicFunctionality");
-const _ChatInputEntity = require("./ChatInputEntity");
-const _GhostText = require("./GhostText");
-const _ImperativeControl = require("./ImperativeControl");
-const _ManualGhostText = require("./ManualGhostText");
-const _PasteUnfurling = require("./PasteUnfurling");

package/lib-commonjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  BasicFunctionalityBase,\n  SentinelNode,\n  $createSentinelNode,\n  $isSentinelNode,\n  SENTINEL_VALUE,\n} from './BasicFunctionality';\nexport type { IBasicFunctionalityBase } from './BasicFunctionality';\n\nexport { ChatInputEntityPluginBase } from './ChatInputEntity';\nexport type {\n  ChatInputEntityData,\n  ChatInputEntityPluginProps,\n  IChatInputEntityPluginBase,\n  IEntityNode,\n} from './ChatInputEntity';\n\nexport { GhostTextPluginBase } from './GhostText';\nexport type { GetGhostTextFunction, IGhostTextNode } from './GhostText';\n\nexport { ImperativeControlBase } from './ImperativeControl';\nexport type { IImperativeControlBase } from './ImperativeControl';\n\nexport { ManualGhostTextBase } from './ManualGhostText';\nexport type { IManualGhostTextBase } from './ManualGhostText';\n\nexport { registerPasteUnfurlingPlugin } from './PasteUnfurling';\nexport type {\n  PasteUnfurlingPluginBaseProps,\n  PasteUnfurlingTransformFunction,\n  PasteUnfurlingTransformedPart,\n  PasteUnfurlingTransformResult,\n} from './PasteUnfurling';\n"],"names":["$createSentinelNode","$isSentinelNode","BasicFunctionalityBase","ChatInputEntityPluginBase","GhostTextPluginBase","ImperativeControlBase","ManualGhostTextBase","SENTINEL_VALUE","SentinelNode","registerPasteUnfurlingPlugin"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAGEA,mBAAmB;eAAnBA,uCAAmB;;IACnBC,eAAe;eAAfA,mCAAe;;IAHfC,sBAAsB;eAAtBA,0CAAsB;;IAQfC,yBAAyB;eAAzBA,0CAAyB;;IAQzBC,mBAAmB;eAAnBA,8BAAmB;;IAGnBC,qBAAqB;eAArBA,wCAAqB;;IAGrBC,mBAAmB;eAAnBA,oCAAmB;;IAlB1BC,cAAc;eAAdA,kCAAc;;IAHdC,YAAY;eAAZA,gCAAY;;IAwBLC,4BAA4B;eAA5BA,4CAA4B;;;oCApB9B;iCAGmC;2BAQN;mCAGE;iCAGF;gCAGS"}