@crystallize/design-system 1.21.0 → 1.21.2

package/dist/rich-text-editor-BA5R66CS.mjs

@@ -0,0 +1,3227 @@
+import {
+  ActionMenu,
+  Button,
+  Dialog,
+  DropdownMenu,
+  Icon,
+  IconButton,
+  InputWithLabel
+} from "./chunk-PB47BT3T.mjs";
+import "./chunk-NIH5ZMPE.mjs";
+
+// src/rich-text-editor/rich-text-editor.tsx
+import { useEffect as useEffect11, useRef as useRef5, useState as useState10 } from "react";
+import { AutoFocusPlugin } from "@lexical/react/LexicalAutoFocusPlugin";
+import { ClearEditorPlugin } from "@lexical/react/LexicalClearEditorPlugin";
+import { LexicalComposer } from "@lexical/react/LexicalComposer";
+import LexicalErrorBoundary from "@lexical/react/LexicalErrorBoundary";
+import { HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
+import { HorizontalRulePlugin } from "@lexical/react/LexicalHorizontalRulePlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
+import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
+import { useLexicalComposerContext as useLexicalComposerContext12 } from "@lexical/react/LexicalComposerContext";
+import { ContentEditable } from "@lexical/react/LexicalContentEditable";
+
+// src/rich-text-editor/context/SharedHistoryContext.tsx
+import { createContext, useContext, useMemo } from "react";
+import { createEmptyHistoryState } from "@lexical/react/LexicalHistoryPlugin";
+import { jsx } from "react/jsx-runtime";
+var Context = createContext({});
+var SharedHistoryContext = ({ children }) => {
+  const historyContext = useMemo(() => ({ historyState: createEmptyHistoryState() }), []);
+  return /* @__PURE__ */ jsx(Context.Provider, {
+    value: historyContext,
+    children
+  });
+};
+var useSharedHistoryContext = () => {
+  return useContext(Context);
+};
+
+// src/rich-text-editor/i18n/index.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+
+// src/rich-text-editor/i18n/translations/en.ts
+var translations = {
+  actionClearTextFormatting: "Clear text formatting",
+  actionTextFormattingOptions: "Formatting options for additional text styles",
+  actionFormatAsStrongLabel: "Format text as bold",
+  actionFormatAsStrongTitle: "Bold (Ctrl+B)",
+  actionFormatAsStrongTitleApple: "Bold (\u2318B)",
+  actionFormatAsEmphasizedLabel: "Format text as italics",
+  actionFormatAsEmphasizedTitle: "Italic (Ctrl+I)",
+  actionFormatAsEmphasizedTitleApple: "Italic (\u2318I)",
+  actionFormatAsUnderlinedLabel: "Underline text",
+  actionFormatAsUnderlinedTitle: "Underlined (Ctrl+U)",
+  actionFormatAsUnderlinedTitleApple: "Underlined (\u2318U)",
+  actionFormatWithStrikethroughLabel: "Format text with a strikethrough",
+  actionFormatWithStrikethroughTitle: "Strikethrough",
+  actionFormatWithSubscriptLabel: "Format text as subscript",
+  actionFormatWithSubscriptTitle: "Subscript",
+  actionFormatWithSuperscriptLabel: "Format text as superscript",
+  actionFormatWithSuperscriptTitle: "Superscript",
+  actionFormatClear: "Clear formatting",
+  actionInsertCodeBlock: "Insert code block",
+  actionInsertlink: "Insert link",
+  actionCopyJSON: "Copy JSON",
+  actionCopyCode: "Copy code",
+  actionClear: "Clear editor",
+  actionFormatCode: "Format code with Prettier",
+  actionTableInsertRowsAbove: "Insert row above",
+  actionTableInsertRowsAbove_plural: "Insert {{rows}} rows above",
+  actionTableInsertRowsBelow: "Insert row below",
+  actionTableInsertRowsBelow_plural: "Insert {{rows}} rows below",
+  actionTableInsertColumnsBefore: "Insert column left",
+  actionTableInsertColumnsBefore_plural: "Insert {{columns}} columns left",
+  actionTableInsertColumnsAfter: "Insert column right",
+  actionTableInsertColumnsAfter_plural: "Insert {{columns}} columns right",
+  actionTableAddRowHeader: "Add row header",
+  actionTableRemoveRowHeader: "Remove row header",
+  actionTableAddColumnHeader: "Add column header",
+  actionTableRemoveColumnHeader: "Remove column header",
+  actionTableDeleteColumn: "Delete column",
+  actionTableDeleteRow: "Delete row",
+  actionTableDeleteTable: "Delete table",
+  actionTableOpenOptions: "Open table options",
+  actionUndoLabel: "Undo",
+  actionUndoTitle: "Undo (Ctrl+Z)",
+  actionUndoTitleApple: "Undo (\u2318Z)",
+  actionRedoLabel: "Undo",
+  actionRedoTitle: "Undo (Ctrl+Y)",
+  actionRedoTitleApple: "Redo (\u2318Y)",
+  codeSelectLanguage: "Select language",
+  linkEditorLink: "Link",
+  linkEditorRel: "Rel",
+  linkEditorTarget: "Target",
+  linkEditorCommit: "Done",
+  linkEditorEdit: "Edit",
+  linkPreviewReplaceTextWithTitle: "Replace link text with its title",
+  horizontalRule: "Horizontal rule",
+  table: "Table",
+  insertTableTitle: "Insert table",
+  insertTableDescription: "Define your starting point of a table, you can add and remove columns and rows after creation.",
+  insertTableRows: "Rows",
+  insertTableColumns: "Columns",
+  insertTableCommit: "Insert table"
+};
+var en_default = translations;
+
+// src/rich-text-editor/i18n/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var I18nContext = createContext2(null);
+function I18nProvider({
+  labelTranslations,
+  children
+}) {
+  const translations2 = labelTranslations || en_default;
+  return /* @__PURE__ */ jsx2(I18nContext.Provider, {
+    value: translations2,
+    children
+  });
+}
+function replaceI18nVariablesInString(str, replaceWith) {
+  return str.replace(/({{[^}]+}})/g, replaceWith);
+}
+function useTr() {
+  const context = useContext2(I18nContext);
+  return (key, units) => {
+    const thereAreUnits = typeof units === "number";
+    const keyToUse = thereAreUnits && units > 1 ? `${key}_plural` : key;
+    if (context && keyToUse in context) {
+      const tr = context[keyToUse];
+      if (thereAreUnits) {
+        return replaceI18nVariablesInString(tr, units.toString());
+      }
+      return tr;
+    }
+    return "";
+  };
+}
+
+// src/rich-text-editor/model/crystallize-to-lexical.ts
+import {
+  $createLineBreakNode,
+  $createParagraphNode,
+  $createTextNode,
+  $getRoot,
+  $isTextNode
+} from "lexical";
+import { $createCodeHighlightNode, $createCodeNode } from "@lexical/code";
+import { $createLinkNode } from "@lexical/link";
+import { $createListItemNode, $createListNode } from "@lexical/list";
+import { $createHorizontalRuleNode } from "@lexical/react/LexicalHorizontalRuleNode";
+import { $createHeadingNode, $createQuoteNode } from "@lexical/rich-text";
+import { $createTableCellNode, $createTableNode, $createTableRowNode } from "@lexical/table";
+
+// src/rich-text-editor/model/parse-initial-state.ts
+function parseInitialState({ richText }) {
+  let richTextArray = Array.isArray(richText) ? richText : [richText];
+  richTextArray = richTextArray.map((rootNode) => {
+    if (!rootNode.kind || rootNode.kind === "inline") {
+      return {
+        type: "paragraph",
+        kind: "block",
+        children: [rootNode]
+      };
+    }
+    return rootNode;
+  });
+  return richTextArray;
+}
+
+// src/rich-text-editor/model/crystallize-to-lexical.ts
+function composeInitialState({ richText }) {
+  return function setLexicalState() {
+    const root = $getRoot();
+    function handleNode({
+      crystallizeContentNode,
+      lexicalParent
+    }) {
+      const { textContent, kind, type, children, metadata } = crystallizeContentNode;
+      let lexicalNode = null;
+      let insertedTextContent = false;
+      const customTextFormat = getLexicalTextFormat(crystallizeContentNode);
+      if (customTextFormat) {
+        lexicalNode = $createTextNode(textContent).toggleFormat(customTextFormat);
+        insertedTextContent = true;
+      } else {
+        switch (type) {
+          case "heading1": {
+            lexicalNode = $createHeadingNode("h1");
+            break;
+          }
+          case "heading2": {
+            lexicalNode = $createHeadingNode("h2");
+            break;
+          }
+          case "heading3": {
+            lexicalNode = $createHeadingNode("h3");
+            break;
+          }
+          case "heading4": {
+            lexicalNode = $createHeadingNode("h4");
+            break;
+          }
+          case "heading5": {
+            lexicalNode = $createHeadingNode("h5");
+            break;
+          }
+          case "heading6": {
+            lexicalNode = $createHeadingNode("h6");
+            break;
+          }
+          case "paragraph": {
+            lexicalNode = $createParagraphNode();
+            break;
+          }
+          case "horizontal-line": {
+            lexicalNode = $createHorizontalRuleNode();
+            break;
+          }
+          case "code": {
+            const language = metadata && typeof metadata.language === "string" ? metadata.language : null;
+            lexicalNode = $createCodeNode(language);
+            lexicalNode.append($createCodeHighlightNode(textContent ?? ""));
+            insertedTextContent = true;
+            break;
+          }
+          case "ordered-list": {
+            lexicalNode = $createListNode("number");
+            break;
+          }
+          case "unordered-list": {
+            lexicalNode = $createListNode("bullet");
+            break;
+          }
+          case "list-item": {
+            lexicalNode = $createListItemNode();
+            break;
+          }
+          case "line-break": {
+            lexicalNode = $createLineBreakNode();
+            break;
+          }
+          case "link": {
+            const href = metadata && typeof metadata.href === "string" ? metadata.href : "";
+            const target = metadata && typeof metadata.target === "string" ? metadata.target : null;
+            const rel = metadata && typeof metadata.rel === "string" ? metadata.rel : null;
+            lexicalNode = $createLinkNode(href, {
+              target,
+              rel
+            });
+            break;
+          }
+          case "quote": {
+            lexicalNode = $createQuoteNode();
+            break;
+          }
+          case "table": {
+            lexicalNode = $createTableNode();
+            break;
+          }
+          case "table-row": {
+            lexicalNode = $createTableRowNode();
+            break;
+          }
+          case "table-cell":
+          case "table-head-cell": {
+            const colSpan = void 0;
+            lexicalNode = $createTableCellNode(
+              0,
+              colSpan
+            );
+            break;
+          }
+          case "preformatted": {
+            lexicalNode = lexicalParent;
+            if (children) {
+              children.forEach((n) => handleNode({ crystallizeContentNode: n, lexicalParent }));
+            }
+            return;
+          }
+        }
+        if (!insertedTextContent && typeof textContent === "string") {
+          const textNode = $createTextNode(textContent);
+          if (!lexicalNode && kind === "inline") {
+            lexicalNode = textNode;
+          } else if (lexicalNode) {
+            lexicalNode.append(textNode);
+          }
+        }
+      }
+      if (lexicalNode) {
+        if (Array.isArray(children)) {
+          if ($isTextNode(lexicalNode)) {
+            const handleInlineTextChild = (child) => {
+              if ($isTextNode(lexicalNode)) {
+                const textFormat = getLexicalTextFormat(child);
+                if (textFormat && !lexicalNode.hasFormat(textFormat)) {
+                  lexicalNode.toggleFormat(textFormat);
+                }
+                if (child.textContent) {
+                  lexicalNode.setTextContent(child.textContent);
+                }
+              }
+              if ("children" in child) {
+                child.children?.forEach(handleInlineTextChild);
+              }
+            };
+            children.forEach(handleInlineTextChild);
+          } else {
+            children.forEach((n) => handleNode({ crystallizeContentNode: n, lexicalParent: lexicalNode }));
+          }
+        }
+        lexicalParent.append(lexicalNode);
+      }
+    }
+    parseInitialState({ richText }).forEach(
+      (crystallizeContentNode) => handleNode({ crystallizeContentNode, lexicalParent: root })
+    );
+  };
+}
+function getLexicalTextFormat(node) {
+  switch (node.type) {
+    case "strong":
+      return "bold";
+    case "emphasized":
+      return "italic";
+    case "underlined":
+      return "underline";
+    case "subscripted":
+      return "subscript";
+    case "superscripted":
+      return "superscript";
+    case "deleted":
+      return "strikethrough";
+    case "code": {
+      if (node.kind === "inline") {
+        return "code";
+      }
+      break;
+    }
+  }
+  return null;
+}
+
+// src/rich-text-editor/model/lexical-to-crystallize.ts
+import {
+  $getRoot as $getRoot2,
+  $isElementNode,
+  $isLineBreakNode,
+  $isParagraphNode,
+  $isTextNode as $isTextNode2
+} from "lexical";
+import { $isCodeNode } from "@lexical/code";
+import { $isLinkNode } from "@lexical/link";
+import { $isListItemNode, $isListNode } from "@lexical/list";
+import { $isHorizontalRuleNode } from "@lexical/react/LexicalHorizontalRuleNode";
+import { $isHeadingNode, $isQuoteNode } from "@lexical/rich-text";
+import { $isTableCellNode, $isTableNode, $isTableRowNode } from "@lexical/table";
+var headingMapper = {
+  h1: "heading1",
+  h2: "heading2",
+  h3: "heading3",
+  h4: "heading4",
+  h5: "heading5",
+  h6: "heading6"
+};
+function lexicalToCrystallizeRichText({
+  editorState
+}) {
+  const crystallizeRichText = [];
+  editorState.read(() => {
+    handleNode($getRoot2(), crystallizeRichText);
+    function handleNode(lexicalNode, parentChildren) {
+      let crystallizeNode = null;
+      let innerContentsIsTakenCareOf = false;
+      if ($isParagraphNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "paragraph"
+        };
+      } else if ($isHeadingNode(lexicalNode)) {
+        const tag = lexicalNode.getTag();
+        crystallizeNode = {
+          kind: "block",
+          type: headingMapper[tag]
+        };
+      } else if ($isLinkNode(lexicalNode)) {
+        const href = lexicalNode.getURL();
+        const target = lexicalNode.getTarget();
+        const rel = lexicalNode.getRel();
+        crystallizeNode = {
+          kind: "inline",
+          type: "link",
+          metadata: {
+            href,
+            ...target && { target },
+            ...rel && { rel }
+          }
+        };
+      } else if ($isListNode(lexicalNode)) {
+        const listType = lexicalNode.getListType();
+        crystallizeNode = {
+          kind: "block",
+          type: listType === "number" ? "ordered-list" : "unordered-list"
+        };
+      } else if ($isListItemNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "list-item"
+        };
+      } else if ($isQuoteNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "quote"
+        };
+      } else if ($isLineBreakNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "inline",
+          type: "line-break"
+        };
+      } else if ($isCodeNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "preformatted",
+          children: [
+            {
+              type: "code",
+              kind: "block",
+              textContent: lexicalNode.getTextContent(),
+              metadata: {
+                language: lexicalNode.getLanguage()
+              }
+            }
+          ]
+        };
+        innerContentsIsTakenCareOf = true;
+      } else if ($isTableNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "table"
+        };
+      } else if ($isTableRowNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "block",
+          type: "table-row"
+        };
+      } else if ($isTableCellNode(lexicalNode)) {
+        crystallizeNode = {
+          kind: "inline",
+          type: lexicalNode.hasHeader() ? "table-head-cell" : "table-cell"
+        };
+      }
+      if (crystallizeNode) {
+        parentChildren.push(crystallizeNode);
+      }
+      if (!innerContentsIsTakenCareOf) {
+        let onlyChildIsPureTextContent = false;
+        const children = lexicalNode.getChildren();
+        if (children?.length > 0) {
+          let parentChildrenToUse = parentChildren;
+          if (crystallizeNode) {
+            if (children.length === 1 && parent) {
+              const [first] = children;
+              if ($isTextNode2(first)) {
+                const childTextNode = getTextChild(first);
+                if (!childTextNode.type) {
+                  crystallizeNode.textContent = childTextNode.textContent;
+                  onlyChildIsPureTextContent = true;
+                }
+              }
+            }
+            if (!onlyChildIsPureTextContent) {
+              crystallizeNode.children = [];
+              parentChildrenToUse = crystallizeNode.children;
+            }
+          }
+          if (!onlyChildIsPureTextContent) {
+            children.forEach((childNode) => {
+              if ($isElementNode(childNode)) {
+                handleNode(childNode, parentChildrenToUse);
+              } else if ($isHorizontalRuleNode(childNode)) {
+                parentChildrenToUse.push({ kind: "block", type: "horizontal-line" });
+              } else if ($isTextNode2(childNode)) {
+                parentChildrenToUse.push(getTextChild(childNode));
+              } else if ($isLineBreakNode(childNode)) {
+                parentChildrenToUse.push({ kind: "inline", type: "line-break" });
+              }
+            });
+          }
+        }
+      }
+    }
+  });
+  return crystallizeRichText;
+}
+var lexicalFormatToCrystallizeType = {
+  bold: "strong",
+  italic: "emphasized",
+  underline: "underlined",
+  strikethrough: "deleted",
+  subscript: "subscripted",
+  superscript: "superscripted",
+  highlight: "emphasized",
+  code: "code"
+};
+function getTextChild(n) {
+  let currentChild = {
+    kind: "inline"
+  };
+  let textChild = null;
+  function checkFormat(format) {
+    const type = lexicalFormatToCrystallizeType[format];
+    if (n.hasFormat(format) && type) {
+      if (!textChild) {
+        currentChild = textChild = {
+          kind: "inline",
+          type
+        };
+      } else {
+        currentChild.children = [
+          {
+            kind: "inline",
+            type
+          }
+        ];
+        currentChild = currentChild.children[0];
+      }
+    }
+  }
+  Object.keys(lexicalFormatToCrystallizeType).forEach(checkFormat);
+  if (!textChild) {
+    currentChild = textChild = {
+      kind: "inline"
+    };
+  }
+  currentChild.textContent = n.getTextContent();
+  return textChild;
+}
+
+// src/rich-text-editor/nodes/BaseNodes.ts
+import { LineBreakNode } from "lexical";
+import { CodeHighlightNode, CodeNode } from "@lexical/code";
+import { AutoLinkNode, LinkNode } from "@lexical/link";
+import { ListItemNode, ListNode } from "@lexical/list";
+import { MarkNode } from "@lexical/mark";
+import { OverflowNode } from "@lexical/overflow";
+import { HorizontalRuleNode } from "@lexical/react/LexicalHorizontalRuleNode";
+import { HeadingNode, QuoteNode } from "@lexical/rich-text";
+import { TableCellNode, TableNode, TableRowNode } from "@lexical/table";
+var BaseNodes = [
+  HeadingNode,
+  ListNode,
+  ListItemNode,
+  QuoteNode,
+  CodeNode,
+  TableNode,
+  TableCellNode,
+  TableRowNode,
+  CodeHighlightNode,
+  AutoLinkNode,
+  LinkNode,
+  OverflowNode,
+  HorizontalRuleNode,
+  MarkNode,
+  LineBreakNode
+];
+
+// src/rich-text-editor/plugins/AutoLinkPlugin/index.tsx
+import "react";
+import { AutoLinkPlugin } from "@lexical/react/LexicalAutoLinkPlugin";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var URL_MATCHER = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/;
+var EMAIL_MATCHER = /(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
+var MATCHERS = [
+  (text) => {
+    const match = URL_MATCHER.exec(text);
+    if (match === null) {
+      return null;
+    }
+    const fullMatch = match[0];
+    return {
+      index: match.index,
+      length: fullMatch.length,
+      text: fullMatch,
+      url: fullMatch.startsWith("http") ? fullMatch : `https://${fullMatch}`
+    };
+  },
+  (text) => {
+    const match = EMAIL_MATCHER.exec(text);
+    return match && {
+      index: match.index,
+      length: match[0].length,
+      text: match[0],
+      url: `mailto:${match[0]}`
+    };
+  }
+];
+function LexicalAutoLinkPlugin() {
+  return /* @__PURE__ */ jsx3(AutoLinkPlugin, {
+    matchers: MATCHERS
+  });
+}
+
+// src/rich-text-editor/plugins/CodeActionMenuPlugin/index.tsx
+import { useEffect, useRef, useState as useState3 } from "react";
+import { $getNearestNodeFromDOMNode as $getNearestNodeFromDOMNode3 } from "lexical";
+import { createPortal } from "react-dom";
+import { useDebouncedCallback as useDebouncedCallback2 } from "use-debounce";
+import { $isCodeNode as $isCodeNode4, CodeNode as CodeNode2, getLanguageFriendlyName, normalizeCodeLang } from "@lexical/code";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+
+// src/rich-text-editor/plugins/CodeActionMenuPlugin/components/CopyButton/index.tsx
+import "react";
+import { useState } from "react";
+import { $getNearestNodeFromDOMNode, $getSelection, $setSelection } from "lexical";
+import { useDebouncedCallback } from "use-debounce";
+import { $isCodeNode as $isCodeNode2 } from "@lexical/code";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function CopyButton({ editor, getCodeDOMNode }) {
+  const [isCopyCompleted, setCopyCompleted] = useState(false);
+  const tr = useTr();
+  const removeSuccessIcon = useDebouncedCallback(() => {
+    setCopyCompleted(false);
+  }, 1e3);
+  async function handleClick() {
+    const codeDOMNode = getCodeDOMNode();
+    if (!codeDOMNode) {
+      return;
+    }
+    let content = "";
+    editor.update(() => {
+      const codeNode = $getNearestNodeFromDOMNode(codeDOMNode);
+      if ($isCodeNode2(codeNode)) {
+        content = codeNode.getTextContent();
+      }
+      const selection = $getSelection();
+      $setSelection(selection);
+    });
+    try {
+      await navigator.clipboard.writeText(content);
+      setCopyCompleted(true);
+      removeSuccessIcon();
+    } catch (err) {
+      console.error("Failed to copy: ", err);
+    }
+  }
+  return /* @__PURE__ */ jsx4("button", {
+    className: "c-rte-code-button",
+    onClick: handleClick,
+    "aria-label": tr("actionCopyCode"),
+    children: isCopyCompleted ? /* @__PURE__ */ jsx4("i", {
+      className: "c-rte-code-button__icon c-rte-icon-success"
+    }) : /* @__PURE__ */ jsx4("i", {
+      className: "c-rte-code-button__icon c-rte-icon-copy"
+    })
+  });
+}
+
+// src/rich-text-editor/plugins/CodeActionMenuPlugin/components/PrettierButton/index.tsx
+import "react";
+import { useState as useState2 } from "react";
+import { $getNearestNodeFromDOMNode as $getNearestNodeFromDOMNode2 } from "lexical";
+import { $isCodeNode as $isCodeNode3 } from "@lexical/code";
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+var PRETTIER_PARSER_MODULES = {
+  css: () => import("./parser-postcss-AN2EJ77H.mjs"),
+  html: () => import("./parser-html-URMUOK6U.mjs"),
+  js: () => import("./parser-babel-B7AMC4UT.mjs")
+};
+async function loadPrettierParserByLang(lang) {
+  const dynamicImport = PRETTIER_PARSER_MODULES[lang];
+  return await dynamicImport();
+}
+async function loadPrettierFormat() {
+  const { format } = await import("./standalone-AR2ENVE7.mjs");
+  return format;
+}
+var PRETTIER_OPTIONS_BY_LANG = {
+  css: {
+    parser: "css"
+  },
+  html: {
+    parser: "html"
+  },
+  js: {
+    parser: "babel"
+  },
+  markdown: {
+    parser: "markdown"
+  }
+};
+var LANG_CAN_BE_PRETTIER = Object.keys(PRETTIER_OPTIONS_BY_LANG);
+function canBePrettier(lang) {
+  return LANG_CAN_BE_PRETTIER.includes(lang);
+}
+function getPrettierOptions(lang) {
+  const options = PRETTIER_OPTIONS_BY_LANG[lang];
+  if (!options) {
+    throw new Error(`CodeActionMenuPlugin: Prettier does not support this language: ${lang}`);
+  }
+  return options;
+}
+function PrettierButton({ lang, editor, getCodeDOMNode }) {
+  const [syntaxError, setSyntaxError] = useState2("");
+  const [tipsVisible, setTipsVisible] = useState2(false);
+  const tr = useTr();
+  async function handleClick() {
+    const codeDOMNode = getCodeDOMNode();
+    try {
+      const format = await loadPrettierFormat();
+      const options = getPrettierOptions(lang);
+      options.plugins = [await loadPrettierParserByLang(lang)];
+      if (!codeDOMNode) {
+        return;
+      }
+      editor.update(() => {
+        const codeNode = $getNearestNodeFromDOMNode2(codeDOMNode);
+        if ($isCodeNode3(codeNode)) {
+          const content = codeNode.getTextContent();
+          let parsed = "";
+          parsed = format(content, options);
+          parsed = parsed.replace(/[\r\n]+$/, "");
+          if (parsed !== "") {
+            const selection = codeNode.select(0);
+            selection.insertText(parsed);
+            setSyntaxError("");
+            setTipsVisible(false);
+          }
+        }
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        setSyntaxError(error.message);
+        setTipsVisible(true);
+      } else {
+        console.error("Unexpected error: ", error);
+      }
+    }
+  }
+  function handleMouseEnter() {
+    if (syntaxError !== "") {
+      setTipsVisible(true);
+    }
+  }
+  function handleMouseLeave() {
+    if (syntaxError !== "") {
+      setTipsVisible(false);
+    }
+  }
+  return /* @__PURE__ */ jsxs("div", {
+    className: "c-rte-prettier-wrapper",
+    children: [
+      /* @__PURE__ */ jsx5("button", {
+        className: "c-rte-code-button",
+        onClick: handleClick,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        "aria-label": tr("actionFormatCode"),
+        children: syntaxError ? /* @__PURE__ */ jsx5("i", {
+          className: "c-rte-code-button__icon c-rte-icon-prettier-error"
+        }) : /* @__PURE__ */ jsx5("i", {
+          className: "c-rte-code-button__icon c-rte-icon-prettier"
+        })
+      }),
+      tipsVisible ? /* @__PURE__ */ jsx5("pre", {
+        className: "c-rte-code-error-tips",
+        children: syntaxError
+      }) : null
+    ]
+  });
+}
+
+// src/rich-text-editor/plugins/CodeActionMenuPlugin/index.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var CODE_PADDING = 0;
+function CodeActionMenuContainer({ anchorElem }) {
+  const [editor] = useLexicalComposerContext();
+  const [lang, setLang] = useState3("");
+  const [isShown, setShown] = useState3(false);
+  const [shouldListenMouseMove, setShouldListenMouseMove] = useState3(true);
+  const [position, setPosition] = useState3({
+    right: "0",
+    top: "0"
+  });
+  const codeSetRef = useRef(/* @__PURE__ */ new Set());
+  const codeDOMNodeRef = useRef(null);
+  function getCodeDOMNode() {
+    return codeDOMNodeRef.current;
+  }
+  const debouncedOnMouseMove = useDebouncedCallback2((event) => {
+    const { codeDOMNode, isOutside } = getMouseInfo(event);
+    if (isOutside) {
+      setShown(false);
+      return;
+    }
+    if (!codeDOMNode) {
+      return;
+    }
+    codeDOMNodeRef.current = codeDOMNode;
+    let codeNode = null;
+    let _lang = "";
+    editor.update(() => {
+      const maybeCodeNode = $getNearestNodeFromDOMNode3(codeDOMNode);
+      if ($isCodeNode4(maybeCodeNode)) {
+        codeNode = maybeCodeNode;
+        _lang = codeNode.getLanguage() || "";
+      }
+    });
+    if (codeNode) {
+      const { y: editorElemY, right: editorElemRight } = anchorElem.getBoundingClientRect();
+      const { y, right } = codeDOMNode.getBoundingClientRect();
+      setLang(_lang);
+      setShown(true);
+      setPosition({
+        right: `${editorElemRight - right + CODE_PADDING}px`,
+        top: `${y - editorElemY}px`
+      });
+    }
+  }, 50);
+  useEffect(() => {
+    if (!shouldListenMouseMove) {
+      return;
+    }
+    document.addEventListener("mousemove", debouncedOnMouseMove);
+    return () => {
+      setShown(false);
+      debouncedOnMouseMove.cancel();
+      document.removeEventListener("mousemove", debouncedOnMouseMove);
+    };
+  }, [shouldListenMouseMove, debouncedOnMouseMove]);
+  editor.registerMutationListener(CodeNode2, (mutations) => {
+    editor.getEditorState().read(() => {
+      for (const [key, type] of mutations) {
+        switch (type) {
+          case "created":
+            codeSetRef.current.add(key);
+            setShouldListenMouseMove(codeSetRef.current.size > 0);
+            break;
+          case "destroyed":
+            codeSetRef.current.delete(key);
+            setShouldListenMouseMove(codeSetRef.current.size > 0);
+            break;
+          default:
+            break;
+        }
+      }
+    });
+  });
+  const normalizedLang = normalizeCodeLang(lang);
+  const codeFriendlyName = getLanguageFriendlyName(lang);
+  return /* @__PURE__ */ jsx6(Fragment, {
+    children: isShown ? /* @__PURE__ */ jsxs2("div", {
+      className: "c-rte-code-action-menu-container",
+      style: { ...position },
+      children: [
+        /* @__PURE__ */ jsx6("div", {
+          className: "c-rte-code-highlight-language",
+          children: codeFriendlyName
+        }),
+        /* @__PURE__ */ jsx6(CopyButton, {
+          editor,
+          getCodeDOMNode
+        }),
+        canBePrettier(normalizedLang) ? /* @__PURE__ */ jsx6(PrettierButton, {
+          editor,
+          getCodeDOMNode,
+          lang: normalizedLang
+        }) : null
+      ]
+    }) : null
+  });
+}
+function getMouseInfo(event) {
+  const target = event.target;
+  if (target && target instanceof HTMLElement) {
+    const codeDOMNode = target.closest("code.CrystallizeRTEditorTheme__code");
+    const isOutside = !(codeDOMNode || target.closest("div.c-rte-code-action-menu-container"));
+    return { codeDOMNode, isOutside };
+  } else {
+    return { codeDOMNode: null, isOutside: true };
+  }
+}
+function CodeActionMenuPlugin({
+  anchorElem = document.body
+}) {
+  return createPortal(/* @__PURE__ */ jsx6(CodeActionMenuContainer, {
+    anchorElem
+  }), anchorElem);
+}
+
+// src/rich-text-editor/plugins/CodeHighlightPlugin/index.ts
+import { useEffect as useEffect2 } from "react";
+import { registerCodeHighlighting } from "@lexical/code";
+import { useLexicalComposerContext as useLexicalComposerContext2 } from "@lexical/react/LexicalComposerContext";
+function CodeHighlightPlugin() {
+  const [editor] = useLexicalComposerContext2();
+  useEffect2(() => {
+    return registerCodeHighlighting(editor);
+  }, [editor]);
+  return null;
+}
+
+// src/rich-text-editor/plugins/FloatingLinkEditorPlugin/index.tsx
+import { useCallback, useEffect as useEffect4, useRef as useRef2, useState as useState5 } from "react";
+import "react";
+import {
+  $getSelection as $getSelection3,
+  $isRangeSelection,
+  COMMAND_PRIORITY_CRITICAL,
+  COMMAND_PRIORITY_HIGH,
+  COMMAND_PRIORITY_LOW,
+  KEY_ESCAPE_COMMAND,
+  SELECTION_CHANGE_COMMAND
+} from "lexical";
+import { createPortal as createPortal2 } from "react-dom";
+import { $isAutoLinkNode, $isLinkNode as $isLinkNode2, TOGGLE_LINK_COMMAND } from "@lexical/link";
+import { useLexicalComposerContext as useLexicalComposerContext4 } from "@lexical/react/LexicalComposerContext";
+import { $findMatchingParent, mergeRegister } from "@lexical/utils";
+
+// src/rich-text-editor/ui/LinkPreview.tsx
+import { Suspense, useEffect as useEffect3, useState as useState4 } from "react";
+import { $getSelection as $getSelection2, $isTextNode as $isTextNode3 } from "lexical";
+import { useLexicalComposerContext as useLexicalComposerContext3 } from "@lexical/react/LexicalComposerContext";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var PREVIEW_CACHE = {};
+var URL_MATCHER2 = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)/;
+function useSuspenseRequest(url) {
+  let cached = PREVIEW_CACHE[url];
+  if (!url.match(URL_MATCHER2)) {
+    return { preview: null };
+  }
+  if (!cached) {
+    cached = PREVIEW_CACHE[url] = fetch(`https://service-metatags.crystallize.workers.dev/?url=${encodeURI(url)}`).then((response) => response.json()).then((preview) => {
+      PREVIEW_CACHE[url] = { preview };
+      return preview;
+    }).catch(() => {
+      PREVIEW_CACHE[url] = { preview: null };
+    });
+  }
+  if (cached instanceof Promise) {
+    throw cached;
+  }
+  return cached;
+}
+function LinkPreviewContent({
+  url
+}) {
+  const [textContent, setTextContent] = useState4("");
+  const { preview } = useSuspenseRequest(url);
+  const [editor] = useLexicalComposerContext3();
+  const tr = useTr();
+  const hasPreview = preview !== null && preview.google?.title;
+  useEffect3(() => {
+    editor.update(() => {
+      const sel = $getSelection2();
+      const nodes = sel?.getNodes();
+      if (hasPreview && nodes?.length === 1) {
+        const [firstNode] = nodes;
+        if ($isTextNode3(firstNode)) {
+          setTextContent(firstNode.getTextContent());
+        }
+      }
+    });
+  }, [editor, preview]);
+  function useTitleForText() {
+    editor.update(() => {
+      const sel = $getSelection2();
+      const nodes = sel?.getNodes();
+      if (hasPreview && nodes?.length === 1) {
+        const [firstNode] = nodes;
+        if ($isTextNode3(firstNode)) {
+          firstNode.setTextContent(preview.google.title);
+          setTextContent(preview.google.title);
+        }
+      }
+    });
+  }
+  if (!hasPreview) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs3("div", {
+    className: "c-rte-link-preview",
+    children: [
+      preview.google.image && /* @__PURE__ */ jsx7("div", {
+        className: "c-rte-link-preview-image-wrapper",
+        children: /* @__PURE__ */ jsx7("img", {
+          src: preview.google.image,
+          alt: preview.google.title,
+          className: "c-rte-link-preview-image"
+        })
+      }),
+      preview.google.title && /* @__PURE__ */ jsx7("div", {
+        className: "c-rte-link-preview-title",
+        children: preview.google.title
+      }),
+      preview.google.description && /* @__PURE__ */ jsx7("div", {
+        className: "c-rte-link-preview-description",
+        children: preview.google.description
+      }),
+      textContent && textContent !== preview.google.title ? /* @__PURE__ */ jsx7(Button, {
+        className: "c-rte-link-preview__replace-text-btn",
+        onClick: useTitleForText,
+        children: tr("linkPreviewReplaceTextWithTitle")
+      }) : null
+    ]
+  });
+}
+function Glimmer(props) {
+  return /* @__PURE__ */ jsx7("div", {
+    className: "c-rte-link-preview-glimmer",
+    ...props,
+    style: {
+      animationDelay: String((props.index || 0) * 300),
+      ...props.style || {}
+    }
+  });
+}
+function LinkPreview({
+  url
+}) {
+  return /* @__PURE__ */ jsx7(Suspense, {
+    fallback: /* @__PURE__ */ jsxs3(Fragment2, {
+      children: [
+        /* @__PURE__ */ jsx7(Glimmer, {
+          style: { height: "80px" },
+          index: 0
+        }),
+        /* @__PURE__ */ jsx7(Glimmer, {
+          style: { width: "60%" },
+          index: 1
+        }),
+        /* @__PURE__ */ jsx7(Glimmer, {
+          style: { width: "80%" },
+          index: 2
+        })
+      ]
+    }),
+    children: /* @__PURE__ */ jsx7(LinkPreviewContent, {
+      url
+    })
+  });
+}
+
+// src/rich-text-editor/utils/getSelectedNode.ts
+import { $isAtNodeEnd } from "@lexical/selection";
+function getSelectedNode(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = selection.anchor.getNode();
+  const focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  const isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  } else {
+    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+  }
+}
+
+// src/rich-text-editor/utils/setFloatingElemPosition.ts
+var VERTICAL_GAP = 10;
+var HORIZONTAL_OFFSET = 5;
+function setFloatingElemPosition(targetRect, floatingElem, anchorElem, verticalGap = VERTICAL_GAP, horizontalOffset = HORIZONTAL_OFFSET) {
+  const scrollerElem = anchorElem.parentElement;
+  if (targetRect === null || !scrollerElem) {
+    floatingElem.style.opacity = "0";
+    floatingElem.style.transform = "translate(-10000px, -10000px)";
+    return;
+  }
+  const floatingElemRect = floatingElem.getBoundingClientRect();
+  const anchorElementRect = anchorElem.getBoundingClientRect();
+  const editorScrollerRect = scrollerElem.getBoundingClientRect();
+  let top = targetRect.top - floatingElemRect.height - verticalGap;
+  let left = targetRect.left - horizontalOffset;
+  if (top < editorScrollerRect.top) {
+    top += floatingElemRect.height + targetRect.height + verticalGap * 2;
+  }
+  if (left + floatingElemRect.width > editorScrollerRect.right) {
+    left = editorScrollerRect.right - floatingElemRect.width - horizontalOffset;
+  }
+  top -= anchorElementRect.top;
+  left -= anchorElementRect.left;
+  floatingElem.style.opacity = "1";
+  floatingElem.style.transform = `translate(${left}px, ${top}px)`;
+}
+
+// src/rich-text-editor/utils/url.ts
+function sanitizeUrl(url) {
+  const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^&:/?#]*(?:[/?#]|$))/gi;
+  const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;
+  url = String(url).trim();
+  if (url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN))
+    return url;
+  return "https://";
+}
+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/rich-text-editor/plugins/FloatingLinkEditorPlugin/index.tsx
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function FloatingLinkEditor({
+  editor,
+  isLink,
+  setIsLink,
+  anchorElem
+}) {
+  const editorRef = useRef2(null);
+  const inputRef = useRef2(null);
+  const [linkUrl, setLinkUrl] = useState5("");
+  const [rel, setRel] = useState5(null);
+  const [target, setTarget] = useState5(null);
+  const [isEditMode, setEditMode] = useState5(false);
+  const [lastSelection, setLastSelection] = useState5(null);
+  const tr = useTr();
+  const updateLinkEditor = useCallback(() => {
+    const selection = $getSelection3();
+    if ($isRangeSelection(selection)) {
+      const node = getSelectedNode(selection);
+      const parent2 = node.getParent();
+      if ($isLinkNode2(parent2)) {
+        setLinkUrl(parent2.getURL());
+        setRel(parent2.getRel());
+        setTarget(parent2.getTarget());
+      } else if ($isLinkNode2(node)) {
+        setLinkUrl(node.getURL());
+        setRel(node.getRel());
+        setRel(node.getTarget());
+      } else {
+        setLinkUrl("");
+        setRel(null);
+        setTarget(null);
+      }
+    }
+    const editorElem = editorRef.current;
+    const nativeSelection = window.getSelection();
+    const activeElement = document.activeElement;
+    if (editorElem === null) {
+      return;
+    }
+    const rootElement = editor.getRootElement();
+    if (selection !== null && nativeSelection !== null && rootElement !== null && rootElement.contains(nativeSelection.anchorNode) && editor.isEditable()) {
+      const domRange = nativeSelection.getRangeAt(0);
+      let rect;
+      if (nativeSelection.anchorNode === rootElement) {
+        let inner = rootElement;
+        while (inner.firstElementChild != null) {
+          inner = inner.firstElementChild;
+        }
+        rect = inner.getBoundingClientRect();
+      } else {
+        rect = domRange.getBoundingClientRect();
+      }
+      setFloatingElemPosition(rect, editorElem, anchorElem);
+      setLastSelection(selection);
+    } else if (!activeElement || activeElement.className !== "link-input") {
+      if (rootElement !== null) {
+        setFloatingElemPosition(null, editorElem, anchorElem);
+      }
+      setLastSelection(null);
+      setEditMode(false);
+      setLinkUrl("");
+    }
+    return true;
+  }, [anchorElem, editor]);
+  useEffect4(() => {
+    const scrollerElem = anchorElem.parentElement;
+    const update = () => {
+      editor.getEditorState().read(() => {
+        updateLinkEditor();
+      });
+    };
+    window.addEventListener("resize", update);
+    if (scrollerElem) {
+      scrollerElem.addEventListener("scroll", update);
+    }
+    return () => {
+      window.removeEventListener("resize", update);
+      if (scrollerElem) {
+        scrollerElem.removeEventListener("scroll", update);
+      }
+    };
+  }, [anchorElem.parentElement, editor, updateLinkEditor]);
+  useEffect4(() => {
+    return mergeRegister(
+      editor.registerUpdateListener(({ editorState }) => {
+        editorState.read(() => {
+          updateLinkEditor();
+        });
+      }),
+      editor.registerCommand(
+        SELECTION_CHANGE_COMMAND,
+        () => {
+          updateLinkEditor();
+          return true;
+        },
+        COMMAND_PRIORITY_LOW
+      ),
+      editor.registerCommand(
+        KEY_ESCAPE_COMMAND,
+        () => {
+          if (isLink) {
+            setIsLink(false);
+            return true;
+          }
+          return false;
+        },
+        COMMAND_PRIORITY_HIGH
+      )
+    );
+  }, [editor, updateLinkEditor, setIsLink, isLink]);
+  useEffect4(() => {
+    editor.getEditorState().read(() => {
+      updateLinkEditor();
+    });
+  }, [editor, updateLinkEditor]);
+  useEffect4(() => {
+    if (isEditMode && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [isEditMode]);
+  return /* @__PURE__ */ jsx8("div", {
+    ref: editorRef,
+    className: "c-rte-link-editor",
+    "data-testid": "rich-text-link-editor",
+    children: isEditMode ? /* @__PURE__ */ jsxs4("div", {
+      children: [
+        /* @__PURE__ */ jsx8("div", {
+          className: "c-rte-link-editor-input-group",
+          children: /* @__PURE__ */ jsx8(InputWithLabel, {
+            label: tr("linkEditorLink"),
+            type: "text",
+            value: linkUrl,
+            onChange: (e) => setLinkUrl(e.target.value)
+          })
+        }),
+        /* @__PURE__ */ jsx8("div", {
+          className: "c-rte-link-editor-input-group",
+          children: /* @__PURE__ */ jsx8(InputWithLabel, {
+            label: tr("linkEditorRel"),
+            type: "text",
+            value: rel ?? "",
+            onChange: (e) => setRel(e.target.value)
+          })
+        }),
+        /* @__PURE__ */ jsx8("div", {
+          className: "c-rte-link-editor-input-group",
+          children: /* @__PURE__ */ jsx8(InputWithLabel, {
+            label: tr("linkEditorTarget"),
+            type: "text",
+            value: target ?? "",
+            onChange: (e) => setTarget(e.target.value)
+          })
+        }),
+        /* @__PURE__ */ jsx8("div", {
+          className: "c-rte-link-editor-button-wrap",
+          children: /* @__PURE__ */ jsx8(Button, {
+            "data-testid": "link-editor-save-button",
+            onClick: () => {
+              if (lastSelection !== null) {
+                if (linkUrl !== "") {
+                  editor.dispatchCommand(TOGGLE_LINK_COMMAND, {
+                    url: sanitizeUrl(linkUrl),
+                    rel,
+                    target
+                  });
+                }
+                setEditMode(false);
+              }
+            },
+            children: tr("linkEditorCommit")
+          })
+        })
+      ]
+    }) : /* @__PURE__ */ jsxs4(Fragment3, {
+      children: [
+        /* @__PURE__ */ jsxs4("div", {
+          className: "c-rte-link-editor-link-input",
+          children: [
+            /* @__PURE__ */ jsxs4("div", {
+              className: "c-rte-link-editor-link-preview",
+              children: [
+                /* @__PURE__ */ jsx8("a", {
+                  href: linkUrl,
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  children: linkUrl
+                }),
+                rel || target ? /* @__PURE__ */ jsxs4("div", {
+                  className: "c-rte-link-editor-preview-attrs",
+                  children: [
+                    rel && /* @__PURE__ */ jsx8("div", {
+                      className: "c-rte-link-editor-preview-attr",
+                      children: rel
+                    }),
+                    target && /* @__PURE__ */ jsx8("div", {
+                      className: "c-rte-link-editor-preview-attr",
+                      children: target
+                    })
+                  ]
+                }) : null
+              ]
+            }),
+            /* @__PURE__ */ jsx8("div", {
+              children: /* @__PURE__ */ jsx8(IconButton, {
+                size: "sm",
+                tabIndex: 0,
+                onMouseDown: (event) => event.preventDefault(),
+                onClick: () => setEditMode(true),
+                "aria-label": tr("linkEditorEdit"),
+                "data-testid": "link-editor-edit",
+                children: /* @__PURE__ */ jsx8(Icon.Edit, {})
+              })
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsx8("div", {
+          children: /* @__PURE__ */ jsx8(LinkPreview, {
+            url: linkUrl
+          })
+        })
+      ]
+    })
+  });
+}
+function useFloatingLinkEditorToolbar(editor, anchorElem) {
+  const [activeEditor, setActiveEditor] = useState5(editor);
+  const [isLink, setIsLink] = useState5(false);
+  const updateToolbar = useCallback(() => {
+    const selection = $getSelection3();
+    if ($isRangeSelection(selection)) {
+      const node = getSelectedNode(selection);
+      const linkParent = $findMatchingParent(node, $isLinkNode2);
+      const autoLinkParent = $findMatchingParent(node, $isAutoLinkNode);
+      if (linkParent != null && autoLinkParent == null) {
+        setIsLink(true);
+      } else {
+        setIsLink(false);
+      }
+    }
+  }, []);
+  useEffect4(() => {
+    return editor.registerCommand(
+      SELECTION_CHANGE_COMMAND,
+      (_payload, newEditor) => {
+        updateToolbar();
+        setActiveEditor(newEditor);
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  }, [editor, updateToolbar]);
+  return isLink ? createPortal2(
+    /* @__PURE__ */ jsx8(FloatingLinkEditor, {
+      editor: activeEditor,
+      isLink,
+      anchorElem,
+      setIsLink
+    }),
+    anchorElem
+  ) : null;
+}
+function FloatingLinkEditorPlugin({
+  anchorElem = document.body
+}) {
+  const [editor] = useLexicalComposerContext4();
+  return useFloatingLinkEditorToolbar(editor, anchorElem);
+}
+
+// src/rich-text-editor/plugins/FloatingTextFormatToolbarPlugin/index.tsx
+import { useCallback as useCallback2, useEffect as useEffect5, useRef as useRef3, useState as useState6 } from "react";
+import "react";
+import {
+  $getSelection as $getSelection4,
+  $isRangeSelection as $isRangeSelection2,
+  $isTextNode as $isTextNode4,
+  COMMAND_PRIORITY_LOW as COMMAND_PRIORITY_LOW2,
+  FORMAT_TEXT_COMMAND,
+  SELECTION_CHANGE_COMMAND as SELECTION_CHANGE_COMMAND2
+} from "lexical";
+import { createPortal as createPortal3 } from "react-dom";
+import { $isCodeHighlightNode } from "@lexical/code";
+import { $isLinkNode as $isLinkNode3, TOGGLE_LINK_COMMAND as TOGGLE_LINK_COMMAND2 } from "@lexical/link";
+import { useLexicalComposerContext as useLexicalComposerContext5 } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister as mergeRegister2 } from "@lexical/utils";
+
+// src/rich-text-editor/utils/environment.ts
+var IS_APPLE = typeof navigator !== "undefined" && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+
+// src/rich-text-editor/utils/getDOMRangeRect.ts
+function getDOMRangeRect(nativeSelection, rootElement) {
+  const domRange = nativeSelection.getRangeAt(0);
+  let rect;
+  if (nativeSelection.anchorNode === rootElement) {
+    let inner = rootElement;
+    while (inner.firstElementChild != null) {
+      inner = inner.firstElementChild;
+    }
+    rect = inner.getBoundingClientRect();
+  } else {
+    if ("getBoundingClientRect" in domRange) {
+      rect = domRange.getBoundingClientRect();
+    } else {
+      return {
+        height: 0,
+        width: 0,
+        x: 0,
+        y: 0,
+        bottom: 0,
+        left: 0,
+        top: 0,
+        right: 0
+      };
+    }
+  }
+  return rect;
+}
+
+// src/rich-text-editor/plugins/FloatingTextFormatToolbarPlugin/index.tsx
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+function TextFormatFloatingToolbar({
+  editor,
+  anchorElem,
+  isLink,
+  isBold,
+  isItalic,
+  isUnderline,
+  isCode,
+  isStrikethrough,
+  isSubscript,
+  isSuperscript
+}) {
+  const popupCharStylesEditorRef = useRef3(null);
+  const tr = useTr();
+  const insertLink = useCallback2(() => {
+    if (!isLink) {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND2, "https://");
+    } else {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND2, null);
+    }
+  }, [editor, isLink]);
+  const updateTextFormatFloatingToolbar = useCallback2(() => {
+    const selection = $getSelection4();
+    const popupCharStylesEditorElem = popupCharStylesEditorRef.current;
+    const nativeSelection = window.getSelection();
+    if (popupCharStylesEditorElem === null) {
+      return;
+    }
+    const rootElement = editor.getRootElement();
+    if (selection !== null && nativeSelection !== null && !nativeSelection.isCollapsed && rootElement !== null && rootElement.contains(nativeSelection.anchorNode)) {
+      const rangeRect = getDOMRangeRect(nativeSelection, rootElement);
+      setFloatingElemPosition(rangeRect, popupCharStylesEditorElem, anchorElem);
+    }
+  }, [editor, anchorElem]);
+  useEffect5(() => {
+    const scrollerElem = anchorElem.parentElement;
+    const update = () => {
+      editor.getEditorState().read(() => {
+        updateTextFormatFloatingToolbar();
+      });
+    };
+    window.addEventListener("resize", update);
+    if (scrollerElem) {
+      scrollerElem.addEventListener("scroll", update);
+    }
+    return () => {
+      window.removeEventListener("resize", update);
+      if (scrollerElem) {
+        scrollerElem.removeEventListener("scroll", update);
+      }
+    };
+  }, [editor, updateTextFormatFloatingToolbar, anchorElem]);
+  useEffect5(() => {
+    editor.getEditorState().read(() => {
+      updateTextFormatFloatingToolbar();
+    });
+    return mergeRegister2(
+      editor.registerUpdateListener(({ editorState }) => {
+        editorState.read(() => {
+          updateTextFormatFloatingToolbar();
+        });
+      }),
+      editor.registerCommand(
+        SELECTION_CHANGE_COMMAND2,
+        () => {
+          updateTextFormatFloatingToolbar();
+          return false;
+        },
+        COMMAND_PRIORITY_LOW2
+      )
+    );
+  }, [editor, updateTextFormatFloatingToolbar]);
+  if (!editor.isEditable()) {
+    return /* @__PURE__ */ jsx9("span", {});
+  }
+  return /* @__PURE__ */ jsxs5("div", {
+    ref: popupCharStylesEditorRef,
+    className: "c-rte-floating-text-format-tb-plugin",
+    children: [
+      /* @__PURE__ */ jsx9(IconButton, {
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "bold");
+        },
+        style: { padding: 0, overflow: "hidden" },
+        title: tr(IS_APPLE ? "actionFormatAsStrongTitleApple" : "actionFormatAsStrongTitle"),
+        "aria-label": tr("actionFormatAsStrongLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-bold c-rte-floating-text-format-tb-plugin__format-icon ${isBold ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "italic");
+        },
+        title: tr("actionFormatAsEmphasizedTitle"),
+        "aria-label": tr("actionFormatAsEmphasizedLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-italic c-rte-floating-text-format-tb-plugin__format-icon ${isItalic ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "underline");
+        },
+        title: tr("actionFormatAsUnderlinedTitle"),
+        "aria-label": tr("actionFormatAsUnderlinedLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-underline c-rte-floating-text-format-tb-plugin__format-icon ${isUnderline ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "code");
+        },
+        "aria-label": tr("actionInsertCodeBlock"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-code c-rte-floating-text-format-tb-plugin__format-icon ${isCode ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: insertLink,
+        "aria-label": tr("actionInsertlink"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-link c-rte-floating-text-format-tb-plugin__format-icon ${isLink ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "strikethrough");
+        },
+        title: tr("actionFormatWithStrikethroughTitle"),
+        "aria-label": tr("actionFormatWithStrikethroughLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-strikethrough c-rte-floating-text-format-tb-plugin__format-icon ${isStrikethrough ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "subscript");
+        },
+        title: tr("actionFormatWithSubscriptTitle"),
+        "aria-label": tr("actionFormatWithSubscriptLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-subscript c-rte-floating-text-format-tb-plugin__format-icon ${isSubscript ? "selected" : ""}`
+        })
+      }),
+      /* @__PURE__ */ jsx9(IconButton, {
+        style: { padding: 0, overflow: "hidden" },
+        onClick: () => {
+          editor.dispatchCommand(FORMAT_TEXT_COMMAND, "superscript");
+        },
+        title: tr("actionFormatWithSuperscriptTitle"),
+        "aria-label": tr("actionFormatWithSuperscriptLabel"),
+        children: /* @__PURE__ */ jsx9("i", {
+          className: `c-rte-icon-superscript c-rte-floating-text-format-tb-plugin__format-icon ${isSuperscript ? "selected" : ""}`
+        })
+      })
+    ]
+  });
+}
+function useFloatingTextFormatToolbar(editor, anchorElem) {
+  const [isText, setIsText] = useState6(false);
+  const [isLink, setIsLink] = useState6(false);
+  const [isBold, setIsBold] = useState6(false);
+  const [isItalic, setIsItalic] = useState6(false);
+  const [isUnderline, setIsUnderline] = useState6(false);
+  const [isStrikethrough, setIsStrikethrough] = useState6(false);
+  const [isSubscript, setIsSubscript] = useState6(false);
+  const [isSuperscript, setIsSuperscript] = useState6(false);
+  const [isCode, setIsCode] = useState6(false);
+  const updatePopup = useCallback2(() => {
+    editor.getEditorState().read(() => {
+      if (editor.isComposing()) {
+        return;
+      }
+      const selection = $getSelection4();
+      const nativeSelection = window.getSelection();
+      const rootElement = editor.getRootElement();
+      if (nativeSelection !== null && (!$isRangeSelection2(selection) || rootElement === null || !rootElement.contains(nativeSelection.anchorNode))) {
+        setIsText(false);
+        return;
+      }
+      if (!$isRangeSelection2(selection)) {
+        return;
+      }
+      const node = getSelectedNode(selection);
+      setIsBold(selection.hasFormat("bold"));
+      setIsItalic(selection.hasFormat("italic"));
+      setIsUnderline(selection.hasFormat("underline"));
+      setIsStrikethrough(selection.hasFormat("strikethrough"));
+      setIsSubscript(selection.hasFormat("subscript"));
+      setIsSuperscript(selection.hasFormat("superscript"));
+      setIsCode(selection.hasFormat("code"));
+      const parent2 = node.getParent();
+      if ($isLinkNode3(parent2) || $isLinkNode3(node)) {
+        setIsLink(true);
+      } else {
+        setIsLink(false);
+      }
+      if (!$isCodeHighlightNode(selection.anchor.getNode()) && selection.getTextContent() !== "") {
+        setIsText($isTextNode4(node));
+      } else {
+        setIsText(false);
+      }
+    });
+  }, [editor]);
+  useEffect5(() => {
+    document.addEventListener("selectionchange", updatePopup);
+    return () => {
+      document.removeEventListener("selectionchange", updatePopup);
+    };
+  }, [updatePopup]);
+  useEffect5(() => {
+    return mergeRegister2(
+      editor.registerUpdateListener(() => {
+        updatePopup();
+      }),
+      editor.registerRootListener(() => {
+        if (editor.getRootElement() === null) {
+          setIsText(false);
+        }
+      })
+    );
+  }, [editor, updatePopup]);
+  if (!isText || isLink) {
+    return null;
+  }
+  return createPortal3(
+    /* @__PURE__ */ jsx9(TextFormatFloatingToolbar, {
+      editor,
+      anchorElem,
+      isLink,
+      isBold,
+      isItalic,
+      isStrikethrough,
+      isSubscript,
+      isSuperscript,
+      isUnderline,
+      isCode
+    }),
+    anchorElem
+  );
+}
+function FloatingTextFormatToolbarPlugin({
+  anchorElem = document.body
+}) {
+  const [editor] = useLexicalComposerContext5();
+  return useFloatingTextFormatToolbar(editor, anchorElem);
+}
+
+// src/rich-text-editor/plugins/LinkPlugin/index.tsx
+import "react";
+import { LinkPlugin as LexicalLinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function LinkPlugin() {
+  return /* @__PURE__ */ jsx10(LexicalLinkPlugin, {
+    validateUrl
+  });
+}
+
+// src/rich-text-editor/plugins/ListMaxIndentLevelPlugin/index.ts
+import { useEffect as useEffect6 } from "react";
+import {
+  $getSelection as $getSelection5,
+  $isElementNode as $isElementNode2,
+  $isRangeSelection as $isRangeSelection3,
+  COMMAND_PRIORITY_CRITICAL as COMMAND_PRIORITY_CRITICAL2,
+  INDENT_CONTENT_COMMAND
+} from "lexical";
+import { $getListDepth, $isListItemNode as $isListItemNode2, $isListNode as $isListNode2 } from "@lexical/list";
+import { useLexicalComposerContext as useLexicalComposerContext6 } from "@lexical/react/LexicalComposerContext";
+function getElementNodesInSelection(selection) {
+  const nodesInSelection = selection.getNodes();
+  if (nodesInSelection.length === 0) {
+    return /* @__PURE__ */ new Set([selection.anchor.getNode().getParentOrThrow(), selection.focus.getNode().getParentOrThrow()]);
+  }
+  return new Set(nodesInSelection.map((n) => $isElementNode2(n) ? n : n.getParentOrThrow()));
+}
+function isIndentPermitted(maxDepth) {
+  const selection = $getSelection5();
+  if (!$isRangeSelection3(selection)) {
+    return false;
+  }
+  const elementNodesInSelection = getElementNodesInSelection(selection);
+  let totalDepth = 0;
+  for (const elementNode of elementNodesInSelection) {
+    if ($isListNode2(elementNode)) {
+      totalDepth = Math.max($getListDepth(elementNode) + 1, totalDepth);
+    } else if ($isListItemNode2(elementNode)) {
+      const parent2 = elementNode.getParent();
+      if (!$isListNode2(parent2)) {
+        throw new Error("ListMaxIndentLevelPlugin: A ListItemNode must have a ListNode for a parent.");
+      }
+      totalDepth = Math.max($getListDepth(parent2) + 1, totalDepth);
+    }
+  }
+  return totalDepth <= maxDepth;
+}
+function ListMaxIndentLevelPlugin({ maxDepth }) {
+  const [editor] = useLexicalComposerContext6();
+  useEffect6(() => {
+    return editor.registerCommand(
+      INDENT_CONTENT_COMMAND,
+      () => !isIndentPermitted(maxDepth ?? 7),
+      COMMAND_PRIORITY_CRITICAL2
+    );
+  }, [editor, maxDepth]);
+  return null;
+}
+
+// src/rich-text-editor/plugins/MaxLengthPlugin/index.tsx
+import { useEffect as useEffect7 } from "react";
+import { $getSelection as $getSelection6, $isRangeSelection as $isRangeSelection4 } from "lexical";
+import { useLexicalComposerContext as useLexicalComposerContext7 } from "@lexical/react/LexicalComposerContext";
+import { trimTextContentFromAnchor } from "@lexical/selection";
+import { $restoreEditorState } from "@lexical/utils";
+
+// src/rich-text-editor/model/to-text.ts
+function trim(str) {
+  if (!str) {
+    return "";
+  }
+  return str.replace(/^(\r|\n)+/, "").replace(/(\r|\n)+$/, "");
+}
+function toText(model, options) {
+  function getTextFromNode(node) {
+    if (!node) {
+      return "";
+    }
+    let childrenText = "";
+    if (node.children) {
+      childrenText = node.children.reduce((acc, n) => acc + getTextFromNode(n), "");
+    }
+    let content = "";
+    content += node.textContent || childrenText || "";
+    if (node.kind === "block") {
+      content = `
+${content}
+`;
+    } else if (options?.keepLineBreaks && node.type === "line-break") {
+      content += "\n";
+    }
+    return content;
+  }
+  if (Array.isArray(model)) {
+    return model.map(getTextFromNode).join("").trimStart().trimEnd();
+  }
+  return trim(getTextFromNode(model));
+}
+
+// src/rich-text-editor/plugins/MaxLengthPlugin/index.tsx
+function MaxLengthPlugin({ maxLength }) {
+  const [editor] = useLexicalComposerContext7();
+  useEffect7(() => {
+    let lastRestoredEditorState = null;
+    return editor.registerUpdateListener(({ editorState, prevEditorState }) => {
+      editor.update(() => {
+        const selection = $getSelection6();
+        if (!$isRangeSelection4(selection) || !selection.isCollapsed()) {
+          return;
+        }
+        const prevTextContent = toText(lexicalToCrystallizeRichText({ editor, editorState: prevEditorState }));
+        const textContent = toText(lexicalToCrystallizeRichText({ editor, editorState }));
+        if (prevTextContent !== textContent) {
+          const textLength = textContent.length;
+          const delCount = textLength - maxLength;
+          const anchor = selection.anchor;
+          if (delCount > 0) {
+            if (prevTextContent.length === maxLength && lastRestoredEditorState !== prevEditorState) {
+              lastRestoredEditorState = prevEditorState;
+              $restoreEditorState(editor, prevEditorState);
+            } else {
+              trimTextContentFromAnchor(editor, anchor, delCount);
+            }
+          }
+        }
+      });
+    });
+  }, [editor, maxLength]);
+  return null;
+}
+
+// src/rich-text-editor/plugins/TabFocusPlugin/index.tsx
+import { useEffect as useEffect8 } from "react";
+import { $getSelection as $getSelection7, $isRangeSelection as $isRangeSelection5, $setSelection as $setSelection2, FOCUS_COMMAND } from "lexical";
+import { useLexicalComposerContext as useLexicalComposerContext8 } from "@lexical/react/LexicalComposerContext";
+var COMMAND_PRIORITY_LOW3 = 1;
+var TAB_TO_FOCUS_INTERVAL = 100;
+var lastTabKeyDownTimestamp = 0;
+var hasRegisteredKeyDownListener = false;
+function registerKeyTimeStampTracker() {
+  window.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.keyCode === 9) {
+        lastTabKeyDownTimestamp = event.timeStamp;
+      }
+    },
+    true
+  );
+}
+function TabFocusPlugin() {
+  const [editor] = useLexicalComposerContext8();
+  useEffect8(() => {
+    if (!hasRegisteredKeyDownListener) {
+      registerKeyTimeStampTracker();
+      hasRegisteredKeyDownListener = true;
+    }
+    return editor.registerCommand(
+      FOCUS_COMMAND,
+      (event) => {
+        const selection = $getSelection7();
+        if ($isRangeSelection5(selection)) {
+          if (lastTabKeyDownTimestamp + TAB_TO_FOCUS_INTERVAL > event.timeStamp) {
+            $setSelection2(selection.clone());
+          }
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_LOW3
+    );
+  }, [editor]);
+  return null;
+}
+
+// src/rich-text-editor/plugins/TableActionMenuPlugin/index.tsx
+import { useCallback as useCallback3, useEffect as useEffect9, useRef as useRef4, useState as useState7 } from "react";
+import { $getRoot as $getRoot3, $getSelection as $getSelection8, $isRangeSelection as $isRangeSelection6, DEPRECATED_$isGridSelection } from "lexical";
+import { createPortal as createPortal4 } from "react-dom";
+import { useLexicalComposerContext as useLexicalComposerContext9 } from "@lexical/react/LexicalComposerContext";
+import useLexicalEditable from "@lexical/react/useLexicalEditable";
+import {
+  $deleteTableColumn,
+  $getElementGridForTableNode,
+  $getTableCellNodeFromLexicalNode,
+  $getTableColumnIndexFromTableCellNode,
+  $getTableNodeFromLexicalNodeOrThrow,
+  $getTableRowIndexFromTableCellNode,
+  $insertTableColumn,
+  $insertTableRow,
+  $isTableCellNode as $isTableCellNode2,
+  $isTableNode as $isTableNode2,
+  $isTableRowNode as $isTableRowNode2,
+  $removeTableRowAtIndex,
+  getTableSelectionFromTableElement,
+  TableCellHeaderStates,
+  TableCellNode as TableCellNode2
+} from "@lexical/table";
+import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+function TableActionMenu({ tableCellNode: _tableCellNode, tableStats }) {
+  const [editor] = useLexicalComposerContext9();
+  const [tableCellNode, updateTableCellNode] = useState7(_tableCellNode);
+  const [selectionCounts, updateSelectionCounts] = useState7({
+    columns: 1,
+    rows: 1
+  });
+  const tr = useTr();
+  useEffect9(() => {
+    return editor.registerMutationListener(TableCellNode2, (nodeMutations) => {
+      const nodeUpdated = nodeMutations.get(tableCellNode.getKey()) === "updated";
+      if (nodeUpdated) {
+        editor.getEditorState().read(() => {
+          updateTableCellNode(tableCellNode.getLatest());
+        });
+      }
+    });
+  }, [editor, tableCellNode]);
+  useEffect9(() => {
+    editor.getEditorState().read(() => {
+      const selection = $getSelection8();
+      if (DEPRECATED_$isGridSelection(selection)) {
+        const selectionShape = selection.getShape();
+        updateSelectionCounts({
+          columns: selectionShape.toX - selectionShape.fromX + 1,
+          rows: selectionShape.toY - selectionShape.fromY + 1
+        });
+      }
+    });
+  }, [editor]);
+  const clearTableSelection = useCallback3(() => {
+    editor.update(() => {
+      if (tableCellNode.isAttached()) {
+        const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+        const tableElement = editor.getElementByKey(tableNode.getKey());
+        if (!tableElement) {
+          throw new Error("Expected to find tableElement in DOM");
+        }
+        const tableSelection = getTableSelectionFromTableElement(tableElement);
+        if (tableSelection !== null) {
+          tableSelection.clearHighlight();
+        }
+        tableNode.markDirty();
+        updateTableCellNode(tableCellNode.getLatest());
+      }
+      const rootNode = $getRoot3();
+      rootNode.selectStart();
+    });
+  }, [editor, tableCellNode]);
+  const insertTableRowAtSelection = useCallback3(
+    (shouldInsertAfter) => {
+      editor.update(() => {
+        const selection = $getSelection8();
+        const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+        let tableRowIndex;
+        if (DEPRECATED_$isGridSelection(selection)) {
+          const selectionShape = selection.getShape();
+          tableRowIndex = shouldInsertAfter ? selectionShape.toY : selectionShape.fromY;
+        } else {
+          tableRowIndex = $getTableRowIndexFromTableCellNode(tableCellNode);
+        }
+        const grid = $getElementGridForTableNode(editor, tableNode);
+        $insertTableRow(tableNode, tableRowIndex, shouldInsertAfter, selectionCounts.rows, grid);
+        clearTableSelection();
+      });
+    },
+    [editor, tableCellNode, selectionCounts.rows, clearTableSelection]
+  );
+  const insertTableColumnAtSelection = useCallback3(
+    (shouldInsertAfter) => {
+      editor.update(() => {
+        const selection = $getSelection8();
+        const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+        let tableColumnIndex;
+        if (DEPRECATED_$isGridSelection(selection)) {
+          const selectionShape = selection.getShape();
+          tableColumnIndex = shouldInsertAfter ? selectionShape.toX : selectionShape.fromX;
+        } else {
+          tableColumnIndex = $getTableColumnIndexFromTableCellNode(tableCellNode);
+        }
+        const grid = $getElementGridForTableNode(editor, tableNode);
+        $insertTableColumn(tableNode, tableColumnIndex, shouldInsertAfter, selectionCounts.columns, grid);
+        clearTableSelection();
+      });
+    },
+    [editor, tableCellNode, selectionCounts.columns, clearTableSelection]
+  );
+  const deleteTableRowAtSelection = useCallback3(() => {
+    editor.update(() => {
+      const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      const tableRowIndex = $getTableRowIndexFromTableCellNode(tableCellNode);
+      $removeTableRowAtIndex(tableNode, tableRowIndex);
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  const deleteTableAtSelection = useCallback3(() => {
+    editor.update(() => {
+      const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      tableNode.remove();
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  const deleteTableColumnAtSelection = useCallback3(() => {
+    editor.update(() => {
+      const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      const tableColumnIndex = $getTableColumnIndexFromTableCellNode(tableCellNode);
+      $deleteTableColumn(tableNode, tableColumnIndex);
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  const toggleTableRowIsHeader = useCallback3(() => {
+    editor.update(() => {
+      const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      const tableRowIndex = $getTableRowIndexFromTableCellNode(tableCellNode);
+      const tableRows = tableNode.getChildren();
+      if (tableRowIndex >= tableRows.length || tableRowIndex < 0) {
+        throw new Error("Expected table cell to be inside of table row.");
+      }
+      const tableRow = tableRows[tableRowIndex];
+      if (!$isTableRowNode2(tableRow)) {
+        throw new Error("Expected table row");
+      }
+      tableRow.getChildren().forEach((tableCell) => {
+        if (!$isTableCellNode2(tableCell)) {
+          throw new Error("Expected table cell");
+        }
+        tableCell.toggleHeaderStyle(TableCellHeaderStates.ROW);
+      });
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  const toggleTableColumnIsHeader = useCallback3(() => {
+    editor.update(() => {
+      const tableNode = $getTableNodeFromLexicalNodeOrThrow(tableCellNode);
+      const tableColumnIndex = $getTableColumnIndexFromTableCellNode(tableCellNode);
+      const tableRows = tableNode.getChildren();
+      for (let r = 0; r < tableRows.length; r++) {
+        const tableRow = tableRows[r];
+        if (!$isTableRowNode2(tableRow)) {
+          throw new Error("Expected table row");
+        }
+        const tableCells = tableRow.getChildren();
+        if (tableColumnIndex >= tableCells.length || tableColumnIndex < 0) {
+          throw new Error("Expected table cell to be inside of table row.");
+        }
+        const tableCell = tableCells[tableColumnIndex];
+        if (!$isTableCellNode2(tableCell)) {
+          throw new Error("Expected table cell");
+        }
+        tableCell.toggleHeaderStyle(TableCellHeaderStates.COLUMN);
+      }
+      clearTableSelection();
+    });
+  }, [editor, tableCellNode, clearTableSelection]);
+  return /* @__PURE__ */ jsxs6(Fragment4, {
+    children: [
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => insertTableRowAtSelection(false),
+        children: tr("actionTableInsertRowsAbove", selectionCounts.rows)
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => insertTableRowAtSelection(true),
+        children: tr("actionTableInsertRowsBelow", selectionCounts.rows)
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => insertTableColumnAtSelection(false),
+        children: tr("actionTableInsertColumnsBefore", selectionCounts.columns)
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => insertTableColumnAtSelection(true),
+        children: tr("actionTableInsertColumnsAfter", selectionCounts.columns)
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => toggleTableRowIsHeader(),
+        children: tr(
+          (tableCellNode.__headerState & TableCellHeaderStates.ROW) === TableCellHeaderStates.ROW ? "actionTableRemoveRowHeader" : "actionTableAddRowHeader"
+        )
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => toggleTableColumnIsHeader(),
+        children: tr(
+          (tableCellNode.__headerState & TableCellHeaderStates.COLUMN) === TableCellHeaderStates.COLUMN ? "actionTableRemoveColumnHeader" : "actionTableAddColumnHeader"
+        )
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Separator, {}),
+      tableStats.columns > 1 && /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => deleteTableColumnAtSelection(),
+        children: tr("actionTableDeleteColumn")
+      }),
+      tableStats.rows > 1 && /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => deleteTableRowAtSelection(),
+        children: tr("actionTableDeleteRow")
+      }),
+      /* @__PURE__ */ jsx11(DropdownMenu.Item, {
+        onSelect: () => deleteTableAtSelection(),
+        children: tr("actionTableDeleteTable")
+      })
+    ]
+  });
+}
+function TableCellActionMenuContainer({ anchorElem }) {
+  const [editor] = useLexicalComposerContext9();
+  const tr = useTr();
+  const menuButtonRef = useRef4(null);
+  const [isMenuOpen, setIsMenuOpen] = useState7(false);
+  const [tableCellNode, setTableMenuCellNode] = useState7(null);
+  const [tableStats, setTablestats] = useState7({ rows: 1, columns: 1 });
+  const moveMenu = useCallback3(() => {
+    if (isMenuOpen) {
+      return;
+    }
+    const menu = menuButtonRef.current;
+    const selection = $getSelection8();
+    const nativeSelection = window.getSelection();
+    const activeElement = document.activeElement;
+    if (selection == null || menu == null) {
+      setTableMenuCellNode(null);
+      return;
+    }
+    const rootElement = editor.getRootElement();
+    if ($isRangeSelection6(selection) && rootElement !== null && nativeSelection !== null && rootElement.contains(nativeSelection.anchorNode)) {
+      const tableCellNodeFromSelection = $getTableCellNodeFromLexicalNode(selection.anchor.getNode());
+      if (tableCellNodeFromSelection == null) {
+        setTableMenuCellNode(null);
+        return;
+      }
+      const tableCellParentNodeDOM = editor.getElementByKey(tableCellNodeFromSelection.getKey());
+      if (tableCellParentNodeDOM == null) {
+        setTableMenuCellNode(null);
+        return;
+      }
+      setTableMenuCellNode(tableCellNodeFromSelection);
+      let rows = 1;
+      let columns = 1;
+      const parentRowNode = tableCellNodeFromSelection.getParent();
+      if ($isTableRowNode2(parentRowNode)) {
+        const parentTableNode = parentRowNode.getParent();
+        if ($isTableNode2(parentTableNode)) {
+          rows = parentTableNode.getChildrenSize();
+          columns = parentRowNode.getChildrenSize();
+        }
+      }
+      setTablestats({
+        rows,
+        columns
+      });
+    } else if (!activeElement) {
+      setTableMenuCellNode(null);
+    }
+  }, [editor, isMenuOpen]);
+  useEffect9(() => {
+    return editor.registerUpdateListener(() => {
+      editor.getEditorState().read(() => {
+        moveMenu();
+      });
+    });
+  });
+  useEffect9(() => {
+    const menuButtonDOM = menuButtonRef.current;
+    if (menuButtonDOM != null && tableCellNode != null) {
+      const tableCellNodeDOM = editor.getElementByKey(tableCellNode.getKey());
+      if (tableCellNodeDOM != null) {
+        const tableCellRect = tableCellNodeDOM.getBoundingClientRect();
+        const menuRect = menuButtonDOM.getBoundingClientRect();
+        const anchorRect = anchorElem.getBoundingClientRect();
+        const top = tableCellRect.top - anchorRect.top + 4;
+        const left = tableCellRect.right - menuRect.width - 10 - anchorRect.left;
+        menuButtonDOM.style.opacity = "1";
+        menuButtonDOM.style.transform = `translate(${left}px, ${top}px)`;
+      } else {
+        menuButtonDOM.style.opacity = "0";
+        menuButtonDOM.style.transform = "translate(-10000px, -10000px)";
+      }
+    }
+  }, [menuButtonRef, tableCellNode, editor, anchorElem]);
+  return /* @__PURE__ */ jsx11("div", {
+    className: "c-rte-table-cell-action-button-container",
+    ref: menuButtonRef,
+    children: tableCellNode != null && /* @__PURE__ */ jsx11(DropdownMenu.Root, {
+      onOpenChange: (isOpen) => setIsMenuOpen(isOpen),
+      content: /* @__PURE__ */ jsx11(TableActionMenu, {
+        tableCellNode,
+        tableStats
+      }),
+      children: /* @__PURE__ */ jsx11(IconButton, {
+        size: "xs",
+        "aria-label": tr("actionTableOpenOptions"),
+        children: /* @__PURE__ */ jsx11(Icon.Arrow, {})
+      })
+    })
+  });
+}
+function TableActionMenuPlugin({
+  anchorElem = document.body
+}) {
+  const isEditable = useLexicalEditable();
+  return createPortal4(isEditable ? /* @__PURE__ */ jsx11(TableCellActionMenuContainer, {
+    anchorElem
+  }) : null, anchorElem);
+}
+
+// src/rich-text-editor/plugins/ToolbarPlugin/index.tsx
+import { useCallback as useCallback4, useEffect as useEffect10, useState as useState9 } from "react";
+import {
+  $createParagraphNode as $createParagraphNode2,
+  $getNodeByKey,
+  $getRoot as $getRoot4,
+  $getSelection as $getSelection9,
+  $isRangeSelection as $isRangeSelection7,
+  $isRootOrShadowRoot,
+  $isTextNode as $isTextNode5,
+  CAN_REDO_COMMAND,
+  CAN_UNDO_COMMAND,
+  COMMAND_PRIORITY_CRITICAL as COMMAND_PRIORITY_CRITICAL3,
+  DEPRECATED_$isGridSelection as DEPRECATED_$isGridSelection2,
+  FORMAT_TEXT_COMMAND as FORMAT_TEXT_COMMAND2,
+  REDO_COMMAND,
+  SELECTION_CHANGE_COMMAND as SELECTION_CHANGE_COMMAND3,
+  UNDO_COMMAND
+} from "lexical";
+import {
+  $createCodeNode as $createCodeNode2,
+  $isCodeNode as $isCodeNode5,
+  CODE_LANGUAGE_FRIENDLY_NAME_MAP,
+  CODE_LANGUAGE_MAP,
+  getLanguageFriendlyName as getLanguageFriendlyName2
+} from "@lexical/code";
+import { $isLinkNode as $isLinkNode4, TOGGLE_LINK_COMMAND as TOGGLE_LINK_COMMAND3 } from "@lexical/link";
+import {
+  $isListNode as $isListNode3,
+  INSERT_ORDERED_LIST_COMMAND,
+  INSERT_UNORDERED_LIST_COMMAND,
+  ListNode as ListNode2,
+  REMOVE_LIST_COMMAND
+} from "@lexical/list";
+import { useLexicalComposerContext as useLexicalComposerContext11 } from "@lexical/react/LexicalComposerContext";
+import { $isDecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";
+import { INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/react/LexicalHorizontalRuleNode";
+import { $createHeadingNode as $createHeadingNode2, $createQuoteNode as $createQuoteNode2, $isHeadingNode as $isHeadingNode2 } from "@lexical/rich-text";
+import { $selectAll, $setBlocksType } from "@lexical/selection";
+import {
+  $findMatchingParent as $findMatchingParent2,
+  $getNearestBlockElementAncestorOrThrow,
+  $getNearestNodeOfType,
+  mergeRegister as mergeRegister3
+} from "@lexical/utils";
+
+// src/rich-text-editor/plugins/ActionsPlugin/index.tsx
+import { CLEAR_EDITOR_COMMAND } from "lexical";
+import { useLexicalComposerContext as useLexicalComposerContext10 } from "@lexical/react/LexicalComposerContext";
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+async function copyJson(editor) {
+  const json = lexicalToCrystallizeRichText({ editor, editorState: editor.getEditorState() });
+  try {
+    await navigator.clipboard.writeText(JSON.stringify(json, null, 1));
+  } catch (error) {
+    console.warn("Copy failed", error);
+  }
+}
+function ActionsPlugin({ append, prepend, disabled }) {
+  const [editor] = useLexicalComposerContext10();
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs7(ActionMenu, {
+    children: [
+      !prepend ? null : prepend.map((actionItem) => /* @__PURE__ */ jsx12(ActionMenu.Item, {
+        onSelect: actionItem.action,
+        className: actionItem.type === "danger" ? "danger" : "",
+        disabled: actionItem.disabled,
+        children: actionItem.title
+      }, actionItem.title)),
+      /* @__PURE__ */ jsx12(ActionMenu.Item, {
+        onSelect: () => copyJson(editor),
+        children: tr("actionCopyJSON")
+      }),
+      /* @__PURE__ */ jsx12(ActionMenu.Item, {
+        disabled,
+        className: "danger",
+        onSelect: () => {
+          editor.dispatchCommand(CLEAR_EDITOR_COMMAND, void 0);
+          editor.focus();
+        },
+        children: tr("actionClear")
+      }),
+      !append ? null : append.map((actionItem) => /* @__PURE__ */ jsx12(ActionMenu.Item, {
+        onSelect: actionItem.action,
+        className: actionItem.type === "danger" ? "danger" : "",
+        disabled: actionItem.disabled,
+        children: actionItem.title
+      }, actionItem.title))
+    ]
+  });
+}
+
+// src/rich-text-editor/plugins/ToolbarPlugin/insert-table.tsx
+import { useState as useState8 } from "react";
+import { INSERT_TABLE_COMMAND } from "@lexical/table";
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+function InsertTableDialog({ activeEditor }) {
+  const [rows, setRows] = useState8("5");
+  const [columns, setColumns] = useState8("5");
+  const tr = useTr();
+  const onClick = () => {
+    if (parseInt(rows) < 1 || parseInt(columns) < 1) {
+      return;
+    }
+    activeEditor.dispatchCommand(INSERT_TABLE_COMMAND, {
+      columns,
+      rows,
+      includeHeaders: {
+        columns: false,
+        rows: false
+      }
+    });
+  };
+  return /* @__PURE__ */ jsxs8("div", {
+    className: "c-rte-insert-table",
+    children: [
+      /* @__PURE__ */ jsxs8("div", {
+        className: "c-rte-insert-table__dimensions",
+        children: [
+          /* @__PURE__ */ jsx13(InputWithLabel, {
+            label: tr("insertTableRows"),
+            value: rows,
+            placeholder: "0",
+            type: "text",
+            inputMode: "numeric",
+            onChange: (e) => setRows(e.target.value)
+          }),
+          /* @__PURE__ */ jsx13("span", {
+            className: "c-rte-insert-table__dimensions__separator"
+          }),
+          /* @__PURE__ */ jsx13(InputWithLabel, {
+            type: "text",
+            label: tr("insertTableColumns"),
+            placeholder: "0",
+            value: columns,
+            inputMode: "numeric",
+            onChange: (e) => setColumns(e.target.value)
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx13("div", {
+        className: "c-rte-insert-table__actions",
+        children: /* @__PURE__ */ jsx13(Button, {
+          as: Dialog.Close,
+          size: "sm",
+          intent: "action",
+          "aria-label": tr("insertTableCommit"),
+          onClick,
+          children: tr("insertTableCommit")
+        })
+      })
+    ]
+  });
+}
+
+// src/rich-text-editor/plugins/ToolbarPlugin/index.tsx
+import { Fragment as Fragment5, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+var headingTypeToBlockName = {
+  h1: "Heading 1",
+  h2: "Heading 2",
+  h3: "Heading 3",
+  h4: "Heading 4",
+  h5: "Heading 5",
+  h6: "Heading 6"
+};
+var headings = Object.keys(headingTypeToBlockName);
+var blockTypeToBlockName = {
+  ...headingTypeToBlockName,
+  bullet: "Bulleted List",
+  check: "Check List",
+  code: "Code Block",
+  number: "Numbered List",
+  paragraph: "Normal",
+  quote: "Quote"
+};
+function getCodeLanguageOptions() {
+  const options = [];
+  for (const [lang, friendlyName] of Object.entries(CODE_LANGUAGE_FRIENDLY_NAME_MAP)) {
+    options.push([lang, friendlyName]);
+  }
+  return options;
+}
+var CODE_LANGUAGE_OPTIONS = getCodeLanguageOptions();
+function dropDownActiveClass(active) {
+  if (active)
+    return "active dropdown-item-active";
+  else
+    return "";
+}
+function BlockFormatDropDown({
+  editor,
+  blockType,
+  disabled = false
+}) {
+  const formatParagraph = () => {
+    if (blockType !== "paragraph") {
+      editor.update(() => {
+        const selection = $getSelection9();
+        if ($isRangeSelection7(selection) || DEPRECATED_$isGridSelection2(selection))
+          $setBlocksType(selection, () => $createParagraphNode2());
+      });
+    }
+  };
+  const formatHeading = (headingSize) => {
+    if (blockType !== headingSize) {
+      editor.update(() => {
+        const selection = $getSelection9();
+        if ($isRangeSelection7(selection) || DEPRECATED_$isGridSelection2(selection)) {
+          $setBlocksType(selection, () => $createHeadingNode2(headingSize));
+        }
+      });
+    }
+  };
+  const formatBulletList = () => {
+    if (blockType !== "bullet") {
+      editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, void 0);
+    } else {
+      editor.dispatchCommand(REMOVE_LIST_COMMAND, void 0);
+    }
+  };
+  const formatNumberedList = () => {
+    if (blockType !== "number") {
+      editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, void 0);
+    } else {
+      editor.dispatchCommand(REMOVE_LIST_COMMAND, void 0);
+    }
+  };
+  const formatQuote = () => {
+    if (blockType !== "quote") {
+      editor.update(() => {
+        const selection = $getSelection9();
+        if ($isRangeSelection7(selection) || DEPRECATED_$isGridSelection2(selection)) {
+          $setBlocksType(selection, () => $createQuoteNode2());
+        } else {
+          $setBlocksType($getRoot4().select(), () => $createQuoteNode2());
+        }
+      });
+    }
+  };
+  const formatCode = () => {
+    if (blockType !== "code") {
+      editor.update(() => {
+        let selection = $getSelection9();
+        if ($isRangeSelection7(selection) || DEPRECATED_$isGridSelection2(selection)) {
+          if (selection.isCollapsed()) {
+            $setBlocksType(selection, () => $createCodeNode2());
+          } else {
+            const textContent = selection.getTextContent();
+            const codeNode = $createCodeNode2();
+            selection.insertNodes([codeNode]);
+            selection = $getSelection9();
+            if ($isRangeSelection7(selection))
+              selection.insertRawText(textContent);
+          }
+        } else {
+          $setBlocksType($getRoot4().select(), () => $createCodeNode2());
+        }
+      });
+    }
+  };
+  return /* @__PURE__ */ jsx14(DropdownMenu.Root, {
+    disabled,
+    style: { zIndex: 1 },
+    content: /* @__PURE__ */ jsxs9(Fragment5, {
+      children: [
+        /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: formatParagraph,
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-paragraph c-rte-toolbar__block-format__icon ${blockType === "paragraph" ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === "paragraph" ? "selected" : ""}`,
+              children: "Normal"
+            })
+          ]
+        }),
+        headings.map((headingSize) => /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: () => formatHeading(headingSize),
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-${headingSize} c-rte-toolbar__block-format__icon ${blockType === headingSize ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === headingSize ? "selected" : ""}`,
+              children: headingTypeToBlockName[headingSize]
+            })
+          ]
+        }, headingSize)),
+        /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: formatBulletList,
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-bullet-list c-rte-toolbar__block-format__icon ${blockType === "bullet" ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === "bullet" ? "selected" : ""}`,
+              children: "Bullet List"
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: formatNumberedList,
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-numbered-list c-rte-toolbar__block-format__icon ${blockType === "number" ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === "number" ? "selected" : ""}`,
+              children: "Numbered List"
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: formatQuote,
+          "data-testid": "toggle-block-format-quote",
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-quote c-rte-toolbar__block-format__icon ${blockType === "quote" ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === "quote" ? "selected" : ""}`,
+              children: "Quote"
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+          onClick: formatCode,
+          "data-testid": "toggle-block-format-code",
+          children: [
+            /* @__PURE__ */ jsx14("i", {
+              className: `icon c-rte-icon-code c-rte-toolbar__block-format__icon ${blockType === "code" ? "selected" : ""}`
+            }),
+            /* @__PURE__ */ jsx14("span", {
+              className: `c-rte-toolbar__block-format__text ${blockType === "code" ? "selected" : ""}`,
+              children: "Code block"
+            })
+          ]
+        })
+      ]
+    }),
+    children: /* @__PURE__ */ jsxs9(Button, {
+      style: { backgroundColor: "transparent", padding: "0 8px" },
+      "aria-label": "Formatting options for text style",
+      "data-testid": "toggle-block-format",
+      children: [
+        /* @__PURE__ */ jsx14("i", {
+          className: `c-rte-toolbar__toggle-icon c-rte-icon-${blockType}`
+        }),
+        /* @__PURE__ */ jsx14(Icon.Arrow, {})
+      ]
+    })
+  });
+}
+function Divider() {
+  return /* @__PURE__ */ jsx14("div", {
+    className: "c-rte-toolbar__divider"
+  });
+}
+function ToolbarPlugin({
+  actionsMenuPrepend,
+  actionsMenuAppend,
+  disabled
+}) {
+  const [editor] = useLexicalComposerContext11();
+  const [activeEditor, setActiveEditor] = useState9(editor);
+  const [blockType, setBlockType] = useState9("paragraph");
+  const [selectedElementKey, setSelectedElementKey] = useState9(null);
+  const [isLink, setIsLink] = useState9(false);
+  const [isBold, setIsBold] = useState9(false);
+  const [isItalic, setIsItalic] = useState9(false);
+  const [isUnderline, setIsUnderline] = useState9(false);
+  const [isStrikethrough, setIsStrikethrough] = useState9(false);
+  const [isSubscript, setIsSubscript] = useState9(false);
+  const [isSuperscript, setIsSuperscript] = useState9(false);
+  const [isCode, setIsCode] = useState9(false);
+  const [canUndo, setCanUndo] = useState9(false);
+  const [canRedo, setCanRedo] = useState9(false);
+  const tr = useTr();
+  const [codeLanguage, setCodeLanguage] = useState9("");
+  const [isEditable, setIsEditable] = useState9(() => editor.isEditable());
+  const updateToolbar = useCallback4(() => {
+    const selection = $getSelection9();
+    if ($isRangeSelection7(selection)) {
+      const anchorNode = selection.anchor.getNode();
+      let element = anchorNode.getKey() === "root" ? anchorNode : $findMatchingParent2(anchorNode, (e) => {
+        const parent3 = e.getParent();
+        return parent3 !== null && $isRootOrShadowRoot(parent3);
+      });
+      if (element === null) {
+        element = anchorNode.getTopLevelElementOrThrow();
+      }
+      const elementKey = element.getKey();
+      const elementDOM = activeEditor.getElementByKey(elementKey);
+      setIsBold(selection.hasFormat("bold"));
+      setIsItalic(selection.hasFormat("italic"));
+      setIsUnderline(selection.hasFormat("underline"));
+      setIsStrikethrough(selection.hasFormat("strikethrough"));
+      setIsSubscript(selection.hasFormat("subscript"));
+      setIsSuperscript(selection.hasFormat("superscript"));
+      setIsCode(selection.hasFormat("code"));
+      const node = getSelectedNode(selection);
+      const parent2 = node.getParent();
+      if ($isLinkNode4(parent2) || $isLinkNode4(node)) {
+        setIsLink(true);
+      } else {
+        setIsLink(false);
+      }
+      if (elementDOM !== null) {
+        setSelectedElementKey(elementKey);
+        if ($isListNode3(element)) {
+          const parentList = $getNearestNodeOfType(anchorNode, ListNode2);
+          const type = parentList ? parentList.getListType() : element.getListType();
+          setBlockType(type);
+        } else {
+          const type = $isHeadingNode2(element) ? element.getTag() : element.getType();
+          if (type in blockTypeToBlockName) {
+            setBlockType(type);
+          }
+          if ($isCodeNode5(element)) {
+            const language = element.getLanguage();
+            setCodeLanguage(language ? CODE_LANGUAGE_MAP[language] || language : "");
+            return;
+          }
+        }
+      }
+    }
+  }, [activeEditor]);
+  useEffect10(() => {
+    return editor.registerCommand(
+      SELECTION_CHANGE_COMMAND3,
+      (_payload, newEditor) => {
+        updateToolbar();
+        setActiveEditor(newEditor);
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL3
+    );
+  }, [editor, updateToolbar]);
+  useEffect10(() => {
+    return mergeRegister3(
+      editor.registerEditableListener((editable) => {
+        setIsEditable(editable);
+      }),
+      activeEditor.registerUpdateListener(({ editorState }) => {
+        editorState.read(() => {
+          updateToolbar();
+        });
+      }),
+      activeEditor.registerCommand(
+        CAN_UNDO_COMMAND,
+        (payload) => {
+          setCanUndo(payload);
+          return false;
+        },
+        COMMAND_PRIORITY_CRITICAL3
+      ),
+      activeEditor.registerCommand(
+        CAN_REDO_COMMAND,
+        (payload) => {
+          setCanRedo(payload);
+          return false;
+        },
+        COMMAND_PRIORITY_CRITICAL3
+      )
+    );
+  }, [activeEditor, editor, updateToolbar]);
+  const clearFormatting = useCallback4(() => {
+    activeEditor.update(() => {
+      const selection = $getSelection9();
+      if ($isRangeSelection7(selection)) {
+        $selectAll(selection);
+        selection.getNodes().forEach((node) => {
+          if ($isTextNode5(node)) {
+            node.setFormat(0);
+            node.setStyle("");
+            $getNearestBlockElementAncestorOrThrow(node).setFormat("");
+          }
+          if ($isDecoratorBlockNode(node)) {
+            node.setFormat("");
+          }
+        });
+      }
+    });
+  }, [activeEditor]);
+  const insertLink = useCallback4(() => {
+    if (!isLink) {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND3, sanitizeUrl("https://"));
+    } else {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND3, null);
+    }
+  }, [editor, isLink]);
+  const onCodeLanguageSelect = useCallback4(
+    (value) => {
+      activeEditor.update(() => {
+        if (selectedElementKey !== null) {
+          const node = $getNodeByKey(selectedElementKey);
+          if ($isCodeNode5(node)) {
+            node.setLanguage(value);
+          }
+        }
+      });
+    },
+    [activeEditor, selectedElementKey]
+  );
+  return /* @__PURE__ */ jsxs9("div", {
+    className: "c-rte-toolbar",
+    children: [
+      /* @__PURE__ */ jsxs9("div", {
+        className: "c-rte-toolbar__inner",
+        children: [
+          /* @__PURE__ */ jsx14(IconButton, {
+            disabled: !canUndo || !isEditable,
+            onClick: () => {
+              activeEditor.dispatchCommand(UNDO_COMMAND, void 0);
+            },
+            type: "button",
+            title: tr(IS_APPLE ? "actionUndoTitleApple" : "actionUndoTitle"),
+            "aria-label": tr("actionUndoLabel"),
+            "data-testid": "rich-text-undo-button",
+            children: /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-undo c-rte-toolbar__icon ${!canUndo ? "disabled" : ""}
+        `
+            })
+          }),
+          /* @__PURE__ */ jsx14(IconButton, {
+            disabled: !canRedo || !isEditable,
+            onClick: () => {
+              activeEditor.dispatchCommand(REDO_COMMAND, void 0);
+            },
+            type: "button",
+            title: tr(IS_APPLE ? "actionRedoTitleApple" : "actionRedoTitle"),
+            "aria-label": tr("actionRedoLabel"),
+            children: /* @__PURE__ */ jsx14("i", {
+              className: `c-rte-icon-redo c-rte-toolbar__icon ${!canRedo ? "disabled" : ""}`
+            })
+          }),
+          /* @__PURE__ */ jsx14(Divider, {}),
+          blockType in blockTypeToBlockName && activeEditor === editor && /* @__PURE__ */ jsxs9(Fragment5, {
+            children: [
+              /* @__PURE__ */ jsx14(BlockFormatDropDown, {
+                disabled: !isEditable,
+                blockType,
+                editor
+              }),
+              /* @__PURE__ */ jsx14(Divider, {})
+            ]
+          }),
+          blockType === "code" ? /* @__PURE__ */ jsx14(Fragment5, {
+            children: /* @__PURE__ */ jsx14(DropdownMenu.Root, {
+              disabled: !isEditable,
+              style: { zIndex: 1 },
+              content: /* @__PURE__ */ jsx14(Fragment5, {
+                children: CODE_LANGUAGE_OPTIONS.map(([value, name]) => {
+                  return /* @__PURE__ */ jsx14(DropdownMenu.Item, {
+                    className: `item ${dropDownActiveClass(value === codeLanguage)}`,
+                    onClick: () => onCodeLanguageSelect(value),
+                    children: /* @__PURE__ */ jsx14("span", {
+                      className: `c-rte-toolbar__code-lang__sel-item ${dropDownActiveClass(value === codeLanguage) ? "selected" : ""}`,
+                      children: name
+                    })
+                  }, value);
+                })
+              }),
+              children: /* @__PURE__ */ jsx14(Button, {
+                "aria-label": tr("codeSelectLanguage"),
+                append: /* @__PURE__ */ jsx14(Icon.Arrow, {}),
+                children: /* @__PURE__ */ jsx14("span", {
+                  className: "c-rte-toolbar__code-lang__button-text",
+                  children: getLanguageFriendlyName2(codeLanguage)
+                })
+              })
+            })
+          }) : /* @__PURE__ */ jsx14(Dialog, {
+            children: /* @__PURE__ */ jsxs9("div", {
+              className: "c-rte-toolbar__actions-rest",
+              children: [
+                /* @__PURE__ */ jsx14(IconButton, {
+                  disabled: !isEditable,
+                  className: `c-rte-toolbar__icon-btn ${isBold ? "selected" : ""}`,
+                  type: "button",
+                  title: tr(IS_APPLE ? "actionFormatAsStrongTitleApple" : "actionFormatAsStrongTitle"),
+                  "aria-label": tr("actionFormatAsStrongLabel"),
+                  "data-testid": "toggle-format-bold",
+                  onClick: () => {
+                    activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "bold");
+                  },
+                  children: /* @__PURE__ */ jsx14("i", {
+                    className: `c-rte-toolbar__icon-btn__icon c-rte-icon-bold`
+                  })
+                }),
+                /* @__PURE__ */ jsx14(IconButton, {
+                  className: `c-rte-toolbar__icon-btn ${isItalic ? "selected" : ""}`,
+                  disabled: !isEditable,
+                  onClick: () => {
+                    activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "italic");
+                  },
+                  type: "button",
+                  title: tr(IS_APPLE ? "actionFormatAsEmphasizedTitleApple" : "actionFormatAsEmphasizedTitle"),
+                  "aria-label": tr("actionFormatAsEmphasizedLabel"),
+                  "data-testid": "toggle-format-emphasized",
+                  children: /* @__PURE__ */ jsx14("i", {
+                    className: `c-rte-toolbar__icon-btn__icon c-rte-icon-italic`
+                  })
+                }),
+                /* @__PURE__ */ jsx14(IconButton, {
+                  className: `c-rte-toolbar__icon-btn ${isUnderline ? "selected" : ""}`,
+                  disabled: !isEditable,
+                  onClick: () => {
+                    activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "underline");
+                  },
+                  type: "button",
+                  title: tr(IS_APPLE ? "actionFormatAsUnderlinedTitleApple" : "actionFormatAsUnderlinedTitle"),
+                  "aria-label": tr("actionFormatAsUnderlinedLabel"),
+                  "data-testid": "toggle-format-underlined",
+                  children: /* @__PURE__ */ jsx14("i", {
+                    className: `c-rte-toolbar__icon-btn__icon c-rte-icon-underline`
+                  })
+                }),
+                /* @__PURE__ */ jsx14(IconButton, {
+                  className: `c-rte-toolbar__icon-btn ${isCode ? "selected" : ""}`,
+                  disabled: !isEditable,
+                  onClick: () => {
+                    activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "code");
+                  },
+                  type: "button",
+                  title: tr("actionInsertCodeBlock"),
+                  "aria-label": tr("actionInsertCodeBlock"),
+                  "data-testid": "toggle-format-code",
+                  children: /* @__PURE__ */ jsx14("i", {
+                    className: `c-rte-toolbar__icon-btn__icon c-rte-icon-code`
+                  })
+                }),
+                /* @__PURE__ */ jsx14(IconButton, {
+                  className: `c-rte-toolbar__icon-btn ${isLink ? "selected" : ""}`,
+                  disabled: !isEditable,
+                  onClick: insertLink,
+                  type: "button",
+                  "aria-label": tr("actionInsertlink"),
+                  title: tr("actionInsertlink"),
+                  children: /* @__PURE__ */ jsx14("i", {
+                    className: `c-rte-toolbar__icon-btn__icon c-rte-icon-link`
+                  })
+                }),
+                /* @__PURE__ */ jsx14(DropdownMenu.Root, {
+                  disabled: !isEditable,
+                  style: { zIndex: 1 },
+                  content: /* @__PURE__ */ jsxs9(Fragment5, {
+                    children: [
+                      /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+                        disabled: !isEditable,
+                        onClick: () => activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "strikethrough"),
+                        title: tr("actionFormatWithStrikethroughTitle"),
+                        "aria-label": tr("actionFormatWithStrikethroughLabel"),
+                        children: [
+                          /* @__PURE__ */ jsx14("i", {
+                            className: `c-rte-icon-strikethrough c-rte-toolbar__dd-item__icon ${isStrikethrough ? "selected" : ""}`
+                          }),
+                          /* @__PURE__ */ jsx14("span", {
+                            className: `c-rte-toolbar__dd-item__text ${isStrikethrough ? "selected" : ""}`,
+                            children: tr("actionFormatWithStrikethroughTitle")
+                          })
+                        ]
+                      }),
+                      /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+                        disabled: !isEditable,
+                        onClick: () => activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "subscript"),
+                        title: tr("actionFormatWithSubscriptTitle"),
+                        "aria-label": tr("actionFormatWithSubscriptLabel"),
+                        children: [
+                          /* @__PURE__ */ jsx14("i", {
+                            className: `c-rte-icon-subscript c-rte-toolbar__dd-item__icon ${isSubscript ? "selected" : ""}`
+                          }),
+                          /* @__PURE__ */ jsx14("span", {
+                            className: `c-rte-toolbar__dd-item__text ${isSubscript ? "selected" : ""}`,
+                            children: tr("actionFormatWithSubscriptTitle")
+                          })
+                        ]
+                      }),
+                      /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+                        disabled: !isEditable,
+                        onClick: () => activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND2, "superscript"),
+                        title: tr("actionFormatWithSuperscriptTitle"),
+                        "aria-label": tr("actionFormatWithSuperscriptLabel"),
+                        children: [
+                          /* @__PURE__ */ jsx14("i", {
+                            className: `c-rte-icon-superscript c-rte-toolbar__dd-item__icon ${isSuperscript ? "selected" : ""}`
+                          }),
+                          /* @__PURE__ */ jsx14("span", {
+                            className: `c-rte-toolbar__dd-item__text ${isSuperscript ? "selected" : ""}`,
+                            children: tr("actionFormatWithSuperscriptTitle")
+                          })
+                        ]
+                      }),
+                      /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+                        disabled: !isEditable,
+                        onClick: clearFormatting,
+                        className: "item",
+                        title: tr("actionClearTextFormatting"),
+                        "aria-label": tr("actionClearTextFormatting"),
+                        children: [
+                          /* @__PURE__ */ jsx14("i", {
+                            className: "c-rte-icon-clear c-rte-toolbar__dd-item__icon"
+                          }),
+                          /* @__PURE__ */ jsx14("span", {
+                            className: "c-rte-toolbar__dd-item__text--clear",
+                            children: tr("actionFormatClear")
+                          })
+                        ]
+                      })
+                    ]
+                  }),
+                  children: /* @__PURE__ */ jsxs9(Button, {
+                    style: { backgroundColor: "transparent", padding: "0 8px" },
+                    "aria-label": tr("actionTextFormattingOptions"),
+                    children: [
+                      /* @__PURE__ */ jsx14("i", {
+                        className: `c-rte-icon-dropdown-more c-rte-toolbar__toggle-icon`
+                      }),
+                      /* @__PURE__ */ jsx14(Icon.Arrow, {})
+                    ]
+                  })
+                }),
+                /* @__PURE__ */ jsx14(Divider, {}),
+                /* @__PURE__ */ jsx14(DropdownMenu.Root, {
+                  style: { zIndex: 1 },
+                  disabled: !isEditable,
+                  content: /* @__PURE__ */ jsxs9(Fragment5, {
+                    children: [
+                      /* @__PURE__ */ jsxs9(DropdownMenu.Item, {
+                        onClick: () => {
+                          activeEditor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, void 0);
+                        },
+                        children: [
+                          /* @__PURE__ */ jsx14("i", {
+                            className: "c-rte-toolbar__dd-item__icon c-rte-icon-horizontal-rule"
+                          }),
+                          /* @__PURE__ */ jsx14("span", {
+                            className: "c-rte-toolbar__dd-item__text",
+                            children: tr("horizontalRule")
+                          })
+                        ]
+                      }),
+                      /* @__PURE__ */ jsx14(DropdownMenu.Item, {
+                        children: /* @__PURE__ */ jsx14(Dialog.Trigger, {
+                          asChild: true,
+                          children: /* @__PURE__ */ jsxs9("div", {
+                            className: "c-rte-toolbar__dd-item--table",
+                            children: [
+                              /* @__PURE__ */ jsx14("i", {
+                                className: "c-rte-toolbar__dd-item__icon c-rte-icon-table"
+                              }),
+                              /* @__PURE__ */ jsx14("span", {
+                                className: "c-rte-toolbar__dd-item__text",
+                                children: tr("table")
+                              })
+                            ]
+                          })
+                        })
+                      })
+                    ]
+                  }),
+                  children: /* @__PURE__ */ jsx14(IconButton, {
+                    children: /* @__PURE__ */ jsx14("i", {
+                      className: "c-rte-icon-plus c-rte-toolbar__plus"
+                    })
+                  })
+                }),
+                /* @__PURE__ */ jsxs9(Dialog.Content, {
+                  children: [
+                    /* @__PURE__ */ jsx14(Dialog.Title, {
+                      children: tr("insertTableTitle")
+                    }),
+                    /* @__PURE__ */ jsx14(Dialog.Description, {
+                      children: tr("insertTableDescription")
+                    }),
+                    /* @__PURE__ */ jsx14(InsertTableDialog, {
+                      activeEditor
+                    })
+                  ]
+                })
+              ]
+            })
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx14(ActionsPlugin, {
+        disabled,
+        prepend: actionsMenuPrepend,
+        append: actionsMenuAppend
+      })
+    ]
+  });
+}
+
+// src/rich-text-editor/themes/CrystallizeRTEditorTheme.ts
+var theme = {
+  blockCursor: "CrystallizeRTEditorTheme__blockCursor",
+  characterLimit: "CrystallizeRTEditorTheme__characterLimit",
+  code: "CrystallizeRTEditorTheme__code",
+  codeHighlight: {
+    atrule: "CrystallizeRTEditorTheme__tokenAttr",
+    attr: "CrystallizeRTEditorTheme__tokenAttr",
+    boolean: "CrystallizeRTEditorTheme__tokenProperty",
+    builtin: "CrystallizeRTEditorTheme__tokenSelector",
+    cdata: "CrystallizeRTEditorTheme__tokenComment",
+    char: "CrystallizeRTEditorTheme__tokenSelector",
+    class: "CrystallizeRTEditorTheme__tokenFunction",
+    "class-name": "CrystallizeRTEditorTheme__tokenFunction",
+    comment: "CrystallizeRTEditorTheme__tokenComment",
+    constant: "CrystallizeRTEditorTheme__tokenProperty",
+    deleted: "CrystallizeRTEditorTheme__tokenProperty",
+    doctype: "CrystallizeRTEditorTheme__tokenComment",
+    entity: "CrystallizeRTEditorTheme__tokenOperator",
+    function: "CrystallizeRTEditorTheme__tokenFunction",
+    important: "CrystallizeRTEditorTheme__tokenVariable",
+    inserted: "CrystallizeRTEditorTheme__tokenSelector",
+    keyword: "CrystallizeRTEditorTheme__tokenAttr",
+    namespace: "CrystallizeRTEditorTheme__tokenVariable",
+    number: "CrystallizeRTEditorTheme__tokenProperty",
+    operator: "CrystallizeRTEditorTheme__tokenOperator",
+    prolog: "CrystallizeRTEditorTheme__tokenComment",
+    property: "CrystallizeRTEditorTheme__tokenProperty",
+    punctuation: "CrystallizeRTEditorTheme__tokenPunctuation",
+    regex: "CrystallizeRTEditorTheme__tokenVariable",
+    selector: "CrystallizeRTEditorTheme__tokenSelector",
+    string: "CrystallizeRTEditorTheme__tokenSelector",
+    symbol: "CrystallizeRTEditorTheme__tokenProperty",
+    tag: "CrystallizeRTEditorTheme__tokenProperty",
+    url: "CrystallizeRTEditorTheme__tokenOperator",
+    variable: "CrystallizeRTEditorTheme__tokenVariable"
+  },
+  embedBlock: {
+    base: "CrystallizeRTEditorTheme__embedBlock",
+    focus: "CrystallizeRTEditorTheme__embedBlockFocus"
+  },
+  hashtag: "CrystallizeRTEditorTheme__hashtag",
+  heading: {
+    h1: "CrystallizeRTEditorTheme__h1",
+    h2: "CrystallizeRTEditorTheme__h2",
+    h3: "CrystallizeRTEditorTheme__h3",
+    h4: "CrystallizeRTEditorTheme__h4",
+    h5: "CrystallizeRTEditorTheme__h5",
+    h6: "CrystallizeRTEditorTheme__h6"
+  },
+  image: "",
+  indent: "CrystallizeRTEditorTheme__indent",
+  link: "CrystallizeRTEditorTheme__link",
+  list: {
+    listitem: "CrystallizeRTEditorTheme__listItem",
+    listitemChecked: "CrystallizeRTEditorTheme__listItemChecked",
+    listitemUnchecked: "CrystallizeRTEditorTheme__listItemUnchecked",
+    nested: {
+      listitem: "CrystallizeRTEditorTheme__nestedListItem"
+    },
+    olDepth: [
+      "CrystallizeRTEditorTheme__ol1",
+      "CrystallizeRTEditorTheme__ol2",
+      "CrystallizeRTEditorTheme__ol3",
+      "CrystallizeRTEditorTheme__ol4",
+      "CrystallizeRTEditorTheme__ol5"
+    ],
+    ul: "CrystallizeRTEditorTheme__ul"
+  },
+  ltr: "CrystallizeRTEditorTheme__ltr",
+  mark: "CrystallizeRTEditorTheme__mark",
+  markOverlap: "CrystallizeRTEditorTheme__markOverlap",
+  paragraph: "CrystallizeRTEditorTheme__paragraph",
+  quote: "CrystallizeRTEditorTheme__quote",
+  rtl: "CrystallizeRTEditorTheme__rtl",
+  table: "CrystallizeRTEditorTheme__table",
+  tableAddColumns: "CrystallizeRTEditorTheme__tableAddColumns",
+  tableAddRows: "CrystallizeRTEditorTheme__tableAddRows",
+  tableCell: "CrystallizeRTEditorTheme__tableCell",
+  tableCellActionButton: "CrystallizeRTEditorTheme__tableCellActionButton",
+  tableCellActionButtonContainer: "CrystallizeRTEditorTheme__tableCellActionButtonContainer",
+  tableCellEditing: "CrystallizeRTEditorTheme__tableCellEditing",
+  tableCellHeader: "CrystallizeRTEditorTheme__tableCellHeader",
+  tableCellPrimarySelected: "CrystallizeRTEditorTheme__tableCellPrimarySelected",
+  tableCellResizer: "CrystallizeRTEditorTheme__tableCellResizer",
+  tableCellSelected: "CrystallizeRTEditorTheme__tableCellSelected",
+  tableCellSortedIndicator: "CrystallizeRTEditorTheme__tableCellSortedIndicator",
+  tableResizeRuler: "CrystallizeRTEditorTheme__tableCellResizeRuler",
+  tableSelected: "CrystallizeRTEditorTheme__tableSelected",
+  text: {
+    bold: "CrystallizeRTEditorTheme__textBold",
+    code: "CrystallizeRTEditorTheme__textCode",
+    italic: "CrystallizeRTEditorTheme__textItalic",
+    strikethrough: "CrystallizeRTEditorTheme__textStrikethrough",
+    subscript: "CrystallizeRTEditorTheme__textSubscript",
+    superscript: "CrystallizeRTEditorTheme__textSuperscript",
+    underline: "CrystallizeRTEditorTheme__textUnderline",
+    underlineStrikethrough: "CrystallizeRTEditorTheme__textUnderlineStrikethrough"
+  }
+};
+var CrystallizeRTEditorTheme_default = theme;
+
+// src/rich-text-editor/rich-text-editor.tsx
+import { Fragment as Fragment6, jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
+function RichTextEditor({
+  initialData,
+  language = "en",
+  labelTranslations,
+  ...rest
+}) {
+  return /* @__PURE__ */ jsx15(LexicalComposer, {
+    initialConfig: {
+      editable: !rest.disabled,
+      namespace: "crystallize-rich-text-editor",
+      nodes: [...BaseNodes],
+      theme: CrystallizeRTEditorTheme_default,
+      editorState: initialData ? composeInitialState({ richText: initialData }) : void 0,
+      onError: (error) => {
+        throw error;
+      }
+    },
+    children: /* @__PURE__ */ jsx15(I18nProvider, {
+      language,
+      labelTranslations,
+      children: /* @__PURE__ */ jsx15(SharedHistoryContext, {
+        children: /* @__PURE__ */ jsx15("div", {
+          className: "c-rich-text-editor",
+          children: /* @__PURE__ */ jsx15(RichTextEditorWithoutContext, {
+            ...rest
+          })
+        })
+      })
+    })
+  });
+}
+function RichTextEditorWithoutContext({
+  placeholder: placeholderText,
+  onChange,
+  triggerOnChangeOnAutoFocus,
+  autoFocus,
+  actionsMenuPrepend,
+  actionsMenuAppend,
+  slotPreContent,
+  maxLength,
+  disabled,
+  id
+}) {
+  const editable = !disabled;
+  const { historyState } = useSharedHistoryContext();
+  const placeholder = /* @__PURE__ */ jsx15("div", {
+    className: "c-rte-placeholder",
+    children: placeholderText ?? ""
+  });
+  const [editor] = useLexicalComposerContext12();
+  const [floatingAnchorElem, setFloatingAnchorElem] = useState10(null);
+  const firstOnChangeTriggeredRef = useRef5(!autoFocus);
+  const onRef = (_floatingAnchorElem) => {
+    if (_floatingAnchorElem !== null) {
+      setFloatingAnchorElem(_floatingAnchorElem);
+    }
+  };
+  useEffect11(() => {
+    editor.setEditable(editable || false);
+  }, [editable, editor]);
+  function onLocalChange(editorState) {
+    if (onChange) {
+      if (triggerOnChangeOnAutoFocus || firstOnChangeTriggeredRef.current) {
+        onChange(lexicalToCrystallizeRichText({ editor, editorState }));
+      }
+    }
+    firstOnChangeTriggeredRef.current = true;
+  }
+  return /* @__PURE__ */ jsxs10(Fragment6, {
+    children: [
+      /* @__PURE__ */ jsx15(OnChangePlugin, {
+        onChange: onLocalChange,
+        ignoreSelectionChange: true
+      }),
+      /* @__PURE__ */ jsx15(ToolbarPlugin, {
+        disabled,
+        actionsMenuPrepend,
+        actionsMenuAppend
+      }),
+      slotPreContent,
+      /* @__PURE__ */ jsxs10("div", {
+        className: `c-rte-editor-container ${disabled ? "disabled" : ""}`,
+        children: [
+          maxLength != null ? /* @__PURE__ */ jsx15(MaxLengthPlugin, {
+            maxLength
+          }) : null,
+          !autoFocus ? null : /* @__PURE__ */ jsx15(AutoFocusPlugin, {}),
+          /* @__PURE__ */ jsx15(ClearEditorPlugin, {}),
+          /* @__PURE__ */ jsx15(LexicalAutoLinkPlugin, {}),
+          /* @__PURE__ */ jsx15(HistoryPlugin, {
+            externalHistoryState: historyState
+          }),
+          /* @__PURE__ */ jsx15(RichTextPlugin, {
+            contentEditable: /* @__PURE__ */ jsx15("div", {
+              className: "c-rte-editor-scroller",
+              children: /* @__PURE__ */ jsx15("div", {
+                className: "c-rte-editor",
+                ref: onRef,
+                children: /* @__PURE__ */ jsx15(ContentEditable, {
+                  className: "c-rte-contenteditable-root",
+                  id
+                })
+              })
+            }),
+            placeholder,
+            ErrorBoundary: LexicalErrorBoundary
+          }),
+          /* @__PURE__ */ jsx15(CodeHighlightPlugin, {}),
+          /* @__PURE__ */ jsx15(ListPlugin, {}),
+          /* @__PURE__ */ jsx15(ListMaxIndentLevelPlugin, {
+            maxDepth: 7
+          }),
+          /* @__PURE__ */ jsx15(TablePlugin, {}),
+          /* @__PURE__ */ jsx15(LinkPlugin, {}),
+          /* @__PURE__ */ jsx15(HorizontalRulePlugin, {}),
+          /* @__PURE__ */ jsx15(TabFocusPlugin, {}),
+          /* @__PURE__ */ jsx15(TabIndentationPlugin, {}),
+          floatingAnchorElem && /* @__PURE__ */ jsxs10(Fragment6, {
+            children: [
+              /* @__PURE__ */ jsx15(CodeActionMenuPlugin, {
+                anchorElem: floatingAnchorElem
+              }),
+              /* @__PURE__ */ jsx15(FloatingLinkEditorPlugin, {
+                anchorElem: floatingAnchorElem
+              }),
+              /* @__PURE__ */ jsx15(TableActionMenuPlugin, {
+                anchorElem: floatingAnchorElem
+              }),
+              /* @__PURE__ */ jsx15(FloatingTextFormatToolbarPlugin, {
+                anchorElem: floatingAnchorElem
+              })
+            ]
+          })
+        ]
+      })
+    ]
+  });
+}
+var rich_text_editor_default = RichTextEditor;
+export {
+  RichTextEditor,
+  rich_text_editor_default as default
+};