@baasix/lexical 0.0.2

package/dist/chunk-I43VQAHW.js

@@ -0,0 +1,918 @@
+// src/context/SettingsContext.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_SETTINGS = {
+  isCollab: false,
+  useCollabV2: false,
+  isRichText: true,
+  emptyEditor: false,
+  isCharLimit: false,
+  isCharLimitUtf8: false,
+  isAutocomplete: false,
+  isMaxLength: false,
+  showTreeView: false,
+  showTableOfContents: false,
+  shouldUseLexicalContextMenu: false,
+  shouldPreserveNewLinesInMarkdown: false,
+  tableCellMerge: true,
+  tableCellBackgroundColor: true,
+  tableScrollShadow: true,
+  tableFitNestedTables: true,
+  tableHorizontalScroll: true,
+  hasLinkAttributes: false,
+  hasNestedTables: true,
+  hasFitNestedTables: true,
+  isCodeHighlighted: true,
+  isCodeShiki: false,
+  selectionAlwaysOnDisplay: false,
+  listStrictIndent: false,
+  shouldAllowHighlightingWithBrackets: false,
+  shouldDisableFocusOnClickChecklist: false
+};
+var INITIAL_SETTINGS = {
+  ...DEFAULT_SETTINGS
+};
+var Context = createContext({
+  setOption: (_name, _value) => {
+    return;
+  },
+  settings: INITIAL_SETTINGS
+});
+var SettingsContext = ({
+  children
+}) => {
+  const [settings, setSettings] = useState(INITIAL_SETTINGS);
+  const setOption = useCallback((setting, value) => {
+    setSettings((options) => ({
+      ...options,
+      [setting]: value
+    }));
+  }, []);
+  const contextValue = useMemo(() => {
+    return { setOption, settings };
+  }, [setOption, settings]);
+  return /* @__PURE__ */ jsx(Context.Provider, { value: contextValue, children });
+};
+var useSettings = () => {
+  return useContext(Context);
+};
+
+// src/plugins/EmojisPlugin/index.ts
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { TextNode as TextNode2 } from "lexical";
+import { useEffect } from "react";
+
+// src/nodes/EmojiNode.tsx
+import { $applyNodeReplacement, TextNode } from "lexical";
+var EmojiNode = class _EmojiNode extends TextNode {
+  __className;
+  static getType() {
+    return "emoji";
+  }
+  static clone(node) {
+    return new _EmojiNode(node.__className, node.__text, node.__key);
+  }
+  constructor(className, text, key) {
+    super(text, key);
+    this.__className = className;
+  }
+  createDOM(config) {
+    const dom = document.createElement("span");
+    const inner = super.createDOM(config);
+    dom.className = this.__className;
+    inner.className = "emoji-inner";
+    dom.appendChild(inner);
+    return dom;
+  }
+  updateDOM(prevNode, dom, config) {
+    const inner = dom.firstChild;
+    if (inner === null) {
+      return true;
+    }
+    super.updateDOM(prevNode, inner, config);
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createEmojiNode(
+      serializedNode.className,
+      serializedNode.text
+    ).updateFromJSON(serializedNode);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      className: this.getClassName()
+    };
+  }
+  getClassName() {
+    const self = this.getLatest();
+    return self.__className;
+  }
+};
+function $createEmojiNode(className, emojiText) {
+  const node = new EmojiNode(className, emojiText).setMode("token");
+  return $applyNodeReplacement(node);
+}
+
+// src/plugins/EmojisPlugin/index.ts
+var emojis = /* @__PURE__ */ new Map([
+  [":)", ["emoji happysmile", "\u{1F642}"]],
+  [":D", ["emoji veryhappysmile", "\u{1F600}"]],
+  [":(", ["emoji unhappysmile", "\u{1F641}"]],
+  ["<3", ["emoji heart", "\u2764"]]
+]);
+function $findAndTransformEmoji(node) {
+  const text = node.getTextContent();
+  for (let i = 0; i < text.length; i++) {
+    const emojiData = emojis.get(text[i]) || emojis.get(text.slice(i, i + 2));
+    if (emojiData !== void 0) {
+      const [emojiStyle, emojiText] = emojiData;
+      let targetNode;
+      if (i === 0) {
+        [targetNode] = node.splitText(i + 2);
+      } else {
+        [, targetNode] = node.splitText(i, i + 2);
+      }
+      const emojiNode = $createEmojiNode(emojiStyle, emojiText);
+      targetNode.replace(emojiNode);
+      return emojiNode;
+    }
+  }
+  return null;
+}
+function $textNodeTransform(node) {
+  let targetNode = node;
+  while (targetNode !== null) {
+    if (!targetNode.isSimpleText()) {
+      return;
+    }
+    targetNode = $findAndTransformEmoji(targetNode);
+  }
+}
+function useEmojis(editor) {
+  useEffect(() => {
+    if (!editor.hasNodes([EmojiNode])) {
+      throw new Error("EmojisPlugin: EmojiNode not registered on editor");
+    }
+    return editor.registerNodeTransform(TextNode2, $textNodeTransform);
+  }, [editor]);
+}
+function EmojisPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEmojis(editor);
+  return null;
+}
+
+// src/plugins/KeywordsPlugin/index.ts
+import { useLexicalComposerContext as useLexicalComposerContext2 } from "@lexical/react/LexicalComposerContext";
+import { useLexicalTextEntity } from "@lexical/react/useLexicalTextEntity";
+import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
+
+// src/nodes/KeywordNode.ts
+import { $applyNodeReplacement as $applyNodeReplacement2, TextNode as TextNode3 } from "lexical";
+var KeywordNode = class _KeywordNode extends TextNode3 {
+  static getType() {
+    return "keyword";
+  }
+  static clone(node) {
+    return new _KeywordNode(node.__text, node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createKeywordNode().updateFromJSON(serializedNode);
+  }
+  createDOM(config) {
+    const dom = super.createDOM(config);
+    dom.style.cursor = "default";
+    dom.className = "keyword";
+    return dom;
+  }
+  canInsertTextBefore() {
+    return false;
+  }
+  canInsertTextAfter() {
+    return false;
+  }
+  isTextEntity() {
+    return true;
+  }
+};
+function $createKeywordNode(keyword = "") {
+  return $applyNodeReplacement2(new KeywordNode(keyword));
+}
+
+// src/plugins/KeywordsPlugin/index.ts
+var KEYWORDS_REGEX = /(^|$|[^A-Za-zªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎↃↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々〆〱-〵〻〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ])(congrats|congratulations|gratuluju|gratuluji|gratulujeme|blahopřeju|blahopřeji|blahopřejeme|Til lykke|Tillykke|Glückwunsch|Gratuliere|felicitaciones|enhorabuena|paljon onnea|onnittelut|Félicitations|gratula|gratulálok|gratulálunk|congratulazioni|complimenti|おめでとう|おめでとうございます|축하해|축하해요|gratulerer|Gefeliciteerd|gratulacje|Parabéns|parabéns|felicitações|felicitări|мои поздравления|поздравляем|поздравляю|gratulujem|blahoželám|ยินดีด้วย|ขอแสดงความยินดี|tebrikler|tebrik ederim|恭喜|祝贺你|恭喜你|恭喜|恭喜|baie geluk|veels geluk|অভিনন্দন|Čestitam|Čestitke|Čestitamo|Συγχαρητήρια|Μπράβο|અભિનંદન|badhai|बधाई|अभिनंदन|Честитам|Свака част|hongera|வாழ்த்துகள்|வாழ்த்துக்கள்|అభినందనలు|അഭിനന്ദനങ്ങൾ|Chúc mừng|מזל טוב|mazel tov|mazal tov)(^|$|[^A-Za-zªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎↃↄⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々〆〱-〵〻〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛥꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ])/i;
+function KeywordsPlugin() {
+  const [editor] = useLexicalComposerContext2();
+  useEffect2(() => {
+    if (!editor.hasNodes([KeywordNode])) {
+      throw new Error("KeywordsPlugin: KeywordNode not registered on editor");
+    }
+  }, [editor]);
+  const $createKeywordNode_ = useCallback2((textNode) => {
+    return $createKeywordNode(textNode.getTextContent());
+  }, []);
+  const getKeywordMatch = useCallback2((text) => {
+    const matchArr = KEYWORDS_REGEX.exec(text);
+    if (matchArr === null) {
+      return null;
+    }
+    const hashtagLength = matchArr[2].length;
+    const startOffset = matchArr.index + matchArr[1].length;
+    const endOffset = startOffset + hashtagLength;
+    return {
+      end: endOffset,
+      start: startOffset
+    };
+  }, []);
+  useLexicalTextEntity(
+    getKeywordMatch,
+    KeywordNode,
+    $createKeywordNode_
+  );
+  return null;
+}
+
+// src/plugins/LinkPlugin/index.tsx
+import { LinkPlugin as LexicalLinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+
+// src/utils/url.ts
+var SUPPORTED_URL_PROTOCOLS = /* @__PURE__ */ new Set([
+  "http:",
+  "https:",
+  "mailto:",
+  "sms:",
+  "tel:"
+]);
+function sanitizeUrl(url) {
+  try {
+    const parsedUrl = new URL(url);
+    if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {
+      return "about:blank";
+    }
+  } catch {
+    return url;
+  }
+  return url;
+}
+var urlRegExp = new RegExp(
+  /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
+);
+function validateUrl(url) {
+  return url === "https://" || urlRegExp.test(url);
+}
+
+// src/plugins/LinkPlugin/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function LinkPlugin({
+  hasLinkAttributes = false
+}) {
+  return /* @__PURE__ */ jsx2(
+    LexicalLinkPlugin,
+    {
+      validateUrl,
+      attributes: hasLinkAttributes ? {
+        rel: "noopener noreferrer",
+        target: "_blank"
+      } : void 0
+    }
+  );
+}
+
+// src/plugins/MentionsPlugin/index.tsx
+import { useLexicalComposerContext as useLexicalComposerContext3 } from "@lexical/react/LexicalComposerContext";
+import {
+  LexicalTypeaheadMenuPlugin,
+  MenuOption,
+  useBasicTypeaheadTriggerMatch
+} from "@lexical/react/LexicalTypeaheadMenuPlugin";
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo2, useState as useState2 } from "react";
+import * as ReactDOM from "react-dom";
+
+// src/context/EditorConfigContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var EditorConfigContext = createContext2(null);
+function EditorConfigProvider({
+  baasixClient,
+  folder,
+  children
+}) {
+  return /* @__PURE__ */ jsx3(EditorConfigContext.Provider, { value: { baasixClient, folder }, children });
+}
+function useEditorConfig() {
+  const ctx = useContext2(EditorConfigContext);
+  if (!ctx) {
+    throw new Error("useEditorConfig must be used within EditorConfigProvider");
+  }
+  return ctx;
+}
+
+// src/nodes/MentionNode.ts
+import {
+  $applyNodeReplacement as $applyNodeReplacement3,
+  TextNode as TextNode4
+} from "lexical";
+function $convertMentionElement(domNode) {
+  const textContent = domNode.textContent;
+  const mentionName = domNode.getAttribute("data-lexical-mention-name");
+  if (textContent !== null) {
+    const node = $createMentionNode(
+      typeof mentionName === "string" ? mentionName : textContent,
+      textContent
+    );
+    return {
+      node
+    };
+  }
+  return null;
+}
+var mentionStyle = "background-color: rgba(24, 119, 232, 0.2)";
+var MentionNode = class _MentionNode extends TextNode4 {
+  __mention;
+  static getType() {
+    return "mention";
+  }
+  static clone(node) {
+    return new _MentionNode(node.__mention, node.__text, node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createMentionNode(serializedNode.mentionName).updateFromJSON(
+      serializedNode
+    );
+  }
+  constructor(mentionName, text, key) {
+    super(text ?? mentionName, key);
+    this.__mention = mentionName;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      mentionName: this.__mention
+    };
+  }
+  createDOM(config) {
+    const dom = super.createDOM(config);
+    dom.style.cssText = mentionStyle;
+    dom.className = "mention";
+    dom.spellcheck = false;
+    return dom;
+  }
+  exportDOM() {
+    const element = document.createElement("span");
+    element.setAttribute("data-lexical-mention", "true");
+    if (this.__text !== this.__mention) {
+      element.setAttribute("data-lexical-mention-name", this.__mention);
+    }
+    element.textContent = this.__text;
+    return { element };
+  }
+  static importDOM() {
+    return {
+      span: (domNode) => {
+        if (!domNode.hasAttribute("data-lexical-mention")) {
+          return null;
+        }
+        return {
+          conversion: $convertMentionElement,
+          priority: 1
+        };
+      }
+    };
+  }
+  isTextEntity() {
+    return true;
+  }
+  canInsertTextBefore() {
+    return false;
+  }
+  canInsertTextAfter() {
+    return false;
+  }
+};
+function $createMentionNode(mentionName, textContent) {
+  const mentionNode = new MentionNode(mentionName, textContent = mentionName);
+  mentionNode.setMode("segmented").toggleDirectionless();
+  return $applyNodeReplacement3(mentionNode);
+}
+
+// src/plugins/MentionsPlugin/index.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var PUNCTUATION = `\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'"~=<>_:;`;
+var NAME = "\\b[A-Z][^\\s" + PUNCTUATION + "]";
+var DocumentMentionsRegex = {
+  NAME,
+  PUNCTUATION
+};
+var PUNC = DocumentMentionsRegex.PUNCTUATION;
+var TRIGGERS = ["@"].join("");
+var VALID_CHARS = "[^" + TRIGGERS + PUNC + "\\s]";
+var VALID_JOINS = "(?:\\.[ |$]| |[" + PUNC + "]|)";
+var LENGTH_LIMIT = 75;
+var AtSignMentionsRegex = new RegExp(
+  "(^|\\s|\\()([" + TRIGGERS + "]((?:" + VALID_CHARS + VALID_JOINS + "){0," + LENGTH_LIMIT + "}))$"
+);
+var ALIAS_LENGTH_LIMIT = 50;
+var AtSignMentionsRegexAliasRegex = new RegExp(
+  "(^|\\s|\\()([" + TRIGGERS + "]((?:" + VALID_CHARS + "){0," + ALIAS_LENGTH_LIMIT + "}))$"
+);
+var SUGGESTION_LIST_LENGTH_LIMIT = 5;
+var mentionsCache = /* @__PURE__ */ new Map();
+async function searchBaasixUsers(client, query) {
+  if (!query || query.length < 1) return [];
+  try {
+    const response = await client.items("baasix_User").find({ search: query, fields: ["id", "fullName"], limit: 10 });
+    return (response?.data || []).map(
+      (user) => user.fullName || user.id
+    );
+  } catch {
+    return [];
+  }
+}
+function useMentionLookupService(client, mentionString) {
+  const [results, setResults] = useState2([]);
+  useEffect3(() => {
+    if (mentionString == null) {
+      setResults([]);
+      return;
+    }
+    const cachedResults = mentionsCache.get(mentionString);
+    if (cachedResults === null) {
+      return;
+    }
+    if (cachedResults !== void 0) {
+      setResults(cachedResults);
+      return;
+    }
+    mentionsCache.set(mentionString, null);
+    let cancelled = false;
+    searchBaasixUsers(client, mentionString).then((newResults) => {
+      mentionsCache.set(mentionString, newResults);
+      if (!cancelled) {
+        setResults(newResults);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [mentionString]);
+  return results;
+}
+function checkForAtSignMentions(text, minMatchLength) {
+  let match = AtSignMentionsRegex.exec(text);
+  if (match === null) {
+    match = AtSignMentionsRegexAliasRegex.exec(text);
+  }
+  if (match !== null) {
+    const maybeLeadingWhitespace = match[1];
+    const matchingString = match[3];
+    if (matchingString.length >= minMatchLength) {
+      return {
+        leadOffset: match.index + maybeLeadingWhitespace.length,
+        matchingString,
+        replaceableString: match[2]
+      };
+    }
+  }
+  return null;
+}
+function getPossibleQueryMatch(text) {
+  return checkForAtSignMentions(text, 1);
+}
+var MentionTypeaheadOption = class extends MenuOption {
+  name;
+  picture;
+  constructor(name, picture) {
+    super(name);
+    this.name = name;
+    this.picture = picture;
+  }
+};
+function MentionsTypeaheadMenuItem({
+  index,
+  isSelected,
+  onClick,
+  onMouseEnter,
+  option
+}) {
+  let className = "item";
+  if (isSelected) {
+    className += " selected";
+  }
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      tabIndex: -1,
+      className,
+      ref: option.setRefElement,
+      role: "option",
+      "aria-selected": isSelected,
+      id: "typeahead-item-" + index,
+      onMouseEnter,
+      onClick,
+      children: [
+        option.picture,
+        /* @__PURE__ */ jsx4("span", { className: "text", children: option.name })
+      ]
+    },
+    option.key
+  );
+}
+function NewMentionsPlugin() {
+  const [editor] = useLexicalComposerContext3();
+  const { baasixClient } = useEditorConfig();
+  const [queryString, setQueryString] = useState2(null);
+  const results = useMentionLookupService(baasixClient, queryString);
+  const checkForSlashTriggerMatch = useBasicTypeaheadTriggerMatch("/", {
+    minLength: 0
+  });
+  const options = useMemo2(
+    () => results.map(
+      (result) => new MentionTypeaheadOption(result, /* @__PURE__ */ jsx4("i", { className: "icon user" }))
+    ).slice(0, SUGGESTION_LIST_LENGTH_LIMIT),
+    [results]
+  );
+  const onSelectOption = useCallback3(
+    (selectedOption, nodeToReplace, closeMenu) => {
+      editor.update(() => {
+        const mentionNode = $createMentionNode(selectedOption.name);
+        if (nodeToReplace) {
+          nodeToReplace.replace(mentionNode);
+        }
+        mentionNode.select();
+        closeMenu();
+      });
+    },
+    [editor]
+  );
+  const checkForMentionMatch = useCallback3(
+    (text) => {
+      const slashMatch = checkForSlashTriggerMatch(text, editor);
+      if (slashMatch !== null) {
+        return null;
+      }
+      return getPossibleQueryMatch(text);
+    },
+    [checkForSlashTriggerMatch, editor]
+  );
+  return /* @__PURE__ */ jsx4(
+    LexicalTypeaheadMenuPlugin,
+    {
+      onQueryChange: setQueryString,
+      onSelectOption,
+      triggerFn: checkForMentionMatch,
+      options,
+      menuRenderFn: (anchorElementRef, { selectedIndex, selectOptionAndCleanUp, setHighlightedIndex }) => anchorElementRef.current && results.length ? ReactDOM.createPortal(
+        /* @__PURE__ */ jsx4("div", { className: "typeahead-popover mentions-menu", children: /* @__PURE__ */ jsx4("ul", { children: options.map((option, i) => /* @__PURE__ */ jsx4(
+          MentionsTypeaheadMenuItem,
+          {
+            index: i,
+            isSelected: selectedIndex === i,
+            onClick: () => {
+              setHighlightedIndex(i);
+              selectOptionAndCleanUp(option);
+            },
+            onMouseEnter: () => {
+              setHighlightedIndex(i);
+            },
+            option
+          },
+          option.key
+        )) }) }),
+        anchorElementRef.current
+      ) : null
+    }
+  );
+}
+
+// src/plugins/TreeViewPlugin/index.tsx
+import { useLexicalComposerContext as useLexicalComposerContext4 } from "@lexical/react/LexicalComposerContext";
+import { TreeView } from "@lexical/react/LexicalTreeView";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function TreeViewPlugin() {
+  const [editor] = useLexicalComposerContext4();
+  return /* @__PURE__ */ jsx5(
+    TreeView,
+    {
+      viewClassName: "tree-view-output",
+      treeTypeButtonClassName: "debug-treetype-button",
+      timeTravelPanelClassName: "debug-timetravel-panel",
+      timeTravelButtonClassName: "debug-timetravel-button",
+      timeTravelPanelSliderClassName: "debug-timetravel-panel-slider",
+      timeTravelPanelButtonClassName: "debug-timetravel-panel-button",
+      editor
+    }
+  );
+}
+
+// src/nodes/ImageNode.tsx
+import { $insertGeneratedNodes } from "@lexical/clipboard";
+import { HashtagNode } from "@lexical/hashtag";
+import { $generateHtmlFromNodes, $generateNodesFromDOM } from "@lexical/html";
+import { LinkNode } from "@lexical/link";
+import {
+  $applyNodeReplacement as $applyNodeReplacement4,
+  $createRangeSelection,
+  $extendCaretToRange,
+  $getChildCaret,
+  $getEditor,
+  $getRoot,
+  $isElementNode,
+  $isParagraphNode,
+  $selectAll,
+  $setSelection,
+  createEditor,
+  DecoratorNode,
+  LineBreakNode,
+  ParagraphNode,
+  RootNode,
+  SKIP_DOM_SELECTION_TAG,
+  TextNode as TextNode5
+} from "lexical";
+import * as React2 from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ImageComponent = React2.lazy(() => import("./ImageComponent-TTUYUG3M.js"));
+function isGoogleDocCheckboxImg(img) {
+  return img.parentElement != null && img.parentElement.tagName === "LI" && img.previousSibling === null && img.getAttribute("aria-roledescription") === "checkbox";
+}
+function $convertImageElement(domNode) {
+  const img = domNode;
+  const src = img.getAttribute("src");
+  if (!src || src.startsWith("file:///") || isGoogleDocCheckboxImg(img)) {
+    return null;
+  }
+  const { alt: altText, width, height } = img;
+  const node = $createImageNode({ altText, height, src, width });
+  return { node };
+}
+function $isCaptionEditorEmpty() {
+  for (const { origin } of $extendCaretToRange(
+    $getChildCaret($getRoot(), "next")
+  )) {
+    if (!$isElementNode(origin)) {
+      return false;
+    }
+  }
+  return true;
+}
+var ImageNode = class _ImageNode extends DecoratorNode {
+  __src;
+  __altText;
+  __width;
+  __height;
+  __maxWidth;
+  __showCaption;
+  __caption;
+  // Captions cannot yet be used within editor cells
+  __captionsEnabled;
+  static getType() {
+    return "image";
+  }
+  static clone(node) {
+    return new _ImageNode(
+      node.__src,
+      node.__altText,
+      node.__maxWidth,
+      node.__width,
+      node.__height,
+      node.__showCaption,
+      node.__caption,
+      node.__captionsEnabled,
+      node.__key
+    );
+  }
+  static importJSON(serializedNode) {
+    const { altText, height, width, maxWidth, src, showCaption } = serializedNode;
+    return $createImageNode({
+      altText,
+      height,
+      maxWidth,
+      showCaption,
+      src,
+      width
+    }).updateFromJSON(serializedNode);
+  }
+  updateFromJSON(serializedNode) {
+    const node = super.updateFromJSON(serializedNode);
+    const { caption } = serializedNode;
+    const nestedEditor = node.__caption;
+    const editorState = nestedEditor.parseEditorState(caption.editorState);
+    if (!editorState.isEmpty()) {
+      nestedEditor.setEditorState(editorState);
+    }
+    return node;
+  }
+  exportDOM() {
+    const imgElement = document.createElement("img");
+    imgElement.setAttribute("src", this.__src);
+    imgElement.setAttribute("alt", this.__altText);
+    imgElement.setAttribute("width", this.__width.toString());
+    imgElement.setAttribute("height", this.__height.toString());
+    if (this.__showCaption && this.__caption) {
+      const captionEditor = this.__caption;
+      const captionHtml = captionEditor.read(() => {
+        if ($isCaptionEditorEmpty()) {
+          return null;
+        }
+        let selection = null;
+        const firstChild = $getRoot().getFirstChild();
+        if ($isParagraphNode(firstChild) && firstChild.getNextSibling() === null) {
+          selection = $createRangeSelection();
+          selection.anchor.set(firstChild.getKey(), 0, "element");
+          selection.focus.set(
+            firstChild.getKey(),
+            firstChild.getChildrenSize(),
+            "element"
+          );
+        }
+        return $generateHtmlFromNodes(captionEditor, selection);
+      });
+      if (captionHtml) {
+        const figureElement = document.createElement("figure");
+        const figcaptionElement = document.createElement("figcaption");
+        figcaptionElement.innerHTML = captionHtml;
+        figureElement.appendChild(imgElement);
+        figureElement.appendChild(figcaptionElement);
+        return { element: figureElement };
+      }
+    }
+    return { element: imgElement };
+  }
+  static importDOM() {
+    return {
+      figcaption: () => ({
+        conversion: () => ({ node: null }),
+        priority: 0
+      }),
+      figure: () => ({
+        conversion: (node) => {
+          return {
+            after: (childNodes) => {
+              const imageNodes = childNodes.filter($isImageNode);
+              const figcaption = node.querySelector("figcaption");
+              if (figcaption) {
+                for (const imgNode of imageNodes) {
+                  imgNode.setShowCaption(true);
+                  imgNode.__caption.update(
+                    () => {
+                      const editor = $getEditor();
+                      $insertGeneratedNodes(
+                        editor,
+                        $generateNodesFromDOM(editor, figcaption),
+                        $selectAll()
+                      );
+                      $setSelection(null);
+                    },
+                    { tag: SKIP_DOM_SELECTION_TAG }
+                  );
+                }
+              }
+              return imageNodes;
+            },
+            node: null
+          };
+        },
+        priority: 0
+      }),
+      img: () => ({
+        conversion: $convertImageElement,
+        priority: 0
+      })
+    };
+  }
+  constructor(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, key) {
+    super(key);
+    this.__src = src;
+    this.__altText = altText;
+    this.__maxWidth = maxWidth;
+    this.__width = width || "inherit";
+    this.__height = height || "inherit";
+    this.__showCaption = showCaption || false;
+    this.__caption = caption || createEditor({
+      namespace: "Playground/ImageNodeCaption",
+      nodes: [
+        RootNode,
+        TextNode5,
+        LineBreakNode,
+        ParagraphNode,
+        LinkNode,
+        EmojiNode,
+        HashtagNode,
+        KeywordNode
+      ]
+    });
+    this.__captionsEnabled = captionsEnabled || captionsEnabled === void 0;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      altText: this.getAltText(),
+      caption: this.__caption.toJSON(),
+      height: this.__height === "inherit" ? 0 : this.__height,
+      maxWidth: this.__maxWidth,
+      showCaption: this.__showCaption,
+      src: this.getSrc(),
+      width: this.__width === "inherit" ? 0 : this.__width
+    };
+  }
+  setWidthAndHeight(width, height) {
+    const writable = this.getWritable();
+    writable.__width = width;
+    writable.__height = height;
+  }
+  setShowCaption(showCaption) {
+    const writable = this.getWritable();
+    writable.__showCaption = showCaption;
+  }
+  // View
+  createDOM(config) {
+    const span = document.createElement("span");
+    const theme = config.theme;
+    const className = theme.image;
+    if (className !== void 0) {
+      span.className = className;
+    }
+    return span;
+  }
+  updateDOM() {
+    return false;
+  }
+  getSrc() {
+    return this.__src;
+  }
+  getAltText() {
+    return this.__altText;
+  }
+  decorate() {
+    return /* @__PURE__ */ jsx6(
+      ImageComponent,
+      {
+        src: this.__src,
+        altText: this.__altText,
+        width: this.__width,
+        height: this.__height,
+        maxWidth: this.__maxWidth,
+        nodeKey: this.getKey(),
+        showCaption: this.__showCaption,
+        caption: this.__caption,
+        captionsEnabled: this.__captionsEnabled,
+        resizable: true
+      }
+    );
+  }
+};
+function $createImageNode({
+  altText,
+  height,
+  maxWidth = 500,
+  captionsEnabled,
+  src,
+  width,
+  showCaption,
+  caption,
+  key
+}) {
+  return $applyNodeReplacement4(
+    new ImageNode(
+      src,
+      altText,
+      maxWidth,
+      width,
+      height,
+      showCaption,
+      caption,
+      captionsEnabled,
+      key
+    )
+  );
+}
+function $isImageNode(node) {
+  return node instanceof ImageNode;
+}
+
+export {
+  SettingsContext,
+  useSettings,
+  EmojiNode,
+  KeywordNode,
+  EmojisPlugin,
+  KeywordsPlugin,
+  sanitizeUrl,
+  LinkPlugin,
+  EditorConfigProvider,
+  useEditorConfig,
+  MentionNode,
+  NewMentionsPlugin,
+  TreeViewPlugin,
+  $isCaptionEditorEmpty,
+  ImageNode,
+  $createImageNode,
+  $isImageNode
+};
+//# sourceMappingURL=chunk-I43VQAHW.js.map