@copilotkit/react-textarea 0.25.0 → 0.26.0-alpha.0

package/dist/index.mjs

@@ -1,51 +1,2207 @@
-import './chunk-MMVDU6DF.mjs';
-export { CopilotTextarea } from './chunk-7VKOE5UL.mjs';
-import './chunk-7SZDD6XT.mjs';
-import './chunk-VYECMH73.mjs';
-import './chunk-DE5K76I2.mjs';
-import './chunk-5FO6ISW4.mjs';
-export { ChatlikeApiEndpoint } from './chunk-TZLW7PBU.mjs';
-export { defaultAutosuggestionsConfig } from './chunk-NTLVQENP.mjs';
-import './chunk-K5LNB36H.mjs';
-import './chunk-RBR32FWA.mjs';
-import './chunk-KDVMG3XF.mjs';
-import './chunk-WADHCMPK.mjs';
-export { BaseCopilotTextarea } from './chunk-74HF6Q3L.mjs';
-import './chunk-U3LUDDT5.mjs';
-import './chunk-2CDXHWVF.mjs';
-import './chunk-LZ3UOAQ4.mjs';
-import './chunk-2C7O2EVM.mjs';
-import './chunk-GQN2HYFJ.mjs';
-import './chunk-5UNJXFUO.mjs';
-import './chunk-WVRTFPNO.mjs';
-import './chunk-BLRAOGXD.mjs';
-import './chunk-V55OPCG4.mjs';
-import './chunk-7LSRNPNI.mjs';
-import './chunk-W2ZHOUV6.mjs';
-import './chunk-L7VVZH4Q.mjs';
-import './chunk-CK7Q3Y5A.mjs';
-import './chunk-5IISSXS2.mjs';
-import './chunk-ZEHF3AXH.mjs';
-import './chunk-3PQ7GSFE.mjs';
-import './chunk-KMXSZRIA.mjs';
-import './chunk-FK2XUDQQ.mjs';
-import './chunk-QRKKPCUD.mjs';
-import './chunk-ZKRM3DIR.mjs';
-import './chunk-AUCHS4VR.mjs';
-import './chunk-ZMNOLW5V.mjs';
-import './chunk-PDCIGRCE.mjs';
-import './chunk-2QDCE7PD.mjs';
-import './chunk-F626GQCD.mjs';
-import './chunk-WJHSY5T6.mjs';
-export { defaultBaseAutosuggestionsConfig } from './chunk-FP2EKU3L.mjs';
-import './chunk-UEQYKC4W.mjs';
-import './chunk-EZCKXWQF.mjs';
-import './chunk-IU3WTXLQ.mjs';
-import './chunk-H4VKQGVU.mjs';
-import './chunk-M2DR4KVB.mjs';
-import './chunk-T6MTDQZ7.mjs';
-import './chunk-ECR45NSD.mjs';
-import './chunk-KNQIEOFP.mjs';
-import './chunk-MRXNTQOX.mjs';
-//# sourceMappingURL=out.js.map
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/components/base-copilot-textarea/base-copilot-textarea.tsx
+import React9, { useCallback as useCallback3, useEffect as useEffect7, useMemo as useMemo4, useState as useState6 } from "react";
+import { Editor as Editor5 } from "slate";
+import { Editable, Slate } from "slate-react";
+import { twMerge as twMerge2 } from "tailwind-merge";
+
+// src/hooks/base-copilot-textarea-implementation/use-autosuggestions.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+// src/lib/debouncer.ts
+var Debouncer = class {
+  constructor(wait) {
+    this.wait = wait;
+    this.debounce = (func, ...args) => __async(this, null, function* () {
+      this.cancel();
+      this.timeoutId = setTimeout(() => __async(this, null, function* () {
+        try {
+          this.activeAbortController = new AbortController();
+          yield func(...args, this.activeAbortController.signal);
+          this.activeAbortController = void 0;
+        } catch (error) {
+        }
+      }), this.wait);
+    });
+    this.cancel = () => {
+      if (this.activeAbortController) {
+        this.activeAbortController.abort();
+        this.activeAbortController = void 0;
+      }
+      if (this.timeoutId !== void 0) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = void 0;
+      }
+    };
+  }
+};
+
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { customAlphabet } from "nanoid";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var nanoid = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var arraysAreEqual = (arr1, arr2) => arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
+function nullableCompatibleEqualityCheck(naiveEqualityCheck, a, b) {
+  if (a === null || a === void 0 || b === null || b === void 0) {
+    return a === b;
+  }
+  return naiveEqualityCheck(a, b);
+}
+
+// src/types/base/editor-autocomplete-state.ts
+function areEqual_autocompleteState(prev, next) {
+  return prev.cursorPoint.offset === next.cursorPoint.offset && arraysAreEqual(prev.cursorPoint.path, next.cursorPoint.path) && prev.textBeforeCursor === next.textBeforeCursor && prev.textAfterCursor === next.textAfterCursor;
+}
+
+// src/hooks/base-copilot-textarea-implementation/use-autosuggestions.ts
+function useAutosuggestions(debounceTime, shouldAcceptAutosuggestionOnKeyPress, autosuggestionFunction, insertAutocompleteSuggestion, disableWhenEmpty, disabled) {
+  const [previousAutocompleteState, setPreviousAutocompleteState] = useState(null);
+  const [currentAutocompleteSuggestion, setCurrentAutocompleteSuggestion] = useState(null);
+  const awaitForAndAppendSuggestion = useCallback(
+    (editorAutocompleteState, abortSignal) => __async(this, null, function* () {
+      if (disabled) {
+        return;
+      }
+      if (disableWhenEmpty && editorAutocompleteState.textBeforeCursor === "" && editorAutocompleteState.textAfterCursor === "") {
+        return;
+      }
+      const suggestion = yield autosuggestionFunction(editorAutocompleteState, abortSignal);
+      if (!suggestion || abortSignal.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      setCurrentAutocompleteSuggestion({
+        text: suggestion,
+        point: editorAutocompleteState.cursorPoint
+      });
+    }),
+    [autosuggestionFunction, setCurrentAutocompleteSuggestion, disableWhenEmpty, disabled]
+  );
+  const debouncedFunction = useMemo(
+    () => new Debouncer(debounceTime),
+    [debounceTime]
+  );
+  useEffect(() => {
+    return () => {
+      debouncedFunction.cancel();
+      setCurrentAutocompleteSuggestion(null);
+    };
+  }, [debouncedFunction, disabled]);
+  const onChange = useCallback(
+    (newEditorState) => {
+      const editorStateHasChanged = !nullableCompatibleEqualityCheck(
+        areEqual_autocompleteState,
+        previousAutocompleteState,
+        newEditorState
+      );
+      setPreviousAutocompleteState(newEditorState);
+      if (!editorStateHasChanged) {
+        return;
+      }
+      setCurrentAutocompleteSuggestion(null);
+      if (newEditorState) {
+        debouncedFunction.debounce(awaitForAndAppendSuggestion, newEditorState);
+      } else {
+        debouncedFunction.cancel();
+      }
+    },
+    [
+      previousAutocompleteState,
+      setPreviousAutocompleteState,
+      debouncedFunction,
+      awaitForAndAppendSuggestion,
+      setCurrentAutocompleteSuggestion
+    ]
+  );
+  const keyDownHandler = useCallback(
+    (event) => {
+      if (currentAutocompleteSuggestion) {
+        if (shouldAcceptAutosuggestionOnKeyPress(event)) {
+          event.preventDefault();
+          insertAutocompleteSuggestion(currentAutocompleteSuggestion);
+          setCurrentAutocompleteSuggestion(null);
+        }
+      }
+    },
+    [
+      currentAutocompleteSuggestion,
+      setCurrentAutocompleteSuggestion,
+      insertAutocompleteSuggestion,
+      shouldAcceptAutosuggestionOnKeyPress
+    ]
+  );
+  return {
+    currentAutocompleteSuggestion,
+    onChangeHandler: onChange,
+    onKeyDownHandler: keyDownHandler
+  };
+}
+
+// src/hooks/base-copilot-textarea-implementation/use-copilot-textarea-editor.tsx
+import { useMemo as useMemo2 } from "react";
+import { createEditor, Element } from "slate";
+import { withReact } from "slate-react";
+
+// src/lib/slatejs-edits/with-partial-history.ts
+import { Editor, Operation, Path, Transforms } from "slate";
+import { HistoryEditor } from "slate-history";
+var withPartialHistory = (editor, shouldSave2) => {
+  const e = editor;
+  const { apply } = e;
+  e.history = { undos: [], redos: [] };
+  e.redo = () => {
+    const { history } = e;
+    const { redos } = history;
+    if (redos.length > 0) {
+      const batch = redos[redos.length - 1];
+      if (batch.selectionBefore) {
+        Transforms.setSelection(e, batch.selectionBefore);
+      }
+      HistoryEditor.withoutSaving(e, () => {
+        Editor.withoutNormalizing(e, () => {
+          for (const op of batch.operations) {
+            e.apply(op);
+          }
+        });
+      });
+      history.redos.pop();
+      e.writeHistory("undos", batch);
+    }
+  };
+  e.undo = () => {
+    const { history } = e;
+    const { undos } = history;
+    if (undos.length > 0) {
+      const batch = undos[undos.length - 1];
+      HistoryEditor.withoutSaving(e, () => {
+        Editor.withoutNormalizing(e, () => {
+          const inverseOps = batch.operations.map(Operation.inverse).reverse();
+          for (const op of inverseOps) {
+            e.apply(op);
+          }
+          if (batch.selectionBefore) {
+            Transforms.setSelection(e, batch.selectionBefore);
+          }
+        });
+      });
+      e.writeHistory("redos", batch);
+      history.undos.pop();
+    }
+  };
+  e.apply = (op) => {
+    const { operations, history } = e;
+    const { undos } = history;
+    const lastBatch = undos[undos.length - 1];
+    const lastOp = lastBatch && lastBatch.operations[lastBatch.operations.length - 1];
+    let save = HistoryEditor.isSaving(e);
+    let merge2 = HistoryEditor.isMerging(e);
+    if (save == null) {
+      save = shouldSave2(op, lastOp);
+    }
+    if (save) {
+      if (merge2 == null) {
+        if (lastBatch == null) {
+          merge2 = false;
+        } else if (operations.length !== 0) {
+          merge2 = true;
+        } else {
+          merge2 = shouldMerge(op, lastOp);
+        }
+      }
+      if (lastBatch && merge2) {
+        lastBatch.operations.push(op);
+      } else {
+        const batch = {
+          operations: [op],
+          selectionBefore: e.selection
+        };
+        e.writeHistory("undos", batch);
+      }
+      while (undos.length > 100) {
+        undos.shift();
+      }
+      history.redos = [];
+    }
+    apply(op);
+  };
+  e.writeHistory = (stack, batch) => {
+    e.history[stack].push(batch);
+  };
+  return e;
+};
+var shouldMerge = (op, prev) => {
+  if (prev && op.type === "insert_text" && prev.type === "insert_text" && op.offset === prev.offset + prev.text.length && Path.equals(op.path, prev.path)) {
+    return true;
+  }
+  if (prev && op.type === "remove_text" && prev.type === "remove_text" && op.offset + op.text.length === prev.offset && Path.equals(op.path, prev.path)) {
+    return true;
+  }
+  return false;
+};
+var defaultShouldSave = (op, prev) => {
+  if (op.type === "set_selection") {
+    return false;
+  }
+  return true;
+};
+
+// src/hooks/base-copilot-textarea-implementation/use-copilot-textarea-editor.tsx
+var shouldSave = (op, prev) => {
+  const excludedNodeType = "suggestion";
+  if (op.type === "insert_node" && Element.isElement(op.node) && op.node.type === excludedNodeType) {
+    return false;
+  }
+  if (op.type === "remove_node" && Element.isElement(op.node) && op.node.type === excludedNodeType) {
+    return false;
+  }
+  if (op.type === "set_node" && "type" in op.newProperties && op.newProperties.type === excludedNodeType) {
+    return false;
+  }
+  if (op.type == "set_node" && "type" in op.properties && op.properties.type === excludedNodeType) {
+    return false;
+  }
+  if (op.type === "merge_node" && "type" in op.properties && op.properties.type === excludedNodeType) {
+    return false;
+  }
+  if (op.type === "split_node" && "type" in op.properties && op.properties.type === excludedNodeType) {
+    return false;
+  }
+  return defaultShouldSave(op, prev);
+};
+function useCopilotTextareaEditor() {
+  const editor = useMemo2(() => {
+    const editor2 = withPartialHistory(withReact(createEditor()), shouldSave);
+    const { isVoid } = editor2;
+    editor2.isVoid = (element) => {
+      switch (element.type) {
+        case "suggestion":
+          return true;
+        default:
+          return isVoid(element);
+      }
+    };
+    const { markableVoid } = editor2;
+    editor2.markableVoid = (element) => {
+      switch (element.type) {
+        case "suggestion":
+          return true;
+        default:
+          return markableVoid(element);
+      }
+    };
+    const { isInline } = editor2;
+    editor2.isInline = (element) => {
+      switch (element.type) {
+        case "suggestion":
+          return element.inline;
+        default:
+          return isInline(element);
+      }
+    };
+    return editor2;
+  }, []);
+  return editor;
+}
+
+// src/hooks/base-copilot-textarea-implementation/use-populate-copilot-textarea-ref.ts
+import React from "react";
+import { ReactEditor } from "slate-react";
+
+// src/lib/get-text-around-cursor.ts
+import { Editor as Editor2, Path as Path2, Range as Range2, Text, Element as Element2, Point } from "slate";
+function getTextAroundCollapsedCursor(editor) {
+  const { selection } = editor;
+  if (!selection || !Range2.isCollapsed(selection)) {
+    return null;
+  }
+  const cursorPoint = selection.anchor;
+  const beforeRange = {
+    anchor: Editor2.start(editor, []),
+    focus: cursorPoint
+  };
+  const afterRange = {
+    anchor: cursorPoint,
+    focus: Editor2.end(editor, [])
+  };
+  const before = extractTextWithNewlines(editor, beforeRange);
+  const after = extractTextWithNewlines(editor, afterRange);
+  return {
+    cursorPoint,
+    textBeforeCursor: before,
+    textAfterCursor: after
+  };
+}
+function getTextAroundSelection(editor) {
+  const { selection } = editor;
+  if (!selection) {
+    return null;
+  }
+  const wellOrderedSelection = wellOrderedRange(selection);
+  const beforeRange = {
+    anchor: Editor2.start(editor, []),
+    focus: wellOrderedSelection.anchor
+  };
+  const afterRange = {
+    anchor: wellOrderedSelection.focus,
+    focus: Editor2.end(editor, [])
+  };
+  const before = extractTextWithNewlines(editor, beforeRange);
+  const after = extractTextWithNewlines(editor, afterRange);
+  const selectedText = extractTextWithNewlines(editor, wellOrderedSelection);
+  return {
+    selection: wellOrderedSelection,
+    textBeforeCursor: before,
+    selectedText,
+    textAfterCursor: after
+  };
+}
+function getFullEditorTextWithNewlines(editor) {
+  const fullDocumentRange = {
+    anchor: Editor2.start(editor, []),
+    focus: Editor2.end(editor, [])
+  };
+  return extractTextWithNewlines(editor, fullDocumentRange);
+}
+function extractTextWithNewlines(editor, range) {
+  const voids = false;
+  const [start, end] = Range2.edges(range);
+  let text = "";
+  let lastBlock = null;
+  for (const [node, path] of Editor2.nodes(editor, {
+    at: range,
+    match: Text.isText,
+    voids
+  })) {
+    let t = node.text;
+    const [block] = Editor2.above(editor, {
+      at: path,
+      match: (n) => Element2.isElement(n) && n.type === "paragraph"
+    }) || [null];
+    if (lastBlock !== block && block) {
+      if (lastBlock) {
+        text += "\n";
+      }
+      lastBlock = block;
+    }
+    if (Path2.equals(path, end.path)) {
+      t = t.slice(0, end.offset);
+    }
+    if (Path2.equals(path, start.path)) {
+      t = t.slice(start.offset);
+    }
+    text += t;
+  }
+  return text;
+}
+function wellOrderedRange(range) {
+  const { anchor, focus } = range;
+  if (Point.isBefore(anchor, focus)) {
+    return range;
+  }
+  return {
+    anchor: focus,
+    focus: anchor
+  };
+}
+
+// src/lib/slatejs-edits/replace-text.ts
+import { Editor as Editor3, Transforms as Transforms2 } from "slate";
+function replaceEditorText(editor, newText) {
+  Transforms2.delete(editor, {
+    at: {
+      anchor: Editor3.start(editor, []),
+      focus: Editor3.end(editor, [])
+    }
+  });
+  if (newText && newText !== "") {
+    Transforms2.insertNodes(
+      editor,
+      [
+        {
+          type: "paragraph",
+          children: [{ text: newText }]
+        }
+      ],
+      {
+        at: [0]
+      }
+    );
+  }
+}
+
+// src/hooks/base-copilot-textarea-implementation/use-populate-copilot-textarea-ref.ts
+function usePopulateCopilotTextareaRef(editor, ref) {
+  React.useImperativeHandle(
+    ref,
+    () => {
+      class Combined {
+        constructor(customMethods2, editorHtmlElement2) {
+          this.customMethods = customMethods2;
+          this.editorHtmlElement = editorHtmlElement2;
+        }
+        get(target, propKey) {
+          if (this.isKeyOfCustomMethods(propKey)) {
+            const value = this.customMethods[propKey];
+            if (typeof value === "function") {
+              return value.bind(this.customMethods);
+            }
+            return value;
+          } else if (this.isKeyOfHTMLElement(propKey)) {
+            const value = this.editorHtmlElement[propKey];
+            if (typeof value === "function") {
+              return value.bind(this.editorHtmlElement);
+            }
+            return value;
+          }
+        }
+        set(target, propKey, value) {
+          if (this.isKeyOfCustomMethods(propKey)) {
+            this.customMethods[propKey] = value;
+          } else if (this.isKeyOfHTMLElement(propKey)) {
+            this.editorHtmlElement[propKey] = value;
+          } else {
+            target[propKey] = value;
+          }
+          return true;
+        }
+        isKeyOfCustomMethods(key) {
+          return key in this.customMethods;
+        }
+        isKeyOfHTMLElement(key) {
+          return key in this.editorHtmlElement;
+        }
+      }
+      const handler = {
+        get(target, propKey) {
+          return target.get(target, propKey);
+        },
+        set(target, propKey, value) {
+          return target.set(target, propKey, value);
+        }
+      };
+      class CustomMethods {
+        constructor(editor2) {
+          this.editor = editor2;
+        }
+        focus() {
+          ReactEditor.focus(this.editor);
+        }
+        blur() {
+          ReactEditor.blur(this.editor);
+        }
+        get value() {
+          return getFullEditorTextWithNewlines(this.editor);
+        }
+        set value(value) {
+          replaceEditorText(this.editor, value);
+        }
+      }
+      const editorHtmlElement = ReactEditor.toDOMNode(editor, editor);
+      const customMethods = new CustomMethods(editor);
+      const combined = new Combined(customMethods, editorHtmlElement);
+      return new Proxy(combined, handler);
+    },
+    [editor]
+  );
+}
+
+// src/lib/slatejs-edits/add-autocompletions.ts
+import { Transforms as Transforms3 } from "slate";
+function addAutocompletionsToEditor(editor, newSuggestion, point) {
+  const editorPosition = editor.selection;
+  Transforms3.insertNodes(
+    editor,
+    [
+      {
+        type: "suggestion",
+        inline: true,
+        content: newSuggestion,
+        children: [{ text: "" }]
+      }
+    ],
+    {
+      at: point
+    }
+  );
+  if (editorPosition) {
+    editor.selection = editorPosition;
+  }
+}
+
+// src/lib/slatejs-edits/clear-autocompletions.ts
+import { Element as Element3, Node as Node2, Transforms as Transforms4 } from "slate";
+function clearAutocompletionsFromEditor(editor) {
+  const paths = [];
+  for (const [node, path] of Node2.nodes(editor)) {
+    if (Element3.isElement(node) && node.type === "suggestion") {
+      paths.push(path);
+    }
+  }
+  for (const path of paths) {
+    try {
+      Transforms4.removeNodes(editor, { at: path });
+    } catch (e) {
+      console.log("CopilotTextarea.clearAutocompletionsFromEditor: error removing node", e);
+    }
+  }
+}
+
+// src/types/base/base-autosuggestions-config.tsx
+import { defaultCopilotContextCategories } from "@copilotkit/react-core";
+var defaultShouldToggleHoveringEditorOnKeyPress = (event) => {
+  if (event.key === "k" && event.metaKey) {
+    return true;
+  }
+  return false;
+};
+var defaultShouldAcceptAutosuggestionOnKeyPress = (event) => {
+  if (event.key === "Tab") {
+    return true;
+  }
+  return false;
+};
+var defaultBaseAutosuggestionsConfig = {
+  debounceTime: 250,
+  contextCategories: defaultCopilotContextCategories,
+  disableWhenEmpty: true,
+  disabled: false,
+  temporarilyDisableWhenMovingCursorWithoutChangingText: true,
+  shouldToggleHoveringEditorOnKeyPress: defaultShouldToggleHoveringEditorOnKeyPress,
+  shouldAcceptAutosuggestionOnKeyPress: defaultShouldAcceptAutosuggestionOnKeyPress
+};
+
+// src/components/hovering-toolbar/hovering-toolbar.tsx
+import { useEffect as useEffect4, useRef as useRef2, useState as useState5 } from "react";
+import { Transforms as Transforms5 } from "slate";
+import { useSlate, useSlateSelection } from "slate-react";
+
+// src/hooks/misc/use-autosize-textarea.tsx
+import { useEffect as useEffect2 } from "react";
+var useAutosizeTextArea = (textAreaRef, value) => {
+  useEffect2(() => {
+    if (textAreaRef.current !== null) {
+      textAreaRef.current.style.height = "0px";
+      const scrollHeight = textAreaRef.current.scrollHeight;
+      textAreaRef.current.style.height = scrollHeight + "px";
+    }
+  }, [textAreaRef, value]);
+};
+var use_autosize_textarea_default = useAutosizeTextArea;
+
+// src/components/source-search-box/source-search-box.tsx
+import { useState as useState2 } from "react";
+
+// src/components/ui/command.tsx
+import * as React2 from "react";
+import { Command as CommandPrimitive } from "cmdk";
+import { jsx } from "react/jsx-runtime";
+var Command = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    CommandPrimitive,
+    __spreadValues({
+      ref,
+      className: cn(
+        "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
+        className
+      )
+    }, props)
+  );
+});
+Command.displayName = CommandPrimitive.displayName;
+var CommandInput = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center border-b px-3", "cmdk-input-wrapper": "", children: /* @__PURE__ */ jsx(
+    CommandPrimitive.Input,
+    __spreadValues({
+      ref,
+      className: cn(
+        "flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      )
+    }, props)
+  ) });
+});
+CommandInput.displayName = CommandPrimitive.Input.displayName;
+var CommandList = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    CommandPrimitive.List,
+    __spreadValues({
+      ref,
+      className: cn("max-h-[300px] overflow-y-auto overflow-x-hidden pb-2", className)
+    }, props)
+  );
+});
+CommandList.displayName = CommandPrimitive.List.displayName;
+var CommandEmpty = React2.forwardRef((props, ref) => /* @__PURE__ */ jsx(CommandPrimitive.Empty, __spreadValues({ ref, className: "py-6 text-center text-sm" }, props)));
+CommandEmpty.displayName = CommandPrimitive.Empty.displayName;
+var CommandGroup = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    CommandPrimitive.Group,
+    __spreadValues({
+      ref,
+      className: cn(
+        "overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
+        className
+      )
+    }, props)
+  );
+});
+CommandGroup.displayName = CommandPrimitive.Group.displayName;
+var CommandSeparator = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    CommandPrimitive.Separator,
+    __spreadValues({
+      ref,
+      className: cn("-mx-1 h-px bg-border", className)
+    }, props)
+  );
+});
+CommandSeparator.displayName = CommandPrimitive.Separator.displayName;
+var CommandItem = React2.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    CommandPrimitive.Item,
+    __spreadValues({
+      ref,
+      className: cn(
+        "relative flex cursor-default select-none items-center rounded-sm text-sm outline-none aria-selected:bg-accent aria-selected:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+        className
+      )
+    }, props)
+  );
+});
+CommandItem.displayName = CommandPrimitive.Item.displayName;
+var CommandShortcut = (_a) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    "span",
+    __spreadValues({
+      className: cn("ml-auto text-xs tracking-widest text-muted-foreground", className)
+    }, props)
+  );
+};
+CommandShortcut.displayName = "CommandShortcut";
+
+// src/components/source-search-box/source-search-box.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function SourceSearchBox(props) {
+  const [selectedValue, setSelectedValue] = useState2("");
+  return /* @__PURE__ */ jsxs(
+    Command,
+    {
+      className: "rounded-lg border shadow-md",
+      value: selectedValue,
+      onValueChange: (value) => {
+        setSelectedValue(value);
+      },
+      filter: (value, search) => {
+        if (props.searchTerm === "")
+          return 1;
+        if (value.startsWith(props.searchTerm))
+          return 1;
+        return 0;
+      },
+      children: [
+        /* @__PURE__ */ jsx2(
+          CommandInput,
+          {
+            value: props.searchTerm,
+            className: "rounded-t-lg hidden",
+            placeholder: "Search for a command..."
+          }
+        ),
+        /* @__PURE__ */ jsxs(CommandList, { children: [
+          /* @__PURE__ */ jsx2(CommandEmpty, { children: "No results found." }),
+          /* @__PURE__ */ jsx2(CommandGroup, { heading: "Available resources", children: props.suggestedFiles.map((filePointer) => {
+            return /* @__PURE__ */ jsx2(
+              CommandItem,
+              {
+                value: filePointer.name,
+                onSelect: (value) => {
+                  props.onSelectedFile(filePointer);
+                },
+                children: /* @__PURE__ */ jsxs("div", { className: " px-3  flex flex-row gap-1 items-center", children: [
+                  /* @__PURE__ */ jsx2(Logo, { width: "20px", height: "20px", children: /* @__PURE__ */ jsx2(
+                    "img",
+                    {
+                      src: filePointer.iconImageUri,
+                      alt: filePointer.sourceApplication,
+                      className: "w-full h-full"
+                    }
+                  ) }),
+                  filePointer.name
+                ] })
+              },
+              `word-${filePointer.sourceApplication}.${filePointer.name}`
+            );
+          }) }),
+          /* @__PURE__ */ jsx2(CommandSeparator, {})
+        ] })
+      ]
+    }
+  );
+}
+function Logo({
+  children,
+  width,
+  height
+}) {
+  return /* @__PURE__ */ jsx2("div", { className: "flex items-center justify-center", style: { width, height }, children });
+}
+
+// src/components/ui/button.tsx
+import * as React3 from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var buttonVariants = cva(
+  "inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+        icon: "h-10 w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React3.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, variant, size, asChild = false } = _b, props = __objRest(_b, ["className", "variant", "size", "asChild"]);
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx3(Comp, __spreadValues({ className: cn(buttonVariants({ variant, size, className })), ref }, props));
+  }
+);
+Button.displayName = "Button";
+
+// src/components/ui/label.tsx
+import * as React4 from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { cva as cva2 } from "class-variance-authority";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var labelVariants = cva2(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label = React4.forwardRef((_a, ref) => {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx4(LabelPrimitive.Root, __spreadValues({ ref, className: cn(labelVariants(), className) }, props));
+});
+Label.displayName = LabelPrimitive.Root.displayName;
+
+// src/components/hovering-toolbar/text-insertion-prompt-box/hovering-insertion-prompt-box-core.tsx
+import { useCallback as useCallback2, useContext, useEffect as useEffect3, useRef, useState as useState3 } from "react";
+
+// src/lib/stream-promise-flatten.ts
+function streamPromiseFlatten(promise) {
+  return new ReadableStream({
+    start(controller) {
+      return __async(this, null, function* () {
+        try {
+          const stream = yield promise;
+          const reader = stream.getReader();
+          while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+              controller.close();
+              return;
+            }
+            controller.enqueue(value);
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+
+// src/components/hovering-toolbar/text-insertion-prompt-box/hovering-insertion-prompt-box-core.tsx
+import { CopilotContext } from "@copilotkit/react-core";
+
+// src/components/hovering-toolbar/text-insertion-prompt-box/included-files-preview.tsx
+import Chip from "@mui/material/Chip/Chip.js";
+import Avatar from "@mui/material/Avatar/Avatar.js";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var IncludedFilesPreview = ({
+  includedFiles,
+  setIncludedFiles
+}) => {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-2 mt-2", children: [
+    /* @__PURE__ */ jsx5(Label, { className: "", children: "Included context:" }),
+    /* @__PURE__ */ jsx5("div", { className: "flex flex-wrap gap-2", children: includedFiles.map((filePointer, index) => {
+      return /* @__PURE__ */ jsx5(
+        FileChipPreview,
+        {
+          filePointer,
+          onDelete: () => {
+            setIncludedFiles((prev) => prev.filter((fp) => fp !== filePointer));
+          }
+        },
+        `file-${filePointer.sourceApplication}.${filePointer.name}`
+      );
+    }) })
+  ] });
+};
+var FileChipPreview = ({ filePointer, onDelete }) => {
+  return /* @__PURE__ */ jsx5(
+    Chip,
+    {
+      label: filePointer.name,
+      onDelete,
+      avatar: /* @__PURE__ */ jsx5(
+        Avatar,
+        {
+          src: filePointer.iconImageUri,
+          alt: filePointer.sourceApplication,
+          sx: { backgroundColor: "transparent" }
+        }
+      )
+    }
+  );
+};
+
+// src/components/hovering-toolbar/text-insertion-prompt-box/hovering-insertion-prompt-box-core.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var HoveringInsertionPromptBoxCore = ({
+  performInsertion,
+  state,
+  insertionOrEditingFunction,
+  contextCategories
+}) => {
+  const { getDocumentsContext } = useContext(CopilotContext);
+  const [editSuggestion, setEditSuggestion] = useState3("");
+  const [suggestionIsLoading, setSuggestionIsLoading] = useState3(false);
+  const [adjustmentPrompt, setAdjustmentPrompt] = useState3("");
+  const [generatingSuggestion, setGeneratingSuggestion] = useState3(
+    null
+  );
+  const adjustmentTextAreaRef = useRef(null);
+  const suggestionTextAreaRef = useRef(null);
+  const [filePointers, setFilePointers] = useState3([]);
+  const [suggestedFiles, setSuggestedFiles] = useState3([]);
+  useEffect3(() => {
+    setSuggestedFiles(getDocumentsContext(contextCategories));
+  }, [contextCategories, getDocumentsContext]);
+  use_autosize_textarea_default(suggestionTextAreaRef, editSuggestion || "");
+  use_autosize_textarea_default(adjustmentTextAreaRef, adjustmentPrompt || "");
+  useEffect3(() => {
+    var _a;
+    (_a = adjustmentTextAreaRef.current) == null ? void 0 : _a.focus();
+  }, []);
+  useEffect3(() => {
+    if (!generatingSuggestion) {
+      return;
+    }
+    if (generatingSuggestion.locked) {
+      return;
+    }
+    setEditSuggestion("");
+    const reader = generatingSuggestion.getReader();
+    const read = () => __async(void 0, null, function* () {
+      setSuggestionIsLoading(true);
+      while (true) {
+        const { done, value } = yield reader.read();
+        if (done) {
+          break;
+        }
+        setEditSuggestion((prev) => {
+          const newSuggestion = prev + value;
+          if (suggestionTextAreaRef.current) {
+            suggestionTextAreaRef.current.scrollTop = suggestionTextAreaRef.current.scrollHeight;
+          }
+          return newSuggestion;
+        });
+      }
+      setSuggestionIsLoading(false);
+    });
+    read();
+    return () => {
+      const releaseLockIfNotClosed = () => __async(void 0, null, function* () {
+        try {
+          yield reader.closed;
+        } catch (e) {
+          reader.releaseLock();
+        }
+      });
+      releaseLockIfNotClosed();
+    };
+  }, [generatingSuggestion]);
+  const beginGeneratingAdjustment = useCallback2(() => __async(void 0, null, function* () {
+    if (!adjustmentPrompt.trim()) {
+      return;
+    }
+    let modificationState = state.editorState;
+    if (editSuggestion !== "") {
+      modificationState.selectedText = editSuggestion;
+    }
+    const adjustmentSuggestionTextStreamPromise = insertionOrEditingFunction(
+      modificationState,
+      adjustmentPrompt,
+      filePointers,
+      new AbortController().signal
+    );
+    const adjustmentSuggestionTextStream = streamPromiseFlatten(
+      adjustmentSuggestionTextStreamPromise
+    );
+    setGeneratingSuggestion(adjustmentSuggestionTextStream);
+  }), [
+    adjustmentPrompt,
+    editSuggestion,
+    state.editorState,
+    insertionOrEditingFunction,
+    filePointers
+  ]);
+  const isLoading = suggestionIsLoading;
+  const textToEdit = editSuggestion || state.editorState.selectedText;
+  const adjustmentLabel = textToEdit === "" ? "Describe the text you want to insert" : "Describe adjustments to the suggested text";
+  const placeholder = textToEdit === "" ? "e.g. 'summarize the client's top 3 pain-points from @CallTranscript'" : "e.g. 'make it more formal', 'be more specific', ...";
+  const AdjustmentPromptComponent = /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx6(Label, { className: "", children: adjustmentLabel }),
+    /* @__PURE__ */ jsxs3("div", { className: "relative w-full flex items-center", children: [
+      /* @__PURE__ */ jsx6(
+        "textarea",
+        {
+          disabled: suggestionIsLoading,
+          ref: adjustmentTextAreaRef,
+          value: adjustmentPrompt,
+          onChange: (e) => setAdjustmentPrompt(e.target.value),
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && e.shiftKey) {
+              e.preventDefault();
+              setAdjustmentPrompt(adjustmentPrompt + "\n");
+            } else if (e.key === "Enter") {
+              e.preventDefault();
+              beginGeneratingAdjustment();
+            }
+          },
+          placeholder,
+          style: { minHeight: "3rem" },
+          className: "w-full bg-slate-100 h-auto h-min-14 text-sm p-2 rounded-md resize-none overflow-visible focus:outline-none focus:ring-0 focus:border-non pr-[3rem]",
+          rows: 1
+        }
+      ),
+      /* @__PURE__ */ jsx6(
+        "button",
+        {
+          onClick: beginGeneratingAdjustment,
+          className: "absolute right-2 bg-blue-500 text-white w-8 h-8 rounded-full flex items-center justify-center",
+          children: /* @__PURE__ */ jsx6("i", { className: "material-icons", children: "arrow_forward" })
+        }
+      )
+    ] })
+  ] });
+  const SuggestionComponent = /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsxs3("div", { className: "flex justify-between items-end w-full", children: [
+      /* @__PURE__ */ jsx6(Label, { className: "mt-4", children: "Suggested:" }),
+      /* @__PURE__ */ jsx6("div", { className: "ml-auto", children: isLoading && /* @__PURE__ */ jsx6("div", { className: "flex justify-center items-center", children: /* @__PURE__ */ jsx6(
+        "div",
+        {
+          className: "inline-block h-4 w-4 animate-spin rounded-full border-4 border-solid border-current border-r-transparent align-[-0.125em] motion-reduce:animate-[spin_1.5s_linear_infinite]",
+          role: "status",
+          children: /* @__PURE__ */ jsx6("span", { className: "!absolute !-m-px !h-px !w-px !overflow-hidden !whitespace-nowrap !border-0 !p-0 ![clip:rect(0,0,0,0)]", children: "Loading..." })
+        }
+      ) }) })
+    ] }),
+    /* @__PURE__ */ jsx6(
+      "textarea",
+      {
+        ref: suggestionTextAreaRef,
+        value: editSuggestion,
+        disabled: suggestionIsLoading,
+        onChange: (e) => setEditSuggestion(e.target.value),
+        className: "w-full text-base p-2 border border-gray-300 rounded-md resize-none bg-green-50",
+        style: { overflow: "auto", maxHeight: "10em" }
+      }
+    )
+  ] });
+  const SubmitComponent = /* @__PURE__ */ jsx6("div", { className: "flex w-full gap-4 justify-start", children: /* @__PURE__ */ jsxs3(
+    Button,
+    {
+      className: " bg-green-700 text-white",
+      onClick: () => {
+        performInsertion(editSuggestion);
+      },
+      children: [
+        "Insert ",
+        /* @__PURE__ */ jsx6("i", { className: "material-icons", children: "check" })
+      ]
+    }
+  ) });
+  const sourceSearchCandidate = adjustmentPrompt.split(" ").pop();
+  const sourceSearchWord = (sourceSearchCandidate == null ? void 0 : sourceSearchCandidate.startsWith("@")) ? sourceSearchCandidate.slice(1) : void 0;
+  return /* @__PURE__ */ jsxs3("div", { className: "w-full flex flex-col items-start relative gap-2", children: [
+    AdjustmentPromptComponent,
+    filePointers.length > 0 && /* @__PURE__ */ jsx6(IncludedFilesPreview, { includedFiles: filePointers, setIncludedFiles: setFilePointers }),
+    sourceSearchWord !== void 0 && /* @__PURE__ */ jsx6(
+      SourceSearchBox,
+      {
+        searchTerm: sourceSearchWord,
+        suggestedFiles,
+        onSelectedFile: (filePointer) => {
+          var _a;
+          setAdjustmentPrompt(adjustmentPrompt.replace(new RegExp(`@${sourceSearchWord}$`), ""));
+          setFilePointers((prev) => [...prev, filePointer]);
+          (_a = adjustmentTextAreaRef.current) == null ? void 0 : _a.focus();
+        }
+      }
+    ),
+    generatingSuggestion ? SuggestionComponent : null,
+    generatingSuggestion ? SubmitComponent : null
+  ] });
+};
+
+// src/components/hovering-toolbar/text-insertion-prompt-box/hovering-insertion-prompt-box.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var HoveringInsertionPromptBox = (props) => {
+  return /* @__PURE__ */ jsx7(
+    "div",
+    {
+      className: "flex flex-col justify-center items-center space-y-4 rounded-md border shadow-lg p-4 border-gray- bg-white",
+      style: { width: "35rem" },
+      children: /* @__PURE__ */ jsx7(
+        HoveringInsertionPromptBoxCore,
+        {
+          state: {
+            editorState: props.editorState
+          },
+          insertionOrEditingFunction: props.apiConfig.insertionOrEditingFunction,
+          performInsertion: props.performInsertion,
+          contextCategories: props.contextCategories
+        }
+      )
+    }
+  );
+};
+
+// src/components/hovering-toolbar/hovering-toolbar-components.tsx
+import { css, cx } from "@emotion/css";
+import React6 from "react";
+import ReactDOM from "react-dom";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var Button2 = React6.forwardRef(
+  (_a, ref) => {
+    var _b = _a, {
+      className,
+      active,
+      reversed
+    } = _b, props = __objRest(_b, [
+      "className",
+      "active",
+      "reversed"
+    ]);
+    return /* @__PURE__ */ jsx8(
+      "span",
+      __spreadProps(__spreadValues({}, props), {
+        ref,
+        className: cx(
+          className,
+          css`
+          cursor: pointer;
+          color: ${reversed ? active ? "white" : "#aaa" : active ? "black" : "#ccc"};
+        `
+        )
+      })
+    );
+  }
+);
+var Icon = React6.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+    return /* @__PURE__ */ jsx8(
+      "span",
+      __spreadProps(__spreadValues({}, props), {
+        ref,
+        className: cx(
+          "material-icons",
+          className,
+          css`
+          font-size: 18px;
+          vertical-align: text-bottom;
+        `
+        )
+      })
+    );
+  }
+);
+var Menu = React6.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+    return /* @__PURE__ */ jsx8(
+      "div",
+      __spreadProps(__spreadValues({}, props), {
+        "data-test-id": "menu",
+        ref,
+        className: cx(
+          className,
+          css`
+          & > * {
+            display: inline-block;
+          }
+
+          & > * + * {
+            margin-left: 15px;
+          }
+        `
+        )
+      })
+    );
+  }
+);
+var Portal = ({ children }) => {
+  return typeof document === "object" ? ReactDOM.createPortal(children, document.body) : null;
+};
+var Toolbar = React6.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+    return /* @__PURE__ */ jsx8(
+      Menu,
+      __spreadProps(__spreadValues({}, props), {
+        ref,
+        className: cx(
+          className,
+          css`
+          position: relative;
+          padding: 1px 18px 17px;
+          margin: 0 -20px;
+          border-bottom: 2px solid #eee;
+          margin-bottom: 20px;
+        `
+        )
+      })
+    );
+  }
+);
+
+// src/components/hovering-toolbar/hovering-editor-provider.tsx
+import { createContext, useState as useState4, useContext as useContext2 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var HoveringEditorContext = createContext({
+  isDisplayed: false,
+  setIsDisplayed: () => {
+  }
+});
+var HoveringEditorProvider = ({ children }) => {
+  const [isDisplayed, setIsDisplayed] = useState4(false);
+  return /* @__PURE__ */ jsx9(HoveringEditorContext.Provider, { value: { isDisplayed, setIsDisplayed }, children });
+};
+var useHoveringEditorContext = () => useContext2(HoveringEditorContext);
+
+// src/components/hovering-toolbar/hovering-toolbar.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var HoveringToolbar = (props) => {
+  const ref = useRef2(null);
+  const editor = useSlate();
+  const selection = useSlateSelection();
+  const { isDisplayed, setIsDisplayed } = useHoveringEditorContext();
+  const [isClient, setIsClient] = useState5(false);
+  useEffect4(() => {
+    setIsClient(true);
+  }, []);
+  useEffect4(() => {
+    const el = ref.current;
+    const { selection: selection2 } = editor;
+    if (!el) {
+      return;
+    }
+    if (!selection2) {
+      el.removeAttribute("style");
+      return;
+    }
+    const domSelection = window.getSelection();
+    if (!domSelection) {
+      return;
+    }
+    const domRange = domSelection.getRangeAt(0);
+    const rect = domRange.getBoundingClientRect();
+    if (rect.top === 0 && rect.left === 0 && rect.width === 0 && rect.height === 0) {
+      return;
+    }
+    const minGapFromEdge = 60;
+    const verticalOffsetFromCorner = 35;
+    const horizontalOffsetFromCorner = 15;
+    let top = rect.top + window.scrollY - el.offsetHeight + verticalOffsetFromCorner;
+    if (top < minGapFromEdge) {
+      top = rect.bottom + window.scrollY + minGapFromEdge;
+    } else if (top + el.offsetHeight > window.innerHeight - minGapFromEdge) {
+      top = rect.top + window.scrollY - el.offsetHeight - minGapFromEdge;
+    }
+    let left = rect.left + window.scrollX - el.offsetWidth / 2 + rect.width / 2 + horizontalOffsetFromCorner;
+    if (left < minGapFromEdge) {
+      left = minGapFromEdge;
+    } else if (left + el.offsetWidth > window.innerWidth - minGapFromEdge) {
+      left = window.innerWidth - el.offsetWidth - minGapFromEdge;
+    }
+    el.style.opacity = "1";
+    el.style.top = `${top}px`;
+    el.style.left = `${left}px`;
+  });
+  useEffect4(() => {
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        setIsDisplayed(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [ref, setIsDisplayed]);
+  if (!isClient) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx10(Portal, { children: /* @__PURE__ */ jsx10(
+    Menu,
+    {
+      ref,
+      className: props.hoverMenuClassname || "p-2 absolute z-10 top-[-10000px] left-[-10000px] mt-[-6px] opacity-0 transition-opacity duration-700",
+      children: isDisplayed && selection && /* @__PURE__ */ jsx10(
+        HoveringInsertionPromptBox,
+        {
+          editorState: editorState(editor, selection),
+          apiConfig: props.apiConfig,
+          closeWindow: () => {
+            setIsDisplayed(false);
+          },
+          performInsertion: (insertedText) => {
+            console.log("inserted text", insertedText);
+            Transforms5.delete(editor, { at: selection });
+            Transforms5.insertText(editor, insertedText, {
+              at: selection
+            });
+            setIsDisplayed(false);
+          },
+          contextCategories: props.contextCategories
+        }
+      )
+    }
+  ) });
+};
+function editorState(editor, selection) {
+  const textAroundCursor = getTextAroundSelection(editor);
+  if (textAroundCursor) {
+    return textAroundCursor;
+  }
+  return {
+    textBeforeCursor: getFullEditorTextWithNewlines(editor),
+    textAfterCursor: "",
+    selectedText: ""
+  };
+}
+
+// src/components/base-copilot-textarea/render-element.tsx
+import { jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+function makeRenderElementFunction(suggestionsStyle) {
+  return (props) => {
+    switch (props.element.type) {
+      case "paragraph":
+        return /* @__PURE__ */ jsx11(DefaultElement, __spreadValues({}, props));
+      case "suggestion":
+        return /* @__PURE__ */ jsx11(SuggestionElement, __spreadProps(__spreadValues({}, props), { suggestionsStyle }));
+    }
+  };
+}
+var DefaultElement = (props) => {
+  return /* @__PURE__ */ jsx11("div", __spreadProps(__spreadValues({}, props.attributes), { children: props.children }));
+};
+var SuggestionElement = (props) => {
+  return /* @__PURE__ */ jsxs4(
+    "span",
+    __spreadProps(__spreadValues({}, props.attributes), {
+      style: __spreadValues({}, props.suggestionsStyle),
+      contentEditable: false,
+      children: [
+        props.children,
+        props.element.type === "suggestion" && props.element.content
+      ]
+    })
+  );
+};
+
+// src/components/base-copilot-textarea/render-placeholder.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function makeRenderPlaceholderFunction(placeholderStyle) {
+  return (props) => {
+    const _a = props.attributes, { style } = _a, restAttributes = __objRest(_a, ["style"]);
+    return /* @__PURE__ */ jsx12(
+      "div",
+      __spreadProps(__spreadValues({}, restAttributes), {
+        style: __spreadValues(__spreadValues({}, style), placeholderStyle),
+        children: props.children
+      })
+    );
+  };
+}
+
+// src/components/base-copilot-textarea/use-add-branding-css.tsx
+import { useEffect as useEffect5 } from "react";
+function useAddBrandingCss(suggestionStyleAugmented, disableBranding) {
+  const cssSelector = ".copilot-textarea.with-branding";
+  useEffect5(() => {
+    if (disableBranding) {
+      return;
+    }
+    const styleEl = document.createElement("style");
+    styleEl.id = "dynamic-styles";
+    let dynamicStyles = Object.entries(suggestionStyleAugmented).map(([key, value]) => {
+      const kebabCaseKey = key.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
+      return `${kebabCaseKey}: ${value};`;
+    }).join(" ");
+    dynamicStyles += `font-style: normal; font-size: x-small;`;
+    dynamicStyles += `content: "CopilotKit";`;
+    dynamicStyles += `bottom: 6px;`;
+    dynamicStyles += `right: 6px;`;
+    dynamicStyles += `pointer-events: none;`;
+    dynamicStyles += `font-weight: 200;`;
+    dynamicStyles += `padding: 0;`;
+    dynamicStyles += `margin: 0;`;
+    dynamicStyles += `border: 0;`;
+    dynamicStyles += `line-height: 1;`;
+    dynamicStyles += `position: absolute;`;
+    styleEl.innerHTML = `
+      ${cssSelector}::after {
+        ${dynamicStyles}
+      }
+    `;
+    document.head.appendChild(styleEl);
+    const textarea = document.querySelector(cssSelector);
+    const handleScroll = () => {
+      const styleEl2 = document.getElementById("dynamic-styles");
+      if (styleEl2 && textarea) {
+        const offsetFromBottom = -textarea.scrollTop + 6;
+        const offsetFromRight = -textarea.scrollLeft + 6;
+        styleEl2.innerHTML = `
+          ${cssSelector}::after {
+            ${dynamicStyles}
+            bottom: ${offsetFromBottom}px;
+            right: ${offsetFromRight}px;
+          }
+        `;
+      }
+    };
+    textarea == null ? void 0 : textarea.addEventListener("scroll", handleScroll);
+    return () => {
+      var _a;
+      (_a = document.getElementById("dynamic-styles")) == null ? void 0 : _a.remove();
+      textarea == null ? void 0 : textarea.removeEventListener("scroll", handleScroll);
+    };
+  }, [disableBranding, suggestionStyleAugmented]);
+}
+
+// src/components/base-copilot-textarea/track-cursor-moved-since-last-text-change.tsx
+import { useEffect as useEffect6, useRef as useRef3 } from "react";
+import { useSlateSelector } from "slate-react";
+import { Range as Range4 } from "slate";
+
+// src/lib/editor-to-text.ts
+import { Element as Element4 } from "slate";
+function nodeChildrenToTextComponents(editor, nodes) {
+  const indeciesOfInlineElements = new Set(
+    nodes.map((node, index) => {
+      if (Element4.isElement(node) && editor.isInline(node)) {
+        return index;
+      }
+      return -1;
+    }).filter((index) => index !== -1)
+  );
+  const nonIgnorableItems = nodes.filter((node, index) => {
+    const isInline = indeciesOfInlineElements.has(index);
+    if (isInline) {
+      return false;
+    }
+    const isNeighbourOfInline = indeciesOfInlineElements.has(index - 1) || indeciesOfInlineElements.has(index + 1);
+    if (isNeighbourOfInline) {
+      return node.text !== "";
+    }
+    return true;
+  });
+  return nonIgnorableItems.map((node) => {
+    if (Element4.isElement(node)) {
+      switch (node.type) {
+        case "paragraph":
+          return nodeChildrenToTextComponents(editor, node.children);
+        case "suggestion":
+          return [];
+      }
+    } else {
+      return [node];
+    }
+  }).reduce((acc, val) => acc.concat(val), []);
+}
+var editorToText = (editor) => {
+  const flattened = nodeChildrenToTextComponents(editor, editor.children);
+  const text = flattened.map((textComponent) => textComponent.text).join("\n");
+  return text;
+};
+
+// src/components/base-copilot-textarea/track-cursor-moved-since-last-text-change.tsx
+import { Fragment as Fragment2, jsx as jsx13 } from "react/jsx-runtime";
+function TrackerTextEditedSinceLastCursorMovement(props) {
+  const cursorState = useSlateSelector((state) => ({
+    selection: state.selection,
+    text: editorToText(state)
+  }));
+  const previousState = usePrevious(cursorState);
+  useEffect6(() => {
+    if (!previousState) {
+      return;
+    }
+    if (cursorChangedWithoutTextChanged(previousState, cursorState)) {
+      props.setCursorMovedSinceLastTextChange(true);
+    }
+  }, [props.setCursorMovedSinceLastTextChange, cursorState]);
+  return /* @__PURE__ */ jsx13(Fragment2, {});
+}
+var cursorChangedWithoutTextChanged = (prev, next) => {
+  const isSelectionChanged = !isSelectionEqual(prev.selection, next.selection);
+  const isTextSame = prev.text === next.text;
+  return isSelectionChanged && isTextSame;
+};
+var isSelectionEqual = (a, b) => {
+  if (!a && !b)
+    return true;
+  if (!a || !b)
+    return false;
+  return Range4.equals(a, b);
+};
+function usePrevious(value) {
+  const ref = useRef3();
+  useEffect6(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+
+// src/components/base-copilot-textarea/base-copilot-textarea.tsx
+import { jsx as jsx14, jsxs as jsxs5 } from "react/jsx-runtime";
+var BaseCopilotTextarea = React9.forwardRef(
+  (props, ref) => {
+    return /* @__PURE__ */ jsx14(HoveringEditorProvider, { children: /* @__PURE__ */ jsx14(BaseCopilotTextareaWithHoveringContext, __spreadProps(__spreadValues({}, props), { ref })) });
+  }
+);
+var BaseCopilotTextareaWithHoveringContext = React9.forwardRef(
+  (props, ref) => {
+    const autosuggestionsConfig = __spreadValues(__spreadValues({}, defaultBaseAutosuggestionsConfig), props.baseAutosuggestionsConfig);
+    const valueOnInitialRender = useMemo4(() => {
+      var _a2;
+      return (_a2 = props.value) != null ? _a2 : "";
+    }, []);
+    const [lastKnownFullEditorText, setLastKnownFullEditorText] = useState6(valueOnInitialRender);
+    const [cursorMovedSinceLastTextChange, setCursorMovedSinceLastTextChange] = useState6(false);
+    const initialValue = useMemo4(() => {
+      return [
+        {
+          type: "paragraph",
+          children: [{ text: valueOnInitialRender }]
+        }
+      ];
+    }, [valueOnInitialRender]);
+    const editor = useCopilotTextareaEditor();
+    const { isDisplayed: hoveringEditorIsDisplayed, setIsDisplayed: setHoveringEditorIsDisplayed } = useHoveringEditorContext();
+    const insertText = useCallback3(
+      (autosuggestion) => {
+        Editor5.insertText(editor, autosuggestion.text, {
+          at: autosuggestion.point
+        });
+      },
+      [editor]
+    );
+    const shouldDisableAutosuggestions = (
+      // textarea is manually disabled:
+      autosuggestionsConfig.disabled || // hovering editor is displayed:
+      hoveringEditorIsDisplayed || // the cursor has moved since the last text change AND we are configured to disable autosuggestions in this case:
+      cursorMovedSinceLastTextChange && autosuggestionsConfig.temporarilyDisableWhenMovingCursorWithoutChangingText
+    );
+    const {
+      currentAutocompleteSuggestion,
+      onChangeHandler: onChangeHandlerForAutocomplete,
+      onKeyDownHandler: onKeyDownHandlerForAutocomplete
+    } = useAutosuggestions(
+      autosuggestionsConfig.debounceTime,
+      autosuggestionsConfig.shouldAcceptAutosuggestionOnKeyPress,
+      autosuggestionsConfig.apiConfig.autosuggestionsFunction,
+      insertText,
+      autosuggestionsConfig.disableWhenEmpty,
+      shouldDisableAutosuggestions
+    );
+    const onKeyDownHandlerForHoveringEditor = useCallback3(
+      (event) => {
+        if (autosuggestionsConfig.shouldToggleHoveringEditorOnKeyPress(event)) {
+          event.preventDefault();
+          setHoveringEditorIsDisplayed(!hoveringEditorIsDisplayed);
+        }
+      },
+      [
+        hoveringEditorIsDisplayed,
+        setHoveringEditorIsDisplayed,
+        autosuggestionsConfig.shouldToggleHoveringEditorOnKeyPress
+      ]
+    );
+    useEffect7(() => {
+      clearAutocompletionsFromEditor(editor);
+      if (currentAutocompleteSuggestion) {
+        addAutocompletionsToEditor(
+          editor,
+          currentAutocompleteSuggestion.text,
+          currentAutocompleteSuggestion.point
+        );
+      }
+    }, [currentAutocompleteSuggestion]);
+    const suggestionStyleAugmented = useMemo4(() => {
+      return __spreadValues({
+        fontStyle: "italic",
+        color: "gray"
+      }, props.suggestionsStyle);
+    }, [props.suggestionsStyle]);
+    const renderElementMemoized = useMemo4(() => {
+      return makeRenderElementFunction(suggestionStyleAugmented);
+    }, [suggestionStyleAugmented]);
+    const renderPlaceholderMemoized = useMemo4(() => {
+      const placeholderStyleSlatejsOverrides = {
+        top: void 0
+      };
+      const placeholderStyleAugmented = __spreadValues(__spreadValues({}, placeholderStyleSlatejsOverrides), props.placeholderStyle);
+      return makeRenderPlaceholderFunction(placeholderStyleAugmented);
+    }, [props.placeholderStyle]);
+    useEffect7(() => {
+      var _a2, _b;
+      if (props.value === lastKnownFullEditorText) {
+        return;
+      }
+      setLastKnownFullEditorText((_a2 = props.value) != null ? _a2 : "");
+      replaceEditorText(editor, (_b = props.value) != null ? _b : "");
+    }, [props.value]);
+    const _a = props, {
+      placeholderStyle,
+      value,
+      hoverMenuClassname,
+      onValueChange,
+      baseAutosuggestionsConfig: autosuggestionsConfigFromProps,
+      className,
+      onChange,
+      onKeyDown,
+      disableBranding
+    } = _a, propsToForward = __objRest(_a, [
+      "placeholderStyle",
+      "value",
+      "hoverMenuClassname",
+      "onValueChange",
+      "baseAutosuggestionsConfig",
+      "className",
+      "onChange",
+      "onKeyDown",
+      "disableBranding"
+    ]);
+    useAddBrandingCss(suggestionStyleAugmented, disableBranding);
+    usePopulateCopilotTextareaRef(editor, ref);
+    const moddedClassName = (() => {
+      const baseClassName = "copilot-textarea";
+      const brandingClass = disableBranding ? "no-branding" : "with-branding";
+      const defaultTailwindClassName = "bg-white overflow-y-auto resize-y";
+      const mergedClassName = twMerge2(defaultTailwindClassName, className != null ? className : "");
+      return `${baseClassName} ${brandingClass} ${mergedClassName}`;
+    })();
+    return /* @__PURE__ */ jsxs5(
+      Slate,
+      {
+        editor,
+        initialValue,
+        onChange: (value2) => {
+          var _a2, _b;
+          const newEditorState = getTextAroundCollapsedCursor(editor);
+          const fullEditorText = newEditorState ? newEditorState.textBeforeCursor + newEditorState.textAfterCursor : getFullEditorTextWithNewlines(editor);
+          setLastKnownFullEditorText((prev) => {
+            if (prev !== fullEditorText) {
+              setCursorMovedSinceLastTextChange(false);
+            }
+            return fullEditorText;
+          });
+          onChangeHandlerForAutocomplete(newEditorState);
+          (_a2 = props.onValueChange) == null ? void 0 : _a2.call(props, fullEditorText);
+          (_b = props.onChange) == null ? void 0 : _b.call(props, makeSemiFakeReactTextAreaEvent(fullEditorText));
+        },
+        children: [
+          /* @__PURE__ */ jsx14(
+            TrackerTextEditedSinceLastCursorMovement,
+            {
+              setCursorMovedSinceLastTextChange
+            }
+          ),
+          /* @__PURE__ */ jsx14(
+            HoveringToolbar,
+            {
+              apiConfig: autosuggestionsConfig.apiConfig,
+              contextCategories: autosuggestionsConfig.contextCategories,
+              hoverMenuClassname
+            }
+          ),
+          /* @__PURE__ */ jsx14(
+            Editable,
+            __spreadValues({
+              renderElement: renderElementMemoized,
+              renderPlaceholder: renderPlaceholderMemoized,
+              onKeyDown: (event) => {
+                var _a2;
+                onKeyDownHandlerForHoveringEditor(event);
+                onKeyDownHandlerForAutocomplete(event);
+                (_a2 = props.onKeyDown) == null ? void 0 : _a2.call(props, event);
+              },
+              className: moddedClassName
+            }, propsToForward)
+          )
+        ]
+      }
+    );
+  }
+);
+function makeSemiFakeReactTextAreaEvent(currentText) {
+  return {
+    target: {
+      value: currentText,
+      type: "copilot-textarea"
+    },
+    currentTarget: {
+      value: currentText,
+      type: "copilot-textarea"
+    }
+  };
+}
+
+// src/components/copilot-textarea/copilot-textarea.tsx
+import React10 from "react";
+
+// src/hooks/make-autosuggestions-function/use-make-standard-autosuggestions-function.tsx
+import { CopilotContext as CopilotContext2 } from "@copilotkit/react-core";
+import { useCallback as useCallback4, useContext as useContext3 } from "react";
+
+// src/types/autosuggestions-config/suggestions-api-config.tsx
+var defaultSuggestionsMakeSystemPrompt = (textareaPurpose, contextString) => {
+  return `You are a versatile writing assistant.
+  
+The user is writing some text.
+The purpose is: "${textareaPurpose}"
+
+Your job is to guess what the user will write next AS BEST YOU CAN.
+Only guess a SHORT distance ahead. Usually 1 sentence, or at most 1 paragraph.
+
+Adjust yourself to the user's style and implied intent.
+
+The user will provide both the text before and after the cursor. You should use this to infer what the user is likely to write next.
+<TextAfterCursor>
+<TextBeforeCursor>
+<YourSuggestion>
+
+If we need to add a whitespace character to the suggested text, make sure to explicitly add it in.
+
+The following external context is also provided. Use it to help you make better suggestions!!!
+\`\`\`
+${contextString}
+\`\`\`
+`;
+};
+var defaultSuggestionsFewShotMessages = [
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "While I was there I also picked up some apples, oranges, and bananas."
+  },
+  {
+    role: "user",
+    content: "This morning I woke up and went straight to the grocery store."
+  },
+  {
+    role: "assistant",
+    content: " When I arrived I went straight to the produce section and picked out a big watermelon. "
+  },
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "and (iii) to the appointment of the Equityholders' Representative pursuant to Section 10.7 of the Merger Agreement and to the provisions thereof."
+  },
+  {
+    role: "user",
+    name: "TextBeforeCursor",
+    content: `The Optionholder, in the Optionholder's capacity as a holder of vested Options, hereby irrevocably and unconditionally agrees: (i) that the Optionholder shall be deemed an "Equityholder" under the Merger Agreement and shall be entitled to the rights and benefits, and subject to the obligations, of an "Equityholder" thereunder;`
+  },
+  {
+    role: "assistant",
+    content: ` (ii) that, for purposes of this Agreement and the Merger Agreement, the applicable percentage set forth opposite the name of the Optionholder in the Distribution Waterfall shall be such the Optionholder's "Pro Rata Share"; `
+  }
+];
+var defaultSuggestionsApiConfig = {
+  makeSystemPrompt: defaultSuggestionsMakeSystemPrompt,
+  fewShotMessages: defaultSuggestionsFewShotMessages,
+  forwardedParams: void 0
+};
+
+// src/types/autosuggestions-config/insertions-api-config.tsx
+var defaultInsertionsMakeSystemPrompt = (textareaPurpose, contextString) => {
+  return `You are a versatile writing assistant.
+  
+The user is writing some text.
+The purpose is: "${textareaPurpose}"
+
+The following external context is also provided. Use it to help you make better suggestions!!!
+\`\`\`
+${contextString}
+\`\`\`
+
+The user also provides you with a prompt for INSERTIONS into the text they are writing. 
+Your job is to come up with an INSERTION into the text that the user would like AS BEST YOU CAN.
+Only insert a SHORT segment. Usually 1 sentence, or at most 1 paragraph.
+
+Adjust yourself to the user's style and implied intent.
+
+The user will provide the text before and after the cursor, as well as the insertion prompt. You should use this to infer the best relevant insertion.
+<TextAfterCursor>
+<TextBeforeCursor>
+<InsertionPrompt>
+<YourSuggestion>
+`;
+};
+var defaultInsertionsFewShotMessages = [
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "While I was there I also picked up some apples, oranges, and bananas."
+  },
+  {
+    role: "user",
+    name: "TextBeforeCursor",
+    content: "This morning I woke up and went straight to the grocery store."
+  },
+  {
+    role: "user",
+    name: "InsertionPrompt",
+    content: "I bought a big watermelon"
+  },
+  {
+    role: "assistant",
+    content: " When I arrived I went straight to the produce section and picked out a big watermelon. "
+  },
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "and (iii) to the appointment of the Equityholders' Representative pursuant to Section 10.7 of the Merger Agreement and to the provisions thereof."
+  },
+  {
+    role: "user",
+    name: "TextBeforeCursor",
+    content: `The Optionholder, in the Optionholder's capacity as a holder of vested Options, hereby irrevocably and unconditionally agrees: (i) that the Optionholder shall be deemed an "Equityholder" under the Merger Agreement and shall be entitled to the rights and benefits, and subject to the obligations, of an "Equityholder" thereunder;`
+  },
+  {
+    role: "user",
+    name: "InsertionPrompt",
+    content: "add section about the optionholder's pro rata share"
+  },
+  {
+    role: "assistant",
+    content: ` (ii) that, for purposes of this Agreement and the Merger Agreement, the applicable percentage set forth opposite the name of the Optionholder in the Distribution Waterfall shall be such the Optionholder's "Pro Rata Share"; `
+  }
+];
+var defaultInsertionsApiConfig = {
+  makeSystemPrompt: defaultInsertionsMakeSystemPrompt,
+  fewShotMessages: defaultInsertionsFewShotMessages,
+  forwardedParams: void 0
+};
+
+// src/types/autosuggestions-config/editing-api-config.tsx
+var defaultEditingMakeSystemPrompt = (textareaPurpose, contextString) => {
+  return `You are a versatile writing assistant.
+  
+The user is writing some text.
+The purpose is: "${textareaPurpose}"
+
+The following external context is also provided. Use it to help you make better suggestions!!!
+\`\`\`
+${contextString}
+\`\`\`
+
+The user also provides you with a prompt for EDITING some text they are writing. 
+Your job is to come up with an EDIT of the text that the user would like to use - AS BEST YOU CAN.
+
+Adjust yourself to the user's style and implied intent.
+
+The user will provide the following information; use this to infer the best relevant EDIT:
+<TextBeforeCursor>
+<TextToEdit>
+<TextAfterCursor>
+<EditingPrompt>
+
+<YourEditSuggestion>
+`;
+};
+var defaultEditingFewShotMessages = [
+  {
+    role: "user",
+    name: "TextBeforeCursor",
+    content: "This morning I woke up and went straight to the grocery store. "
+  },
+  {
+    role: "user",
+    name: "TextToEdit",
+    content: "While I was there I also picked up some apples, oranges, and bananas. "
+  },
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "The grocery store was having a sale on fruit, so I decided to stock up."
+  },
+  {
+    role: "user",
+    name: "EditingPrompt",
+    content: "I bought a big watermelon"
+  },
+  {
+    role: "assistant",
+    content: " When I arrived I went straight to the produce section and picked out a big watermelon. "
+  },
+  {
+    role: "user",
+    name: "TextAfterCursor",
+    content: "and (iii) to the appointment of the Equityholders' Representative pursuant to Section 10.7 of the Merger Agreement and to the provisions thereof."
+  },
+  {
+    role: "user",
+    name: "TextBeforeCursor",
+    content: `The Optionholder, in the Optionholder's capacity as a holder of vested Options, hereby irrevocably and unconditionally agrees: (i) that the Optionholder shall be deemed an "Equityholder" under the Merger Agreement and shall be entitled to the rights and benefits, and subject to the obligations, of an "Equityholder" thereunder;`
+  },
+  {
+    role: "user",
+    name: "InsertionPrompt",
+    content: "add section about the optionholder's pro rata share"
+  },
+  {
+    role: "assistant",
+    content: ` (ii) that, for purposes of this Agreement and the Merger Agreement, the applicable percentage set forth opposite the name of the Optionholder in the Distribution Waterfall shall be such the Optionholder's "Pro Rata Share"; `
+  }
+];
+var defaultEditingApiConfig = {
+  makeSystemPrompt: defaultEditingMakeSystemPrompt,
+  fewShotMessages: defaultEditingFewShotMessages,
+  forwardedParams: void 0
+};
+
+// src/types/autosuggestions-config/autosuggestions-config.tsx
+import { defaultCopilotContextCategories as defaultCopilotContextCategories2 } from "@copilotkit/react-core";
+var defaultAutosuggestionsConfig = __spreadProps(__spreadValues({}, defaultBaseAutosuggestionsConfig), {
+  contextCategories: defaultCopilotContextCategories2,
+  chatApiConfigs: {
+    suggestionsApiConfig: defaultSuggestionsApiConfig,
+    insertionApiConfig: defaultInsertionsApiConfig,
+    editingApiConfig: defaultEditingApiConfig
+  }
+});
+
+// src/types/autosuggestions-config/subtypes/chatlike-api-endpoint.tsx
+import { copilotApiConfigExtrapolator } from "@copilotkit/react-core";
+var ChatlikeApiEndpoint = class {
+  constructor(run) {
+    this.run = run;
+  }
+  /**
+   * Creates a new instance of ChatlikeApiEndpoint with the provided API endpoint.
+   * @param apiEndpoint The URL of the OpenAI-compatible API endpoint.
+   * @returns A new instance of ChatlikeApiEndpoint.
+   */
+  static fromCopilotApiConfig(copilotApiConfig) {
+    return new ChatlikeApiEndpoint(
+      (abortSignal, messages, forwardedProps) => __async(this, null, function* () {
+        const res = yield fetch(copilotApiConfigExtrapolator(copilotApiConfig).chatApiEndpoint, {
+          method: "POST",
+          headers: __spreadValues({}, copilotApiConfig.headers),
+          body: JSON.stringify(__spreadProps(__spreadValues(__spreadValues({}, forwardedProps), copilotApiConfig.body), {
+            messages
+          })),
+          signal: abortSignal
+        });
+        const bodySteram = res.body;
+        if (!bodySteram) {
+          throw new Error("The response body is empty.");
+        }
+        const stringStream = bodySteram.pipeThrough(new TextDecoderStream());
+        return stringStream;
+      })
+    );
+  }
+  /**
+   * Creates a fully customized instance of ChatlikeApiEndpoint.
+   * @param run - The implementation of the ChatlikeApiEndpointImpl interface.
+   * @returns A new instance of ChatlikeApiEndpoint .
+   */
+  static custom(run) {
+    return new ChatlikeApiEndpoint(run);
+  }
+};
+
+// src/lib/retry.tsx
+function retry(fn, retriesLeft = 2, interval = 200, backoff = 1.5) {
+  return new Promise((resolve, reject) => {
+    fn().then(resolve).catch((error) => {
+      if (retriesLeft === 1) {
+        reject(error);
+        return;
+      }
+      setTimeout(() => {
+        retry(fn, retriesLeft - 1, interval * backoff, backoff).then(resolve).catch(reject);
+      }, interval);
+    });
+  });
+}
+
+// src/hooks/make-autosuggestions-function/use-make-standard-autosuggestions-function.tsx
+function useMakeStandardAutosuggestionFunction(textareaPurpose, contextCategories, apiConfig) {
+  const { getContextString, copilotApiConfig } = useContext3(CopilotContext2);
+  return useCallback4(
+    (editorState2, abortSignal) => __async(this, null, function* () {
+      const res = yield retry(() => __async(this, null, function* () {
+        const messages = [
+          {
+            role: "system",
+            content: apiConfig.makeSystemPrompt(
+              textareaPurpose,
+              getContextString([], contextCategories)
+            )
+          },
+          ...apiConfig.fewShotMessages,
+          {
+            role: "user",
+            name: "TextAfterCursor",
+            content: editorState2.textAfterCursor
+          },
+          {
+            role: "user",
+            name: "TextBeforeCursor",
+            content: editorState2.textBeforeCursor
+          }
+        ];
+        const apiEndpoint = ChatlikeApiEndpoint.fromCopilotApiConfig(copilotApiConfig);
+        const stream = yield apiEndpoint.run(abortSignal, messages, apiConfig.forwardedParams);
+        const reader = stream.getReader();
+        let result = "";
+        while (true) {
+          const { done, value } = yield reader.read();
+          if (done) {
+            break;
+          }
+          result += value;
+        }
+        return result;
+      }));
+      return res;
+    }),
+    [apiConfig, getContextString, contextCategories, textareaPurpose]
+  );
+}
+
+// src/hooks/make-autosuggestions-function/use-make-standard-insertion-function.tsx
+import { CopilotContext as CopilotContext3 } from "@copilotkit/react-core";
+import { useCallback as useCallback5, useContext as useContext4 } from "react";
+function useMakeStandardInsertionOrEditingFunction(textareaPurpose, contextCategories, insertionApiConfig, editingApiConfig) {
+  const { getContextString, copilotApiConfig } = useContext4(CopilotContext3);
+  const insertionFunction = useCallback5(
+    (editorState2, insertionPrompt, documents, abortSignal) => __async(this, null, function* () {
+      const res = yield retry(() => __async(this, null, function* () {
+        const messages = [
+          {
+            role: "system",
+            content: insertionApiConfig.makeSystemPrompt(
+              textareaPurpose,
+              getContextString(documents, contextCategories)
+            )
+          },
+          ...insertionApiConfig.fewShotMessages,
+          {
+            role: "user",
+            name: "TextAfterCursor",
+            content: editorState2.textAfterCursor
+          },
+          {
+            role: "user",
+            name: "TextBeforeCursor",
+            content: editorState2.textBeforeCursor
+          },
+          {
+            role: "user",
+            name: "InsertionPrompt",
+            content: insertionPrompt
+          }
+        ];
+        const apiEndpoint = ChatlikeApiEndpoint.fromCopilotApiConfig(copilotApiConfig);
+        return yield apiEndpoint.run(abortSignal, messages, insertionApiConfig.forwardedParams);
+      }));
+      return res;
+    }),
+    [insertionApiConfig, getContextString, contextCategories, textareaPurpose]
+  );
+  const editingFunction = useCallback5(
+    (editorState2, editingPrompt, documents, abortSignal) => __async(this, null, function* () {
+      const res = yield retry(() => __async(this, null, function* () {
+        const messages = [
+          {
+            role: "system",
+            content: editingApiConfig.makeSystemPrompt(
+              textareaPurpose,
+              getContextString(documents, contextCategories)
+            )
+          },
+          ...editingApiConfig.fewShotMessages,
+          {
+            role: "user",
+            name: "TextBeforeCursor",
+            content: editorState2.textBeforeCursor
+          },
+          {
+            role: "user",
+            name: "TextToEdit",
+            content: editorState2.selectedText
+          },
+          {
+            role: "user",
+            name: "TextAfterCursor",
+            content: editorState2.textAfterCursor
+          },
+          {
+            role: "user",
+            name: "EditingPrompt",
+            content: editingPrompt
+          }
+        ];
+        const apiEndpoint = ChatlikeApiEndpoint.fromCopilotApiConfig(copilotApiConfig);
+        return yield apiEndpoint.run(abortSignal, messages, editingApiConfig.forwardedParams);
+      }));
+      return res;
+    }),
+    [editingApiConfig, getContextString, contextCategories, textareaPurpose]
+  );
+  const insertionOrEditingFunction = useCallback5(
+    (editorState2, insertionPrompt, documents, abortSignal) => __async(this, null, function* () {
+      if (editorState2.selectedText === "") {
+        return yield insertionFunction(editorState2, insertionPrompt, documents, abortSignal);
+      } else {
+        return yield editingFunction(editorState2, insertionPrompt, documents, abortSignal);
+      }
+    }),
+    [insertionFunction, editingFunction]
+  );
+  return insertionOrEditingFunction;
+}
+
+// src/components/copilot-textarea/copilot-textarea.tsx
+import merge from "lodash.merge";
+import { Fragment as Fragment3, jsx as jsx15 } from "react/jsx-runtime";
+var CopilotTextarea = React10.forwardRef(
+  (props, ref) => {
+    const _a = props, { autosuggestionsConfig: autosuggestionsConfigUserSpecified } = _a, forwardedProps = __objRest(_a, ["autosuggestionsConfig"]);
+    const autosuggestionsConfig = merge(
+      defaultAutosuggestionsConfig,
+      autosuggestionsConfigUserSpecified
+    );
+    const autosuggestionsFunction = useMakeStandardAutosuggestionFunction(
+      autosuggestionsConfig.textareaPurpose,
+      autosuggestionsConfig.contextCategories,
+      autosuggestionsConfig.chatApiConfigs.suggestionsApiConfig
+    );
+    const insertionOrEditingFunction = useMakeStandardInsertionOrEditingFunction(
+      autosuggestionsConfig.textareaPurpose,
+      autosuggestionsConfig.contextCategories,
+      autosuggestionsConfig.chatApiConfigs.insertionApiConfig,
+      autosuggestionsConfig.chatApiConfigs.editingApiConfig
+    );
+    return /* @__PURE__ */ jsx15(Fragment3, { children: /* @__PURE__ */ jsx15(
+      BaseCopilotTextarea,
+      __spreadProps(__spreadValues({
+        ref
+      }, forwardedProps), {
+        baseAutosuggestionsConfig: __spreadProps(__spreadValues({}, autosuggestionsConfig), {
+          apiConfig: {
+            insertionOrEditingFunction,
+            autosuggestionsFunction
+          }
+        })
+      })
+    ) });
+  }
+);
+export {
+  BaseCopilotTextarea,
+  ChatlikeApiEndpoint,
+  CopilotTextarea,
+  defaultAutosuggestionsConfig,
+  defaultBaseAutosuggestionsConfig
+};
 //# sourceMappingURL=index.mjs.map